platform.c 17.2 KB
Newer Older
S
Stephen Rothwell 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 *    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
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version
 *  2 of the License, or (at your option) any later version.
 *
 */
#include <linux/errno.h>
15
#include <linux/module.h>
16
#include <linux/amba/bus.h>
S
Stephen Rothwell 已提交
17
#include <linux/device.h>
18
#include <linux/dma-mapping.h>
G
Grant Likely 已提交
19
#include <linux/slab.h>
20
#include <linux/of_address.h>
S
Stephen Rothwell 已提交
21
#include <linux/of_device.h>
22
#include <linux/of_irq.h>
S
Stephen Rothwell 已提交
23
#include <linux/of_platform.h>
24 25
#include <linux/platform_device.h>

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

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
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
 *
 * 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);

54
#ifdef CONFIG_OF_ADDRESS
55 56 57 58 59 60 61 62
/*
 * 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.
 */

63 64 65 66
/**
 * 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
 *
67 68 69
 * 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.
70
 */
71
void of_device_make_bus_id(struct device *dev)
72 73
{
	struct device_node *node = dev->of_node;
K
Kim Phillips 已提交
74
	const __be32 *reg;
75 76
	u64 addr;

77 78 79 80 81 82 83 84 85 86 87
	/* 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));
88 89 90
			return;
		}

91 92 93 94 95
		/* format arguments only used if dev_name() resolves to NULL */
		dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s",
			     strrchr(node->full_name, '/') + 1, dev_name(dev));
		node = node->parent;
	}
96 97 98 99 100 101 102 103
}

/**
 * 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.
 */
104
struct platform_device *of_device_alloc(struct device_node *np,
105 106 107
				  const char *bus_id,
				  struct device *parent)
{
108
	struct platform_device *dev;
109
	int rc, i, num_reg = 0, num_irq;
110 111
	struct resource *res, temp_res;

112 113 114 115 116
	dev = platform_device_alloc("", -1);
	if (!dev)
		return NULL;

	/* count the io and irq resources */
117 118
	while (of_address_to_resource(np, num_reg, &temp_res) == 0)
		num_reg++;
119
	num_irq = of_irq_count(np);
120 121 122

	/* Populate the resource table */
	if (num_irq || num_reg) {
123 124 125 126 127 128
		res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
		if (!res) {
			platform_device_put(dev);
			return NULL;
		}

129 130 131 132 133 134
		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);
		}
135 136 137
		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);
138
	}
139 140

	dev->dev.of_node = of_node_get(np);
141
	dev->dev.parent = parent ? : &platform_bus;
142 143 144 145 146 147 148 149 150 151

	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);

152 153 154 155 156 157 158 159 160 161 162
/**
 * of_dma_configure - Setup DMA configuration
 * @dev:	Device to apply DMA configuration
 *
 * Try to get devices's DMA configuration from DT and update it
 * accordingly.
 *
 * In case if platform code need to use own special DMA configuration,it
 * can use Platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE event
 * to fix up DMA configuration.
 */
163
static void of_dma_configure(struct device *dev)
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
{
	u64 dma_addr, paddr, size;
	int ret;

	/*
	 * Set default dma-mask to 32 bit. Drivers are expected to setup
	 * the correct supported dma_mask.
	 */
	dev->coherent_dma_mask = DMA_BIT_MASK(32);

	/*
	 * Set it to coherent_dma_mask by default if the architecture
	 * code has not set it.
	 */
	if (!dev->dma_mask)
		dev->dma_mask = &dev->coherent_dma_mask;

	/*
	 * if dma-coherent property exist, call arch hook to setup
	 * dma coherent operations.
	 */
	if (of_dma_is_coherent(dev->of_node)) {
		set_arch_dma_coherent_ops(dev);
		dev_dbg(dev, "device is dma coherent\n");
	}

	/*
	 * if dma-ranges property doesn't exist - just return else
	 * setup the dma offset
	 */
	ret = of_dma_get_range(dev->of_node, &dma_addr, &paddr, &size);
	if (ret < 0) {
		dev_dbg(dev, "no dma range information to setup\n");
		return;
	}

	/* DMA ranges found. Calculate and set dma_pfn_offset */
	dev->dma_pfn_offset = PFN_DOWN(paddr - dma_addr);
	dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", dev->dma_pfn_offset);
}

