platform.c 19.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
S
Stephen Rothwell 已提交
2 3 4 5 6 7 8
/*
 *    Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
 *			 <benh@kernel.crashing.org>
 *    and		 Arnd Bergmann, IBM Corp.
 *    Merged from powerpc/kernel/of_platform.c and
 *    sparc{,64}/kernel/of_device.c by Stephen Rothwell
 */
9 10 11

#define pr_fmt(fmt)	"OF: " fmt

S
Stephen Rothwell 已提交
12
#include <linux/errno.h>
13
#include <linux/module.h>
14
#include <linux/amba/bus.h>
S
Stephen Rothwell 已提交
15
#include <linux/device.h>
16
#include <linux/dma-mapping.h>
G
Grant Likely 已提交
17
#include <linux/slab.h>
18
#include <linux/of_address.h>
S
Stephen Rothwell 已提交
19
#include <linux/of_device.h>
20
#include <linux/of_iommu.h>
21
#include <linux/of_irq.h>
S
Stephen Rothwell 已提交
22
#include <linux/of_platform.h>
23 24
#include <linux/platform_device.h>

25 26
const struct of_device_id of_default_bus_match_table[] = {
	{ .compatible = "simple-bus", },
27
	{ .compatible = "simple-mfd", },
28
	{ .compatible = "isa", },
29 30 31 32 33 34
#ifdef CONFIG_ARM_AMBA
	{ .compatible = "arm,amba-bus", },
#endif /* CONFIG_ARM_AMBA */
	{} /* Empty terminated list */
};

35 36 37 38 39
static const struct of_device_id of_skipped_node_table[] = {
	{ .compatible = "operating-points-v2", },
	{} /* Empty terminated list */
};

40 41 42 43 44 45 46 47 48
static int of_dev_node_match(struct device *dev, void *data)
{
	return dev->of_node == data;
}

/**
 * of_find_device_by_node - Find the platform_device associated with a node
 * @np: Pointer to device tree node
 *
49 50 51
 * Takes a reference to the embedded struct device which needs to be dropped
 * after use.
 *
52 53 54 55 56 57 58 59 60 61 62
 * Returns platform_device pointer, or NULL if not found
 */
struct platform_device *of_find_device_by_node(struct device_node *np)
{
	struct device *dev;

	dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
	return dev ? to_platform_device(dev) : NULL;
}
EXPORT_SYMBOL(of_find_device_by_node);

63
#ifdef CONFIG_OF_ADDRESS
64 65 66 67 68 69 70 71
/*
 * The following routines scan a subtree and registers a device for
 * each applicable node.
 *
 * Note: sparc doesn't use these routines because it has a different
 * mechanism for creating devices from device tree nodes.
 */

72 73 74 75
/**
 * of_device_make_bus_id - Use the device node data to assign a unique name
 * @dev: pointer to device structure that is linked to a device tree node
 *
76 77 78
 * This routine will first try using the translated bus address to
 * derive a unique name. If it cannot, then it will prepend names from
 * parent nodes until a unique name can be derived.
79
 */
80
static void of_device_make_bus_id(struct device *dev)
81 82
{
	struct device_node *node = dev->of_node;
K
Kim Phillips 已提交
83
	const __be32 *reg;
84 85
	u64 addr;

86 87 88 89 90 91 92 93 94 95 96
	/* Construct the name, using parent nodes if necessary to ensure uniqueness */
	while (node->parent) {
		/*
		 * If the address can be translated, then that is as much
		 * uniqueness as we need. Make it the first component and return
		 */
		reg = of_get_property(node, "reg", NULL);
		if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) {
			dev_set_name(dev, dev_name(dev) ? "%llx.%s:%s" : "%llx.%s",
				     (unsigned long long)addr, node->name,
				     dev_name(dev));
97 98 99
			return;
		}

100 101
		/* format arguments only used if dev_name() resolves to NULL */
		dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s",
102
			     kbasename(node->full_name), dev_name(dev));
103 104
		node = node->parent;
	}
105 106 107 108 109 110 111 112
}

/**
 * of_device_alloc - Allocate and initialize an of_device
 * @np: device node to assign to device
 * @bus_id: Name to assign to the device.  May be null to use default name.
 * @parent: Parent device.
 */
