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 #include <linux/errno.h> 15 #include <linux/module.h> 16 #include <linux/amba/bus.h> 17 #include <linux/device.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/slab.h> 20 #include <linux/of_address.h> 21 #include <linux/of_device.h> 22 #include <linux/of_irq.h> 23 #include <linux/of_platform.h> 24 #include <linux/platform_device.h> 25 26 const struct of_device_id of_default_bus_match_table[] = { 27 { .compatible = "simple-bus", }, 28 #ifdef CONFIG_ARM_AMBA 29 { .compatible = "arm,amba-bus", }, 30 #endif /* CONFIG_ARM_AMBA */ 31 {} /* Empty terminated list */ 32 }; 33 34 static int of_dev_node_match(struct device *dev, void *data) 35 { 36 return dev->of_node == data; 37 } 38 39 /** 40 * of_find_device_by_node - Find the platform_device associated with a node 41 * @np: Pointer to device tree node 42 * 43 * Returns platform_device pointer, or NULL if not found 44 */ 45 struct platform_device *of_find_device_by_node(struct device_node *np) 46 { 47 struct device *dev; 48 49 dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match); 50 return dev ? to_platform_device(dev) : NULL; 51 } 52 EXPORT_SYMBOL(of_find_device_by_node); 53 54 #ifdef CONFIG_OF_ADDRESS 55 /* 56 * The following routines scan a subtree and registers a device for 57 * each applicable node. 58 * 59 * Note: sparc doesn't use these routines because it has a different 60 * mechanism for creating devices from device tree nodes. 61 */ 62 63 /** 64 * of_device_make_bus_id - Use the device node data to assign a unique name 65 * @dev: pointer to device structure that is linked to a device tree node 66 * 67 * This routine will first try using the translated bus address to 68 * derive a unique name. If it cannot, then it will prepend names from 69 * 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; 74 const __be32 *reg; 75 u64 addr; 76 77 /* Construct the name, using parent nodes if necessary to ensure uniqueness */ 78 while (node->parent) { 79 /* 80 * If the address can be translated, then that is as much 81 * uniqueness as we need. Make it the first component and return 82 */ 83 reg = of_get_property(node, "reg", NULL); 84 if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) { 85 dev_set_name(dev, dev_name(dev) ? "%llx.%s:%s" : "%llx.%s", 86 (unsigned long long)addr, node->name, 87 dev_name(dev)); 88 return; 89 } 90 91 /* format arguments only used if dev_name() resolves to NULL */ 92 dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s", 93 strrchr(node->full_name, '/') + 1, dev_name(dev)); 94 node = node->parent; 95 } 96 } 97 98 /** 99 * of_device_alloc - Allocate and initialize an of_device 100 * @np: device node to assign to device 101 * @bus_id: Name to assign to the device. May be null to use default name. 102 * @parent: Parent device. 103 */ 104 struct platform_device *of_device_alloc(struct device_node *np, 105 const char *bus_id, 106 struct device *parent) 107 { 108 struct platform_device *dev; 109 int rc, i, num_reg = 0, num_irq; 110 struct resource *res, temp_res; 111 112 dev = platform_device_alloc("", -1); 113 if (!dev) 114 return NULL; 115 116 /* count the io and irq resources */ 117 while (of_address_to_resource(np, num_reg, &temp_res) == 0) 118 num_reg++; 119 num_irq = of_irq_count(np); 120 121 /* Populate the resource table */ 122 if (num_irq || num_reg) { 123 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); 124 if (!res) { 125 platform_device_put(dev); 126 return NULL; 127 } 128 129 dev->num_resources = num_reg + num_irq; 130 dev->resource = res; 131 for (i = 0; i < num_reg; i++, res++) { 132 rc = of_address_to_resource(np, i, res); 133 WARN_ON(rc); 134 } 135 if (of_irq_to_resource_table(np, res, num_irq) != num_irq) 136 pr_debug("not all legacy IRQ resources mapped for %s\n", 137 np->name); 138 } 139 140 dev->dev.of_node = of_node_get(np); 141 dev->dev.parent = parent; 142 143 if (bus_id) 144 dev_set_name(&dev->dev, "%s", bus_id); 145 else 146 of_device_make_bus_id(&dev->dev); 147 148 return dev; 149 } 150 EXPORT_SYMBOL(of_device_alloc); 151 152 /** 153 * of_dma_configure - Setup DMA configuration 154 * @dev: Device to apply DMA configuration 155 * 156 * Try to get devices's DMA configuration from DT and update it 157 * accordingly. 158 * 159 * In case if platform code need to use own special DMA configuration,it 160 * can use Platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE event 161 * to fix up DMA configuration. 162 */ 163 static void of_dma_configure(struct platform_device *pdev) 164 { 165 u64 dma_addr, paddr, size; 166 int ret; 167 struct device *dev = &pdev->dev; 168 169 #if defined(CONFIG_MICROBLAZE) 170 pdev->archdata.dma_mask = 0xffffffffUL; 171 #endif 172 173 /* 174 * Set default dma-mask to 32 bit. Drivers are expected to setup 175 * the correct supported dma_mask. 176 */ 177 dev->coherent_dma_mask = DMA_BIT_MASK(32); 178 179 /* 180 * Set it to coherent_dma_mask by default if the architecture 181 * code has not set it. 182 */ 183 if (!dev->dma_mask) 184 dev->dma_mask = &dev->coherent_dma_mask; 185 186 /* 187 * if dma-coherent property exist, call arch hook to setup 188 * dma coherent operations. 189 */ 190 if (of_dma_is_coherent(dev->of_node)) { 191 set_arch_dma_coherent_ops(dev); 192 dev_dbg(dev, "device is dma coherent\n"); 193 } 194 195 /* 196 * if dma-ranges property doesn't exist - just return else 197 * setup the dma offset 198 */ 199 ret = of_dma_get_range(dev->of_node, &dma_addr, &paddr, &size); 200 if (ret < 0) { 201 dev_dbg(dev, "no dma range information to setup\n"); 202 return; 203 } 204 205 /* DMA ranges found. Calculate and set dma_pfn_offset */ 206 dev->dma_pfn_offset = PFN_DOWN(paddr - dma_addr); 207 dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", dev->dma_pfn_offset); 208 } 209 210 /** 211 * of_platform_device_create_pdata - Alloc, initialize and register an of_device 212 * @np: pointer to node to create device for 213 * @bus_id: name to assign device 214 * @platform_data: pointer to populate platform_data pointer with 215 * @parent: Linux device model parent device. 216 * 217 * Returns pointer to created platform device, or NULL if a device was not 218 * registered. Unavailable devices will not get registered. 219 */ 220 static struct platform_device *of_platform_device_create_pdata( 221 struct device_node *np, 222 const char *bus_id, 223 void *platform_data, 224 struct device *parent) 225 { 226 struct platform_device *dev; 227 228 if (!of_device_is_available(np) || 229 of_node_test_and_set_flag(np, OF_POPULATED)) 230 return NULL; 231 232 dev = of_device_alloc(np, bus_id, parent); 233 if (!dev) 234 goto err_clear_flag; 235 236 of_dma_configure(dev); 237 dev->dev.bus = &platform_bus_type; 238 dev->dev.platform_data = platform_data; 239 240 /* We do not fill the DMA ops for platform devices by default. 241 * This is currently the responsibility of the platform code 242 * to do such, possibly using a device notifier 243 */ 244 245 if (of_device_add(dev) != 0) { 246 platform_device_put(dev); 247 goto err_clear_flag; 248 } 249 250 return dev; 251 252 err_clear_flag: 253 of_node_clear_flag(np, OF_POPULATED); 254 return NULL; 255 } 256 257 /** 258 * of_platform_device_create - Alloc, initialize and register an of_device 259 * @np: pointer to node to create device for 260 * @bus_id: name to assign device 261 * @parent: Linux device model parent device. 262 * 263 * Returns pointer to created platform device, or NULL if a device was not 264 * registered. Unavailable devices will not get registered. 265 */ 266 struct platform_device *of_platform_device_create(struct device_node *np, 267 const char *bus_id, 268 struct device *parent) 269 { 270 return of_platform_device_create_pdata(np, bus_id, NULL, parent); 271 } 272 EXPORT_SYMBOL(of_platform_device_create); 273 274 #ifdef CONFIG_ARM_AMBA 275 static struct amba_device *of_amba_device_create(struct device_node *node, 276 const char *bus_id, 277 void *platform_data, 278 struct device *parent) 279 { 280 struct amba_device *dev; 281 const void *prop; 282 int i, ret; 283 284 pr_debug("Creating amba device %s\n", node->full_name); 285 286 if (!of_device_is_available(node) || 287 of_node_test_and_set_flag(node, OF_POPULATED)) 288 return NULL; 289 290 dev = amba_device_alloc(NULL, 0, 0); 291 if (!dev) { 292 pr_err("%s(): amba_device_alloc() failed for %s\n", 293 __func__, node->full_name); 294 goto err_clear_flag; 295 } 296 297 /* setup generic device info */ 298 dev->dev.coherent_dma_mask = ~0; 299 dev->dev.of_node = of_node_get(node); 300 dev->dev.parent = parent; 301 dev->dev.platform_data = platform_data; 302 if (bus_id) 303 dev_set_name(&dev->dev, "%s", bus_id); 304 else 305 of_device_make_bus_id(&dev->dev); 306 307 /* Allow the HW Peripheral ID to be overridden */ 308 prop = of_get_property(node, "arm,primecell-periphid", NULL); 309 if (prop) 310 dev->periphid = of_read_ulong(prop, 1); 311 312 /* Decode the IRQs and address ranges */ 313 for (i = 0; i < AMBA_NR_IRQS; i++) 314 dev->irq[i] = irq_of_parse_and_map(node, i); 315 316 ret = of_address_to_resource(node, 0, &dev->res); 317 if (ret) { 318 pr_err("%s(): of_address_to_resource() failed (%d) for %s\n", 319 __func__, ret, node->full_name); 320 goto err_free; 321 } 322 323 ret = amba_device_add(dev, &iomem_resource); 324 if (ret) { 325 pr_err("%s(): amba_device_add() failed (%d) for %s\n", 326 __func__, ret, node->full_name); 327 goto err_free; 328 } 329 330 return dev; 331 332 err_free: 333 amba_device_put(dev); 334 err_clear_flag: 335 of_node_clear_flag(node, OF_POPULATED); 336 return NULL; 337 } 338 #else /* CONFIG_ARM_AMBA */ 339 static struct amba_device *of_amba_device_create(struct device_node *node, 340 const char *bus_id, 341 void *platform_data, 342 struct device *parent) 343 { 344 return NULL; 345 } 346 #endif /* CONFIG_ARM_AMBA */ 347 348 /** 349 * of_devname_lookup() - Given a device node, lookup the preferred Linux name 350 */ 351 static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup, 352 struct device_node *np) 353 { 354 struct resource res; 355 356 if (!lookup) 357 return NULL; 358 359 for(; lookup->compatible != NULL; lookup++) { 360 if (!of_device_is_compatible(np, lookup->compatible)) 361 continue; 362 if (!of_address_to_resource(np, 0, &res)) 363 if (res.start != lookup->phys_addr) 364 continue; 365 pr_debug("%s: devname=%s\n", np->full_name, lookup->name); 366 return lookup; 367 } 368 369 return NULL; 370 } 371 372 /** 373 * of_platform_bus_create() - Create a device for a node and its children. 374 * @bus: device node of the bus to instantiate 375 * @matches: match table for bus nodes 376 * @lookup: auxdata table for matching id and platform_data with device nodes 377 * @parent: parent for new device, or NULL for top level. 378 * @strict: require compatible property 379 * 380 * Creates a platform_device for the provided device_node, and optionally 381 * recursively create devices for all the child nodes. 382 */ 383 static int of_platform_bus_create(struct device_node *bus, 384 const struct of_device_id *matches, 385 const struct of_dev_auxdata *lookup, 386 struct device *parent, bool strict) 387 { 388 const struct of_dev_auxdata *auxdata; 389 struct device_node *child; 390 struct platform_device *dev; 391 const char *bus_id = NULL; 392 void *platform_data = NULL; 393 int rc = 0; 394 395 /* Make sure it has a compatible property */ 396 if (strict && (!of_get_property(bus, "compatible", NULL))) { 397 pr_debug("%s() - skipping %s, no compatible prop\n", 398 __func__, bus->full_name); 399 return 0; 400 } 401 402 auxdata = of_dev_lookup(lookup, bus); 403 if (auxdata) { 404 bus_id = auxdata->name; 405 platform_data = auxdata->platform_data; 406 } 407 408 if (of_device_is_compatible(bus, "arm,primecell")) { 409 /* 410 * Don't return an error here to keep compatibility with older 411 * device tree files. 412 */ 413 of_amba_device_create(bus, bus_id, platform_data, parent); 414 return 0; 415 } 416 417 dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent); 418 if (!dev || !of_match_node(matches, bus)) 419 return 0; 420 421 for_each_child_of_node(bus, child) { 422 pr_debug(" create child: %s\n", child->full_name); 423 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict); 424 if (rc) { 425 of_node_put(child); 426 break; 427 } 428 } 429 return rc; 430 } 431 432 /** 433 * of_platform_bus_probe() - Probe the device-tree for platform buses 434 * @root: parent of the first level to probe or NULL for the root of the tree 435 * @matches: match table for bus nodes 436 * @parent: parent to hook devices from, NULL for toplevel 437 * 438 * Note that children of the provided root are not instantiated as devices 439 * unless the specified root itself matches the bus list and is not NULL. 440 */ 441 int of_platform_bus_probe(struct device_node *root, 442 const struct of_device_id *matches, 443 struct device *parent) 444 { 445 struct device_node *child; 446 int rc = 0; 447 448 root = root ? of_node_get(root) : of_find_node_by_path("/"); 449 if (!root) 450 return -EINVAL; 451 452 pr_debug("of_platform_bus_probe()\n"); 453 pr_debug(" starting at: %s\n", root->full_name); 454 455 /* Do a self check of bus type, if there's a match, create children */ 456 if (of_match_node(matches, root)) { 457 rc = of_platform_bus_create(root, matches, NULL, parent, false); 458 } else for_each_child_of_node(root, child) { 459 if (!of_match_node(matches, child)) 460 continue; 461 rc = of_platform_bus_create(child, matches, NULL, parent, false); 462 if (rc) 463 break; 464 } 465 466 of_node_put(root); 467 return rc; 468 } 469 EXPORT_SYMBOL(of_platform_bus_probe); 470 471 /** 472 * of_platform_populate() - Populate platform_devices from device tree data 473 * @root: parent of the first level to probe or NULL for the root of the tree 474 * @matches: match table, NULL to use the default 475 * @lookup: auxdata table for matching id and platform_data with device nodes 476 * @parent: parent to hook devices from, NULL for toplevel 477 * 478 * Similar to of_platform_bus_probe(), this function walks the device tree 479 * and creates devices from nodes. It differs in that it follows the modern 480 * convention of requiring all device nodes to have a 'compatible' property, 481 * and it is suitable for creating devices which are children of the root 482 * node (of_platform_bus_probe will only create children of the root which 483 * are selected by the @matches argument). 484 * 485 * New board support should be using this function instead of 486 * of_platform_bus_probe(). 487 * 488 * Returns 0 on success, < 0 on failure. 489 */ 490 int of_platform_populate(struct device_node *root, 491 const struct of_device_id *matches, 492 const struct of_dev_auxdata *lookup, 493 struct device *parent) 494 { 495 struct device_node *child; 496 int rc = 0; 497 498 root = root ? of_node_get(root) : of_find_node_by_path("/"); 499 if (!root) 500 return -EINVAL; 501 502 for_each_child_of_node(root, child) { 503 rc = of_platform_bus_create(child, matches, lookup, parent, true); 504 if (rc) 505 break; 506 } 507 508 of_node_put(root); 509 return rc; 510 } 511 EXPORT_SYMBOL_GPL(of_platform_populate); 512 513 static int of_platform_device_destroy(struct device *dev, void *data) 514 { 515 bool *children_left = data; 516 517 /* Do not touch devices not populated from the device tree */ 518 if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED)) { 519 *children_left = true; 520 return 0; 521 } 522 523 /* Recurse, but don't touch this device if it has any children left */ 524 if (of_platform_depopulate(dev) != 0) { 525 *children_left = true; 526 return 0; 527 } 528 529 if (dev->bus == &platform_bus_type) 530 platform_device_unregister(to_platform_device(dev)); 531 #ifdef CONFIG_ARM_AMBA 532 else if (dev->bus == &amba_bustype) 533 amba_device_unregister(to_amba_device(dev)); 534 #endif 535 else { 536 *children_left = true; 537 return 0; 538 } 539 540 of_node_clear_flag(dev->of_node, OF_POPULATED); 541 542 return 0; 543 } 544 545 /** 546 * of_platform_depopulate() - Remove devices populated from device tree 547 * @parent: device which childred will be removed 548 * 549 * Complementary to of_platform_populate(), this function removes children 550 * of the given device (and, recurrently, their children) that have been 551 * created from their respective device tree nodes (and only those, 552 * leaving others - eg. manually created - unharmed). 553 * 554 * Returns 0 when all children devices have been removed or 555 * -EBUSY when some children remained. 556 */ 557 int of_platform_depopulate(struct device *parent) 558 { 559 bool children_left = false; 560 561 device_for_each_child(parent, &children_left, 562 of_platform_device_destroy); 563 564 return children_left ? -EBUSY : 0; 565 } 566 EXPORT_SYMBOL_GPL(of_platform_depopulate); 567 568 #endif /* CONFIG_OF_ADDRESS */ 569