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