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)
86 struct usb_raw_event *event;
89 * This function can be called concurrently. We first check that
90 * there's at least one event queued by decrementing the semaphore,
91 * and then take the lock to protect queue struct fields.
93 ret = down_interruptible(&queue->sema);
96 spin_lock_irqsave(&queue->lock, flags);
98 * queue->size must have the same value as queue->sema counter (before
99 * the down_interruptible() call above), so this check is a fail-safe.
101 if (WARN_ON(!queue->size)) {
102 spin_unlock_irqrestore(&queue->lock, flags);
103 return ERR_PTR(-ENODEV);
105 event = queue->events[0];
107 memmove(&queue->events[0], &queue->events[1],
108 queue->size * sizeof(queue->events[0]));
109 spin_unlock_irqrestore(&queue->lock, flags);
113 static void raw_event_queue_destroy(struct raw_event_queue *queue)
117 for (i = 0; i < queue->size; i++)
118 kfree(queue->events[i]);
122 /*----------------------------------------------------------------------*/
126 #define USB_RAW_MAX_ENDPOINTS 32
137 struct usb_request *req;
144 STATE_DEV_INVALID = 0,
146 STATE_DEV_INITIALIZED,
156 const char *udc_name;
157 struct usb_gadget_driver driver;
159 /* Reference to misc device: */
162 /* Protected by lock: */
163 enum dev_state state;
164 bool gadget_registered;
165 struct usb_gadget *gadget;
166 struct usb_request *req;
168 bool ep0_out_pending;
171 struct raw_ep eps[USB_RAW_MAX_ENDPOINTS];
173 struct completion ep0_done;
174 struct raw_event_queue queue;
177 static struct raw_dev *dev_new(void)
181 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
184 /* Matches kref_put() in raw_release(). */
185 kref_init(&dev->count);
186 spin_lock_init(&dev->lock);
187 init_completion(&dev->ep0_done);
188 raw_event_queue_init(&dev->queue);
192 static void dev_free(struct kref *kref)
194 struct raw_dev *dev = container_of(kref, struct raw_dev, count);
197 kfree(dev->udc_name);
198 kfree(dev->driver.udc_name);
200 if (dev->ep0_urb_queued)
201 usb_ep_dequeue(dev->gadget->ep0, dev->req);
202 usb_ep_free_request(dev->gadget->ep0, dev->req);
204 raw_event_queue_destroy(&dev->queue);
205 for (i = 0; i < USB_RAW_MAX_ENDPOINTS; i++) {
206 if (dev->eps[i].state != STATE_EP_ENABLED)
208 usb_ep_disable(dev->eps[i].ep);
209 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
210 kfree(dev->eps[i].ep->desc);
211 dev->eps[i].state = STATE_EP_DISABLED;
216 /*----------------------------------------------------------------------*/
218 static int raw_queue_event(struct raw_dev *dev,
219 enum usb_raw_event_type type, size_t length, const void *data)
224 ret = raw_event_queue_add(&dev->queue, type, length, data);
226 spin_lock_irqsave(&dev->lock, flags);
227 dev->state = STATE_DEV_FAILED;
228 spin_unlock_irqrestore(&dev->lock, flags);
233 static void gadget_ep0_complete(struct usb_ep *ep, struct usb_request *req)
235 struct raw_dev *dev = req->context;
238 spin_lock_irqsave(&dev->lock, flags);
240 dev->ep0_status = req->status;
242 dev->ep0_status = req->actual;
243 if (dev->ep0_in_pending)
244 dev->ep0_in_pending = false;
246 dev->ep0_out_pending = false;
247 spin_unlock_irqrestore(&dev->lock, flags);
249 complete(&dev->ep0_done);
252 static int gadget_bind(struct usb_gadget *gadget,
253 struct usb_gadget_driver *driver)
256 struct raw_dev *dev = container_of(driver, struct raw_dev, driver);
257 struct usb_request *req;
260 if (strcmp(gadget->name, dev->udc_name) != 0)
263 set_gadget_data(gadget, dev);
264 req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
266 dev_err(&gadget->dev, "usb_ep_alloc_request failed\n");
267 set_gadget_data(gadget, NULL);
271 spin_lock_irqsave(&dev->lock, flags);
273 dev->req->context = dev;
274 dev->req->complete = gadget_ep0_complete;
275 dev->gadget = gadget;
276 spin_unlock_irqrestore(&dev->lock, flags);
278 /* Matches kref_put() in gadget_unbind(). */
279 kref_get(&dev->count);
281 ret = raw_queue_event(dev, USB_RAW_EVENT_CONNECT, 0, NULL);
283 dev_err(&gadget->dev, "failed to queue event\n");
288 static void gadget_unbind(struct usb_gadget *gadget)
290 struct raw_dev *dev = get_gadget_data(gadget);
292 set_gadget_data(gadget, NULL);
293 /* Matches kref_get() in gadget_bind(). */
294 kref_put(&dev->count, dev_free);
297 static int gadget_setup(struct usb_gadget *gadget,
298 const struct usb_ctrlrequest *ctrl)
301 struct raw_dev *dev = get_gadget_data(gadget);
304 spin_lock_irqsave(&dev->lock, flags);
305 if (dev->state != STATE_DEV_RUNNING) {
306 dev_err(&gadget->dev, "ignoring, device is not running\n");
310 if (dev->ep0_in_pending || dev->ep0_out_pending) {
311 dev_dbg(&gadget->dev, "stalling, request already pending\n");
315 if ((ctrl->bRequestType & USB_DIR_IN) && ctrl->wLength)
316 dev->ep0_in_pending = true;
318 dev->ep0_out_pending = true;
319 spin_unlock_irqrestore(&dev->lock, flags);
321 ret = raw_queue_event(dev, USB_RAW_EVENT_CONTROL, sizeof(*ctrl), ctrl);
323 dev_err(&gadget->dev, "failed to queue event\n");
327 spin_unlock_irqrestore(&dev->lock, flags);
332 /* These are currently unused but present in case UDC driver requires them. */
333 static void gadget_disconnect(struct usb_gadget *gadget) { }
334 static void gadget_suspend(struct usb_gadget *gadget) { }
335 static void gadget_resume(struct usb_gadget *gadget) { }
336 static void gadget_reset(struct usb_gadget *gadget) { }
338 /*----------------------------------------------------------------------*/
340 static struct miscdevice raw_misc_device;
342 static int raw_open(struct inode *inode, struct file *fd)
346 /* Nonblocking I/O is not supported yet. */
347 if (fd->f_flags & O_NONBLOCK)
353 fd->private_data = dev;
354 dev->state = STATE_DEV_OPENED;
355 dev->dev = raw_misc_device.this_device;
359 static int raw_release(struct inode *inode, struct file *fd)
362 struct raw_dev *dev = fd->private_data;
364 bool unregister = false;
366 spin_lock_irqsave(&dev->lock, flags);
367 dev->state = STATE_DEV_CLOSED;
369 spin_unlock_irqrestore(&dev->lock, flags);
372 if (dev->gadget_registered)
374 dev->gadget_registered = false;
375 spin_unlock_irqrestore(&dev->lock, flags);
378 ret = usb_gadget_unregister_driver(&dev->driver);
381 "usb_gadget_unregister_driver() failed with %d\n",
383 /* Matches kref_get() in raw_ioctl_run(). */
384 kref_put(&dev->count, dev_free);
388 /* Matches dev_new() in raw_open(). */
389 kref_put(&dev->count, dev_free);
393 /*----------------------------------------------------------------------*/
395 static int raw_ioctl_init(struct raw_dev *dev, unsigned long value)
398 struct usb_raw_init arg;
399 char *udc_driver_name;
400 char *udc_device_name;
403 if (copy_from_user(&arg, (void __user *)value, sizeof(arg)))
407 case USB_SPEED_UNKNOWN:
408 arg.speed = USB_SPEED_HIGH;
413 case USB_SPEED_SUPER:
419 udc_driver_name = kmalloc(UDC_NAME_LENGTH_MAX, GFP_KERNEL);
420 if (!udc_driver_name)
422 ret = strscpy(udc_driver_name, &arg.driver_name[0],
423 UDC_NAME_LENGTH_MAX);
425 kfree(udc_driver_name);
430 udc_device_name = kmalloc(UDC_NAME_LENGTH_MAX, GFP_KERNEL);
431 if (!udc_device_name) {
432 kfree(udc_driver_name);
435 ret = strscpy(udc_device_name, &arg.device_name[0],
436 UDC_NAME_LENGTH_MAX);
438 kfree(udc_driver_name);
439 kfree(udc_device_name);
444 spin_lock_irqsave(&dev->lock, flags);
445 if (dev->state != STATE_DEV_OPENED) {
446 dev_dbg(dev->dev, "fail, device is not opened\n");
447 kfree(udc_driver_name);
448 kfree(udc_device_name);
452 dev->udc_name = udc_driver_name;
454 dev->driver.function = DRIVER_DESC;
455 dev->driver.max_speed = arg.speed;
456 dev->driver.setup = gadget_setup;
457 dev->driver.disconnect = gadget_disconnect;
458 dev->driver.bind = gadget_bind;
459 dev->driver.unbind = gadget_unbind;
460 dev->driver.suspend = gadget_suspend;
461 dev->driver.resume = gadget_resume;
462 dev->driver.reset = gadget_reset;
463 dev->driver.driver.name = DRIVER_NAME;
464 dev->driver.udc_name = udc_device_name;
465 dev->driver.match_existing_only = 1;
467 dev->state = STATE_DEV_INITIALIZED;
470 spin_unlock_irqrestore(&dev->lock, flags);
474 static int raw_ioctl_run(struct raw_dev *dev, unsigned long value)
482 spin_lock_irqsave(&dev->lock, flags);
483 if (dev->state != STATE_DEV_INITIALIZED) {
484 dev_dbg(dev->dev, "fail, device is not initialized\n");
488 spin_unlock_irqrestore(&dev->lock, flags);
490 ret = usb_gadget_probe_driver(&dev->driver);
492 spin_lock_irqsave(&dev->lock, flags);
495 "fail, usb_gadget_probe_driver returned %d\n", ret);
496 dev->state = STATE_DEV_FAILED;
499 dev->gadget_registered = true;
500 dev->state = STATE_DEV_RUNNING;
501 /* Matches kref_put() in raw_release(). */
502 kref_get(&dev->count);
505 spin_unlock_irqrestore(&dev->lock, flags);
509 static int raw_ioctl_event_fetch(struct raw_dev *dev, unsigned long value)
511 struct usb_raw_event arg;
513 struct usb_raw_event *event;
516 if (copy_from_user(&arg, (void __user *)value, sizeof(arg)))
519 spin_lock_irqsave(&dev->lock, flags);
520 if (dev->state != STATE_DEV_RUNNING) {
521 dev_dbg(dev->dev, "fail, device is not running\n");
522 spin_unlock_irqrestore(&dev->lock, flags);
526 dev_dbg(dev->dev, "fail, gadget is not bound\n");
527 spin_unlock_irqrestore(&dev->lock, flags);
530 spin_unlock_irqrestore(&dev->lock, flags);
532 event = raw_event_queue_fetch(&dev->queue);
533 if (PTR_ERR(event) == -EINTR) {
534 dev_dbg(&dev->gadget->dev, "event fetching interrupted\n");
538 dev_err(&dev->gadget->dev, "failed to fetch event\n");
539 spin_lock_irqsave(&dev->lock, flags);
540 dev->state = STATE_DEV_FAILED;
541 spin_unlock_irqrestore(&dev->lock, flags);
544 length = min(arg.length, event->length);
545 if (copy_to_user((void __user *)value, event, sizeof(*event) + length))
551 static void *raw_alloc_io_data(struct usb_raw_ep_io *io, void __user *ptr,
556 if (copy_from_user(io, ptr, sizeof(*io)))
557 return ERR_PTR(-EFAULT);
558 if (io->ep >= USB_RAW_MAX_ENDPOINTS)
559 return ERR_PTR(-EINVAL);
560 if (!usb_raw_io_flags_valid(io->flags))
561 return ERR_PTR(-EINVAL);
562 if (io->length > PAGE_SIZE)
563 return ERR_PTR(-EINVAL);
565 data = memdup_user(ptr + sizeof(*io), io->length);
567 data = kmalloc(io->length, GFP_KERNEL);
569 data = ERR_PTR(-ENOMEM);
574 static int raw_process_ep0_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
580 spin_lock_irqsave(&dev->lock, flags);
581 if (dev->state != STATE_DEV_RUNNING) {
582 dev_dbg(dev->dev, "fail, device is not running\n");
587 dev_dbg(dev->dev, "fail, gadget is not bound\n");
591 if (dev->ep0_urb_queued) {
592 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
596 if ((in && !dev->ep0_in_pending) ||
597 (!in && !dev->ep0_out_pending)) {
598 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
602 if (WARN_ON(in && dev->ep0_out_pending)) {
604 dev->state = STATE_DEV_FAILED;
607 if (WARN_ON(!in && dev->ep0_in_pending)) {
609 dev->state = STATE_DEV_FAILED;
613 dev->req->buf = data;
614 dev->req->length = io->length;
615 dev->req->zero = usb_raw_io_flags_zero(io->flags);
616 dev->ep0_urb_queued = true;
617 spin_unlock_irqrestore(&dev->lock, flags);
619 ret = usb_ep_queue(dev->gadget->ep0, dev->req, GFP_KERNEL);
621 dev_err(&dev->gadget->dev,
622 "fail, usb_ep_queue returned %d\n", ret);
623 spin_lock_irqsave(&dev->lock, flags);
624 dev->state = STATE_DEV_FAILED;
628 ret = wait_for_completion_interruptible(&dev->ep0_done);
630 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
631 usb_ep_dequeue(dev->gadget->ep0, dev->req);
632 wait_for_completion(&dev->ep0_done);
633 spin_lock_irqsave(&dev->lock, flags);
637 spin_lock_irqsave(&dev->lock, flags);
638 ret = dev->ep0_status;
641 dev->ep0_urb_queued = false;
643 spin_unlock_irqrestore(&dev->lock, flags);
647 static int raw_ioctl_ep0_write(struct raw_dev *dev, unsigned long value)
651 struct usb_raw_ep_io io;
653 data = raw_alloc_io_data(&io, (void __user *)value, true);
655 return PTR_ERR(data);
656 ret = raw_process_ep0_io(dev, &io, data, true);
661 static int raw_ioctl_ep0_read(struct raw_dev *dev, unsigned long value)
665 struct usb_raw_ep_io io;
668 data = raw_alloc_io_data(&io, (void __user *)value, false);
670 return PTR_ERR(data);
671 ret = raw_process_ep0_io(dev, &io, data, false);
675 length = min(io.length, (unsigned int)ret);
676 if (copy_to_user((void __user *)(value + sizeof(io)), data, length))
685 static bool check_ep_caps(struct usb_ep *ep,
686 struct usb_endpoint_descriptor *desc)
688 switch (usb_endpoint_type(desc)) {
689 case USB_ENDPOINT_XFER_ISOC:
690 if (!ep->caps.type_iso)
693 case USB_ENDPOINT_XFER_BULK:
694 if (!ep->caps.type_bulk)
697 case USB_ENDPOINT_XFER_INT:
698 if (!ep->caps.type_int)
705 if (usb_endpoint_dir_in(desc) && !ep->caps.dir_in)
707 if (usb_endpoint_dir_out(desc) && !ep->caps.dir_out)
713 static int raw_ioctl_ep_enable(struct raw_dev *dev, unsigned long value)
717 struct usb_endpoint_descriptor *desc;
718 struct usb_ep *ep = NULL;
720 desc = memdup_user((void __user *)value, sizeof(*desc));
722 return PTR_ERR(desc);
725 * Endpoints with a maxpacket length of 0 can cause crashes in UDC
728 if (usb_endpoint_maxp(desc) == 0) {
729 dev_dbg(dev->dev, "fail, bad endpoint maxpacket\n");
734 spin_lock_irqsave(&dev->lock, flags);
735 if (dev->state != STATE_DEV_RUNNING) {
736 dev_dbg(dev->dev, "fail, device is not running\n");
741 dev_dbg(dev->dev, "fail, gadget is not bound\n");
746 for (i = 0; i < USB_RAW_MAX_ENDPOINTS; i++) {
747 if (dev->eps[i].state == STATE_EP_ENABLED)
751 if (i == USB_RAW_MAX_ENDPOINTS) {
752 dev_dbg(&dev->gadget->dev,
753 "fail, no device endpoints available\n");
758 gadget_for_each_ep(ep, dev->gadget) {
761 if (!check_ep_caps(ep, desc))
764 ret = usb_ep_enable(ep);
766 dev_err(&dev->gadget->dev,
767 "fail, usb_ep_enable returned %d\n", ret);
770 dev->eps[i].req = usb_ep_alloc_request(ep, GFP_ATOMIC);
771 if (!dev->eps[i].req) {
772 dev_err(&dev->gadget->dev,
773 "fail, usb_ep_alloc_request failed\n");
779 dev->eps[i].state = STATE_EP_ENABLED;
780 ep->driver_data = &dev->eps[i];
785 dev_dbg(&dev->gadget->dev, "fail, no gadget endpoints available\n");
791 spin_unlock_irqrestore(&dev->lock, flags);
795 static int raw_ioctl_ep_disable(struct raw_dev *dev, unsigned long value)
797 int ret = 0, i = value;
801 if (i < 0 || i >= USB_RAW_MAX_ENDPOINTS)
804 spin_lock_irqsave(&dev->lock, flags);
805 if (dev->state != STATE_DEV_RUNNING) {
806 dev_dbg(dev->dev, "fail, device is not running\n");
811 dev_dbg(dev->dev, "fail, gadget is not bound\n");
815 if (dev->eps[i].state != STATE_EP_ENABLED) {
816 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
820 if (dev->eps[i].disabling) {
821 dev_dbg(&dev->gadget->dev,
822 "fail, disable already in progress\n");
826 if (dev->eps[i].urb_queued) {
827 dev_dbg(&dev->gadget->dev,
828 "fail, waiting for urb completion\n");
832 dev->eps[i].disabling = true;
833 spin_unlock_irqrestore(&dev->lock, flags);
835 usb_ep_disable(dev->eps[i].ep);
837 spin_lock_irqsave(&dev->lock, flags);
838 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
839 desc = dev->eps[i].ep->desc;
840 dev->eps[i].ep = NULL;
841 dev->eps[i].state = STATE_EP_DISABLED;
843 dev->eps[i].disabling = false;
846 spin_unlock_irqrestore(&dev->lock, flags);
850 static void gadget_ep_complete(struct usb_ep *ep, struct usb_request *req)
852 struct raw_ep *r_ep = (struct raw_ep *)ep->driver_data;
853 struct raw_dev *dev = r_ep->dev;
856 spin_lock_irqsave(&dev->lock, flags);
858 r_ep->status = req->status;
860 r_ep->status = req->actual;
861 spin_unlock_irqrestore(&dev->lock, flags);
863 complete((struct completion *)req->context);
866 static int raw_process_ep_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
871 struct raw_ep *ep = &dev->eps[io->ep];
872 DECLARE_COMPLETION_ONSTACK(done);
874 spin_lock_irqsave(&dev->lock, flags);
875 if (dev->state != STATE_DEV_RUNNING) {
876 dev_dbg(dev->dev, "fail, device is not running\n");
881 dev_dbg(dev->dev, "fail, gadget is not bound\n");
885 if (ep->state != STATE_EP_ENABLED) {
886 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
891 dev_dbg(&dev->gadget->dev,
892 "fail, endpoint is already being disabled\n");
896 if (ep->urb_queued) {
897 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
901 if ((in && !ep->ep->caps.dir_in) || (!in && ep->ep->caps.dir_in)) {
902 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
908 ep->req->context = &done;
909 ep->req->complete = gadget_ep_complete;
911 ep->req->length = io->length;
912 ep->req->zero = usb_raw_io_flags_zero(io->flags);
913 ep->urb_queued = true;
914 spin_unlock_irqrestore(&dev->lock, flags);
916 ret = usb_ep_queue(ep->ep, ep->req, GFP_KERNEL);
918 dev_err(&dev->gadget->dev,
919 "fail, usb_ep_queue returned %d\n", ret);
920 spin_lock_irqsave(&dev->lock, flags);
921 dev->state = STATE_DEV_FAILED;
925 ret = wait_for_completion_interruptible(&done);
927 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
928 usb_ep_dequeue(ep->ep, ep->req);
929 wait_for_completion(&done);
930 spin_lock_irqsave(&dev->lock, flags);
934 spin_lock_irqsave(&dev->lock, flags);
938 ep->urb_queued = false;
940 spin_unlock_irqrestore(&dev->lock, flags);
944 static int raw_ioctl_ep_write(struct raw_dev *dev, unsigned long value)
948 struct usb_raw_ep_io io;
950 data = raw_alloc_io_data(&io, (void __user *)value, true);
952 return PTR_ERR(data);
953 ret = raw_process_ep_io(dev, &io, data, true);
958 static int raw_ioctl_ep_read(struct raw_dev *dev, unsigned long value)
962 struct usb_raw_ep_io io;
965 data = raw_alloc_io_data(&io, (void __user *)value, false);
967 return PTR_ERR(data);
968 ret = raw_process_ep_io(dev, &io, data, false);
972 length = min(io.length, (unsigned int)ret);
973 if (copy_to_user((void __user *)(value + sizeof(io)), data, length))
982 static int raw_ioctl_configure(struct raw_dev *dev, unsigned long value)
989 spin_lock_irqsave(&dev->lock, flags);
990 if (dev->state != STATE_DEV_RUNNING) {
991 dev_dbg(dev->dev, "fail, device is not running\n");
996 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1000 usb_gadget_set_state(dev->gadget, USB_STATE_CONFIGURED);
1003 spin_unlock_irqrestore(&dev->lock, flags);
1007 static int raw_ioctl_vbus_draw(struct raw_dev *dev, unsigned long value)
1010 unsigned long flags;
1012 spin_lock_irqsave(&dev->lock, flags);
1013 if (dev->state != STATE_DEV_RUNNING) {
1014 dev_dbg(dev->dev, "fail, device is not running\n");
1019 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1023 usb_gadget_vbus_draw(dev->gadget, 2 * value);
1026 spin_unlock_irqrestore(&dev->lock, flags);
1030 static long raw_ioctl(struct file *fd, unsigned int cmd, unsigned long value)
1032 struct raw_dev *dev = fd->private_data;
1039 case USB_RAW_IOCTL_INIT:
1040 ret = raw_ioctl_init(dev, value);
1042 case USB_RAW_IOCTL_RUN:
1043 ret = raw_ioctl_run(dev, value);
1045 case USB_RAW_IOCTL_EVENT_FETCH:
1046 ret = raw_ioctl_event_fetch(dev, value);
1048 case USB_RAW_IOCTL_EP0_WRITE:
1049 ret = raw_ioctl_ep0_write(dev, value);
1051 case USB_RAW_IOCTL_EP0_READ:
1052 ret = raw_ioctl_ep0_read(dev, value);
1054 case USB_RAW_IOCTL_EP_ENABLE:
1055 ret = raw_ioctl_ep_enable(dev, value);
1057 case USB_RAW_IOCTL_EP_DISABLE:
1058 ret = raw_ioctl_ep_disable(dev, value);
1060 case USB_RAW_IOCTL_EP_WRITE:
1061 ret = raw_ioctl_ep_write(dev, value);
1063 case USB_RAW_IOCTL_EP_READ:
1064 ret = raw_ioctl_ep_read(dev, value);
1066 case USB_RAW_IOCTL_CONFIGURE:
1067 ret = raw_ioctl_configure(dev, value);
1069 case USB_RAW_IOCTL_VBUS_DRAW:
1070 ret = raw_ioctl_vbus_draw(dev, value);
1079 /*----------------------------------------------------------------------*/
1081 static const struct file_operations raw_fops = {
1083 .unlocked_ioctl = raw_ioctl,
1084 .compat_ioctl = raw_ioctl,
1085 .release = raw_release,
1086 .llseek = no_llseek,
1089 static struct miscdevice raw_misc_device = {
1090 .minor = MISC_DYNAMIC_MINOR,
1091 .name = DRIVER_NAME,
1095 module_misc_device(raw_misc_device);