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 #if defined(CONFIG_PPC_DCR) 55 #include <asm/dcr.h> 56 #endif 57 58 #ifdef CONFIG_OF_ADDRESS 59 /* 60 * The following routines scan a subtree and registers a device for 61 * each applicable node. 62 * 63 * Note: sparc doesn't use these routines because it has a different 64 * mechanism for creating devices from device tree nodes. 65 */ 66 67 /** 68 * of_device_make_bus_id - Use the device node data to assign a unique name 69 * @dev: pointer to device structure that is linked to a device tree node 70 * 71 * This routine will first try using either the dcr-reg or the reg property 72 * value to derive a unique name. As a last resort it will use the node 73 * name followed by a unique number. 74 */ 75 void of_device_make_bus_id(struct device *dev) 76 { 77 static atomic_t bus_no_reg_magic; 78 struct device_node *node = dev->of_node; 79 const __be32 *reg; 80 u64 addr; 81 const __be32 *addrp; 82 int magic; 83 84 #ifdef CONFIG_PPC_DCR 85 /* 86 * If it's a DCR based device, use 'd' for native DCRs 87 * and 'D' for MMIO DCRs. 88 */ 89 reg = of_get_property(node, "dcr-reg", NULL); 90 if (reg) { 91 #ifdef CONFIG_PPC_DCR_NATIVE 92 dev_set_name(dev, "d%x.%s", *reg, node->name); 93 #else /* CONFIG_PPC_DCR_NATIVE */ 94 u64 addr = of_translate_dcr_address(node, *reg, NULL); 95 if (addr != OF_BAD_ADDR) { 96 dev_set_name(dev, "D%llx.%s", 97 (unsigned long long)addr, node->name); 98 return; 99 } 100 #endif /* !CONFIG_PPC_DCR_NATIVE */ 101 } 102 #endif /* CONFIG_PPC_DCR */ 103 104 /* 105 * For MMIO, get the physical address 106 */ 107 reg = of_get_property(node, "reg", NULL); 108 if (reg) { 109 if (of_can_translate_address(node)) { 110 addr = of_translate_address(node, reg); 111 } else { 112 addrp = of_get_address(node, 0, NULL, NULL); 113 if (addrp) 114 addr = of_read_number(addrp, 1); 115 else 116 addr = OF_BAD_ADDR; 117 } 118 if (addr != OF_BAD_ADDR) { 119 dev_set_name(dev, "%llx.%s", 120 (unsigned long long)addr, node->name); 121 return; 122 } 123 } 124 125 /* 126 * No BusID, use the node name and add a globally incremented 127 * counter (and pray...) 128 */ 129 magic = atomic_add_return(1, &bus_no_reg_magic); 130 dev_set_name(dev, "%s.%d", node->name, magic - 1); 131 } 132 133 /** 134 * of_device_alloc - Allocate and initialize an of_device 135 * @np: device node to assign to device 136 * @bus_id: Name to assign to the device. May be null to use default name. 137 * @parent: Parent device. 138 */ 139 struct platform_device *of_device_alloc(struct device_node *np, 140 const char *bus_id, 141 struct device *parent) 142 { 143 struct platform_device *dev; 144 int rc, i, num_reg = 0, num_irq; 145 struct resource *res, temp_res; 146 147 dev = platform_device_alloc("", -1); 148 if (!dev) 149 return NULL; 150 151 /* count the io and irq resources */ 152 if (of_can_translate_address(np)) 153 while (of_address_to_resource(np, num_reg, &temp_res) == 0) 154 num_reg++; 155 num_irq = of_irq_count(np); 156 157 /* Populate the resource table */ 158 if (num_irq || num_reg) { 159 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); 160 if (!res) { 161 platform_device_put(dev); 162 return NULL; 163 } 164 165 dev->num_resources = num_reg + num_irq; 166 dev->resource = res; 167 for (i = 0; i < num_reg; i++, res++) { 168 rc = of_address_to_resource(np, i, res); 169 WARN_ON(rc); 170 } 171 if (of_irq_to_resource_table(np, res, num_irq) != num_irq) 172 pr_debug("not all legacy IRQ resources mapped for %s\n", 173 np->name); 174 } 175 176 dev->dev.of_node = of_node_get(np); 177 #if defined(CONFIG_MICROBLAZE) 178 dev->dev.dma_mask = &dev->archdata.dma_mask; 179 #endif 180 dev->dev.parent = parent; 181 182 if (bus_id) 183 dev_set_name(&dev->dev, "%s", bus_id); 184 else 185 of_device_make_bus_id(&dev->dev); 186 187 return dev; 188 } 189 EXPORT_SYMBOL(of_device_alloc); 190 191 /** 192 * of_platform_device_create_pdata - Alloc, initialize and register an of_device 193 * @np: pointer to node to create device for 194 * @bus_id: name to assign device 195 * @platform_data: pointer to populate platform_data pointer with 196 * @parent: Linux device model parent device. 197 * 198 * Returns pointer to created platform device, or NULL if a device was not 199 * registered. Unavailable devices will not get registered. 200 */ 201 static struct platform_device *of_platform_device_create_pdata( 202 struct device_node *np, 203 const char *bus_id, 204 void *platform_data, 205 struct device *parent) 206 { 207 struct platform_device *dev; 208 209 if (!of_device_is_available(np)) 210 return NULL; 211 212 dev = of_device_alloc(np, bus_id, parent); 213 if (!dev) 214 return NULL; 215 216 #if defined(CONFIG_MICROBLAZE) 217 dev->archdata.dma_mask = 0xffffffffUL; 218 #endif 219 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 220 if (!dev->dev.dma_mask) 221 dev->dev.dma_mask = &dev->dev.coherent_dma_mask; 222 dev->dev.bus = &platform_bus_type; 223 dev->dev.platform_data = platform_data; 224 225 /* We do not fill the DMA ops for platform devices by default. 226 * This is currently the responsibility of the platform code 227 * to do such, possibly using a device notifier 228 */ 229 230 if (of_device_add(dev) != 0) { 231 platform_device_put(dev); 232 return NULL; 233 } 234 235 return dev; 236 } 237 238 /** 239 * of_platform_device_create - Alloc, initialize and register an of_device 240 * @np: pointer to node to create device for 241 * @bus_id: name to assign device 242 * @parent: Linux device model parent device. 243 * 244 * Returns pointer to created platform device, or NULL if a device was not 245 * registered. Unavailable devices will not get registered. 246 */ 247 struct platform_device *of_platform_device_create(struct device_node *np, 248 const char *bus_id, 249 struct device *parent) 250 { 251 return of_platform_device_create_pdata(np, bus_id, NULL, parent); 252 } 253 EXPORT_SYMBOL(of_platform_device_create); 254 255 #ifdef CONFIG_ARM_AMBA 256 static struct amba_device *of_amba_device_create(struct device_node *node, 257 const char *bus_id, 258 void *platform_data, 259 struct device *parent) 260 { 261 struct amba_device *dev; 262 const void *prop; 263 int i, ret; 264 265 pr_debug("Creating amba device %s\n", node->full_name); 266 267 if (!of_device_is_available(node)) 268 return NULL; 269 270 dev = amba_device_alloc(NULL, 0, 0); 271 if (!dev) { 272 pr_err("%s(): amba_device_alloc() failed for %s\n", 273 __func__, node->full_name); 274 return NULL; 275 } 276 277 /* setup generic device info */ 278 dev->dev.coherent_dma_mask = ~0; 279 dev->dev.of_node = of_node_get(node); 280 dev->dev.parent = parent; 281 dev->dev.platform_data = platform_data; 282 if (bus_id) 283 dev_set_name(&dev->dev, "%s", bus_id); 284 else 285 of_device_make_bus_id(&dev->dev); 286 287 /* Allow the HW Peripheral ID to be overridden */ 288 prop = of_get_property(node, "arm,primecell-periphid", NULL); 289 if (prop) 290 dev->periphid = of_read_ulong(prop, 1); 291 292 /* Decode the IRQs and address ranges */ 293 for (i = 0; i < AMBA_NR_IRQS; i++) 294 dev->irq[i] = irq_of_parse_and_map(node, i); 295 296 ret = of_address_to_resource(node, 0, &dev->res); 297 if (ret) { 298 pr_err("%s(): of_address_to_resource() failed (%d) for %s\n", 299 __func__, ret, node->full_name); 300 goto err_free; 301 } 302 303 ret = amba_device_add(dev, &iomem_resource); 304 if (ret) { 305 pr_err("%s(): amba_device_add() failed (%d) for %s\n", 306 __func__, ret, node->full_name); 307 goto err_free; 308 } 309 310 return dev; 311 312 err_free: 313 amba_device_put(dev); 314 return NULL; 315 } 316 #else /* CONFIG_ARM_AMBA */ 317 static struct amba_device *of_amba_device_create(struct device_node *node, 318 const char *bus_id, 319 void *platform_data, 320 struct device *parent) 321 { 322 return NULL; 323 } 324 #endif /* CONFIG_ARM_AMBA */ 325 326 /** 327 * of_devname_lookup() - Given a device node, lookup the preferred Linux name 328 */ 329 static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup, 330 struct device_node *np) 331 { 332 struct resource res; 333 334 if (!lookup) 335 return NULL; 336 337 for(; lookup->compatible != NULL; lookup++) { 338 if (!of_device_is_compatible(np, lookup->compatible)) 339 continue; 340 if (!of_address_to_resource(np, 0, &res)) 341 if (res.start != lookup->phys_addr) 342 continue; 343 pr_debug("%s: devname=%s\n", np->full_name, lookup->name); 344 return lookup; 345 } 346 347 return NULL; 348 } 349 350 /** 351 * of_platform_bus_create() - Create a device for a node and its children. 352 * @bus: device node of the bus to instantiate 353 * @matches: match table for bus nodes 354 * @lookup: auxdata table for matching id and platform_data with device nodes 355 * @parent: parent for new device, or NULL for top level. 356 * @strict: require compatible property 357 * 358 * Creates a platform_device for the provided device_node, and optionally 359 * recursively create devices for all the child nodes. 360 */ 361 static int of_platform_bus_create(struct device_node *bus, 362 const struct of_device_id *matches, 363 const struct of_dev_auxdata *lookup, 364 struct device *parent, bool strict) 365 { 366 const struct of_dev_auxdata *auxdata; 367 struct device_node *child; 368 struct platform_device *dev; 369 const char *bus_id = NULL; 370 void *platform_data = NULL; 371 int rc = 0; 372 373 /* Make sure it has a compatible property */ 374 if (strict && (!of_get_property(bus, "compatible", NULL))) { 375 pr_debug("%s() - skipping %s, no compatible prop\n", 376 __func__, bus->full_name); 377 return 0; 378 } 379 380 auxdata = of_dev_lookup(lookup, bus); 381 if (auxdata) { 382 bus_id = auxdata->name; 383 platform_data = auxdata->platform_data; 384 } 385 386 if (of_device_is_compatible(bus, "arm,primecell")) { 387 /* 388 * Don't return an error here to keep compatibility with older 389 * device tree files. 390 */ 391 of_amba_device_create(bus, bus_id, platform_data, parent); 392 return 0; 393 } 394 395 dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent); 396 if (!dev || !of_match_node(matches, bus)) 397 return 0; 398 399 for_each_child_of_node(bus, child) { 400 pr_debug(" create child: %s\n", child->full_name); 401 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict); 402 if (rc) { 403 of_node_put(child); 404 break; 405 } 406 } 407 return rc; 408 } 409 410 /** 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 * @parent: parent to hook devices from, NULL for toplevel 415 * 416 * Note that children of the provided root are not instantiated as devices 417 * unless the specified root itself matches the bus list and is not NULL. 418 */ 419 int of_platform_bus_probe(struct device_node *root, 420 const struct of_device_id *matches, 421 struct device *parent) 422 { 423 struct device_node *child; 424 int rc = 0; 425 426 root = root ? of_node_get(root) : of_find_node_by_path("/"); 427 if (!root) 428 return -EINVAL; 429 430 pr_debug("of_platform_bus_probe()\n"); 431 pr_debug(" starting at: %s\n", root->full_name); 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 if (!of_match_node(matches, child)) 438 continue; 439 rc = of_platform_bus_create(child, matches, NULL, parent, false); 440 if (rc) 441 break; 442 } 443 444 of_node_put(root); 445 return rc; 446 } 447 EXPORT_SYMBOL(of_platform_bus_probe); 448 449 /** 450 * of_platform_populate() - Populate platform_devices from device tree data 451 * @root: parent of the first level to probe or NULL for the root of the tree 452 * @matches: match table, NULL to use the default 453 * @lookup: auxdata table for matching id and platform_data with device nodes 454 * @parent: parent to hook devices from, NULL for toplevel 455 * 456 * Similar to of_platform_bus_probe(), this function walks the device tree 457 * and creates devices from nodes. It differs in that it follows the modern 458 * convention of requiring all device nodes to have a 'compatible' property, 459 * and it is suitable for creating devices which are children of the root 460 * node (of_platform_bus_probe will only create children of the root which 461 * are selected by the @matches argument). 462 * 463 * New board support should be using this function instead of 464 * of_platform_bus_probe(). 465 * 466 * Returns 0 on success, < 0 on failure. 467 */ 468 int of_platform_populate(struct device_node *root, 469 const struct of_device_id *matches, 470 const struct of_dev_auxdata *lookup, 471 struct device *parent) 472 { 473 struct device_node *child; 474 int rc = 0; 475 476 root = root ? of_node_get(root) : of_find_node_by_path("/"); 477 if (!root) 478 return -EINVAL; 479 480 for_each_child_of_node(root, child) { 481 rc = of_platform_bus_create(child, matches, lookup, parent, true); 482 if (rc) 483 break; 484 } 485 486 of_node_put(root); 487 return rc; 488 } 489 EXPORT_SYMBOL_GPL(of_platform_populate); 490 #endif /* CONFIG_OF_ADDRESS */ 491