Lines Matching refs:dev
137 struct raw_dev *dev;
165 struct device *dev;
188 struct raw_dev *dev;
190 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
191 if (!dev)
194 kref_init(&dev->count);
195 spin_lock_init(&dev->lock);
196 init_completion(&dev->ep0_done);
197 raw_event_queue_init(&dev->queue);
198 dev->driver_id_number = -1;
199 return dev;
204 struct raw_dev *dev = container_of(kref, struct raw_dev, count);
207 kfree(dev->udc_name);
208 kfree(dev->driver.udc_name);
209 kfree(dev->driver.driver.name);
210 if (dev->driver_id_number >= 0)
211 ida_free(&driver_id_numbers, dev->driver_id_number);
212 if (dev->req) {
213 if (dev->ep0_urb_queued)
214 usb_ep_dequeue(dev->gadget->ep0, dev->req);
215 usb_ep_free_request(dev->gadget->ep0, dev->req);
217 raw_event_queue_destroy(&dev->queue);
218 for (i = 0; i < dev->eps_num; i++) {
219 if (dev->eps[i].state == STATE_EP_DISABLED)
221 usb_ep_disable(dev->eps[i].ep);
222 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
223 kfree(dev->eps[i].ep->desc);
224 dev->eps[i].state = STATE_EP_DISABLED;
226 kfree(dev);
231 static int raw_queue_event(struct raw_dev *dev,
237 ret = raw_event_queue_add(&dev->queue, type, length, data);
239 spin_lock_irqsave(&dev->lock, flags);
240 dev->state = STATE_DEV_FAILED;
241 spin_unlock_irqrestore(&dev->lock, flags);
248 struct raw_dev *dev = req->context;
251 spin_lock_irqsave(&dev->lock, flags);
253 dev->ep0_status = req->status;
255 dev->ep0_status = req->actual;
256 if (dev->ep0_in_pending)
257 dev->ep0_in_pending = false;
259 dev->ep0_out_pending = false;
260 spin_unlock_irqrestore(&dev->lock, flags);
262 complete(&dev->ep0_done);
282 struct raw_dev *dev = container_of(driver, struct raw_dev, driver);
287 if (strcmp(gadget->name, dev->udc_name) != 0)
290 set_gadget_data(gadget, dev);
293 dev_err(&gadget->dev, "usb_ep_alloc_request failed\n");
298 spin_lock_irqsave(&dev->lock, flags);
299 dev->req = req;
300 dev->req->context = dev;
301 dev->req->complete = gadget_ep0_complete;
302 dev->gadget = gadget;
303 gadget_for_each_ep(ep, dev->gadget) {
304 dev->eps[i].ep = ep;
305 dev->eps[i].addr = get_ep_addr(ep->name);
306 dev->eps[i].state = STATE_EP_DISABLED;
309 dev->eps_num = i;
310 spin_unlock_irqrestore(&dev->lock, flags);
312 ret = raw_queue_event(dev, USB_RAW_EVENT_CONNECT, 0, NULL);
314 dev_err(&gadget->dev, "failed to queue event\n");
320 kref_get(&dev->count);
326 struct raw_dev *dev = get_gadget_data(gadget);
330 kref_put(&dev->count, dev_free);
337 struct raw_dev *dev = get_gadget_data(gadget);
340 spin_lock_irqsave(&dev->lock, flags);
341 if (dev->state != STATE_DEV_RUNNING) {
342 dev_err(&gadget->dev, "ignoring, device is not running\n");
346 if (dev->ep0_in_pending || dev->ep0_out_pending) {
347 dev_dbg(&gadget->dev, "stalling, request already pending\n");
352 dev->ep0_in_pending = true;
354 dev->ep0_out_pending = true;
355 spin_unlock_irqrestore(&dev->lock, flags);
357 ret = raw_queue_event(dev, USB_RAW_EVENT_CONTROL, sizeof(*ctrl), ctrl);
359 dev_err(&gadget->dev, "failed to queue event\n");
363 spin_unlock_irqrestore(&dev->lock, flags);
380 struct raw_dev *dev;
386 dev = dev_new();
387 if (!dev)
389 fd->private_data = dev;
390 dev->state = STATE_DEV_OPENED;
391 dev->dev = raw_misc_device.this_device;
398 struct raw_dev *dev = fd->private_data;
402 spin_lock_irqsave(&dev->lock, flags);
403 dev->state = STATE_DEV_CLOSED;
404 if (!dev->gadget) {
405 spin_unlock_irqrestore(&dev->lock, flags);
408 if (dev->gadget_registered)
410 dev->gadget_registered = false;
411 spin_unlock_irqrestore(&dev->lock, flags);
414 ret = usb_gadget_unregister_driver(&dev->driver);
416 dev_err(dev->dev,
420 kref_put(&dev->count, dev_free);
425 kref_put(&dev->count, dev_free);
431 static int raw_ioctl_init(struct raw_dev *dev, unsigned long value)
491 spin_lock_irqsave(&dev->lock, flags);
492 if (dev->state != STATE_DEV_OPENED) {
493 dev_dbg(dev->dev, "fail, device is not opened\n");
497 dev->udc_name = udc_driver_name;
499 dev->driver.function = DRIVER_DESC;
500 dev->driver.max_speed = arg.speed;
501 dev->driver.setup = gadget_setup;
502 dev->driver.disconnect = gadget_disconnect;
503 dev->driver.bind = gadget_bind;
504 dev->driver.unbind = gadget_unbind;
505 dev->driver.suspend = gadget_suspend;
506 dev->driver.resume = gadget_resume;
507 dev->driver.reset = gadget_reset;
508 dev->driver.driver.name = driver_driver_name;
509 dev->driver.udc_name = udc_device_name;
510 dev->driver.match_existing_only = 1;
511 dev->driver_id_number = driver_id_number;
513 dev->state = STATE_DEV_INITIALIZED;
514 spin_unlock_irqrestore(&dev->lock, flags);
518 spin_unlock_irqrestore(&dev->lock, flags);
530 static int raw_ioctl_run(struct raw_dev *dev, unsigned long value)
538 spin_lock_irqsave(&dev->lock, flags);
539 if (dev->state != STATE_DEV_INITIALIZED) {
540 dev_dbg(dev->dev, "fail, device is not initialized\n");
544 dev->state = STATE_DEV_REGISTERING;
545 spin_unlock_irqrestore(&dev->lock, flags);
547 ret = usb_gadget_probe_driver(&dev->driver);
549 spin_lock_irqsave(&dev->lock, flags);
551 dev_err(dev->dev,
553 dev->state = STATE_DEV_FAILED;
556 dev->gadget_registered = true;
557 dev->state = STATE_DEV_RUNNING;
559 kref_get(&dev->count);
562 spin_unlock_irqrestore(&dev->lock, flags);
566 static int raw_ioctl_event_fetch(struct raw_dev *dev, unsigned long value)
576 spin_lock_irqsave(&dev->lock, flags);
577 if (dev->state != STATE_DEV_RUNNING) {
578 dev_dbg(dev->dev, "fail, device is not running\n");
579 spin_unlock_irqrestore(&dev->lock, flags);
582 if (!dev->gadget) {
583 dev_dbg(dev->dev, "fail, gadget is not bound\n");
584 spin_unlock_irqrestore(&dev->lock, flags);
587 spin_unlock_irqrestore(&dev->lock, flags);
589 event = raw_event_queue_fetch(&dev->queue);
591 dev_dbg(&dev->gadget->dev, "event fetching interrupted\n");
595 dev_err(&dev->gadget->dev, "failed to fetch event\n");
596 spin_lock_irqsave(&dev->lock, flags);
597 dev->state = STATE_DEV_FAILED;
598 spin_unlock_irqrestore(&dev->lock, flags);
634 static int raw_process_ep0_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
640 spin_lock_irqsave(&dev->lock, flags);
641 if (dev->state != STATE_DEV_RUNNING) {
642 dev_dbg(dev->dev, "fail, device is not running\n");
646 if (!dev->gadget) {
647 dev_dbg(dev->dev, "fail, gadget is not bound\n");
651 if (dev->ep0_urb_queued) {
652 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
656 if ((in && !dev->ep0_in_pending) ||
657 (!in && !dev->ep0_out_pending)) {
658 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
662 if (WARN_ON(in && dev->ep0_out_pending)) {
664 dev->state = STATE_DEV_FAILED;
667 if (WARN_ON(!in && dev->ep0_in_pending)) {
669 dev->state = STATE_DEV_FAILED;
673 dev->req->buf = data;
674 dev->req->length = io->length;
675 dev->req->zero = usb_raw_io_flags_zero(io->flags);
676 dev->ep0_urb_queued = true;
677 spin_unlock_irqrestore(&dev->lock, flags);
679 ret = usb_ep_queue(dev->gadget->ep0, dev->req, GFP_KERNEL);
681 dev_err(&dev->gadget->dev,
683 spin_lock_irqsave(&dev->lock, flags);
684 dev->state = STATE_DEV_FAILED;
688 ret = wait_for_completion_interruptible(&dev->ep0_done);
690 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
691 usb_ep_dequeue(dev->gadget->ep0, dev->req);
692 wait_for_completion(&dev->ep0_done);
693 spin_lock_irqsave(&dev->lock, flags);
694 if (dev->ep0_status == -ECONNRESET)
695 dev->ep0_status = -EINTR;
699 spin_lock_irqsave(&dev->lock, flags);
702 ret = dev->ep0_status;
704 dev->ep0_urb_queued = false;
706 spin_unlock_irqrestore(&dev->lock, flags);
710 static int raw_ioctl_ep0_write(struct raw_dev *dev, unsigned long value)
719 ret = raw_process_ep0_io(dev, &io, data, true);
724 static int raw_ioctl_ep0_read(struct raw_dev *dev, unsigned long value)
734 ret = raw_process_ep0_io(dev, &io, data, false);
748 static int raw_ioctl_ep0_stall(struct raw_dev *dev, unsigned long value)
755 spin_lock_irqsave(&dev->lock, flags);
756 if (dev->state != STATE_DEV_RUNNING) {
757 dev_dbg(dev->dev, "fail, device is not running\n");
761 if (!dev->gadget) {
762 dev_dbg(dev->dev, "fail, gadget is not bound\n");
766 if (dev->ep0_urb_queued) {
767 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
771 if (!dev->ep0_in_pending && !dev->ep0_out_pending) {
772 dev_dbg(&dev->gadget->dev, "fail, no request pending\n");
777 ret = usb_ep_set_halt(dev->gadget->ep0);
779 dev_err(&dev->gadget->dev,
782 if (dev->ep0_in_pending)
783 dev->ep0_in_pending = false;
785 dev->ep0_out_pending = false;
788 spin_unlock_irqrestore(&dev->lock, flags);
792 static int raw_ioctl_ep_enable(struct raw_dev *dev, unsigned long value)
808 dev_dbg(dev->dev, "fail, bad endpoint maxpacket\n");
813 spin_lock_irqsave(&dev->lock, flags);
814 if (dev->state != STATE_DEV_RUNNING) {
815 dev_dbg(dev->dev, "fail, device is not running\n");
819 if (!dev->gadget) {
820 dev_dbg(dev->dev, "fail, gadget is not bound\n");
825 for (i = 0; i < dev->eps_num; i++) {
826 ep = &dev->eps[i];
832 if (!usb_gadget_ep_match_desc(dev->gadget, ep->ep, desc, NULL))
837 dev_err(&dev->gadget->dev,
843 dev_err(&dev->gadget->dev,
855 dev_dbg(&dev->gadget->dev, "fail, no gadget endpoints available\n");
861 spin_unlock_irqrestore(&dev->lock, flags);
865 static int raw_ioctl_ep_disable(struct raw_dev *dev, unsigned long value)
870 spin_lock_irqsave(&dev->lock, flags);
871 if (dev->state != STATE_DEV_RUNNING) {
872 dev_dbg(dev->dev, "fail, device is not running\n");
876 if (!dev->gadget) {
877 dev_dbg(dev->dev, "fail, gadget is not bound\n");
881 if (i < 0 || i >= dev->eps_num) {
882 dev_dbg(dev->dev, "fail, invalid endpoint\n");
886 if (dev->eps[i].state == STATE_EP_DISABLED) {
887 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
891 if (dev->eps[i].disabling) {
892 dev_dbg(&dev->gadget->dev,
897 if (dev->eps[i].urb_queued) {
898 dev_dbg(&dev->gadget->dev,
903 dev->eps[i].disabling = true;
904 spin_unlock_irqrestore(&dev->lock, flags);
906 usb_ep_disable(dev->eps[i].ep);
908 spin_lock_irqsave(&dev->lock, flags);
909 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
910 kfree(dev->eps[i].ep->desc);
911 dev->eps[i].state = STATE_EP_DISABLED;
912 dev->eps[i].disabling = false;
915 spin_unlock_irqrestore(&dev->lock, flags);
919 static int raw_ioctl_ep_set_clear_halt_wedge(struct raw_dev *dev,
925 spin_lock_irqsave(&dev->lock, flags);
926 if (dev->state != STATE_DEV_RUNNING) {
927 dev_dbg(dev->dev, "fail, device is not running\n");
931 if (!dev->gadget) {
932 dev_dbg(dev->dev, "fail, gadget is not bound\n");
936 if (i < 0 || i >= dev->eps_num) {
937 dev_dbg(dev->dev, "fail, invalid endpoint\n");
941 if (dev->eps[i].state == STATE_EP_DISABLED) {
942 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
946 if (dev->eps[i].disabling) {
947 dev_dbg(&dev->gadget->dev,
952 if (dev->eps[i].urb_queued) {
953 dev_dbg(&dev->gadget->dev,
958 if (usb_endpoint_xfer_isoc(dev->eps[i].ep->desc)) {
959 dev_dbg(&dev->gadget->dev,
966 ret = usb_ep_set_halt(dev->eps[i].ep);
968 dev_err(&dev->gadget->dev,
971 ret = usb_ep_clear_halt(dev->eps[i].ep);
973 dev_err(&dev->gadget->dev,
976 ret = usb_ep_set_wedge(dev->eps[i].ep);
978 dev_err(&dev->gadget->dev,
983 spin_unlock_irqrestore(&dev->lock, flags);
990 struct raw_dev *dev = r_ep->dev;
993 spin_lock_irqsave(&dev->lock, flags);
998 spin_unlock_irqrestore(&dev->lock, flags);
1003 static int raw_process_ep_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
1011 spin_lock_irqsave(&dev->lock, flags);
1012 if (dev->state != STATE_DEV_RUNNING) {
1013 dev_dbg(dev->dev, "fail, device is not running\n");
1017 if (!dev->gadget) {
1018 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1022 if (io->ep >= dev->eps_num) {
1023 dev_dbg(&dev->gadget->dev, "fail, invalid endpoint\n");
1027 ep = &dev->eps[io->ep];
1029 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
1034 dev_dbg(&dev->gadget->dev,
1040 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
1045 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
1050 ep->dev = dev;
1057 spin_unlock_irqrestore(&dev->lock, flags);
1061 dev_err(&dev->gadget->dev,
1063 spin_lock_irqsave(&dev->lock, flags);
1064 dev->state = STATE_DEV_FAILED;
1070 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
1073 spin_lock_irqsave(&dev->lock, flags);
1079 spin_lock_irqsave(&dev->lock, flags);
1086 spin_unlock_irqrestore(&dev->lock, flags);
1090 static int raw_ioctl_ep_write(struct raw_dev *dev, unsigned long value)
1099 ret = raw_process_ep_io(dev, &io, data, true);
1104 static int raw_ioctl_ep_read(struct raw_dev *dev, unsigned long value)
1114 ret = raw_process_ep_io(dev, &io, data, false);
1128 static int raw_ioctl_configure(struct raw_dev *dev, unsigned long value)
1135 spin_lock_irqsave(&dev->lock, flags);
1136 if (dev->state != STATE_DEV_RUNNING) {
1137 dev_dbg(dev->dev, "fail, device is not running\n");
1141 if (!dev->gadget) {
1142 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1146 usb_gadget_set_state(dev->gadget, USB_STATE_CONFIGURED);
1149 spin_unlock_irqrestore(&dev->lock, flags);
1153 static int raw_ioctl_vbus_draw(struct raw_dev *dev, unsigned long value)
1158 spin_lock_irqsave(&dev->lock, flags);
1159 if (dev->state != STATE_DEV_RUNNING) {
1160 dev_dbg(dev->dev, "fail, device is not running\n");
1164 if (!dev->gadget) {
1165 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1169 usb_gadget_vbus_draw(dev->gadget, 2 * value);
1172 spin_unlock_irqrestore(&dev->lock, flags);
1193 static int raw_ioctl_eps_info(struct raw_dev *dev, unsigned long value)
1206 spin_lock_irqsave(&dev->lock, flags);
1207 if (dev->state != STATE_DEV_RUNNING) {
1208 dev_dbg(dev->dev, "fail, device is not running\n");
1210 spin_unlock_irqrestore(&dev->lock, flags);
1213 if (!dev->gadget) {
1214 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1216 spin_unlock_irqrestore(&dev->lock, flags);
1221 for (i = 0; i < dev->eps_num; i++) {
1222 ep = &dev->eps[i];
1229 ret = dev->eps_num;
1230 spin_unlock_irqrestore(&dev->lock, flags);
1243 struct raw_dev *dev = fd->private_data;
1246 if (!dev)
1251 ret = raw_ioctl_init(dev, value);
1254 ret = raw_ioctl_run(dev, value);
1257 ret = raw_ioctl_event_fetch(dev, value);
1260 ret = raw_ioctl_ep0_write(dev, value);
1263 ret = raw_ioctl_ep0_read(dev, value);
1266 ret = raw_ioctl_ep_enable(dev, value);
1269 ret = raw_ioctl_ep_disable(dev, value);
1272 ret = raw_ioctl_ep_write(dev, value);
1275 ret = raw_ioctl_ep_read(dev, value);
1278 ret = raw_ioctl_configure(dev, value);
1281 ret = raw_ioctl_vbus_draw(dev, value);
1284 ret = raw_ioctl_eps_info(dev, value);
1287 ret = raw_ioctl_ep0_stall(dev, value);
1291 dev, value, true, true);
1295 dev, value, false, true);
1299 dev, value, true, false);