1 /* 2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. 3 * <benh@kernel.crashing.org> 4 * and Arnd Bergmann, IBM Corp. 5 * Merged from powerpc/kernel/of_platform.c and 6 * sparc{,64}/kernel/of_device.c by Stephen Rothwell 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 */ 14 15 #define pr_fmt(fmt) "OF: " fmt 16 17 #include <linux/errno.h> 18 #include <linux/module.h> 19 #include <linux/amba/bus.h> 20 #include <linux/device.h> 21 #include <linux/dma-mapping.h> 22 #include <linux/slab.h> 23 #include <linux/of_address.h> 24 #include <linux/of_device.h> 25 #include <linux/of_irq.h> 26 #include <linux/of_platform.h> 27 #include <linux/platform_device.h> 28 29 const struct of_device_id of_default_bus_match_table[] = { 30 { .compatible = "simple-bus", }, 31 { .compatible = "simple-mfd", }, 32 { .compatible = "isa", }, 33 #ifdef CONFIG_ARM_AMBA 34 { .compatible = "arm,amba-bus", }, 35 #endif /* CONFIG_ARM_AMBA */ 36 {} /* Empty terminated list */ 37 }; 38 39 static int of_dev_node_match(struct device *dev, void *data) 40 { 41 return dev->of_node == data; 42 } 43 44 /** 45 * of_find_device_by_node - Find the platform_device associated with a node 46 * @np: Pointer to device tree node 47 * 48 * Returns platform_device pointer, or NULL if not found 49 */ 50 struct platform_device *of_find_device_by_node(struct device_node *np) 51 { 52 struct device *dev; 53 54 dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match); 55 return dev ? to_platform_device(dev) : NULL; 56 } 57 EXPORT_SYMBOL(of_find_device_by_node); 58 59 #ifdef CONFIG_OF_ADDRESS 60 /* 61 * The following routines scan a subtree and registers a device for 62 * each applicable node. 63 * 64 * Note: sparc doesn't use these routines because it has a different 65 * mechanism for creating devices from device tree nodes. 66 */ 67 68 /** 69 * of_device_make_bus_id - Use the device node data to assign a unique name 70 * @dev: pointer to device structure that is linked to a device tree node 71 * 72 * This routine will first try using the translated bus address to 73 * derive a unique name. If it cannot, then it will prepend names from 74 * parent nodes until a unique name can be derived. 75 */ 76 void of_device_make_bus_id(struct device *dev) 77 { 78 struct device_node *node = dev->of_node; 79 const __be32 *reg; 80 u64 addr; 81 82 /* Construct the name, using parent nodes if necessary to ensure uniqueness */ 83 while (node->parent) { 84 /* 85 * If the address can be translated, then that is as much 86 * uniqueness as we need. Make it the first component and return 87 */ 88 reg = of_get_property(node, "reg", NULL); 89 if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) { 90 dev_set_name(dev, dev_name(dev) ? "%llx.%s:%s" : "%llx.%s", 91 (unsigned long long)addr, node->name, 92 dev_name(dev)); 93 return; 94 } 95 96 /* format arguments only used if dev_name() resolves to NULL */ 97 dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s", 98 strrchr(node->full_name, '/') + 1, dev_name(dev)); 99 node = node->parent; 100 } 101 } 102 103 /** 104 * of_device_alloc - Allocate and initialize an of_device 105 * @np: device node to assign to device 106 * @bus_id: Name to assign to the device. May be null to use default name. 107 * @parent: Parent device. 108 */ 109 struct platform_device *of_device_alloc(struct device_node *np, 110 const char *bus_id, 111 struct device *parent) 112 { 113 struct platform_device *dev; 114 int rc, i, num_reg = 0, num_irq; 115 struct resource *res, temp_res; 116 117 dev = platform_device_alloc("", -1); 118 if (!dev) 119 return NULL; 120 121 /* count the io and irq resources */ 122 while (of_address_to_resource(np, num_reg, &temp_res) == 0) 123 num_reg++; 124 num_irq = of_irq_count(np); 125 126 /* Populate the resource table */ 127 if (num_irq || num_reg) { 128 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); 129 if (!res) { 130 platform_device_put(dev); 131 return NULL; 132 } 133 134 dev->num_resources = num_reg + num_irq; 135 dev->resource = res; 136 for (i = 0; i < num_reg; i++, res++) { 137 rc = of_address_to_resource(np, i, res); 138 WARN_ON(rc); 139 } 140 if (of_irq_to_resource_table(np, res, num_irq) != num_irq) 141 pr_debug("not all legacy IRQ resources mapped for %s\n", 142 np->name); 143 } 144 145 dev->dev.of_node = of_node_get(np); 146 dev->dev.fwnode = &np->fwnode; 147 dev->dev.parent = parent ? : &platform_bus; 148 149 if (bus_id) 150 dev_set_name(&dev->dev, "%s", bus_id); 151 else 152 of_device_make_bus_id(&dev->dev); 153 154 return dev; 155 } 156 EXPORT_SYMBOL(of_device_alloc); 157 158 static void of_dma_deconfigure(struct device *dev) 159 { 160 arch_teardown_dma_ops(dev); 161 } 162 163 /** 164 * of_platform_device_create_pdata - Alloc, initialize and register an of_device 165 * @np: pointer to node to create device for 166 * @bus_id: name to assign device 167 * @platform_data: pointer to populate platform_data pointer with 168 * @parent: Linux device model parent device. 169 * 170 * Returns pointer to created platform device, or NULL if a device was not 171 * registered. Unavailable devices will not get registered. 172 */ 173 static struct platform_device *of_platform_device_create_pdata( 174 struct device_node *np, 175 const char *bus_id, 176 void *platform_data, 177 struct device *parent) 178 { 179 struct platform_device *dev; 180 181 if (!of_device_is_available(np) || 182 of_node_test_and_set_flag(np, OF_POPULATED)) 183 return NULL; 184 185 dev = of_device_alloc(np, bus_id, parent); 186 if (!dev) 187 goto err_clear_flag; 188 189 dev->dev.bus = &platform_bus_type; 190 dev->dev.platform_data = platform_data; 191 of_dma_configure(&dev->dev, dev->dev.of_node); 192 of_msi_configure(&dev->dev, dev->dev.of_node); 193 194 if (of_device_add(dev) != 0) { 195 of_dma_deconfigure(&dev->dev); 196 platform_device_put(dev); 197 goto err_clear_flag; 198 } 199 200 return dev; 201 202 err_clear_flag: 203 of_node_clear_flag(np, OF_POPULATED); 204 return NULL; 205 } 206 207 /** 208 * of_platform_device_create - Alloc, initialize and register an of_device 209 * @np: pointer to node to create device for 210 * @bus_id: name to assign device 211 * @parent: Linux device model parent device. 212 * 213 * Returns pointer to created platform device, or NULL if a device was not 214 * registered. Unavailable devices will not get registered. 215 */ 216 struct platform_device *of_platform_device_create(struct device_node *np, 217 const char *bus_id, 218 struct device *parent) 219 { 220 return of_platform_device_create_pdata(np, bus_id, NULL, parent); 221 } 222 EXPORT_SYMBOL(of_platform_device_create); 223 224 #ifdef CONFIG_ARM_AMBA 225 static struct amba_device *of_amba_device_create(struct device_node *node, 226 const char *bus_id, 227 void *platform_data, 228 struct device *parent) 229 { 230 struct amba_device *dev; 231 const void *prop; 232 int i, ret; 233 234 pr_debug("Creating amba device %s\n", node->full_name); 235 236 if (!of_device_is_available(node) || 237 of_node_test_and_set_flag(node, OF_POPULATED)) 238 return NULL; 239 240 dev = amba_device_alloc(NULL, 0, 0); 241 if (!dev) 242 goto err_clear_flag; 243 244 /* setup generic device info */ 245 dev->dev.of_node = of_node_get(node); 246 dev->dev.fwnode = &node->fwnode; 247 dev->dev.parent = parent ? : &platform_bus; 248 dev->dev.platform_data = platform_data; 249 if (bus_id) 250 dev_set_name(&dev->dev, "%s", bus_id); 251 else 252 of_device_make_bus_id(&dev->dev); 253 of_dma_configure(&dev->dev, dev->dev.of_node); 254 255 /* Allow the HW Peripheral ID to be overridden */ 256 prop = of_get_property(node, "arm,primecell-periphid", NULL); 257 if (prop) 258 dev->periphid = of_read_ulong(prop, 1); 259 260 /* Decode the IRQs and address ranges */ 261 for (i = 0; i < AMBA_NR_IRQS; i++) 262 dev->irq[i] = irq_of_parse_and_map(node, i); 263 264 ret = of_address_to_resource(node, 0, &dev->res); 265 if (ret) { 266 pr_err("amba: of_address_to_resource() failed (%d) for %s\n", 267 ret, node->full_name); 268 goto err_free; 269 } 270 271 ret = amba_device_add(dev, &iomem_resource); 272 if (ret) { 273 pr_err("amba_device_add() failed (%d) for %s\n", 274 ret, node->full_name); 275 goto err_free; 276 } 277 278 return dev; 279 280 err_free: 281 amba_device_put(dev); 282 err_clear_flag: 283 of_node_clear_flag(node, OF_POPULATED); 284 return NULL; 285 } 286 #else /* CONFIG_ARM_AMBA */ 287 static struct amba_device *of_amba_device_create(struct device_node *node, 288 const char *bus_id, 289 void *platform_data, 290 struct device *parent) 291 { 292 return NULL; 293 } 294 #endif /* CONFIG_ARM_AMBA */ 295 296 /** 297 * of_devname_lookup() - Given a device node, lookup the preferred Linux name 298 */ 299 static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup, 300 struct device_node *np) 301 { 302 const struct of_dev_auxdata *auxdata; 303 struct resource res; 304 int compatible = 0; 305 306 if (!lookup) 307 return NULL; 308 309 auxdata = lookup; 310 for (; auxdata->compatible; auxdata++) { 311 if (!of_device_is_compatible(np, auxdata->compatible)) 312 continue; 313 compatible++; 314 if (!of_address_to_resource(np, 0, &res)) 315 if (res.start != auxdata->phys_addr) 316 continue; 317 pr_debug("%s: devname=%s\n", np->full_name, auxdata->name); 318 return auxdata; 319 } 320 321 if (!compatible) 322 return NULL; 323 324 /* Try compatible match if no phys_addr and name are specified */ 325 auxdata = lookup; 326 for (; auxdata->compatible; auxdata++) { 327 if (!of_device_is_compatible(np, auxdata->compatible)) 328 continue; 329 if (!auxdata->phys_addr && !auxdata->name) { 330 pr_debug("%s: compatible match\n", np->full_name); 331 return auxdata; 332 } 333 } 334 335 return NULL; 336 } 337 338 /** 339 * of_platform_bus_create() - Create a device for a node and its children. 340 * @bus: device node of the bus to instantiate 341 * @matches: match table for bus nodes 342 * @lookup: auxdata table for matching id and platform_data with device nodes 343 * @parent: parent for new device, or NULL for top level. 344 * @strict: require compatible property 345 * 346 * Creates a platform_device for the provided device_node, and optionally 347 * recursively create devices for all the child nodes. 348 */ 349 static int of_platform_bus_create(struct device_node *bus, 350 const struct of_device_id *matches, 351 const struct of_dev_auxdata *lookup, 352 struct device *parent, bool strict) 353 { 354 const struct of_dev_auxdata *auxdata; 355 struct device_node *child; 356 struct platform_device *dev; 357 const char *bus_id = NULL; 358 void *platform_data = NULL; 359 int rc = 0; 360 361 /* Make sure it has a compatible property */ 362 if (strict && (!of_get_property(bus, "compatible", NULL))) { 363 pr_debug("%s() - skipping %s, no compatible prop\n", 364 __func__, bus->full_name); 365 return 0; 366 } 367 368 if (of_node_check_flag(bus, OF_POPULATED_BUS)) { 369 pr_debug("%s() - skipping %s, already populated\n", 370 __func__, bus->full_name); 371 return 0; 372 } 373 374 auxdata = of_dev_lookup(lookup, bus); 375 if (auxdata) { 376 bus_id = auxdata->name; 377 platform_data = auxdata->platform_data; 378 } 379 380 if (of_device_is_compatible(bus, "arm,primecell")) { 381 /* 382 * Don't return an error here to keep compatibility with older 383 * device tree files. 384 */ 385 of_amba_device_create(bus, bus_id, platform_data, parent); 386 return 0; 387 } 388 389 dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent); 390 if (!dev || !of_match_node(matches, bus)) 391 return 0; 392 393 for_each_child_of_node(bus, child) { 394 pr_debug(" create child: %s\n", child->full_name); 395 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict); 396 if (rc) { 397 of_node_put(child); 398 break; 399 } 400 } 401 of_node_set_flag(bus, OF_POPULATED_BUS); 402 return rc; 403 } 404 405 /** 406 * of_platform_bus_probe() - Probe the device-tree for platform buses 407 * @root: parent of the first level to probe or NULL for the root of the tree 408 * @matches: match table for bus nodes 409 * @parent: parent to hook devices from, NULL for toplevel 410 * 411 * Note that children of the provided root are not instantiated as devices 412 * unless the specified root itself matches the bus list and is not NULL. 413 */ 414 int of_platform_bus_probe(struct device_node *root, 415 const struct of_device_id *matches, 416 struct device *parent) 417 { 418 struct device_node *child; 419 int rc = 0; 420 421 root = root ? of_node_get(root) : of_find_node_by_path("/"); 422 if (!root) 423 return -EINVAL; 424 425 pr_debug("%s()\n", __func__); 426 pr_debug(" starting at: %s\n", root->full_name); 427 428 /* Do a self check of bus type, if there's a match, create children */ 429 if (of_match_node(matches, root)) { 430 rc = of_platform_bus_create(root, matches, NULL, parent, false); 431 } else for_each_child_of_node(root, child) { 432 if (!of_match_node(matches, child)) 433 continue; 434 rc = of_platform_bus_create(child, matches, NULL, parent, false); 435 if (rc) { 436 of_node_put(child); 437 break; 438 } 439 } 440 441 of_node_put(root); 442 return rc; 443 } 444 EXPORT_SYMBOL(of_platform_bus_probe); 445 446 /** 447 * of_platform_populate() - Populate platform_devices from device tree data 448 * @root: parent of the first level to probe or NULL for the root of the tree 449 * @matches: match table, NULL to use the default 450 * @lookup: auxdata table for matching id and platform_data with device nodes 451 * @parent: parent to hook devices from, NULL for toplevel 452 * 453 * Similar to of_platform_bus_probe(), this function walks the device tree 454 * and creates devices from nodes. It differs in that it follows the modern 455 * convention of requiring all device nodes to have a 'compatible' property, 456 * and it is suitable for creating devices which are children of the root 457 * node (of_platform_bus_probe will only create children of the root which 458 * are selected by the @matches argument). 459 * 460 * New board support should be using this function instead of 461 * of_platform_bus_probe(). 462 * 463 * Returns 0 on success, < 0 on failure. 464 */ 465 int of_platform_populate(struct device_node *root, 466 const struct of_device_id *matches, 467 const struct of_dev_auxdata *lookup, 468 struct device *parent) 469 { 470 struct device_node *child; 471 int rc = 0; 472 473 root = root ? of_node_get(root) : of_find_node_by_path("/"); 474 if (!root) 475 return -EINVAL; 476 477 pr_debug("%s()\n", __func__); 478 pr_debug(" starting at: %s\n", root->full_name); 479 480 for_each_child_of_node(root, child) { 481 rc = of_platform_bus_create(child, matches, lookup, parent, true); 482 if (rc) { 483 of_node_put(child); 484 break; 485 } 486 } 487 of_node_set_flag(root, OF_POPULATED_BUS); 488 489 of_node_put(root); 490 return rc; 491 } 492 EXPORT_SYMBOL_GPL(of_platform_populate); 493 494 int of_platform_default_populate(struct device_node *root, 495 const struct of_dev_auxdata *lookup, 496 struct device *parent) 497 { 498 return of_platform_populate(root, of_default_bus_match_table, lookup, 499 parent); 500 } 501 EXPORT_SYMBOL_GPL(of_platform_default_populate); 502 503 #ifndef CONFIG_PPC 504 static int __init of_platform_default_populate_init(void) 505 { 506 struct device_node *node; 507 508 if (!of_have_populated_dt()) 509 return -ENODEV; 510 511 /* 512 * Handle ramoops explicitly, since it is inside /reserved-memory, 513 * which lacks a "compatible" property. 514 */ 515 node = of_find_node_by_path("/reserved-memory"); 516 if (node) { 517 node = of_find_compatible_node(node, NULL, "ramoops"); 518 if (node) 519 of_platform_device_create(node, NULL, NULL); 520 } 521 522 /* Populate everything else. */ 523 of_platform_default_populate(NULL, NULL, NULL); 524 525 return 0; 526 } 527 arch_initcall_sync(of_platform_default_populate_init); 528 #endif 529 530 static int of_platform_device_destroy(struct device *dev, void *data) 531 { 532 /* Do not touch devices not populated from the device tree */ 533 if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED)) 534 return 0; 535 536 /* Recurse for any nodes that were treated as busses */ 537 if (of_node_check_flag(dev->of_node, OF_POPULATED_BUS)) 538 device_for_each_child(dev, NULL, of_platform_device_destroy); 539 540 if (dev->bus == &platform_bus_type) 541 platform_device_unregister(to_platform_device(dev)); 542 #ifdef CONFIG_ARM_AMBA 543 else if (dev->bus == &amba_bustype) 544 amba_device_unregister(to_amba_device(dev)); 545 #endif 546 547 of_dma_deconfigure(dev); 548 of_node_clear_flag(dev->of_node, OF_POPULATED); 549 of_node_clear_flag(dev->of_node, OF_POPULATED_BUS); 550 return 0; 551 } 552 553 /** 554 * of_platform_depopulate() - Remove devices populated from device tree 555 * @parent: device which children will be removed 556 * 557 * Complementary to of_platform_populate(), this function removes children 558 * of the given device (and, recurrently, their children) that have been 559 * created from their respective device tree nodes (and only those, 560 * leaving others - eg. manually created - unharmed). 561 * 562 * Returns 0 when all children devices have been removed or 563 * -EBUSY when some children remained. 564 */ 565 void of_platform_depopulate(struct device *parent) 566 { 567 if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) { 568 device_for_each_child(parent, NULL, of_platform_device_destroy); 569 of_node_clear_flag(parent->of_node, OF_POPULATED_BUS); 570 } 571 } 572 EXPORT_SYMBOL_GPL(of_platform_depopulate); 573 574 #ifdef CONFIG_OF_DYNAMIC 575 static int of_platform_notify(struct notifier_block *nb, 576 unsigned long action, void *arg) 577 { 578 struct of_reconfig_data *rd = arg; 579 struct platform_device *pdev_parent, *pdev; 580 bool children_left; 581 582 switch (of_reconfig_get_state_change(action, rd)) { 583 case OF_RECONFIG_CHANGE_ADD: 584 /* verify that the parent is a bus */ 585 if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS)) 586 return NOTIFY_OK; /* not for us */ 587 588 /* already populated? (driver using of_populate manually) */ 589 if (of_node_check_flag(rd->dn, OF_POPULATED)) 590 return NOTIFY_OK; 591 592 /* pdev_parent may be NULL when no bus platform device */ 593 pdev_parent = of_find_device_by_node(rd->dn->parent); 594 pdev = of_platform_device_create(rd->dn, NULL, 595 pdev_parent ? &pdev_parent->dev : NULL); 596 of_dev_put(pdev_parent); 597 598 if (pdev == NULL) { 599 pr_err("%s: failed to create for '%s'\n", 600 __func__, rd->dn->full_name); 601 /* of_platform_device_create tosses the error code */ 602 return notifier_from_errno(-EINVAL); 603 } 604 break; 605 606 case OF_RECONFIG_CHANGE_REMOVE: 607 608 /* already depopulated? */ 609 if (!of_node_check_flag(rd->dn, OF_POPULATED)) 610 return NOTIFY_OK; 611 612 /* find our device by node */ 613 pdev = of_find_device_by_node(rd->dn); 614 if (pdev == NULL) 615 return NOTIFY_OK; /* no? not meant for us */ 616 617 /* unregister takes one ref away */ 618 of_platform_device_destroy(&pdev->dev, &children_left); 619 620 /* and put the reference of the find */ 621 of_dev_put(pdev); 622 break; 623 } 624 625 return NOTIFY_OK; 626 } 627 628 static struct notifier_block platform_of_notifier = { 629 .notifier_call = of_platform_notify, 630 }; 631 632 void of_platform_register_reconfig_notifier(void) 633 { 634 WARN_ON(of_reconfig_notifier_register(&platform_of_notifier)); 635 } 636 #endif /* CONFIG_OF_DYNAMIC */ 637 638 #endif /* CONFIG_OF_ADDRESS */ 639