drivers/pci/controller/pcie-rcar-ep.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PCIe endpoint driver for Renesas R-Car SoCs
   4  *  Copyright (c) 2020 Renesas Electronics Europe GmbH
   5  *
   6  * Author: Lad Prabhakar <prabhakar.mahadev-lad.rj@bp.renesas.com>
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/of_address.h>
  11 #include <linux/of_platform.h>
  12 #include <linux/pci.h>
  13 #include <linux/pci-epc.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/pm_runtime.h>
  16
  17 #include "pcie-rcar.h"
  18
  19 #define RCAR_EPC_MAX_FUNCTIONS          1
  20
  21 /* Structure representing the PCIe interface */
  22 struct rcar_pcie_endpoint {
  23         struct rcar_pcie        pcie;
  24         phys_addr_t             *ob_mapped_addr;
  25         struct pci_epc_mem_window *ob_window;
  26         u8                      max_functions;
  27         unsigned int            bar_to_atu[MAX_NR_INBOUND_MAPS];
  28         unsigned long           *ib_window_map;
  29         u32                     num_ib_windows;
  30         u32                     num_ob_windows;
  31 };
  32
  33 static void rcar_pcie_ep_hw_init(struct rcar_pcie *pcie)
  34 {
  35         u32 val;
  36
  37         rcar_pci_write_reg(pcie, 0, PCIETCTLR);
  38
  39         /* Set endpoint mode */
  40         rcar_pci_write_reg(pcie, 0, PCIEMSR);
  41
  42         /* Initialize default capabilities. */
  43         rcar_rmw32(pcie, REXPCAP(0), 0xff, PCI_CAP_ID_EXP);
  44         rcar_rmw32(pcie, REXPCAP(PCI_EXP_FLAGS),
  45                    PCI_EXP_FLAGS_TYPE, PCI_EXP_TYPE_ENDPOINT << 4);
  46         rcar_rmw32(pcie, RCONF(PCI_HEADER_TYPE), PCI_HEADER_TYPE_MASK,
  47                    PCI_HEADER_TYPE_NORMAL);
  48
  49         /* Write out the physical slot number = 0 */
  50         rcar_rmw32(pcie, REXPCAP(PCI_EXP_SLTCAP), PCI_EXP_SLTCAP_PSN, 0);
  51
  52         val = rcar_pci_read_reg(pcie, EXPCAP(1));
  53         /* device supports fixed 128 bytes MPSS */
  54         val &= ~GENMASK(2, 0);
  55         rcar_pci_write_reg(pcie, val, EXPCAP(1));
  56
  57         val = rcar_pci_read_reg(pcie, EXPCAP(2));
  58         /* read requests size 128 bytes */
  59         val &= ~GENMASK(14, 12);
  60         /* payload size 128 bytes */
  61         val &= ~GENMASK(7, 5);
  62         rcar_pci_write_reg(pcie, val, EXPCAP(2));
  63
  64         /* Set target link speed to 5.0 GT/s */
  65         rcar_rmw32(pcie, EXPCAP(12), PCI_EXP_LNKSTA_CLS,
  66                    PCI_EXP_LNKSTA_CLS_5_0GB);
  67
  68         /* Set the completion timer timeout to the maximum 50ms. */
  69         rcar_rmw32(pcie, TLCTLR + 1, 0x3f, 50);
  70
  71         /* Terminate list of capabilities (Next Capability Offset=0) */
  72         rcar_rmw32(pcie, RVCCAP(0), 0xfff00000, 0);
  73
  74         /* flush modifications */
  75         wmb();
  76 }
  77
  78 static int rcar_pcie_ep_get_window(struct rcar_pcie_endpoint *ep,
  79                                    phys_addr_t addr)
  80 {
  81         int i;
  82
  83         for (i = 0; i < ep->num_ob_windows; i++)
  84                 if (ep->ob_window[i].phys_base == addr)
  85                         return i;
  86
  87         return -EINVAL;
  88 }
  89
  90 static int rcar_pcie_parse_outbound_ranges(struct rcar_pcie_endpoint *ep,
  91                                            struct platform_device *pdev)
  92 {
  93         struct rcar_pcie *pcie = &ep->pcie;
  94         char outbound_name[10];
  95         struct resource *res;
  96         unsigned int i = 0;
  97
  98         ep->num_ob_windows = 0;
  99         for (i = 0; i < RCAR_PCI_MAX_RESOURCES; i++) {
 100                 sprintf(outbound_name, "memory%u", i);
 101                 res = platform_get_resource_byname(pdev,
 102                                                    IORESOURCE_MEM,
 103                                                    outbound_name);
 104                 if (!res) {
 105                         dev_err(pcie->dev, "missing outbound window %u\n", i);
 106                         return -EINVAL;
 107                 }
 108                 if (!devm_request_mem_region(&pdev->dev, res->start,
 109                                              resource_size(res),
 110                                              outbound_name)) {
 111                         dev_err(pcie->dev, "Cannot request memory region %s.\n",
 112                                 outbound_name);
 113                         return -EIO;
 114                 }
 115
 116                 ep->ob_window[i].phys_base = res->start;
 117                 ep->ob_window[i].size = resource_size(res);
 118                 /* controller doesn't support multiple allocation
 119                  * from same window, so set page_size to window size
 120                  */
 121                 ep->ob_window[i].page_size = resource_size(res);
 122         }
 123         ep->num_ob_windows = i;
 124
 125         return 0;
 126 }
 127
 128 static int rcar_pcie_ep_get_pdata(struct rcar_pcie_endpoint *ep,
 129                                   struct platform_device *pdev)
 130 {
 131         struct rcar_pcie *pcie = &ep->pcie;
 132         struct pci_epc_mem_window *window;
 133         struct device *dev = pcie->dev;
 134         struct resource res;
 135         int err;
 136
 137         err = of_address_to_resource(dev->of_node, 0, &res);
 138         if (err)
 139                 return err;
 140         pcie->base = devm_ioremap_resource(dev, &res);
 141         if (IS_ERR(pcie->base))
 142                 return PTR_ERR(pcie->base);
 143
 144         ep->ob_window = devm_kcalloc(dev, RCAR_PCI_MAX_RESOURCES,
 145                                      sizeof(*window), GFP_KERNEL);
 146         if (!ep->ob_window)
 147                 return -ENOMEM;
 148
 149         rcar_pcie_parse_outbound_ranges(ep, pdev);
 150
 151         err = of_property_read_u8(dev->of_node, "max-functions",
 152                                   &ep->max_functions);
 153         if (err < 0 || ep->max_functions > RCAR_EPC_MAX_FUNCTIONS)
 154                 ep->max_functions = RCAR_EPC_MAX_FUNCTIONS;
 155
 156         return 0;
 157 }
 158
 159 static int rcar_pcie_ep_write_header(struct pci_epc *epc, u8 fn, u8 vfn,
 160                                      struct pci_epf_header *hdr)
 161 {
 162         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 163         struct rcar_pcie *pcie = &ep->pcie;
 164         u32 val;
 165
 166         if (!fn)
 167                 val = hdr->vendorid;
 168         else
 169                 val = rcar_pci_read_reg(pcie, IDSETR0);
 170         val |= hdr->deviceid << 16;
 171         rcar_pci_write_reg(pcie, val, IDSETR0);
 172
 173         val = hdr->revid;
 174         val |= hdr->progif_code << 8;
 175         val |= hdr->subclass_code << 16;
 176         val |= hdr->baseclass_code << 24;
 177         rcar_pci_write_reg(pcie, val, IDSETR1);
 178
 179         if (!fn)
 180                 val = hdr->subsys_vendor_id;
 181         else
 182                 val = rcar_pci_read_reg(pcie, SUBIDSETR);
 183         val |= hdr->subsys_id << 16;
 184         rcar_pci_write_reg(pcie, val, SUBIDSETR);
 185
 186         if (hdr->interrupt_pin > PCI_INTERRUPT_INTA)
 187                 return -EINVAL;
 188         val = rcar_pci_read_reg(pcie, PCICONF(15));
 189         val |= (hdr->interrupt_pin << 8);
 190         rcar_pci_write_reg(pcie, val, PCICONF(15));
 191
 192         return 0;
 193 }
 194
 195 static int rcar_pcie_ep_set_bar(struct pci_epc *epc, u8 func_no, u8 vfunc_no,
 196                                 struct pci_epf_bar *epf_bar)
 197 {
 198         int flags = epf_bar->flags | LAR_ENABLE | LAM_64BIT;
 199         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 200         u64 size = 1ULL << fls64(epf_bar->size - 1);
 201         dma_addr_t cpu_addr = epf_bar->phys_addr;
 202         enum pci_barno bar = epf_bar->barno;
 203         struct rcar_pcie *pcie = &ep->pcie;
 204         u32 mask;
 205         int idx;
 206         int err;
 207
 208         idx = find_first_zero_bit(ep->ib_window_map, ep->num_ib_windows);
 209         if (idx >= ep->num_ib_windows) {
 210                 dev_err(pcie->dev, "no free inbound window\n");
 211                 return -EINVAL;
 212         }
 213
 214         if ((flags & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
 215                 flags |= IO_SPACE;
 216
 217         ep->bar_to_atu[bar] = idx;
 218         /* use 64-bit BARs */
 219         set_bit(idx, ep->ib_window_map);
 220         set_bit(idx + 1, ep->ib_window_map);
 221
 222         if (cpu_addr > 0) {
 223                 unsigned long nr_zeros = __ffs64(cpu_addr);
 224                 u64 alignment = 1ULL << nr_zeros;
 225
 226                 size = min(size, alignment);
 227         }
 228
 229         size = min(size, 1ULL << 32);
 230
 231         mask = roundup_pow_of_two(size) - 1;
 232         mask &= ~0xf;
 233
 234         rcar_pcie_set_inbound(pcie, cpu_addr,
 235                               0x0, mask | flags, idx, false);
 236
 237         err = rcar_pcie_wait_for_phyrdy(pcie);
 238         if (err) {
 239                 dev_err(pcie->dev, "phy not ready\n");
 240                 return -EINVAL;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static void rcar_pcie_ep_clear_bar(struct pci_epc *epc, u8 fn, u8 vfn,
 247                                    struct pci_epf_bar *epf_bar)
 248 {
 249         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 250         enum pci_barno bar = epf_bar->barno;
 251         u32 atu_index = ep->bar_to_atu[bar];
 252
 253         rcar_pcie_set_inbound(&ep->pcie, 0x0, 0x0, 0x0, bar, false);
 254
 255         clear_bit(atu_index, ep->ib_window_map);
 256         clear_bit(atu_index + 1, ep->ib_window_map);
 257 }
 258
 259 static int rcar_pcie_ep_set_msi(struct pci_epc *epc, u8 fn, u8 vfn,
 260                                 u8 interrupts)
 261 {
 262         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 263         struct rcar_pcie *pcie = &ep->pcie;
 264         u32 flags;
 265
 266         flags = rcar_pci_read_reg(pcie, MSICAP(fn));
 267         flags |= interrupts << MSICAP0_MMESCAP_OFFSET;
 268         rcar_pci_write_reg(pcie, flags, MSICAP(fn));
 269
 270         return 0;
 271 }
 272
 273 static int rcar_pcie_ep_get_msi(struct pci_epc *epc, u8 fn, u8 vfn)
 274 {
 275         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 276         struct rcar_pcie *pcie = &ep->pcie;
 277         u32 flags;
 278
 279         flags = rcar_pci_read_reg(pcie, MSICAP(fn));
 280         if (!(flags & MSICAP0_MSIE))
 281                 return -EINVAL;
 282
 283         return ((flags & MSICAP0_MMESE_MASK) >> MSICAP0_MMESE_OFFSET);
 284 }
 285
 286 static int rcar_pcie_ep_map_addr(struct pci_epc *epc, u8 fn, u8 vfn,
 287                                  phys_addr_t addr, u64 pci_addr, size_t size)
 288 {
 289         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 290         struct rcar_pcie *pcie = &ep->pcie;
 291         struct resource_entry win;
 292         struct resource res;
 293         int window;
 294         int err;
 295
 296         /* check if we have a link. */
 297         err = rcar_pcie_wait_for_dl(pcie);
 298         if (err) {
 299                 dev_err(pcie->dev, "link not up\n");
 300                 return err;
 301         }
 302
 303         window = rcar_pcie_ep_get_window(ep, addr);
 304         if (window < 0) {
 305                 dev_err(pcie->dev, "failed to get corresponding window\n");
 306                 return -EINVAL;
 307         }
 308
 309         memset(&win, 0x0, sizeof(win));
 310         memset(&res, 0x0, sizeof(res));
 311         res.start = pci_addr;
 312         res.end = pci_addr + size - 1;
 313         res.flags = IORESOURCE_MEM;
 314         win.res = &res;
 315
 316         rcar_pcie_set_outbound(pcie, window, &win);
 317
 318         ep->ob_mapped_addr[window] = addr;
 319
 320         return 0;
 321 }
 322
 323 static void rcar_pcie_ep_unmap_addr(struct pci_epc *epc, u8 fn, u8 vfn,
 324                                     phys_addr_t addr)
 325 {
 326         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 327         struct resource_entry win;
 328         struct resource res;
 329         int idx;
 330
 331         for (idx = 0; idx < ep->num_ob_windows; idx++)
 332                 if (ep->ob_mapped_addr[idx] == addr)
 333                         break;
 334
 335         if (idx >= ep->num_ob_windows)
 336                 return;
 337
 338         memset(&win, 0x0, sizeof(win));
 339         memset(&res, 0x0, sizeof(res));
 340         win.res = &res;
 341         rcar_pcie_set_outbound(&ep->pcie, idx, &win);
 342
 343         ep->ob_mapped_addr[idx] = 0;
 344 }
 345
 346 static int rcar_pcie_ep_assert_intx(struct rcar_pcie_endpoint *ep,
 347                                     u8 fn, u8 intx)
 348 {
 349         struct rcar_pcie *pcie = &ep->pcie;
 350         u32 val;
 351
 352         val = rcar_pci_read_reg(pcie, PCIEMSITXR);
 353         if ((val & PCI_MSI_FLAGS_ENABLE)) {
 354                 dev_err(pcie->dev, "MSI is enabled, cannot assert INTx\n");
 355                 return -EINVAL;
 356         }
 357
 358         val = rcar_pci_read_reg(pcie, PCICONF(1));
 359         if ((val & INTDIS)) {
 360                 dev_err(pcie->dev, "INTx message transmission is disabled\n");
 361                 return -EINVAL;
 362         }
 363
 364         val = rcar_pci_read_reg(pcie, PCIEINTXR);
 365         if ((val & ASTINTX)) {
 366                 dev_err(pcie->dev, "INTx is already asserted\n");
 367                 return -EINVAL;
 368         }
 369
 370         val |= ASTINTX;
 371         rcar_pci_write_reg(pcie, val, PCIEINTXR);
 372         usleep_range(1000, 1001);
 373         val = rcar_pci_read_reg(pcie, PCIEINTXR);
 374         val &= ~ASTINTX;
 375         rcar_pci_write_reg(pcie, val, PCIEINTXR);
 376
 377         return 0;
 378 }
 379
 380 static int rcar_pcie_ep_assert_msi(struct rcar_pcie *pcie,
 381                                    u8 fn, u8 interrupt_num)
 382 {
 383         u16 msi_count;
 384         u32 val;
 385
 386         /* Check MSI enable bit */
 387         val = rcar_pci_read_reg(pcie, MSICAP(fn));
 388         if (!(val & MSICAP0_MSIE))
 389                 return -EINVAL;
 390
 391         /* Get MSI numbers from MME */
 392         msi_count = ((val & MSICAP0_MMESE_MASK) >> MSICAP0_MMESE_OFFSET);
 393         msi_count = 1 << msi_count;
 394
 395         if (!interrupt_num || interrupt_num > msi_count)
 396                 return -EINVAL;
 397
 398         val = rcar_pci_read_reg(pcie, PCIEMSITXR);
 399         rcar_pci_write_reg(pcie, val | (interrupt_num - 1), PCIEMSITXR);
 400
 401         return 0;
 402 }
 403
 404 static int rcar_pcie_ep_raise_irq(struct pci_epc *epc, u8 fn, u8 vfn,
 405                                   enum pci_epc_irq_type type,
 406                                   u16 interrupt_num)
 407 {
 408         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 409
 410         switch (type) {
 411         case PCI_EPC_IRQ_LEGACY:
 412                 return rcar_pcie_ep_assert_intx(ep, fn, 0);
 413
 414         case PCI_EPC_IRQ_MSI:
 415                 return rcar_pcie_ep_assert_msi(&ep->pcie, fn, interrupt_num);
 416
 417         default:
 418                 return -EINVAL;
 419         }
 420 }
 421
 422 static int rcar_pcie_ep_start(struct pci_epc *epc)
 423 {
 424         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 425
 426         rcar_pci_write_reg(&ep->pcie, MACCTLR_INIT_VAL, MACCTLR);
 427         rcar_pci_write_reg(&ep->pcie, CFINIT, PCIETCTLR);
 428
 429         return 0;
 430 }
 431
 432 static void rcar_pcie_ep_stop(struct pci_epc *epc)
 433 {
 434         struct rcar_pcie_endpoint *ep = epc_get_drvdata(epc);
 435
 436         rcar_pci_write_reg(&ep->pcie, 0, PCIETCTLR);
 437 }
 438
 439 static const struct pci_epc_features rcar_pcie_epc_features = {
 440         .linkup_notifier = false,
 441         .msi_capable = true,
 442         .msix_capable = false,
 443         /* use 64-bit BARs so mark BAR[1,3,5] as reserved */
 444         .reserved_bar = 1 << BAR_1 | 1 << BAR_3 | 1 << BAR_5,
 445         .bar_fixed_64bit = 1 << BAR_0 | 1 << BAR_2 | 1 << BAR_4,
 446         .bar_fixed_size[0] = 128,
 447         .bar_fixed_size[2] = 256,
 448         .bar_fixed_size[4] = 256,
 449 };
 450
 451 static const struct pci_epc_features*
 452 rcar_pcie_ep_get_features(struct pci_epc *epc, u8 func_no, u8 vfunc_no)
 453 {
 454         return &rcar_pcie_epc_features;
 455 }
 456
 457 static const struct pci_epc_ops rcar_pcie_epc_ops = {
 458         .write_header   = rcar_pcie_ep_write_header,
 459         .set_bar        = rcar_pcie_ep_set_bar,
 460         .clear_bar      = rcar_pcie_ep_clear_bar,
 461         .set_msi        = rcar_pcie_ep_set_msi,
 462         .get_msi        = rcar_pcie_ep_get_msi,
 463         .map_addr       = rcar_pcie_ep_map_addr,
 464         .unmap_addr     = rcar_pcie_ep_unmap_addr,
 465         .raise_irq      = rcar_pcie_ep_raise_irq,
 466         .start          = rcar_pcie_ep_start,
 467         .stop           = rcar_pcie_ep_stop,
 468         .get_features   = rcar_pcie_ep_get_features,
 469 };
 470
 471 static const struct of_device_id rcar_pcie_ep_of_match[] = {
 472         { .compatible = "renesas,r8a774c0-pcie-ep", },
 473         { .compatible = "renesas,rcar-gen3-pcie-ep" },
 474         { },
 475 };
 476
 477 static int rcar_pcie_ep_probe(struct platform_device *pdev)
 478 {
 479         struct device *dev = &pdev->dev;
 480         struct rcar_pcie_endpoint *ep;
 481         struct rcar_pcie *pcie;
 482         struct pci_epc *epc;
 483         int err;
 484
 485         ep = devm_kzalloc(dev, sizeof(*ep), GFP_KERNEL);
 486         if (!ep)
 487                 return -ENOMEM;
 488
 489         pcie = &ep->pcie;
 490         pcie->dev = dev;
 491
 492         pm_runtime_enable(dev);
 493         err = pm_runtime_resume_and_get(dev);
 494         if (err < 0) {
 495                 dev_err(dev, "pm_runtime_resume_and_get failed\n");
 496                 goto err_pm_disable;
 497         }
 498
 499         err = rcar_pcie_ep_get_pdata(ep, pdev);
 500         if (err < 0) {
 501                 dev_err(dev, "failed to request resources: %d\n", err);
 502                 goto err_pm_put;
 503         }
 504
 505         ep->num_ib_windows = MAX_NR_INBOUND_MAPS;
 506         ep->ib_window_map =
 507                         devm_kcalloc(dev, BITS_TO_LONGS(ep->num_ib_windows),
 508                                      sizeof(long), GFP_KERNEL);
 509         if (!ep->ib_window_map) {
 510                 err = -ENOMEM;
 511                 dev_err(dev, "failed to allocate memory for inbound map\n");
 512                 goto err_pm_put;
 513         }
 514
 515         ep->ob_mapped_addr = devm_kcalloc(dev, ep->num_ob_windows,
 516                                           sizeof(*ep->ob_mapped_addr),
 517                                           GFP_KERNEL);
 518         if (!ep->ob_mapped_addr) {
 519                 err = -ENOMEM;
 520                 dev_err(dev, "failed to allocate memory for outbound memory pointers\n");
 521                 goto err_pm_put;
 522         }
 523
 524         epc = devm_pci_epc_create(dev, &rcar_pcie_epc_ops);
 525         if (IS_ERR(epc)) {
 526                 dev_err(dev, "failed to create epc device\n");
 527                 err = PTR_ERR(epc);
 528                 goto err_pm_put;
 529         }
 530
 531         epc->max_functions = ep->max_functions;
 532         epc_set_drvdata(epc, ep);
 533
 534         rcar_pcie_ep_hw_init(pcie);
 535
 536         err = pci_epc_multi_mem_init(epc, ep->ob_window, ep->num_ob_windows);
 537         if (err < 0) {
 538                 dev_err(dev, "failed to initialize the epc memory space\n");
 539                 goto err_pm_put;
 540         }
 541
 542         return 0;
 543
 544 err_pm_put:
 545         pm_runtime_put(dev);
 546
 547 err_pm_disable:
 548         pm_runtime_disable(dev);
 549
 550         return err;
 551 }
 552
 553 static struct platform_driver rcar_pcie_ep_driver = {
 554         .driver = {
 555                 .name = "rcar-pcie-ep",
 556                 .of_match_table = rcar_pcie_ep_of_match,
 557                 .suppress_bind_attrs = true,
 558         },
 559         .probe = rcar_pcie_ep_probe,
 560 };
 561 builtin_platform_driver(rcar_pcie_ep_driver);