1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * PCI <-> OF mapping helpers 4 * 5 * Copyright 2011 IBM Corp. 6 */ 7 #define pr_fmt(fmt) "PCI: OF: " fmt 8 9 #include <linux/cleanup.h> 10 #include <linux/irqdomain.h> 11 #include <linux/kernel.h> 12 #include <linux/pci.h> 13 #include <linux/of.h> 14 #include <linux/of_irq.h> 15 #include <linux/of_address.h> 16 #include <linux/of_pci.h> 17 #include <linux/platform_device.h> 18 #include "pci.h" 19 20 #ifdef CONFIG_PCI 21 /** 22 * pci_set_of_node - Find and set device's DT device_node 23 * @dev: the PCI device structure to fill 24 * 25 * Returns 0 on success with of_node set or when no device is described in the 26 * DT. Returns -ENODEV if the device is present, but disabled in the DT. 27 */ 28 int pci_set_of_node(struct pci_dev *dev) 29 { 30 if (!dev->bus->dev.of_node) 31 return 0; 32 33 struct device_node *node __free(device_node) = 34 of_pci_find_child_device(dev->bus->dev.of_node, dev->devfn); 35 if (!node) 36 return 0; 37 38 struct device *pdev __free(put_device) = 39 bus_find_device_by_of_node(&platform_bus_type, node); 40 if (pdev) 41 dev->bus->dev.of_node_reused = true; 42 43 device_set_node(&dev->dev, of_fwnode_handle(no_free_ptr(node))); 44 return 0; 45 } 46 47 void pci_release_of_node(struct pci_dev *dev) 48 { 49 of_node_put(dev->dev.of_node); 50 device_set_node(&dev->dev, NULL); 51 } 52 53 void pci_set_bus_of_node(struct pci_bus *bus) 54 { 55 struct device_node *node; 56 57 if (bus->self == NULL) { 58 node = pcibios_get_phb_of_node(bus); 59 } else { 60 node = of_node_get(bus->self->dev.of_node); 61 if (node && of_property_read_bool(node, "external-facing")) 62 bus->self->external_facing = true; 63 } 64 65 device_set_node(&bus->dev, of_fwnode_handle(node)); 66 } 67 68 void pci_release_bus_of_node(struct pci_bus *bus) 69 { 70 of_node_put(bus->dev.of_node); 71 device_set_node(&bus->dev, NULL); 72 } 73 74 struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus) 75 { 76 /* This should only be called for PHBs */ 77 if (WARN_ON(bus->self || bus->parent)) 78 return NULL; 79 80 /* 81 * Look for a node pointer in either the intermediary device we 82 * create above the root bus or its own parent. Normally only 83 * the later is populated. 84 */ 85 if (bus->bridge->of_node) 86 return of_node_get(bus->bridge->of_node); 87 if (bus->bridge->parent && bus->bridge->parent->of_node) 88 return of_node_get(bus->bridge->parent->of_node); 89 return NULL; 90 } 91 92 struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus) 93 { 94 #ifdef CONFIG_IRQ_DOMAIN 95 struct irq_domain *d; 96 97 if (!bus->dev.of_node) 98 return NULL; 99 100 /* Start looking for a phandle to an MSI controller. */ 101 d = of_msi_get_domain(&bus->dev, bus->dev.of_node, DOMAIN_BUS_PCI_MSI); 102 if (d) 103 return d; 104 105 /* 106 * If we don't have an msi-parent property, look for a domain 107 * directly attached to the host bridge. 108 */ 109 d = irq_find_matching_host(bus->dev.of_node, DOMAIN_BUS_PCI_MSI); 110 if (d) 111 return d; 112 113 return irq_find_host(bus->dev.of_node); 114 #else 115 return NULL; 116 #endif 117 } 118 119 bool pci_host_of_has_msi_map(struct device *dev) 120 { 121 if (dev && dev->of_node) 122 return of_get_property(dev->of_node, "msi-map", NULL); 123 return false; 124 } 125 126 static inline int __of_pci_pci_compare(struct device_node *node, 127 unsigned int data) 128 { 129 int devfn; 130 131 devfn = of_pci_get_devfn(node); 132 if (devfn < 0) 133 return 0; 134 135 return devfn == data; 136 } 137 138 struct device_node *of_pci_find_child_device(struct device_node *parent, 139 unsigned int devfn) 140 { 141 struct device_node *node, *node2; 142 143 for_each_child_of_node(parent, node) { 144 if (__of_pci_pci_compare(node, devfn)) 145 return node; 146 /* 147 * Some OFs create a parent node "multifunc-device" as 148 * a fake root for all functions of a multi-function 149 * device we go down them as well. 150 */ 151 if (of_node_name_eq(node, "multifunc-device")) { 152 for_each_child_of_node(node, node2) { 153 if (__of_pci_pci_compare(node2, devfn)) { 154 of_node_put(node); 155 return node2; 156 } 157 } 158 } 159 } 160 return NULL; 161 } 162 EXPORT_SYMBOL_GPL(of_pci_find_child_device); 163 164 /** 165 * of_pci_get_devfn() - Get device and function numbers for a device node 166 * @np: device node 167 * 168 * Parses a standard 5-cell PCI resource and returns an 8-bit value that can 169 * be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device 170 * and function numbers respectively. On error a negative error code is 171 * returned. 172 */ 173 int of_pci_get_devfn(struct device_node *np) 174 { 175 u32 reg[5]; 176 int error; 177 178 error = of_property_read_u32_array(np, "reg", reg, ARRAY_SIZE(reg)); 179 if (error) 180 return error; 181 182 return (reg[0] >> 8) & 0xff; 183 } 184 EXPORT_SYMBOL_GPL(of_pci_get_devfn); 185 186 /** 187 * of_pci_parse_bus_range() - parse the bus-range property of a PCI device 188 * @node: device node 189 * @res: address to a struct resource to return the bus-range 190 * 191 * Returns 0 on success or a negative error-code on failure. 192 */ 193 static int of_pci_parse_bus_range(struct device_node *node, 194 struct resource *res) 195 { 196 u32 bus_range[2]; 197 int error; 198 199 error = of_property_read_u32_array(node, "bus-range", bus_range, 200 ARRAY_SIZE(bus_range)); 201 if (error) 202 return error; 203 204 res->name = node->name; 205 res->start = bus_range[0]; 206 res->end = bus_range[1]; 207 res->flags = IORESOURCE_BUS; 208 209 return 0; 210 } 211 212 /** 213 * of_get_pci_domain_nr - Find the host bridge domain number 214 * of the given device node. 215 * @node: Device tree node with the domain information. 216 * 217 * This function will try to obtain the host bridge domain number by finding 218 * a property called "linux,pci-domain" of the given device node. 219 * 220 * Return: 221 * * > 0 - On success, an associated domain number. 222 * * -EINVAL - The property "linux,pci-domain" does not exist. 223 * * -ENODATA - The linux,pci-domain" property does not have value. 224 * * -EOVERFLOW - Invalid "linux,pci-domain" property value. 225 * 226 * Returns the associated domain number from DT in the range [0-0xffff], or 227 * a negative value if the required property is not found. 228 */ 229 int of_get_pci_domain_nr(struct device_node *node) 230 { 231 u32 domain; 232 int error; 233 234 error = of_property_read_u32(node, "linux,pci-domain", &domain); 235 if (error) 236 return error; 237 238 return (u16)domain; 239 } 240 EXPORT_SYMBOL_GPL(of_get_pci_domain_nr); 241 242 /** 243 * of_pci_preserve_config - Return true if the boot configuration needs to 244 * be preserved 245 * @node: Device tree node. 246 * 247 * Look for "linux,pci-probe-only" property for a given PCI controller's 248 * node and return true if found. Also look in the chosen node if the 249 * property is not found in the given controller's node. Having this 250 * property ensures that the kernel doesn't reconfigure the BARs and bridge 251 * windows that are already done by the platform firmware. 252 * 253 * Return: true if the property exists; false otherwise. 254 */ 255 bool of_pci_preserve_config(struct device_node *node) 256 { 257 u32 val = 0; 258 int ret; 259 260 if (!node) { 261 pr_warn("device node is NULL, trying with of_chosen\n"); 262 node = of_chosen; 263 } 264 265 retry: 266 ret = of_property_read_u32(node, "linux,pci-probe-only", &val); 267 if (ret) { 268 if (ret == -ENODATA || ret == -EOVERFLOW) { 269 pr_warn("Incorrect value for linux,pci-probe-only in %pOF, ignoring\n", 270 node); 271 return false; 272 } 273 if (ret == -EINVAL) { 274 if (node == of_chosen) 275 return false; 276 277 node = of_chosen; 278 goto retry; 279 } 280 } 281 282 if (val) 283 return true; 284 else 285 return false; 286 } 287 288 /** 289 * of_pci_check_probe_only - Setup probe only mode if linux,pci-probe-only 290 * is present and valid 291 */ 292 void of_pci_check_probe_only(void) 293 { 294 if (of_pci_preserve_config(of_chosen)) 295 pci_add_flags(PCI_PROBE_ONLY); 296 else 297 pci_clear_flags(PCI_PROBE_ONLY); 298 } 299 EXPORT_SYMBOL_GPL(of_pci_check_probe_only); 300 301 /** 302 * devm_of_pci_get_host_bridge_resources() - Resource-managed parsing of PCI 303 * host bridge resources from DT 304 * @dev: host bridge device 305 * @resources: list where the range of resources will be added after DT parsing 306 * @ib_resources: list where the range of inbound resources (with addresses 307 * from 'dma-ranges') will be added after DT parsing 308 * @io_base: pointer to a variable that will contain on return the physical 309 * address for the start of the I/O range. Can be NULL if the caller doesn't 310 * expect I/O ranges to be present in the device tree. 311 * 312 * This function will parse the "ranges" property of a PCI host bridge device 313 * node and setup the resource mapping based on its content. It is expected 314 * that the property conforms with the Power ePAPR document. 315 * 316 * It returns zero if the range parsing has been successful or a standard error 317 * value if it failed. 318 */ 319 static int devm_of_pci_get_host_bridge_resources(struct device *dev, 320 struct list_head *resources, 321 struct list_head *ib_resources, 322 resource_size_t *io_base) 323 { 324 struct device_node *dev_node = dev->of_node; 325 struct resource *res, tmp_res; 326 struct resource *bus_range; 327 struct of_pci_range range; 328 struct of_pci_range_parser parser; 329 const char *range_type; 330 int err; 331 332 if (io_base) 333 *io_base = (resource_size_t)OF_BAD_ADDR; 334 335 bus_range = devm_kzalloc(dev, sizeof(*bus_range), GFP_KERNEL); 336 if (!bus_range) 337 return -ENOMEM; 338 339 dev_info(dev, "host bridge %pOF ranges:\n", dev_node); 340 341 err = of_pci_parse_bus_range(dev_node, bus_range); 342 if (err) { 343 bus_range->start = 0; 344 bus_range->end = 0xff; 345 bus_range->flags = IORESOURCE_BUS; 346 } else { 347 if (bus_range->end > 0xff) { 348 dev_warn(dev, " Invalid end bus number in %pR, defaulting to 0xff\n", 349 bus_range); 350 bus_range->end = 0xff; 351 } 352 } 353 pci_add_resource(resources, bus_range); 354 355 /* Check for ranges property */ 356 err = of_pci_range_parser_init(&parser, dev_node); 357 if (err) 358 return 0; 359 360 dev_dbg(dev, "Parsing ranges property...\n"); 361 for_each_of_pci_range(&parser, &range) { 362 /* Read next ranges element */ 363 if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO) 364 range_type = "IO"; 365 else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM) 366 range_type = "MEM"; 367 else 368 range_type = "err"; 369 dev_info(dev, " %6s %#012llx..%#012llx -> %#012llx\n", 370 range_type, range.cpu_addr, 371 range.cpu_addr + range.size - 1, range.pci_addr); 372 373 /* 374 * If we failed translation or got a zero-sized region 375 * then skip this range 376 */ 377 if (range.cpu_addr == OF_BAD_ADDR || range.size == 0) 378 continue; 379 380 err = of_pci_range_to_resource(&range, dev_node, &tmp_res); 381 if (err) 382 continue; 383 384 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL); 385 if (!res) { 386 err = -ENOMEM; 387 goto failed; 388 } 389 390 if (resource_type(res) == IORESOURCE_IO) { 391 if (!io_base) { 392 dev_err(dev, "I/O range found for %pOF. Please provide an io_base pointer to save CPU base address\n", 393 dev_node); 394 err = -EINVAL; 395 goto failed; 396 } 397 if (*io_base != (resource_size_t)OF_BAD_ADDR) 398 dev_warn(dev, "More than one I/O resource converted for %pOF. CPU base address for old range lost!\n", 399 dev_node); 400 *io_base = range.cpu_addr; 401 } else if (resource_type(res) == IORESOURCE_MEM) { 402 res->flags &= ~IORESOURCE_MEM_64; 403 } 404 405 pci_add_resource_offset(resources, res, res->start - range.pci_addr); 406 } 407 408 /* Check for dma-ranges property */ 409 if (!ib_resources) 410 return 0; 411 err = of_pci_dma_range_parser_init(&parser, dev_node); 412 if (err) 413 return 0; 414 415 dev_dbg(dev, "Parsing dma-ranges property...\n"); 416 for_each_of_pci_range(&parser, &range) { 417 /* 418 * If we failed translation or got a zero-sized region 419 * then skip this range 420 */ 421 if (((range.flags & IORESOURCE_TYPE_BITS) != IORESOURCE_MEM) || 422 range.cpu_addr == OF_BAD_ADDR || range.size == 0) 423 continue; 424 425 dev_info(dev, " %6s %#012llx..%#012llx -> %#012llx\n", 426 "IB MEM", range.cpu_addr, 427 range.cpu_addr + range.size - 1, range.pci_addr); 428 429 430 err = of_pci_range_to_resource(&range, dev_node, &tmp_res); 431 if (err) 432 continue; 433 434 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL); 435 if (!res) { 436 err = -ENOMEM; 437 goto failed; 438 } 439 440 pci_add_resource_offset(ib_resources, res, 441 res->start - range.pci_addr); 442 } 443 444 return 0; 445 446 failed: 447 pci_free_resource_list(resources); 448 return err; 449 } 450 451 #if IS_ENABLED(CONFIG_OF_IRQ) 452 /** 453 * of_irq_parse_pci - Resolve the interrupt for a PCI device 454 * @pdev: the device whose interrupt is to be resolved 455 * @out_irq: structure of_phandle_args filled by this function 456 * 457 * This function resolves the PCI interrupt for a given PCI device. If a 458 * device node exists for a given pci_dev, it will use normal OF tree 459 * walking. If not, it will implement standard swizzling and walk up the 460 * PCI tree until a device node is found, at which point it will finish 461 * resolving using the OF tree walking. 462 */ 463 static int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq) 464 { 465 struct device_node *dn, *ppnode = NULL; 466 struct pci_dev *ppdev; 467 __be32 laddr[3]; 468 u8 pin; 469 int rc; 470 471 /* 472 * Check if we have a device node, if yes, fallback to standard 473 * device tree parsing 474 */ 475 dn = pci_device_to_OF_node(pdev); 476 if (dn) { 477 rc = of_irq_parse_one(dn, 0, out_irq); 478 if (!rc) 479 return rc; 480 } 481 482 /* 483 * Ok, we don't, time to have fun. Let's start by building up an 484 * interrupt spec. we assume #interrupt-cells is 1, which is standard 485 * for PCI. If you do different, then don't use that routine. 486 */ 487 rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin); 488 if (rc != 0) 489 goto err; 490 /* No pin, exit with no error message. */ 491 if (pin == 0) 492 return -ENODEV; 493 494 /* Local interrupt-map in the device node? Use it! */ 495 if (of_property_present(dn, "interrupt-map")) { 496 pin = pci_swizzle_interrupt_pin(pdev, pin); 497 ppnode = dn; 498 } 499 500 /* Now we walk up the PCI tree */ 501 while (!ppnode) { 502 /* Get the pci_dev of our parent */ 503 ppdev = pdev->bus->self; 504 505 /* Ouch, it's a host bridge... */ 506 if (ppdev == NULL) { 507 ppnode = pci_bus_to_OF_node(pdev->bus); 508 509 /* No node for host bridge ? give up */ 510 if (ppnode == NULL) { 511 rc = -EINVAL; 512 goto err; 513 } 514 } else { 515 /* We found a P2P bridge, check if it has a node */ 516 ppnode = pci_device_to_OF_node(ppdev); 517 } 518 519 /* 520 * Ok, we have found a parent with a device node, hand over to 521 * the OF parsing code. 522 * 523 * We build a unit address from the linux device to be used for 524 * resolution. Note that we use the linux bus number which may 525 * not match your firmware bus numbering. 526 * 527 * Fortunately, in most cases, interrupt-map-mask doesn't 528 * include the bus number as part of the matching. 529 * 530 * You should still be careful about that though if you intend 531 * to rely on this function (you ship a firmware that doesn't 532 * create device nodes for all PCI devices). 533 */ 534 if (ppnode) 535 break; 536 537 /* 538 * We can only get here if we hit a P2P bridge with no node; 539 * let's do standard swizzling and try again 540 */ 541 pin = pci_swizzle_interrupt_pin(pdev, pin); 542 pdev = ppdev; 543 } 544 545 out_irq->np = ppnode; 546 out_irq->args_count = 1; 547 out_irq->args[0] = pin; 548 laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8)); 549 laddr[1] = laddr[2] = cpu_to_be32(0); 550 rc = of_irq_parse_raw(laddr, out_irq); 551 if (rc) 552 goto err; 553 return 0; 554 err: 555 if (rc == -ENOENT) { 556 dev_warn(&pdev->dev, 557 "%s: no interrupt-map found, INTx interrupts not available\n", 558 __func__); 559 pr_warn_once("%s: possibly some PCI slots don't have level triggered interrupts capability\n", 560 __func__); 561 } else { 562 dev_err(&pdev->dev, "%s: failed with rc=%d\n", __func__, rc); 563 } 564 return rc; 565 } 566 567 /** 568 * of_irq_parse_and_map_pci() - Decode a PCI IRQ from the device tree and map to a VIRQ 569 * @dev: The PCI device needing an IRQ 570 * @slot: PCI slot number; passed when used as map_irq callback. Unused 571 * @pin: PCI IRQ pin number; passed when used as map_irq callback. Unused 572 * 573 * @slot and @pin are unused, but included in the function so that this 574 * function can be used directly as the map_irq callback to 575 * pci_assign_irq() and struct pci_host_bridge.map_irq pointer 576 */ 577 int of_irq_parse_and_map_pci(const struct pci_dev *dev, u8 slot, u8 pin) 578 { 579 struct of_phandle_args oirq; 580 int ret; 581 582 ret = of_irq_parse_pci(dev, &oirq); 583 if (ret) 584 return 0; /* Proper return code 0 == NO_IRQ */ 585 586 return irq_create_of_mapping(&oirq); 587 } 588 EXPORT_SYMBOL_GPL(of_irq_parse_and_map_pci); 589 #endif /* CONFIG_OF_IRQ */ 590 591 static int pci_parse_request_of_pci_ranges(struct device *dev, 592 struct pci_host_bridge *bridge) 593 { 594 int err, res_valid = 0; 595 resource_size_t iobase; 596 struct resource_entry *win, *tmp; 597 598 INIT_LIST_HEAD(&bridge->windows); 599 INIT_LIST_HEAD(&bridge->dma_ranges); 600 601 err = devm_of_pci_get_host_bridge_resources(dev, &bridge->windows, 602 &bridge->dma_ranges, &iobase); 603 if (err) 604 return err; 605 606 err = devm_request_pci_bus_resources(dev, &bridge->windows); 607 if (err) 608 return err; 609 610 resource_list_for_each_entry_safe(win, tmp, &bridge->windows) { 611 struct resource *res = win->res; 612 613 switch (resource_type(res)) { 614 case IORESOURCE_IO: 615 err = devm_pci_remap_iospace(dev, res, iobase); 616 if (err) { 617 dev_warn(dev, "error %d: failed to map resource %pR\n", 618 err, res); 619 resource_list_destroy_entry(win); 620 } 621 break; 622 case IORESOURCE_MEM: 623 res_valid |= !(res->flags & IORESOURCE_PREFETCH); 624 625 if (!(res->flags & IORESOURCE_PREFETCH)) 626 if (upper_32_bits(resource_size(res))) 627 dev_warn(dev, "Memory resource size exceeds max for 32 bits\n"); 628 629 break; 630 } 631 } 632 633 if (!res_valid) 634 dev_warn(dev, "non-prefetchable memory resource required\n"); 635 636 return 0; 637 } 638 639 int devm_of_pci_bridge_init(struct device *dev, struct pci_host_bridge *bridge) 640 { 641 if (!dev->of_node) 642 return 0; 643 644 bridge->swizzle_irq = pci_common_swizzle; 645 bridge->map_irq = of_irq_parse_and_map_pci; 646 647 return pci_parse_request_of_pci_ranges(dev, bridge); 648 } 649 650 #ifdef CONFIG_PCI_DYNAMIC_OF_NODES 651 652 void of_pci_remove_node(struct pci_dev *pdev) 653 { 654 struct device_node *np; 655 656 np = pci_device_to_OF_node(pdev); 657 if (!np || !of_node_check_flag(np, OF_DYNAMIC)) 658 return; 659 660 device_remove_of_node(&pdev->dev); 661 of_changeset_revert(np->data); 662 of_changeset_destroy(np->data); 663 of_node_put(np); 664 } 665 666 void of_pci_make_dev_node(struct pci_dev *pdev) 667 { 668 struct device_node *ppnode, *np = NULL; 669 const char *pci_type; 670 struct of_changeset *cset; 671 const char *name; 672 int ret; 673 674 /* 675 * If there is already a device tree node linked to this device, 676 * return immediately. 677 */ 678 if (pci_device_to_OF_node(pdev)) 679 return; 680 681 /* Check if there is device tree node for parent device */ 682 if (!pdev->bus->self) 683 ppnode = pdev->bus->dev.of_node; 684 else 685 ppnode = pdev->bus->self->dev.of_node; 686 if (!ppnode) 687 return; 688 689 if (pci_is_bridge(pdev)) 690 pci_type = "pci"; 691 else 692 pci_type = "dev"; 693 694 name = kasprintf(GFP_KERNEL, "%s@%x,%x", pci_type, 695 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); 696 if (!name) 697 return; 698 699 cset = kmalloc(sizeof(*cset), GFP_KERNEL); 700 if (!cset) 701 goto out_free_name; 702 of_changeset_init(cset); 703 704 np = of_changeset_create_node(cset, ppnode, name); 705 if (!np) 706 goto out_destroy_cset; 707 708 ret = of_pci_add_properties(pdev, cset, np); 709 if (ret) 710 goto out_free_node; 711 712 ret = of_changeset_apply(cset); 713 if (ret) 714 goto out_free_node; 715 716 np->data = cset; 717 718 ret = device_add_of_node(&pdev->dev, np); 719 if (ret) 720 goto out_revert_cset; 721 722 kfree(name); 723 724 return; 725 726 out_revert_cset: 727 np->data = NULL; 728 of_changeset_revert(cset); 729 out_free_node: 730 of_node_put(np); 731 out_destroy_cset: 732 of_changeset_destroy(cset); 733 kfree(cset); 734 out_free_name: 735 kfree(name); 736 } 737 738 void of_pci_remove_host_bridge_node(struct pci_host_bridge *bridge) 739 { 740 struct device_node *np; 741 742 np = pci_bus_to_OF_node(bridge->bus); 743 if (!np || !of_node_check_flag(np, OF_DYNAMIC)) 744 return; 745 746 device_remove_of_node(&bridge->bus->dev); 747 device_remove_of_node(&bridge->dev); 748 of_changeset_revert(np->data); 749 of_changeset_destroy(np->data); 750 of_node_put(np); 751 } 752 753 void of_pci_make_host_bridge_node(struct pci_host_bridge *bridge) 754 { 755 struct device_node *np = NULL; 756 struct of_changeset *cset; 757 const char *name; 758 int ret; 759 760 /* 761 * If there is already a device tree node linked to the PCI bus handled 762 * by this bridge (i.e. the PCI root bus), nothing to do. 763 */ 764 if (pci_bus_to_OF_node(bridge->bus)) 765 return; 766 767 /* 768 * The root bus has no node. Check that the host bridge has no node 769 * too 770 */ 771 if (bridge->dev.of_node) { 772 dev_err(&bridge->dev, "PCI host bridge of_node already set"); 773 return; 774 } 775 776 /* Check if there is a DT root node to attach the created node */ 777 if (!of_root) { 778 pr_err("of_root node is NULL, cannot create PCI host bridge node\n"); 779 return; 780 } 781 782 name = kasprintf(GFP_KERNEL, "pci@%x,%x", pci_domain_nr(bridge->bus), 783 bridge->bus->number); 784 if (!name) 785 return; 786 787 cset = kmalloc(sizeof(*cset), GFP_KERNEL); 788 if (!cset) 789 goto out_free_name; 790 of_changeset_init(cset); 791 792 np = of_changeset_create_node(cset, of_root, name); 793 if (!np) 794 goto out_destroy_cset; 795 796 ret = of_pci_add_host_bridge_properties(bridge, cset, np); 797 if (ret) 798 goto out_free_node; 799 800 /* 801 * This of_node will be added to an existing device. The of_node parent 802 * is the root OF node and so this node will be handled by the platform 803 * bus. Avoid any new device creation. 804 */ 805 of_node_set_flag(np, OF_POPULATED); 806 np->fwnode.dev = &bridge->dev; 807 fwnode_dev_initialized(&np->fwnode, true); 808 809 ret = of_changeset_apply(cset); 810 if (ret) 811 goto out_free_node; 812 813 np->data = cset; 814 815 /* Add the of_node to host bridge and the root bus */ 816 ret = device_add_of_node(&bridge->dev, np); 817 if (ret) 818 goto out_revert_cset; 819 820 ret = device_add_of_node(&bridge->bus->dev, np); 821 if (ret) 822 goto out_remove_bridge_dev_of_node; 823 824 kfree(name); 825 826 return; 827 828 out_remove_bridge_dev_of_node: 829 device_remove_of_node(&bridge->dev); 830 out_revert_cset: 831 np->data = NULL; 832 of_changeset_revert(cset); 833 out_free_node: 834 of_node_put(np); 835 out_destroy_cset: 836 of_changeset_destroy(cset); 837 kfree(cset); 838 out_free_name: 839 kfree(name); 840 } 841 842 #endif /* CONFIG_PCI_DYNAMIC_OF_NODES */ 843 844 /** 845 * of_pci_supply_present() - Check if the power supply is present for the PCI 846 * device 847 * @np: Device tree node 848 * 849 * Check if the power supply for the PCI device is present in the device tree 850 * node or not. 851 * 852 * Return: true if at least one power supply exists; false otherwise. 853 */ 854 bool of_pci_supply_present(struct device_node *np) 855 { 856 struct property *prop; 857 char *supply; 858 859 if (!np) 860 return false; 861 862 for_each_property_of_node(np, prop) { 863 supply = strrchr(prop->name, '-'); 864 if (supply && !strcmp(supply, "-supply")) 865 return true; 866 } 867 868 return false; 869 } 870 871 #endif /* CONFIG_PCI */ 872 873 /** 874 * of_pci_get_max_link_speed - Find the maximum link speed of the given device node. 875 * @node: Device tree node with the maximum link speed information. 876 * 877 * This function will try to find the limitation of link speed by finding 878 * a property called "max-link-speed" of the given device node. 879 * 880 * Return: 881 * * > 0 - On success, a maximum link speed. 882 * * -EINVAL - Invalid "max-link-speed" property value, or failure to access 883 * the property of the device tree node. 884 * 885 * Returns the associated max link speed from DT, or a negative value if the 886 * required property is not found or is invalid. 887 */ 888 int of_pci_get_max_link_speed(struct device_node *node) 889 { 890 u32 max_link_speed; 891 892 if (of_property_read_u32(node, "max-link-speed", &max_link_speed) || 893 max_link_speed == 0 || max_link_speed > 4) 894 return -EINVAL; 895 896 return max_link_speed; 897 } 898 EXPORT_SYMBOL_GPL(of_pci_get_max_link_speed); 899 900 /** 901 * of_pci_get_slot_power_limit - Parses the "slot-power-limit-milliwatt" 902 * property. 903 * 904 * @node: device tree node with the slot power limit information 905 * @slot_power_limit_value: pointer where the value should be stored in PCIe 906 * Slot Capabilities Register format 907 * @slot_power_limit_scale: pointer where the scale should be stored in PCIe 908 * Slot Capabilities Register format 909 * 910 * Returns the slot power limit in milliwatts and if @slot_power_limit_value 911 * and @slot_power_limit_scale pointers are non-NULL, fills in the value and 912 * scale in format used by PCIe Slot Capabilities Register. 913 * 914 * If the property is not found or is invalid, returns 0. 915 */ 916 u32 of_pci_get_slot_power_limit(struct device_node *node, 917 u8 *slot_power_limit_value, 918 u8 *slot_power_limit_scale) 919 { 920 u32 slot_power_limit_mw; 921 u8 value, scale; 922 923 if (of_property_read_u32(node, "slot-power-limit-milliwatt", 924 &slot_power_limit_mw)) 925 slot_power_limit_mw = 0; 926 927 /* Calculate Slot Power Limit Value and Slot Power Limit Scale */ 928 if (slot_power_limit_mw == 0) { 929 value = 0x00; 930 scale = 0; 931 } else if (slot_power_limit_mw <= 255) { 932 value = slot_power_limit_mw; 933 scale = 3; 934 } else if (slot_power_limit_mw <= 255*10) { 935 value = slot_power_limit_mw / 10; 936 scale = 2; 937 slot_power_limit_mw = slot_power_limit_mw / 10 * 10; 938 } else if (slot_power_limit_mw <= 255*100) { 939 value = slot_power_limit_mw / 100; 940 scale = 1; 941 slot_power_limit_mw = slot_power_limit_mw / 100 * 100; 942 } else if (slot_power_limit_mw <= 239*1000) { 943 value = slot_power_limit_mw / 1000; 944 scale = 0; 945 slot_power_limit_mw = slot_power_limit_mw / 1000 * 1000; 946 } else if (slot_power_limit_mw < 250*1000) { 947 value = 0xEF; 948 scale = 0; 949 slot_power_limit_mw = 239*1000; 950 } else if (slot_power_limit_mw <= 600*1000) { 951 value = 0xF0 + (slot_power_limit_mw / 1000 - 250) / 25; 952 scale = 0; 953 slot_power_limit_mw = slot_power_limit_mw / (1000*25) * (1000*25); 954 } else { 955 value = 0xFE; 956 scale = 0; 957 slot_power_limit_mw = 600*1000; 958 } 959 960 if (slot_power_limit_value) 961 *slot_power_limit_value = value; 962 963 if (slot_power_limit_scale) 964 *slot_power_limit_scale = scale; 965 966 return slot_power_limit_mw; 967 } 968 EXPORT_SYMBOL_GPL(of_pci_get_slot_power_limit); 969 970 /** 971 * of_pci_get_equalization_presets - Parses the "eq-presets-Ngts" property. 972 * 973 * @dev: Device containing the properties. 974 * @presets: Pointer to store the parsed data. 975 * @num_lanes: Maximum number of lanes supported. 976 * 977 * If the property is present, read and store the data in the @presets structure. 978 * Else, assign a default value of PCI_EQ_RESV. 979 * 980 * Return: 0 if the property is not available or successfully parsed else 981 * errno otherwise. 982 */ 983 int of_pci_get_equalization_presets(struct device *dev, 984 struct pci_eq_presets *presets, 985 int num_lanes) 986 { 987 char name[20]; 988 int ret; 989 990 presets->eq_presets_8gts[0] = PCI_EQ_RESV; 991 ret = of_property_read_u16_array(dev->of_node, "eq-presets-8gts", 992 presets->eq_presets_8gts, num_lanes); 993 if (ret && ret != -EINVAL) { 994 dev_err(dev, "Error reading eq-presets-8gts: %d\n", ret); 995 return ret; 996 } 997 998 for (int i = 0; i < EQ_PRESET_TYPE_MAX - 1; i++) { 999 presets->eq_presets_Ngts[i][0] = PCI_EQ_RESV; 1000 snprintf(name, sizeof(name), "eq-presets-%dgts", 8 << (i + 1)); 1001 ret = of_property_read_u8_array(dev->of_node, name, 1002 presets->eq_presets_Ngts[i], 1003 num_lanes); 1004 if (ret && ret != -EINVAL) { 1005 dev_err(dev, "Error reading %s: %d\n", name, ret); 1006 return ret; 1007 } 1008 } 1009 1010 return 0; 1011 } 1012 EXPORT_SYMBOL_GPL(of_pci_get_equalization_presets); 1013