Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6.git] / sound / aoa / soundbus / core.c
1 /*
2  * soundbus
3  *
4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * GPL v2, can be found in COPYING.
7  */
8
9 #include <linux/module.h>
10 #include "soundbus.h"
11
12 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
13 MODULE_LICENSE("GPL");
14 MODULE_DESCRIPTION("Apple Soundbus");
15
16 struct soundbus_dev *soundbus_dev_get(struct soundbus_dev *dev)
17 {
18         struct device *tmp;
19
20         if (!dev)
21                 return NULL;
22         tmp = get_device(&dev->ofdev.dev);
23         if (tmp)
24                 return to_soundbus_device(tmp);
25         else
26                 return NULL;
27 }
28 EXPORT_SYMBOL_GPL(soundbus_dev_get);
29
30 void soundbus_dev_put(struct soundbus_dev *dev)
31 {
32         if (dev)
33                 put_device(&dev->ofdev.dev);
34 }
35 EXPORT_SYMBOL_GPL(soundbus_dev_put);
36
37 static int soundbus_probe(struct device *dev)
38 {
39         int error = -ENODEV;
40         struct soundbus_driver *drv;
41         struct soundbus_dev *soundbus_dev;
42
43         drv = to_soundbus_driver(dev->driver);
44         soundbus_dev = to_soundbus_device(dev);
45
46         if (!drv->probe)
47                 return error;
48
49         soundbus_dev_get(soundbus_dev);
50
51         error = drv->probe(soundbus_dev);
52         if (error)
53                 soundbus_dev_put(soundbus_dev);
54
55         return error;
56 }
57
58
59 static int soundbus_uevent(struct device *dev, char **envp, int num_envp,
60                            char *buffer, int buffer_size)
61 {
62         struct soundbus_dev * soundbus_dev;
63         struct of_device * of;
64         char *compat;
65         int retval = 0, i = 0, length = 0;
66         int cplen, seen = 0;
67
68         if (!dev)
69                 return -ENODEV;
70
71         soundbus_dev = to_soundbus_device(dev);
72         if (!soundbus_dev)
73                 return -ENODEV;
74
75         of = &soundbus_dev->ofdev;
76
77         /* stuff we want to pass to /sbin/hotplug */
78         retval = add_uevent_var(envp, num_envp, &i,
79                                 buffer, buffer_size, &length,
80                                 "OF_NAME=%s", of->node->name);
81         if (retval)
82                 return retval;
83
84         retval = add_uevent_var(envp, num_envp, &i,
85                                 buffer, buffer_size, &length,
86                                 "OF_TYPE=%s", of->node->type);
87         if (retval)
88                 return retval;
89
90         /* Since the compatible field can contain pretty much anything
91          * it's not really legal to split it out with commas. We split it
92          * up using a number of environment variables instead. */
93
94         compat = (char *) get_property(of->node, "compatible", &cplen);
95         while (compat && cplen > 0) {
96                 int tmp = length;
97                 retval = add_uevent_var(envp, num_envp, &i,
98                                         buffer, buffer_size, &length,
99                                         "OF_COMPATIBLE_%d=%s", seen, compat);
100                 if (retval)
101                         return retval;
102                 compat += length - tmp;
103                 cplen -= length - tmp;
104                 seen += 1;
105         }
106
107         retval = add_uevent_var(envp, num_envp, &i,
108                                 buffer, buffer_size, &length,
109                                 "OF_COMPATIBLE_N=%d", seen);
110         if (retval)
111                 return retval;
112         retval = add_uevent_var(envp, num_envp, &i,
113                                 buffer, buffer_size, &length,
114                                 "MODALIAS=%s", soundbus_dev->modalias);
115
116         envp[i] = NULL;
117
118         return retval;
119 }
120
121 static int soundbus_device_remove(struct device *dev)
122 {
123         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
124         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
125
126         if (dev->driver && drv->remove)
127                 drv->remove(soundbus_dev);
128         soundbus_dev_put(soundbus_dev);
129
130         return 0;
131 }
132
133 static void soundbus_device_shutdown(struct device *dev)
134 {
135         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
136         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
137
138         if (dev->driver && drv->shutdown)
139                 drv->shutdown(soundbus_dev);
140 }
141
142 #ifdef CONFIG_PM
143
144 static int soundbus_device_suspend(struct device *dev, pm_message_t state)
145 {
146         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
147         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
148
149         if (dev->driver && drv->suspend)
150                 return drv->suspend(soundbus_dev, state);
151         return 0;
152 }
153
154 static int soundbus_device_resume(struct device * dev)
155 {
156         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
157         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
158
159         if (dev->driver && drv->resume)
160                 return drv->resume(soundbus_dev);
161         return 0;
162 }
163
164 #endif /* CONFIG_PM */
165
166 extern struct device_attribute soundbus_dev_attrs[];
167
168 static struct bus_type soundbus_bus_type = {
169         .name           = "aoa-soundbus",
170         .probe          = soundbus_probe,
171         .uevent         = soundbus_uevent,
172         .remove         = soundbus_device_remove,
173         .shutdown       = soundbus_device_shutdown,
174 #ifdef CONFIG_PM
175         .suspend        = soundbus_device_suspend,
176         .resume         = soundbus_device_resume,
177 #endif
178         .dev_attrs      = soundbus_dev_attrs,
179 };
180
181 int soundbus_add_one(struct soundbus_dev *dev)
182 {
183         static int devcount;
184
185         /* sanity checks */
186         if (!dev->attach_codec ||
187             !dev->ofdev.node ||
188             dev->pcmname ||
189             dev->pcmid != -1) {
190                 printk(KERN_ERR "soundbus: adding device failed sanity check!\n");
191                 return -EINVAL;
192         }
193
194         snprintf(dev->ofdev.dev.bus_id, BUS_ID_SIZE, "soundbus:%x", ++devcount);
195         dev->ofdev.dev.bus = &soundbus_bus_type;
196         return of_device_register(&dev->ofdev);
197 }
198 EXPORT_SYMBOL_GPL(soundbus_add_one);
199
200 void soundbus_remove_one(struct soundbus_dev *dev)
201 {
202         of_device_unregister(&dev->ofdev);
203 }
204 EXPORT_SYMBOL_GPL(soundbus_remove_one);
205
206 int soundbus_register_driver(struct soundbus_driver *drv)
207 {
208         /* initialize common driver fields */
209         drv->driver.name = drv->name;
210         drv->driver.bus = &soundbus_bus_type;
211
212         /* register with core */
213         return driver_register(&drv->driver);
214 }
215 EXPORT_SYMBOL_GPL(soundbus_register_driver);
216
217 void soundbus_unregister_driver(struct soundbus_driver *drv)
218 {
219         driver_unregister(&drv->driver);
220 }
221 EXPORT_SYMBOL_GPL(soundbus_unregister_driver);
222
223 static int __init soundbus_init(void)
224 {
225         return bus_register(&soundbus_bus_type);
226 }
227
228 static void __exit soundbus_exit(void)
229 {
230         bus_unregister(&soundbus_bus_type);
231 }
232
233 subsys_initcall(soundbus_init);
234 module_exit(soundbus_exit);