Lines Matching refs:dev
138 struct raw_dev *dev;
166 struct device *dev;
189 struct raw_dev *dev;
191 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
192 if (!dev)
195 kref_init(&dev->count);
196 spin_lock_init(&dev->lock);
197 init_completion(&dev->ep0_done);
198 raw_event_queue_init(&dev->queue);
199 dev->driver_id_number = -1;
200 return dev;
205 struct raw_dev *dev = container_of(kref, struct raw_dev, count);
208 kfree(dev->udc_name);
209 kfree(dev->driver.udc_name);
210 kfree(dev->driver.driver.name);
211 if (dev->driver_id_number >= 0)
212 ida_free(&driver_id_numbers, dev->driver_id_number);
213 if (dev->req) {
214 if (dev->ep0_urb_queued)
215 usb_ep_dequeue(dev->gadget->ep0, dev->req);
216 usb_ep_free_request(dev->gadget->ep0, dev->req);
218 raw_event_queue_destroy(&dev->queue);
219 for (i = 0; i < dev->eps_num; i++) {
220 if (dev->eps[i].state == STATE_EP_DISABLED)
222 usb_ep_disable(dev->eps[i].ep);
223 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
224 kfree(dev->eps[i].ep->desc);
225 dev->eps[i].state = STATE_EP_DISABLED;
227 kfree(dev);
232 static int raw_queue_event(struct raw_dev *dev,
238 ret = raw_event_queue_add(&dev->queue, type, length, data);
240 spin_lock_irqsave(&dev->lock, flags);
241 dev->state = STATE_DEV_FAILED;
242 spin_unlock_irqrestore(&dev->lock, flags);
249 struct raw_dev *dev = req->context;
252 spin_lock_irqsave(&dev->lock, flags);
254 dev->ep0_status = req->status;
256 dev->ep0_status = req->actual;
257 if (dev->ep0_in_pending)
258 dev->ep0_in_pending = false;
260 dev->ep0_out_pending = false;
261 spin_unlock_irqrestore(&dev->lock, flags);
263 complete(&dev->ep0_done);
283 struct raw_dev *dev = container_of(driver, struct raw_dev, driver);
288 if (strcmp(gadget->name, dev->udc_name) != 0)
291 set_gadget_data(gadget, dev);
294 dev_err(&gadget->dev, "usb_ep_alloc_request failed\n");
299 spin_lock_irqsave(&dev->lock, flags);
300 dev->req = req;
301 dev->req->context = dev;
302 dev->req->complete = gadget_ep0_complete;
303 dev->gadget = gadget;
304 gadget_for_each_ep(ep, dev->gadget) {
305 dev->eps[i].ep = ep;
306 dev->eps[i].addr = get_ep_addr(ep->name);
307 dev->eps[i].state = STATE_EP_DISABLED;
310 dev->eps_num = i;
311 spin_unlock_irqrestore(&dev->lock, flags);
313 ret = raw_queue_event(dev, USB_RAW_EVENT_CONNECT, 0, NULL);
315 dev_err(&gadget->dev, "failed to queue event\n");
321 kref_get(&dev->count);
327 struct raw_dev *dev = get_gadget_data(gadget);
331 kref_put(&dev->count, dev_free);
338 struct raw_dev *dev = get_gadget_data(gadget);
341 spin_lock_irqsave(&dev->lock, flags);
342 if (dev->state != STATE_DEV_RUNNING) {
343 dev_err(&gadget->dev, "ignoring, device is not running\n");
347 if (dev->ep0_in_pending || dev->ep0_out_pending) {
348 dev_dbg(&gadget->dev, "stalling, request already pending\n");
353 dev->ep0_in_pending = true;
355 dev->ep0_out_pending = true;
356 spin_unlock_irqrestore(&dev->lock, flags);
358 ret = raw_queue_event(dev, USB_RAW_EVENT_CONTROL, sizeof(*ctrl), ctrl);
360 dev_err(&gadget->dev, "failed to queue event\n");
364 spin_unlock_irqrestore(&dev->lock, flags);
381 struct raw_dev *dev;
387 dev = dev_new();
388 if (!dev)
390 fd->private_data = dev;
391 dev->state = STATE_DEV_OPENED;
392 dev->dev = raw_misc_device.this_device;
399 struct raw_dev *dev = fd->private_data;
403 spin_lock_irqsave(&dev->lock, flags);
404 dev->state = STATE_DEV_CLOSED;
405 if (!dev->gadget) {
406 spin_unlock_irqrestore(&dev->lock, flags);
409 if (dev->gadget_registered)
411 dev->gadget_registered = false;
412 spin_unlock_irqrestore(&dev->lock, flags);
415 ret = usb_gadget_unregister_driver(&dev->driver);
417 dev_err(dev->dev,
421 kref_put(&dev->count, dev_free);
426 kref_put(&dev->count, dev_free);
432 static int raw_ioctl_init(struct raw_dev *dev, unsigned long value)
492 spin_lock_irqsave(&dev->lock, flags);
493 if (dev->state != STATE_DEV_OPENED) {
494 dev_dbg(dev->dev, "fail, device is not opened\n");
498 dev->udc_name = udc_driver_name;
500 dev->driver.function = DRIVER_DESC;
501 dev->driver.max_speed = arg.speed;
502 dev->driver.setup = gadget_setup;
503 dev->driver.disconnect = gadget_disconnect;
504 dev->driver.bind = gadget_bind;
505 dev->driver.unbind = gadget_unbind;
506 dev->driver.suspend = gadget_suspend;
507 dev->driver.resume = gadget_resume;
508 dev->driver.reset = gadget_reset;
509 dev->driver.driver.name = driver_driver_name;
510 dev->driver.udc_name = udc_device_name;
511 dev->driver.match_existing_only = 1;
512 dev->driver_id_number = driver_id_number;
514 dev->state = STATE_DEV_INITIALIZED;
515 spin_unlock_irqrestore(&dev->lock, flags);
519 spin_unlock_irqrestore(&dev->lock, flags);
531 static int raw_ioctl_run(struct raw_dev *dev, unsigned long value)
539 spin_lock_irqsave(&dev->lock, flags);
540 if (dev->state != STATE_DEV_INITIALIZED) {
541 dev_dbg(dev->dev, "fail, device is not initialized\n");
545 dev->state = STATE_DEV_REGISTERING;
546 spin_unlock_irqrestore(&dev->lock, flags);
548 ret = usb_gadget_register_driver(&dev->driver);
550 spin_lock_irqsave(&dev->lock, flags);
552 dev_err(dev->dev,
554 dev->state = STATE_DEV_FAILED;
557 dev->gadget_registered = true;
558 dev->state = STATE_DEV_RUNNING;
560 kref_get(&dev->count);
563 spin_unlock_irqrestore(&dev->lock, flags);
567 static int raw_ioctl_event_fetch(struct raw_dev *dev, unsigned long value)
577 spin_lock_irqsave(&dev->lock, flags);
578 if (dev->state != STATE_DEV_RUNNING) {
579 dev_dbg(dev->dev, "fail, device is not running\n");
580 spin_unlock_irqrestore(&dev->lock, flags);
583 if (!dev->gadget) {
584 dev_dbg(dev->dev, "fail, gadget is not bound\n");
585 spin_unlock_irqrestore(&dev->lock, flags);
588 spin_unlock_irqrestore(&dev->lock, flags);
590 event = raw_event_queue_fetch(&dev->queue);
592 dev_dbg(&dev->gadget->dev, "event fetching interrupted\n");
596 dev_err(&dev->gadget->dev, "failed to fetch event\n");
597 spin_lock_irqsave(&dev->lock, flags);
598 dev->state = STATE_DEV_FAILED;
599 spin_unlock_irqrestore(&dev->lock, flags);
635 static int raw_process_ep0_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
641 spin_lock_irqsave(&dev->lock, flags);
642 if (dev->state != STATE_DEV_RUNNING) {
643 dev_dbg(dev->dev, "fail, device is not running\n");
647 if (!dev->gadget) {
648 dev_dbg(dev->dev, "fail, gadget is not bound\n");
652 if (dev->ep0_urb_queued) {
653 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
657 if ((in && !dev->ep0_in_pending) ||
658 (!in && !dev->ep0_out_pending)) {
659 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
663 if (WARN_ON(in && dev->ep0_out_pending)) {
665 dev->state = STATE_DEV_FAILED;
668 if (WARN_ON(!in && dev->ep0_in_pending)) {
670 dev->state = STATE_DEV_FAILED;
674 dev->req->buf = data;
675 dev->req->length = io->length;
676 dev->req->zero = usb_raw_io_flags_zero(io->flags);
677 dev->ep0_urb_queued = true;
678 spin_unlock_irqrestore(&dev->lock, flags);
680 ret = usb_ep_queue(dev->gadget->ep0, dev->req, GFP_KERNEL);
682 dev_err(&dev->gadget->dev,
684 spin_lock_irqsave(&dev->lock, flags);
685 dev->state = STATE_DEV_FAILED;
689 ret = wait_for_completion_interruptible(&dev->ep0_done);
691 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
692 usb_ep_dequeue(dev->gadget->ep0, dev->req);
693 wait_for_completion(&dev->ep0_done);
694 spin_lock_irqsave(&dev->lock, flags);
695 if (dev->ep0_status == -ECONNRESET)
696 dev->ep0_status = -EINTR;
700 spin_lock_irqsave(&dev->lock, flags);
703 ret = dev->ep0_status;
705 dev->ep0_urb_queued = false;
707 spin_unlock_irqrestore(&dev->lock, flags);
711 static int raw_ioctl_ep0_write(struct raw_dev *dev, unsigned long value)
720 ret = raw_process_ep0_io(dev, &io, data, true);
725 static int raw_ioctl_ep0_read(struct raw_dev *dev, unsigned long value)
735 ret = raw_process_ep0_io(dev, &io, data, false);
749 static int raw_ioctl_ep0_stall(struct raw_dev *dev, unsigned long value)
756 spin_lock_irqsave(&dev->lock, flags);
757 if (dev->state != STATE_DEV_RUNNING) {
758 dev_dbg(dev->dev, "fail, device is not running\n");
762 if (!dev->gadget) {
763 dev_dbg(dev->dev, "fail, gadget is not bound\n");
767 if (dev->ep0_urb_queued) {
768 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
772 if (!dev->ep0_in_pending && !dev->ep0_out_pending) {
773 dev_dbg(&dev->gadget->dev, "fail, no request pending\n");
778 ret = usb_ep_set_halt(dev->gadget->ep0);
780 dev_err(&dev->gadget->dev,
783 if (dev->ep0_in_pending)
784 dev->ep0_in_pending = false;
786 dev->ep0_out_pending = false;
789 spin_unlock_irqrestore(&dev->lock, flags);
793 static int raw_ioctl_ep_enable(struct raw_dev *dev, unsigned long value)
810 dev_dbg(dev->dev, "fail, bad endpoint maxpacket\n");
815 spin_lock_irqsave(&dev->lock, flags);
816 if (dev->state != STATE_DEV_RUNNING) {
817 dev_dbg(dev->dev, "fail, device is not running\n");
821 if (!dev->gadget) {
822 dev_dbg(dev->dev, "fail, gadget is not bound\n");
827 for (i = 0; i < dev->eps_num; i++) {
828 ep = &dev->eps[i];
832 if (!usb_gadget_ep_match_desc(dev->gadget, ep->ep, desc, NULL))
840 dev_err(&dev->gadget->dev,
846 dev_err(&dev->gadget->dev,
859 dev_dbg(&dev->gadget->dev, "fail, bad endpoint descriptor\n");
862 dev_dbg(&dev->gadget->dev, "fail, no endpoints available\n");
869 spin_unlock_irqrestore(&dev->lock, flags);
873 static int raw_ioctl_ep_disable(struct raw_dev *dev, unsigned long value)
878 spin_lock_irqsave(&dev->lock, flags);
879 if (dev->state != STATE_DEV_RUNNING) {
880 dev_dbg(dev->dev, "fail, device is not running\n");
884 if (!dev->gadget) {
885 dev_dbg(dev->dev, "fail, gadget is not bound\n");
889 if (i < 0 || i >= dev->eps_num) {
890 dev_dbg(dev->dev, "fail, invalid endpoint\n");
894 if (dev->eps[i].state == STATE_EP_DISABLED) {
895 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
899 if (dev->eps[i].disabling) {
900 dev_dbg(&dev->gadget->dev,
905 if (dev->eps[i].urb_queued) {
906 dev_dbg(&dev->gadget->dev,
911 dev->eps[i].disabling = true;
912 spin_unlock_irqrestore(&dev->lock, flags);
914 usb_ep_disable(dev->eps[i].ep);
916 spin_lock_irqsave(&dev->lock, flags);
917 usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
918 kfree(dev->eps[i].ep->desc);
919 dev->eps[i].state = STATE_EP_DISABLED;
920 dev->eps[i].disabling = false;
923 spin_unlock_irqrestore(&dev->lock, flags);
927 static int raw_ioctl_ep_set_clear_halt_wedge(struct raw_dev *dev,
933 spin_lock_irqsave(&dev->lock, flags);
934 if (dev->state != STATE_DEV_RUNNING) {
935 dev_dbg(dev->dev, "fail, device is not running\n");
939 if (!dev->gadget) {
940 dev_dbg(dev->dev, "fail, gadget is not bound\n");
944 if (i < 0 || i >= dev->eps_num) {
945 dev_dbg(dev->dev, "fail, invalid endpoint\n");
949 if (dev->eps[i].state == STATE_EP_DISABLED) {
950 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
954 if (dev->eps[i].disabling) {
955 dev_dbg(&dev->gadget->dev,
960 if (dev->eps[i].urb_queued) {
961 dev_dbg(&dev->gadget->dev,
966 if (usb_endpoint_xfer_isoc(dev->eps[i].ep->desc)) {
967 dev_dbg(&dev->gadget->dev,
974 ret = usb_ep_set_halt(dev->eps[i].ep);
976 dev_err(&dev->gadget->dev,
979 ret = usb_ep_clear_halt(dev->eps[i].ep);
981 dev_err(&dev->gadget->dev,
984 ret = usb_ep_set_wedge(dev->eps[i].ep);
986 dev_err(&dev->gadget->dev,
991 spin_unlock_irqrestore(&dev->lock, flags);
998 struct raw_dev *dev = r_ep->dev;
1001 spin_lock_irqsave(&dev->lock, flags);
1006 spin_unlock_irqrestore(&dev->lock, flags);
1011 static int raw_process_ep_io(struct raw_dev *dev, struct usb_raw_ep_io *io,
1019 spin_lock_irqsave(&dev->lock, flags);
1020 if (dev->state != STATE_DEV_RUNNING) {
1021 dev_dbg(dev->dev, "fail, device is not running\n");
1025 if (!dev->gadget) {
1026 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1030 if (io->ep >= dev->eps_num) {
1031 dev_dbg(&dev->gadget->dev, "fail, invalid endpoint\n");
1035 ep = &dev->eps[io->ep];
1037 dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
1042 dev_dbg(&dev->gadget->dev,
1048 dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
1053 dev_dbg(&dev->gadget->dev, "fail, wrong direction\n");
1058 ep->dev = dev;
1065 spin_unlock_irqrestore(&dev->lock, flags);
1069 dev_err(&dev->gadget->dev,
1071 spin_lock_irqsave(&dev->lock, flags);
1072 dev->state = STATE_DEV_FAILED;
1078 dev_dbg(&dev->gadget->dev, "wait interrupted\n");
1081 spin_lock_irqsave(&dev->lock, flags);
1087 spin_lock_irqsave(&dev->lock, flags);
1094 spin_unlock_irqrestore(&dev->lock, flags);
1098 static int raw_ioctl_ep_write(struct raw_dev *dev, unsigned long value)
1107 ret = raw_process_ep_io(dev, &io, data, true);
1112 static int raw_ioctl_ep_read(struct raw_dev *dev, unsigned long value)
1122 ret = raw_process_ep_io(dev, &io, data, false);
1136 static int raw_ioctl_configure(struct raw_dev *dev, unsigned long value)
1143 spin_lock_irqsave(&dev->lock, flags);
1144 if (dev->state != STATE_DEV_RUNNING) {
1145 dev_dbg(dev->dev, "fail, device is not running\n");
1149 if (!dev->gadget) {
1150 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1154 usb_gadget_set_state(dev->gadget, USB_STATE_CONFIGURED);
1157 spin_unlock_irqrestore(&dev->lock, flags);
1161 static int raw_ioctl_vbus_draw(struct raw_dev *dev, unsigned long value)
1166 spin_lock_irqsave(&dev->lock, flags);
1167 if (dev->state != STATE_DEV_RUNNING) {
1168 dev_dbg(dev->dev, "fail, device is not running\n");
1172 if (!dev->gadget) {
1173 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1177 usb_gadget_vbus_draw(dev->gadget, 2 * value);
1180 spin_unlock_irqrestore(&dev->lock, flags);
1201 static int raw_ioctl_eps_info(struct raw_dev *dev, unsigned long value)
1214 spin_lock_irqsave(&dev->lock, flags);
1215 if (dev->state != STATE_DEV_RUNNING) {
1216 dev_dbg(dev->dev, "fail, device is not running\n");
1218 spin_unlock_irqrestore(&dev->lock, flags);
1221 if (!dev->gadget) {
1222 dev_dbg(dev->dev, "fail, gadget is not bound\n");
1224 spin_unlock_irqrestore(&dev->lock, flags);
1228 for (i = 0; i < dev->eps_num; i++) {
1229 ep = &dev->eps[i];
1236 ret = dev->eps_num;
1237 spin_unlock_irqrestore(&dev->lock, flags);
1250 struct raw_dev *dev = fd->private_data;
1253 if (!dev)
1258 ret = raw_ioctl_init(dev, value);
1261 ret = raw_ioctl_run(dev, value);
1264 ret = raw_ioctl_event_fetch(dev, value);
1267 ret = raw_ioctl_ep0_write(dev, value);
1270 ret = raw_ioctl_ep0_read(dev, value);
1273 ret = raw_ioctl_ep_enable(dev, value);
1276 ret = raw_ioctl_ep_disable(dev, value);
1279 ret = raw_ioctl_ep_write(dev, value);
1282 ret = raw_ioctl_ep_read(dev, value);
1285 ret = raw_ioctl_configure(dev, value);
1288 ret = raw_ioctl_vbus_draw(dev, value);
1291 ret = raw_ioctl_eps_info(dev, value);
1294 ret = raw_ioctl_ep0_stall(dev, value);
1298 dev, value, true, true);
1302 dev, value, false, true);
1306 dev, value, true, false);