205
/**
206
 * of_platform_device_create_pdata - Alloc, initialize and register an of_device
207 208
 * @np: pointer to node to create device for
 * @bus_id: name to assign device
209
 * @platform_data: pointer to populate platform_data pointer with
210
 * @parent: Linux device model parent device.
211 212 213
 *
 * Returns pointer to created platform device, or NULL if a device was not
 * registered.  Unavailable devices will not get registered.
214
 */
215
static struct platform_device *of_platform_device_create_pdata(
216 217 218 219
					struct device_node *np,
					const char *bus_id,
					void *platform_data,
					struct device *parent)
220
{
221
	struct platform_device *dev;
222

223 224
	if (!of_device_is_available(np) ||
	    of_node_test_and_set_flag(np, OF_POPULATED))
225 226
		return NULL;

227 228
	dev = of_device_alloc(np, bus_id, parent);
	if (!dev)
229
		goto err_clear_flag;
230

231
	of_dma_configure(&dev->dev);
232
	dev->dev.bus = &platform_bus_type;
233
	dev->dev.platform_data = platform_data;
234 235 236 237 238 239

	/* We do not fill the DMA ops for platform devices by default.
	 * This is currently the responsibility of the platform code
	 * to do such, possibly using a device notifier
	 */

240 241
	if (of_device_add(dev) != 0) {
		platform_device_put(dev);
242
		goto err_clear_flag;
243 244 245
	}

	return dev;
246 247 248 249

err_clear_flag:
	of_node_clear_flag(np, OF_POPULATED);
	return NULL;
250
}
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266

/**
 * 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);
}
267 268
EXPORT_SYMBOL(of_platform_device_create);

269 270 271 272 273 274 275 276 277 278 279 280
#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;

	pr_debug("Creating amba device %s\n", node->full_name);

281 282
	if (!of_device_is_available(node) ||
	    of_node_test_and_set_flag(node, OF_POPULATED))
283 284
		return NULL;

285
	dev = amba_device_alloc(NULL, 0, 0);
286 287 288
	if (!dev) {
		pr_err("%s(): amba_device_alloc() failed for %s\n",
		       __func__, node->full_name);
289
		goto err_clear_flag;
290
	}
291 292 293

	/* setup generic device info */
	dev->dev.of_node = of_node_get(node);
294
	dev->dev.parent = parent ? : &platform_bus;
295 296 297 298 299
	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);
300
	of_dma_configure(&dev->dev);
301 302 303 304 305 306 307 308 309 310 311

	/* 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);
312 313 314
	if (ret) {
		pr_err("%s(): of_address_to_resource() failed (%d) for %s\n",
		       __func__, ret, node->full_name);
315
		goto err_free;
316
	}
317

318
	ret = amba_device_add(dev, &iomem_resource);
319 320 321
	if (ret) {
		pr_err("%s(): amba_device_add() failed (%d) for %s\n",
		       __func__, ret, node->full_name);
322
		goto err_free;
323
	}
324 325 326 327

	return dev;

err_free:
328
	amba_device_put(dev);
329 330
err_clear_flag:
	of_node_clear_flag(node, OF_POPULATED);
331 332 333 334 335 336 337 338 339 340 341 342
	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 */

343 344 345 346 347 348 349
/**
 * 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)
{
	struct resource res;
O
Olof Johansson 已提交
350 351 352 353

	if (!lookup)
		return NULL;

354
	for(; lookup->compatible != NULL; lookup++) {
O
Olof Johansson 已提交
355 356
		if (!of_device_is_compatible(np, lookup->compatible))
			continue;
357 358 359
		if (!of_address_to_resource(np, 0, &res))
			if (res.start != lookup->phys_addr)
				continue;
O
Olof Johansson 已提交
360 361
		pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
		return lookup;
362
	}
O
Olof Johansson 已提交
363

364 365 366
	return NULL;
}

367
/**
368
 * of_platform_bus_create() - Create a device for a node and its children.
369
 * @bus: device node of the bus to instantiate
370
 * @matches: match table for bus nodes
O
Olof Johansson 已提交
371
 * @lookup: auxdata table for matching id and platform_data with device nodes
372
 * @parent: parent for new device, or NULL for top level.
O
Olof Johansson 已提交
373
 * @strict: require compatible property
374 375 376
 *
 * Creates a platform_device for the provided device_node, and optionally
 * recursively create devices for all the child nodes.
377
 */
378
static int of_platform_bus_create(struct device_node *bus,
379
				  const struct of_device_id *matches,
380
				  const struct of_dev_auxdata *lookup,
381
				  struct device *parent, bool strict)
