Lines Matching refs:desc
116 struct wdm_device *desc;
119 list_for_each_entry(desc, &wdm_device_list, device_list)
120 if (desc->intf == intf)
122 desc = NULL;
126 return desc;
131 struct wdm_device *desc;
134 list_for_each_entry(desc, &wdm_device_list, device_list)
135 if (desc->intf->minor == minor)
137 desc = NULL;
141 return desc;
147 struct wdm_device *desc;
150 desc = urb->context;
151 spin_lock_irqsave(&desc->iuspin, flags);
152 desc->werr = urb->status;
153 spin_unlock_irqrestore(&desc->iuspin, flags);
154 kfree(desc->outbuf);
155 desc->outbuf = NULL;
156 clear_bit(WDM_IN_USE, &desc->flags);
157 wake_up_all(&desc->wait);
163 struct wdm_device *desc = urb->context;
167 spin_lock_irqsave(&desc->iuspin, flags);
168 clear_bit(WDM_RESPONDING, &desc->flags);
173 dev_dbg(&desc->intf->dev,
177 dev_dbg(&desc->intf->dev,
181 dev_dbg(&desc->intf->dev,
185 dev_err(&desc->intf->dev,
189 dev_err(&desc->intf->dev,
201 if (desc->rerr == 0 && status != -EPIPE)
202 desc->rerr = status;
204 if (length + desc->length > desc->wMaxCommand) {
206 set_bit(WDM_OVERFLOW, &desc->flags);
209 if (!test_bit(WDM_OVERFLOW, &desc->flags)) {
210 memmove(desc->ubuf + desc->length, desc->inbuf, length);
211 desc->length += length;
212 desc->reslength = length;
217 if (desc->rerr) {
224 schedule_work(&desc->service_outs_intr);
226 set_bit(WDM_READ, &desc->flags);
227 wake_up(&desc->wait);
229 spin_unlock_irqrestore(&desc->iuspin, flags);
238 struct wdm_device *desc;
241 desc = urb->context;
242 dr = (struct usb_cdc_notification *)desc->sbuf;
251 set_bit(WDM_INT_STALL, &desc->flags);
252 dev_err(&desc->intf->dev, "Stall on int endpoint\n");
255 dev_err(&desc->intf->dev,
262 dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n",
269 dev_dbg(&desc->intf->dev,
276 dev_dbg(&desc->intf->dev,
281 dev_dbg(&desc->intf->dev, "SPEED_CHANGE received (len %u)\n",
285 clear_bit(WDM_POLL_RUNNING, &desc->flags);
286 dev_err(&desc->intf->dev,
294 spin_lock_irqsave(&desc->iuspin, flags);
295 responding = test_and_set_bit(WDM_RESPONDING, &desc->flags);
296 if (!desc->resp_count++ && !responding
297 && !test_bit(WDM_DISCONNECTING, &desc->flags)
298 && !test_bit(WDM_SUSPENDING, &desc->flags)) {
299 rv = usb_submit_urb(desc->response, GFP_ATOMIC);
300 dev_dbg(&desc->intf->dev, "submit response URB %d\n", rv);
302 spin_unlock_irqrestore(&desc->iuspin, flags);
304 clear_bit(WDM_RESPONDING, &desc->flags);
309 rv = schedule_work(&desc->rxwork);
311 dev_err(&desc->intf->dev,
318 dev_err(&desc->intf->dev,
324 static void poison_urbs(struct wdm_device *desc)
327 usb_poison_urb(desc->command);
328 usb_poison_urb(desc->validity);
329 usb_poison_urb(desc->response);
332 static void unpoison_urbs(struct wdm_device *desc)
338 usb_unpoison_urb(desc->response);
339 usb_unpoison_urb(desc->validity);
340 usb_unpoison_urb(desc->command);
343 static void free_urbs(struct wdm_device *desc)
345 usb_free_urb(desc->validity);
346 usb_free_urb(desc->response);
347 usb_free_urb(desc->command);
350 static void cleanup(struct wdm_device *desc)
352 kfree(desc->sbuf);
353 kfree(desc->inbuf);
354 kfree(desc->orq);
355 kfree(desc->irq);
356 kfree(desc->ubuf);
357 free_urbs(desc);
358 kfree(desc);
366 struct wdm_device *desc = file->private_data;
369 if (count > desc->wMaxCommand)
370 count = desc->wMaxCommand;
372 spin_lock_irq(&desc->iuspin);
373 we = desc->werr;
374 desc->werr = 0;
375 spin_unlock_irq(&desc->iuspin);
384 r = mutex_lock_interruptible(&desc->wlock);
389 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
394 r = usb_autopm_get_interface(desc->intf);
401 r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
402 &desc->flags));
404 if (test_bit(WDM_IN_USE, &desc->flags))
407 if (test_bit(WDM_RESETTING, &desc->flags))
410 if (test_bit(WDM_DISCONNECTING, &desc->flags))
418 req = desc->orq;
420 desc->command,
421 interface_to_usbdev(desc->intf),
423 usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
428 desc
435 req->wIndex = desc->inum; /* already converted */
437 set_bit(WDM_IN_USE, &desc->flags);
438 desc->outbuf = buf;
440 rv = usb_submit_urb(desc->command, GFP_KERNEL);
442 desc->outbuf = NULL;
443 clear_bit(WDM_IN_USE, &desc->flags);
444 wake_up_all(&desc->wait); /* for wdm_wait_for_response() */
445 dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
449 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d\n",
453 usb_autopm_put_interface(desc->intf);
454 mutex_unlock(&desc->wlock);
458 usb_autopm_put_interface(desc->intf);
460 mutex_unlock(&desc->wlock);
469 * Called with desc->iuspin locked
471 static int service_outstanding_interrupt(struct wdm_device *desc)
476 if (!desc->resp_count || !--desc->resp_count)
479 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
483 if (test_bit(WDM_RESETTING, &desc->flags)) {
488 set_bit(WDM_RESPONDING, &desc->flags);
489 spin_unlock_irq(&desc->iuspin);
490 rv = usb_submit_urb(desc->response, GFP_KERNEL);
491 spin_lock_irq(&desc->iuspin);
493 if (!test_bit(WDM_DISCONNECTING, &desc->flags))
494 dev_err(&desc->intf->dev,
498 clear_bit(WDM_RESPONDING, &desc->flags);
499 desc->resp_count = 0;
510 struct wdm_device *desc = file->private_data;
513 rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
517 cntr = READ_ONCE(desc->length);
519 desc->read = 0;
521 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
525 if (test_bit(WDM_OVERFLOW, &desc->flags)) {
526 clear_bit(WDM_OVERFLOW, &desc->flags);
532 if (!test_bit(WDM_READ, &desc->flags)) {
538 rv = wait_event_interruptible(desc->wait,
539 test_bit(WDM_READ, &desc->flags));
543 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
547 if (test_bit(WDM_RESETTING, &desc->flags)) {
551 usb_mark_last_busy(interface_to_usbdev(desc->intf));
557 spin_lock_irq(&desc->iuspin);
559 if (desc->rerr) { /* read completed, error happened */
560 rv = usb_translate_errors(desc->rerr);
561 desc->rerr = 0;
562 spin_unlock_irq(&desc->iuspin);
569 if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
570 spin_unlock_irq(&desc->iuspin);
574 if (!desc->reslength) { /* zero length read */
575 dev_dbg(&desc->intf->dev, "zero length - clearing WDM_READ\n");
576 clear_bit(WDM_READ, &desc->flags);
577 rv = service_outstanding_interrupt(desc);
578 spin_unlock_irq(&desc->iuspin);
583 cntr = desc->length;
584 spin_unlock_irq(&desc->iuspin);
589 rv = copy_to_user(buffer, desc->ubuf, cntr);
595 spin_lock_irq(&desc->iuspin);
597 for (i = 0; i < desc->length - cntr; i++)
598 desc->ubuf[i] = desc->ubuf[i + cntr];
600 desc->length -= cntr;
602 if (!desc->length) {
603 clear_bit(WDM_READ, &desc->flags);
604 service_outstanding_interrupt(desc);
606 spin_unlock_irq(&desc->iuspin);
610 mutex_unlock(&desc->rlock);
616 struct wdm_device *desc = file->private_data;
623 rv = wait_event_interruptible_timeout(desc->wait,
624 !test_bit(WDM_IN_USE, &desc->flags) ||
625 test_bit(WDM_DISCONNECTING, &desc->flags),
632 if (test_bit(WDM_DISCONNECTING, &desc->flags))
639 spin_lock_irq(&desc->iuspin);
640 rv = desc->werr;
641 desc->werr = 0;
642 spin_unlock_irq(&desc->iuspin);
670 struct wdm_device *desc = file->private_data;
674 spin_lock_irqsave(&desc->iuspin, flags);
675 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
677 spin_unlock_irqrestore(&desc->iuspin, flags);
680 if (test_bit(WDM_READ, &desc->flags))
682 if (desc->rerr || desc->werr)
684 if (!test_bit(WDM_IN_USE, &desc->flags))
686 spin_unlock_irqrestore(&desc->iuspin, flags);
688 poll_wait(file, &desc->wait, wait);
699 struct wdm_device *desc;
702 desc = wdm_find_device_by_minor(minor);
703 if (!desc)
706 intf = desc->intf;
707 if (test_bit(WDM_DISCONNECTING, &desc->flags))
709 file->private_data = desc;
711 rv = usb_autopm_get_interface(desc->intf);
713 dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
717 /* using write lock to protect desc->count */
718 mutex_lock(&desc->wlock);
719 if (!desc->count++) {
720 desc->werr = 0;
721 desc->rerr = 0;
722 rv = usb_submit_urb(desc->validity, GFP_KERNEL);
724 desc->count--;
725 dev_err(&desc->intf->dev,
732 mutex_unlock(&desc->wlock);
733 if (desc->count == 1)
734 desc->manage_power(intf, 1);
735 usb_autopm_put_interface(desc->intf);
743 struct wdm_device *desc = file->private_data;
747 /* using write lock to protect desc->count */
748 mutex_lock(&desc->wlock);
749 desc->count--;
750 mutex_unlock(&desc->wlock);
752 if (!desc->count) {
753 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
754 dev_dbg(&desc->intf->dev, "wdm_release: cleanup\n");
755 poison_urbs(desc);
756 spin_lock_irq(&desc->iuspin);
757 desc->resp_count = 0;
758 clear_bit(WDM_RESPONDING, &desc->flags);
759 spin_unlock_irq(&desc->iuspin);
760 desc->manage_power(desc->intf, 0);
761 unpoison_urbs(desc);
763 /* must avoid dev_printk here as desc->intf is invalid */
765 cleanup(desc);
774 struct wdm_device *desc = file->private_data;
779 if (copy_to_user((void __user *)arg, &desc->wMaxCommand, sizeof(desc->wMaxCommand)))
811 struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
816 spin_lock_irqsave(&desc->iuspin, flags);
817 if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
818 spin_unlock_irqrestore(&desc->iuspin, flags);
820 responding = test_and_set_bit(WDM_RESPONDING, &desc->flags);
821 spin_unlock_irqrestore(&desc->iuspin, flags);
823 rv = usb_submit_urb(desc->response, GFP_KERNEL);
825 spin_lock_irqsave(&desc->iuspin, flags);
826 clear_bit(WDM_RESPONDING, &desc->flags);
827 if (!test_bit(WDM_DISCONNECTING, &desc->flags))
828 schedule_work(&desc->rxwork);
829 spin_unlock_irqrestore(&desc->iuspin, flags);
836 struct wdm_device *desc;
838 desc = container_of(work, struct wdm_device, service_outs_intr);
840 spin_lock_irq(&desc->iuspin);
841 service_outstanding_interrupt(desc);
842 if (!desc->resp_count) {
843 set_bit(WDM_READ, &desc->flags);
844 wake_up(&desc->wait);
846 spin_unlock_irq(&desc->iuspin);
855 struct wdm_device *desc;
857 desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
858 if (!desc)
860 INIT_LIST_HEAD(&desc->device_list);
861 mutex_init(&desc->rlock);
862 mutex_init(&desc->wlock);
863 spin_lock_init(&desc->iuspin);
864 init_waitqueue_head(&desc->wait);
865 desc->wMaxCommand = bufsize;
867 desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
868 desc->intf = intf;
869 INIT_WORK(&desc->rxwork, wdm_rxwork);
870 INIT_WORK(&desc->service_outs_intr, service_interrupt_work);
876 desc->wMaxPacketSize = usb_endpoint_maxp(ep);
878 desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
879 if (!desc->orq)
881 desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
882 if (!desc->irq)
885 desc->validity = usb_alloc_urb(0, GFP_KERNEL);
886 if (!desc->validity)
889 desc->response = usb_alloc_urb(0, GFP_KERNEL);
890 if (!desc->response)
893 desc->command = usb_alloc_urb(0, GFP_KERNEL);
894 if (!desc->command)
897 desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
898 if (!desc->ubuf)
901 desc->sbuf = kmalloc(desc->wMaxPacketSize, GFP_KERNEL);
902 if (!desc->sbuf)
905 desc->inbuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
906 if (!desc->inbuf)
910 desc->validity,
913 desc->sbuf,
914 desc->wMaxPacketSize,
916 desc,
920 desc->irq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
921 desc->irq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
922 desc->irq->wValue = 0;
923 desc->irq->wIndex = desc->inum; /* already converted */
924 desc->irq->wLength = cpu_to_le16(desc->wMaxCommand);
927 desc->response,
930 usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
931 (unsigned char *)desc->irq,
932 desc->inbuf,
933 desc->wMaxCommand,
935 desc
938 desc->manage_power = manage_power;
941 list_add(&desc->device_list, &wdm_device_list);
953 list_del(&desc->device_list);
955 cleanup(desc);
989 if (iface->desc.bNumEndpoints != 1)
991 ep = &iface->endpoint[0].desc;
1038 struct wdm_device *desc;
1042 desc = wdm_find_device(intf);
1046 spin_lock_irqsave(&desc->iuspin, flags);
1047 set_bit(WDM_DISCONNECTING, &desc->flags);
1048 set_bit(WDM_READ, &desc->flags);
1049 spin_unlock_irqrestore(&desc->iuspin, flags);
1050 wake_up_all(&desc->wait);
1051 mutex_lock(&desc->rlock);
1052 mutex_lock(&desc->wlock);
1053 poison_urbs(desc);
1054 cancel_work_sync(&desc->rxwork);
1055 cancel_work_sync(&desc->service_outs_intr);
1056 mutex_unlock(&desc->wlock);
1057 mutex_unlock(&desc->rlock);
1059 /* the desc->intf pointer used as list key is now invalid */
1061 list_del(&desc->device_list);
1064 if (!desc->count)
1065 cleanup(desc);
1067 dev_dbg(&intf->dev, "%d open files - postponing cleanup\n", desc->count);
1074 struct wdm_device *desc = wdm_find_device(intf);
1077 dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
1081 mutex_lock(&desc->rlock);
1082 mutex_lock(&desc->wlock);
1084 spin_lock_irq(&desc->iuspin);
1087 (test_bit(WDM_IN_USE, &desc->flags)
1088 || test_bit(WDM_RESPONDING, &desc->flags))) {
1089 spin_unlock_irq(&desc->iuspin);
1093 set_bit(WDM_SUSPENDING, &desc->flags);
1094 spin_unlock_irq(&desc->iuspin);
1096 poison_urbs(desc);
1097 cancel_work_sync(&desc->rxwork);
1098 cancel_work_sync(&desc->service_outs_intr);
1099 unpoison_urbs(desc);
1102 mutex_unlock(&desc->wlock);
1103 mutex_unlock(&desc->rlock);
1110 static int recover_from_urb_loss(struct wdm_device *desc)
1114 if (desc->count) {
1115 rv = usb_submit_urb(desc->validity, GFP_NOIO);
1117 dev_err(&desc->intf->dev,
1126 struct wdm_device *desc = wdm_find_device(intf);
1129 dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
1131 clear_bit(WDM_SUSPENDING, &desc->flags);
1132 rv = recover_from_urb_loss(desc);
1140 struct wdm_device *desc = wdm_find_device(intf);
1148 spin_lock_irq(&desc->iuspin);
1149 set_bit(WDM_RESETTING, &desc->flags); /* inform read/write */
1150 set_bit(WDM_READ, &desc->flags); /* unblock read */
1151 clear_bit(WDM_IN_USE, &desc->flags); /* unblock write */
1152 desc->rerr = -EINTR;
1153 spin_unlock_irq(&desc->iuspin);
1154 wake_up_all(&desc->wait);
1155 mutex_lock(&desc->rlock);
1156 mutex_lock(&desc->wlock);
1157 poison_urbs(desc);
1158 cancel_work_sync(&desc->rxwork);
1159 cancel_work_sync(&desc->service_outs_intr);
1165 struct wdm_device *desc = wdm_find_device(intf);
1168 unpoison_urbs(desc);
1169 clear_bit(WDM_OVERFLOW, &desc->flags);
1170 clear_bit(WDM_RESETTING, &desc->flags);
1171 rv = recover_from_urb_loss(desc);
1172 mutex_unlock(&desc->wlock);
1173 mutex_unlock(&desc->rlock);