113
struct platform_device *of_device_alloc(struct device_node *np,
114 115 116
				  const char *bus_id,
				  struct device *parent)
{
117
	struct platform_device *dev;
118
	int rc, i, num_reg = 0, num_irq;
119 120
	struct resource *res, temp_res;

121
	dev = platform_device_alloc("", PLATFORM_DEVID_NONE);
122 123 124 125
	if (!dev)
		return NULL;

	/* count the io and irq resources */
126 127
	while (of_address_to_resource(np, num_reg, &temp_res) == 0)
		num_reg++;
128
	num_irq = of_irq_count(np);
129 130 131

	/* Populate the resource table */
	if (num_irq || num_reg) {
K
Kees Cook 已提交
132
		res = kcalloc(num_irq + num_reg, sizeof(*res), GFP_KERNEL);
133 134 135 136 137
		if (!res) {
			platform_device_put(dev);
			return NULL;
		}

138 139 140 141 142 143
		dev->num_resources = num_reg + num_irq;
		dev->resource = res;
		for (i = 0; i < num_reg; i++, res++) {
			rc = of_address_to_resource(np, i, res);
			WARN_ON(rc);
		}
144 145 146
		if (of_irq_to_resource_table(np, res, num_irq) != num_irq)
			pr_debug("not all legacy IRQ resources mapped for %s\n",
				 np->name);
147
	}
148 149

	dev->dev.of_node = of_node_get(np);
150
	dev->dev.fwnode = &np->fwnode;
151
	dev->dev.parent = parent ? : &platform_bus;
152 153 154 155 156 157 158 159 160 161

	if (bus_id)
		dev_set_name(&dev->dev, "%s", bus_id);
	else
		of_device_make_bus_id(&dev->dev);

	return dev;
}
EXPORT_SYMBOL(of_device_alloc);

162
/**
163
 * of_platform_device_create_pdata - Alloc, initialize and register an of_device
164 165
 * @np: pointer to node to create device for
 * @bus_id: name to assign device
166
 * @platform_data: pointer to populate platform_data pointer with
167
 * @parent: Linux device model parent device.
168 169 170
 *
 * Returns pointer to created platform device, or NULL if a device was not
 * registered.  Unavailable devices will not get registered.
171
 */
172
static struct platform_device *of_platform_device_create_pdata(
173 174 175 176
					struct device_node *np,
					const char *bus_id,
					void *platform_data,
					struct device *parent)
177
{
178
	struct platform_device *dev;
179

180 181
	if (!of_device_is_available(np) ||
	    of_node_test_and_set_flag(np, OF_POPULATED))
182 183
		return NULL;

184 185
	dev = of_device_alloc(np, bus_id, parent);
	if (!dev)
186
		goto err_clear_flag;
187

188 189 190
	dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
	if (!dev->dev.dma_mask)
		dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
191
	dev->dev.bus = &platform_bus_type;
192
	dev->dev.platform_data = platform_data;
193
	of_msi_configure(&dev->dev, dev->dev.of_node);
194

195 196
	if (of_device_add(dev) != 0) {
		platform_device_put(dev);
197
		goto err_clear_flag;
198 199 200
	}

	return dev;
201 202 203 204

err_clear_flag:
	of_node_clear_flag(np, OF_POPULATED);
	return NULL;
205
}
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221

/**
 * of_platform_device_create - Alloc, initialize and register an of_device
 * @np: pointer to node to create device for
 * @bus_id: name to assign device
 * @parent: Linux device model parent device.
 *
 * Returns pointer to created platform device, or NULL if a device was not
 * registered.  Unavailable devices will not get registered.
 */
struct platform_device *of_platform_device_create(struct device_node *np,
					    const char *bus_id,
					    struct device *parent)
{
	return of_platform_device_create_pdata(np, bus_id, NULL, parent);
}
222 223
EXPORT_SYMBOL(of_platform_device_create);

