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/device.h> 17 #include <linux/dma-mapping.h> 18 #include <linux/slab.h> 19 #include <linux/of_address.h> 20 #include <linux/of_device.h> 21 #include <linux/of_irq.h> 22 #include <linux/of_platform.h> 23 #include <linux/platform_device.h> 24 25 static int of_dev_node_match(struct device *dev, void *data) 26 { 27 return dev->of_node == data; 28 } 29 30 /** 31 * of_find_device_by_node - Find the platform_device associated with a node 32 * @np: Pointer to device tree node 33 * 34 * Returns platform_device pointer, or NULL if not found 35 */ 36 struct platform_device *of_find_device_by_node(struct device_node *np) 37 { 38 struct device *dev; 39 40 dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match); 41 return dev ? to_platform_device(dev) : NULL; 42 } 43 EXPORT_SYMBOL(of_find_device_by_node); 44 45 #if defined(CONFIG_PPC_DCR) 46 #include <asm/dcr.h> 47 #endif 48 49 #if !defined(CONFIG_SPARC) 50 /* 51 * The following routines scan a subtree and registers a device for 52 * each applicable node. 53 * 54 * Note: sparc doesn't use these routines because it has a different 55 * mechanism for creating devices from device tree nodes. 56 */ 57 58 /** 59 * of_device_make_bus_id - Use the device node data to assign a unique name 60 * @dev: pointer to device structure that is linked to a device tree node 61 * 62 * This routine will first try using either the dcr-reg or the reg property 63 * value to derive a unique name. As a last resort it will use the node 64 * name followed by a unique number. 65 */ 66 void of_device_make_bus_id(struct device *dev) 67 { 68 static atomic_t bus_no_reg_magic; 69 struct device_node *node = dev->of_node; 70 const u32 *reg; 71 u64 addr; 72 int magic; 73 74 #ifdef CONFIG_PPC_DCR 75 /* 76 * If it's a DCR based device, use 'd' for native DCRs 77 * and 'D' for MMIO DCRs. 78 */ 79 reg = of_get_property(node, "dcr-reg", NULL); 80 if (reg) { 81 #ifdef CONFIG_PPC_DCR_NATIVE 82 dev_set_name(dev, "d%x.%s", *reg, node->name); 83 #else /* CONFIG_PPC_DCR_NATIVE */ 84 u64 addr = of_translate_dcr_address(node, *reg, NULL); 85 if (addr != OF_BAD_ADDR) { 86 dev_set_name(dev, "D%llx.%s", 87 (unsigned long long)addr, node->name); 88 return; 89 } 90 #endif /* !CONFIG_PPC_DCR_NATIVE */ 91 } 92 #endif /* CONFIG_PPC_DCR */ 93 94 /* 95 * For MMIO, get the physical address 96 */ 97 reg = of_get_property(node, "reg", NULL); 98 if (reg) { 99 addr = of_translate_address(node, reg); 100 if (addr != OF_BAD_ADDR) { 101 dev_set_name(dev, "%llx.%s", 102 (unsigned long long)addr, node->name); 103 return; 104 } 105 } 106 107 /* 108 * No BusID, use the node name and add a globally incremented 109 * counter (and pray...) 110 */ 111 magic = atomic_add_return(1, &bus_no_reg_magic); 112 dev_set_name(dev, "%s.%d", node->name, magic - 1); 113 } 114 115 /** 116 * of_device_alloc - Allocate and initialize an of_device 117 * @np: device node to assign to device 118 * @bus_id: Name to assign to the device. May be null to use default name. 119 * @parent: Parent device. 120 */ 121 struct platform_device *of_device_alloc(struct device_node *np, 122 const char *bus_id, 123 struct device *parent) 124 { 125 struct platform_device *dev; 126 int rc, i, num_reg = 0, num_irq; 127 struct resource *res, temp_res; 128 129 dev = platform_device_alloc("", -1); 130 if (!dev) 131 return NULL; 132 133 /* count the io and irq resources */ 134 while (of_address_to_resource(np, num_reg, &temp_res) == 0) 135 num_reg++; 136 num_irq = of_irq_count(np); 137 138 /* Populate the resource table */ 139 if (num_irq || num_reg) { 140 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL); 141 if (!res) { 142 platform_device_put(dev); 143 return NULL; 144 } 145 146 dev->num_resources = num_reg + num_irq; 147 dev->resource = res; 148 for (i = 0; i < num_reg; i++, res++) { 149 rc = of_address_to_resource(np, i, res); 150 WARN_ON(rc); 151 } 152 WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq); 153 } 154 155 dev->dev.of_node = of_node_get(np); 156 #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 157 dev->dev.dma_mask = &dev->archdata.dma_mask; 158 #endif 159 dev->dev.parent = parent; 160 161 if (bus_id) 162 dev_set_name(&dev->dev, "%s", bus_id); 163 else 164 of_device_make_bus_id(&dev->dev); 165 166 return dev; 167 } 168 EXPORT_SYMBOL(of_device_alloc); 169 170 /** 171 * of_platform_device_create - Alloc, initialize and register an of_device 172 * @np: pointer to node to create device for 173 * @bus_id: name to assign device 174 * @parent: Linux device model parent device. 175 * 176 * Returns pointer to created platform device, or NULL if a device was not 177 * registered. Unavailable devices will not get registered. 178 */ 179 struct platform_device *of_platform_device_create(struct device_node *np, 180 const char *bus_id, 181 struct device *parent) 182 { 183 struct platform_device *dev; 184 185 if (!of_device_is_available(np)) 186 return NULL; 187 188 dev = of_device_alloc(np, bus_id, parent); 189 if (!dev) 190 return NULL; 191 192 #if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 193 dev->archdata.dma_mask = 0xffffffffUL; 194 #endif 195 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 196 dev->dev.bus = &platform_bus_type; 197 198 /* We do not fill the DMA ops for platform devices by default. 199 * This is currently the responsibility of the platform code 200 * to do such, possibly using a device notifier 201 */ 202 203 if (of_device_add(dev) != 0) { 204 platform_device_put(dev); 205 return NULL; 206 } 207 208 return dev; 209 } 210 EXPORT_SYMBOL(of_platform_device_create); 211 212 /** 213 * of_platform_bus_create - Create an OF device for a bus node and all its 214 * children. Optionally recursively instantiate matching busses. 215 * @bus: device node of the bus to instantiate 216 * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to 217 * disallow recursive creation of child busses 218 */ 219 static int of_platform_bus_create(const struct device_node *bus, 220 const struct of_device_id *matches, 221 struct device *parent) 222 { 223 struct device_node *child; 224 struct platform_device *dev; 225 int rc = 0; 226 227 for_each_child_of_node(bus, child) { 228 pr_debug(" create child: %s\n", child->full_name); 229 dev = of_platform_device_create(child, NULL, parent); 230 if (dev == NULL) 231 continue; 232 233 if (!of_match_node(matches, child)) 234 continue; 235 if (rc == 0) { 236 pr_debug(" and sub busses\n"); 237 rc = of_platform_bus_create(child, matches, &dev->dev); 238 } 239 if (rc) { 240 of_node_put(child); 241 break; 242 } 243 } 244 return rc; 245 } 246 247 /** 248 * of_platform_bus_probe - Probe the device-tree for platform busses 249 * @root: parent of the first level to probe or NULL for the root of the tree 250 * @matches: match table, NULL to use the default 251 * @parent: parent to hook devices from, NULL for toplevel 252 * 253 * Note that children of the provided root are not instantiated as devices 254 * unless the specified root itself matches the bus list and is not NULL. 255 */ 256 int of_platform_bus_probe(struct device_node *root, 257 const struct of_device_id *matches, 258 struct device *parent) 259 { 260 struct device_node *child; 261 struct platform_device *dev; 262 int rc = 0; 263 264 if (WARN_ON(!matches || matches == OF_NO_DEEP_PROBE)) 265 return -EINVAL; 266 if (root == NULL) 267 root = of_find_node_by_path("/"); 268 else 269 of_node_get(root); 270 if (root == NULL) 271 return -EINVAL; 272 273 pr_debug("of_platform_bus_probe()\n"); 274 pr_debug(" starting at: %s\n", root->full_name); 275 276 /* Do a self check of bus type, if there's a match, create 277 * children 278 */ 279 if (of_match_node(matches, root)) { 280 pr_debug(" root match, create all sub devices\n"); 281 dev = of_platform_device_create(root, NULL, parent); 282 if (dev == NULL) 283 goto bail; 284 285 pr_debug(" create all sub busses\n"); 286 rc = of_platform_bus_create(root, matches, &dev->dev); 287 goto bail; 288 } 289 for_each_child_of_node(root, child) { 290 if (!of_match_node(matches, child)) 291 continue; 292 293 pr_debug(" match: %s\n", child->full_name); 294 dev = of_platform_device_create(child, NULL, parent); 295 if (dev == NULL) 296 continue; 297 298 rc = of_platform_bus_create(child, matches, &dev->dev); 299 if (rc) { 300 of_node_put(child); 301 break; 302 } 303 } 304 bail: 305 of_node_put(root); 306 return rc; 307 } 308 EXPORT_SYMBOL(of_platform_bus_probe); 309 #endif /* !CONFIG_SPARC */ 310