arch/powerpc/kernel/of_device.c

   1 #include <linux/string.h>
   2 #include <linux/kernel.h>
   3 #include <linux/of.h>
   4 #include <linux/init.h>
   5 #include <linux/module.h>
   6 #include <linux/mod_devicetable.h>
   7 #include <linux/slab.h>
   8 #include <linux/of_device.h>
   9
  10 #include <asm/errno.h>
  11 #include <asm/dcr.h>
  12
  13 static void of_device_make_bus_id(struct of_device *dev)
  14 {
  15         static atomic_t bus_no_reg_magic;
  16         struct device_node *node = dev->node;
  17         const u32 *reg;
  18         u64 addr;
  19         int magic;
  20
  21         /*
  22          * If it's a DCR based device, use 'd' for native DCRs
  23          * and 'D' for MMIO DCRs.
  24          */
  25 #ifdef CONFIG_PPC_DCR
  26         reg = of_get_property(node, "dcr-reg", NULL);
  27         if (reg) {
  28 #ifdef CONFIG_PPC_DCR_NATIVE
  29                 dev_set_name(&dev->dev, "d%x.%s", *reg, node->name);
  30 #else /* CONFIG_PPC_DCR_NATIVE */
  31                 addr = of_translate_dcr_address(node, *reg, NULL);
  32                 if (addr != OF_BAD_ADDR) {
  33                         dev_set_name(&dev->dev, "D%llx.%s",
  34                                      (unsigned long long)addr, node->name);
  35                         return;
  36                 }
  37 #endif /* !CONFIG_PPC_DCR_NATIVE */
  38         }
  39 #endif /* CONFIG_PPC_DCR */
  40
  41         /*
  42          * For MMIO, get the physical address
  43          */
  44         reg = of_get_property(node, "reg", NULL);
  45         if (reg) {
  46                 addr = of_translate_address(node, reg);
  47                 if (addr != OF_BAD_ADDR) {
  48                         dev_set_name(&dev->dev, "%llx.%s",
  49                                      (unsigned long long)addr, node->name);
  50                         return;
  51                 }
  52         }
  53
  54         /*
  55          * No BusID, use the node name and add a globally incremented
  56          * counter (and pray...)
  57          */
  58         magic = atomic_add_return(1, &bus_no_reg_magic);
  59         dev_set_name(&dev->dev, "%s.%d", node->name, magic - 1);
  60 }
  61
  62 struct of_device *of_device_alloc(struct device_node *np,
  63                                   const char *bus_id,
  64                                   struct device *parent)
  65 {
  66         struct of_device *dev;
  67
  68         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  69         if (!dev)
  70                 return NULL;
  71
  72         dev->node = of_node_get(np);
  73         dev->dev.dma_mask = &dev->dma_mask;
  74         dev->dev.parent = parent;
  75         dev->dev.release = of_release_dev;
  76         dev->dev.archdata.of_node = np;
  77         dev->dev.of_node = np;
  78
  79         if (bus_id)
  80                 dev_set_name(&dev->dev, "%s", bus_id);
  81         else
  82                 of_device_make_bus_id(dev);
  83
  84         return dev;
  85 }
  86 EXPORT_SYMBOL(of_device_alloc);
  87
  88 int of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
  89 {
  90         struct of_device *ofdev;
  91         const char *compat;
  92         int seen = 0, cplen, sl;
  93
  94         if (!dev)
  95                 return -ENODEV;
  96
  97         ofdev = to_of_device(dev);
  98
  99         if (add_uevent_var(env, "OF_NAME=%s", ofdev->node->name))
 100                 return -ENOMEM;
 101
 102         if (add_uevent_var(env, "OF_TYPE=%s", ofdev->node->type))
 103                 return -ENOMEM;
 104
 105         /* Since the compatible field can contain pretty much anything
 106          * it's not really legal to split it out with commas. We split it
 107          * up using a number of environment variables instead. */
 108
 109         compat = of_get_property(ofdev->node, "compatible", &cplen);
 110         while (compat && *compat && cplen > 0) {
 111                 if (add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat))
 112                         return -ENOMEM;
 113
 114                 sl = strlen (compat) + 1;
 115                 compat += sl;
 116                 cplen -= sl;
 117                 seen++;
 118         }
 119
 120         if (add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen))
 121                 return -ENOMEM;
 122
 123         /* modalias is trickier, we add it in 2 steps */
 124         if (add_uevent_var(env, "MODALIAS="))
 125                 return -ENOMEM;
 126         sl = of_device_get_modalias(ofdev, &env->buf[env->buflen-1],
 127                                     sizeof(env->buf) - env->buflen);
 128         if (sl >= (sizeof(env->buf) - env->buflen))
 129                 return -ENOMEM;
 130         env->buflen += sl;
 131
 132         return 0;
 133 }
 134 EXPORT_SYMBOL(of_device_uevent);
 135 EXPORT_SYMBOL(of_device_get_modalias);