224 225 226 227 228 229 230 231 232 233
#ifdef CONFIG_ARM_AMBA
static struct amba_device *of_amba_device_create(struct device_node *node,
						 const char *bus_id,
						 void *platform_data,
						 struct device *parent)
{
	struct amba_device *dev;
	const void *prop;
	int i, ret;

234
	pr_debug("Creating amba device %pOF\n", node);
235

236 237
	if (!of_device_is_available(node) ||
	    of_node_test_and_set_flag(node, OF_POPULATED))
238 239
		return NULL;

240
	dev = amba_device_alloc(NULL, 0, 0);
241
	if (!dev)
242
		goto err_clear_flag;
243 244 245

	/* setup generic device info */
	dev->dev.of_node = of_node_get(node);
246
	dev->dev.fwnode = &node->fwnode;
247
	dev->dev.parent = parent ? : &platform_bus;
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	dev->dev.platform_data = platform_data;
	if (bus_id)
		dev_set_name(&dev->dev, "%s", bus_id);
	else
		of_device_make_bus_id(&dev->dev);

	/* Allow the HW Peripheral ID to be overridden */
	prop = of_get_property(node, "arm,primecell-periphid", NULL);
	if (prop)
		dev->periphid = of_read_ulong(prop, 1);

	/* Decode the IRQs and address ranges */
	for (i = 0; i < AMBA_NR_IRQS; i++)
		dev->irq[i] = irq_of_parse_and_map(node, i);

	ret = of_address_to_resource(node, 0, &dev->res);
264
	if (ret) {
265 266
		pr_err("amba: of_address_to_resource() failed (%d) for %pOF\n",
		       ret, node);
267
		goto err_free;
268
	}
269

270
	ret = amba_device_add(dev, &iomem_resource);
271
	if (ret) {
272 273
		pr_err("amba_device_add() failed (%d) for %pOF\n",
		       ret, node);
274
		goto err_free;
275
	}
276 277 278 279

	return dev;

err_free:
280
	amba_device_put(dev);
281 282
err_clear_flag:
	of_node_clear_flag(node, OF_POPULATED);
283 284 285 286 287 288 289 290 291 292 293 294
	return NULL;
}
#else /* CONFIG_ARM_AMBA */
static struct amba_device *of_amba_device_create(struct device_node *node,
						 const char *bus_id,
						 void *platform_data,
						 struct device *parent)
{
	return NULL;
}
#endif /* CONFIG_ARM_AMBA */

295 296 297 298 299 300
/**
 * of_devname_lookup() - Given a device node, lookup the preferred Linux name
 */
static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
				 struct device_node *np)
{
301
	const struct of_dev_auxdata *auxdata;
302
	struct resource res;
303
	int compatible = 0;
O
Olof Johansson 已提交
304 305 306 307

	if (!lookup)
		return NULL;

308 309 310
	auxdata = lookup;
	for (; auxdata->compatible; auxdata++) {
		if (!of_device_is_compatible(np, auxdata->compatible))
O
Olof Johansson 已提交
311
			continue;
312
		compatible++;
313
		if (!of_address_to_resource(np, 0, &res))
314
			if (res.start != auxdata->phys_addr)
315
				continue;
316
		pr_debug("%pOF: devname=%s\n", np, auxdata->name);
317 318 319 320 321 322 323 324 325 326 327 328
		return auxdata;
	}

	if (!compatible)
		return NULL;

	/* Try compatible match if no phys_addr and name are specified */
	auxdata = lookup;
	for (; auxdata->compatible; auxdata++) {
		if (!of_device_is_compatible(np, auxdata->compatible))
			continue;
		if (!auxdata->phys_addr && !auxdata->name) {
329
			pr_debug("%pOF: compatible match\n", np);
330 331
			return auxdata;
		}
332
	}
O
Olof Johansson 已提交
333

334 335 336
	return NULL;
}

337
/**
338
 * of_platform_bus_create() - Create a device for a node and its children.
339
 * @bus: device node of the bus to instantiate
340
 * @matches: match table for bus nodes
O
Olof Johansson 已提交
341
 * @lookup: auxdata table for matching id and platform_data with device nodes
342
 * @parent: parent for new device, or NULL for top level.
O
Olof Johansson 已提交
343
 * @strict: require compatible property
344 345 346
 *
 * Creates a platform_device for the provided device_node, and optionally
 * recursively create devices for all the child nodes.
347
 */
