usb/class/cdc-wdm.c

122 	struct wdm_device *desc;
125 	list_for_each_entry(desc, &wdm_device_list, device_list)
126 		if (desc->intf == intf)
128 	desc = NULL;
132 	return desc;
137 	struct wdm_device *desc;
140 	list_for_each_entry(desc, &wdm_device_list, device_list)
141 		if (desc->intf->minor == minor)
143 	desc = NULL;
147 	return desc;
153 	struct wdm_device *desc;
156 	desc = urb->context;
157 	spin_lock_irqsave(&desc->iuspin, flags);
158 	desc->werr = urb->status;
159 	spin_unlock_irqrestore(&desc->iuspin, flags);
160 	kfree(desc->outbuf);
161 	desc->outbuf = NULL;
162 	clear_bit(WDM_IN_USE, &desc->flags);
163 	wake_up_all(&desc->wait);
166 static void wdm_wwan_rx(struct wdm_device *desc, int length);
171 	struct wdm_device *desc = urb->context;
175 	spin_lock_irqsave(&desc->iuspin, flags);
176 	clear_bit(WDM_RESPONDING, &desc->flags);
181 			dev_dbg(&desc->intf->dev,
185 			dev_dbg(&desc->intf->dev,
189 			dev_dbg(&desc->intf->dev,
193 			dev_err(&desc->intf->dev,
197 			dev_err(&desc->intf->dev,
203 	if (test_bit(WDM_WWAN_IN_USE, &desc->flags)) {
204 		wdm_wwan_rx(desc, length);
214 	if (desc->rerr == 0 && status != -EPIPE)
215 		desc->rerr = status;
217 	if (length + desc->length > desc->wMaxCommand) {
219 		set_bit(WDM_OVERFLOW, &desc->flags);
222 		if (!test_bit(WDM_OVERFLOW, &desc->flags)) {
223 			memmove(desc->ubuf + desc->length, desc->inbuf, length);
224 			desc->length += length;
225 			desc->reslength = length;
230 	if (desc->rerr) {
237 		schedule_work(&desc->service_outs_intr);
239 		set_bit(WDM_READ, &desc->flags);
240 		wake_up(&desc->wait);
243 	spin_unlock_irqrestore(&desc->iuspin, flags);
252 	struct wdm_device *desc;
255 	desc = urb->context;
256 	dr = (struct usb_cdc_notification *)desc->sbuf;
265 			set_bit(WDM_INT_STALL, &desc->flags);
266 			dev_err(&desc->intf->dev, "Stall on int endpoint\n");
269 			dev_err(&desc->intf->dev,
276 		dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n",
283 		dev_dbg(&desc->intf->dev,
290 		dev_dbg(&desc->intf->dev,
295 		dev_dbg(&desc->intf->dev, "SPEED_CHANGE received (len %u)\n",
299 		clear_bit(WDM_POLL_RUNNING, &desc->flags);
300 		dev_err(&desc->intf->dev,
308 	spin_lock_irqsave(&desc->iuspin, flags);
309 	responding = test_and_set_bit(WDM_RESPONDING, &desc->flags);
310 	if (!desc->resp_count++ && !responding
311 		&& !test_bit(WDM_DISCONNECTING, &desc->flags)
312 		&& !test_bit(WDM_SUSPENDING, &desc->flags)) {
313 		rv = usb_submit_urb(desc->response, GFP_ATOMIC);
314 		dev_dbg(&desc->intf->dev, "submit response URB %d\n", rv);
316 	spin_unlock_irqrestore(&desc->iuspin, flags);
318 		clear_bit(WDM_RESPONDING, &desc->flags);
323 			rv = schedule_work(&desc->rxwork);
325 				dev_err(&desc->intf->dev,
332 		dev_err(&desc->intf->dev,
338 static void poison_urbs(struct wdm_device *desc)
341 	usb_poison_urb(desc->command);
342 	usb_poison_urb(desc->validity);
343 	usb_poison_urb(desc->response);
346 static void unpoison_urbs(struct wdm_device *desc)
352 	usb_unpoison_urb(desc->response);
353 	usb_unpoison_urb(desc->validity);
354 	usb_unpoison_urb(desc->command);
357 static void free_urbs(struct wdm_device *desc)
359 	usb_free_urb(desc->validity);
360 	usb_free_urb(desc->response);
361 	usb_free_urb(desc->command);
364 static void cleanup(struct wdm_device *desc)
366 	kfree(desc->sbuf);
367 	kfree(desc->inbuf);
368 	kfree(desc->orq);
369 	kfree(desc->irq);
370 	kfree(desc->ubuf);
371 	free_urbs(desc);
372 	kfree(desc);
380 	struct wdm_device *desc = file->private_data;
383 	if (count > desc->wMaxCommand)
384 		count = desc->wMaxCommand;
386 	spin_lock_irq(&desc->iuspin);
387 	we = desc->werr;
388 	desc->werr = 0;
389 	spin_unlock_irq(&desc->iuspin);
398 	r = mutex_lock_interruptible(&desc->wlock);
403 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
408 	r = usb_autopm_get_interface(desc->intf);
415 		r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
416 								&desc->flags));
418 		if (test_bit(WDM_IN_USE, &desc->flags))
421 	if (test_bit(WDM_RESETTING, &desc->flags))
424 	if (test_bit(WDM_DISCONNECTING, &desc->flags))
432 	req = desc->orq;
434 		desc->command,
435 		interface_to_usbdev(desc->intf),
437 		usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
442 		desc
449 	req->wIndex = desc->inum; /* already converted */
451 	set_bit(WDM_IN_USE, &desc->flags);
452 	desc->outbuf = buf;
454 	rv = usb_submit_urb(desc->command, GFP_KERNEL);
456 		desc->outbuf = NULL;
457 		clear_bit(WDM_IN_USE, &desc->flags);
458 		wake_up_all(&desc->wait); /* for wdm_wait_for_response() */
459 		dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
463 		dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d\n",
467 	usb_autopm_put_interface(desc->intf);
468 	mutex_unlock(&desc->wlock);
472 	usb_autopm_put_interface(desc->intf);
474 	mutex_unlock(&desc->wlock);
483  * Called with desc->iuspin locked
485 static int service_outstanding_interrupt(struct wdm_device *desc)
490 	if (!desc->resp_count || !--desc->resp_count)
493 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
497 	if (test_bit(WDM_RESETTING, &desc->flags)) {
502 	set_bit(WDM_RESPONDING, &desc->flags);
503 	spin_unlock_irq(&desc->iuspin);
504 	rv = usb_submit_urb(desc->response, GFP_KERNEL);
505 	spin_lock_irq(&desc->iuspin);
507 		if (!test_bit(WDM_DISCONNECTING, &desc->flags))
508 			dev_err(&desc->intf->dev,
512 		clear_bit(WDM_RESPONDING, &desc->flags);
513 		desc->resp_count = 0;
524 	struct wdm_device *desc = file->private_data;
527 	rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
531 	cntr = READ_ONCE(desc->length);
533 		desc->read = 0;
535 		if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
539 		if (test_bit(WDM_OVERFLOW, &desc->flags)) {
540 			clear_bit(WDM_OVERFLOW, &desc->flags);
546 			if (!test_bit(WDM_READ, &desc->flags)) {
552 			rv = wait_event_interruptible(desc->wait,
553 				test_bit(WDM_READ, &desc->flags));
557 		if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
561 		if (test_bit(WDM_RESETTING, &desc->flags)) {
565 		usb_mark_last_busy(interface_to_usbdev(desc->intf));
571 		spin_lock_irq(&desc->iuspin);
573 		if (desc->rerr) { /* read completed, error happened */
574 			rv = usb_translate_errors(desc->rerr);
575 			desc->rerr = 0;
576 			spin_unlock_irq(&desc->iuspin);
583 		if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
584 			spin_unlock_irq(&desc->iuspin);
588 		if (!desc->reslength) { /* zero length read */
589 			dev_dbg(&desc->intf->dev, "zero length - clearing WDM_READ\n");
590 			clear_bit(WDM_READ, &desc->flags);
591 			rv = service_outstanding_interrupt(desc);
592 			spin_unlock_irq(&desc->iuspin);
597 		cntr = desc->length;
598 		spin_unlock_irq(&desc->iuspin);
603 	rv = copy_to_user(buffer, desc->ubuf, cntr);
609 	spin_lock_irq(&desc->iuspin);
611 	for (i = 0; i < desc->length - cntr; i++)
612 		desc->ubuf[i] = desc->ubuf[i + cntr];
614 	desc->length -= cntr;
616 	if (!desc->length) {
617 		clear_bit(WDM_READ, &desc->flags);
618 		service_outstanding_interrupt(desc);
620 	spin_unlock_irq(&desc->iuspin);
624 	mutex_unlock(&desc->rlock);
630 	struct wdm_device *desc = file->private_data;
637 	rv = wait_event_interruptible_timeout(desc->wait,
638 			      !test_bit(WDM_IN_USE, &desc->flags) ||
639 			      test_bit(WDM_DISCONNECTING, &desc->flags),
646 	if (test_bit(WDM_DISCONNECTING, &desc->flags))
653 	spin_lock_irq(&desc->iuspin);
654 	rv = desc->werr;
655 	desc->werr = 0;
656 	spin_unlock_irq(&desc->iuspin);
684 	struct wdm_device *desc = file->private_data;
688 	spin_lock_irqsave(&desc->iuspin, flags);
689 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
691 		spin_unlock_irqrestore(&desc->iuspin, flags);
694 	if (test_bit(WDM_READ, &desc->flags))
696 	if (desc->rerr || desc->werr)
698 	if (!test_bit(WDM_IN_USE, &desc->flags))
700 	spin_unlock_irqrestore(&desc->iuspin, flags);
702 	poll_wait(file, &desc->wait, wait);
713 	struct wdm_device *desc;
716 	desc = wdm_find_device_by_minor(minor);
717 	if (!desc)
720 	intf = desc->intf;
721 	if (test_bit(WDM_DISCONNECTING, &desc->flags))
723 	file->private_data = desc;
725 	if (test_bit(WDM_WWAN_IN_USE, &desc->flags)) {
730 	rv = usb_autopm_get_interface(desc->intf);
732 		dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
736 	/* using write lock to protect desc->count */
737 	mutex_lock(&desc->wlock);
738 	if (!desc->count++) {
739 		desc->werr = 0;
740 		desc->rerr = 0;
741 		rv = usb_submit_urb(desc->validity, GFP_KERNEL);
743 			desc->count--;
744 			dev_err(&desc->intf->dev,
751 	mutex_unlock(&desc->wlock);
752 	if (desc->count == 1)
753 		desc->manage_power(intf, 1);
754 	usb_autopm_put_interface(desc->intf);
762 	struct wdm_device *desc = file->private_data;
766 	/* using write lock to protect desc->count */
767 	mutex_lock(&desc->wlock);
768 	desc->count--;
769 	mutex_unlock(&desc->wlock);
771 	if (!desc->count) {
772 		if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
773 			dev_dbg(&desc->intf->dev, "wdm_release: cleanup\n");
774 			poison_urbs(desc);
775 			spin_lock_irq(&desc->iuspin);
776 			desc->resp_count = 0;
777 			clear_bit(WDM_RESPONDING, &desc->flags);
778 			spin_unlock_irq(&desc->iuspin);
779 			desc->manage_power(desc->intf, 0);
780 			unpoison_urbs(desc);
782 			/* must avoid dev_printk here as desc->intf is invalid */
784 			cleanup(desc);
793 	struct wdm_device *desc = file->private_data;
798 		if (copy_to_user((void __user *)arg, &desc->wMaxCommand, sizeof(desc->wMaxCommand)))
831 	struct wdm_device *desc = wwan_port_get_drvdata(port);
838 	if (desc->count) {
842 	set_bit(WDM_WWAN_IN_USE, &desc->flags);
845 	desc->manage_power(desc->intf, 1);
851 	return usb_submit_urb(desc->validity, GFP_KERNEL);
856 	struct wdm_device *desc = wwan_port_get_drvdata(port);
859 	poison_urbs(desc);
860 	desc->manage_power(desc->intf, 0);
861 	clear_bit(WDM_READ, &desc->flags);
862 	clear_bit(WDM_WWAN_IN_USE, &desc->flags);
863 	unpoison_urbs(desc);
869 	struct wdm_device *desc = skb_shinfo(skb)->destructor_arg;
871 	usb_autopm_put_interface(desc->intf);
872 	wwan_port_txon(desc->wwanp);
878 	struct wdm_device *desc = wwan_port_get_drvdata(port);
879 	struct usb_interface *intf = desc->intf;
880 	struct usb_ctrlrequest *req = desc->orq;
888 		desc->command,
901 	req->wIndex = desc->inum;
904 	skb_shinfo(skb)->destructor_arg = desc;
906 	rv = usb_submit_urb(desc->command, GFP_KERNEL);
921 static void wdm_wwan_init(struct wdm_device *desc)
923 	struct usb_interface *intf = desc->intf;
927 	if (desc->wwanp_type == WWAN_PORT_UNKNOWN) {
932 	port = wwan_create_port(&intf->dev, desc->wwanp_type, &wdm_wwan_port_ops,
933 				NULL, desc);
940 	desc->wwanp = port;
943 static void wdm_wwan_deinit(struct wdm_device *desc)
945 	if (!desc->wwanp)
948 	wwan_remove_port(desc->wwanp);
949 	desc->wwanp = NULL;
952 static void wdm_wwan_rx(struct wdm_device *desc, int length)
954 	struct wwan_port *port = desc->wwanp;
962 	skb_put_data(skb, desc->inbuf, length);
966 	schedule_work(&desc->service_outs_intr);
969 static void wdm_wwan_init(struct wdm_device *desc) {}
970 static void wdm_wwan_deinit(struct wdm_device *desc) {}
971 static void wdm_wwan_rx(struct wdm_device *desc, int length) {}
977 	struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
982 	spin_lock_irqsave(&desc->iuspin, flags);
983 	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
984 		spin_unlock_irqrestore(&desc->iuspin, flags);
986 		responding = test_and_set_bit(WDM_RESPONDING, &desc->flags);
987 		spin_unlock_irqrestore(&desc->iuspin, flags);
989 			rv = usb_submit_urb(desc->response, GFP_KERNEL);
991 			spin_lock_irqsave(&desc->iuspin, flags);
992 			clear_bit(WDM_RESPONDING, &desc->flags);
993 			if (!test_bit(WDM_DISCONNECTING, &desc->flags))
994 				schedule_work(&desc->rxwork);
995 			spin_unlock_irqrestore(&desc->iuspin, flags);
1002 	struct wdm_device *desc;
1004 	desc = container_of(work, struct wdm_device, service_outs_intr);
1006 	spin_lock_irq(&desc->iuspin);
1007 	service_outstanding_interrupt(desc);
1008 	if (!desc->resp_count) {
1009 		set_bit(WDM_READ, &desc->flags);
1010 		wake_up(&desc->wait);
1012 	spin_unlock_irq(&desc->iuspin);
1022 	struct wdm_device *desc;
1024 	desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
1025 	if (!desc)
1027 	INIT_LIST_HEAD(&desc->device_list);
1028 	mutex_init(&desc->rlock);
1029 	mutex_init(&desc->wlock);
1030 	spin_lock_init(&desc->iuspin);
1031 	init_waitqueue_head(&desc->wait);
1032 	desc->wMaxCommand = bufsize;
1034 	desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
1035 	desc->intf = intf;
1036 	desc->wwanp_type = type;
1037 	INIT_WORK(&desc->rxwork, wdm_rxwork);
1038 	INIT_WORK(&desc->service_outs_intr, service_interrupt_work);
1045 	desc->wMaxPacketSize = usb_endpoint_maxp(ep);
1047 	desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
1048 	if (!desc->orq)
1050 	desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
1051 	if (!desc->irq)
1054 	desc->validity = usb_alloc_urb(0, GFP_KERNEL);
1055 	if (!desc->validity)
1058 	desc->response = usb_alloc_urb(0, GFP_KERNEL);
1059 	if (!desc->response)
1062 	desc->command = usb_alloc_urb(0, GFP_KERNEL);
1063 	if (!desc->command)
1066 	desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
1067 	if (!desc->ubuf)
1070 	desc->sbuf = kmalloc(desc->wMaxPacketSize, GFP_KERNEL);
1071 	if (!desc->sbuf)
1074 	desc->inbuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
1075 	if (!desc->inbuf)
1079 		desc->validity,
1082 		desc->sbuf,
1083 		desc->wMaxPacketSize,
1085 		desc,
1089 	desc->irq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
1090 	desc->irq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
1091 	desc->irq->wValue = 0;
1092 	desc->irq->wIndex = desc->inum; /* already converted */
1093 	desc->irq->wLength = cpu_to_le16(desc->wMaxCommand);
1096 		desc->response,
1099 		usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
1100 		(unsigned char *)desc->irq,
1101 		desc->inbuf,
1102 		desc->wMaxCommand,
1104 		desc
1107 	desc->manage_power = manage_power;
1110 	list_add(&desc->device_list, &wdm_device_list);
1119 	wdm_wwan_init(desc);
1125 	list_del(&desc->device_list);
1127 	cleanup(desc);
1161 	if (iface->desc.bNumEndpoints != 1)
1163 	ep = &iface->endpoint[0].desc;
1211 	struct wdm_device *desc;
1215 	desc = wdm_find_device(intf);
1218 	wdm_wwan_deinit(desc);
1221 	spin_lock_irqsave(&desc->iuspin, flags);
1222 	set_bit(WDM_DISCONNECTING, &desc->flags);
1223 	set_bit(WDM_READ, &desc->flags);
1224 	spin_unlock_irqrestore(&desc->iuspin, flags);
1225 	wake_up_all(&desc->wait);
1226 	mutex_lock(&desc->rlock);
1227 	mutex_lock(&desc->wlock);
1228 	poison_urbs(desc);
1229 	cancel_work_sync(&desc->rxwork);
1230 	cancel_work_sync(&desc->service_outs_intr);
1231 	mutex_unlock(&desc->wlock);
1232 	mutex_unlock(&desc->rlock);
1234 	/* the desc->intf pointer used as list key is now invalid */
1236 	list_del(&desc->device_list);
1239 	if (!desc->count)
1240 		cleanup(desc);
1242 		dev_dbg(&intf->dev, "%d open files - postponing cleanup\n", desc->count);
1249 	struct wdm_device *desc = wdm_find_device(intf);
1252 	dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
1256 		mutex_lock(&desc->rlock);
1257 		mutex_lock(&desc->wlock);
1259 	spin_lock_irq(&desc->iuspin);
1262 			(test_bit(WDM_IN_USE, &desc->flags)
1263 			|| test_bit(WDM_RESPONDING, &desc->flags))) {
1264 		spin_unlock_irq(&desc->iuspin);
1268 		set_bit(WDM_SUSPENDING, &desc->flags);
1269 		spin_unlock_irq(&desc->iuspin);
1271 		poison_urbs(desc);
1272 		cancel_work_sync(&desc->rxwork);
1273 		cancel_work_sync(&desc->service_outs_intr);
1274 		unpoison_urbs(desc);
1277 		mutex_unlock(&desc->wlock);
1278 		mutex_unlock(&desc->rlock);
1285 static int recover_from_urb_loss(struct wdm_device *desc)
1289 	if (desc->count) {
1290 		rv = usb_submit_urb(desc->validity, GFP_NOIO);
1292 			dev_err(&desc->intf->dev,
1301 	struct wdm_device *desc = wdm_find_device(intf);
1304 	dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
1306 	clear_bit(WDM_SUSPENDING, &desc->flags);
1307 	rv = recover_from_urb_loss(desc);
1315 	struct wdm_device *desc = wdm_find_device(intf);
1323 	spin_lock_irq(&desc->iuspin);
1324 	set_bit(WDM_RESETTING, &desc->flags);	/* inform read/write */
1325 	set_bit(WDM_READ, &desc->flags);	/* unblock read */
1326 	clear_bit(WDM_IN_USE, &desc->flags);	/* unblock write */
1327 	desc->rerr = -EINTR;
1328 	spin_unlock_irq(&desc->iuspin);
1329 	wake_up_all(&desc->wait);
1330 	mutex_lock(&desc->rlock);
1331 	mutex_lock(&desc->wlock);
1332 	poison_urbs(desc);
1333 	cancel_work_sync(&desc->rxwork);
1334 	cancel_work_sync(&desc->service_outs_intr);
1340 	struct wdm_device *desc = wdm_find_device(intf);
1343 	unpoison_urbs(desc);
1344 	clear_bit(WDM_OVERFLOW, &desc->flags);
1345 	clear_bit(WDM_RESETTING, &desc->flags);
1346 	rv = recover_from_urb_loss(desc);
1347 	mutex_unlock(&desc->wlock);
1348 	mutex_unlock(&desc->rlock);