GNU Linux-libre 5.10.219-gnu1
[releases.git] / 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 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->external_facing = 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 /**
240  * devm_of_pci_get_host_bridge_resources() - Resource-managed parsing of PCI
241  *                                           host bridge resources from DT
242  * @dev: host bridge device
243  * @busno: bus number associated with the bridge root bus
244  * @bus_max: maximum number of buses for this bridge
245  * @resources: list where the range of resources will be added after DT parsing
246  * @ib_resources: list where the range of inbound resources (with addresses
247  *                from 'dma-ranges') will be added after DT parsing
248  * @io_base: pointer to a variable that will contain on return the physical
249  * address for the start of the I/O range. Can be NULL if the caller doesn't
250  * expect I/O ranges to be present in the device tree.
251  *
252  * This function will parse the "ranges" property of a PCI host bridge device
253  * node and setup the resource mapping based on its content. It is expected
254  * that the property conforms with the Power ePAPR document.
255  *
256  * It returns zero if the range parsing has been successful or a standard error
257  * value if it failed.
258  */
259 static int devm_of_pci_get_host_bridge_resources(struct device *dev,
260                         unsigned char busno, unsigned char bus_max,
261                         struct list_head *resources,
262                         struct list_head *ib_resources,
263                         resource_size_t *io_base)
264 {
265         struct device_node *dev_node = dev->of_node;
266         struct resource *res, tmp_res;
267         struct resource *bus_range;
268         struct of_pci_range range;
269         struct of_pci_range_parser parser;
270         const char *range_type;
271         int err;
272
273         if (io_base)
274                 *io_base = (resource_size_t)OF_BAD_ADDR;
275
276         bus_range = devm_kzalloc(dev, sizeof(*bus_range), GFP_KERNEL);
277         if (!bus_range)
278                 return -ENOMEM;
279
280         dev_info(dev, "host bridge %pOF ranges:\n", dev_node);
281
282         err = of_pci_parse_bus_range(dev_node, bus_range);
283         if (err) {
284                 bus_range->start = busno;
285                 bus_range->end = bus_max;
286                 bus_range->flags = IORESOURCE_BUS;
287                 dev_info(dev, "  No bus range found for %pOF, using %pR\n",
288                          dev_node, bus_range);
289         } else {
290                 if (bus_range->end > bus_range->start + bus_max)
291                         bus_range->end = bus_range->start + bus_max;
292         }
293         pci_add_resource(resources, bus_range);
294
295         /* Check for ranges property */
296         err = of_pci_range_parser_init(&parser, dev_node);
297         if (err)
298                 return 0;
299
300         dev_dbg(dev, "Parsing ranges property...\n");
301         for_each_of_pci_range(&parser, &range) {
302                 /* Read next ranges element */
303                 if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_IO)
304                         range_type = "IO";
305                 else if ((range.flags & IORESOURCE_TYPE_BITS) == IORESOURCE_MEM)
306                         range_type = "MEM";
307                 else
308                         range_type = "err";
309                 dev_info(dev, "  %6s %#012llx..%#012llx -> %#012llx\n",
310                          range_type, range.cpu_addr,
311                          range.cpu_addr + range.size - 1, range.pci_addr);
312
313                 /*
314                  * If we failed translation or got a zero-sized region
315                  * then skip this range
316                  */
317                 if (range.cpu_addr == OF_BAD_ADDR || range.size == 0)
318                         continue;
319
320                 err = of_pci_range_to_resource(&range, dev_node, &tmp_res);
321                 if (err)
322                         continue;
323
324                 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL);
325                 if (!res) {
326                         err = -ENOMEM;
327                         goto failed;
328                 }
329
330                 if (resource_type(res) == IORESOURCE_IO) {
331                         if (!io_base) {
332                                 dev_err(dev, "I/O range found for %pOF. Please provide an io_base pointer to save CPU base address\n",
333                                         dev_node);
334                                 err = -EINVAL;
335                                 goto failed;
336                         }
337                         if (*io_base != (resource_size_t)OF_BAD_ADDR)
338                                 dev_warn(dev, "More than one I/O resource converted for %pOF. CPU base address for old range lost!\n",
339                                          dev_node);
340                         *io_base = range.cpu_addr;
341                 }
342
343                 pci_add_resource_offset(resources, res, res->start - range.pci_addr);
344         }
345
346         /* Check for dma-ranges property */
347         if (!ib_resources)
348                 return 0;
349         err = of_pci_dma_range_parser_init(&parser, dev_node);
350         if (err)
351                 return 0;
352
353         dev_dbg(dev, "Parsing dma-ranges property...\n");
354         for_each_of_pci_range(&parser, &range) {
355                 struct resource_entry *entry;
356                 /*
357                  * If we failed translation or got a zero-sized region
358                  * then skip this range
359                  */
360                 if (((range.flags & IORESOURCE_TYPE_BITS) != IORESOURCE_MEM) ||
361                     range.cpu_addr == OF_BAD_ADDR || range.size == 0)
362                         continue;
363
364                 dev_info(dev, "  %6s %#012llx..%#012llx -> %#012llx\n",
365                          "IB MEM", range.cpu_addr,
366                          range.cpu_addr + range.size - 1, range.pci_addr);
367
368
369                 err = of_pci_range_to_resource(&range, dev_node, &tmp_res);
370                 if (err)
371                         continue;
372
373                 res = devm_kmemdup(dev, &tmp_res, sizeof(tmp_res), GFP_KERNEL);
374                 if (!res) {
375                         err = -ENOMEM;
376                         goto failed;
377                 }
378
379                 /* Keep the resource list sorted */
380                 resource_list_for_each_entry(entry, ib_resources)
381                         if (entry->res->start > res->start)
382                                 break;
383
384                 pci_add_resource_offset(&entry->node, res,
385                                         res->start - range.pci_addr);
386         }
387
388         return 0;
389
390 failed:
391         pci_free_resource_list(resources);
392         return err;
393 }
394
395 #if IS_ENABLED(CONFIG_OF_IRQ)
396 /**
397  * of_irq_parse_pci - Resolve the interrupt for a PCI device
398  * @pdev:       the device whose interrupt is to be resolved
399  * @out_irq:    structure of_phandle_args filled by this function
400  *
401  * This function resolves the PCI interrupt for a given PCI device. If a
402  * device-node exists for a given pci_dev, it will use normal OF tree
403  * walking. If not, it will implement standard swizzling and walk up the
404  * PCI tree until an device-node is found, at which point it will finish
405  * resolving using the OF tree walking.
406  */
407 static int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq)
408 {
409         struct device_node *dn, *ppnode;
410         struct pci_dev *ppdev;
411         __be32 laddr[3];
412         u8 pin;
413         int rc;
414
415         /*
416          * Check if we have a device node, if yes, fallback to standard
417          * device tree parsing
418          */
419         dn = pci_device_to_OF_node(pdev);
420         if (dn) {
421                 rc = of_irq_parse_one(dn, 0, out_irq);
422                 if (!rc)
423                         return rc;
424         }
425
426         /*
427          * Ok, we don't, time to have fun. Let's start by building up an
428          * interrupt spec.  we assume #interrupt-cells is 1, which is standard
429          * for PCI. If you do different, then don't use that routine.
430          */
431         rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin);
432         if (rc != 0)
433                 goto err;
434         /* No pin, exit with no error message. */
435         if (pin == 0)
436                 return -ENODEV;
437
438         /* Now we walk up the PCI tree */
439         for (;;) {
440                 /* Get the pci_dev of our parent */
441                 ppdev = pdev->bus->self;
442
443                 /* Ouch, it's a host bridge... */
444                 if (ppdev == NULL) {
445                         ppnode = pci_bus_to_OF_node(pdev->bus);
446
447                         /* No node for host bridge ? give up */
448                         if (ppnode == NULL) {
449                                 rc = -EINVAL;
450                                 goto err;
451                         }
452                 } else {
453                         /* We found a P2P bridge, check if it has a node */
454                         ppnode = pci_device_to_OF_node(ppdev);
455                 }
456
457                 /*
458                  * Ok, we have found a parent with a device-node, hand over to
459                  * the OF parsing code.
460                  * We build a unit address from the linux device to be used for
461                  * resolution. Note that we use the linux bus number which may
462                  * not match your firmware bus numbering.
463                  * Fortunately, in most cases, interrupt-map-mask doesn't
464                  * include the bus number as part of the matching.
465                  * You should still be careful about that though if you intend
466                  * to rely on this function (you ship a firmware that doesn't
467                  * create device nodes for all PCI devices).
468                  */
469                 if (ppnode)
470                         break;
471
472                 /*
473                  * We can only get here if we hit a P2P bridge with no node;
474                  * let's do standard swizzling and try again
475                  */
476                 pin = pci_swizzle_interrupt_pin(pdev, pin);
477                 pdev = ppdev;
478         }
479
480         out_irq->np = ppnode;
481         out_irq->args_count = 1;
482         out_irq->args[0] = pin;
483         laddr[0] = cpu_to_be32((pdev->bus->number << 16) | (pdev->devfn << 8));
484         laddr[1] = laddr[2] = cpu_to_be32(0);
485         rc = of_irq_parse_raw(laddr, out_irq);
486         if (rc)
487                 goto err;
488         return 0;
489 err:
490         if (rc == -ENOENT) {
491                 dev_warn(&pdev->dev,
492                         "%s: no interrupt-map found, INTx interrupts not available\n",
493                         __func__);
494                 pr_warn_once("%s: possibly some PCI slots don't have level triggered interrupts capability\n",
495                         __func__);
496         } else {
497                 dev_err(&pdev->dev, "%s: failed with rc=%d\n", __func__, rc);
498         }
499         return rc;
500 }
501
502 /**
503  * of_irq_parse_and_map_pci() - Decode a PCI IRQ from the device tree and map to a VIRQ
504  * @dev: The PCI device needing an IRQ
505  * @slot: PCI slot number; passed when used as map_irq callback. Unused
506  * @pin: PCI IRQ pin number; passed when used as map_irq callback. Unused
507  *
508  * @slot and @pin are unused, but included in the function so that this
509  * function can be used directly as the map_irq callback to
510  * pci_assign_irq() and struct pci_host_bridge.map_irq pointer
511  */
512 int of_irq_parse_and_map_pci(const struct pci_dev *dev, u8 slot, u8 pin)
513 {
514         struct of_phandle_args oirq;
515         int ret;
516
517         ret = of_irq_parse_pci(dev, &oirq);
518         if (ret)
519                 return 0; /* Proper return code 0 == NO_IRQ */
520
521         return irq_create_of_mapping(&oirq);
522 }
523 EXPORT_SYMBOL_GPL(of_irq_parse_and_map_pci);
524 #endif  /* CONFIG_OF_IRQ */
525
526 static int pci_parse_request_of_pci_ranges(struct device *dev,
527                                            struct pci_host_bridge *bridge)
528 {
529         int err, res_valid = 0;
530         resource_size_t iobase;
531         struct resource_entry *win, *tmp;
532
533         INIT_LIST_HEAD(&bridge->windows);
534         INIT_LIST_HEAD(&bridge->dma_ranges);
535
536         err = devm_of_pci_get_host_bridge_resources(dev, 0, 0xff, &bridge->windows,
537                                                     &bridge->dma_ranges, &iobase);
538         if (err)
539                 return err;
540
541         err = devm_request_pci_bus_resources(dev, &bridge->windows);
542         if (err)
543                 return err;
544
545         resource_list_for_each_entry_safe(win, tmp, &bridge->windows) {
546                 struct resource *res = win->res;
547
548                 switch (resource_type(res)) {
549                 case IORESOURCE_IO:
550                         err = devm_pci_remap_iospace(dev, res, iobase);
551                         if (err) {
552                                 dev_warn(dev, "error %d: failed to map resource %pR\n",
553                                          err, res);
554                                 resource_list_destroy_entry(win);
555                         }
556                         break;
557                 case IORESOURCE_MEM:
558                         res_valid |= !(res->flags & IORESOURCE_PREFETCH);
559                         break;
560                 }
561         }
562
563         if (!res_valid)
564                 dev_warn(dev, "non-prefetchable memory resource required\n");
565
566         return 0;
567 }
568
569 int devm_of_pci_bridge_init(struct device *dev, struct pci_host_bridge *bridge)
570 {
571         if (!dev->of_node)
572                 return 0;
573
574         bridge->swizzle_irq = pci_common_swizzle;
575         bridge->map_irq = of_irq_parse_and_map_pci;
576
577         return pci_parse_request_of_pci_ranges(dev, bridge);
578 }
579
580 #endif /* CONFIG_PCI */
581
582 /**
583  * This function will try to find the limitation of link speed by finding
584  * a property called "max-link-speed" of the given device node.
585  *
586  * @node: device tree node with the max link speed information
587  *
588  * Returns the associated max link speed from DT, or a negative value if the
589  * required property is not found or is invalid.
590  */
591 int of_pci_get_max_link_speed(struct device_node *node)
592 {
593         u32 max_link_speed;
594
595         if (of_property_read_u32(node, "max-link-speed", &max_link_speed) ||
596             max_link_speed == 0 || max_link_speed > 4)
597                 return -EINVAL;
598
599         return max_link_speed;
600 }
601 EXPORT_SYMBOL_GPL(of_pci_get_max_link_speed);