348
static int of_platform_bus_create(struct device_node *bus,
349
				  const struct of_device_id *matches,
350
				  const struct of_dev_auxdata *lookup,
351
				  struct device *parent, bool strict)
352
{
353
	const struct of_dev_auxdata *auxdata;
354
	struct device_node *child;
355
	struct platform_device *dev;
356 357
	const char *bus_id = NULL;
	void *platform_data = NULL;
358 359
	int rc = 0;

360 361
	/* Make sure it has a compatible property */
	if (strict && (!of_get_property(bus, "compatible", NULL))) {
362 363
		pr_debug("%s() - skipping %pOF, no compatible prop\n",
			 __func__, bus);
364 365 366
		return 0;
	}

367 368 369 370 371 372
	/* Skip nodes for which we don't want to create devices */
	if (unlikely(of_match_node(of_skipped_node_table, bus))) {
		pr_debug("%s() - skipping %pOF node\n", __func__, bus);
		return 0;
	}

373
	if (of_node_check_flag(bus, OF_POPULATED_BUS)) {
374 375
		pr_debug("%s() - skipping %pOF, already populated\n",
			__func__, bus);
376 377 378
		return 0;
	}

379 380 381 382 383 384
	auxdata = of_dev_lookup(lookup, bus);
	if (auxdata) {
		bus_id = auxdata->name;
		platform_data = auxdata->platform_data;
	}

385
	if (of_device_is_compatible(bus, "arm,primecell")) {
386 387 388 389
		/*
		 * Don't return an error here to keep compatibility with older
		 * device tree files.
		 */
390
		of_amba_device_create(bus, bus_id, platform_data, parent);
391 392 393
		return 0;
	}

394
	dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
395 396 397
	if (!dev || !of_match_node(matches, bus))
		return 0;

398
	for_each_child_of_node(bus, child) {
399
		pr_debug("   create child: %pOF\n", child);
400
		rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
401 402 403 404 405
		if (rc) {
			of_node_put(child);
			break;
		}
	}
406
	of_node_set_flag(bus, OF_POPULATED_BUS);
407 408 409 410
	return rc;
}

/**
411
 * of_platform_bus_probe() - Probe the device-tree for platform buses
412
 * @root: parent of the first level to probe or NULL for the root of the tree
413
 * @matches: match table for bus nodes
414 415 416 417 418 419 420 421 422 423 424 425
 * @parent: parent to hook devices from, NULL for toplevel
 *
 * Note that children of the provided root are not instantiated as devices
 * unless the specified root itself matches the bus list and is not NULL.
 */
int of_platform_bus_probe(struct device_node *root,
			  const struct of_device_id *matches,
			  struct device *parent)
{
	struct device_node *child;
	int rc = 0;

426 427
	root = root ? of_node_get(root) : of_find_node_by_path("/");
	if (!root)
428
		return -EINVAL;
429

430
	pr_debug("%s()\n", __func__);
431
	pr_debug(" starting at: %pOF\n", root);
432

433
	/* Do a self check of bus type, if there's a match, create children */
434
	if (of_match_node(matches, root)) {
435
		rc = of_platform_bus_create(root, matches, NULL, parent, false);
436
	} else for_each_child_of_node(root, child) {
437 438
		if (!of_match_node(matches, child))
			continue;
439
		rc = of_platform_bus_create(child, matches, NULL, parent, false);
440 441
		if (rc) {
			of_node_put(child);
442
			break;
443
		}
444
	}
445

446 447 448 449
	of_node_put(root);
	return rc;
}
EXPORT_SYMBOL(of_platform_bus_probe);
450 451 452 453 454

/**
 * of_platform_populate() - Populate platform_devices from device tree data
 * @root: parent of the first level to probe or NULL for the root of the tree
 * @matches: match table, NULL to use the default
455
 * @lookup: auxdata table for matching id and platform_data with device nodes
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
 * @parent: parent to hook devices from, NULL for toplevel
 *
 * Similar to of_platform_bus_probe(), this function walks the device tree
 * and creates devices from nodes.  It differs in that it follows the modern
 * convention of requiring all device nodes to have a 'compatible' property,
 * and it is suitable for creating devices which are children of the root
 * node (of_platform_bus_probe will only create children of the root which
 * are selected by the @matches argument).
 *
 * New board support should be using this function instead of
 * of_platform_bus_probe().
 *
 * Returns 0 on success, < 0 on failure.
 */
