1/* 2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. 3 * <benh@kernel.crashing.org> 4 * and Arnd Bergmann, IBM Corp. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 * 11 */ 12 13#undef DEBUG 14 15#include <linux/string.h> 16#include <linux/kernel.h> 17#include <linux/init.h> 18#include <linux/module.h> 19#include <linux/mod_devicetable.h> 20#include <linux/slab.h> 21#include <linux/pci.h> 22 23#include <asm/errno.h> 24#include <asm/dcr.h> 25#include <asm/of_device.h> 26#include <asm/of_platform.h> 27#include <asm/topology.h> 28#include <asm/pci-bridge.h> 29#include <asm/ppc-pci.h> 30#include <asm/atomic.h> 31 32/* 33 * The list of OF IDs below is used for matching bus types in the 34 * system whose devices are to be exposed as of_platform_devices. 35 * 36 * This is the default list valid for most platforms. This file provides 37 * functions who can take an explicit list if necessary though 38 * 39 * The search is always performed recursively looking for children of 40 * the provided device_node and recursively if such a children matches 41 * a bus type in the list 42 */ 43 44static struct of_device_id of_default_bus_ids[] = { 45 { .type = "soc", }, 46 { .compatible = "soc", }, 47 { .type = "spider", }, 48 { .type = "axon", }, 49 { .type = "plb5", }, 50 { .type = "plb4", }, 51 { .type = "opb", }, 52 { .type = "ebc", }, 53 {}, 54}; 55 56static atomic_t bus_no_reg_magic; 57 58/* 59 * 60 * OF platform device type definition & base infrastructure 61 * 62 */ 63 64static int of_platform_bus_match(struct device *dev, struct device_driver *drv) 65{ 66 struct of_device * of_dev = to_of_device(dev); 67 struct of_platform_driver * of_drv = to_of_platform_driver(drv); 68 const struct of_device_id * matches = of_drv->match_table; 69 70 if (!matches) 71 return 0; 72 73 return of_match_device(matches, of_dev) != NULL; 74} 75 76static int of_platform_device_probe(struct device *dev) 77{ 78 int error = -ENODEV; 79 struct of_platform_driver *drv; 80 struct of_device *of_dev; 81 const struct of_device_id *match; 82 83 drv = to_of_platform_driver(dev->driver); 84 of_dev = to_of_device(dev); 85 86 if (!drv->probe) 87 return error; 88 89 of_dev_get(of_dev); 90 91 match = of_match_device(drv->match_table, of_dev); 92 if (match) 93 error = drv->probe(of_dev, match); 94 if (error) 95 of_dev_put(of_dev); 96 97 return error; 98} 99 100static int of_platform_device_remove(struct device *dev) 101{ 102 struct of_device * of_dev = to_of_device(dev); 103 struct of_platform_driver * drv = to_of_platform_driver(dev->driver); 104 105 if (dev->driver && drv->remove) 106 drv->remove(of_dev); 107 return 0; 108} 109 110static int of_platform_device_suspend(struct device *dev, pm_message_t state) 111{ 112 struct of_device * of_dev = to_of_device(dev); 113 struct of_platform_driver * drv = to_of_platform_driver(dev->driver); 114 int error = 0; 115 116 if (dev->driver && drv->suspend) 117 error = drv->suspend(of_dev, state); 118 return error; 119} 120 121static int of_platform_device_resume(struct device * dev) 122{ 123 struct of_device * of_dev = to_of_device(dev); 124 struct of_platform_driver * drv = to_of_platform_driver(dev->driver); 125 int error = 0; 126 127 if (dev->driver && drv->resume) 128 error = drv->resume(of_dev); 129 return error; 130} 131 132struct bus_type of_platform_bus_type = { 133 .name = "of_platform", 134 .match = of_platform_bus_match, 135 .uevent = of_device_uevent, 136 .probe = of_platform_device_probe, 137 .remove = of_platform_device_remove, 138 .suspend = of_platform_device_suspend, 139 .resume = of_platform_device_resume, 140}; 141EXPORT_SYMBOL(of_platform_bus_type); 142 143static int __init of_bus_driver_init(void) 144{ 145 return bus_register(&of_platform_bus_type); 146} 147 148postcore_initcall(of_bus_driver_init); 149 150int of_register_platform_driver(struct of_platform_driver *drv) 151{ 152 /* initialize common driver fields */ 153 drv->driver.name = drv->name; 154 drv->driver.bus = &of_platform_bus_type; 155 156 /* register with core */ 157 return driver_register(&drv->driver); 158} 159EXPORT_SYMBOL(of_register_platform_driver); 160 161void of_unregister_platform_driver(struct of_platform_driver *drv) 162{ 163 driver_unregister(&drv->driver); 164} 165EXPORT_SYMBOL(of_unregister_platform_driver); 166 167static void of_platform_make_bus_id(struct of_device *dev) 168{ 169 struct device_node *node = dev->node; 170 char *name = dev->dev.bus_id; 171 const u32 *reg; 172 u64 addr; 173 int magic; 174 175 /* 176 * If it's a DCR based device, use 'd' for native DCRs 177 * and 'D' for MMIO DCRs. 178 */ 179#ifdef CONFIG_PPC_DCR 180 reg = of_get_property(node, "dcr-reg", NULL); 181 if (reg) { 182#ifdef CONFIG_PPC_DCR_NATIVE 183 snprintf(name, BUS_ID_SIZE, "d%x.%s", 184 *reg, node->name); 185#else /* CONFIG_PPC_DCR_NATIVE */ 186 addr = of_translate_dcr_address(node, *reg, NULL); 187 if (addr != OF_BAD_ADDR) { 188 snprintf(name, BUS_ID_SIZE, 189 "D%llx.%s", (unsigned long long)addr, 190 node->name); 191 return; 192 } 193#endif /* !CONFIG_PPC_DCR_NATIVE */ 194 } 195#endif /* CONFIG_PPC_DCR */ 196 197 /* 198 * For MMIO, get the physical address 199 */ 200 reg = of_get_property(node, "reg", NULL); 201 if (reg) { 202 addr = of_translate_address(node, reg); 203 if (addr != OF_BAD_ADDR) { 204 snprintf(name, BUS_ID_SIZE, 205 "%llx.%s", (unsigned long long)addr, 206 node->name); 207 return; 208 } 209 } 210 211 /* 212 * No BusID, use the node name and add a globally incremented 213 * counter (and pray...) 214 */ 215 magic = atomic_add_return(1, &bus_no_reg_magic); 216 snprintf(name, BUS_ID_SIZE, "%s.%d", node->name, magic - 1); 217} 218 219struct of_device* of_platform_device_create(struct device_node *np, 220 const char *bus_id, 221 struct device *parent) 222{ 223 struct of_device *dev; 224 225 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 226 if (!dev) 227 return NULL; 228 memset(dev, 0, sizeof(*dev)); 229 230 dev->node = of_node_get(np); 231 dev->dma_mask = 0xffffffffUL; 232 dev->dev.dma_mask = &dev->dma_mask; 233 dev->dev.parent = parent; 234 dev->dev.bus = &of_platform_bus_type; 235 dev->dev.release = of_release_dev; 236 dev->dev.archdata.of_node = np; 237 dev->dev.archdata.numa_node = of_node_to_nid(np); 238 239 /* We do not fill the DMA ops for platform devices by default. 240 * This is currently the responsibility of the platform code 241 * to do such, possibly using a device notifier 242 */ 243 244 if (bus_id) 245 strlcpy(dev->dev.bus_id, bus_id, BUS_ID_SIZE); 246 else 247 of_platform_make_bus_id(dev); 248 249 if (of_device_register(dev) != 0) { 250 kfree(dev); 251 return NULL; 252 } 253 254 return dev; 255} 256EXPORT_SYMBOL(of_platform_device_create); 257 258 259 260/** 261 * of_platform_bus_create - Create an OF device for a bus node and all its 262 * children. Optionally recursively instanciate matching busses. 263 * @bus: device node of the bus to instanciate 264 * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to 265 * disallow recursive creation of child busses 266 */ 267static int of_platform_bus_create(struct device_node *bus, 268 struct of_device_id *matches, 269 struct device *parent) 270{ 271 struct device_node *child; 272 struct of_device *dev; 273 int rc = 0; 274 275 for (child = NULL; (child = of_get_next_child(bus, child)); ) { 276 pr_debug(" create child: %s\n", child->full_name); 277 dev = of_platform_device_create(child, NULL, parent); 278 if (dev == NULL) 279 rc = -ENOMEM; 280 else if (!of_match_node(matches, child)) 281 continue; 282 if (rc == 0) { 283 pr_debug(" and sub busses\n"); 284 rc = of_platform_bus_create(child, matches, &dev->dev); 285 } if (rc) { 286 of_node_put(child); 287 break; 288 } 289 } 290 return rc; 291} 292 293/** 294 * of_platform_bus_probe - Probe the device-tree for platform busses 295 * @root: parent of the first level to probe or NULL for the root of the tree 296 * @matches: match table, NULL to use the default 297 * @parent: parent to hook devices from, NULL for toplevel 298 * 299 * Note that children of the provided root are not instanciated as devices 300 * unless the specified root itself matches the bus list and is not NULL. 301 */ 302 303int of_platform_bus_probe(struct device_node *root, 304 struct of_device_id *matches, 305 struct device *parent) 306{ 307 struct device_node *child; 308 struct of_device *dev; 309 int rc = 0; 310 311 if (matches == NULL) 312 matches = of_default_bus_ids; 313 if (matches == OF_NO_DEEP_PROBE) 314 return -EINVAL; 315 if (root == NULL) 316 root = of_find_node_by_path("/"); 317 else 318 of_node_get(root); 319 320 pr_debug("of_platform_bus_probe()\n"); 321 pr_debug(" starting at: %s\n", root->full_name); 322 323 /* Do a self check of bus type, if there's a match, create 324 * children 325 */ 326 if (of_match_node(matches, root)) { 327 pr_debug(" root match, create all sub devices\n"); 328 dev = of_platform_device_create(root, NULL, parent); 329 if (dev == NULL) { 330 rc = -ENOMEM; 331 goto bail; 332 } 333 pr_debug(" create all sub busses\n"); 334 rc = of_platform_bus_create(root, matches, &dev->dev); 335 goto bail; 336 } 337 for (child = NULL; (child = of_get_next_child(root, child)); ) { 338 if (!of_match_node(matches, child)) 339 continue; 340 341 pr_debug(" match: %s\n", child->full_name); 342 dev = of_platform_device_create(child, NULL, parent); 343 if (dev == NULL) 344 rc = -ENOMEM; 345 else 346 rc = of_platform_bus_create(child, matches, &dev->dev); 347 if (rc) { 348 of_node_put(child); 349 break; 350 } 351 } 352 bail: 353 of_node_put(root); 354 return rc; 355} 356EXPORT_SYMBOL(of_platform_bus_probe); 357 358static int of_dev_node_match(struct device *dev, void *data) 359{ 360 return to_of_device(dev)->node == data; 361} 362 363struct of_device *of_find_device_by_node(struct device_node *np) 364{ 365 struct device *dev; 366 367 dev = bus_find_device(&of_platform_bus_type, 368 NULL, np, of_dev_node_match); 369 if (dev) 370 return to_of_device(dev); 371 return NULL; 372} 373EXPORT_SYMBOL(of_find_device_by_node); 374 375static int of_dev_phandle_match(struct device *dev, void *data) 376{ 377 phandle *ph = data; 378 return to_of_device(dev)->node->linux_phandle == *ph; 379} 380 381struct of_device *of_find_device_by_phandle(phandle ph) 382{ 383 struct device *dev; 384 385 dev = bus_find_device(&of_platform_bus_type, 386 NULL, &ph, of_dev_phandle_match); 387 if (dev) 388 return to_of_device(dev); 389 return NULL; 390} 391EXPORT_SYMBOL(of_find_device_by_phandle); 392 393 394#ifdef CONFIG_PPC_OF_PLATFORM_PCI 395 396/* The probing of PCI controllers from of_platform is currently 397 * 64 bits only, mostly due to gratuitous differences between 398 * the 32 and 64 bits PCI code on PowerPC and the 32 bits one 399 * lacking some bits needed here. 400 */ 401 402static int __devinit of_pci_phb_probe(struct of_device *dev, 403 const struct of_device_id *match) 404{ 405 struct pci_controller *phb; 406 407 /* Check if we can do that ... */ 408 if (ppc_md.pci_setup_phb == NULL) 409 return -ENODEV; 410 411 printk(KERN_INFO "Setting up PCI bus %s\n", dev->node->full_name); 412 413 /* Alloc and setup PHB data structure */ 414 phb = pcibios_alloc_controller(dev->node); 415 if (!phb) 416 return -ENODEV; 417 418 /* Setup parent in sysfs */ 419 phb->parent = &dev->dev; 420 421 /* Setup the PHB using arch provided callback */ 422 if (ppc_md.pci_setup_phb(phb)) { 423 pcibios_free_controller(phb); 424 return -ENODEV; 425 } 426 427 /* Process "ranges" property */ 428 pci_process_bridge_OF_ranges(phb, dev->node, 0); 429 430 /* Setup IO space. We use the non-dynamic version of that code here, 431 * which doesn't quite support unplugging. Next kernel release will 432 * have a better fix for this. 433 * Note also that we don't do ISA, this will also be fixed with a 434 * more massive rework. 435 */ 436 pci_setup_phb_io(phb, pci_io_base == 0); 437 438 /* Init pci_dn data structures */ 439 pci_devs_phb_init_dynamic(phb); 440 441 /* Register devices with EEH */ 442#ifdef CONFIG_EEH 443 if (dev->node->child) 444 eeh_add_device_tree_early(dev->node); 445#endif /* CONFIG_EEH */ 446 447 /* Scan the bus */ 448 scan_phb(phb); 449 450 /* Claim resources. This might need some rework as well depending 451 * wether we are doing probe-only or not, like assigning unassigned 452 * resources etc... 453 */ 454 pcibios_claim_one_bus(phb->bus); 455 456 /* Finish EEH setup */ 457#ifdef CONFIG_EEH 458 eeh_add_device_tree_late(phb->bus); 459#endif 460 461 /* Add probed PCI devices to the device model */ 462 pci_bus_add_devices(phb->bus); 463 464 return 0; 465} 466 467static struct of_device_id of_pci_phb_ids[] = { 468 { .type = "pci", }, 469 { .type = "pcix", }, 470 { .type = "pcie", }, 471 { .type = "pciex", }, 472 { .type = "ht", }, 473 {} 474}; 475 476static struct of_platform_driver of_pci_phb_driver = { 477 .name = "of-pci", 478 .match_table = of_pci_phb_ids, 479 .probe = of_pci_phb_probe, 480}; 481 482static __init int of_pci_phb_init(void) 483{ 484 return of_register_platform_driver(&of_pci_phb_driver); 485} 486 487device_initcall(of_pci_phb_init); 488 489#endif /* CONFIG_PPC_OF_PLATFORM_PCI */ 490