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