int of_platform_populate(struct device_node *root,
			const struct of_device_id *matches,
472
			const struct of_dev_auxdata *lookup,
473 474 475 476 477 478 479 480 481
			struct device *parent)
{
	struct device_node *child;
	int rc = 0;

	root = root ? of_node_get(root) : of_find_node_by_path("/");
	if (!root)
		return -EINVAL;

482
	pr_debug("%s()\n", __func__);
483
	pr_debug(" starting at: %pOF\n", root);
484

485
	for_each_child_of_node(root, child) {
486
		rc = of_platform_bus_create(child, matches, lookup, parent, true);
487 488
		if (rc) {
			of_node_put(child);
489
			break;
490
		}
491
	}
492
	of_node_set_flag(root, OF_POPULATED_BUS);
493 494 495 496

	of_node_put(root);
	return rc;
}
497
EXPORT_SYMBOL_GPL(of_platform_populate);
498

499 500 501 502 503 504 505 506 507
int of_platform_default_populate(struct device_node *root,
				 const struct of_dev_auxdata *lookup,
				 struct device *parent)
{
	return of_platform_populate(root, of_default_bus_match_table, lookup,
				    parent);
}
EXPORT_SYMBOL_GPL(of_platform_default_populate);

508
#ifndef CONFIG_PPC
509
static const struct of_device_id reserved_mem_matches[] = {
510
	{ .compatible = "qcom,rmtfs-mem" },
511
	{ .compatible = "qcom,cmd-db" },
512 513 514 515
	{ .compatible = "ramoops" },
	{}
};

516 517
static int __init of_platform_default_populate_init(void)
{
518 519 520 521 522 523
	struct device_node *node;

	if (!of_have_populated_dt())
		return -ENODEV;

	/*
524 525 526
	 * Handle certain compatibles explicitly, since we don't want to create
	 * platform_devices for every node in /reserved-memory with a
	 * "compatible",
527
	 */
528 529
	for_each_matching_node(node, reserved_mem_matches)
		of_platform_device_create(node, NULL, NULL);
530

531
	node = of_find_node_by_path("/firmware");
532
	if (node) {
533
		of_platform_populate(node, NULL, NULL, NULL);
534 535
		of_node_put(node);
	}
536

537 538
	/* Populate everything else. */
	of_platform_default_populate(NULL, NULL, NULL);
539 540 541 542

	return 0;
}
arch_initcall_sync(of_platform_default_populate_init);
543
#endif
544

545
int of_platform_device_destroy(struct device *dev, void *data)
546 547
{
	/* Do not touch devices not populated from the device tree */
548
	if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED))
549 550
		return 0;

551 552 553
	/* Recurse for any nodes that were treated as busses */
	if (of_node_check_flag(dev->of_node, OF_POPULATED_BUS))
		device_for_each_child(dev, NULL, of_platform_device_destroy);
554

555 556 557
	of_node_clear_flag(dev->of_node, OF_POPULATED);
	of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);

558 559 560 561 562 563 564 565 566
	if (dev->bus == &platform_bus_type)
		platform_device_unregister(to_platform_device(dev));
#ifdef CONFIG_ARM_AMBA
	else if (dev->bus == &amba_bustype)
		amba_device_unregister(to_amba_device(dev));
#endif

	return 0;
}
567
EXPORT_SYMBOL_GPL(of_platform_device_destroy);
568 569 570

/**
 * of_platform_depopulate() - Remove devices populated from device tree
571
 * @parent: device which children will be removed
572 573 574 575 576 577
 *
 * Complementary to of_platform_populate(), this function removes children
 * of the given device (and, recurrently, their children) that have been
 * created from their respective device tree nodes (and only those,
 * leaving others - eg. manually created - unharmed).
 */
578
void of_platform_depopulate(struct device *parent)
579
{
580 581 582 583
	if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) {
		device_for_each_child(parent, NULL, of_platform_device_destroy);
		of_node_clear_flag(parent->of_node, OF_POPULATED_BUS);
	}
