drivers/pci/of.c

   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/irqdomain.h>
  10 #include <linux/kernel.h>
  11 #include <linux/pci.h>
  12 #include <linux/of.h>
  13 #include <linux/of_irq.h>
  14 #include <linux/of_address.h>
  15 #include <linux/of_pci.h>
  16 #include "pci.h"
  17
  18 #ifdef CONFIG_PCI
  19 /**
  20  * pci_set_of_node - Find and set device's DT device_node
  21  * @dev: the PCI device structure to fill
  22  *
  23  * Returns 0 on success with of_node set or when no device is described in the
  24  * DT. Returns -ENODEV if the device is present, but disabled in the DT.
  25  */
  26 int pci_set_of_node(struct pci_dev *dev)
  27 {
  28         struct device_node *node;
  29
  30         if (!dev->bus->dev.of_node)
  31                 return 0;
  32
  33         node = of_pci_find_child_device(dev->bus->dev.of_node, dev->devfn);
  34         if (!node)
  35                 return 0;
  36
  37         if (!of_device_is_available(node)) {
  38                 of_node_put(node);
  39                 return -ENODEV;
  40         }
  41
  42         dev->dev.of_node = node;
  43         dev->dev.fwnode = &node->fwnode;
  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         dev->dev.of_node = NULL;
  51         dev->dev.fwnode = NULL;
  52 }
  53
  54 void pci_set_bus_of_node(struct pci_bus *bus)
  55 {
  56         struct device_node *node;
  57
  58         if (bus->self == NULL) {
  59                 node = pcibios_get_phb_of_node(bus);
  60         } else {
  61                 node = of_node_get(bus->self->dev.of_node);
  62                 if (node && of_property_read_bool(node, "external-facing"))
  63                         bus->self->external_facing = true;
  64         }
  65
  66         bus->dev.of_node = node;
  67
  68         if (bus->dev.of_node)
  69                 bus->dev.fwnode = &bus->dev.of_node->fwnode;
  70 }
  71
  72 void pci_release_bus_of_node(struct pci_bus *bus)
  73 {
  74         of_node_put(bus->dev.of_node);
  75         bus->dev.of_node = NULL;
  76         bus->dev.fwnode = NULL;
  77 }
  78
  79 struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus)
  80 {
  81         /* This should only be called for PHBs */
  82         if (WARN_ON(bus->self || bus->parent))
  83                 return NULL;
  84
  85         /*
  86          * Look for a node pointer in either the intermediary device we
  87          * create above the root bus or its own parent. Normally only
  88          * the later is populated.
  89          */
  90         if (bus->bridge->of_node)
  91                 return of_node_get(bus->bridge->of_node);
  92         if (bus->bridge->parent && bus->bridge->parent->of_node)
  93                 return of_node_get(bus->bridge->parent->of_node);
  94         return NULL;
  95 }
  96
  97 struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus)
  98 {
  99 #ifdef CONFIG_IRQ_DOMAIN
 100         struct irq_domain *d;
 101
 102         if (!bus->dev.of_node)
 103                 return NULL;
 104
 105         /* Start looking for a phandle to an MSI controller. */
 106         d = of_msi_get_domain(&bus->dev, bus->dev.of_node, DOMAIN_BUS_PCI_MSI);
 107         if (d)
 108                 return d;
 109
 110         /*
 111          * If we don't have an msi-parent property, look for a domain
 112          * directly attached to the host bridge.
 113          */
 114         d = irq_find_matching_host(bus->dev.of_node, DOMAIN_BUS_PCI_MSI);
 115         if (d)
 116                 return d;
 117
 118         return irq_find_host(bus->dev.of_node);
 119 #else
 120         return NULL;
 121 #endif
 122 }
 123
 124 bool pci_host_of_has_msi_map(struct device *dev)
 125 {
 126         if (dev && dev->of_node)
 127                 return of_get_property(dev->of_node, "msi-map", NULL);
 128         return false;
 129 }
 130
 131 static inline int __of_pci_pci_compare(struct device_node *node,
 132                                        unsigned int data)
 133 {
 134         int devfn;
 135
 136         devfn = of_pci_get_devfn(node);
 137         if (devfn < 0)
 138                 return 0;
 139
 140         return devfn == data;
 141 }
 142
 143 struct device_node *of_pci_find_child_device(struct device_node *parent,
 144                                              unsigned int devfn)
 145 {
 146         struct device_node *node, *node2;
 147
 148         for_each_child_of_node(parent, node) {
 149                 if (__of_pci_pci_compare(node, devfn))
 150                         return node;
 151                 /*
 152                  * Some OFs create a parent node "multifunc-device" as
 153                  * a fake root for all functions of a multi-function
 154                  * device we go down them as well.
 155                  */
 156                 if (of_node_name_eq(node, "multifunc-device")) {
 157                         for_each_child_of_node(node, node2) {
 158                                 if (__of_pci_pci_compare(node2, devfn)) {
 159                                         of_node_put(node);
 160                                         return node2;
 161                                 }
 162                         }
 163                 }
 164         }
 165         return NULL;
 166 }
 167 EXPORT_SYMBOL_GPL(of_pci_find_child_device);
 168
 169 /**
 170  * of_pci_get_devfn() - Get device and function numbers for a device node
 171  * @np: device node
 172  *
 173  * Parses a standard 5-cell PCI resource and returns an 8-bit value that can
 174  * be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
 175  * and function numbers respectively. On error a negative error code is
 176  * returned.
 177  */
 178 int of_pci_get_devfn(struct device_node *np)
 179 {
 180         u32 reg[5];
 181         int error;
 182
 183         error = of_property_read_u32_array(np, "reg", reg, ARRAY_SIZE(reg));
 184         if (error)
 185                 return error;
 186
 187         return (reg[0] >> 8) & 0xff;
 188 }
 189 EXPORT_SYMBOL_GPL(of_pci_get_devfn);
 190
 191 /**
 192  * of_pci_parse_bus_range() - parse the bus-range property of a PCI device
 193  * @node: device node
 194  * @res: address to a struct resource to return the bus-range
 195  *
 196  * Returns 0 on success or a negative error-code on failure.
 197  */
 198 int of_pci_parse_bus_range(struct device_node *node, struct resource *res)
 199 {
 200         u32 bus_range[2];
 201         int error;
 202
 203         error = of_property_read_u32_array(node, "bus-range", bus_range,
 204                                            ARRAY_SIZE(bus_range));
 205         if (error)
 206                 return error;
 207
 208         res->name = node->name;
 209         res->start = bus_range[0];
 210         res->end = bus_range[1];
 211         res->flags = IORESOURCE_BUS;
 212
 213         return 0;
 214 }
 215 EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);
 216
 217 /**
 218  * of_get_pci_domain_nr - Find the host bridge domain number
 219  *                        of the given device node.
 220  * @node: Device tree node with the domain information.
 221  *
 222  * This function will try to obtain the host bridge domain number by finding
 223  * a property called "linux,pci-domain" of the given device node.
 224  *
 225  * Return:
 226  * * > 0        - On success, an associated domain number.
 227  * * -EINVAL    - The property "linux,pci-domain" does not exist.
 228  * * -ENODATA   - The linux,pci-domain" property does not have value.
 229  * * -EOVERFLOW - Invalid "linux,pci-domain" property value.
 230  *
 231  * Returns the associated domain number from DT in the range [0-0xffff], or
 232  * a negative value if the required property is not found.
 233  */
 234 int of_get_pci_domain_nr(struct device_node *node)
 235 {
 236         u32 domain;
 237         int error;
 238
 239         error = of_property_read_u32(node, "linux,pci-domain", &domain);
 240         if (error)
 241                 return error;
 242
 243         return (u16)domain;
 244 }
 245 EXPORT_SYMBOL_GPL(of_get_pci_domain_nr);
 246
 247 /**
 248  * of_pci_check_probe_only - Setup probe only mode if linux,pci-probe-only
 249  *                           is present and valid
 250  */
 251 void of_pci_check_probe_only(void)
 252 {
 253         u32 val;
 254         int ret;
 255
 256         ret = of_property_read_u32(of_chosen, "linux,pci-probe-only", &val);
 257         if (ret) {
 258                 if (ret == -ENODATA || ret == -EOVERFLOW)
 259                         pr_warn("linux,pci-probe-only without valid value, ignoring\n");
 260                 return;
 261         }
 262
 263         if (val)
 264                 pci_add_flags(PCI_PROBE_ONLY);
 265         else
 266                 pci_clear_flags(PCI_PROBE_ONLY);
 267
 268         pr_info("PROBE_ONLY %s\n", val ? "enabled" : "disabled");
 269 }
 270 EXPORT_SYMBOL_GPL(of_pci_check_probe_only);
 271
 272 /**
 273  * devm_of_pci_get_host_bridge_resources() - Resource-managed parsing of PCI
 274  *                                           host bridge resources from DT
 275  * @dev: host bridge device
 276  * @busno: bus number associated with the bridge root bus
 277  * @bus_max: maximum number of buses for this bridge
 278  * @resources: list where the range of resources will be added after DT parsing
 279  * @ib_resources: list where the range of inbound resources (with addresses
 280  *                from 'dma-ranges') will be added after DT parsing
 281  * @io_base: pointer to a variable that will contain on return the physical
 282  * address for the start of the I/O range. Can be NULL if the caller doesn't
 283  * expect I/O ranges to be present in the device tree.
 284  *
 285  * This function will parse the "ranges" property of a PCI host bridge device
 286  * node and setup the resource mapping based on its content. It is expected
 287  * that the property conforms with the Power ePAPR document.
 288  *
 289  * It returns zero if the range parsing has been successful or a standard error
 290  * value if it failed.
 291  */
 292 static int devm_of_pci_get_host_bridge_resources(struct device *dev,
 293                         unsigned char busno, unsigned char bus_max,
 294                         struct list_head *resources,
 295                         struct list_head *ib_resources,
 296                         resource_size_t *io_base)
 297 {
 298         struct device_node *dev_node = dev->of_node;
 299         struct resource *res, tmp_res;
 300         struct resource *bus_range;
 301         struct of_pci_range range;
 302         struct of_pci_range_parser parser;
 303         const char *range_type;
 304         int err;
 305
 306         if (io_base)
 307                 *io_base = (resource_size_t)OF_BAD_ADDR;
 308
 309         bus_range = devm_kzalloc(dev, sizeof(*bus_range), GFP_KERNEL);
 310         if (!bus_range)
 311                 return -ENOMEM;
 312
 313         dev_info(dev, "host bridge %pOF ranges:\n", dev_node);
 314
 315         err = of_pci_parse_bus_range(dev_node, bus_range);
 316         if (err) {
 317                 bus_range->start = busno;
 318                 bus_range->end = bus_max;
 319                 bus_range->flags = IORESOURCE_BUS;
 320                 dev_info(dev, "  No bus range found for %pOF, using %pR\n",
 321                          dev_node, bus_range);
 322         } else {
 323                 if (bus_range->end > bus_range->start + bus_max)
 324                         bus_range->end = bus_range->start + bus_max;
 325         }
 326         pci_add_resource(resources, bus_range);
 327
 328         /* Check for ranges property */
 329         err = of_pci_range_parser_init(&parser, dev_node);
 330         if (err)
 331                 return 0;
 332
 333         dev_dbg(dev, "Parsing ranges property...\n");
 334         for_each_of_pci_range(&parser, &range) {
 335                 /* Read next ranges element */
 336                 if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
 337                         range_type = "IO";
 338                 else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
 339                         range_type = "MEM";
 340                 else
 341                         range_type = "err";
 342                 dev_info(dev, "  %6s %#012llx..%#012llx -> %#012llx\n",
 343                          range_type, range.cpu_addr,
 344                          range.cpu_addr + range.size - 1, range.pci_addr);
 345
 346                 /*
 347                  * If we failed translation or got a zero-sized region
 348                  * then skip this range
 349                  */
 350                 if (range.cpu_addr == OF_BAD_ADDR || range.size == 0)
 351                         continue;
 352
 353                 err = of_pci_range_to_resource(&range, dev_node, &tmp_res);
 354                 if (err)
 355                         continue;
 356
 357                 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL);
 358                 if (!res) {
 359                         err = -ENOMEM;
 360                         goto failed;
 361                 }
 362
 363                 if (resource_type(res) == IORESOURCE_IO) {
 364                         if (!io_base) {
 365                                 dev_err(dev, "I/O range found for %pOF. Please provide an io_base pointer to save CPU base address\n",
 366                                         dev_node);
 367                                 err = -EINVAL;
 368                                 goto failed;
 369                         }
 370                         if (*io_base != (resource_size_t)OF_BAD_ADDR)
 371                                 dev_warn(dev, "More than one I/O resource converted for %pOF. CPU base address for old range lost!\n",
 372                                          dev_node);
 373                         *io_base = range.cpu_addr;
 374                 } else if (resource_type(res) == IORESOURCE_MEM) {
 375                         res->flags &= ~IORESOURCE_MEM_64;
 376                 }
 377
 378                 pci_add_resource_offset(resources, res, res->start - range.pci_addr);
 379         }
 380
 381         /* Check for dma-ranges property */
 382         if (!ib_resources)
 383                 return 0;
 384         err = of_pci_dma_range_parser_init(&parser, dev_node);
 385         if (err)
 386                 return 0;
 387
 388         dev_dbg(dev, "Parsing dma-ranges property...\n");
 389         for_each_of_pci_range(&parser, &range) {
 390                 /*
 391                  * If we failed translation or got a zero-sized region
 392                  * then skip this range
 393                  */
 394                 if (((range.flags & IORESOURCE_TYPE_BITS) != IORESOURCE_MEM) ||
 395                     range.cpu_addr == OF_BAD_ADDR || range.size == 0)
 396                         continue;
 397
 398                 dev_info(dev, "  %6s %#012llx..%#012llx -> %#012llx\n",
 399                          "IB MEM", range.cpu_addr,
 400                          range.cpu_addr + range.size - 1, range.pci_addr);
 401
 402
 403                 err = of_pci_range_to_resource(&range, dev_node, &tmp_res);
 404                 if (err)
 405                         continue;
 406
 407                 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL);
 408                 if (!res) {
 409                         err = -ENOMEM;
 410                         goto failed;
 411                 }
 412
 413                 pci_add_resource_offset(ib_resources, res,
 414                                         res->start - range.pci_addr);
 415         }
 416
 417         return 0;
 418
 419 failed:
 420         pci_free_resource_list(resources);
 421         return err;
 422 }
 423
 424 #if IS_ENABLED(CONFIG_OF_IRQ)
 425 /**
 426  * of_irq_parse_pci - Resolve the interrupt for a PCI device
 427  * @pdev:       the device whose interrupt is to be resolved
 428  * @out_irq:    structure of_phandle_args filled by this function
 429  *
 430  * This function resolves the PCI interrupt for a given PCI device. If a
 431  * device-node exists for a given pci_dev, it will use normal OF tree
 432  * walking. If not, it will implement standard swizzling and walk up the
 433  * PCI tree until an device-node is found, at which point it will finish
 434  * resolving using the OF tree walking.
 435  */
 436 static int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq)
 437 {
 438         struct device_node *dn, *ppnode = NULL;
 439         struct pci_dev *ppdev;
 440         __be32 laddr[3];
 441         u8 pin;
 442         int rc;
 443
 444         /*
 445          * Check if we have a device node, if yes, fallback to standard
 446          * device tree parsing
 447          */
 448         dn = pci_device_to_OF_node(pdev);
 449         if (dn) {
 450                 rc = of_irq_parse_one(dn, 0, out_irq);
 451                 if (!rc)
 452                         return rc;
 453         }
 454
 455         /*
 456          * Ok, we don't, time to have fun. Let's start by building up an
 457          * interrupt spec.  we assume #interrupt-cells is 1, which is standard
 458          * for PCI. If you do different, then don't use that routine.
 459          */
 460         rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
 461         if (rc != 0)
 462                 goto err;
 463         /* No pin, exit with no error message. */
 464         if (pin == 0)
 465                 return -ENODEV;
 466
 467         /* Local interrupt-map in the device node? Use it! */
 468         if (of_property_present(dn, "interrupt-map")) {
 469                 pin = pci_swizzle_interrupt_pin(pdev, pin);
 470                 ppnode = dn;
 471         }
 472
 473         /* Now we walk up the PCI tree */
 474         while (!ppnode) {
 475                 /* Get the pci_dev of our parent */
 476                 ppdev = pdev->bus->self;
 477
 478                 /* Ouch, it's a host bridge... */
 479                 if (ppdev == NULL) {
 480                         ppnode = pci_bus_to_OF_node(pdev->bus);
 481
 482                         /* No node for host bridge ? give up */
 483                         if (ppnode == NULL) {
 484                                 rc = -EINVAL;
 485                                 goto err;
 486                         }
 487                 } else {
 488                         /* We found a P2P bridge, check if it has a node */
 489                         ppnode = pci_device_to_OF_node(ppdev);
 490                 }
 491
 492                 /*
 493                  * Ok, we have found a parent with a device-node, hand over to
 494                  * the OF parsing code.
 495                  * We build a unit address from the linux device to be used for
 496                  * resolution. Note that we use the linux bus number which may
 497                  * not match your firmware bus numbering.
 498                  * Fortunately, in most cases, interrupt-map-mask doesn't
 499                  * include the bus number as part of the matching.
 500                  * You should still be careful about that though if you intend
 501                  * to rely on this function (you ship a firmware that doesn't
 502                  * create device nodes for all PCI devices).
 503                  */
 504                 if (ppnode)
 505                         break;
 506
 507                 /*
 508                  * We can only get here if we hit a P2P bridge with no node;
 509                  * let's do standard swizzling and try again
 510                  */
 511                 pin = pci_swizzle_interrupt_pin(pdev, pin);
 512                 pdev = ppdev;
 513         }
 514
 515         out_irq->np = ppnode;
 516         out_irq->args_count = 1;
 517         out_irq->args[0] = pin;
 518         laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
 519         laddr[1] = laddr[2] = cpu_to_be32(0);
 520         rc = of_irq_parse_raw(laddr, out_irq);
 521         if (rc)
 522                 goto err;
 523         return 0;
 524 err:
 525         if (rc == -ENOENT) {
 526                 dev_warn(&pdev->dev,
 527                         "%s: no interrupt-map found, INTx interrupts not available\n",
 528                         __func__);
 529                 pr_warn_once("%s: possibly some PCI slots don't have level triggered interrupts capability\n",
 530                         __func__);
 531         } else {
 532                 dev_err(&pdev->dev, "%s: failed with rc=%d\n", __func__, rc);
 533         }
 534         return rc;
 535 }
 536
 537 /**
 538  * of_irq_parse_and_map_pci() - Decode a PCI IRQ from the device tree and map to a VIRQ
 539  * @dev: The PCI device needing an IRQ
 540  * @slot: PCI slot number; passed when used as map_irq callback. Unused
 541  * @pin: PCI IRQ pin number; passed when used as map_irq callback. Unused
 542  *
 543  * @slot and @pin are unused, but included in the function so that this
 544  * function can be used directly as the map_irq callback to
 545  * pci_assign_irq() and struct pci_host_bridge.map_irq pointer
 546  */
 547 int of_irq_parse_and_map_pci(const struct pci_dev *dev, u8 slot, u8 pin)
 548 {
 549         struct of_phandle_args oirq;
 550         int ret;
 551
 552         ret = of_irq_parse_pci(dev, &oirq);
 553         if (ret)
 554                 return 0; /* Proper return code 0 == NO_IRQ */
 555
 556         return irq_create_of_mapping(&oirq);
 557 }
 558 EXPORT_SYMBOL_GPL(of_irq_parse_and_map_pci);
 559 #endif  /* CONFIG_OF_IRQ */
 560
 561 static int pci_parse_request_of_pci_ranges(struct device *dev,
 562                                            struct pci_host_bridge *bridge)
 563 {
 564         int err, res_valid = 0;
 565         resource_size_t iobase;
 566         struct resource_entry *win, *tmp;
 567
 568         INIT_LIST_HEAD(&bridge->windows);
 569         INIT_LIST_HEAD(&bridge->dma_ranges);
 570
 571         err = devm_of_pci_get_host_bridge_resources(dev, 0, 0xff, &bridge->windows,
 572                                                     &bridge->dma_ranges, &iobase);
 573         if (err)
 574                 return err;
 575
 576         err = devm_request_pci_bus_resources(dev, &bridge->windows);
 577         if (err)
 578                 return err;
 579
 580         resource_list_for_each_entry_safe(win, tmp, &bridge->windows) {
 581                 struct resource *res = win->res;
 582
 583                 switch (resource_type(res)) {
 584                 case IORESOURCE_IO:
 585                         err = devm_pci_remap_iospace(dev, res, iobase);
 586                         if (err) {
 587                                 dev_warn(dev, "error %d: failed to map resource %pR\n",
 588                                          err, res);
 589                                 resource_list_destroy_entry(win);
 590                         }
 591                         break;
 592                 case IORESOURCE_MEM:
 593                         res_valid |= !(res->flags & IORESOURCE_PREFETCH);
 594
 595                         if (!(res->flags & IORESOURCE_PREFETCH))
 596                                 if (upper_32_bits(resource_size(res)))
 597                                         dev_warn(dev, "Memory resource size exceeds max for 32 bits\n");
 598
 599                         break;
 600                 }
 601         }
 602
 603         if (!res_valid)
 604                 dev_warn(dev, "non-prefetchable memory resource required\n");
 605
 606         return 0;
 607 }
 608
 609 int devm_of_pci_bridge_init(struct device *dev, struct pci_host_bridge *bridge)
 610 {
 611         if (!dev->of_node)
 612                 return 0;
 613
 614         bridge->swizzle_irq = pci_common_swizzle;
 615         bridge->map_irq = of_irq_parse_and_map_pci;
 616
 617         return pci_parse_request_of_pci_ranges(dev, bridge);
 618 }
 619
 620 #endif /* CONFIG_PCI */
 621
 622 /**
 623  * of_pci_get_max_link_speed - Find the maximum link speed of the given device node.
 624  * @node: Device tree node with the maximum link speed information.
 625  *
 626  * This function will try to find the limitation of link speed by finding
 627  * a property called "max-link-speed" of the given device node.
 628  *
 629  * Return:
 630  * * > 0        - On success, a maximum link speed.
 631  * * -EINVAL    - Invalid "max-link-speed" property value, or failure to access
 632  *                the property of the device tree node.
 633  *
 634  * Returns the associated max link speed from DT, or a negative value if the
 635  * required property is not found or is invalid.
 636  */
 637 int of_pci_get_max_link_speed(struct device_node *node)
 638 {
 639         u32 max_link_speed;
 640
 641         if (of_property_read_u32(node, "max-link-speed", &max_link_speed) ||
 642             max_link_speed == 0 || max_link_speed > 4)
 643                 return -EINVAL;
 644
 645         return max_link_speed;
 646 }
 647 EXPORT_SYMBOL_GPL(of_pci_get_max_link_speed);
 648
 649 /**
 650  * of_pci_get_slot_power_limit - Parses the "slot-power-limit-milliwatt"
 651  *                               property.
 652  *
 653  * @node: device tree node with the slot power limit information
 654  * @slot_power_limit_value: pointer where the value should be stored in PCIe
 655  *                          Slot Capabilities Register format
 656  * @slot_power_limit_scale: pointer where the scale should be stored in PCIe
 657  *                          Slot Capabilities Register format
 658  *
 659  * Returns the slot power limit in milliwatts and if @slot_power_limit_value
 660  * and @slot_power_limit_scale pointers are non-NULL, fills in the value and
 661  * scale in format used by PCIe Slot Capabilities Register.
 662  *
 663  * If the property is not found or is invalid, returns 0.
 664  */
 665 u32 of_pci_get_slot_power_limit(struct device_node *node,
 666                                 u8 *slot_power_limit_value,
 667                                 u8 *slot_power_limit_scale)
 668 {
 669         u32 slot_power_limit_mw;
 670         u8 value, scale;
 671
 672         if (of_property_read_u32(node, "slot-power-limit-milliwatt",
 673                                  &slot_power_limit_mw))
 674                 slot_power_limit_mw = 0;
 675
 676         /* Calculate Slot Power Limit Value and Slot Power Limit Scale */
 677         if (slot_power_limit_mw == 0) {
 678                 value = 0x00;
 679                 scale = 0;
 680         } else if (slot_power_limit_mw <= 255) {
 681                 value = slot_power_limit_mw;
 682                 scale = 3;
 683         } else if (slot_power_limit_mw <= 255*10) {
 684                 value = slot_power_limit_mw / 10;
 685                 scale = 2;
 686                 slot_power_limit_mw = slot_power_limit_mw / 10 * 10;
 687         } else if (slot_power_limit_mw <= 255*100) {
 688                 value = slot_power_limit_mw / 100;
 689                 scale = 1;
 690                 slot_power_limit_mw = slot_power_limit_mw / 100 * 100;
 691         } else if (slot_power_limit_mw <= 239*1000) {
 692                 value = slot_power_limit_mw / 1000;
 693                 scale = 0;
 694                 slot_power_limit_mw = slot_power_limit_mw / 1000 * 1000;
 695         } else if (slot_power_limit_mw < 250*1000) {
 696                 value = 0xEF;
 697                 scale = 0;
 698                 slot_power_limit_mw = 239*1000;
 699         } else if (slot_power_limit_mw <= 600*1000) {
 700                 value = 0xF0 + (slot_power_limit_mw / 1000 - 250) / 25;
 701                 scale = 0;
 702                 slot_power_limit_mw = slot_power_limit_mw / (1000*25) * (1000*25);
 703         } else {
 704                 value = 0xFE;
 705                 scale = 0;
 706                 slot_power_limit_mw = 600*1000;
 707         }
 708
 709         if (slot_power_limit_value)
 710                 *slot_power_limit_value = value;
 711
 712         if (slot_power_limit_scale)
 713                 *slot_power_limit_scale = scale;
 714
 715         return slot_power_limit_mw;
 716 }
 717 EXPORT_SYMBOL_GPL(of_pci_get_slot_power_limit);