1/*
2 * cdc-wdm.c
3 *
4 * This driver supports USB CDC WCM Device Management.
5 *
6 * Copyright (c) 2007-2009 Oliver Neukum
7 *
8 * Some code taken from cdc-acm.c
9 *
10 * Released under the GPLv2.
11 *
12 * Many thanks to Carl Nordbeck
13 */
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
17#include <linux/module.h>
18#include <linux/mutex.h>
19#include <linux/uaccess.h>
20#include <linux/bitops.h>
21#include <linux/poll.h>
22#include <linux/usb.h>
23#include <linux/usb/cdc.h>
24#include <asm/byteorder.h>
25#include <asm/unaligned.h>
26#include <linux/usb/cdc-wdm.h>
27
28/*
29 * Version Information
30 */
31#define DRIVER_VERSION "v0.03"
32#define DRIVER_AUTHOR "Oliver Neukum"
33#define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
34
35#define HUAWEI_VENDOR_ID	0x12D1
36
37static const struct usb_device_id wdm_ids[] = {
38	{
39		.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
40				 USB_DEVICE_ID_MATCH_INT_SUBCLASS,
41		.bInterfaceClass = USB_CLASS_COMM,
42		.bInterfaceSubClass = USB_CDC_SUBCLASS_DMM
43	},
44	{
45		/*
46		 * Huawei E392, E398 and possibly other Qualcomm based modems
47		 * embed the Qualcomm QMI protocol inside CDC on CDC ECM like
48		 * control interfaces.  Userspace access to this is required
49		 * to configure the accompanying data interface
50		 */
51		.match_flags        = USB_DEVICE_ID_MATCH_VENDOR |
52					USB_DEVICE_ID_MATCH_INT_INFO,
53		.idVendor           = HUAWEI_VENDOR_ID,
54		.bInterfaceClass    = USB_CLASS_VENDOR_SPEC,
55		.bInterfaceSubClass = 1,
56		.bInterfaceProtocol = 9, /* NOTE: CDC ECM control interface! */
57	},
58	{
59		 /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */
60		.match_flags        = USB_DEVICE_ID_MATCH_VENDOR |
61				      USB_DEVICE_ID_MATCH_INT_INFO,
62		.idVendor           = HUAWEI_VENDOR_ID,
63		.bInterfaceClass    = USB_CLASS_VENDOR_SPEC,
64		.bInterfaceSubClass = 1,
65		.bInterfaceProtocol = 57, /* NOTE: CDC ECM control interface! */
66	},
67	{ }
68};
69
70MODULE_DEVICE_TABLE (usb, wdm_ids);
71
72#define WDM_MINOR_BASE	176
73
74
75#define WDM_IN_USE		1
76#define WDM_DISCONNECTING	2
77#define WDM_RESULT		3
78#define WDM_READ		4
79#define WDM_INT_STALL		5
80#define WDM_POLL_RUNNING	6
81#define WDM_RESPONDING		7
82#define WDM_SUSPENDING		8
83#define WDM_RESETTING		9
84
85#define WDM_MAX			16
86
87/* CDC-WMC r1.1 requires wMaxCommand to be "at least 256 decimal (0x100)" */
88#define WDM_DEFAULT_BUFSIZE	256
89
90static DEFINE_MUTEX(wdm_mutex);
91static DEFINE_SPINLOCK(wdm_device_list_lock);
92static LIST_HEAD(wdm_device_list);
93
94/* --- method tables --- */
95
96struct wdm_device {
97	u8			*inbuf; /* buffer for response */
98	u8			*outbuf; /* buffer for command */
99	u8			*sbuf; /* buffer for status */
100	u8			*ubuf; /* buffer for copy to user space */
101
102	struct urb		*command;
103	struct urb		*response;
104	struct urb		*validity;
105	struct usb_interface	*intf;
106	struct usb_ctrlrequest	*orq;
107	struct usb_ctrlrequest	*irq;
108	spinlock_t		iuspin;
109
110	unsigned long		flags;
111	u16			bufsize;
112	u16			wMaxCommand;
113	u16			wMaxPacketSize;
114	__le16			inum;
115	int			reslength;
116	int			length;
117	int			read;
118	int			count;
119	dma_addr_t		shandle;
120	dma_addr_t		ihandle;
121	struct mutex		wlock;
122	struct mutex		rlock;
123	wait_queue_head_t	wait;
124	struct work_struct	rxwork;
125	int			werr;
126	int			rerr;
127
128	struct list_head	device_list;
129	int			(*manage_power)(struct usb_interface *, int);
130};
131
132static struct usb_driver wdm_driver;
133
134/* return intfdata if we own the interface, else look up intf in the list */
135static struct wdm_device *wdm_find_device(struct usb_interface *intf)
136{
137	struct wdm_device *desc = NULL;
138
139	spin_lock(&wdm_device_list_lock);
140	list_for_each_entry(desc, &wdm_device_list, device_list)
141		if (desc->intf == intf)
142			break;
143	spin_unlock(&wdm_device_list_lock);
144
145	return desc;
146}
147
148static struct wdm_device *wdm_find_device_by_minor(int minor)
149{
150	struct wdm_device *desc = NULL;
151
152	spin_lock(&wdm_device_list_lock);
153	list_for_each_entry(desc, &wdm_device_list, device_list)
154		if (desc->intf->minor == minor)
155			break;
156	spin_unlock(&wdm_device_list_lock);
157
158	return desc;
159}
160
161/* --- callbacks --- */
162static void wdm_out_callback(struct urb *urb)
163{
164	struct wdm_device *desc;
165	desc = urb->context;
166	spin_lock(&desc->iuspin);
167	desc->werr = urb->status;
168	spin_unlock(&desc->iuspin);
169	kfree(desc->outbuf);
170	desc->outbuf = NULL;
171	clear_bit(WDM_IN_USE, &desc->flags);
172	wake_up(&desc->wait);
173}
174
175static void wdm_in_callback(struct urb *urb)
176{
177	struct wdm_device *desc = urb->context;
178	int status = urb->status;
179
180	spin_lock(&desc->iuspin);
181	clear_bit(WDM_RESPONDING, &desc->flags);
182
183	if (status) {
184		switch (status) {
185		case -ENOENT:
186			dev_dbg(&desc->intf->dev,
187				"nonzero urb status received: -ENOENT");
188			goto skip_error;
189		case -ECONNRESET:
190			dev_dbg(&desc->intf->dev,
191				"nonzero urb status received: -ECONNRESET");
192			goto skip_error;
193		case -ESHUTDOWN:
194			dev_dbg(&desc->intf->dev,
195				"nonzero urb status received: -ESHUTDOWN");
196			goto skip_error;
197		case -EPIPE:
198			dev_err(&desc->intf->dev,
199				"nonzero urb status received: -EPIPE\n");
200			break;
201		default:
202			dev_err(&desc->intf->dev,
203				"Unexpected error %d\n", status);
204			break;
205		}
206	}
207
208	desc->rerr = status;
209	desc->reslength = urb->actual_length;
210	memmove(desc->ubuf + desc->length, desc->inbuf, desc->reslength);
211	desc->length += desc->reslength;
212skip_error:
213	wake_up(&desc->wait);
214
215	set_bit(WDM_READ, &desc->flags);
216	spin_unlock(&desc->iuspin);
217}
218
219static void wdm_int_callback(struct urb *urb)
220{
221	int rv = 0;
222	int status = urb->status;
223	struct wdm_device *desc;
224	struct usb_cdc_notification *dr;
225
226	desc = urb->context;
227	dr = (struct usb_cdc_notification *)desc->sbuf;
228
229	if (status) {
230		switch (status) {
231		case -ESHUTDOWN:
232		case -ENOENT:
233		case -ECONNRESET:
234			return; /* unplug */
235		case -EPIPE:
236			set_bit(WDM_INT_STALL, &desc->flags);
237			dev_err(&desc->intf->dev, "Stall on int endpoint\n");
238			goto sw; /* halt is cleared in work */
239		default:
240			dev_err(&desc->intf->dev,
241				"nonzero urb status received: %d\n", status);
242			break;
243		}
244	}
245
246	if (urb->actual_length < sizeof(struct usb_cdc_notification)) {
247		dev_err(&desc->intf->dev, "wdm_int_callback - %d bytes\n",
248			urb->actual_length);
249		goto exit;
250	}
251
252	switch (dr->bNotificationType) {
253	case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:
254		dev_dbg(&desc->intf->dev,
255			"NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
256			dr->wIndex, dr->wLength);
257		break;
258
259	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
260
261		dev_dbg(&desc->intf->dev,
262			"NOTIFY_NETWORK_CONNECTION %s network",
263			dr->wValue ? "connected to" : "disconnected from");
264		goto exit;
265	default:
266		clear_bit(WDM_POLL_RUNNING, &desc->flags);
267		dev_err(&desc->intf->dev,
268			"unknown notification %d received: index %d len %d\n",
269			dr->bNotificationType, dr->wIndex, dr->wLength);
270		goto exit;
271	}
272
273	spin_lock(&desc->iuspin);
274	clear_bit(WDM_READ, &desc->flags);
275	set_bit(WDM_RESPONDING, &desc->flags);
276	if (!test_bit(WDM_DISCONNECTING, &desc->flags)
277		&& !test_bit(WDM_SUSPENDING, &desc->flags)) {
278		rv = usb_submit_urb(desc->response, GFP_ATOMIC);
279		dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d",
280			__func__, rv);
281	}
282	spin_unlock(&desc->iuspin);
283	if (rv < 0) {
284		clear_bit(WDM_RESPONDING, &desc->flags);
285		if (rv == -EPERM)
286			return;
287		if (rv == -ENOMEM) {
288sw:
289			rv = schedule_work(&desc->rxwork);
290			if (rv)
291				dev_err(&desc->intf->dev,
292					"Cannot schedule work\n");
293		}
294	}
295exit:
296	rv = usb_submit_urb(urb, GFP_ATOMIC);
297	if (rv)
298		dev_err(&desc->intf->dev,
299			"%s - usb_submit_urb failed with result %d\n",
300			__func__, rv);
301
302}
303
304static void kill_urbs(struct wdm_device *desc)
305{
306	/* the order here is essential */
307	usb_kill_urb(desc->command);
308	usb_kill_urb(desc->validity);
309	usb_kill_urb(desc->response);
310}
311
312static void free_urbs(struct wdm_device *desc)
313{
314	usb_free_urb(desc->validity);
315	usb_free_urb(desc->response);
316	usb_free_urb(desc->command);
317}
318
319static void cleanup(struct wdm_device *desc)
320{
321	kfree(desc->sbuf);
322	kfree(desc->inbuf);
323	kfree(desc->orq);
324	kfree(desc->irq);
325	kfree(desc->ubuf);
326	free_urbs(desc);
327	kfree(desc);
328}
329
330static ssize_t wdm_write
331(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
332{
333	u8 *buf;
334	int rv = -EMSGSIZE, r, we;
335	struct wdm_device *desc = file->private_data;
336	struct usb_ctrlrequest *req;
337
338	if (count > desc->wMaxCommand)
339		count = desc->wMaxCommand;
340
341	spin_lock_irq(&desc->iuspin);
342	we = desc->werr;
343	desc->werr = 0;
344	spin_unlock_irq(&desc->iuspin);
345	if (we < 0)
346		return -EIO;
347
348	buf = kmalloc(count, GFP_KERNEL);
349	if (!buf) {
350		rv = -ENOMEM;
351		goto outnl;
352	}
353
354	r = copy_from_user(buf, buffer, count);
355	if (r > 0) {
356		kfree(buf);
357		rv = -EFAULT;
358		goto outnl;
359	}
360
361	/* concurrent writes and disconnect */
362	r = mutex_lock_interruptible(&desc->wlock);
363	rv = -ERESTARTSYS;
364	if (r) {
365		kfree(buf);
366		goto outnl;
367	}
368
369	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
370		kfree(buf);
371		rv = -ENODEV;
372		goto outnp;
373	}
374
375	r = usb_autopm_get_interface(desc->intf);
376	if (r < 0) {
377		kfree(buf);
378		goto outnp;
379	}
380
381	if (!(file->f_flags & O_NONBLOCK))
382		r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
383								&desc->flags));
384	else
385		if (test_bit(WDM_IN_USE, &desc->flags))
386			r = -EAGAIN;
387
388	if (test_bit(WDM_RESETTING, &desc->flags))
389		r = -EIO;
390
391	if (r < 0) {
392		kfree(buf);
393		goto out;
394	}
395
396	req = desc->orq;
397	usb_fill_control_urb(
398		desc->command,
399		interface_to_usbdev(desc->intf),
400		/* using common endpoint 0 */
401		usb_sndctrlpipe(interface_to_usbdev(desc->intf), 0),
402		(unsigned char *)req,
403		buf,
404		count,
405		wdm_out_callback,
406		desc
407	);
408
409	req->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
410			     USB_RECIP_INTERFACE);
411	req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
412	req->wValue = 0;
413	req->wIndex = desc->inum;
414	req->wLength = cpu_to_le16(count);
415	set_bit(WDM_IN_USE, &desc->flags);
416	desc->outbuf = buf;
417
418	rv = usb_submit_urb(desc->command, GFP_KERNEL);
419	if (rv < 0) {
420		kfree(buf);
421		desc->outbuf = NULL;
422		clear_bit(WDM_IN_USE, &desc->flags);
423		dev_err(&desc->intf->dev, "Tx URB error: %d\n", rv);
424	} else {
425		dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
426			req->wIndex);
427	}
428out:
429	usb_autopm_put_interface(desc->intf);
430outnp:
431	mutex_unlock(&desc->wlock);
432outnl:
433	return rv < 0 ? rv : count;
434}
435
436static ssize_t wdm_read
437(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
438{
439	int rv, cntr;
440	int i = 0;
441	struct wdm_device *desc = file->private_data;
442
443
444	rv = mutex_lock_interruptible(&desc->rlock); /*concurrent reads */
445	if (rv < 0)
446		return -ERESTARTSYS;
447
448	cntr = ACCESS_ONCE(desc->length);
449	if (cntr == 0) {
450		desc->read = 0;
451retry:
452		if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
453			rv = -ENODEV;
454			goto err;
455		}
456		i++;
457		if (file->f_flags & O_NONBLOCK) {
458			if (!test_bit(WDM_READ, &desc->flags)) {
459				rv = cntr ? cntr : -EAGAIN;
460				goto err;
461			}
462			rv = 0;
463		} else {
464			rv = wait_event_interruptible(desc->wait,
465				test_bit(WDM_READ, &desc->flags));
466		}
467
468		/* may have happened while we slept */
469		if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
470			rv = -ENODEV;
471			goto err;
472		}
473		if (test_bit(WDM_RESETTING, &desc->flags)) {
474			rv = -EIO;
475			goto err;
476		}
477		usb_mark_last_busy(interface_to_usbdev(desc->intf));
478		if (rv < 0) {
479			rv = -ERESTARTSYS;
480			goto err;
481		}
482
483		spin_lock_irq(&desc->iuspin);
484
485		if (desc->rerr) { /* read completed, error happened */
486			desc->rerr = 0;
487			spin_unlock_irq(&desc->iuspin);
488			rv = -EIO;
489			goto err;
490		}
491		/*
492		 * recheck whether we've lost the race
493		 * against the completion handler
494		 */
495		if (!test_bit(WDM_READ, &desc->flags)) { /* lost race */
496			spin_unlock_irq(&desc->iuspin);
497			goto retry;
498		}
499		if (!desc->reslength) { /* zero length read */
500			dev_dbg(&desc->intf->dev, "%s: zero length - clearing WDM_READ\n", __func__);
501			clear_bit(WDM_READ, &desc->flags);
502			spin_unlock_irq(&desc->iuspin);
503			goto retry;
504		}
505		cntr = desc->length;
506		spin_unlock_irq(&desc->iuspin);
507	}
508
509	if (cntr > count)
510		cntr = count;
511	rv = copy_to_user(buffer, desc->ubuf, cntr);
512	if (rv > 0) {
513		rv = -EFAULT;
514		goto err;
515	}
516
517	spin_lock_irq(&desc->iuspin);
518
519	for (i = 0; i < desc->length - cntr; i++)
520		desc->ubuf[i] = desc->ubuf[i + cntr];
521
522	desc->length -= cntr;
523	/* in case we had outstanding data */
524	if (!desc->length)
525		clear_bit(WDM_READ, &desc->flags);
526
527	spin_unlock_irq(&desc->iuspin);
528
529	rv = cntr;
530
531err:
532	mutex_unlock(&desc->rlock);
533	return rv;
534}
535
536static int wdm_flush(struct file *file, fl_owner_t id)
537{
538	struct wdm_device *desc = file->private_data;
539
540	wait_event(desc->wait, !test_bit(WDM_IN_USE, &desc->flags));
541
542	/* cannot dereference desc->intf if WDM_DISCONNECTING */
543	if (desc->werr < 0 && !test_bit(WDM_DISCONNECTING, &desc->flags))
544		dev_err(&desc->intf->dev, "Error in flush path: %d\n",
545			desc->werr);
546
547	return usb_translate_errors(desc->werr);
548}
549
550static unsigned int wdm_poll(struct file *file, struct poll_table_struct *wait)
551{
552	struct wdm_device *desc = file->private_data;
553	unsigned long flags;
554	unsigned int mask = 0;
555
556	spin_lock_irqsave(&desc->iuspin, flags);
557	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
558		mask = POLLHUP | POLLERR;
559		spin_unlock_irqrestore(&desc->iuspin, flags);
560		goto desc_out;
561	}
562	if (test_bit(WDM_READ, &desc->flags))
563		mask = POLLIN | POLLRDNORM;
564	if (desc->rerr || desc->werr)
565		mask |= POLLERR;
566	if (!test_bit(WDM_IN_USE, &desc->flags))
567		mask |= POLLOUT | POLLWRNORM;
568	spin_unlock_irqrestore(&desc->iuspin, flags);
569
570	poll_wait(file, &desc->wait, wait);
571
572desc_out:
573	return mask;
574}
575
576static int wdm_open(struct inode *inode, struct file *file)
577{
578	int minor = iminor(inode);
579	int rv = -ENODEV;
580	struct usb_interface *intf;
581	struct wdm_device *desc;
582
583	mutex_lock(&wdm_mutex);
584	desc = wdm_find_device_by_minor(minor);
585	if (!desc)
586		goto out;
587
588	intf = desc->intf;
589	if (test_bit(WDM_DISCONNECTING, &desc->flags))
590		goto out;
591	file->private_data = desc;
592
593	rv = usb_autopm_get_interface(desc->intf);
594	if (rv < 0) {
595		dev_err(&desc->intf->dev, "Error autopm - %d\n", rv);
596		goto out;
597	}
598
599	/* using write lock to protect desc->count */
600	mutex_lock(&desc->wlock);
601	if (!desc->count++) {
602		desc->werr = 0;
603		desc->rerr = 0;
604		rv = usb_submit_urb(desc->validity, GFP_KERNEL);
605		if (rv < 0) {
606			desc->count--;
607			dev_err(&desc->intf->dev,
608				"Error submitting int urb - %d\n", rv);
609		}
610	} else {
611		rv = 0;
612	}
613	mutex_unlock(&desc->wlock);
614	if (desc->count == 1)
615		desc->manage_power(intf, 1);
616	usb_autopm_put_interface(desc->intf);
617out:
618	mutex_unlock(&wdm_mutex);
619	return rv;
620}
621
622static int wdm_release(struct inode *inode, struct file *file)
623{
624	struct wdm_device *desc = file->private_data;
625
626	mutex_lock(&wdm_mutex);
627
628	/* using write lock to protect desc->count */
629	mutex_lock(&desc->wlock);
630	desc->count--;
631	mutex_unlock(&desc->wlock);
632
633	if (!desc->count) {
634		if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
635			dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
636			kill_urbs(desc);
637			desc->manage_power(desc->intf, 0);
638		} else {
639			/* must avoid dev_printk here as desc->intf is invalid */
640			pr_debug(KBUILD_MODNAME " %s: device gone - cleaning up\n", __func__);
641			cleanup(desc);
642		}
643	}
644	mutex_unlock(&wdm_mutex);
645	return 0;
646}
647
648static const struct file_operations wdm_fops = {
649	.owner =	THIS_MODULE,
650	.read =		wdm_read,
651	.write =	wdm_write,
652	.open =		wdm_open,
653	.flush =	wdm_flush,
654	.release =	wdm_release,
655	.poll =		wdm_poll,
656	.llseek =	noop_llseek,
657};
658
659static struct usb_class_driver wdm_class = {
660	.name =		"cdc-wdm%d",
661	.fops =		&wdm_fops,
662	.minor_base =	WDM_MINOR_BASE,
663};
664
665/* --- error handling --- */
666static void wdm_rxwork(struct work_struct *work)
667{
668	struct wdm_device *desc = container_of(work, struct wdm_device, rxwork);
669	unsigned long flags;
670	int rv;
671
672	spin_lock_irqsave(&desc->iuspin, flags);
673	if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
674		spin_unlock_irqrestore(&desc->iuspin, flags);
675	} else {
676		spin_unlock_irqrestore(&desc->iuspin, flags);
677		rv = usb_submit_urb(desc->response, GFP_KERNEL);
678		if (rv < 0 && rv != -EPERM) {
679			spin_lock_irqsave(&desc->iuspin, flags);
680			if (!test_bit(WDM_DISCONNECTING, &desc->flags))
681				schedule_work(&desc->rxwork);
682			spin_unlock_irqrestore(&desc->iuspin, flags);
683		}
684	}
685}
686
687/* --- hotplug --- */
688
689static int wdm_create(struct usb_interface *intf, struct usb_endpoint_descriptor *ep,
690		u16 bufsize, int (*manage_power)(struct usb_interface *, int))
691{
692	int rv = -ENOMEM;
693	struct wdm_device *desc;
694
695	desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);
696	if (!desc)
697		goto out;
698	INIT_LIST_HEAD(&desc->device_list);
699	mutex_init(&desc->rlock);
700	mutex_init(&desc->wlock);
701	spin_lock_init(&desc->iuspin);
702	init_waitqueue_head(&desc->wait);
703	desc->wMaxCommand = bufsize;
704	/* this will be expanded and needed in hardware endianness */
705	desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);
706	desc->intf = intf;
707	INIT_WORK(&desc->rxwork, wdm_rxwork);
708
709	rv = -EINVAL;
710	if (!usb_endpoint_is_int_in(ep))
711		goto err;
712
713	desc->wMaxPacketSize = usb_endpoint_maxp(ep);
714
715	desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
716	if (!desc->orq)
717		goto err;
718	desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
719	if (!desc->irq)
720		goto err;
721
722	desc->validity = usb_alloc_urb(0, GFP_KERNEL);
723	if (!desc->validity)
724		goto err;
725
726	desc->response = usb_alloc_urb(0, GFP_KERNEL);
727	if (!desc->response)
728		goto err;
729
730	desc->command = usb_alloc_urb(0, GFP_KERNEL);
731	if (!desc->command)
732		goto err;
733
734	desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
735	if (!desc->ubuf)
736		goto err;
737
738	desc->sbuf = kmalloc(desc->wMaxPacketSize, GFP_KERNEL);
739	if (!desc->sbuf)
740		goto err;
741
742	desc->inbuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);
743	if (!desc->inbuf)
744		goto err;
745
746	usb_fill_int_urb(
747		desc->validity,
748		interface_to_usbdev(intf),
749		usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),
750		desc->sbuf,
751		desc->wMaxPacketSize,
752		wdm_int_callback,
753		desc,
754		ep->bInterval
755	);
756
757	desc->irq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
758	desc->irq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
759	desc->irq->wValue = 0;
760	desc->irq->wIndex = desc->inum;
761	desc->irq->wLength = cpu_to_le16(desc->wMaxCommand);
762
763	usb_fill_control_urb(
764		desc->response,
765		interface_to_usbdev(intf),
766		/* using common endpoint 0 */
767		usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
768		(unsigned char *)desc->irq,
769		desc->inbuf,
770		desc->wMaxCommand,
771		wdm_in_callback,
772		desc
773	);
774
775	desc->manage_power = manage_power;
776
777	spin_lock(&wdm_device_list_lock);
778	list_add(&desc->device_list, &wdm_device_list);
779	spin_unlock(&wdm_device_list_lock);
780
781	rv = usb_register_dev(intf, &wdm_class);
782	if (rv < 0)
783		goto err;
784	else
785		dev_info(&intf->dev, "%s: USB WDM device\n", dev_name(intf->usb_dev));
786out:
787	return rv;
788err:
789	spin_lock(&wdm_device_list_lock);
790	list_del(&desc->device_list);
791	spin_unlock(&wdm_device_list_lock);
792	cleanup(desc);
793	return rv;
794}
795
796static int wdm_manage_power(struct usb_interface *intf, int on)
797{
798	/* need autopm_get/put here to ensure the usbcore sees the new value */
799	int rv = usb_autopm_get_interface(intf);
800	if (rv < 0)
801		goto err;
802
803	intf->needs_remote_wakeup = on;
804	usb_autopm_put_interface(intf);
805err:
806	return rv;
807}
808
809static int wdm_probe(struct usb_interface *intf, const struct usb_device_id *id)
810{
811	int rv = -EINVAL;
812	struct usb_host_interface *iface;
813	struct usb_endpoint_descriptor *ep;
814	struct usb_cdc_dmm_desc *dmhd;
815	u8 *buffer = intf->altsetting->extra;
816	int buflen = intf->altsetting->extralen;
817	u16 maxcom = WDM_DEFAULT_BUFSIZE;
818
819	if (!buffer)
820		goto err;
821	while (buflen > 2) {
822		if (buffer[1] != USB_DT_CS_INTERFACE) {
823			dev_err(&intf->dev, "skipping garbage\n");
824			goto next_desc;
825		}
826
827		switch (buffer[2]) {
828		case USB_CDC_HEADER_TYPE:
829			break;
830		case USB_CDC_DMM_TYPE:
831			dmhd = (struct usb_cdc_dmm_desc *)buffer;
832			maxcom = le16_to_cpu(dmhd->wMaxCommand);
833			dev_dbg(&intf->dev,
834				"Finding maximum buffer length: %d", maxcom);
835			break;
836		default:
837			dev_err(&intf->dev,
838				"Ignoring extra header, type %d, length %d\n",
839				buffer[2], buffer[0]);
840			break;
841		}
842next_desc:
843		buflen -= buffer[0];
844		buffer += buffer[0];
845	}
846
847	iface = intf->cur_altsetting;
848	if (iface->desc.bNumEndpoints != 1)
849		goto err;
850	ep = &iface->endpoint[0].desc;
851
852	rv = wdm_create(intf, ep, maxcom, &wdm_manage_power);
853
854err:
855	return rv;
856}
857
858/**
859 * usb_cdc_wdm_register - register a WDM subdriver
860 * @intf: usb interface the subdriver will associate with
861 * @ep: interrupt endpoint to monitor for notifications
862 * @bufsize: maximum message size to support for read/write
863 *
864 * Create WDM usb class character device and associate it with intf
865 * without binding, allowing another driver to manage the interface.
866 *
867 * The subdriver will manage the given interrupt endpoint exclusively
868 * and will issue control requests referring to the given intf. It
869 * will otherwise avoid interferring, and in particular not do
870 * usb_set_intfdata/usb_get_intfdata on intf.
871 *
872 * The return value is a pointer to the subdriver's struct usb_driver.
873 * The registering driver is responsible for calling this subdriver's
874 * disconnect, suspend, resume, pre_reset and post_reset methods from
875 * its own.
876 */
877struct usb_driver *usb_cdc_wdm_register(struct usb_interface *intf,
878					struct usb_endpoint_descriptor *ep,
879					int bufsize,
880					int (*manage_power)(struct usb_interface *, int))
881{
882	int rv = -EINVAL;
883
884	rv = wdm_create(intf, ep, bufsize, manage_power);
885	if (rv < 0)
886		goto err;
887
888	return &wdm_driver;
889err:
890	return ERR_PTR(rv);
891}
892EXPORT_SYMBOL(usb_cdc_wdm_register);
893
894static void wdm_disconnect(struct usb_interface *intf)
895{
896	struct wdm_device *desc;
897	unsigned long flags;
898
899	usb_deregister_dev(intf, &wdm_class);
900	desc = wdm_find_device(intf);
901	mutex_lock(&wdm_mutex);
902
903	/* the spinlock makes sure no new urbs are generated in the callbacks */
904	spin_lock_irqsave(&desc->iuspin, flags);
905	set_bit(WDM_DISCONNECTING, &desc->flags);
906	set_bit(WDM_READ, &desc->flags);
907	/* to terminate pending flushes */
908	clear_bit(WDM_IN_USE, &desc->flags);
909	spin_unlock_irqrestore(&desc->iuspin, flags);
910	wake_up_all(&desc->wait);
911	mutex_lock(&desc->rlock);
912	mutex_lock(&desc->wlock);
913	kill_urbs(desc);
914	cancel_work_sync(&desc->rxwork);
915	mutex_unlock(&desc->wlock);
916	mutex_unlock(&desc->rlock);
917
918	/* the desc->intf pointer used as list key is now invalid */
919	spin_lock(&wdm_device_list_lock);
920	list_del(&desc->device_list);
921	spin_unlock(&wdm_device_list_lock);
922
923	if (!desc->count)
924		cleanup(desc);
925	mutex_unlock(&wdm_mutex);
926}
927
928#ifdef CONFIG_PM
929static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
930{
931	struct wdm_device *desc = wdm_find_device(intf);
932	int rv = 0;
933
934	dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
935
936	/* if this is an autosuspend the caller does the locking */
937	if (!PMSG_IS_AUTO(message)) {
938		mutex_lock(&desc->rlock);
939		mutex_lock(&desc->wlock);
940	}
941	spin_lock_irq(&desc->iuspin);
942
943	if (PMSG_IS_AUTO(message) &&
944			(test_bit(WDM_IN_USE, &desc->flags)
945			|| test_bit(WDM_RESPONDING, &desc->flags))) {
946		spin_unlock_irq(&desc->iuspin);
947		rv = -EBUSY;
948	} else {
949
950		set_bit(WDM_SUSPENDING, &desc->flags);
951		spin_unlock_irq(&desc->iuspin);
952		/* callback submits work - order is essential */
953		kill_urbs(desc);
954		cancel_work_sync(&desc->rxwork);
955	}
956	if (!PMSG_IS_AUTO(message)) {
957		mutex_unlock(&desc->wlock);
958		mutex_unlock(&desc->rlock);
959	}
960
961	return rv;
962}
963#endif
964
965static int recover_from_urb_loss(struct wdm_device *desc)
966{
967	int rv = 0;
968
969	if (desc->count) {
970		rv = usb_submit_urb(desc->validity, GFP_NOIO);
971		if (rv < 0)
972			dev_err(&desc->intf->dev,
973				"Error resume submitting int urb - %d\n", rv);
974	}
975	return rv;
976}
977
978#ifdef CONFIG_PM
979static int wdm_resume(struct usb_interface *intf)
980{
981	struct wdm_device *desc = wdm_find_device(intf);
982	int rv;
983
984	dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
985
986	clear_bit(WDM_SUSPENDING, &desc->flags);
987	rv = recover_from_urb_loss(desc);
988
989	return rv;
990}
991#endif
992
993static int wdm_pre_reset(struct usb_interface *intf)
994{
995	struct wdm_device *desc = wdm_find_device(intf);
996
997	/*
998	 * we notify everybody using poll of
999	 * an exceptional situation
1000	 * must be done before recovery lest a spontaneous
1001	 * message from the device is lost
1002	 */
1003	spin_lock_irq(&desc->iuspin);
1004	set_bit(WDM_RESETTING, &desc->flags);	/* inform read/write */
1005	set_bit(WDM_READ, &desc->flags);	/* unblock read */
1006	clear_bit(WDM_IN_USE, &desc->flags);	/* unblock write */
1007	desc->rerr = -EINTR;
1008	spin_unlock_irq(&desc->iuspin);
1009	wake_up_all(&desc->wait);
1010	mutex_lock(&desc->rlock);
1011	mutex_lock(&desc->wlock);
1012	kill_urbs(desc);
1013	cancel_work_sync(&desc->rxwork);
1014	return 0;
1015}
1016
1017static int wdm_post_reset(struct usb_interface *intf)
1018{
1019	struct wdm_device *desc = wdm_find_device(intf);
1020	int rv;
1021
1022	clear_bit(WDM_RESETTING, &desc->flags);
1023	rv = recover_from_urb_loss(desc);
1024	mutex_unlock(&desc->wlock);
1025	mutex_unlock(&desc->rlock);
1026	return 0;
1027}
1028
1029static struct usb_driver wdm_driver = {
1030	.name =		"cdc_wdm",
1031	.probe =	wdm_probe,
1032	.disconnect =	wdm_disconnect,
1033#ifdef CONFIG_PM
1034	.suspend =	wdm_suspend,
1035	.resume =	wdm_resume,
1036	.reset_resume =	wdm_resume,
1037#endif
1038	.pre_reset =	wdm_pre_reset,
1039	.post_reset =	wdm_post_reset,
1040	.id_table =	wdm_ids,
1041	.supports_autosuspend = 1,
1042};
1043
1044module_usb_driver(wdm_driver);
1045
1046MODULE_AUTHOR(DRIVER_AUTHOR);
1047MODULE_DESCRIPTION(DRIVER_DESC);
1048MODULE_LICENSE("GPL");
1049