LCOV - code coverage report
Current view: top level - drivers/pci - of.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 4 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 1 0.0 %
Branches: 0 4 0.0 %

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

Generated by: LCOV version 1.14