382
{
383
	const struct of_dev_auxdata *auxdata;
384
	struct device_node *child;
385
	struct platform_device *dev;
386 387
	const char *bus_id = NULL;
	void *platform_data = NULL;
388 389
	int rc = 0;

390 391 392 393 394 395 396
	/* Make sure it has a compatible property */
	if (strict && (!of_get_property(bus, "compatible", NULL))) {
		pr_debug("%s() - skipping %s, no compatible prop\n",
			 __func__, bus->full_name);
		return 0;
	}

397 398 399 400 401 402
	auxdata = of_dev_lookup(lookup, bus);
	if (auxdata) {
		bus_id = auxdata->name;
		platform_data = auxdata->platform_data;
	}

403
	if (of_device_is_compatible(bus, "arm,primecell")) {
404 405 406 407
		/*
		 * Don't return an error here to keep compatibility with older
		 * device tree files.
		 */
408
		of_amba_device_create(bus, bus_id, platform_data, parent);
409 410 411
		return 0;
	}

412
	dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
413 414 415
	if (!dev || !of_match_node(matches, bus))
		return 0;

416 417
	for_each_child_of_node(bus, child) {
		pr_debug("   create child: %s\n", child->full_name);
418
		rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
419 420 421 422 423
		if (rc) {
			of_node_put(child);
			break;
		}
	}
424
	of_node_set_flag(bus, OF_POPULATED_BUS);
425 426 427 428
	return rc;
}

/**
429
 * of_platform_bus_probe() - Probe the device-tree for platform buses
430
 * @root: parent of the first level to probe or NULL for the root of the tree
431
 * @matches: match table for bus nodes
432 433 434 435 436 437 438 439 440 441 442 443
 * @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;

444 445
	root = root ? of_node_get(root) : of_find_node_by_path("/");
	if (!root)
446
		return -EINVAL;
447 448 449 450

	pr_debug("of_platform_bus_probe()\n");
	pr_debug(" starting at: %s\n", root->full_name);

451
	/* Do a self check of bus type, if there's a match, create children */
452
	if (of_match_node(matches, root)) {
453
		rc = of_platform_bus_create(root, matches, NULL, parent, false);
454
	} else for_each_child_of_node(root, child) {
455 456
		if (!of_match_node(matches, child))
			continue;
457
		rc = of_platform_bus_create(child, matches, NULL, parent, false);
458
		if (rc)
459 460
			break;
	}
461

462 463 464 465
	of_node_put(root);
	return rc;
}
EXPORT_SYMBOL(of_platform_bus_probe);
466 467 468 469 470

/**
 * 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
471
 * @lookup: auxdata table for matching id and platform_data with device nodes
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
 * @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,
488
			const struct of_dev_auxdata *lookup,
489 490 491 492 493 494 495 496 497 498
			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;

	for_each_child_of_node(root, child) {
499
		rc = of_platform_bus_create(child, matches, lookup, parent, true);
500 501 502
		if (rc)
			break;
	}
503
	of_node_set_flag(root, OF_POPULATED_BUS);
504 505 506 507

	of_node_put(root);
	return rc;
}
508
EXPORT_SYMBOL_GPL(of_platform_populate);
509 510 511 512

static int of_platform_device_destroy(struct device *dev, void *data)
{
	/* Do not touch devices not populated from the device tree */
513
	if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED))
514 515
		return 0;

516 517 518
	/* 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);
519 520 521 522 523 524 525 526 527

	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

	of_node_clear_flag(dev->of_node, OF_POPULATED);
528
	of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
529 530 531 532 533
	return 0;
}

/**
 * of_platform_depopulate() - Remove devices populated from device tree
534
 * @parent: device which children will be removed
535 536 537 538 539 540 541 542 543
 *
 * 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).
 *
 * Returns 0 when all children devices have been removed or
 * -EBUSY when some children remained.
 */
544
void of_platform_depopulate(struct device *parent)
545
{
546 547 548 549
	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);
	}
550 551 552
}
EXPORT_SYMBOL_GPL(of_platform_depopulate);

553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
#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 */

		/* 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) {
			pr_err("%s: failed to create for '%s'\n",
					__func__, rd->dn->full_name);
			/* of_platform_device_create tosses the error code */
			return notifier_from_errno(-EINVAL);
		}
		break;

	case OF_RECONFIG_CHANGE_REMOVE:
		/* 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 */

608
#endif /* CONFIG_OF_ADDRESS */