LXR linux/drivers/of/of

   1#include <linux/kernel.h>
   2#include <linux/export.h>
   3#include <linux/of.h>
   4#include <linux/of_address.h>
   5#include <linux/of_device.h>
   6#include <linux/of_pci.h>
   7#include <linux/slab.h>
   8#include <asm-generic/pci-bridge.h>
   9
  10static inline int __of_pci_pci_compare(struct device_node *node,
  11                                       unsigned int data)
  12{
  13        int devfn;
  14
  15        devfn = of_pci_get_devfn(node);
  16        if (devfn < 0)
  17                return 0;
  18
  19        return devfn == data;
  20}
  21
  22struct device_node *of_pci_find_child_device(struct device_node *parent,
  23                                             unsigned int devfn)
  24{
  25        struct device_node *node, *node2;
  26
  27        for_each_child_of_node(parent, node) {
  28                if (__of_pci_pci_compare(node, devfn))
  29                        return node;
  30                /*
  31                 * Some OFs create a parent node "multifunc-device" as
  32                 * a fake root for all functions of a multi-function
  33                 * device we go down them as well.
  34                 */
  35                if (!strcmp(node->name, "multifunc-device")) {
  36                        for_each_child_of_node(node, node2) {
  37                                if (__of_pci_pci_compare(node2, devfn)) {
  38                                        of_node_put(node);
  39                                        return node2;
  40                                }
  41                        }
  42                }
  43        }
  44        return NULL;
  45}
  46EXPORT_SYMBOL_GPL(of_pci_find_child_device);
  47
  48/**
  49 * of_pci_get_devfn() - Get device and function numbers for a device node
  50 * @np: device node
  51 *
  52 * Parses a standard 5-cell PCI resource and returns an 8-bit value that can
  53 * be passed to the PCI_SLOT() and PCI_FUNC() macros to extract the device
  54 * and function numbers respectively. On error a negative error code is
  55 * returned.
  56 */
  57int of_pci_get_devfn(struct device_node *np)
  58{
  59        unsigned int size;
  60        const __be32 *reg;
  61
  62        reg = of_get_property(np, "reg", &size);
  63
  64        if (!reg || size < 5 * sizeof(__be32))
  65                return -EINVAL;
  66
  67        return (be32_to_cpup(reg) >> 8) & 0xff;
  68}
  69EXPORT_SYMBOL_GPL(of_pci_get_devfn);
  70
  71/**
  72 * of_pci_parse_bus_range() - parse the bus-range property of a PCI device
  73 * @node: device node
  74 * @res: address to a struct resource to return the bus-range
  75 *
  76 * Returns 0 on success or a negative error-code on failure.
  77 */
  78int of_pci_parse_bus_range(struct device_node *node, struct resource *res)
  79{
  80        const __be32 *values;
  81        int len;
  82
  83        values = of_get_property(node, "bus-range", &len);
  84        if (!values || len < sizeof(*values) * 2)
  85                return -EINVAL;
  86
  87        res->name = node->name;
  88        res->start = be32_to_cpup(values++);
  89        res->end = be32_to_cpup(values);
  90        res->flags = IORESOURCE_BUS;
  91
  92        return 0;
  93}
  94EXPORT_SYMBOL_GPL(of_pci_parse_bus_range);
  95
  96/**
  97 * This function will try to obtain the host bridge domain number by
  98 * finding a property called "linux,pci-domain" of the given device node.
  99 *
 100 * @node: device tree node with the domain information
 101 *
 102 * Returns the associated domain number from DT in the range [0-0xffff], or
 103 * a negative value if the required property is not found.
 104 */
 105int of_get_pci_domain_nr(struct device_node *node)
 106{
 107        const __be32 *value;
 108        int len;
 109        u16 domain;
 110
 111        value = of_get_property(node, "linux,pci-domain", &len);
 112        if (!value || len < sizeof(*value))
 113                return -EINVAL;
 114
 115        domain = (u16)be32_to_cpup(value);
 116
 117        return domain;
 118}
 119EXPORT_SYMBOL_GPL(of_get_pci_domain_nr);
 120
 121/**
 122 * of_pci_check_probe_only - Setup probe only mode if linux,pci-probe-only
 123 *                           is present and valid
 124 */
 125void of_pci_check_probe_only(void)
 126{
 127        u32 val;
 128        int ret;
 129
 130        ret = of_property_read_u32(of_chosen, "linux,pci-probe-only", &val);
 131        if (ret) {
 132                if (ret == -ENODATA || ret == -EOVERFLOW)
 133                        pr_warn("linux,pci-probe-only without valid value, ignoring\n");
 134                return;
 135        }
 136
 137        if (val)
 138                pci_add_flags(PCI_PROBE_ONLY);
 139        else
 140                pci_clear_flags(PCI_PROBE_ONLY);
 141
 142        pr_info("PCI: PROBE_ONLY %sabled\n", val ? "en" : "dis");
 143}
 144EXPORT_SYMBOL_GPL(of_pci_check_probe_only);
 145
 146#if defined(CONFIG_OF_ADDRESS)
 147/**
 148 * of_pci_get_host_bridge_resources - Parse PCI host bridge resources from DT
 149 * @dev: device node of the host bridge having the range property
 150 * @busno: bus number associated with the bridge root bus
 151 * @bus_max: maximum number of buses for this bridge
 152 * @resources: list where the range of resources will be added after DT parsing
 153 * @io_base: pointer to a variable that will contain on return the physical
 154 * address for the start of the I/O range. Can be NULL if the caller doesn't
 155 * expect IO ranges to be present in the device tree.
 156 *
 157 * It is the caller's job to free the @resources list.
 158 *
 159 * This function will parse the "ranges" property of a PCI host bridge device
 160 * node and setup the resource mapping based on its content. It is expected
 161 * that the property conforms with the Power ePAPR document.
 162 *
 163 * It returns zero if the range parsing has been successful or a standard error
 164 * value if it failed.
 165 */
 166int of_pci_get_host_bridge_resources(struct device_node *dev,
 167                        unsigned char busno, unsigned char bus_max,
 168                        struct list_head *resources, resource_size_t *io_base)
 169{
 170        struct resource_entry *window;
 171        struct resource *res;
 172        struct resource *bus_range;
 173        struct of_pci_range range;
 174        struct of_pci_range_parser parser;
 175        char range_type[4];
 176        int err;
 177
 178        if (io_base)
 179                *io_base = (resource_size_t)OF_BAD_ADDR;
 180
 181        bus_range = kzalloc(sizeof(*bus_range), GFP_KERNEL);
 182        if (!bus_range)
 183                return -ENOMEM;
 184
 185        pr_info("PCI host bridge %s ranges:\n", dev->full_name);
 186
 187        err = of_pci_parse_bus_range(dev, bus_range);
 188        if (err) {
 189                bus_range->start = busno;
 190                bus_range->end = bus_max;
 191                bus_range->flags = IORESOURCE_BUS;
 192                pr_info("  No bus range found for %s, using %pR\n",
 193                        dev->full_name, bus_range);
 194        } else {
 195                if (bus_range->end > bus_range->start + bus_max)
 196                        bus_range->end = bus_range->start + bus_max;
 197        }
 198        pci_add_resource(resources, bus_range);
 199
 200        /* Check for ranges property */
 201        err = of_pci_range_parser_init(&parser, dev);
 202        if (err)
 203                goto parse_failed;
 204
 205        pr_debug("Parsing ranges property...\n");
 206        for_each_of_pci_range(&parser, &range) {
 207                /* Read next ranges element */
 208                if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
 209                        snprintf(range_type, 4, " IO");
 210                else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
 211                        snprintf(range_type, 4, "MEM");
 212                else
 213                        snprintf(range_type, 4, "err");
 214                pr_info("  %s %#010llx..%#010llx -> %#010llx\n", range_type,
 215                        range.cpu_addr, range.cpu_addr + range.size - 1,
 216                        range.pci_addr);
 217
 218                /*
 219                 * If we failed translation or got a zero-sized region
 220                 * then skip this range
 221                 */
 222                if (range.cpu_addr == OF_BAD_ADDR || range.size == 0)
 223                        continue;
 224
 225                res = kzalloc(sizeof(struct resource), GFP_KERNEL);
 226                if (!res) {
 227                        err = -ENOMEM;
 228                        goto parse_failed;
 229                }
 230
 231                err = of_pci_range_to_resource(&range, dev, res);
 232                if (err) {
 233                        kfree(res);
 234                        continue;
 235                }
 236
 237                if (resource_type(res) == IORESOURCE_IO) {
 238                        if (!io_base) {
 239                                pr_err("I/O range found for %s. Please provide an io_base pointer to save CPU base address\n",
 240                                        dev->full_name);
 241                                err = -EINVAL;
 242                                goto conversion_failed;
 243                        }
 244                        if (*io_base != (resource_size_t)OF_BAD_ADDR)
 245                                pr_warn("More than one I/O resource converted for %s. CPU base address for old range lost!\n",
 246                                        dev->full_name);
 247                        *io_base = range.cpu_addr;
 248                }
 249
 250                pci_add_resource_offset(resources, res, res->start - range.pci_addr);
 251        }
 252
 253        return 0;
 254
 255conversion_failed:
 256        kfree(res);
 257parse_failed:
 258        resource_list_for_each_entry(window, resources)
 259                kfree(window->res);
 260        pci_free_resource_list(resources);
 261        return err;
 262}
 263EXPORT_SYMBOL_GPL(of_pci_get_host_bridge_resources);
 264#endif /* CONFIG_OF_ADDRESS */
 265
 266#ifdef CONFIG_PCI_MSI
 267
 268static LIST_HEAD(of_pci_msi_chip_list);
 269static DEFINE_MUTEX(of_pci_msi_chip_mutex);
 270
 271int of_pci_msi_chip_add(struct msi_controller *chip)
 272{
 273        if (!of_property_read_bool(chip->of_node, "msi-controller"))
 274                return -EINVAL;
 275
 276        mutex_lock(&of_pci_msi_chip_mutex);
 277        list_add(&chip->list, &of_pci_msi_chip_list);
 278        mutex_unlock(&of_pci_msi_chip_mutex);
 279
 280        return 0;
 281}
 282EXPORT_SYMBOL_GPL(of_pci_msi_chip_add);
 283
 284void of_pci_msi_chip_remove(struct msi_controller *chip)
 285{
 286        mutex_lock(&of_pci_msi_chip_mutex);
 287        list_del(&chip->list);
 288        mutex_unlock(&of_pci_msi_chip_mutex);
 289}
 290EXPORT_SYMBOL_GPL(of_pci_msi_chip_remove);
 291
 292struct msi_controller *of_pci_find_msi_chip_by_node(struct device_node *of_node)
 293{
 294        struct msi_controller *c;
 295
 296        mutex_lock(&of_pci_msi_chip_mutex);
 297        list_for_each_entry(c, &of_pci_msi_chip_list, list) {
 298                if (c->of_node == of_node) {
 299                        mutex_unlock(&of_pci_msi_chip_mutex);
 300                        return c;
 301                }
 302        }
 303        mutex_unlock(&of_pci_msi_chip_mutex);
 304
 305        return NULL;
 306}
 307EXPORT_SYMBOL_GPL(of_pci_find_msi_chip_by_node);
 308
 309#endif /* CONFIG_PCI_MSI */
 310