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), 0x7f, 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); 562