Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/of/platform.c

  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         /*
170          * Set default dma-mask to 32 bit. Drivers are expected to setup
171          * the correct supported dma_mask.
172          */
173         dev->coherent_dma_mask = DMA_BIT_MASK(32);
174 
175         /*
176          * Set it to coherent_dma_mask by default if the architecture
177          * code has not set it.
178          */
179         if (!dev->dma_mask)
180                 dev->dma_mask = &dev->coherent_dma_mask;
181 
182         /*
183          * if dma-coherent property exist, call arch hook to setup
184          * dma coherent operations.
185          */
186         if (of_dma_is_coherent(dev->of_node)) {
187                 set_arch_dma_coherent_ops(dev);
188                 dev_dbg(dev, "device is dma coherent\n");
189         }
190 
191         /*
192          * if dma-ranges property doesn't exist - just return else
193          * setup the dma offset
194          */
195         ret = of_dma_get_range(dev->of_node, &dma_addr, &paddr, &size);
196         if (ret < 0) {
197                 dev_dbg(dev, "no dma range information to setup\n");
198                 return;
199         }
200 
201         /* DMA ranges found. Calculate and set dma_pfn_offset */
202         dev->dma_pfn_offset = PFN_DOWN(paddr - dma_addr);
203         dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", dev->dma_pfn_offset);
204 }
205 
206 /**
207  * of_platform_device_create_pdata - Alloc, initialize and register an of_device
208  * @np: pointer to node to create device for
209  * @bus_id: name to assign device
210  * @platform_data: pointer to populate platform_data pointer with
211  * @parent: Linux device model parent device.
212  *
213  * Returns pointer to created platform device, or NULL if a device was not
214  * registered.  Unavailable devices will not get registered.
215  */
216 static struct platform_device *of_platform_device_create_pdata(
217                                         struct device_node *np,
218                                         const char *bus_id,
219                                         void *platform_data,
220                                         struct device *parent)
221 {
222         struct platform_device *dev;
223 
224         if (!of_device_is_available(np) ||
225             of_node_test_and_set_flag(np, OF_POPULATED))
226                 return NULL;
227 
228         dev = of_device_alloc(np, bus_id, parent);
229         if (!dev)
230                 goto err_clear_flag;
231 
232         of_dma_configure(dev);
233         dev->dev.bus = &platform_bus_type;
234         dev->dev.platform_data = platform_data;
235 
236         /* We do not fill the DMA ops for platform devices by default.
237          * This is currently the responsibility of the platform code
238          * to do such, possibly using a device notifier
239          */
240 
241         if (of_device_add(dev) != 0) {
242                 platform_device_put(dev);
243                 goto err_clear_flag;
244         }
245 
246         return dev;
247 
248 err_clear_flag:
249         of_node_clear_flag(np, OF_POPULATED);
250         return NULL;
251 }
252 
253 /**
254  * of_platform_device_create - Alloc, initialize and register an of_device
255  * @np: pointer to node to create device for
256  * @bus_id: name to assign device
257  * @parent: Linux device model parent device.
258  *
259  * Returns pointer to created platform device, or NULL if a device was not
260  * registered.  Unavailable devices will not get registered.
261  */
262 struct platform_device *of_platform_device_create(struct device_node *np,
263                                             const char *bus_id,
264                                             struct device *parent)
265 {
266         return of_platform_device_create_pdata(np, bus_id, NULL, parent);
267 }
268 EXPORT_SYMBOL(of_platform_device_create);
269 
270 #ifdef CONFIG_ARM_AMBA
271 static struct amba_device *of_amba_device_create(struct device_node *node,
272                                                  const char *bus_id,
273                                                  void *platform_data,
274                                                  struct device *parent)
275 {
276         struct amba_device *dev;
277         const void *prop;
278         int i, ret;
279 
280         pr_debug("Creating amba device %s\n", node->full_name);
281 
282         if (!of_device_is_available(node) ||
283             of_node_test_and_set_flag(node, OF_POPULATED))
284                 return NULL;
285 
286         dev = amba_device_alloc(NULL, 0, 0);
287         if (!dev) {
288                 pr_err("%s(): amba_device_alloc() failed for %s\n",
289                        __func__, node->full_name);
290                 goto err_clear_flag;
291         }
292 
293         /* setup generic device info */
294         dev->dev.coherent_dma_mask = ~0;
295         dev->dev.of_node = of_node_get(node);
296         dev->dev.parent = parent;
297         dev->dev.platform_data = platform_data;
298         if (bus_id)
299                 dev_set_name(&dev->dev, "%s", bus_id);
300         else
301                 of_device_make_bus_id(&dev->dev);
302 
303         /* Allow the HW Peripheral ID to be overridden */
304         prop = of_get_property(node, "arm,primecell-periphid", NULL);
305         if (prop)
306                 dev->periphid = of_read_ulong(prop, 1);
307 
308         /* Decode the IRQs and address ranges */
309         for (i = 0; i < AMBA_NR_IRQS; i++)
310                 dev->irq[i] = irq_of_parse_and_map(node, i);
311 
312         ret = of_address_to_resource(node, 0, &dev->res);
313         if (ret) {
314                 pr_err("%s(): of_address_to_resource() failed (%d) for %s\n",
315                        __func__, ret, node->full_name);
316                 goto err_free;
317         }
318 
319         ret = amba_device_add(dev, &iomem_resource);
320         if (ret) {
321                 pr_err("%s(): amba_device_add() failed (%d) for %s\n",
322                        __func__, ret, node->full_name);
323                 goto err_free;
324         }
325 
326         return dev;
327 
328 err_free:
329         amba_device_put(dev);
330 err_clear_flag:
331         of_node_clear_flag(node, OF_POPULATED);
332         return NULL;
333 }
334 #else /* CONFIG_ARM_AMBA */
335 static struct amba_device *of_amba_device_create(struct device_node *node,
336                                                  const char *bus_id,
337                                                  void *platform_data,
338                                                  struct device *parent)
339 {
340         return NULL;
341 }
342 #endif /* CONFIG_ARM_AMBA */
343 
344 /**
345  * of_devname_lookup() - Given a device node, lookup the preferred Linux name
346  */
347 static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
348                                  struct device_node *np)
349 {
350         struct resource res;
351 
352         if (!lookup)
353                 return NULL;
354 
355         for(; lookup->compatible != NULL; lookup++) {
356                 if (!of_device_is_compatible(np, lookup->compatible))
357                         continue;
358                 if (!of_address_to_resource(np, 0, &res))
359                         if (res.start != lookup->phys_addr)
360                                 continue;
361                 pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
362                 return lookup;
363         }
364 
365         return NULL;
366 }
367 
368 /**
369  * of_platform_bus_create() - Create a device for a node and its children.
370  * @bus: device node of the bus to instantiate
371  * @matches: match table for bus nodes
372  * @lookup: auxdata table for matching id and platform_data with device nodes
373  * @parent: parent for new device, or NULL for top level.
374  * @strict: require compatible property
375  *
376  * Creates a platform_device for the provided device_node, and optionally
377  * recursively create devices for all the child nodes.
378  */
379 static int of_platform_bus_create(struct device_node *bus,
380                                   const struct of_device_id *matches,
381                                   const struct of_dev_auxdata *lookup,
382                                   struct device *parent, bool strict)
383 {
384         const struct of_dev_auxdata *auxdata;
385         struct device_node *child;
386         struct platform_device *dev;
387         const char *bus_id = NULL;
388         void *platform_data = NULL;
389         int rc = 0;
390 
391         /* Make sure it has a compatible property */
392         if (strict && (!of_get_property(bus, "compatible", NULL))) {
393                 pr_debug("%s() - skipping %s, no compatible prop\n",
394                          __func__, bus->full_name);
395                 return 0;
396         }
397 
398         auxdata = of_dev_lookup(lookup, bus);
399         if (auxdata) {
400                 bus_id = auxdata->name;
401                 platform_data = auxdata->platform_data;
402         }
403 
404         if (of_device_is_compatible(bus, "arm,primecell")) {
405                 /*
406                  * Don't return an error here to keep compatibility with older
407                  * device tree files.
408                  */
409                 of_amba_device_create(bus, bus_id, platform_data, parent);
410                 return 0;
411         }
412 
413         dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
414         if (!dev || !of_match_node(matches, bus))
415                 return 0;
416 
417         for_each_child_of_node(bus, child) {
418                 pr_debug("   create child: %s\n", child->full_name);
419                 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
420                 if (rc) {
421                         of_node_put(child);
422                         break;
423                 }
424         }
425         return rc;
426 }
427 
428 /**
429  * of_platform_bus_probe() - Probe the device-tree for platform buses
430  * @root: parent of the first level to probe or NULL for the root of the tree
431  * @matches: match table for bus nodes
432  * @parent: parent to hook devices from, NULL for toplevel
433  *
434  * Note that children of the provided root are not instantiated as devices
435  * unless the specified root itself matches the bus list and is not NULL.
436  */
437 int of_platform_bus_probe(struct device_node *root,
438                           const struct of_device_id *matches,
439                           struct device *parent)
440 {
441         struct device_node *child;
442         int rc = 0;
443 
444         root = root ? of_node_get(root) : of_find_node_by_path("/");
445         if (!root)
446                 return -EINVAL;
447 
448         pr_debug("of_platform_bus_probe()\n");
449         pr_debug(" starting at: %s\n", root->full_name);
450 
451         /* Do a self check of bus type, if there's a match, create children */
452         if (of_match_node(matches, root)) {
453                 rc = of_platform_bus_create(root, matches, NULL, parent, false);
454         } else for_each_child_of_node(root, child) {
455                 if (!of_match_node(matches, child))
456                         continue;
457                 rc = of_platform_bus_create(child, matches, NULL, parent, false);
458                 if (rc)
459                         break;
460         }
461 
462         of_node_put(root);
463         return rc;
464 }
465 EXPORT_SYMBOL(of_platform_bus_probe);
466 
467 /**
468  * of_platform_populate() - Populate platform_devices from device tree data
469  * @root: parent of the first level to probe or NULL for the root of the tree
470  * @matches: match table, NULL to use the default
471  * @lookup: auxdata table for matching id and platform_data with device nodes
472  * @parent: parent to hook devices from, NULL for toplevel
473  *
474  * Similar to of_platform_bus_probe(), this function walks the device tree
475  * and creates devices from nodes.  It differs in that it follows the modern
476  * convention of requiring all device nodes to have a 'compatible' property,
477  * and it is suitable for creating devices which are children of the root
478  * node (of_platform_bus_probe will only create children of the root which
479  * are selected by the @matches argument).
480  *
481  * New board support should be using this function instead of
482  * of_platform_bus_probe().
483  *
484  * Returns 0 on success, < 0 on failure.
485  */
486 int of_platform_populate(struct device_node *root,
487                         const struct of_device_id *matches,
488                         const struct of_dev_auxdata *lookup,
489                         struct device *parent)
490 {
491         struct device_node *child;
492         int rc = 0;
493 
494         root = root ? of_node_get(root) : of_find_node_by_path("/");
495         if (!root)
496                 return -EINVAL;
497 
498         for_each_child_of_node(root, child) {
499                 rc = of_platform_bus_create(child, matches, lookup, parent, true);
500                 if (rc)
501                         break;
502         }
503 
504         of_node_put(root);
505         return rc;
506 }
507 EXPORT_SYMBOL_GPL(of_platform_populate);
508 
509 static int of_platform_device_destroy(struct device *dev, void *data)
510 {
511         bool *children_left = data;
512 
513         /* Do not touch devices not populated from the device tree */
514         if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED)) {
515                 *children_left = true;
516                 return 0;
517         }
518 
519         /* Recurse, but don't touch this device if it has any children left */
520         if (of_platform_depopulate(dev) != 0) {
521                 *children_left = true;
522                 return 0;
523         }
524 
525         if (dev->bus == &platform_bus_type)
526                 platform_device_unregister(to_platform_device(dev));
527 #ifdef CONFIG_ARM_AMBA
528         else if (dev->bus == &amba_bustype)
529                 amba_device_unregister(to_amba_device(dev));
530 #endif
531         else {
532                 *children_left = true;
533                 return 0;
534         }
535 
536         of_node_clear_flag(dev->of_node, OF_POPULATED);
537 
538         return 0;
539 }
540 
541 /**
542  * of_platform_depopulate() - Remove devices populated from device tree
543  * @parent: device which childred will be removed
544  *
545  * Complementary to of_platform_populate(), this function removes children
546  * of the given device (and, recurrently, their children) that have been
547  * created from their respective device tree nodes (and only those,
548  * leaving others - eg. manually created - unharmed).
549  *
550  * Returns 0 when all children devices have been removed or
551  * -EBUSY when some children remained.
552  */
553 int of_platform_depopulate(struct device *parent)
554 {
555         bool children_left = false;
556 
557         device_for_each_child(parent, &children_left,
558                               of_platform_device_destroy);
559 
560         return children_left ? -EBUSY : 0;
561 }
562 EXPORT_SYMBOL_GPL(of_platform_depopulate);
563 
564 #endif /* CONFIG_OF_ADDRESS */
565 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us