aboutsummaryrefslogtreecommitdiffstats
path: root/arch/sparc
diff options
context:
space:
mode:
authorDavid S. Miller <davem@sunset.davemloft.net>2006-06-23 18:55:17 -0400
committerDavid S. Miller <davem@sunset.davemloft.net>2006-06-24 02:15:47 -0400
commitfd5314311634245172d40ccb418d89dac91d6ad6 (patch)
treea157e4f2ec03316d733de1ff5c64254d8068d078 /arch/sparc
parent942a6bdd1c4d2419a42be77ba1c964e4ba8dae9e (diff)
[SPARC]: Port of_device layer and make ebus use it.
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'arch/sparc')
-rw-r--r--arch/sparc/kernel/Makefile2
-rw-r--r--arch/sparc/kernel/ebus.c21
-rw-r--r--arch/sparc/kernel/of_device.c268
3 files changed, 290 insertions, 1 deletions
diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile
index 93e41d0dd8da..6616ee05c313 100644
--- a/arch/sparc/kernel/Makefile
+++ b/arch/sparc/kernel/Makefile
@@ -12,7 +12,7 @@ obj-y := entry.o wof.o wuf.o etrap.o rtrap.o traps.o $(IRQ_OBJS) \
12 sys_sparc.o sunos_asm.o systbls.o \ 12 sys_sparc.o sunos_asm.o systbls.o \
13 time.o windows.o cpu.o devices.o sclow.o \ 13 time.o windows.o cpu.o devices.o sclow.o \
14 tadpole.o tick14.o ptrace.o sys_solaris.o \ 14 tadpole.o tick14.o ptrace.o sys_solaris.o \
15 unaligned.o muldiv.o semaphore.o prom.o 15 unaligned.o muldiv.o semaphore.o prom.o of_device.o
16 16
17obj-$(CONFIG_PCI) += pcic.o 17obj-$(CONFIG_PCI) += pcic.o
18obj-$(CONFIG_SUN4) += sun4setup.o 18obj-$(CONFIG_SUN4) += sun4setup.o
diff --git a/arch/sparc/kernel/ebus.c b/arch/sparc/kernel/ebus.c
index 9d461da76399..a7a4892956c8 100644
--- a/arch/sparc/kernel/ebus.c
+++ b/arch/sparc/kernel/ebus.c
@@ -235,6 +235,16 @@ void __init fill_ebus_device(struct device_node *dp, struct linux_ebus_device *d
235 } 235 }
236 } 236 }
237 237
238 dev->ofdev.node = dp;
239 dev->ofdev.dev.parent = &dev->bus->ofdev.dev;
240 dev->ofdev.dev.bus = &ebus_bus_type;
241 strcpy(dev->ofdev.dev.bus_id, dp->path_component_name);
242
243 /* Register with core */
244 if (of_device_register(&dev->ofdev) != 0)
245 printk(KERN_DEBUG "ebus: device registration error for %s!\n",
246 dev->ofdev.dev.bus_id);
247
238 if ((dp = dp->child) != NULL) { 248 if ((dp = dp->child) != NULL) {
239 dev->children = (struct linux_ebus_child *) 249 dev->children = (struct linux_ebus_child *)
240 ebus_alloc(sizeof(struct linux_ebus_child)); 250 ebus_alloc(sizeof(struct linux_ebus_child));
@@ -321,6 +331,17 @@ void __init ebus_init(void)
321 *base++ = addr; 331 *base++ = addr;
322 } 332 }
323 333
334 ebus->ofdev.node = dp;
335 ebus->ofdev.dev.parent = &pdev->dev;
336 ebus->ofdev.dev.bus = &ebus_bus_type;
337 strcpy(ebus->ofdev.dev.bus_id, dp->path_component_name);
338
339 /* Register with core */
340 if (of_device_register(&ebus->ofdev) != 0)
341 printk(KERN_DEBUG "ebus: device registration error for %s!\n",
342 ebus->ofdev.dev.bus_id);
343
344
324 nd = dp->child; 345 nd = dp->child;
325 if (!nd) 346 if (!nd)
326 goto next_ebus; 347 goto next_ebus;
diff --git a/arch/sparc/kernel/of_device.c b/arch/sparc/kernel/of_device.c
new file mode 100644
index 000000000000..001b8673b4bd
--- /dev/null
+++ b/arch/sparc/kernel/of_device.c
@@ -0,0 +1,268 @@
1#include <linux/config.h>
2#include <linux/string.h>
3#include <linux/kernel.h>
4#include <linux/init.h>
5#include <linux/module.h>
6#include <linux/mod_devicetable.h>
7#include <linux/slab.h>
8
9#include <asm/errno.h>
10#include <asm/of_device.h>
11
12/**
13 * of_match_device - Tell if an of_device structure has a matching
14 * of_match structure
15 * @ids: array of of device match structures to search in
16 * @dev: the of device structure to match against
17 *
18 * Used by a driver to check whether an of_device present in the
19 * system is in its list of supported devices.
20 */
21const struct of_device_id *of_match_device(const struct of_device_id *matches,
22 const struct of_device *dev)
23{
24 if (!dev->node)
25 return NULL;
26 while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
27 int match = 1;
28 if (matches->name[0])
29 match &= dev->node->name
30 && !strcmp(matches->name, dev->node->name);
31 if (matches->type[0])
32 match &= dev->node->type
33 && !strcmp(matches->type, dev->node->type);
34 if (matches->compatible[0])
35 match &= of_device_is_compatible(dev->node,
36 matches->compatible);
37 if (match)
38 return matches;
39 matches++;
40 }
41 return NULL;
42}
43
44static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
45{
46 struct of_device * of_dev = to_of_device(dev);
47 struct of_platform_driver * of_drv = to_of_platform_driver(drv);
48 const struct of_device_id * matches = of_drv->match_table;
49
50 if (!matches)
51 return 0;
52
53 return of_match_device(matches, of_dev) != NULL;
54}
55
56struct of_device *of_dev_get(struct of_device *dev)
57{
58 struct device *tmp;
59
60 if (!dev)
61 return NULL;
62 tmp = get_device(&dev->dev);
63 if (tmp)
64 return to_of_device(tmp);
65 else
66 return NULL;
67}
68
69void of_dev_put(struct of_device *dev)
70{
71 if (dev)
72 put_device(&dev->dev);
73}
74
75
76static int of_device_probe(struct device *dev)
77{
78 int error = -ENODEV;
79 struct of_platform_driver *drv;
80 struct of_device *of_dev;
81 const struct of_device_id *match;
82
83 drv = to_of_platform_driver(dev->driver);
84 of_dev = to_of_device(dev);
85
86 if (!drv->probe)
87 return error;
88
89 of_dev_get(of_dev);
90
91 match = of_match_device(drv->match_table, of_dev);
92 if (match)
93 error = drv->probe(of_dev, match);
94 if (error)
95 of_dev_put(of_dev);
96
97 return error;
98}
99
100static int of_device_remove(struct device *dev)
101{
102 struct of_device * of_dev = to_of_device(dev);
103 struct of_platform_driver * drv = to_of_platform_driver(dev->driver);
104
105 if (dev->driver && drv->remove)
106 drv->remove(of_dev);
107 return 0;
108}
109
110static int of_device_suspend(struct device *dev, pm_message_t state)
111{
112 struct of_device * of_dev = to_of_device(dev);
113 struct of_platform_driver * drv = to_of_platform_driver(dev->driver);
114 int error = 0;
115
116 if (dev->driver && drv->suspend)
117 error = drv->suspend(of_dev, state);
118 return error;
119}
120
121static int of_device_resume(struct device * dev)
122{
123 struct of_device * of_dev = to_of_device(dev);
124 struct of_platform_driver * drv = to_of_platform_driver(dev->driver);
125 int error = 0;
126
127 if (dev->driver && drv->resume)
128 error = drv->resume(of_dev);
129 return error;
130}
131
132#ifdef CONFIG_PCI
133struct bus_type ebus_bus_type = {
134 .name = "ebus",
135 .match = of_platform_bus_match,
136 .probe = of_device_probe,
137 .remove = of_device_remove,
138 .suspend = of_device_suspend,
139 .resume = of_device_resume,
140};
141#endif
142
143#ifdef CONFIG_SBUS
144struct bus_type sbus_bus_type = {
145 .name = "sbus",
146 .match = of_platform_bus_match,
147 .probe = of_device_probe,
148 .remove = of_device_remove,
149 .suspend = of_device_suspend,
150 .resume = of_device_resume,
151};
152#endif
153
154static int __init of_bus_driver_init(void)
155{
156 int err = 0;
157
158#ifdef CONFIG_PCI
159 if (!err)
160 err = bus_register(&ebus_bus_type);
161#endif
162#ifdef CONFIG_SBUS
163 if (!err)
164 err = bus_register(&sbus_bus_type);
165#endif
166 return 0;
167}
168
169postcore_initcall(of_bus_driver_init);
170
171int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus)
172{
173 /* initialize common driver fields */
174 drv->driver.name = drv->name;
175 drv->driver.bus = bus;
176
177 /* register with core */
178 return driver_register(&drv->driver);
179}
180
181void of_unregister_driver(struct of_platform_driver *drv)
182{
183 driver_unregister(&drv->driver);
184}
185
186
187static ssize_t dev_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
188{
189 struct of_device *ofdev;
190
191 ofdev = to_of_device(dev);
192 return sprintf(buf, "%s", ofdev->node->full_name);
193}
194
195static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
196
197/**
198 * of_release_dev - free an of device structure when all users of it are finished.
199 * @dev: device that's been disconnected
200 *
201 * Will be called only by the device core when all users of this of device are
202 * done.
203 */
204void of_release_dev(struct device *dev)
205{
206 struct of_device *ofdev;
207
208 ofdev = to_of_device(dev);
209
210 kfree(ofdev);
211}
212
213int of_device_register(struct of_device *ofdev)
214{
215 int rc;
216
217 BUG_ON(ofdev->node == NULL);
218
219 rc = device_register(&ofdev->dev);
220 if (rc)
221 return rc;
222
223 device_create_file(&ofdev->dev, &dev_attr_devspec);
224
225 return 0;
226}
227
228void of_device_unregister(struct of_device *ofdev)
229{
230 device_remove_file(&ofdev->dev, &dev_attr_devspec);
231 device_unregister(&ofdev->dev);
232}
233
234struct of_device* of_platform_device_create(struct device_node *np,
235 const char *bus_id,
236 struct device *parent,
237 struct bus_type *bus)
238{
239 struct of_device *dev;
240
241 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
242 if (!dev)
243 return NULL;
244 memset(dev, 0, sizeof(*dev));
245
246 dev->dev.parent = parent;
247 dev->dev.bus = bus;
248 dev->dev.release = of_release_dev;
249
250 strlcpy(dev->dev.bus_id, bus_id, BUS_ID_SIZE);
251
252 if (of_device_register(dev) != 0) {
253 kfree(dev);
254 return NULL;
255 }
256
257 return dev;
258}
259
260EXPORT_SYMBOL(of_match_device);
261EXPORT_SYMBOL(of_register_driver);
262EXPORT_SYMBOL(of_unregister_driver);
263EXPORT_SYMBOL(of_device_register);
264EXPORT_SYMBOL(of_device_unregister);
265EXPORT_SYMBOL(of_dev_get);
266EXPORT_SYMBOL(of_dev_put);
267EXPORT_SYMBOL(of_platform_device_create);
268EXPORT_SYMBOL(of_release_dev);