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#include <linux/dma-mapping.h>
26#include <linux/workqueue.h>
27
28#include <linux/usb/ch9.h>
29#include <linux/usb/gadget.h>
30#include <linux/usb.h>
31
32/**
33 * struct usb_udc - describes one usb device controller
34 * @driver - the gadget driver pointer. For use by the class code
35 * @dev - the child device to the actual controller
36 * @gadget - the gadget. For use by the class code
37 * @list - for use by the udc class driver
38 * @vbus - for udcs who care about vbus status, this value is real vbus status;
39 * for udcs who do not care about vbus status, this value is always true
40 *
41 * This represents the internal data structure which is used by the UDC-class
42 * to hold information about udc driver and gadget together.
43 */
44struct usb_udc {
45	struct usb_gadget_driver	*driver;
46	struct usb_gadget		*gadget;
47	struct device			dev;
48	struct list_head		list;
49	bool				vbus;
50};
51
52static struct class *udc_class;
53static LIST_HEAD(udc_list);
54static DEFINE_MUTEX(udc_lock);
55
56/* ------------------------------------------------------------------------- */
57
58#ifdef	CONFIG_HAS_DMA
59
60int usb_gadget_map_request(struct usb_gadget *gadget,
61		struct usb_request *req, int is_in)
62{
63	if (req->length == 0)
64		return 0;
65
66	if (req->num_sgs) {
67		int     mapped;
68
69		mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
70				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
71		if (mapped == 0) {
72			dev_err(&gadget->dev, "failed to map SGs\n");
73			return -EFAULT;
74		}
75
76		req->num_mapped_sgs = mapped;
77	} else {
78		req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
79				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
80
81		if (dma_mapping_error(&gadget->dev, req->dma)) {
82			dev_err(&gadget->dev, "failed to map buffer\n");
83			return -EFAULT;
84		}
85	}
86
87	return 0;
88}
89EXPORT_SYMBOL_GPL(usb_gadget_map_request);
90
91void usb_gadget_unmap_request(struct usb_gadget *gadget,
92		struct usb_request *req, int is_in)
93{
94	if (req->length == 0)
95		return;
96
97	if (req->num_mapped_sgs) {
98		dma_unmap_sg(&gadget->dev, req->sg, req->num_mapped_sgs,
99				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
100
101		req->num_mapped_sgs = 0;
102	} else {
103		dma_unmap_single(&gadget->dev, req->dma, req->length,
104				is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
105	}
106}
107EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
108
109#endif	/* CONFIG_HAS_DMA */
110
111/* ------------------------------------------------------------------------- */
112
113/**
114 * usb_gadget_giveback_request - give the request back to the gadget layer
115 * Context: in_interrupt()
116 *
117 * This is called by device controller drivers in order to return the
118 * completed request back to the gadget layer.
119 */
120void usb_gadget_giveback_request(struct usb_ep *ep,
121		struct usb_request *req)
122{
123	if (likely(req->status == 0))
124		usb_led_activity(USB_LED_EVENT_GADGET);
125
126	req->complete(ep, req);
127}
128EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
129
130/* ------------------------------------------------------------------------- */
131
132static void usb_gadget_state_work(struct work_struct *work)
133{
134	struct usb_gadget *gadget = work_to_gadget(work);
135	struct usb_udc *udc = gadget->udc;
136
137	if (udc)
138		sysfs_notify(&udc->dev.kobj, NULL, "state");
139}
140
141void usb_gadget_set_state(struct usb_gadget *gadget,
142		enum usb_device_state state)
143{
144	gadget->state = state;
145	schedule_work(&gadget->work);
146}
147EXPORT_SYMBOL_GPL(usb_gadget_set_state);
148
149/* ------------------------------------------------------------------------- */
150
151static void usb_udc_connect_control(struct usb_udc *udc)
152{
153	if (udc->vbus)
154		usb_gadget_connect(udc->gadget);
155	else
156		usb_gadget_disconnect(udc->gadget);
157}
158
159/**
160 * usb_udc_vbus_handler - updates the udc core vbus status, and try to
161 * connect or disconnect gadget
162 * @gadget: The gadget which vbus change occurs
163 * @status: The vbus status
164 *
165 * The udc driver calls it when it wants to connect or disconnect gadget
166 * according to vbus status.
167 */
168void usb_udc_vbus_handler(struct usb_gadget *gadget, bool status)
169{
170	struct usb_udc *udc = gadget->udc;
171
172	if (udc) {
173		udc->vbus = status;
174		usb_udc_connect_control(udc);
175	}
176}
177EXPORT_SYMBOL_GPL(usb_udc_vbus_handler);
178
179/**
180 * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
181 * @gadget: The gadget which bus reset occurs
182 * @driver: The gadget driver we want to notify
183 *
184 * If the udc driver has bus reset handler, it needs to call this when the bus
185 * reset occurs, it notifies the gadget driver that the bus reset occurs as
186 * well as updates gadget state.
187 */
188void usb_gadget_udc_reset(struct usb_gadget *gadget,
189		struct usb_gadget_driver *driver)
190{
191	driver->reset(gadget);
192	usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
193}
194EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
195
196/**
197 * usb_gadget_udc_start - tells usb device controller to start up
198 * @udc: The UDC to be started
199 *
200 * This call is issued by the UDC Class driver when it's about
201 * to register a gadget driver to the device controller, before
202 * calling gadget driver's bind() method.
203 *
204 * It allows the controller to be powered off until strictly
205 * necessary to have it powered on.
206 *
207 * Returns zero on success, else negative errno.
208 */
209static inline int usb_gadget_udc_start(struct usb_udc *udc)
210{
211	return udc->gadget->ops->udc_start(udc->gadget, udc->driver);
212}
213
214/**
215 * usb_gadget_udc_stop - tells usb device controller we don't need it anymore
216 * @gadget: The device we want to stop activity
217 * @driver: The driver to unbind from @gadget
218 *
219 * This call is issued by the UDC Class driver after calling
220 * gadget driver's unbind() method.
221 *
222 * The details are implementation specific, but it can go as
223 * far as powering off UDC completely and disable its data
224 * line pullups.
225 */
226static inline void usb_gadget_udc_stop(struct usb_udc *udc)
227{
228	udc->gadget->ops->udc_stop(udc->gadget);
229}
230
231/**
232 * usb_udc_release - release the usb_udc struct
233 * @dev: the dev member within usb_udc
234 *
235 * This is called by driver's core in order to free memory once the last
236 * reference is released.
237 */
238static void usb_udc_release(struct device *dev)
239{
240	struct usb_udc *udc;
241
242	udc = container_of(dev, struct usb_udc, dev);
243	dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
244	kfree(udc);
245}
246
247static const struct attribute_group *usb_udc_attr_groups[];
248
249static void usb_udc_nop_release(struct device *dev)
250{
251	dev_vdbg(dev, "%s\n", __func__);
252}
253
254/**
255 * usb_add_gadget_udc_release - adds a new gadget to the udc class driver list
256 * @parent: the parent device to this udc. Usually the controller driver's
257 * device.
258 * @gadget: the gadget to be added to the list.
259 * @release: a gadget release function.
260 *
261 * Returns zero on success, negative errno otherwise.
262 */
263int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
264		void (*release)(struct device *dev))
265{
266	struct usb_udc		*udc;
267	int			ret = -ENOMEM;
268
269	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
270	if (!udc)
271		goto err1;
272
273	dev_set_name(&gadget->dev, "gadget");
274	INIT_WORK(&gadget->work, usb_gadget_state_work);
275	gadget->dev.parent = parent;
276
277#ifdef	CONFIG_HAS_DMA
278	dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
279	gadget->dev.dma_parms = parent->dma_parms;
280	gadget->dev.dma_mask = parent->dma_mask;
281#endif
282
283	if (release)
284		gadget->dev.release = release;
285	else
286		gadget->dev.release = usb_udc_nop_release;
287
288	ret = device_register(&gadget->dev);
289	if (ret)
290		goto err2;
291
292	device_initialize(&udc->dev);
293	udc->dev.release = usb_udc_release;
294	udc->dev.class = udc_class;
295	udc->dev.groups = usb_udc_attr_groups;
296	udc->dev.parent = parent;
297	ret = dev_set_name(&udc->dev, "%s", kobject_name(&parent->kobj));
298	if (ret)
299		goto err3;
300
301	udc->gadget = gadget;
302	gadget->udc = udc;
303
304	mutex_lock(&udc_lock);
305	list_add_tail(&udc->list, &udc_list);
306
307	ret = device_add(&udc->dev);
308	if (ret)
309		goto err4;
310
311	usb_gadget_set_state(gadget, USB_STATE_NOTATTACHED);
312	udc->vbus = true;
313
314	mutex_unlock(&udc_lock);
315
316	return 0;
317
318err4:
319	list_del(&udc->list);
320	mutex_unlock(&udc_lock);
321
322err3:
323	put_device(&udc->dev);
324	device_del(&gadget->dev);
325
326err2:
327	put_device(&gadget->dev);
328	kfree(udc);
329
330err1:
331	return ret;
332}
333EXPORT_SYMBOL_GPL(usb_add_gadget_udc_release);
334
335/**
336 * usb_add_gadget_udc - adds a new gadget to the udc class driver list
337 * @parent: the parent device to this udc. Usually the controller
338 * driver's device.
339 * @gadget: the gadget to be added to the list
340 *
341 * Returns zero on success, negative errno otherwise.
342 */
343int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget)
344{
345	return usb_add_gadget_udc_release(parent, gadget, NULL);
346}
347EXPORT_SYMBOL_GPL(usb_add_gadget_udc);
348
349static void usb_gadget_remove_driver(struct usb_udc *udc)
350{
351	dev_dbg(&udc->dev, "unregistering UDC driver [%s]\n",
352			udc->driver->function);
353
354	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
355
356	usb_gadget_disconnect(udc->gadget);
357	udc->driver->disconnect(udc->gadget);
358	udc->driver->unbind(udc->gadget);
359	usb_gadget_udc_stop(udc);
360
361	udc->driver = NULL;
362	udc->dev.driver = NULL;
363	udc->gadget->dev.driver = NULL;
364}
365
366/**
367 * usb_del_gadget_udc - deletes @udc from udc_list
368 * @gadget: the gadget to be removed.
369 *
370 * This, will call usb_gadget_unregister_driver() if
371 * the @udc is still busy.
372 */
373void usb_del_gadget_udc(struct usb_gadget *gadget)
374{
375	struct usb_udc *udc = gadget->udc;
376
377	if (!udc)
378		return;
379
380	dev_vdbg(gadget->dev.parent, "unregistering gadget\n");
381
382	mutex_lock(&udc_lock);
383	list_del(&udc->list);
384	mutex_unlock(&udc_lock);
385
386	if (udc->driver)
387		usb_gadget_remove_driver(udc);
388
389	kobject_uevent(&udc->dev.kobj, KOBJ_REMOVE);
390	flush_work(&gadget->work);
391	device_unregister(&udc->dev);
392	device_unregister(&gadget->dev);
393}
394EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
395
396/* ------------------------------------------------------------------------- */
397
398static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *driver)
399{
400	int ret;
401
402	dev_dbg(&udc->dev, "registering UDC driver [%s]\n",
403			driver->function);
404
405	udc->driver = driver;
406	udc->dev.driver = &driver->driver;
407	udc->gadget->dev.driver = &driver->driver;
408
409	ret = driver->bind(udc->gadget, driver);
410	if (ret)
411		goto err1;
412	ret = usb_gadget_udc_start(udc);
413	if (ret) {
414		driver->unbind(udc->gadget);
415		goto err1;
416	}
417	usb_udc_connect_control(udc);
418
419	kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
420	return 0;
421err1:
422	if (ret != -EISNAM)
423		dev_err(&udc->dev, "failed to start %s: %d\n",
424			udc->driver->function, ret);
425	udc->driver = NULL;
426	udc->dev.driver = NULL;
427	udc->gadget->dev.driver = NULL;
428	return ret;
429}
430
431int usb_udc_attach_driver(const char *name, struct usb_gadget_driver *driver)
432{
433	struct usb_udc *udc = NULL;
434	int ret = -ENODEV;
435
436	mutex_lock(&udc_lock);
437	list_for_each_entry(udc, &udc_list, list) {
438		ret = strcmp(name, dev_name(&udc->dev));
439		if (!ret)
440			break;
441	}
442	if (ret) {
443		ret = -ENODEV;
444		goto out;
445	}
446	if (udc->driver) {
447		ret = -EBUSY;
448		goto out;
449	}
450	ret = udc_bind_to_driver(udc, driver);
451out:
452	mutex_unlock(&udc_lock);
453	return ret;
454}
455EXPORT_SYMBOL_GPL(usb_udc_attach_driver);
456
457int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
458{
459	struct usb_udc		*udc = NULL;
460	int			ret;
461
462	if (!driver || !driver->bind || !driver->setup)
463		return -EINVAL;
464
465	mutex_lock(&udc_lock);
466	list_for_each_entry(udc, &udc_list, list) {
467		/* For now we take the first one */
468		if (!udc->driver)
469			goto found;
470	}
471
472	pr_debug("couldn't find an available UDC\n");
473	mutex_unlock(&udc_lock);
474	return -ENODEV;
475found:
476	ret = udc_bind_to_driver(udc, driver);
477	mutex_unlock(&udc_lock);
478	return ret;
479}
480EXPORT_SYMBOL_GPL(usb_gadget_probe_driver);
481
482int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
483{
484	struct usb_udc		*udc = NULL;
485	int			ret = -ENODEV;
486
487	if (!driver || !driver->unbind)
488		return -EINVAL;
489
490	mutex_lock(&udc_lock);
491	list_for_each_entry(udc, &udc_list, list)
492		if (udc->driver == driver) {
493			usb_gadget_remove_driver(udc);
494			usb_gadget_set_state(udc->gadget,
495					USB_STATE_NOTATTACHED);
496			ret = 0;
497			break;
498		}
499
500	mutex_unlock(&udc_lock);
501	return ret;
502}
503EXPORT_SYMBOL_GPL(usb_gadget_unregister_driver);
504
505/* ------------------------------------------------------------------------- */
506
507static ssize_t usb_udc_srp_store(struct device *dev,
508		struct device_attribute *attr, const char *buf, size_t n)
509{
510	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
511
512	if (sysfs_streq(buf, "1"))
513		usb_gadget_wakeup(udc->gadget);
514
515	return n;
516}
517static DEVICE_ATTR(srp, S_IWUSR, NULL, usb_udc_srp_store);
518
519static ssize_t usb_udc_softconn_store(struct device *dev,
520		struct device_attribute *attr, const char *buf, size_t n)
521{
522	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
523
524	if (!udc->driver) {
525		dev_err(dev, "soft-connect without a gadget driver\n");
526		return -EOPNOTSUPP;
527	}
528
529	if (sysfs_streq(buf, "connect")) {
530		usb_gadget_udc_start(udc);
531		usb_gadget_connect(udc->gadget);
532	} else if (sysfs_streq(buf, "disconnect")) {
533		usb_gadget_disconnect(udc->gadget);
534		udc->driver->disconnect(udc->gadget);
535		usb_gadget_udc_stop(udc);
536	} else {
537		dev_err(dev, "unsupported command '%s'\n", buf);
538		return -EINVAL;
539	}
540
541	return n;
542}
543static DEVICE_ATTR(soft_connect, S_IWUSR, NULL, usb_udc_softconn_store);
544
545static ssize_t state_show(struct device *dev, struct device_attribute *attr,
546			  char *buf)
547{
548	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
549	struct usb_gadget	*gadget = udc->gadget;
550
551	return sprintf(buf, "%s\n", usb_state_string(gadget->state));
552}
553static DEVICE_ATTR_RO(state);
554
555#define USB_UDC_SPEED_ATTR(name, param)					\
556ssize_t name##_show(struct device *dev,					\
557		struct device_attribute *attr, char *buf)		\
558{									\
559	struct usb_udc *udc = container_of(dev, struct usb_udc, dev);	\
560	return snprintf(buf, PAGE_SIZE, "%s\n",				\
561			usb_speed_string(udc->gadget->param));		\
562}									\
563static DEVICE_ATTR_RO(name)
564
565static USB_UDC_SPEED_ATTR(current_speed, speed);
566static USB_UDC_SPEED_ATTR(maximum_speed, max_speed);
567
568#define USB_UDC_ATTR(name)					\
569ssize_t name##_show(struct device *dev,				\
570		struct device_attribute *attr, char *buf)	\
571{								\
572	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev); \
573	struct usb_gadget	*gadget = udc->gadget;		\
574								\
575	return snprintf(buf, PAGE_SIZE, "%d\n", gadget->name);	\
576}								\
577static DEVICE_ATTR_RO(name)
578
579static USB_UDC_ATTR(is_otg);
580static USB_UDC_ATTR(is_a_peripheral);
581static USB_UDC_ATTR(b_hnp_enable);
582static USB_UDC_ATTR(a_hnp_support);
583static USB_UDC_ATTR(a_alt_hnp_support);
584static USB_UDC_ATTR(is_selfpowered);
585
586static struct attribute *usb_udc_attrs[] = {
587	&dev_attr_srp.attr,
588	&dev_attr_soft_connect.attr,
589	&dev_attr_state.attr,
590	&dev_attr_current_speed.attr,
591	&dev_attr_maximum_speed.attr,
592
593	&dev_attr_is_otg.attr,
594	&dev_attr_is_a_peripheral.attr,
595	&dev_attr_b_hnp_enable.attr,
596	&dev_attr_a_hnp_support.attr,
597	&dev_attr_a_alt_hnp_support.attr,
598	&dev_attr_is_selfpowered.attr,
599	NULL,
600};
601
602static const struct attribute_group usb_udc_attr_group = {
603	.attrs = usb_udc_attrs,
604};
605
606static const struct attribute_group *usb_udc_attr_groups[] = {
607	&usb_udc_attr_group,
608	NULL,
609};
610
611static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env)
612{
613	struct usb_udc		*udc = container_of(dev, struct usb_udc, dev);
614	int			ret;
615
616	ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name);
617	if (ret) {
618		dev_err(dev, "failed to add uevent USB_UDC_NAME\n");
619		return ret;
620	}
621
622	if (udc->driver) {
623		ret = add_uevent_var(env, "USB_UDC_DRIVER=%s",
624				udc->driver->function);
625		if (ret) {
626			dev_err(dev, "failed to add uevent USB_UDC_DRIVER\n");
627			return ret;
628		}
629	}
630
631	return 0;
632}
633
634static int __init usb_udc_init(void)
635{
636	udc_class = class_create(THIS_MODULE, "udc");
637	if (IS_ERR(udc_class)) {
638		pr_err("failed to create udc class --> %ld\n",
639				PTR_ERR(udc_class));
640		return PTR_ERR(udc_class);
641	}
642
643	udc_class->dev_uevent = usb_udc_uevent;
644	return 0;
645}
646subsys_initcall(usb_udc_init);
647
648static void __exit usb_udc_exit(void)
649{
650	class_destroy(udc_class);
651}
652module_exit(usb_udc_exit);
653
654MODULE_DESCRIPTION("UDC Framework");
655MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
656MODULE_LICENSE("GPL v2");
657