• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2   * cdc-acm.c
3   *
4   * Copyright (c) 1999 Armin Fuerst	<fuerst@in.tum.de>
5   * Copyright (c) 1999 Pavel Machek	<pavel@ucw.cz>
6   * Copyright (c) 1999 Johannes Erdfelt	<johannes@erdfelt.com>
7   * Copyright (c) 2000 Vojtech Pavlik	<vojtech@suse.cz>
8   * Copyright (c) 2004 Oliver Neukum	<oliver@neukum.name>
9   * Copyright (c) 2005 David Kubicek	<dave@awk.cz>
10   * Copyright (c) 2011 Johan Hovold	<jhovold@gmail.com>
11   *
12   * USB Abstract Control Model driver for USB modems and ISDN adapters
13   *
14   * Sponsored by SuSE
15   *
16   * This program is free software; you can redistribute it and/or modify
17   * it under the terms of the GNU General Public License as published by
18   * the Free Software Foundation; either version 2 of the License, or
19   * (at your option) any later version.
20   *
21   * This program is distributed in the hope that it will be useful,
22   * but WITHOUT ANY WARRANTY; without even the implied warranty of
23   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24   * GNU General Public License for more details.
25   *
26   * You should have received a copy of the GNU General Public License
27   * along with this program; if not, write to the Free Software
28   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29   */
30  
31  #undef DEBUG
32  #undef VERBOSE_DEBUG
33  
34  #include <linux/kernel.h>
35  #include <linux/errno.h>
36  #include <linux/init.h>
37  #include <linux/slab.h>
38  #include <linux/tty.h>
39  #include <linux/serial.h>
40  #include <linux/tty_driver.h>
41  #include <linux/tty_flip.h>
42  #include <linux/serial.h>
43  #include <linux/module.h>
44  #include <linux/mutex.h>
45  #include <linux/uaccess.h>
46  #include <linux/usb.h>
47  #include <linux/usb/cdc.h>
48  #include <asm/byteorder.h>
49  #include <asm/unaligned.h>
50  #include <linux/list.h>
51  
52  #include "cdc-acm.h"
53  
54  
55  #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
56  #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
57  
58  static struct usb_driver acm_driver;
59  static struct tty_driver *acm_tty_driver;
60  static struct acm *acm_table[ACM_TTY_MINORS];
61  
62  static DEFINE_MUTEX(acm_table_lock);
63  
64  /*
65   * acm_table accessors
66   */
67  
68  /*
69   * Look up an ACM structure by index. If found and not disconnected, increment
70   * its refcount and return it with its mutex held.
71   */
acm_get_by_index(unsigned index)72  static struct acm *acm_get_by_index(unsigned index)
73  {
74  	struct acm *acm;
75  
76  	mutex_lock(&acm_table_lock);
77  	acm = acm_table[index];
78  	if (acm) {
79  		mutex_lock(&acm->mutex);
80  		if (acm->disconnected) {
81  			mutex_unlock(&acm->mutex);
82  			acm = NULL;
83  		} else {
84  			tty_port_get(&acm->port);
85  			mutex_unlock(&acm->mutex);
86  		}
87  	}
88  	mutex_unlock(&acm_table_lock);
89  	return acm;
90  }
91  
92  /*
93   * Try to find an available minor number and if found, associate it with 'acm'.
94   */
acm_alloc_minor(struct acm * acm)95  static int acm_alloc_minor(struct acm *acm)
96  {
97  	int minor;
98  
99  	mutex_lock(&acm_table_lock);
100  	for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
101  		if (!acm_table[minor]) {
102  			acm_table[minor] = acm;
103  			break;
104  		}
105  	}
106  	mutex_unlock(&acm_table_lock);
107  
108  	return minor;
109  }
110  
111  /* Release the minor number associated with 'acm'.  */
acm_release_minor(struct acm * acm)112  static void acm_release_minor(struct acm *acm)
113  {
114  	mutex_lock(&acm_table_lock);
115  	acm_table[acm->minor] = NULL;
116  	mutex_unlock(&acm_table_lock);
117  }
118  
119  /*
120   * Functions for ACM control messages.
121   */
122  
acm_ctrl_msg(struct acm * acm,int request,int value,void * buf,int len)123  static int acm_ctrl_msg(struct acm *acm, int request, int value,
124  							void *buf, int len)
125  {
126  	int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
127  		request, USB_RT_ACM, value,
128  		acm->control->altsetting[0].desc.bInterfaceNumber,
129  		buf, len, 5000);
130  	dev_dbg(&acm->control->dev,
131  			"%s - rq 0x%02x, val %#x, len %#x, result %d\n",
132  			__func__, request, value, len, retval);
133  	return retval < 0 ? retval : 0;
134  }
135  
136  /* devices aren't required to support these requests.
137   * the cdc acm descriptor tells whether they do...
138   */
139  #define acm_set_control(acm, control) \
140  	acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
141  #define acm_set_line(acm, line) \
142  	acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
143  #define acm_send_break(acm, ms) \
144  	acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
145  
146  /*
147   * Write buffer management.
148   * All of these assume proper locks taken by the caller.
149   */
150  
acm_wb_alloc(struct acm * acm)151  static int acm_wb_alloc(struct acm *acm)
152  {
153  	int i, wbn;
154  	struct acm_wb *wb;
155  
156  	wbn = 0;
157  	i = 0;
158  	for (;;) {
159  		wb = &acm->wb[wbn];
160  		if (!wb->use) {
161  			wb->use = 1;
162  			return wbn;
163  		}
164  		wbn = (wbn + 1) % ACM_NW;
165  		if (++i >= ACM_NW)
166  			return -1;
167  	}
168  }
169  
acm_wb_is_avail(struct acm * acm)170  static int acm_wb_is_avail(struct acm *acm)
171  {
172  	int i, n;
173  	unsigned long flags;
174  
175  	n = ACM_NW;
176  	spin_lock_irqsave(&acm->write_lock, flags);
177  	for (i = 0; i < ACM_NW; i++)
178  		n -= acm->wb[i].use;
179  	spin_unlock_irqrestore(&acm->write_lock, flags);
180  	return n;
181  }
182  
183  /*
184   * Finish write. Caller must hold acm->write_lock
185   */
acm_write_done(struct acm * acm,struct acm_wb * wb)186  static void acm_write_done(struct acm *acm, struct acm_wb *wb)
187  {
188  	wb->use = 0;
189  	acm->transmitting--;
190  	usb_autopm_put_interface_async(acm->control);
191  }
192  
193  /*
194   * Poke write.
195   *
196   * the caller is responsible for locking
197   */
198  
acm_start_wb(struct acm * acm,struct acm_wb * wb)199  static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
200  {
201  	int rc;
202  
203  	acm->transmitting++;
204  
205  	wb->urb->transfer_buffer = wb->buf;
206  	wb->urb->transfer_dma = wb->dmah;
207  	wb->urb->transfer_buffer_length = wb->len;
208  	wb->urb->dev = acm->dev;
209  
210  	rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
211  	if (rc < 0) {
212  		dev_err(&acm->data->dev,
213  			"%s - usb_submit_urb(write bulk) failed: %d\n",
214  			__func__, rc);
215  		acm_write_done(acm, wb);
216  	}
217  	return rc;
218  }
219  
acm_write_start(struct acm * acm,int wbn)220  static int acm_write_start(struct acm *acm, int wbn)
221  {
222  	unsigned long flags;
223  	struct acm_wb *wb = &acm->wb[wbn];
224  	int rc;
225  
226  	spin_lock_irqsave(&acm->write_lock, flags);
227  	if (!acm->dev) {
228  		wb->use = 0;
229  		spin_unlock_irqrestore(&acm->write_lock, flags);
230  		return -ENODEV;
231  	}
232  
233  	dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
234  							acm->susp_count);
235  	usb_autopm_get_interface_async(acm->control);
236  	if (acm->susp_count) {
237  		if (!acm->delayed_wb)
238  			acm->delayed_wb = wb;
239  		else
240  			usb_autopm_put_interface_async(acm->control);
241  		spin_unlock_irqrestore(&acm->write_lock, flags);
242  		return 0;	/* A white lie */
243  	}
244  	usb_mark_last_busy(acm->dev);
245  
246  	rc = acm_start_wb(acm, wb);
247  	spin_unlock_irqrestore(&acm->write_lock, flags);
248  
249  	return rc;
250  
251  }
252  /*
253   * attributes exported through sysfs
254   */
show_caps(struct device * dev,struct device_attribute * attr,char * buf)255  static ssize_t show_caps
256  (struct device *dev, struct device_attribute *attr, char *buf)
257  {
258  	struct usb_interface *intf = to_usb_interface(dev);
259  	struct acm *acm = usb_get_intfdata(intf);
260  
261  	return sprintf(buf, "%d", acm->ctrl_caps);
262  }
263  static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
264  
show_country_codes(struct device * dev,struct device_attribute * attr,char * buf)265  static ssize_t show_country_codes
266  (struct device *dev, struct device_attribute *attr, char *buf)
267  {
268  	struct usb_interface *intf = to_usb_interface(dev);
269  	struct acm *acm = usb_get_intfdata(intf);
270  
271  	memcpy(buf, acm->country_codes, acm->country_code_size);
272  	return acm->country_code_size;
273  }
274  
275  static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
276  
show_country_rel_date(struct device * dev,struct device_attribute * attr,char * buf)277  static ssize_t show_country_rel_date
278  (struct device *dev, struct device_attribute *attr, char *buf)
279  {
280  	struct usb_interface *intf = to_usb_interface(dev);
281  	struct acm *acm = usb_get_intfdata(intf);
282  
283  	return sprintf(buf, "%d", acm->country_rel_date);
284  }
285  
286  static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
287  /*
288   * Interrupt handlers for various ACM device responses
289   */
290  
291  /* control interface reports status changes with "interrupt" transfers */
acm_ctrl_irq(struct urb * urb)292  static void acm_ctrl_irq(struct urb *urb)
293  {
294  	struct acm *acm = urb->context;
295  	struct usb_cdc_notification *dr = urb->transfer_buffer;
296  	struct tty_struct *tty;
297  	unsigned char *data;
298  	int newctrl;
299  	int retval;
300  	int status = urb->status;
301  
302  	switch (status) {
303  	case 0:
304  		/* success */
305  		break;
306  	case -ECONNRESET:
307  	case -ENOENT:
308  	case -ESHUTDOWN:
309  		/* this urb is terminated, clean up */
310  		dev_dbg(&acm->control->dev,
311  				"%s - urb shutting down with status: %d\n",
312  				__func__, status);
313  		return;
314  	default:
315  		dev_dbg(&acm->control->dev,
316  				"%s - nonzero urb status received: %d\n",
317  				__func__, status);
318  		goto exit;
319  	}
320  
321  	usb_mark_last_busy(acm->dev);
322  
323  	data = (unsigned char *)(dr + 1);
324  	switch (dr->bNotificationType) {
325  	case USB_CDC_NOTIFY_NETWORK_CONNECTION:
326  		dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
327  							__func__, dr->wValue);
328  		break;
329  
330  	case USB_CDC_NOTIFY_SERIAL_STATE:
331  		tty = tty_port_tty_get(&acm->port);
332  		newctrl = get_unaligned_le16(data);
333  
334  		if (tty) {
335  			if (!acm->clocal &&
336  				(acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
337  				dev_dbg(&acm->control->dev,
338  					"%s - calling hangup\n", __func__);
339  				tty_hangup(tty);
340  			}
341  			tty_kref_put(tty);
342  		}
343  
344  		acm->ctrlin = newctrl;
345  
346  		dev_dbg(&acm->control->dev,
347  			"%s - input control lines: dcd%c dsr%c break%c "
348  			"ring%c framing%c parity%c overrun%c\n",
349  			__func__,
350  			acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
351  			acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
352  			acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
353  			acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
354  			acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
355  			acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
356  			acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
357  			break;
358  
359  	default:
360  		dev_dbg(&acm->control->dev,
361  			"%s - unknown notification %d received: index %d "
362  			"len %d data0 %d data1 %d\n",
363  			__func__,
364  			dr->bNotificationType, dr->wIndex,
365  			dr->wLength, data[0], data[1]);
366  		break;
367  	}
368  exit:
369  	retval = usb_submit_urb(urb, GFP_ATOMIC);
370  	if (retval)
371  		dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
372  							__func__, retval);
373  }
374  
acm_submit_read_urb(struct acm * acm,int index,gfp_t mem_flags)375  static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
376  {
377  	int res;
378  
379  	if (!test_and_clear_bit(index, &acm->read_urbs_free))
380  		return 0;
381  
382  	dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
383  
384  	res = usb_submit_urb(acm->read_urbs[index], mem_flags);
385  	if (res) {
386  		if (res != -EPERM) {
387  			dev_err(&acm->data->dev,
388  					"%s - usb_submit_urb failed: %d\n",
389  					__func__, res);
390  		}
391  		set_bit(index, &acm->read_urbs_free);
392  		return res;
393  	}
394  
395  	return 0;
396  }
397  
acm_submit_read_urbs(struct acm * acm,gfp_t mem_flags)398  static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
399  {
400  	int res;
401  	int i;
402  
403  	for (i = 0; i < acm->rx_buflimit; ++i) {
404  		res = acm_submit_read_urb(acm, i, mem_flags);
405  		if (res)
406  			return res;
407  	}
408  
409  	return 0;
410  }
411  
acm_process_read_urb(struct acm * acm,struct urb * urb)412  static void acm_process_read_urb(struct acm *acm, struct urb *urb)
413  {
414  	struct tty_struct *tty;
415  
416  	if (!urb->actual_length)
417  		return;
418  
419  	tty = tty_port_tty_get(&acm->port);
420  	if (!tty)
421  		return;
422  
423  	tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
424  	tty_flip_buffer_push(tty);
425  
426  	tty_kref_put(tty);
427  }
428  
acm_read_bulk_callback(struct urb * urb)429  static void acm_read_bulk_callback(struct urb *urb)
430  {
431  	struct acm_rb *rb = urb->context;
432  	struct acm *acm = rb->instance;
433  	unsigned long flags;
434  
435  	dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
436  					rb->index, urb->actual_length);
437  	set_bit(rb->index, &acm->read_urbs_free);
438  
439  	if (!acm->dev) {
440  		dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
441  		return;
442  	}
443  	usb_mark_last_busy(acm->dev);
444  
445  	if (urb->status) {
446  		dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
447  							__func__, urb->status);
448  		return;
449  	}
450  	acm_process_read_urb(acm, urb);
451  
452  	/* throttle device if requested by tty */
453  	spin_lock_irqsave(&acm->read_lock, flags);
454  	acm->throttled = acm->throttle_req;
455  	if (!acm->throttled && !acm->susp_count) {
456  		spin_unlock_irqrestore(&acm->read_lock, flags);
457  		acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
458  	} else {
459  		spin_unlock_irqrestore(&acm->read_lock, flags);
460  	}
461  }
462  
463  /* data interface wrote those outgoing bytes */
acm_write_bulk(struct urb * urb)464  static void acm_write_bulk(struct urb *urb)
465  {
466  	struct acm_wb *wb = urb->context;
467  	struct acm *acm = wb->instance;
468  	unsigned long flags;
469  
470  	if (urb->status	|| (urb->actual_length != urb->transfer_buffer_length))
471  		dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
472  			__func__,
473  			urb->actual_length,
474  			urb->transfer_buffer_length,
475  			urb->status);
476  
477  	spin_lock_irqsave(&acm->write_lock, flags);
478  	acm_write_done(acm, wb);
479  	spin_unlock_irqrestore(&acm->write_lock, flags);
480  	schedule_work(&acm->work);
481  }
482  
acm_softint(struct work_struct * work)483  static void acm_softint(struct work_struct *work)
484  {
485  	struct acm *acm = container_of(work, struct acm, work);
486  	struct tty_struct *tty;
487  
488  	dev_vdbg(&acm->data->dev, "%s\n", __func__);
489  
490  	tty = tty_port_tty_get(&acm->port);
491  	if (!tty)
492  		return;
493  	tty_wakeup(tty);
494  	tty_kref_put(tty);
495  }
496  
497  /*
498   * TTY handlers
499   */
500  
acm_tty_install(struct tty_driver * driver,struct tty_struct * tty)501  static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
502  {
503  	struct acm *acm;
504  	int retval;
505  
506  	dev_dbg(tty->dev, "%s\n", __func__);
507  
508  	acm = acm_get_by_index(tty->index);
509  	if (!acm)
510  		return -ENODEV;
511  
512  	retval = tty_standard_install(driver, tty);
513  	if (retval)
514  		goto error_init_termios;
515  
516  	tty->driver_data = acm;
517  
518  	return 0;
519  
520  error_init_termios:
521  	tty_port_put(&acm->port);
522  	return retval;
523  }
524  
acm_tty_open(struct tty_struct * tty,struct file * filp)525  static int acm_tty_open(struct tty_struct *tty, struct file *filp)
526  {
527  	struct acm *acm = tty->driver_data;
528  
529  	dev_dbg(tty->dev, "%s\n", __func__);
530  
531  	return tty_port_open(&acm->port, tty, filp);
532  }
533  
acm_port_activate(struct tty_port * port,struct tty_struct * tty)534  static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
535  {
536  	struct acm *acm = container_of(port, struct acm, port);
537  	int retval = -ENODEV;
538  
539  	dev_dbg(&acm->control->dev, "%s\n", __func__);
540  
541  	mutex_lock(&acm->mutex);
542  	if (acm->disconnected)
543  		goto disconnected;
544  
545  	retval = usb_autopm_get_interface(acm->control);
546  	if (retval)
547  		goto error_get_interface;
548  
549  	/*
550  	 * FIXME: Why do we need this? Allocating 64K of physically contiguous
551  	 * memory is really nasty...
552  	 */
553  	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
554  	acm->control->needs_remote_wakeup = 1;
555  
556  	acm->ctrlurb->dev = acm->dev;
557  	if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
558  		dev_err(&acm->control->dev,
559  			"%s - usb_submit_urb(ctrl irq) failed\n", __func__);
560  		goto error_submit_urb;
561  	}
562  
563  	acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
564  	if (acm_set_control(acm, acm->ctrlout) < 0 &&
565  	    (acm->ctrl_caps & USB_CDC_CAP_LINE))
566  		goto error_set_control;
567  
568  	usb_autopm_put_interface(acm->control);
569  
570  	/*
571  	 * Unthrottle device in case the TTY was closed while throttled.
572  	 */
573  	spin_lock_irq(&acm->read_lock);
574  	acm->throttled = 0;
575  	acm->throttle_req = 0;
576  	spin_unlock_irq(&acm->read_lock);
577  
578  	if (acm_submit_read_urbs(acm, GFP_KERNEL))
579  		goto error_submit_read_urbs;
580  
581  	mutex_unlock(&acm->mutex);
582  
583  	return 0;
584  
585  error_submit_read_urbs:
586  	acm->ctrlout = 0;
587  	acm_set_control(acm, acm->ctrlout);
588  error_set_control:
589  	usb_kill_urb(acm->ctrlurb);
590  error_submit_urb:
591  	usb_autopm_put_interface(acm->control);
592  error_get_interface:
593  disconnected:
594  	mutex_unlock(&acm->mutex);
595  	return retval;
596  }
597  
acm_port_destruct(struct tty_port * port)598  static void acm_port_destruct(struct tty_port *port)
599  {
600  	struct acm *acm = container_of(port, struct acm, port);
601  
602  	dev_dbg(&acm->control->dev, "%s\n", __func__);
603  
604  	acm_release_minor(acm);
605  	usb_put_intf(acm->control);
606  	kfree(acm->country_codes);
607  	kfree(acm);
608  }
609  
acm_port_shutdown(struct tty_port * port)610  static void acm_port_shutdown(struct tty_port *port)
611  {
612  	struct acm *acm = container_of(port, struct acm, port);
613  	int i;
614  
615  	dev_dbg(&acm->control->dev, "%s\n", __func__);
616  
617  	mutex_lock(&acm->mutex);
618  	if (!acm->disconnected) {
619  		usb_autopm_get_interface(acm->control);
620  		acm_set_control(acm, acm->ctrlout = 0);
621  		usb_kill_urb(acm->ctrlurb);
622  		for (i = 0; i < ACM_NW; i++)
623  			usb_kill_urb(acm->wb[i].urb);
624  		for (i = 0; i < acm->rx_buflimit; i++)
625  			usb_kill_urb(acm->read_urbs[i]);
626  		acm->control->needs_remote_wakeup = 0;
627  		usb_autopm_put_interface(acm->control);
628  	}
629  	mutex_unlock(&acm->mutex);
630  }
631  
acm_tty_cleanup(struct tty_struct * tty)632  static void acm_tty_cleanup(struct tty_struct *tty)
633  {
634  	struct acm *acm = tty->driver_data;
635  	dev_dbg(&acm->control->dev, "%s\n", __func__);
636  	tty_port_put(&acm->port);
637  }
638  
acm_tty_hangup(struct tty_struct * tty)639  static void acm_tty_hangup(struct tty_struct *tty)
640  {
641  	struct acm *acm = tty->driver_data;
642  	dev_dbg(&acm->control->dev, "%s\n", __func__);
643  	tty_port_hangup(&acm->port);
644  }
645  
acm_tty_close(struct tty_struct * tty,struct file * filp)646  static void acm_tty_close(struct tty_struct *tty, struct file *filp)
647  {
648  	struct acm *acm = tty->driver_data;
649  	dev_dbg(&acm->control->dev, "%s\n", __func__);
650  	tty_port_close(&acm->port, tty, filp);
651  }
652  
acm_tty_write(struct tty_struct * tty,const unsigned char * buf,int count)653  static int acm_tty_write(struct tty_struct *tty,
654  					const unsigned char *buf, int count)
655  {
656  	struct acm *acm = tty->driver_data;
657  	int stat;
658  	unsigned long flags;
659  	int wbn;
660  	struct acm_wb *wb;
661  
662  	if (!count)
663  		return 0;
664  
665  	dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
666  
667  	spin_lock_irqsave(&acm->write_lock, flags);
668  	wbn = acm_wb_alloc(acm);
669  	if (wbn < 0) {
670  		spin_unlock_irqrestore(&acm->write_lock, flags);
671  		return 0;
672  	}
673  	wb = &acm->wb[wbn];
674  
675  	count = (count > acm->writesize) ? acm->writesize : count;
676  	dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
677  	memcpy(wb->buf, buf, count);
678  	wb->len = count;
679  	spin_unlock_irqrestore(&acm->write_lock, flags);
680  
681  	stat = acm_write_start(acm, wbn);
682  	if (stat < 0)
683  		return stat;
684  	return count;
685  }
686  
acm_tty_write_room(struct tty_struct * tty)687  static int acm_tty_write_room(struct tty_struct *tty)
688  {
689  	struct acm *acm = tty->driver_data;
690  	/*
691  	 * Do not let the line discipline to know that we have a reserve,
692  	 * or it might get too enthusiastic.
693  	 */
694  	return acm_wb_is_avail(acm) ? acm->writesize : 0;
695  }
696  
acm_tty_chars_in_buffer(struct tty_struct * tty)697  static int acm_tty_chars_in_buffer(struct tty_struct *tty)
698  {
699  	struct acm *acm = tty->driver_data;
700  	/*
701  	 * if the device was unplugged then any remaining characters fell out
702  	 * of the connector ;)
703  	 */
704  	if (acm->disconnected)
705  		return 0;
706  	/*
707  	 * This is inaccurate (overcounts), but it works.
708  	 */
709  	return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
710  }
711  
acm_tty_throttle(struct tty_struct * tty)712  static void acm_tty_throttle(struct tty_struct *tty)
713  {
714  	struct acm *acm = tty->driver_data;
715  
716  	spin_lock_irq(&acm->read_lock);
717  	acm->throttle_req = 1;
718  	spin_unlock_irq(&acm->read_lock);
719  }
720  
acm_tty_unthrottle(struct tty_struct * tty)721  static void acm_tty_unthrottle(struct tty_struct *tty)
722  {
723  	struct acm *acm = tty->driver_data;
724  	unsigned int was_throttled;
725  
726  	spin_lock_irq(&acm->read_lock);
727  	was_throttled = acm->throttled;
728  	acm->throttled = 0;
729  	acm->throttle_req = 0;
730  	spin_unlock_irq(&acm->read_lock);
731  
732  	if (was_throttled)
733  		acm_submit_read_urbs(acm, GFP_KERNEL);
734  }
735  
acm_tty_break_ctl(struct tty_struct * tty,int state)736  static int acm_tty_break_ctl(struct tty_struct *tty, int state)
737  {
738  	struct acm *acm = tty->driver_data;
739  	int retval;
740  
741  	retval = acm_send_break(acm, state ? 0xffff : 0);
742  	if (retval < 0)
743  		dev_dbg(&acm->control->dev, "%s - send break failed\n",
744  								__func__);
745  	return retval;
746  }
747  
acm_tty_tiocmget(struct tty_struct * tty)748  static int acm_tty_tiocmget(struct tty_struct *tty)
749  {
750  	struct acm *acm = tty->driver_data;
751  
752  	return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
753  	       (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
754  	       (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
755  	       (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
756  	       (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
757  	       TIOCM_CTS;
758  }
759  
acm_tty_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)760  static int acm_tty_tiocmset(struct tty_struct *tty,
761  			    unsigned int set, unsigned int clear)
762  {
763  	struct acm *acm = tty->driver_data;
764  	unsigned int newctrl;
765  
766  	newctrl = acm->ctrlout;
767  	set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
768  					(set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
769  	clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
770  					(clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
771  
772  	newctrl = (newctrl & ~clear) | set;
773  
774  	if (acm->ctrlout == newctrl)
775  		return 0;
776  	return acm_set_control(acm, acm->ctrlout = newctrl);
777  }
778  
get_serial_info(struct acm * acm,struct serial_struct __user * info)779  static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
780  {
781  	struct serial_struct tmp;
782  
783  	if (!info)
784  		return -EINVAL;
785  
786  	memset(&tmp, 0, sizeof(tmp));
787  	tmp.flags = ASYNC_LOW_LATENCY;
788  	tmp.xmit_fifo_size = acm->writesize;
789  	tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
790  	tmp.close_delay	= acm->port.close_delay / 10;
791  	tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
792  				ASYNC_CLOSING_WAIT_NONE :
793  				acm->port.closing_wait / 10;
794  
795  	if (copy_to_user(info, &tmp, sizeof(tmp)))
796  		return -EFAULT;
797  	else
798  		return 0;
799  }
800  
set_serial_info(struct acm * acm,struct serial_struct __user * newinfo)801  static int set_serial_info(struct acm *acm,
802  				struct serial_struct __user *newinfo)
803  {
804  	struct serial_struct new_serial;
805  	unsigned int closing_wait, close_delay;
806  	int retval = 0;
807  
808  	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
809  		return -EFAULT;
810  
811  	close_delay = new_serial.close_delay * 10;
812  	closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
813  			ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
814  
815  	mutex_lock(&acm->port.mutex);
816  
817  	if (!capable(CAP_SYS_ADMIN)) {
818  		if ((close_delay != acm->port.close_delay) ||
819  		    (closing_wait != acm->port.closing_wait))
820  			retval = -EPERM;
821  		else
822  			retval = -EOPNOTSUPP;
823  	} else {
824  		acm->port.close_delay  = close_delay;
825  		acm->port.closing_wait = closing_wait;
826  	}
827  
828  	mutex_unlock(&acm->port.mutex);
829  	return retval;
830  }
831  
acm_tty_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)832  static int acm_tty_ioctl(struct tty_struct *tty,
833  					unsigned int cmd, unsigned long arg)
834  {
835  	struct acm *acm = tty->driver_data;
836  	int rv = -ENOIOCTLCMD;
837  
838  	switch (cmd) {
839  	case TIOCGSERIAL: /* gets serial port data */
840  		rv = get_serial_info(acm, (struct serial_struct __user *) arg);
841  		break;
842  	case TIOCSSERIAL:
843  		rv = set_serial_info(acm, (struct serial_struct __user *) arg);
844  		break;
845  	}
846  
847  	return rv;
848  }
849  
850  static const __u32 acm_tty_speed[] = {
851  	0, 50, 75, 110, 134, 150, 200, 300, 600,
852  	1200, 1800, 2400, 4800, 9600, 19200, 38400,
853  	57600, 115200, 230400, 460800, 500000, 576000,
854  	921600, 1000000, 1152000, 1500000, 2000000,
855  	2500000, 3000000, 3500000, 4000000
856  };
857  
acm_tty_set_termios(struct tty_struct * tty,struct ktermios * termios_old)858  static void acm_tty_set_termios(struct tty_struct *tty,
859  						struct ktermios *termios_old)
860  {
861  	struct acm *acm = tty->driver_data;
862  	struct ktermios *termios = tty->termios;
863  	struct usb_cdc_line_coding newline;
864  	int newctrl = acm->ctrlout;
865  
866  	newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
867  	newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
868  	newline.bParityType = termios->c_cflag & PARENB ?
869  				(termios->c_cflag & PARODD ? 1 : 2) +
870  				(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
871  	switch (termios->c_cflag & CSIZE) {
872  	case CS5:
873  		newline.bDataBits = 5;
874  		break;
875  	case CS6:
876  		newline.bDataBits = 6;
877  		break;
878  	case CS7:
879  		newline.bDataBits = 7;
880  		break;
881  	case CS8:
882  	default:
883  		newline.bDataBits = 8;
884  		break;
885  	}
886  	/* FIXME: Needs to clear unsupported bits in the termios */
887  	acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
888  
889  	if (!newline.dwDTERate) {
890  		newline.dwDTERate = acm->line.dwDTERate;
891  		newctrl &= ~ACM_CTRL_DTR;
892  	} else
893  		newctrl |=  ACM_CTRL_DTR;
894  
895  	if (newctrl != acm->ctrlout)
896  		acm_set_control(acm, acm->ctrlout = newctrl);
897  
898  	if (memcmp(&acm->line, &newline, sizeof newline)) {
899  		memcpy(&acm->line, &newline, sizeof newline);
900  		dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
901  			__func__,
902  			le32_to_cpu(newline.dwDTERate),
903  			newline.bCharFormat, newline.bParityType,
904  			newline.bDataBits);
905  		acm_set_line(acm, &acm->line);
906  	}
907  }
908  
909  static const struct tty_port_operations acm_port_ops = {
910  	.shutdown = acm_port_shutdown,
911  	.activate = acm_port_activate,
912  	.destruct = acm_port_destruct,
913  };
914  
915  /*
916   * USB probe and disconnect routines.
917   */
918  
919  /* Little helpers: write/read buffers free */
acm_write_buffers_free(struct acm * acm)920  static void acm_write_buffers_free(struct acm *acm)
921  {
922  	int i;
923  	struct acm_wb *wb;
924  	struct usb_device *usb_dev = interface_to_usbdev(acm->control);
925  
926  	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
927  		usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
928  }
929  
acm_read_buffers_free(struct acm * acm)930  static void acm_read_buffers_free(struct acm *acm)
931  {
932  	struct usb_device *usb_dev = interface_to_usbdev(acm->control);
933  	int i;
934  
935  	for (i = 0; i < acm->rx_buflimit; i++)
936  		usb_free_coherent(usb_dev, acm->readsize,
937  			  acm->read_buffers[i].base, acm->read_buffers[i].dma);
938  }
939  
940  /* Little helper: write buffers allocate */
acm_write_buffers_alloc(struct acm * acm)941  static int acm_write_buffers_alloc(struct acm *acm)
942  {
943  	int i;
944  	struct acm_wb *wb;
945  
946  	for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
947  		wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
948  		    &wb->dmah);
949  		if (!wb->buf) {
950  			while (i != 0) {
951  				--i;
952  				--wb;
953  				usb_free_coherent(acm->dev, acm->writesize,
954  				    wb->buf, wb->dmah);
955  			}
956  			return -ENOMEM;
957  		}
958  	}
959  	return 0;
960  }
961  
acm_probe(struct usb_interface * intf,const struct usb_device_id * id)962  static int acm_probe(struct usb_interface *intf,
963  		     const struct usb_device_id *id)
964  {
965  	struct usb_cdc_union_desc *union_header = NULL;
966  	struct usb_cdc_country_functional_desc *cfd = NULL;
967  	unsigned char *buffer = intf->altsetting->extra;
968  	int buflen = intf->altsetting->extralen;
969  	struct usb_interface *control_interface;
970  	struct usb_interface *data_interface;
971  	struct usb_endpoint_descriptor *epctrl = NULL;
972  	struct usb_endpoint_descriptor *epread = NULL;
973  	struct usb_endpoint_descriptor *epwrite = NULL;
974  	struct usb_device *usb_dev = interface_to_usbdev(intf);
975  	struct acm *acm;
976  	int minor;
977  	int ctrlsize, readsize;
978  	u8 *buf;
979  	u8 ac_management_function = 0;
980  	u8 call_management_function = 0;
981  	int call_interface_num = -1;
982  	int data_interface_num = -1;
983  	unsigned long quirks;
984  	int num_rx_buf;
985  	int i;
986  	int combined_interfaces = 0;
987  
988  	/* normal quirks */
989  	quirks = (unsigned long)id->driver_info;
990  	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
991  
992  	/* handle quirks deadly to normal probing*/
993  	if (quirks == NO_UNION_NORMAL) {
994  		data_interface = usb_ifnum_to_if(usb_dev, 1);
995  		control_interface = usb_ifnum_to_if(usb_dev, 0);
996  		goto skip_normal_probe;
997  	}
998  
999  	/* normal probing*/
1000  	if (!buffer) {
1001  		dev_err(&intf->dev, "Weird descriptor references\n");
1002  		return -EINVAL;
1003  	}
1004  
1005  	if (!buflen) {
1006  		if (intf->cur_altsetting->endpoint &&
1007  				intf->cur_altsetting->endpoint->extralen &&
1008  				intf->cur_altsetting->endpoint->extra) {
1009  			dev_dbg(&intf->dev,
1010  				"Seeking extra descriptors on endpoint\n");
1011  			buflen = intf->cur_altsetting->endpoint->extralen;
1012  			buffer = intf->cur_altsetting->endpoint->extra;
1013  		} else {
1014  			dev_err(&intf->dev,
1015  				"Zero length descriptor references\n");
1016  			return -EINVAL;
1017  		}
1018  	}
1019  
1020  	while (buflen > 0) {
1021  		if (buffer[1] != USB_DT_CS_INTERFACE) {
1022  			dev_err(&intf->dev, "skipping garbage\n");
1023  			goto next_desc;
1024  		}
1025  
1026  		switch (buffer[2]) {
1027  		case USB_CDC_UNION_TYPE: /* we've found it */
1028  			if (union_header) {
1029  				dev_err(&intf->dev, "More than one "
1030  					"union descriptor, skipping ...\n");
1031  				goto next_desc;
1032  			}
1033  			union_header = (struct usb_cdc_union_desc *)buffer;
1034  			break;
1035  		case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1036  			cfd = (struct usb_cdc_country_functional_desc *)buffer;
1037  			break;
1038  		case USB_CDC_HEADER_TYPE: /* maybe check version */
1039  			break; /* for now we ignore it */
1040  		case USB_CDC_ACM_TYPE:
1041  			ac_management_function = buffer[3];
1042  			break;
1043  		case USB_CDC_CALL_MANAGEMENT_TYPE:
1044  			call_management_function = buffer[3];
1045  			call_interface_num = buffer[4];
1046  			if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1047  				dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1048  			break;
1049  		default:
1050  			/* there are LOTS more CDC descriptors that
1051  			 * could legitimately be found here.
1052  			 */
1053  			dev_dbg(&intf->dev, "Ignoring descriptor: "
1054  					"type %02x, length %d\n",
1055  					buffer[2], buffer[0]);
1056  			break;
1057  		}
1058  next_desc:
1059  		buflen -= buffer[0];
1060  		buffer += buffer[0];
1061  	}
1062  
1063  	if (!union_header) {
1064  		if (call_interface_num > 0) {
1065  			dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1066  			/* quirks for Droids MuIn LCD */
1067  			if (quirks & NO_DATA_INTERFACE)
1068  				data_interface = usb_ifnum_to_if(usb_dev, 0);
1069  			else
1070  				data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1071  			control_interface = intf;
1072  		} else {
1073  			if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1074  				dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1075  				return -ENODEV;
1076  			} else {
1077  				dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1078  				combined_interfaces = 1;
1079  				control_interface = data_interface = intf;
1080  				goto look_for_collapsed_interface;
1081  			}
1082  		}
1083  	} else {
1084  		control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1085  		data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1086  		if (!control_interface || !data_interface) {
1087  			dev_dbg(&intf->dev, "no interfaces\n");
1088  			return -ENODEV;
1089  		}
1090  	}
1091  
1092  	if (data_interface_num != call_interface_num)
1093  		dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1094  
1095  	if (control_interface == data_interface) {
1096  		/* some broken devices designed for windows work this way */
1097  		dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1098  		combined_interfaces = 1;
1099  		/* a popular other OS doesn't use it */
1100  		quirks |= NO_CAP_LINE;
1101  		if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1102  			dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1103  			return -EINVAL;
1104  		}
1105  look_for_collapsed_interface:
1106  		for (i = 0; i < 3; i++) {
1107  			struct usb_endpoint_descriptor *ep;
1108  			ep = &data_interface->cur_altsetting->endpoint[i].desc;
1109  
1110  			if (usb_endpoint_is_int_in(ep))
1111  				epctrl = ep;
1112  			else if (usb_endpoint_is_bulk_out(ep))
1113  				epwrite = ep;
1114  			else if (usb_endpoint_is_bulk_in(ep))
1115  				epread = ep;
1116  			else
1117  				return -EINVAL;
1118  		}
1119  		if (!epctrl || !epread || !epwrite)
1120  			return -ENODEV;
1121  		else
1122  			goto made_compressed_probe;
1123  	}
1124  
1125  skip_normal_probe:
1126  
1127  	/*workaround for switched interfaces */
1128  	if (data_interface->cur_altsetting->desc.bInterfaceClass
1129  						!= CDC_DATA_INTERFACE_TYPE) {
1130  		if (control_interface->cur_altsetting->desc.bInterfaceClass
1131  						== CDC_DATA_INTERFACE_TYPE) {
1132  			struct usb_interface *t;
1133  			dev_dbg(&intf->dev,
1134  				"Your device has switched interfaces.\n");
1135  			t = control_interface;
1136  			control_interface = data_interface;
1137  			data_interface = t;
1138  		} else {
1139  			return -EINVAL;
1140  		}
1141  	}
1142  
1143  	/* Accept probe requests only for the control interface */
1144  	if (!combined_interfaces && intf != control_interface)
1145  		return -ENODEV;
1146  
1147  	if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1148  		/* valid in this context */
1149  		dev_dbg(&intf->dev, "The data interface isn't available\n");
1150  		return -EBUSY;
1151  	}
1152  
1153  
1154  	if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1155  	    control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1156  		return -EINVAL;
1157  
1158  	epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1159  	epread = &data_interface->cur_altsetting->endpoint[0].desc;
1160  	epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1161  
1162  
1163  	/* workaround for switched endpoints */
1164  	if (!usb_endpoint_dir_in(epread)) {
1165  		/* descriptors are swapped */
1166  		struct usb_endpoint_descriptor *t;
1167  		dev_dbg(&intf->dev,
1168  			"The data interface has switched endpoints\n");
1169  		t = epread;
1170  		epread = epwrite;
1171  		epwrite = t;
1172  	}
1173  made_compressed_probe:
1174  	dev_dbg(&intf->dev, "interfaces are valid\n");
1175  
1176  	acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1177  	if (acm == NULL) {
1178  		dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1179  		goto alloc_fail;
1180  	}
1181  
1182  	minor = acm_alloc_minor(acm);
1183  	if (minor == ACM_TTY_MINORS) {
1184  		dev_err(&intf->dev, "no more free acm devices\n");
1185  		kfree(acm);
1186  		return -ENODEV;
1187  	}
1188  
1189  	ctrlsize = usb_endpoint_maxp(epctrl);
1190  	readsize = usb_endpoint_maxp(epread) *
1191  				(quirks == SINGLE_RX_URB ? 1 : 2);
1192  	acm->combined_interfaces = combined_interfaces;
1193  	acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1194  	acm->control = control_interface;
1195  	acm->data = data_interface;
1196  	acm->minor = minor;
1197  	acm->dev = usb_dev;
1198  	acm->ctrl_caps = ac_management_function;
1199  	if (quirks & NO_CAP_LINE)
1200  		acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1201  	acm->ctrlsize = ctrlsize;
1202  	acm->readsize = readsize;
1203  	acm->rx_buflimit = num_rx_buf;
1204  	INIT_WORK(&acm->work, acm_softint);
1205  	spin_lock_init(&acm->write_lock);
1206  	spin_lock_init(&acm->read_lock);
1207  	mutex_init(&acm->mutex);
1208  	acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1209  	acm->is_int_ep = usb_endpoint_xfer_int(epread);
1210  	if (acm->is_int_ep)
1211  		acm->bInterval = epread->bInterval;
1212  	tty_port_init(&acm->port);
1213  	acm->port.ops = &acm_port_ops;
1214  
1215  	buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1216  	if (!buf) {
1217  		dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1218  		goto alloc_fail2;
1219  	}
1220  	acm->ctrl_buffer = buf;
1221  
1222  	if (acm_write_buffers_alloc(acm) < 0) {
1223  		dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1224  		goto alloc_fail4;
1225  	}
1226  
1227  	acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1228  	if (!acm->ctrlurb) {
1229  		dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1230  		goto alloc_fail5;
1231  	}
1232  	for (i = 0; i < num_rx_buf; i++) {
1233  		struct acm_rb *rb = &(acm->read_buffers[i]);
1234  		struct urb *urb;
1235  
1236  		rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1237  								&rb->dma);
1238  		if (!rb->base) {
1239  			dev_err(&intf->dev, "out of memory "
1240  					"(read bufs usb_alloc_coherent)\n");
1241  			goto alloc_fail6;
1242  		}
1243  		rb->index = i;
1244  		rb->instance = acm;
1245  
1246  		urb = usb_alloc_urb(0, GFP_KERNEL);
1247  		if (!urb) {
1248  			dev_err(&intf->dev,
1249  				"out of memory (read urbs usb_alloc_urb)\n");
1250  			goto alloc_fail6;
1251  		}
1252  		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1253  		urb->transfer_dma = rb->dma;
1254  		if (acm->is_int_ep) {
1255  			usb_fill_int_urb(urb, acm->dev,
1256  					 acm->rx_endpoint,
1257  					 rb->base,
1258  					 acm->readsize,
1259  					 acm_read_bulk_callback, rb,
1260  					 acm->bInterval);
1261  		} else {
1262  			usb_fill_bulk_urb(urb, acm->dev,
1263  					  acm->rx_endpoint,
1264  					  rb->base,
1265  					  acm->readsize,
1266  					  acm_read_bulk_callback, rb);
1267  		}
1268  
1269  		acm->read_urbs[i] = urb;
1270  		__set_bit(i, &acm->read_urbs_free);
1271  	}
1272  	for (i = 0; i < ACM_NW; i++) {
1273  		struct acm_wb *snd = &(acm->wb[i]);
1274  
1275  		snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1276  		if (snd->urb == NULL) {
1277  			dev_err(&intf->dev,
1278  				"out of memory (write urbs usb_alloc_urb)\n");
1279  			goto alloc_fail7;
1280  		}
1281  
1282  		if (usb_endpoint_xfer_int(epwrite))
1283  			usb_fill_int_urb(snd->urb, usb_dev,
1284  				usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1285  				NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1286  		else
1287  			usb_fill_bulk_urb(snd->urb, usb_dev,
1288  				usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1289  				NULL, acm->writesize, acm_write_bulk, snd);
1290  		snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1291  		snd->instance = acm;
1292  	}
1293  
1294  	usb_set_intfdata(intf, acm);
1295  
1296  	i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1297  	if (i < 0)
1298  		goto alloc_fail7;
1299  
1300  	if (cfd) { /* export the country data */
1301  		acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1302  		if (!acm->country_codes)
1303  			goto skip_countries;
1304  		acm->country_code_size = cfd->bLength - 4;
1305  		memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1306  							cfd->bLength - 4);
1307  		acm->country_rel_date = cfd->iCountryCodeRelDate;
1308  
1309  		i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1310  		if (i < 0) {
1311  			kfree(acm->country_codes);
1312  			acm->country_codes = NULL;
1313  			acm->country_code_size = 0;
1314  			goto skip_countries;
1315  		}
1316  
1317  		i = device_create_file(&intf->dev,
1318  						&dev_attr_iCountryCodeRelDate);
1319  		if (i < 0) {
1320  			device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1321  			kfree(acm->country_codes);
1322  			acm->country_codes = NULL;
1323  			acm->country_code_size = 0;
1324  			goto skip_countries;
1325  		}
1326  	}
1327  
1328  skip_countries:
1329  	usb_fill_int_urb(acm->ctrlurb, usb_dev,
1330  			 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1331  			 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1332  			 /* works around buggy devices */
1333  			 epctrl->bInterval ? epctrl->bInterval : 0xff);
1334  	acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1335  	acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1336  
1337  	dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1338  
1339  	acm_set_control(acm, acm->ctrlout);
1340  
1341  	acm->line.dwDTERate = cpu_to_le32(9600);
1342  	acm->line.bDataBits = 8;
1343  	acm_set_line(acm, &acm->line);
1344  
1345  	usb_driver_claim_interface(&acm_driver, data_interface, acm);
1346  	usb_set_intfdata(data_interface, acm);
1347  
1348  	usb_get_intf(control_interface);
1349  	tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1350  
1351  	return 0;
1352  alloc_fail7:
1353  	for (i = 0; i < ACM_NW; i++)
1354  		usb_free_urb(acm->wb[i].urb);
1355  alloc_fail6:
1356  	for (i = 0; i < num_rx_buf; i++)
1357  		usb_free_urb(acm->read_urbs[i]);
1358  	acm_read_buffers_free(acm);
1359  	usb_free_urb(acm->ctrlurb);
1360  alloc_fail5:
1361  	acm_write_buffers_free(acm);
1362  alloc_fail4:
1363  	usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1364  alloc_fail2:
1365  	acm_release_minor(acm);
1366  	kfree(acm);
1367  alloc_fail:
1368  	return -ENOMEM;
1369  }
1370  
stop_data_traffic(struct acm * acm)1371  static void stop_data_traffic(struct acm *acm)
1372  {
1373  	int i;
1374  
1375  	dev_dbg(&acm->control->dev, "%s\n", __func__);
1376  
1377  	usb_kill_urb(acm->ctrlurb);
1378  	for (i = 0; i < ACM_NW; i++)
1379  		usb_kill_urb(acm->wb[i].urb);
1380  	for (i = 0; i < acm->rx_buflimit; i++)
1381  		usb_kill_urb(acm->read_urbs[i]);
1382  
1383  	cancel_work_sync(&acm->work);
1384  }
1385  
acm_disconnect(struct usb_interface * intf)1386  static void acm_disconnect(struct usb_interface *intf)
1387  {
1388  	struct acm *acm = usb_get_intfdata(intf);
1389  	struct usb_device *usb_dev = interface_to_usbdev(intf);
1390  	struct tty_struct *tty;
1391  	int i;
1392  
1393  	dev_dbg(&intf->dev, "%s\n", __func__);
1394  
1395  	/* sibling interface is already cleaning up */
1396  	if (!acm)
1397  		return;
1398  
1399  	mutex_lock(&acm->mutex);
1400  	acm->disconnected = true;
1401  	if (acm->country_codes) {
1402  		device_remove_file(&acm->control->dev,
1403  				&dev_attr_wCountryCodes);
1404  		device_remove_file(&acm->control->dev,
1405  				&dev_attr_iCountryCodeRelDate);
1406  	}
1407  	device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1408  	usb_set_intfdata(acm->control, NULL);
1409  	usb_set_intfdata(acm->data, NULL);
1410  	mutex_unlock(&acm->mutex);
1411  
1412  	tty = tty_port_tty_get(&acm->port);
1413  	if (tty) {
1414  		tty_vhangup(tty);
1415  		tty_kref_put(tty);
1416  	}
1417  
1418  	stop_data_traffic(acm);
1419  
1420  	tty_unregister_device(acm_tty_driver, acm->minor);
1421  
1422  	usb_free_urb(acm->ctrlurb);
1423  	for (i = 0; i < ACM_NW; i++)
1424  		usb_free_urb(acm->wb[i].urb);
1425  	for (i = 0; i < acm->rx_buflimit; i++)
1426  		usb_free_urb(acm->read_urbs[i]);
1427  	acm_write_buffers_free(acm);
1428  	usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1429  	acm_read_buffers_free(acm);
1430  
1431  	if (!acm->combined_interfaces)
1432  		usb_driver_release_interface(&acm_driver, intf == acm->control ?
1433  					acm->data : acm->control);
1434  
1435  	tty_port_put(&acm->port);
1436  }
1437  
1438  #ifdef CONFIG_PM
acm_suspend(struct usb_interface * intf,pm_message_t message)1439  static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1440  {
1441  	struct acm *acm = usb_get_intfdata(intf);
1442  	int cnt;
1443  
1444  	if (PMSG_IS_AUTO(message)) {
1445  		int b;
1446  
1447  		spin_lock_irq(&acm->write_lock);
1448  		b = acm->transmitting;
1449  		spin_unlock_irq(&acm->write_lock);
1450  		if (b)
1451  			return -EBUSY;
1452  	}
1453  
1454  	spin_lock_irq(&acm->read_lock);
1455  	spin_lock(&acm->write_lock);
1456  	cnt = acm->susp_count++;
1457  	spin_unlock(&acm->write_lock);
1458  	spin_unlock_irq(&acm->read_lock);
1459  
1460  	if (cnt)
1461  		return 0;
1462  
1463  	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1464  		stop_data_traffic(acm);
1465  
1466  	return 0;
1467  }
1468  
acm_resume(struct usb_interface * intf)1469  static int acm_resume(struct usb_interface *intf)
1470  {
1471  	struct acm *acm = usb_get_intfdata(intf);
1472  	struct acm_wb *wb;
1473  	int rv = 0;
1474  	int cnt;
1475  
1476  	spin_lock_irq(&acm->read_lock);
1477  	acm->susp_count -= 1;
1478  	cnt = acm->susp_count;
1479  	spin_unlock_irq(&acm->read_lock);
1480  
1481  	if (cnt)
1482  		return 0;
1483  
1484  	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1485  		rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1486  
1487  		spin_lock_irq(&acm->write_lock);
1488  		if (acm->delayed_wb) {
1489  			wb = acm->delayed_wb;
1490  			acm->delayed_wb = NULL;
1491  			spin_unlock_irq(&acm->write_lock);
1492  			acm_start_wb(acm, wb);
1493  		} else {
1494  			spin_unlock_irq(&acm->write_lock);
1495  		}
1496  
1497  		/*
1498  		 * delayed error checking because we must
1499  		 * do the write path at all cost
1500  		 */
1501  		if (rv < 0)
1502  			goto err_out;
1503  
1504  		rv = acm_submit_read_urbs(acm, GFP_NOIO);
1505  	}
1506  
1507  err_out:
1508  	return rv;
1509  }
1510  
acm_reset_resume(struct usb_interface * intf)1511  static int acm_reset_resume(struct usb_interface *intf)
1512  {
1513  	struct acm *acm = usb_get_intfdata(intf);
1514  	struct tty_struct *tty;
1515  
1516  	if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1517  		tty = tty_port_tty_get(&acm->port);
1518  		if (tty) {
1519  			tty_hangup(tty);
1520  			tty_kref_put(tty);
1521  		}
1522  	}
1523  
1524  	return acm_resume(intf);
1525  }
1526  
1527  #endif /* CONFIG_PM */
1528  
1529  #define NOKIA_PCSUITE_ACM_INFO(x) \
1530  		USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1531  		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1532  		USB_CDC_ACM_PROTO_VENDOR)
1533  
1534  #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1535  		USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1536  		USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1537  		USB_CDC_ACM_PROTO_VENDOR)
1538  
1539  /*
1540   * USB driver structure.
1541   */
1542  
1543  static const struct usb_device_id acm_ids[] = {
1544  	/* quirky and broken devices */
1545  	{ USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1546  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1547  	},
1548  	{ USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1549  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1550  	},
1551  	{ USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1552  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1553  	},
1554  	{ USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1555  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1556  	},
1557  	{ USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1558  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1559  	},
1560  	{ USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1561  	.driver_info = SINGLE_RX_URB,
1562  	},
1563  	{ USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1564  	.driver_info = SINGLE_RX_URB, /* firmware bug */
1565  	},
1566  	{ USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1567  	.driver_info = SINGLE_RX_URB, /* firmware bug */
1568  	},
1569  	{ USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1570  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1571  	},
1572  	{ USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1573  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1574  	},
1575  	{ USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1576  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1577  	},
1578  	{ USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1579  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1580  	},
1581  	{ USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1582  	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1583  	},
1584  	{ USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1585  	},
1586  	/* Motorola H24 HSPA module: */
1587  	{ USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1588  	{ USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1589  	{ USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1590  	{ USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1591  	{ USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1592  	{ USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1593  	{ USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1594  	{ USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1595  
1596  	{ USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1597  	.driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1598  					   data interface instead of
1599  					   communications interface.
1600  					   Maybe we should define a new
1601  					   quirk for this. */
1602  	},
1603  	{ USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1604  	.driver_info = NO_UNION_NORMAL,
1605  	},
1606  	{ USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1607  	.driver_info = NO_UNION_NORMAL,
1608  	},
1609  	{ USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1610  	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1611  	},
1612  	{ USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1613  	.driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1614  	},
1615  
1616  	/* Nokia S60 phones expose two ACM channels. The first is
1617  	 * a modem and is picked up by the standard AT-command
1618  	 * information below. The second is 'vendor-specific' but
1619  	 * is treated as a serial device at the S60 end, so we want
1620  	 * to expose it on Linux too. */
1621  	{ NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1622  	{ NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1623  	{ NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1624  	{ NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1625  	{ NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1626  	{ NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1627  	{ NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1628  	{ NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1629  	{ NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1630  	{ NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1631  	{ NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1632  	{ NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1633  	{ NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1634  	{ NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1635  	{ NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1636  	{ NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1637  	{ NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1638  	{ NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1639  	{ NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1640  	{ NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1641  	{ NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1642  	{ NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1643  	{ NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1644  	{ NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1645  	{ NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1646  	{ NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1647  	{ NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1648  	{ NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1649  	{ NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1650  	{ NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1651  	{ NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1652  	{ NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1653  	{ NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1654  	{ NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1655  	{ NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1656  	{ NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1657  	{ NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1658  	{ NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1659  	{ NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1660  	{ NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1661  	{ NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1662  	{ NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1663  	{ NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1664  	{ NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1665  	{ NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1666  	{ NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1667  	{ NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1668  	{ NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1669  	{ NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1670  	{ NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1671  	{ NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1672  	{ NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1673  	{ NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1674  	{ NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1675  	{ NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1676  	{ NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1677  	{ NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1678  	{ SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1679  
1680  	/* Support for Owen devices */
1681  	{ USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1682  
1683  	/* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1684  
1685  	/* Support Lego NXT using pbLua firmware */
1686  	{ USB_DEVICE(0x0694, 0xff00),
1687  	.driver_info = NOT_A_MODEM,
1688  	},
1689  
1690  	/* Support for Droids MuIn LCD */
1691  	{ USB_DEVICE(0x04d8, 0x000b),
1692  	.driver_info = NO_DATA_INTERFACE,
1693  	},
1694  
1695  	/* control interfaces without any protocol set */
1696  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1697  		USB_CDC_PROTO_NONE) },
1698  
1699  	/* control interfaces with various AT-command sets */
1700  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1701  		USB_CDC_ACM_PROTO_AT_V25TER) },
1702  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1703  		USB_CDC_ACM_PROTO_AT_PCCA101) },
1704  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1705  		USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1706  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1707  		USB_CDC_ACM_PROTO_AT_GSM) },
1708  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1709  		USB_CDC_ACM_PROTO_AT_3G) },
1710  	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1711  		USB_CDC_ACM_PROTO_AT_CDMA) },
1712  
1713  	{ }
1714  };
1715  
1716  MODULE_DEVICE_TABLE(usb, acm_ids);
1717  
1718  static struct usb_driver acm_driver = {
1719  	.name =		"cdc_acm",
1720  	.probe =	acm_probe,
1721  	.disconnect =	acm_disconnect,
1722  #ifdef CONFIG_PM
1723  	.suspend =	acm_suspend,
1724  	.resume =	acm_resume,
1725  	.reset_resume =	acm_reset_resume,
1726  #endif
1727  	.id_table =	acm_ids,
1728  #ifdef CONFIG_PM
1729  	.supports_autosuspend = 1,
1730  #endif
1731  };
1732  
1733  /*
1734   * TTY driver structures.
1735   */
1736  
1737  static const struct tty_operations acm_ops = {
1738  	.install =		acm_tty_install,
1739  	.open =			acm_tty_open,
1740  	.close =		acm_tty_close,
1741  	.cleanup =		acm_tty_cleanup,
1742  	.hangup =		acm_tty_hangup,
1743  	.write =		acm_tty_write,
1744  	.write_room =		acm_tty_write_room,
1745  	.ioctl =		acm_tty_ioctl,
1746  	.throttle =		acm_tty_throttle,
1747  	.unthrottle =		acm_tty_unthrottle,
1748  	.chars_in_buffer =	acm_tty_chars_in_buffer,
1749  	.break_ctl =		acm_tty_break_ctl,
1750  	.set_termios =		acm_tty_set_termios,
1751  	.tiocmget =		acm_tty_tiocmget,
1752  	.tiocmset =		acm_tty_tiocmset,
1753  };
1754  
1755  /*
1756   * Init / exit.
1757   */
1758  
acm_init(void)1759  static int __init acm_init(void)
1760  {
1761  	int retval;
1762  	acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1763  	if (!acm_tty_driver)
1764  		return -ENOMEM;
1765  	acm_tty_driver->driver_name = "acm",
1766  	acm_tty_driver->name = "ttyACM",
1767  	acm_tty_driver->major = ACM_TTY_MAJOR,
1768  	acm_tty_driver->minor_start = 0,
1769  	acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1770  	acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1771  	acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1772  	acm_tty_driver->init_termios = tty_std_termios;
1773  	acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1774  								HUPCL | CLOCAL;
1775  	tty_set_operations(acm_tty_driver, &acm_ops);
1776  
1777  	retval = tty_register_driver(acm_tty_driver);
1778  	if (retval) {
1779  		put_tty_driver(acm_tty_driver);
1780  		return retval;
1781  	}
1782  
1783  	retval = usb_register(&acm_driver);
1784  	if (retval) {
1785  		tty_unregister_driver(acm_tty_driver);
1786  		put_tty_driver(acm_tty_driver);
1787  		return retval;
1788  	}
1789  
1790  	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1791  
1792  	return 0;
1793  }
1794  
acm_exit(void)1795  static void __exit acm_exit(void)
1796  {
1797  	usb_deregister(&acm_driver);
1798  	tty_unregister_driver(acm_tty_driver);
1799  	put_tty_driver(acm_tty_driver);
1800  }
1801  
1802  module_init(acm_init);
1803  module_exit(acm_exit);
1804  
1805  MODULE_AUTHOR(DRIVER_AUTHOR);
1806  MODULE_DESCRIPTION(DRIVER_DESC);
1807  MODULE_LICENSE("GPL");
1808  MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
1809