584 585 586
}
EXPORT_SYMBOL_GPL(of_platform_depopulate);

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
static void devm_of_platform_populate_release(struct device *dev, void *res)
{
	of_platform_depopulate(*(struct device **)res);
}

/**
 * devm_of_platform_populate() - Populate platform_devices from device tree data
 * @dev: device that requested to populate from device tree data
 *
 * Similar to of_platform_populate(), but will automatically call
 * of_platform_depopulate() when the device is unbound from the bus.
 *
 * Returns 0 on success, < 0 on failure.
 */
int devm_of_platform_populate(struct device *dev)
{
	struct device **ptr;
	int ret;

	if (!dev)
		return -EINVAL;

	ptr = devres_alloc(devm_of_platform_populate_release,
			   sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
	if (ret) {
		devres_free(ptr);
	} else {
		*ptr = dev;
		devres_add(dev, ptr);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(devm_of_platform_populate);

static int devm_of_platform_match(struct device *dev, void *res, void *data)
{
	struct device **ptr = res;

	if (!ptr) {
		WARN_ON(!ptr);
		return 0;
	}

	return *ptr == data;
}

/**
 * devm_of_platform_depopulate() - Remove devices populated from device tree
 * @dev: device that requested to depopulate from device tree data
 *
 * Complementary to devm_of_platform_populate(), this function removes children
 * of the given device (and, recurrently, their children) that have been
 * created from their respective device tree nodes (and only those,
 * leaving others - eg. manually created - unharmed).
 */
void devm_of_platform_depopulate(struct device *dev)
{
	int ret;

	ret = devres_release(dev, devm_of_platform_populate_release,
			     devm_of_platform_match, dev);

	WARN_ON(ret);
}
EXPORT_SYMBOL_GPL(devm_of_platform_depopulate);

658 659 660 661 662 663 664 665 666 667 668 669 670 671
#ifdef CONFIG_OF_DYNAMIC
static int of_platform_notify(struct notifier_block *nb,
				unsigned long action, void *arg)
{
	struct of_reconfig_data *rd = arg;
	struct platform_device *pdev_parent, *pdev;
	bool children_left;

	switch (of_reconfig_get_state_change(action, rd)) {
	case OF_RECONFIG_CHANGE_ADD:
		/* verify that the parent is a bus */
		if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS))
			return NOTIFY_OK;	/* not for us */

672 673 674 675
		/* already populated? (driver using of_populate manually) */
		if (of_node_check_flag(rd->dn, OF_POPULATED))
			return NOTIFY_OK;

676 677 678 679 680 681 682
		/* pdev_parent may be NULL when no bus platform device */
		pdev_parent = of_find_device_by_node(rd->dn->parent);
		pdev = of_platform_device_create(rd->dn, NULL,
				pdev_parent ? &pdev_parent->dev : NULL);
		of_dev_put(pdev_parent);

		if (pdev == NULL) {
683 684
			pr_err("%s: failed to create for '%pOF'\n",
					__func__, rd->dn);
685 686 687 688 689 690
			/* of_platform_device_create tosses the error code */
			return notifier_from_errno(-EINVAL);
		}
		break;

	case OF_RECONFIG_CHANGE_REMOVE:
691 692 693 694 695

		/* already depopulated? */
		if (!of_node_check_flag(rd->dn, OF_POPULATED))
			return NOTIFY_OK;

696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
		/* find our device by node */
		pdev = of_find_device_by_node(rd->dn);
		if (pdev == NULL)
			return NOTIFY_OK;	/* no? not meant for us */

		/* unregister takes one ref away */
		of_platform_device_destroy(&pdev->dev, &children_left);

		/* and put the reference of the find */
		of_dev_put(pdev);
		break;
	}

	return NOTIFY_OK;
}

static struct notifier_block platform_of_notifier = {
	.notifier_call = of_platform_notify,
};

void of_platform_register_reconfig_notifier(void)
{
	WARN_ON(of_reconfig_notifier_register(&platform_of_notifier));
}
#endif /* CONFIG_OF_DYNAMIC */

722
#endif /* CONFIG_OF_ADDRESS */