arch/powerpc/kernel/of_platform.c

   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 #include <linux/of.h>
  23 #include <linux/of_device.h>
  24 #include <linux/of_platform.h>
  25
  26 #include <asm/errno.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
  44 static const 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
  56 struct bus_type of_platform_bus_type = {
  57        .uevent  = of_device_uevent,
  58 };
  59 EXPORT_SYMBOL(of_platform_bus_type);
  60
  61 static int __init of_bus_driver_init(void)
  62 {
  63         return of_bus_type_init(&of_platform_bus_type, "of_platform");
  64 }
  65
  66 postcore_initcall(of_bus_driver_init);
  67
  68 struct of_device* of_platform_device_create(struct device_node *np,
  69                                             const char *bus_id,
  70                                             struct device *parent)
  71 {
  72         struct of_device *dev;
  73
  74         dev = of_device_alloc(np, bus_id, parent);
  75         if (!dev)
  76                 return NULL;
  77
  78         dev->dma_mask = 0xffffffffUL;
  79         dev->dev.bus = &of_platform_bus_type;
  80
  81         /* We do not fill the DMA ops for platform devices by default.
  82          * This is currently the responsibility of the platform code
  83          * to do such, possibly using a device notifier
  84          */
  85
  86         if (of_device_register(dev) != 0) {
  87                 of_device_free(dev);
  88                 return NULL;
  89         }
  90
  91         return dev;
  92 }
  93 EXPORT_SYMBOL(of_platform_device_create);
  94
  95
  96
  97 /**
  98  * of_platform_bus_create - Create an OF device for a bus node and all its
  99  * children. Optionally recursively instanciate matching busses.
 100  * @bus: device node of the bus to instanciate
 101  * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
 102  * disallow recursive creation of child busses
 103  */
 104 static int of_platform_bus_create(const struct device_node *bus,
 105                                   const struct of_device_id *matches,
 106                                   struct device *parent)
 107 {
 108         struct device_node *child;
 109         struct of_device *dev;
 110         int rc = 0;
 111
 112         for_each_child_of_node(bus, child) {
 113                 pr_debug("   create child: %s\n", child->full_name);
 114                 dev = of_platform_device_create(child, NULL, parent);
 115                 if (dev == NULL)
 116                         rc = -ENOMEM;
 117                 else if (!of_match_node(matches, child))
 118                         continue;
 119                 if (rc == 0) {
 120                         pr_debug("   and sub busses\n");
 121                         rc = of_platform_bus_create(child, matches, &dev->dev);
 122                 } if (rc) {
 123                         of_node_put(child);
 124                         break;
 125                 }
 126         }
 127         return rc;
 128 }
 129
 130 /**
 131  * of_platform_bus_probe - Probe the device-tree for platform busses
 132  * @root: parent of the first level to probe or NULL for the root of the tree
 133  * @matches: match table, NULL to use the default
 134  * @parent: parent to hook devices from, NULL for toplevel
 135  *
 136  * Note that children of the provided root are not instanciated as devices
 137  * unless the specified root itself matches the bus list and is not NULL.
 138  */
 139
 140 int of_platform_bus_probe(struct device_node *root,
 141                           const struct of_device_id *matches,
 142                           struct device *parent)
 143 {
 144         struct device_node *child;
 145         struct of_device *dev;
 146         int rc = 0;
 147
 148         if (matches == NULL)
 149                 matches = of_default_bus_ids;
 150         if (matches == OF_NO_DEEP_PROBE)
 151                 return -EINVAL;
 152         if (root == NULL)
 153                 root = of_find_node_by_path("/");
 154         else
 155                 of_node_get(root);
 156
 157         pr_debug("of_platform_bus_probe()\n");
 158         pr_debug(" starting at: %s\n", root->full_name);
 159
 160         /* Do a self check of bus type, if there's a match, create
 161          * children
 162          */
 163         if (of_match_node(matches, root)) {
 164                 pr_debug(" root match, create all sub devices\n");
 165                 dev = of_platform_device_create(root, NULL, parent);
 166                 if (dev == NULL) {
 167                         rc = -ENOMEM;
 168                         goto bail;
 169                 }
 170                 pr_debug(" create all sub busses\n");
 171                 rc = of_platform_bus_create(root, matches, &dev->dev);
 172                 goto bail;
 173         }
 174         for_each_child_of_node(root, child) {
 175                 if (!of_match_node(matches, child))
 176                         continue;
 177
 178                 pr_debug("  match: %s\n", child->full_name);
 179                 dev = of_platform_device_create(child, NULL, parent);
 180                 if (dev == NULL)
 181                         rc = -ENOMEM;
 182                 else
 183                         rc = of_platform_bus_create(child, matches, &dev->dev);
 184                 if (rc) {
 185                         of_node_put(child);
 186                         break;
 187                 }
 188         }
 189  bail:
 190         of_node_put(root);
 191         return rc;
 192 }
 193 EXPORT_SYMBOL(of_platform_bus_probe);
 194
 195 static int of_dev_node_match(struct device *dev, void *data)
 196 {
 197         return to_of_device(dev)->node == data;
 198 }
 199
 200 struct of_device *of_find_device_by_node(struct device_node *np)
 201 {
 202         struct device *dev;
 203
 204         dev = bus_find_device(&of_platform_bus_type,
 205                               NULL, np, of_dev_node_match);
 206         if (dev)
 207                 return to_of_device(dev);
 208         return NULL;
 209 }
 210 EXPORT_SYMBOL(of_find_device_by_node);
 211
 212 static int of_dev_phandle_match(struct device *dev, void *data)
 213 {
 214         phandle *ph = data;
 215         return to_of_device(dev)->node->linux_phandle == *ph;
 216 }
 217
 218 struct of_device *of_find_device_by_phandle(phandle ph)
 219 {
 220         struct device *dev;
 221
 222         dev = bus_find_device(&of_platform_bus_type,
 223                               NULL, &ph, of_dev_phandle_match);
 224         if (dev)
 225                 return to_of_device(dev);
 226         return NULL;
 227 }
 228 EXPORT_SYMBOL(of_find_device_by_phandle);
 229
 230
 231 #ifdef CONFIG_PPC_OF_PLATFORM_PCI
 232
 233 /* The probing of PCI controllers from of_platform is currently
 234  * 64 bits only, mostly due to gratuitous differences between
 235  * the 32 and 64 bits PCI code on PowerPC and the 32 bits one
 236  * lacking some bits needed here.
 237  */
 238
 239 static int __devinit of_pci_phb_probe(struct of_device *dev,
 240                                       const struct of_device_id *match)
 241 {
 242         struct pci_controller *phb;
 243
 244         /* Check if we can do that ... */
 245         if (ppc_md.pci_setup_phb == NULL)
 246                 return -ENODEV;
 247
 248         printk(KERN_INFO "Setting up PCI bus %s\n", dev->node->full_name);
 249
 250         /* Alloc and setup PHB data structure */
 251         phb = pcibios_alloc_controller(dev->node);
 252         if (!phb)
 253                 return -ENODEV;
 254
 255         /* Setup parent in sysfs */
 256         phb->parent = &dev->dev;
 257
 258         /* Setup the PHB using arch provided callback */
 259         if (ppc_md.pci_setup_phb(phb)) {
 260                 pcibios_free_controller(phb);
 261                 return -ENODEV;
 262         }
 263
 264         /* Process "ranges" property */
 265         pci_process_bridge_OF_ranges(phb, dev->node, 0);
 266
 267         /* Init pci_dn data structures */
 268         pci_devs_phb_init_dynamic(phb);
 269
 270         /* Register devices with EEH */
 271 #ifdef CONFIG_EEH
 272         if (dev->node->child)
 273                 eeh_add_device_tree_early(dev->node);
 274 #endif /* CONFIG_EEH */
 275
 276         /* Scan the bus */
 277         scan_phb(phb);
 278
 279         /* Claim resources. This might need some rework as well depending
 280          * wether we are doing probe-only or not, like assigning unassigned
 281          * resources etc...
 282          */
 283         pcibios_claim_one_bus(phb->bus);
 284
 285         /* Finish EEH setup */
 286 #ifdef CONFIG_EEH
 287         eeh_add_device_tree_late(phb->bus);
 288 #endif
 289
 290         /* Add probed PCI devices to the device model */
 291         pci_bus_add_devices(phb->bus);
 292
 293         return 0;
 294 }
 295
 296 static struct of_device_id of_pci_phb_ids[] = {
 297         { .type = "pci", },
 298         { .type = "pcix", },
 299         { .type = "pcie", },
 300         { .type = "pciex", },
 301         { .type = "ht", },
 302         {}
 303 };
 304
 305 static struct of_platform_driver of_pci_phb_driver = {
 306         .match_table = of_pci_phb_ids,
 307         .probe = of_pci_phb_probe,
 308         .driver = {
 309                 .name = "of-pci",
 310         },
 311 };
 312
 313 static __init int of_pci_phb_init(void)
 314 {
 315         return of_register_platform_driver(&of_pci_phb_driver);
 316 }
 317
 318 device_initcall(of_pci_phb_init);
 319
 320 #endif /* CONFIG_PPC_OF_PLATFORM_PCI */