Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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 
 15 #define pr_fmt(fmt)     "OF: " fmt
 16 
 17 #include <linux/errno.h>
 18 #include <linux/module.h>
 19 #include <linux/amba/bus.h>
 20 #include <linux/device.h>
 21 #include <linux/dma-mapping.h>
 22 #include <linux/slab.h>
 23 #include <linux/of_address.h>
 24 #include <linux/of_device.h>
 25 #include <linux/of_irq.h>
 26 #include <linux/of_platform.h>
 27 #include <linux/platform_device.h>
 28 
 29 const struct of_device_id of_default_bus_match_table[] = {
 30         { .compatible = "simple-bus", },
 31         { .compatible = "simple-mfd", },
 32         { .compatible = "isa", },
 33 #ifdef CONFIG_ARM_AMBA
 34         { .compatible = "arm,amba-bus", },
 35 #endif /* CONFIG_ARM_AMBA */
 36         {} /* Empty terminated list */
 37 };
 38 
 39 static int of_dev_node_match(struct device *dev, void *data)
 40 {
 41         return dev->of_node == data;
 42 }
 43 
 44 /**
 45  * of_find_device_by_node - Find the platform_device associated with a node
 46  * @np: Pointer to device tree node
 47  *
 48  * Takes a reference to the embedded struct device which needs to be dropped
 49  * after use.
 50  *
 51  * Returns platform_device pointer, or NULL if not found
 52  */
 53 struct platform_device *of_find_device_by_node(struct device_node *np)
 54 {
 55         struct device *dev;
 56 
 57         dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
 58         return dev ? to_platform_device(dev) : NULL;
 59 }
 60 EXPORT_SYMBOL(of_find_device_by_node);
 61 
 62 #ifdef CONFIG_OF_ADDRESS
 63 /*
 64  * The following routines scan a subtree and registers a device for
 65  * each applicable node.
 66  *
 67  * Note: sparc doesn't use these routines because it has a different
 68  * mechanism for creating devices from device tree nodes.
 69  */
 70 
 71 /**
 72  * of_device_make_bus_id - Use the device node data to assign a unique name
 73  * @dev: pointer to device structure that is linked to a device tree node
 74  *
 75  * This routine will first try using the translated bus address to
 76  * derive a unique name. If it cannot, then it will prepend names from
 77  * parent nodes until a unique name can be derived.
 78  */
 79 void of_device_make_bus_id(struct device *dev)
 80 {
 81         struct device_node *node = dev->of_node;
 82         const __be32 *reg;
 83         u64 addr;
 84 
 85         /* Construct the name, using parent nodes if necessary to ensure uniqueness */
 86         while (node->parent) {
 87                 /*
 88                  * If the address can be translated, then that is as much
 89                  * uniqueness as we need. Make it the first component and return
 90                  */
 91                 reg = of_get_property(node, "reg", NULL);
 92                 if (reg && (addr = of_translate_address(node, reg)) != OF_BAD_ADDR) {
 93                         dev_set_name(dev, dev_name(dev) ? "%llx.%s:%s" : "%llx.%s",
 94                                      (unsigned long long)addr, node->name,
 95                                      dev_name(dev));
 96                         return;
 97                 }
 98 
 99                 /* format arguments only used if dev_name() resolves to NULL */
100                 dev_set_name(dev, dev_name(dev) ? "%s:%s" : "%s",
101                              strrchr(node->full_name, '/') + 1, dev_name(dev));
102                 node = node->parent;
103         }
104 }
105 
106 /**
107  * of_device_alloc - Allocate and initialize an of_device
108  * @np: device node to assign to device
109  * @bus_id: Name to assign to the device.  May be null to use default name.
110  * @parent: Parent device.
111  */
112 struct platform_device *of_device_alloc(struct device_node *np,
113                                   const char *bus_id,
114                                   struct device *parent)
115 {
116         struct platform_device *dev;
117         int rc, i, num_reg = 0, num_irq;
118         struct resource *res, temp_res;
119 
120         dev = platform_device_alloc("", -1);
121         if (!dev)
122                 return NULL;
123 
124         /* count the io and irq resources */
125         while (of_address_to_resource(np, num_reg, &temp_res) == 0)
126                 num_reg++;
127         num_irq = of_irq_count(np);
128 
129         /* Populate the resource table */
130         if (num_irq || num_reg) {
131                 res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
132                 if (!res) {
133                         platform_device_put(dev);
134                         return NULL;
135                 }
136 
137                 dev->num_resources = num_reg + num_irq;
138                 dev->resource = res;
139                 for (i = 0; i < num_reg; i++, res++) {
140                         rc = of_address_to_resource(np, i, res);
141                         WARN_ON(rc);
142                 }
143                 if (of_irq_to_resource_table(np, res, num_irq) != num_irq)
144                         pr_debug("not all legacy IRQ resources mapped for %s\n",
145                                  np->name);
146         }
147 
148         dev->dev.of_node = of_node_get(np);
149         dev->dev.fwnode = &np->fwnode;
150         dev->dev.parent = parent ? : &platform_bus;
151 
152         if (bus_id)
153                 dev_set_name(&dev->dev, "%s", bus_id);
154         else
155                 of_device_make_bus_id(&dev->dev);
156 
157         return dev;
158 }
159 EXPORT_SYMBOL(of_device_alloc);
160 
161 static void of_dma_deconfigure(struct device *dev)
162 {
163         arch_teardown_dma_ops(dev);
164 }
165 
166 /**
167  * of_platform_device_create_pdata - Alloc, initialize and register an of_device
168  * @np: pointer to node to create device for
169  * @bus_id: name to assign device
170  * @platform_data: pointer to populate platform_data pointer with
171  * @parent: Linux device model parent device.
172  *
173  * Returns pointer to created platform device, or NULL if a device was not
174  * registered.  Unavailable devices will not get registered.
175  */
176 static struct platform_device *of_platform_device_create_pdata(
177                                         struct device_node *np,
178                                         const char *bus_id,
179                                         void *platform_data,
180                                         struct device *parent)
181 {
182         struct platform_device *dev;
183 
184         if (!of_device_is_available(np) ||
185             of_node_test_and_set_flag(np, OF_POPULATED))
186                 return NULL;
187 
188         dev = of_device_alloc(np, bus_id, parent);
189         if (!dev)
190                 goto err_clear_flag;
191 
192         dev->dev.bus = &platform_bus_type;
193         dev->dev.platform_data = platform_data;
194         of_dma_configure(&dev->dev, dev->dev.of_node);
195         of_msi_configure(&dev->dev, dev->dev.of_node);
196 
197         if (of_device_add(dev) != 0) {
198                 of_dma_deconfigure(&dev->dev);
199                 platform_device_put(dev);
200                 goto err_clear_flag;
201         }
202 
203         return dev;
204 
205 err_clear_flag:
206         of_node_clear_flag(np, OF_POPULATED);
207         return NULL;
208 }
209 
210 /**
211  * of_platform_device_create - Alloc, initialize and register an of_device
212  * @np: pointer to node to create device for
213  * @bus_id: name to assign device
214  * @parent: Linux device model parent device.
215  *
216  * Returns pointer to created platform device, or NULL if a device was not
217  * registered.  Unavailable devices will not get registered.
218  */
219 struct platform_device *of_platform_device_create(struct device_node *np,
220                                             const char *bus_id,
221                                             struct device *parent)
222 {
223         return of_platform_device_create_pdata(np, bus_id, NULL, parent);
224 }
225 EXPORT_SYMBOL(of_platform_device_create);
226 
227 #ifdef CONFIG_ARM_AMBA
228 static struct amba_device *of_amba_device_create(struct device_node *node,
229                                                  const char *bus_id,
230                                                  void *platform_data,
231                                                  struct device *parent)
232 {
233         struct amba_device *dev;
234         const void *prop;
235         int i, ret;
236 
237         pr_debug("Creating amba device %s\n", node->full_name);
238 
239         if (!of_device_is_available(node) ||
240             of_node_test_and_set_flag(node, OF_POPULATED))
241                 return NULL;
242 
243         dev = amba_device_alloc(NULL, 0, 0);
244         if (!dev)
245                 goto err_clear_flag;
246 
247         /* setup generic device info */
248         dev->dev.of_node = of_node_get(node);
249         dev->dev.fwnode = &node->fwnode;
250         dev->dev.parent = parent ? : &platform_bus;
251         dev->dev.platform_data = platform_data;
252         if (bus_id)
253                 dev_set_name(&dev->dev, "%s", bus_id);
254         else
255                 of_device_make_bus_id(&dev->dev);
256         of_dma_configure(&dev->dev, dev->dev.of_node);
257 
258         /* Allow the HW Peripheral ID to be overridden */
259         prop = of_get_property(node, "arm,primecell-periphid", NULL);
260         if (prop)
261                 dev->periphid = of_read_ulong(prop, 1);
262 
263         /* Decode the IRQs and address ranges */
264         for (i = 0; i < AMBA_NR_IRQS; i++)
265                 dev->irq[i] = irq_of_parse_and_map(node, i);
266 
267         ret = of_address_to_resource(node, 0, &dev->res);
268         if (ret) {
269                 pr_err("amba: of_address_to_resource() failed (%d) for %s\n",
270                        ret, node->full_name);
271                 goto err_free;
272         }
273 
274         ret = amba_device_add(dev, &iomem_resource);
275         if (ret) {
276                 pr_err("amba_device_add() failed (%d) for %s\n",
277                        ret, node->full_name);
278                 goto err_free;
279         }
280 
281         return dev;
282 
283 err_free:
284         amba_device_put(dev);
285 err_clear_flag:
286         of_node_clear_flag(node, OF_POPULATED);
287         return NULL;
288 }
289 #else /* CONFIG_ARM_AMBA */
290 static struct amba_device *of_amba_device_create(struct device_node *node,
291                                                  const char *bus_id,
292                                                  void *platform_data,
293                                                  struct device *parent)
294 {
295         return NULL;
296 }
297 #endif /* CONFIG_ARM_AMBA */
298 
299 /**
300  * of_devname_lookup() - Given a device node, lookup the preferred Linux name
301  */
302 static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *lookup,
303                                  struct device_node *np)
304 {
305         const struct of_dev_auxdata *auxdata;
306         struct resource res;
307         int compatible = 0;
308 
309         if (!lookup)
310                 return NULL;
311 
312         auxdata = lookup;
313         for (; auxdata->compatible; auxdata++) {
314                 if (!of_device_is_compatible(np, auxdata->compatible))
315                         continue;
316                 compatible++;
317                 if (!of_address_to_resource(np, 0, &res))
318                         if (res.start != auxdata->phys_addr)
319                                 continue;
320                 pr_debug("%s: devname=%s\n", np->full_name, auxdata->name);
321                 return auxdata;
322         }
323 
324         if (!compatible)
325                 return NULL;
326 
327         /* Try compatible match if no phys_addr and name are specified */
328         auxdata = lookup;
329         for (; auxdata->compatible; auxdata++) {
330                 if (!of_device_is_compatible(np, auxdata->compatible))
331                         continue;
332                 if (!auxdata->phys_addr && !auxdata->name) {
333                         pr_debug("%s: compatible match\n", np->full_name);
334                         return auxdata;
335                 }
336         }
337 
338         return NULL;
339 }
340 
341 /**
342  * of_platform_bus_create() - Create a device for a node and its children.
343  * @bus: device node of the bus to instantiate
344  * @matches: match table for bus nodes
345  * @lookup: auxdata table for matching id and platform_data with device nodes
346  * @parent: parent for new device, or NULL for top level.
347  * @strict: require compatible property
348  *
349  * Creates a platform_device for the provided device_node, and optionally
350  * recursively create devices for all the child nodes.
351  */
352 static int of_platform_bus_create(struct device_node *bus,
353                                   const struct of_device_id *matches,
354                                   const struct of_dev_auxdata *lookup,
355                                   struct device *parent, bool strict)
356 {
357         const struct of_dev_auxdata *auxdata;
358         struct device_node *child;
359         struct platform_device *dev;
360         const char *bus_id = NULL;
361         void *platform_data = NULL;
362         int rc = 0;
363 
364         /* Make sure it has a compatible property */
365         if (strict && (!of_get_property(bus, "compatible", NULL))) {
366                 pr_debug("%s() - skipping %s, no compatible prop\n",
367                          __func__, bus->full_name);
368                 return 0;
369         }
370 
371         if (of_node_check_flag(bus, OF_POPULATED_BUS)) {
372                 pr_debug("%s() - skipping %s, already populated\n",
373                         __func__, bus->full_name);
374                 return 0;
375         }
376 
377         auxdata = of_dev_lookup(lookup, bus);
378         if (auxdata) {
379                 bus_id = auxdata->name;
380                 platform_data = auxdata->platform_data;
381         }
382 
383         if (of_device_is_compatible(bus, "arm,primecell")) {
384                 /*
385                  * Don't return an error here to keep compatibility with older
386                  * device tree files.
387                  */
388                 of_amba_device_create(bus, bus_id, platform_data, parent);
389                 return 0;
390         }
391 
392         dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
393         if (!dev || !of_match_node(matches, bus))
394                 return 0;
395 
396         for_each_child_of_node(bus, child) {
397                 pr_debug("   create child: %s\n", child->full_name);
398                 rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
399                 if (rc) {
400                         of_node_put(child);
401                         break;
402                 }
403         }
404         of_node_set_flag(bus, OF_POPULATED_BUS);
405         return rc;
406 }
407 
408 /**
409  * of_platform_bus_probe() - Probe the device-tree for platform buses
410  * @root: parent of the first level to probe or NULL for the root of the tree
411  * @matches: match table for bus nodes
412  * @parent: parent to hook devices from, NULL for toplevel
413  *
414  * Note that children of the provided root are not instantiated as devices
415  * unless the specified root itself matches the bus list and is not NULL.
416  */
417 int of_platform_bus_probe(struct device_node *root,
418                           const struct of_device_id *matches,
419                           struct device *parent)
420 {
421         struct device_node *child;
422         int rc = 0;
423 
424         root = root ? of_node_get(root) : of_find_node_by_path("/");
425         if (!root)
426                 return -EINVAL;
427 
428         pr_debug("%s()\n", __func__);
429         pr_debug(" starting at: %s\n", root->full_name);
430 
431         /* Do a self check of bus type, if there's a match, create children */
432         if (of_match_node(matches, root)) {
433                 rc = of_platform_bus_create(root, matches, NULL, parent, false);
434         } else for_each_child_of_node(root, child) {
435                 if (!of_match_node(matches, child))
436                         continue;
437                 rc = of_platform_bus_create(child, matches, NULL, parent, false);
438                 if (rc) {
439                         of_node_put(child);
440                         break;
441                 }
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         pr_debug("%s()\n", __func__);
481         pr_debug(" starting at: %s\n", root->full_name);
482 
483         for_each_child_of_node(root, child) {
484                 rc = of_platform_bus_create(child, matches, lookup, parent, true);
485                 if (rc) {
486                         of_node_put(child);
487                         break;
488                 }
489         }
490         of_node_set_flag(root, OF_POPULATED_BUS);
491 
492         of_node_put(root);
493         return rc;
494 }
495 EXPORT_SYMBOL_GPL(of_platform_populate);
496 
497 int of_platform_default_populate(struct device_node *root,
498                                  const struct of_dev_auxdata *lookup,
499                                  struct device *parent)
500 {
501         return of_platform_populate(root, of_default_bus_match_table, lookup,
502                                     parent);
503 }
504 EXPORT_SYMBOL_GPL(of_platform_default_populate);
505 
506 #ifndef CONFIG_PPC
507 static int __init of_platform_default_populate_init(void)
508 {
509         struct device_node *node;
510 
511         if (!of_have_populated_dt())
512                 return -ENODEV;
513 
514         /*
515          * Handle ramoops explicitly, since it is inside /reserved-memory,
516          * which lacks a "compatible" property.
517          */
518         node = of_find_node_by_path("/reserved-memory");
519         if (node) {
520                 node = of_find_compatible_node(node, NULL, "ramoops");
521                 if (node)
522                         of_platform_device_create(node, NULL, NULL);
523         }
524 
525         /* Populate everything else. */
526         of_platform_default_populate(NULL, NULL, NULL);
527 
528         return 0;
529 }
530 arch_initcall_sync(of_platform_default_populate_init);
531 #endif
532 
533 static int of_platform_device_destroy(struct device *dev, void *data)
534 {
535         /* Do not touch devices not populated from the device tree */
536         if (!dev->of_node || !of_node_check_flag(dev->of_node, OF_POPULATED))
537                 return 0;
538 
539         /* Recurse for any nodes that were treated as busses */
540         if (of_node_check_flag(dev->of_node, OF_POPULATED_BUS))
541                 device_for_each_child(dev, NULL, of_platform_device_destroy);
542 
543         if (dev->bus == &platform_bus_type)
544                 platform_device_unregister(to_platform_device(dev));
545 #ifdef CONFIG_ARM_AMBA
546         else if (dev->bus == &amba_bustype)
547                 amba_device_unregister(to_amba_device(dev));
548 #endif
549 
550         of_dma_deconfigure(dev);
551         of_node_clear_flag(dev->of_node, OF_POPULATED);
552         of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
553         return 0;
554 }
555 
556 /**
557  * of_platform_depopulate() - Remove devices populated from device tree
558  * @parent: device which children will be removed
559  *
560  * Complementary to of_platform_populate(), this function removes children
561  * of the given device (and, recurrently, their children) that have been
562  * created from their respective device tree nodes (and only those,
563  * leaving others - eg. manually created - unharmed).
564  */
565 void of_platform_depopulate(struct device *parent)
566 {
567         if (parent->of_node && of_node_check_flag(parent->of_node, OF_POPULATED_BUS)) {
568                 device_for_each_child(parent, NULL, of_platform_device_destroy);
569                 of_node_clear_flag(parent->of_node, OF_POPULATED_BUS);
570         }
571 }
572 EXPORT_SYMBOL_GPL(of_platform_depopulate);
573 
574 #ifdef CONFIG_OF_DYNAMIC
575 static int of_platform_notify(struct notifier_block *nb,
576                                 unsigned long action, void *arg)
577 {
578         struct of_reconfig_data *rd = arg;
579         struct platform_device *pdev_parent, *pdev;
580         bool children_left;
581 
582         switch (of_reconfig_get_state_change(action, rd)) {
583         case OF_RECONFIG_CHANGE_ADD:
584                 /* verify that the parent is a bus */
585                 if (!of_node_check_flag(rd->dn->parent, OF_POPULATED_BUS))
586                         return NOTIFY_OK;       /* not for us */
587 
588                 /* already populated? (driver using of_populate manually) */
589                 if (of_node_check_flag(rd->dn, OF_POPULATED))
590                         return NOTIFY_OK;
591 
592                 /* pdev_parent may be NULL when no bus platform device */
593                 pdev_parent = of_find_device_by_node(rd->dn->parent);
594                 pdev = of_platform_device_create(rd->dn, NULL,
595                                 pdev_parent ? &pdev_parent->dev : NULL);
596                 of_dev_put(pdev_parent);
597 
598                 if (pdev == NULL) {
599                         pr_err("%s: failed to create for '%s'\n",
600                                         __func__, rd->dn->full_name);
601                         /* of_platform_device_create tosses the error code */
602                         return notifier_from_errno(-EINVAL);
603                 }
604                 break;
605 
606         case OF_RECONFIG_CHANGE_REMOVE:
607 
608                 /* already depopulated? */
609                 if (!of_node_check_flag(rd->dn, OF_POPULATED))
610                         return NOTIFY_OK;
611 
612                 /* find our device by node */
613                 pdev = of_find_device_by_node(rd->dn);
614                 if (pdev == NULL)
615                         return NOTIFY_OK;       /* no? not meant for us */
616 
617                 /* unregister takes one ref away */
618                 of_platform_device_destroy(&pdev->dev, &children_left);
619 
620                 /* and put the reference of the find */
621                 of_dev_put(pdev);
622                 break;
623         }
624 
625         return NOTIFY_OK;
626 }
627 
628 static struct notifier_block platform_of_notifier = {
629         .notifier_call = of_platform_notify,
630 };
631 
632 void of_platform_register_reconfig_notifier(void)
633 {
634         WARN_ON(of_reconfig_notifier_register(&platform_of_notifier));
635 }
636 #endif /* CONFIG_OF_DYNAMIC */
637 
638 #endif /* CONFIG_OF_ADDRESS */
639 

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