Commit | Line | Data |
---|---|---|
2e686bc3 PM |
1 | #include <linux/string.h> |
2 | #include <linux/kernel.h> | |
f85ff305 | 3 | #include <linux/of.h> |
2e686bc3 PM |
4 | #include <linux/init.h> |
5 | #include <linux/module.h> | |
6 | #include <linux/mod_devicetable.h> | |
734d6524 | 7 | #include <linux/slab.h> |
0173d422 | 8 | #include <linux/of_device.h> |
734d6524 | 9 | |
2e686bc3 | 10 | #include <asm/errno.h> |
fec738dd | 11 | #include <asm/dcr.h> |
2e686bc3 | 12 | |
fec738dd JF |
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 | char *name = dev->dev.bus_id; | |
18 | const u32 *reg; | |
19 | u64 addr; | |
20 | int magic; | |
21 | ||
22 | /* | |
23 | * If it's a DCR based device, use 'd' for native DCRs | |
24 | * and 'D' for MMIO DCRs. | |
25 | */ | |
26 | #ifdef CONFIG_PPC_DCR | |
27 | reg = of_get_property(node, "dcr-reg", NULL); | |
28 | if (reg) { | |
29 | #ifdef CONFIG_PPC_DCR_NATIVE | |
30 | snprintf(name, BUS_ID_SIZE, "d%x.%s", | |
31 | *reg, node->name); | |
32 | #else /* CONFIG_PPC_DCR_NATIVE */ | |
33 | addr = of_translate_dcr_address(node, *reg, NULL); | |
34 | if (addr != OF_BAD_ADDR) { | |
35 | snprintf(name, BUS_ID_SIZE, | |
36 | "D%llx.%s", (unsigned long long)addr, | |
37 | node->name); | |
38 | return; | |
39 | } | |
40 | #endif /* !CONFIG_PPC_DCR_NATIVE */ | |
41 | } | |
42 | #endif /* CONFIG_PPC_DCR */ | |
43 | ||
44 | /* | |
45 | * For MMIO, get the physical address | |
46 | */ | |
47 | reg = of_get_property(node, "reg", NULL); | |
48 | if (reg) { | |
49 | addr = of_translate_address(node, reg); | |
50 | if (addr != OF_BAD_ADDR) { | |
51 | snprintf(name, BUS_ID_SIZE, | |
52 | "%llx.%s", (unsigned long long)addr, | |
53 | node->name); | |
54 | return; | |
55 | } | |
56 | } | |
57 | ||
58 | /* | |
59 | * No BusID, use the node name and add a globally incremented | |
60 | * counter (and pray...) | |
61 | */ | |
62 | magic = atomic_add_return(1, &bus_no_reg_magic); | |
63 | snprintf(name, BUS_ID_SIZE, "%s.%d", node->name, magic - 1); | |
64 | } | |
65 | ||
66 | struct of_device *of_device_alloc(struct device_node *np, | |
67 | const char *bus_id, | |
68 | struct device *parent) | |
69 | { | |
70 | struct of_device *dev; | |
71 | ||
72 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); | |
73 | if (!dev) | |
74 | return NULL; | |
75 | ||
76 | dev->node = of_node_get(np); | |
77 | dev->dev.dma_mask = &dev->dma_mask; | |
78 | dev->dev.parent = parent; | |
79 | dev->dev.release = of_release_dev; | |
80 | dev->dev.archdata.of_node = np; | |
81 | dev->dev.archdata.numa_node = of_node_to_nid(np); | |
82 | ||
83 | if (bus_id) | |
84 | strlcpy(dev->dev.bus_id, bus_id, BUS_ID_SIZE); | |
85 | else | |
86 | of_device_make_bus_id(dev); | |
87 | ||
88 | return dev; | |
89 | } | |
90 | EXPORT_SYMBOL(of_device_alloc); | |
91 | ||
de41189b SM |
92 | ssize_t of_device_get_modalias(struct of_device *ofdev, |
93 | char *str, ssize_t len) | |
eb0cb8a0 SM |
94 | { |
95 | const char *compat; | |
96 | int cplen, i; | |
97 | ssize_t tsize, csize, repend; | |
98 | ||
99 | /* Name & Type */ | |
100 | csize = snprintf(str, len, "of:N%sT%s", | |
101 | ofdev->node->name, ofdev->node->type); | |
102 | ||
103 | /* Get compatible property if any */ | |
b3a6d2a5 | 104 | compat = of_get_property(ofdev->node, "compatible", &cplen); |
eb0cb8a0 SM |
105 | if (!compat) |
106 | return csize; | |
107 | ||
108 | /* Find true end (we tolerate multiple \0 at the end */ | |
109 | for (i=(cplen-1); i>=0 && !compat[i]; i--) | |
110 | cplen--; | |
111 | if (!cplen) | |
112 | return csize; | |
113 | cplen++; | |
114 | ||
115 | /* Check space (need cplen+1 chars including final \0) */ | |
116 | tsize = csize + cplen; | |
117 | repend = tsize; | |
118 | ||
119 | if (csize>=len) /* @ the limit, all is already filled */ | |
120 | return tsize; | |
121 | ||
122 | if (tsize>=len) { /* limit compat list */ | |
123 | cplen = len-csize-1; | |
124 | repend = len; | |
125 | } | |
126 | ||
127 | /* Copy and do char replacement */ | |
128 | memcpy(&str[csize+1], compat, cplen); | |
129 | for (i=csize; i<repend; i++) { | |
130 | char c = str[i]; | |
131 | if (c=='\0') | |
132 | str[i] = 'C'; | |
133 | else if (c==' ') | |
134 | str[i] = '_'; | |
135 | } | |
136 | ||
137 | return tsize; | |
138 | } | |
139 | ||
7eff2e7a | 140 | int of_device_uevent(struct device *dev, struct kobj_uevent_env *env) |
eb0cb8a0 SM |
141 | { |
142 | struct of_device *ofdev; | |
143 | const char *compat; | |
7eff2e7a | 144 | int seen = 0, cplen, sl; |
eb0cb8a0 SM |
145 | |
146 | if (!dev) | |
147 | return -ENODEV; | |
148 | ||
149 | ofdev = to_of_device(dev); | |
150 | ||
7eff2e7a | 151 | if (add_uevent_var(env, "OF_NAME=%s", ofdev->node->name)) |
eb0cb8a0 SM |
152 | return -ENOMEM; |
153 | ||
7eff2e7a | 154 | if (add_uevent_var(env, "OF_TYPE=%s", ofdev->node->type)) |
eb0cb8a0 SM |
155 | return -ENOMEM; |
156 | ||
157 | /* Since the compatible field can contain pretty much anything | |
158 | * it's not really legal to split it out with commas. We split it | |
159 | * up using a number of environment variables instead. */ | |
160 | ||
b3a6d2a5 | 161 | compat = of_get_property(ofdev->node, "compatible", &cplen); |
eb0cb8a0 | 162 | while (compat && *compat && cplen > 0) { |
7eff2e7a | 163 | if (add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat)) |
eb0cb8a0 SM |
164 | return -ENOMEM; |
165 | ||
166 | sl = strlen (compat) + 1; | |
167 | compat += sl; | |
168 | cplen -= sl; | |
169 | seen++; | |
170 | } | |
171 | ||
7eff2e7a | 172 | if (add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen)) |
eb0cb8a0 SM |
173 | return -ENOMEM; |
174 | ||
175 | /* modalias is trickier, we add it in 2 steps */ | |
7eff2e7a | 176 | if (add_uevent_var(env, "MODALIAS=")) |
eb0cb8a0 | 177 | return -ENOMEM; |
7eff2e7a KS |
178 | sl = of_device_get_modalias(ofdev, &env->buf[env->buflen-1], |
179 | sizeof(env->buf) - env->buflen); | |
180 | if (sl >= (sizeof(env->buf) - env->buflen)) | |
eb0cb8a0 | 181 | return -ENOMEM; |
7eff2e7a | 182 | env->buflen += sl; |
eb0cb8a0 SM |
183 | |
184 | return 0; | |
185 | } | |
eb0cb8a0 | 186 | EXPORT_SYMBOL(of_device_uevent); |
de41189b | 187 | EXPORT_SYMBOL(of_device_get_modalias); |