1 // SPDX-License-Identifier: GPL-2.0
3 * USB Raw Gadget driver.
4 * See Documentation/usb/raw-gadget.rst for more details.
6 * Andrey Konovalov <andreyknvl@gmail.com>
9 #include <linux/compiler.h>
10 #include <linux/debugfs.h>
11 #include <linux/delay.h>
12 #include <linux/kref.h>
13 #include <linux/miscdevice.h>
14 #include <linux/module.h>
15 #include <linux/semaphore.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/uaccess.h>
19 #include <linux/wait.h>
21 #include <linux/usb.h>
22 #include <linux/usb/ch9.h>
23 #include <linux/usb/ch11.h>
24 #include <linux/usb/gadget.h>
26 #include <uapi/linux/usb/raw_gadget.h>
28 #define DRIVER_DESC "USB Raw Gadget"
29 #define DRIVER_NAME "raw-gadget"
31 MODULE_DESCRIPTION(DRIVER_DESC);
32 MODULE_AUTHOR("Andrey Konovalov");
33 MODULE_LICENSE("GPL");
35 /*----------------------------------------------------------------------*/
37 #define RAW_EVENT_QUEUE_SIZE 16
39 struct raw_event_queue {
40 /* See the comment in raw_event_queue_fetch() for locking details. */
42 struct semaphore sema;
43 struct usb_raw_event *events[RAW_EVENT_QUEUE_SIZE];
47 static void raw_event_queue_init(struct raw_event_queue *queue)
49 spin_lock_init(&queue->lock);
50 sema_init(&queue->sema, 0);
54 static int raw_event_queue_add(struct raw_event_queue *queue,
55 enum usb_raw_event_type type, size_t length, const void *data)
58 struct usb_raw_event *event;
60 spin_lock_irqsave(&queue->lock, flags);
61 if (WARN_ON(queue->size >= RAW_EVENT_QUEUE_SIZE)) {
62 spin_unlock_irqrestore(&queue->lock, flags);
65 event = kmalloc(sizeof(*event) + length, GFP_ATOMIC);
67 spin_unlock_irqrestore(&queue->lock, flags);
71 event->length = length;
73 memcpy(&event->data[0], data, length);
74 queue->events[queue->size] = event;
77 spin_unlock_irqrestore(&queue->lock, flags);
81 static struct usb_raw_event *raw_event_queue_fetch(
82 struct raw_event_queue *queue)
85 struct usb_raw_event *event;
88 * This function can be called concurrently. We first check that
89 * there's at least one event queued by decrementing the semaphore,
90 * and then take the lock to protect queue struct fields.
92 if (down_interruptible(&queue->sema))
94 spin_lock_irqsave(&queue->lock, flags);
95 if (WARN_ON(!queue->size))
97 event = queue->events[0];
99 memmove(&queue->events[0], &queue->events[1],
100 queue->size * sizeof(queue->events[0]));
101 spin_unlock_irqrestore(&queue->lock, flags);
105 static void raw_event_queue_destroy(struct raw_event_queue *queue)
109 for (i = 0; i < queue->size; i++)
110 kfree(queue->events[i]);
114 /*----------------------------------------------------------------------*/
118 #define USB_RAW_MAX_ENDPOINTS 32
129 struct usb_request *req;
136 STATE_DEV_INVALID = 0,
138 STATE_DEV_INITIALIZED,
148 const char *udc_name;
149 struct usb_gadget_driver driver;
151 /* Reference to misc device: */
154 /* Protected by lock: */
155 enum dev_state state;
156 bool gadget_registered;
157 struct usb_gadget *gadget;
158 struct usb_request *req;
160 bool ep0_out_pending;
163 struct raw_ep eps[USB_RAW_MAX_ENDPOINTS];
165 struct completion ep0_done;
166 struct raw_event_queue queue;
169 static struct raw_dev *dev_new(void)
173 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
176 /* Matches kref_put() in raw_release(). */
177 kref_init(&dev->count);
178 spin_lock_init(&dev->lock);
179 init_completion(&dev->ep0_done);
180 raw_event_queue_init(&dev->queue);
184 static void dev_free(struct kref *kref)
186 struct raw_dev *dev = container_of(kref, struct raw_dev, count);
189 kfree(dev->udc_name);
190 kfree(dev->driver.udc_name);
192 if (dev->ep0_urb_queued)
193 usb_ep_dequeue(dev->gadget->ep0, dev->req);
194 usb_ep_free_request(dev->gadget->ep0, dev->req);
196 raw_event_queue_destroy(&dev->queue);
197 for (i = 0; i < USB_RAW_MAX_ENDPOINTS; i++) {
198 if (dev->eps[i].state != STATE_EP_ENABLED)
200 usb_ep_disable(dev->eps[i].ep);
201 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
202 kfree(dev->eps[i].ep->desc);
203 dev->eps[i].state = STATE_EP_DISABLED;
208 /*----------------------------------------------------------------------*/
210 static int raw_queue_event(struct raw_dev *dev,
211 enum usb_raw_event_type type, size_t length, const void *data)
216 ret = raw_event_queue_add(&dev->queue, type, length, data);
218 spin_lock_irqsave(&dev->lock, flags);
219 dev->state = STATE_DEV_FAILED;
220 spin_unlock_irqrestore(&dev->lock, flags);
225 static void gadget_ep0_complete(struct usb_ep *ep, struct usb_request *req)
227 struct raw_dev *dev = req->context;
230 spin_lock_irqsave(&dev->lock, flags);
232 dev->ep0_status = req->status;
234 dev->ep0_status = req->actual;
235 if (dev->ep0_in_pending)
236 dev->ep0_in_pending = false;
238 dev->ep0_out_pending = false;
239 spin_unlock_irqrestore(&dev->lock, flags);
241 complete(&dev->ep0_done);
244 static int gadget_bind(struct usb_gadget *gadget,
245 struct usb_gadget_driver *driver)
248 struct raw_dev *dev = container_of(driver, struct raw_dev, driver);
249 struct usb_request *req;
252 if (strcmp(gadget->name, dev->udc_name) != 0)
255 set_gadget_data(gadget, dev);
256 req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
258 dev_err(&gadget->dev, "usb_ep_alloc_request failed\n");
259 set_gadget_data(gadget, NULL);
263 spin_lock_irqsave(&dev->lock, flags);
265 dev->req->context = dev;
266 dev->req->complete = gadget_ep0_complete;
267 dev->gadget = gadget;
268 spin_unlock_irqrestore(&dev->lock, flags);
270 /* Matches kref_put() in gadget_unbind(). */
271 kref_get(&dev->count);
273 ret = raw_queue_event(dev, USB_RAW_EVENT_CONNECT, 0, NULL);
275 dev_err(&gadget->dev, "failed to queue event\n");
280 static void gadget_unbind(struct usb_gadget *gadget)
282 struct raw_dev *dev = get_gadget_data(gadget);
284 set_gadget_data(gadget, NULL);
285 /* Matches kref_get() in gadget_bind(). */
286 kref_put(&dev->count, dev_free);
289 static int gadget_setup(struct usb_gadget *gadget,
290 const struct usb_ctrlrequest *ctrl)
293 struct raw_dev *dev = get_gadget_data(gadget);
296 spin_lock_irqsave(&dev->lock, flags);
297 if (dev->state != STATE_DEV_RUNNING) {
298 dev_err(&gadget->dev, "ignoring, device is not running\n");
302 if (dev->ep0_in_pending || dev->ep0_out_pending) {
303 dev_dbg(&gadget->dev, "stalling, request already pending\n");
307 if ((ctrl->bRequestType & USB_DIR_IN) && ctrl->wLength)
308 dev->ep0_in_pending = true;
310 dev->ep0_out_pending = true;
311 spin_unlock_irqrestore(&dev->lock, flags);
313 ret = raw_queue_event(dev, USB_RAW_EVENT_CONTROL, sizeof(*ctrl), ctrl);
315 dev_err(&gadget->dev, "failed to queue event\n");
319 spin_unlock_irqrestore(&dev->lock, flags);
324 /* These are currently unused but present in case UDC driver requires them. */
325 static void gadget_disconnect(struct usb_gadget *gadget) { }
326 static void gadget_suspend(struct usb_gadget *gadget) { }
327 static void gadget_resume(struct usb_gadget *gadget) { }
328 static void gadget_reset(struct usb_gadget *gadget) { }
330 /*----------------------------------------------------------------------*/
332 static struct miscdevice raw_misc_device;
334 static int raw_open(struct inode *inode, struct file *fd)
338 /* Nonblocking I/O is not supported yet. */
339 if (fd->f_flags & O_NONBLOCK)
345 fd->private_data = dev;
346 dev->state = STATE_DEV_OPENED;
347 dev->dev = raw_misc_device.this_device;
351 static int raw_release(struct inode *inode, struct file *fd)
354 struct raw_dev *dev = fd->private_data;
356 bool unregister = false;
358 spin_lock_irqsave(&dev->lock, flags);
359 dev->state = STATE_DEV_CLOSED;
361 spin_unlock_irqrestore(&dev->lock, flags);
364 if (dev->gadget_registered)
366 dev->gadget_registered = false;
367 spin_unlock_irqrestore(&dev->lock, flags);
370 ret = usb_gadget_unregister_driver(&dev->driver);
373 "usb_gadget_unregister_driver() failed with %d\n",
375 /* Matches kref_get() in raw_ioctl_run(). */
376 kref_put(&dev->count, dev_free);
380 /* Matches dev_new() in raw_open(). */
381 kref_put(&dev->count, dev_free);
385 /*----------------------------------------------------------------------*/
387 static int raw_ioctl_init(struct raw_dev *dev, unsigned long value)
390 struct usb_raw_init arg;
391 char *udc_driver_name;
392 char *udc_device_name;
395 ret = copy_from_user(&arg, (void __user *)value, sizeof(arg));
400 case USB_SPEED_UNKNOWN:
401 arg.speed = USB_SPEED_HIGH;
406 case USB_SPEED_SUPER:
412 udc_driver_name = kmalloc(UDC_NAME_LENGTH_MAX, GFP_KERNEL);
413 if (!udc_driver_name)
415 ret = strscpy(udc_driver_name, &arg.driver_name[0],
416 UDC_NAME_LENGTH_MAX);
418 kfree(udc_driver_name);
423 udc_device_name = kmalloc(UDC_NAME_LENGTH_MAX, GFP_KERNEL);
424 if (!udc_device_name) {
425 kfree(udc_driver_name);
428 ret = strscpy(udc_device_name, &arg.device_name[0],
429 UDC_NAME_LENGTH_MAX);
431 kfree(udc_driver_name);
432 kfree(udc_device_name);
437 spin_lock_irqsave(&dev->lock, flags);
438 if (dev->state != STATE_DEV_OPENED) {
439 dev_dbg(dev->dev, "fail, device is not opened\n");
440 kfree(udc_driver_name);
441 kfree(udc_device_name);
445 dev->udc_name = udc_driver_name;
447 dev->driver.function = DRIVER_DESC;
448 dev->driver.max_speed = arg.speed;
449 dev->driver.setup = gadget_setup;
450 dev->driver.disconnect = gadget_disconnect;
451 dev->driver.bind = gadget_bind;
452 dev->driver.unbind = gadget_unbind;
453 dev->driver.suspend = gadget_suspend;
454 dev->driver.resume = gadget_resume;
455 dev->driver.reset = gadget_reset;
456 dev->driver.driver.name = DRIVER_NAME;
457 dev->driver.udc_name = udc_device_name;
458 dev->driver.match_existing_only = 1;
460 dev->state = STATE_DEV_INITIALIZED;
463 spin_unlock_irqrestore(&dev->lock, flags);
467 static int raw_ioctl_run(struct raw_dev *dev, unsigned long value)
475 spin_lock_irqsave(&dev->lock, flags);
476 if (dev->state != STATE_DEV_INITIALIZED) {
477 dev_dbg(dev->dev, "fail, device is not initialized\n");
481 spin_unlock_irqrestore(&dev->lock, flags);
483 ret = usb_gadget_probe_driver(&dev->driver);
485 spin_lock_irqsave(&dev->lock, flags);
488 "fail, usb_gadget_probe_driver returned %d\n", ret);
489 dev->state = STATE_DEV_FAILED;
492 dev->gadget_registered = true;
493 dev->state = STATE_DEV_RUNNING;
494 /* Matches kref_put() in raw_release(). */
495 kref_get(&dev->count);
498 spin_unlock_irqrestore(&dev->lock, flags);
502 static int raw_ioctl_event_fetch(struct raw_dev *dev, unsigned long value)
505 struct usb_raw_event arg;
507 struct usb_raw_event *event;
510 ret = copy_from_user(&arg, (void __user *)value, sizeof(arg));
514 spin_lock_irqsave(&dev->lock, flags);
515 if (dev->state != STATE_DEV_RUNNING) {
516 dev_dbg(dev->dev, "fail, device is not running\n");
517 spin_unlock_irqrestore(&dev->lock, flags);
521 dev_dbg(dev->dev, "fail, gadget is not bound\n");
522 spin_unlock_irqrestore(&dev->lock, flags);
525 spin_unlock_irqrestore(&dev->lock, flags);
527 event = raw_event_queue_fetch(&dev->queue);
529 dev_dbg(&dev->gadget->dev, "event fetching interrupted\n");
532 length = min(arg.length, event->length);
533 ret = copy_to_user((void __user *)value, event,
534 sizeof(*event) + length);
538 static void *raw_alloc_io_data(struct usb_raw_ep_io *io, void __user *ptr,
544 ret = copy_from_user(io, ptr, sizeof(*io));
547 if (io->ep >= USB_RAW_MAX_ENDPOINTS)
548 return ERR_PTR(-EINVAL);
549 if (!usb_raw_io_flags_valid(io->flags))
550 return ERR_PTR(-EINVAL);
551 if (io->length > PAGE_SIZE)
552 return ERR_PTR(-EINVAL);
554 data = memdup_user(ptr + sizeof(*io), io->length);
556 data = kmalloc(io->length, GFP_KERNEL);
558 data = ERR_PTR(-ENOMEM);
563 static int raw_process_ep0_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
569 spin_lock_irqsave(&dev->lock, flags);
570 if (dev->state != STATE_DEV_RUNNING) {
571 dev_dbg(dev->dev, "fail, device is not running\n");
576 dev_dbg(dev->dev, "fail, gadget is not bound\n");
580 if (dev->ep0_urb_queued) {
581 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
585 if ((in && !dev->ep0_in_pending) ||
586 (!in && !dev->ep0_out_pending)) {
587 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
591 if (WARN_ON(in && dev->ep0_out_pending)) {
593 dev->state = STATE_DEV_FAILED;
596 if (WARN_ON(!in && dev->ep0_in_pending)) {
598 dev->state = STATE_DEV_FAILED;
602 dev->req->buf = data;
603 dev->req->length = io->length;
604 dev->req->zero = usb_raw_io_flags_zero(io->flags);
605 dev->ep0_urb_queued = true;
606 spin_unlock_irqrestore(&dev->lock, flags);
608 ret = usb_ep_queue(dev->gadget->ep0, dev->req, GFP_KERNEL);
610 dev_err(&dev->gadget->dev,
611 "fail, usb_ep_queue returned %d\n", ret);
612 spin_lock_irqsave(&dev->lock, flags);
613 dev->state = STATE_DEV_FAILED;
617 ret = wait_for_completion_interruptible(&dev->ep0_done);
619 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
620 usb_ep_dequeue(dev->gadget->ep0, dev->req);
621 wait_for_completion(&dev->ep0_done);
622 spin_lock_irqsave(&dev->lock, flags);
626 spin_lock_irqsave(&dev->lock, flags);
627 ret = dev->ep0_status;
630 dev->ep0_urb_queued = false;
632 spin_unlock_irqrestore(&dev->lock, flags);
636 static int raw_ioctl_ep0_write(struct raw_dev *dev, unsigned long value)
640 struct usb_raw_ep_io io;
642 data = raw_alloc_io_data(&io, (void __user *)value, true);
644 return PTR_ERR(data);
645 ret = raw_process_ep0_io(dev, &io, data, true);
650 static int raw_ioctl_ep0_read(struct raw_dev *dev, unsigned long value)
654 struct usb_raw_ep_io io;
657 data = raw_alloc_io_data(&io, (void __user *)value, false);
659 return PTR_ERR(data);
660 ret = raw_process_ep0_io(dev, &io, data, false);
665 length = min(io.length, (unsigned int)ret);
666 ret = copy_to_user((void __user *)(value + sizeof(io)), data, length);
671 static bool check_ep_caps(struct usb_ep *ep,
672 struct usb_endpoint_descriptor *desc)
674 switch (usb_endpoint_type(desc)) {
675 case USB_ENDPOINT_XFER_ISOC:
676 if (!ep->caps.type_iso)
679 case USB_ENDPOINT_XFER_BULK:
680 if (!ep->caps.type_bulk)
683 case USB_ENDPOINT_XFER_INT:
684 if (!ep->caps.type_int)
691 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
693 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
699 static int raw_ioctl_ep_enable(struct raw_dev *dev, unsigned long value)
703 struct usb_endpoint_descriptor *desc;
704 struct usb_ep *ep = NULL;
706 desc = memdup_user((void __user *)value, sizeof(*desc));
708 return PTR_ERR(desc);
711 * Endpoints with a maxpacket length of 0 can cause crashes in UDC
714 if (usb_endpoint_maxp(desc) == 0) {
715 dev_dbg(dev->dev, "fail, bad endpoint maxpacket\n");
720 spin_lock_irqsave(&dev->lock, flags);
721 if (dev->state != STATE_DEV_RUNNING) {
722 dev_dbg(dev->dev, "fail, device is not running\n");
727 dev_dbg(dev->dev, "fail, gadget is not bound\n");
732 for (i = 0; i < USB_RAW_MAX_ENDPOINTS; i++) {
733 if (dev->eps[i].state == STATE_EP_ENABLED)
737 if (i == USB_RAW_MAX_ENDPOINTS) {
738 dev_dbg(&dev->gadget->dev,
739 "fail, no device endpoints available\n");
744 gadget_for_each_ep(ep, dev->gadget) {
747 if (!check_ep_caps(ep, desc))
750 ret = usb_ep_enable(ep);
752 dev_err(&dev->gadget->dev,
753 "fail, usb_ep_enable returned %d\n", ret);
756 dev->eps[i].req = usb_ep_alloc_request(ep, GFP_ATOMIC);
757 if (!dev->eps[i].req) {
758 dev_err(&dev->gadget->dev,
759 "fail, usb_ep_alloc_request failed\n");
765 dev->eps[i].state = STATE_EP_ENABLED;
766 ep->driver_data = &dev->eps[i];
771 dev_dbg(&dev->gadget->dev, "fail, no gadget endpoints available\n");
777 spin_unlock_irqrestore(&dev->lock, flags);
781 static int raw_ioctl_ep_disable(struct raw_dev *dev, unsigned long value)
783 int ret = 0, i = value;
787 if (i < 0 || i >= USB_RAW_MAX_ENDPOINTS)
790 spin_lock_irqsave(&dev->lock, flags);
791 if (dev->state != STATE_DEV_RUNNING) {
792 dev_dbg(dev->dev, "fail, device is not running\n");
797 dev_dbg(dev->dev, "fail, gadget is not bound\n");
801 if (dev->eps[i].state != STATE_EP_ENABLED) {
802 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
806 if (dev->eps[i].disabling) {
807 dev_dbg(&dev->gadget->dev,
808 "fail, disable already in progress\n");
812 if (dev->eps[i].urb_queued) {
813 dev_dbg(&dev->gadget->dev,
814 "fail, waiting for urb completion\n");
818 dev->eps[i].disabling = true;
819 spin_unlock_irqrestore(&dev->lock, flags);
821 usb_ep_disable(dev->eps[i].ep);
823 spin_lock_irqsave(&dev->lock, flags);
824 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
825 desc = dev->eps[i].ep->desc;
826 dev->eps[i].ep = NULL;
827 dev->eps[i].state = STATE_EP_DISABLED;
829 dev->eps[i].disabling = false;
832 spin_unlock_irqrestore(&dev->lock, flags);
836 static void gadget_ep_complete(struct usb_ep *ep, struct usb_request *req)
838 struct raw_ep *r_ep = (struct raw_ep *)ep->driver_data;
839 struct raw_dev *dev = r_ep->dev;
842 spin_lock_irqsave(&dev->lock, flags);
844 r_ep->status = req->status;
846 r_ep->status = req->actual;
847 spin_unlock_irqrestore(&dev->lock, flags);
849 complete((struct completion *)req->context);
852 static int raw_process_ep_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
857 struct raw_ep *ep = &dev->eps[io->ep];
858 DECLARE_COMPLETION_ONSTACK(done);
860 spin_lock_irqsave(&dev->lock, flags);
861 if (dev->state != STATE_DEV_RUNNING) {
862 dev_dbg(dev->dev, "fail, device is not running\n");
867 dev_dbg(dev->dev, "fail, gadget is not bound\n");
871 if (ep->state != STATE_EP_ENABLED) {
872 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
877 dev_dbg(&dev->gadget->dev,
878 "fail, endpoint is already being disabled\n");
882 if (ep->urb_queued) {
883 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
887 if ((in && !ep->ep->caps.dir_in) || (!in && ep->ep->caps.dir_in)) {
888 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
894 ep->req->context = &done;
895 ep->req->complete = gadget_ep_complete;
897 ep->req->length = io->length;
898 ep->req->zero = usb_raw_io_flags_zero(io->flags);
899 ep->urb_queued = true;
900 spin_unlock_irqrestore(&dev->lock, flags);
902 ret = usb_ep_queue(ep->ep, ep->req, GFP_KERNEL);
904 dev_err(&dev->gadget->dev,
905 "fail, usb_ep_queue returned %d\n", ret);
906 spin_lock_irqsave(&dev->lock, flags);
907 dev->state = STATE_DEV_FAILED;
911 ret = wait_for_completion_interruptible(&done);
913 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
914 usb_ep_dequeue(ep->ep, ep->req);
915 wait_for_completion(&done);
916 spin_lock_irqsave(&dev->lock, flags);
920 spin_lock_irqsave(&dev->lock, flags);
924 ep->urb_queued = false;
926 spin_unlock_irqrestore(&dev->lock, flags);
930 static int raw_ioctl_ep_write(struct raw_dev *dev, unsigned long value)
934 struct usb_raw_ep_io io;
936 data = raw_alloc_io_data(&io, (void __user *)value, true);
938 return PTR_ERR(data);
939 ret = raw_process_ep_io(dev, &io, data, true);
944 static int raw_ioctl_ep_read(struct raw_dev *dev, unsigned long value)
948 struct usb_raw_ep_io io;
951 data = raw_alloc_io_data(&io, (void __user *)value, false);
953 return PTR_ERR(data);
954 ret = raw_process_ep_io(dev, &io, data, false);
959 length = min(io.length, (unsigned int)ret);
960 ret = copy_to_user((void __user *)(value + sizeof(io)), data, length);
965 static int raw_ioctl_configure(struct raw_dev *dev, unsigned long value)
972 spin_lock_irqsave(&dev->lock, flags);
973 if (dev->state != STATE_DEV_RUNNING) {
974 dev_dbg(dev->dev, "fail, device is not running\n");
979 dev_dbg(dev->dev, "fail, gadget is not bound\n");
983 usb_gadget_set_state(dev->gadget, USB_STATE_CONFIGURED);
986 spin_unlock_irqrestore(&dev->lock, flags);
990 static int raw_ioctl_vbus_draw(struct raw_dev *dev, unsigned long value)
995 spin_lock_irqsave(&dev->lock, flags);
996 if (dev->state != STATE_DEV_RUNNING) {
997 dev_dbg(dev->dev, "fail, device is not running\n");
1002 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1006 usb_gadget_vbus_draw(dev->gadget, 2 * value);
1009 spin_unlock_irqrestore(&dev->lock, flags);
1013 static long raw_ioctl(struct file *fd, unsigned int cmd, unsigned long value)
1015 struct raw_dev *dev = fd->private_data;
1022 case USB_RAW_IOCTL_INIT:
1023 ret = raw_ioctl_init(dev, value);
1025 case USB_RAW_IOCTL_RUN:
1026 ret = raw_ioctl_run(dev, value);
1028 case USB_RAW_IOCTL_EVENT_FETCH:
1029 ret = raw_ioctl_event_fetch(dev, value);
1031 case USB_RAW_IOCTL_EP0_WRITE:
1032 ret = raw_ioctl_ep0_write(dev, value);
1034 case USB_RAW_IOCTL_EP0_READ:
1035 ret = raw_ioctl_ep0_read(dev, value);
1037 case USB_RAW_IOCTL_EP_ENABLE:
1038 ret = raw_ioctl_ep_enable(dev, value);
1040 case USB_RAW_IOCTL_EP_DISABLE:
1041 ret = raw_ioctl_ep_disable(dev, value);
1043 case USB_RAW_IOCTL_EP_WRITE:
1044 ret = raw_ioctl_ep_write(dev, value);
1046 case USB_RAW_IOCTL_EP_READ:
1047 ret = raw_ioctl_ep_read(dev, value);
1049 case USB_RAW_IOCTL_CONFIGURE:
1050 ret = raw_ioctl_configure(dev, value);
1052 case USB_RAW_IOCTL_VBUS_DRAW:
1053 ret = raw_ioctl_vbus_draw(dev, value);
1062 /*----------------------------------------------------------------------*/
1064 static const struct file_operations raw_fops = {
1066 .unlocked_ioctl = raw_ioctl,
1067 .compat_ioctl = raw_ioctl,
1068 .release = raw_release,
1069 .llseek = no_llseek,
1072 static struct miscdevice raw_misc_device = {
1073 .minor = MISC_DYNAMIC_MINOR,
1074 .name = DRIVER_NAME,
1078 module_misc_device(raw_misc_device);