83e9e5f99b4a0427a1320879af5b4daa7f8b1258
[linux-2.6.git] / drivers / usb / gadget / udc-core.c
1 /**
2  * udc.c - Core UDC Framework
3  *
4  * Copyright (C) 2010 Texas Instruments
5  * Author: Felipe Balbi <balbi@ti.com>
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2  of
9  * the License as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/device.h>
23 #include <linux/list.h>
24 #include <linux/err.h>
25
26 #include <linux/usb/ch9.h>
27 #include <linux/usb/gadget.h>
28
29 /**
30  * struct usb_udc - describes one usb device controller
31  * @driver - the gadget driver pointer. For use by the class code
32  * @dev - the child device to the actual controller
33  * @gadget - the gadget. For use by the class code
34  * @list - for use by the udc class driver
35  *
36  * This represents the internal data structure which is used by the UDC-class
37  * to hold information about udc driver and gadget together.
38  */
39 struct usb_udc {
40         struct usb_gadget_driver        *driver;
41         struct usb_gadget               *gadget;
42         struct device                   dev;
43         struct list_head                list;
44 };
45
46 static struct class *udc_class;
47 static struct device_type udc_device_type;
48 static LIST_HEAD(udc_list);
49 static DEFINE_MUTEX(udc_lock);
50
51 /* ------------------------------------------------------------------------- */
52
53 /**
54  * usb_gadget_start - tells usb device controller to start up
55  * @gadget: The gadget we want to get started
56  * @driver: The driver we want to bind to @gadget
57  * @bind: The bind function for @driver
58  *
59  * This call is issued by the UDC Class driver when it's about
60  * to register a gadget driver to the device controller, before
61  * calling gadget driver's bind() method.
62  *
63  * It allows the controller to be powered off until strictly
64  * necessary to have it powered on.
65  *
66  * Returns zero on success, else negative errno.
67  */
68 static inline int usb_gadget_start(struct usb_gadget *gadget,
69                 struct usb_gadget_driver *driver,
70                 int (*bind)(struct usb_gadget *))
71 {
72         return gadget->ops->start(driver, bind);
73 }
74
75 /**
76  * usb_gadget_stop - tells usb device controller we don't need it anymore
77  * @gadget: The device we want to stop activity
78  * @driver: The driver to unbind from @gadget
79  *
80  * This call is issued by the UDC Class driver after calling
81  * gadget driver's unbind() method.
82  *
83  * The details are implementation specific, but it can go as
84  * far as powering off UDC completely and disable its data
85  * line pullups.
86  */
87 static inline void usb_gadget_stop(struct usb_gadget *gadget,
88                 struct usb_gadget_driver *driver)
89 {
90         gadget->ops->stop(driver);
91 }
92
93 /**
94  * usb_udc_release - release the usb_udc struct
95  * @dev: the dev member within usb_udc
96  *
97  * This is called by driver's core in order to free memory once the last
98  * reference is released.
99  */
100 static void usb_udc_release(struct device *dev)
101 {
102         struct usb_udc *udc;
103
104         udc = container_of(dev, struct usb_udc, dev);
105         dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
106         kfree(udc);
107 }
108
109 /**
110  * usb_add_gadget_udc - adds a new gadget to the udc class driver list
111  * @parent: the parent device to this udc. Usually the controller
112  * driver's device.
113  * @gadget: the gadget to be added to the list
114  *
115  * Returns zero on success, negative errno otherwise.
116  */
117 int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
118 {
119         struct usb_udc          *udc;
120         int                     ret = -ENOMEM;
121
122         udc = kzalloc(sizeof(*udc), GFP_KERNEL);
123         if (!udc)
124                 goto err1;
125
126         device_initialize(&udc->dev);
127         udc->dev.release = usb_udc_release;
128         udc->dev.class = udc_class;
129         udc->dev.parent = parent;
130         ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
131         if (ret)
132                 goto err2;
133
134         udc->gadget = gadget;
135
136         mutex_lock(&udc_lock);
137         list_add_tail(&udc->list, &udc_list);
138
139         ret = device_add(&udc->dev);
140         if (ret)
141                 goto err3;
142
143         mutex_unlock(&udc_lock);
144
145         return 0;
146 err3:
147         list_del(&udc->list);
148         mutex_unlock(&udc_lock);
149
150 err2:
151         put_device(&udc->dev);
152
153 err1:
154         return ret;
155 }
156 EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
157
158 static void usb_gadget_remove_driver(struct usb_udc *udc)
159 {
160         dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
161                         udc->gadget->name);
162
163         kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
164
165         usb_gadget_stop(udc->gadget, udc->driver);
166
167         udc->driver = NULL;
168         udc->dev.driver = NULL;
169 }
170
171 /**
172  * usb_del_gadget_udc - deletes @udc from udc_list
173  * @gadget: the gadget to be removed.
174  *
175  * This, will call usb_gadget_unregister_driver() if
176  * the @udc is still busy.
177  */
178 void usb_del_gadget_udc(struct usb_gadget *gadget)
179 {
180         struct usb_udc          *udc = NULL;
181
182         mutex_lock(&udc_lock);
183         list_for_each_entry(udc, &udc_list, list)
184                 if (udc->gadget == gadget)
185                         goto found;
186
187         dev_err(gadget->dev.parent, "gadget not registered.\n");
188         mutex_unlock(&udc_lock);
189
190         return;
191
192 found:
193         dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
194
195         list_del(&udc->list);
196         mutex_unlock(&udc_lock);
197
198         if (udc->driver)
199                 usb_gadget_remove_driver(udc);
200
201         kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
202         device_unregister(&udc->dev);
203 }
204 EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
205
206 /* ------------------------------------------------------------------------- */
207
208 int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
209                 int (*bind)(struct usb_gadget *))
210 {
211         struct usb_udc          *udc = NULL;
212         int                     ret;
213
214         if (!driver || !bind || !driver->setup)
215                 return -EINVAL;
216
217         mutex_lock(&udc_lock);
218         list_for_each_entry(udc, &udc_list, list) {
219                 /* For now we take the first one */
220                 if (!udc->driver)
221                         goto found;
222         }
223
224         pr_debug("couldn't find an available UDC\n");
225         mutex_unlock(&udc_lock);
226         return -ENODEV;
227
228 found:
229         dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
230                         driver->function);
231
232         udc->driver = driver;
233         udc->dev.driver = &driver->driver;
234
235         ret = usb_gadget_start(udc->gadget, driver, bind);
236         if (ret)
237                 goto err1;
238
239         kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
240         mutex_unlock(&udc_lock);
241         return 0;
242
243 err1:
244         dev_err(&udc->dev, "failed to start %s: %d\n",
245                         udc->driver->function, ret);
246         udc->driver = NULL;
247         udc->dev.driver = NULL;
248         mutex_unlock(&udc_lock);
249         return ret;
250 }
251 EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
252
253 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
254 {
255         struct usb_udc          *udc = NULL;
256         int                     ret = -ENODEV;
257
258         if (!driver || !driver->unbind)
259                 return -EINVAL;
260
261         mutex_lock(&udc_lock);
262         list_for_each_entry(udc, &udc_list, list)
263                 if (udc->driver == driver) {
264                         usb_gadget_remove_driver(udc);
265                         ret = 0;
266                         break;
267                 }
268
269         mutex_unlock(&udc_lock);
270         return ret;
271 }
272 EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
273
274 /* ------------------------------------------------------------------------- */
275
276 static ssize_t usb_udc_srp_store(struct device *dev,
277                 struct device_attribute *attr, const char *buf, size_t n)
278 {
279         struct usb_udc          *udc = dev_get_drvdata(dev);
280
281         if (sysfs_streq(buf, "1"))
282                 usb_gadget_wakeup(udc->gadget);
283
284         return n;
285 }
286 static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
287
288 static ssize_t usb_udc_softconn_store(struct device *dev,
289                 struct device_attribute *attr, const char *buf, size_t n)
290 {
291         struct usb_udc          *udc = dev_get_drvdata(dev);
292
293         if (sysfs_streq(buf, "connect")) {
294                 usb_gadget_connect(udc->gadget);
295         } else if (sysfs_streq(buf, "disconnect")) {
296                 usb_gadget_disconnect(udc->gadget);
297         } else {
298                 dev_err(dev, "unsupported command '%s'\n", buf);
299                 return -EINVAL;
300         }
301
302         return n;
303 }
304 static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
305
306 static ssize_t usb_udc_speed_show(struct device *dev,
307                 struct device_attribute *attr, char *buf)
308 {
309         struct usb_udc          *udc = dev_get_drvdata(dev);
310         struct usb_gadget       *gadget = udc->gadget;
311
312         switch (gadget->speed) {
313         case USB_SPEED_LOW:
314                 return snprintf(buf, PAGE_SIZE, "low-speed\n");
315         case USB_SPEED_FULL:
316                 return snprintf(buf, PAGE_SIZE, "full-speed\n");
317         case USB_SPEED_HIGH:
318                 return snprintf(buf, PAGE_SIZE, "high-speed\n");
319         case USB_SPEED_WIRELESS:
320                 return snprintf(buf, PAGE_SIZE, "wireless\n");
321         case USB_SPEED_SUPER:
322                 return snprintf(buf, PAGE_SIZE, "super-speed\n");
323         case USB_SPEED_UNKNOWN: /* FALLTHROUGH */
324         default:
325                 return snprintf(buf, PAGE_SIZE, "UNKNOWN\n");
326         }
327 }
328 static DEVICE_ATTR(speed, S_IRUSR, usb_udc_speed_show, NULL);
329
330 #define USB_UDC_ATTR(name)                                      \
331 ssize_t usb_udc_##name##_show(struct device *dev,               \
332                 struct device_attribute *attr, char *buf)       \
333 {                                                               \
334         struct usb_udc          *udc = dev_get_drvdata(dev);    \
335         struct usb_gadget       *gadget = udc->gadget;          \
336                                                                 \
337         return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name);  \
338 }                                                               \
339 static DEVICE_ATTR(name, S_IRUSR, usb_udc_##name##_show, NULL)
340
341 static USB_UDC_ATTR(is_dualspeed);
342 static USB_UDC_ATTR(is_otg);
343 static USB_UDC_ATTR(is_a_peripheral);
344 static USB_UDC_ATTR(b_hnp_enable);
345 static USB_UDC_ATTR(a_hnp_support);
346 static USB_UDC_ATTR(a_alt_hnp_support);
347
348 static struct attribute *usb_udc_attrs[] = {
349         &dev_attr_srp.attr,
350         &dev_attr_soft_connect.attr,
351         &dev_attr_speed.attr,
352
353         &dev_attr_is_dualspeed.attr,
354         &dev_attr_is_otg.attr,
355         &dev_attr_is_a_peripheral.attr,
356         &dev_attr_b_hnp_enable.attr,
357         &dev_attr_a_hnp_support.attr,
358         &dev_attr_a_alt_hnp_support.attr,
359         NULL,
360 };
361
362 static const struct attribute_group usb_udc_attr_group = {
363         .attrs = usb_udc_attrs,
364 };
365
366 static const struct attribute_group *usb_udc_attr_groups[] = {
367         &usb_udc_attr_group,
368         NULL,
369 };
370
371 static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
372 {
373         struct usb_udc          *udc = container_of(dev, struct usb_udc, dev);
374         int                     ret;
375
376         ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
377         if (ret) {
378                 dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
379                 return ret;
380         }
381
382         if (udc->driver) {
383                 ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
384                                 udc->driver->function);
385                 if (ret) {
386                         dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
387                         return ret;
388                 }
389         }
390
391         return 0;
392 }
393
394 static int __init usb_udc_init(void)
395 {
396         udc_class = class_create(THIS_MODULE, "udc");
397         if (IS_ERR(udc_class)) {
398                 pr_err("failed to create udc class --> %ld\n",
399                                 PTR_ERR(udc_class));
400                 return PTR_ERR(udc_class);
401         }
402
403         udc_class->dev_uevent = usb_udc_uevent;
404         udc_device_type.groups = usb_udc_attr_groups;
405
406         return 0;
407 }
408 subsys_initcall(usb_udc_init);
409
410 static void __exit usb_udc_exit(void)
411 {
412         class_destroy(udc_class);
413 }
414 module_exit(usb_udc_exit);
415
416 MODULE_DESCRIPTION("UDC Framework");
417 MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
418 MODULE_LICENSE("GPL v2");