640cf7983b022cc0beed881439ef8576fbe4402e
[linux-2.6.git] / drivers / usb / class / cdc-acm.c
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  */
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  */
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'.  */
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
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
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
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  */
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
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
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  */
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
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
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 */
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
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
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
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
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 */
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
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
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
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
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
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         tty_unregister_device(acm_tty_driver, acm->minor);
605         acm_release_minor(acm);
606         usb_put_intf(acm->control);
607         kfree(acm->country_codes);
608         kfree(acm);
609 }
610
611 static void acm_port_shutdown(struct tty_port *port)
612 {
613         struct acm *acm = container_of(port, struct acm, port);
614         int i;
615
616         dev_dbg(&acm->control->dev, "%s\n", __func__);
617
618         mutex_lock(&acm->mutex);
619         if (!acm->disconnected) {
620                 usb_autopm_get_interface(acm->control);
621                 acm_set_control(acm, acm->ctrlout = 0);
622                 usb_kill_urb(acm->ctrlurb);
623                 for (i = 0; i < ACM_NW; i++)
624                         usb_kill_urb(acm->wb[i].urb);
625                 for (i = 0; i < acm->rx_buflimit; i++)
626                         usb_kill_urb(acm->read_urbs[i]);
627                 acm->control->needs_remote_wakeup = 0;
628                 usb_autopm_put_interface(acm->control);
629         }
630         mutex_unlock(&acm->mutex);
631 }
632
633 static void acm_tty_cleanup(struct tty_struct *tty)
634 {
635         struct acm *acm = tty->driver_data;
636         dev_dbg(&acm->control->dev, "%s\n", __func__);
637         tty_port_put(&acm->port);
638 }
639
640 static void acm_tty_hangup(struct tty_struct *tty)
641 {
642         struct acm *acm = tty->driver_data;
643         dev_dbg(&acm->control->dev, "%s\n", __func__);
644         tty_port_hangup(&acm->port);
645 }
646
647 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
648 {
649         struct acm *acm = tty->driver_data;
650         dev_dbg(&acm->control->dev, "%s\n", __func__);
651         tty_port_close(&acm->port, tty, filp);
652 }
653
654 static int acm_tty_write(struct tty_struct *tty,
655                                         const unsigned char *buf, int count)
656 {
657         struct acm *acm = tty->driver_data;
658         int stat;
659         unsigned long flags;
660         int wbn;
661         struct acm_wb *wb;
662
663         if (!count)
664                 return 0;
665
666         dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
667
668         spin_lock_irqsave(&acm->write_lock, flags);
669         wbn = acm_wb_alloc(acm);
670         if (wbn < 0) {
671                 spin_unlock_irqrestore(&acm->write_lock, flags);
672                 return 0;
673         }
674         wb = &acm->wb[wbn];
675
676         count = (count > acm->writesize) ? acm->writesize : count;
677         dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
678         memcpy(wb->buf, buf, count);
679         wb->len = count;
680         spin_unlock_irqrestore(&acm->write_lock, flags);
681
682         stat = acm_write_start(acm, wbn);
683         if (stat < 0)
684                 return stat;
685         return count;
686 }
687
688 static int acm_tty_write_room(struct tty_struct *tty)
689 {
690         struct acm *acm = tty->driver_data;
691         /*
692          * Do not let the line discipline to know that we have a reserve,
693          * or it might get too enthusiastic.
694          */
695         return acm_wb_is_avail(acm) ? acm->writesize : 0;
696 }
697
698 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
699 {
700         struct acm *acm = tty->driver_data;
701         /*
702          * if the device was unplugged then any remaining characters fell out
703          * of the connector ;)
704          */
705         if (acm->disconnected)
706                 return 0;
707         /*
708          * This is inaccurate (overcounts), but it works.
709          */
710         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
711 }
712
713 static void acm_tty_throttle(struct tty_struct *tty)
714 {
715         struct acm *acm = tty->driver_data;
716
717         spin_lock_irq(&acm->read_lock);
718         acm->throttle_req = 1;
719         spin_unlock_irq(&acm->read_lock);
720 }
721
722 static void acm_tty_unthrottle(struct tty_struct *tty)
723 {
724         struct acm *acm = tty->driver_data;
725         unsigned int was_throttled;
726
727         spin_lock_irq(&acm->read_lock);
728         was_throttled = acm->throttled;
729         acm->throttled = 0;
730         acm->throttle_req = 0;
731         spin_unlock_irq(&acm->read_lock);
732
733         if (was_throttled)
734                 acm_submit_read_urbs(acm, GFP_KERNEL);
735 }
736
737 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
738 {
739         struct acm *acm = tty->driver_data;
740         int retval;
741
742         retval = acm_send_break(acm, state ? 0xffff : 0);
743         if (retval < 0)
744                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
745                                                                 __func__);
746         return retval;
747 }
748
749 static int acm_tty_tiocmget(struct tty_struct *tty)
750 {
751         struct acm *acm = tty->driver_data;
752
753         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
754                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
755                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
756                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
757                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
758                TIOCM_CTS;
759 }
760
761 static int acm_tty_tiocmset(struct tty_struct *tty,
762                             unsigned int set, unsigned int clear)
763 {
764         struct acm *acm = tty->driver_data;
765         unsigned int newctrl;
766
767         newctrl = acm->ctrlout;
768         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
769                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
770         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
771                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
772
773         newctrl = (newctrl & ~clear) | set;
774
775         if (acm->ctrlout == newctrl)
776                 return 0;
777         return acm_set_control(acm, acm->ctrlout = newctrl);
778 }
779
780 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
781 {
782         struct serial_struct tmp;
783
784         if (!info)
785                 return -EINVAL;
786
787         memset(&tmp, 0, sizeof(tmp));
788         tmp.flags = ASYNC_LOW_LATENCY;
789         tmp.xmit_fifo_size = acm->writesize;
790         tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
791
792         if (copy_to_user(info, &tmp, sizeof(tmp)))
793                 return -EFAULT;
794         else
795                 return 0;
796 }
797
798 static int acm_tty_ioctl(struct tty_struct *tty,
799                                         unsigned int cmd, unsigned long arg)
800 {
801         struct acm *acm = tty->driver_data;
802         int rv = -ENOIOCTLCMD;
803
804         switch (cmd) {
805         case TIOCGSERIAL: /* gets serial port data */
806                 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
807                 break;
808         }
809
810         return rv;
811 }
812
813 static const __u32 acm_tty_speed[] = {
814         0, 50, 75, 110, 134, 150, 200, 300, 600,
815         1200, 1800, 2400, 4800, 9600, 19200, 38400,
816         57600, 115200, 230400, 460800, 500000, 576000,
817         921600, 1000000, 1152000, 1500000, 2000000,
818         2500000, 3000000, 3500000, 4000000
819 };
820
821 static const __u8 acm_tty_size[] = {
822         5, 6, 7, 8
823 };
824
825 static void acm_tty_set_termios(struct tty_struct *tty,
826                                                 struct ktermios *termios_old)
827 {
828         struct acm *acm = tty->driver_data;
829         struct ktermios *termios = tty->termios;
830         struct usb_cdc_line_coding newline;
831         int newctrl = acm->ctrlout;
832
833         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
834         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
835         newline.bParityType = termios->c_cflag & PARENB ?
836                                 (termios->c_cflag & PARODD ? 1 : 2) +
837                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
838         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
839         /* FIXME: Needs to clear unsupported bits in the termios */
840         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
841
842         if (!newline.dwDTERate) {
843                 newline.dwDTERate = acm->line.dwDTERate;
844                 newctrl &= ~ACM_CTRL_DTR;
845         } else
846                 newctrl |=  ACM_CTRL_DTR;
847
848         if (newctrl != acm->ctrlout)
849                 acm_set_control(acm, acm->ctrlout = newctrl);
850
851         if (memcmp(&acm->line, &newline, sizeof newline)) {
852                 memcpy(&acm->line, &newline, sizeof newline);
853                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
854                         __func__,
855                         le32_to_cpu(newline.dwDTERate),
856                         newline.bCharFormat, newline.bParityType,
857                         newline.bDataBits);
858                 acm_set_line(acm, &acm->line);
859         }
860 }
861
862 static const struct tty_port_operations acm_port_ops = {
863         .shutdown = acm_port_shutdown,
864         .activate = acm_port_activate,
865         .destruct = acm_port_destruct,
866 };
867
868 /*
869  * USB probe and disconnect routines.
870  */
871
872 /* Little helpers: write/read buffers free */
873 static void acm_write_buffers_free(struct acm *acm)
874 {
875         int i;
876         struct acm_wb *wb;
877         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
878
879         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
880                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
881 }
882
883 static void acm_read_buffers_free(struct acm *acm)
884 {
885         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
886         int i;
887
888         for (i = 0; i < acm->rx_buflimit; i++)
889                 usb_free_coherent(usb_dev, acm->readsize,
890                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
891 }
892
893 /* Little helper: write buffers allocate */
894 static int acm_write_buffers_alloc(struct acm *acm)
895 {
896         int i;
897         struct acm_wb *wb;
898
899         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
900                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
901                     &wb->dmah);
902                 if (!wb->buf) {
903                         while (i != 0) {
904                                 --i;
905                                 --wb;
906                                 usb_free_coherent(acm->dev, acm->writesize,
907                                     wb->buf, wb->dmah);
908                         }
909                         return -ENOMEM;
910                 }
911         }
912         return 0;
913 }
914
915 static int acm_probe(struct usb_interface *intf,
916                      const struct usb_device_id *id)
917 {
918         struct usb_cdc_union_desc *union_header = NULL;
919         struct usb_cdc_country_functional_desc *cfd = NULL;
920         unsigned char *buffer = intf->altsetting->extra;
921         int buflen = intf->altsetting->extralen;
922         struct usb_interface *control_interface;
923         struct usb_interface *data_interface;
924         struct usb_endpoint_descriptor *epctrl = NULL;
925         struct usb_endpoint_descriptor *epread = NULL;
926         struct usb_endpoint_descriptor *epwrite = NULL;
927         struct usb_device *usb_dev = interface_to_usbdev(intf);
928         struct acm *acm;
929         int minor;
930         int ctrlsize, readsize;
931         u8 *buf;
932         u8 ac_management_function = 0;
933         u8 call_management_function = 0;
934         int call_interface_num = -1;
935         int data_interface_num = -1;
936         unsigned long quirks;
937         int num_rx_buf;
938         int i;
939         int combined_interfaces = 0;
940
941         /* normal quirks */
942         quirks = (unsigned long)id->driver_info;
943         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
944
945         /* handle quirks deadly to normal probing*/
946         if (quirks == NO_UNION_NORMAL) {
947                 data_interface = usb_ifnum_to_if(usb_dev, 1);
948                 control_interface = usb_ifnum_to_if(usb_dev, 0);
949                 goto skip_normal_probe;
950         }
951
952         /* normal probing*/
953         if (!buffer) {
954                 dev_err(&intf->dev, "Weird descriptor references\n");
955                 return -EINVAL;
956         }
957
958         if (!buflen) {
959                 if (intf->cur_altsetting->endpoint &&
960                                 intf->cur_altsetting->endpoint->extralen &&
961                                 intf->cur_altsetting->endpoint->extra) {
962                         dev_dbg(&intf->dev,
963                                 "Seeking extra descriptors on endpoint\n");
964                         buflen = intf->cur_altsetting->endpoint->extralen;
965                         buffer = intf->cur_altsetting->endpoint->extra;
966                 } else {
967                         dev_err(&intf->dev,
968                                 "Zero length descriptor references\n");
969                         return -EINVAL;
970                 }
971         }
972
973         while (buflen > 0) {
974                 if (buffer[1] != USB_DT_CS_INTERFACE) {
975                         dev_err(&intf->dev, "skipping garbage\n");
976                         goto next_desc;
977                 }
978
979                 switch (buffer[2]) {
980                 case USB_CDC_UNION_TYPE: /* we've found it */
981                         if (union_header) {
982                                 dev_err(&intf->dev, "More than one "
983                                         "union descriptor, skipping ...\n");
984                                 goto next_desc;
985                         }
986                         union_header = (struct usb_cdc_union_desc *)buffer;
987                         break;
988                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
989                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
990                         break;
991                 case USB_CDC_HEADER_TYPE: /* maybe check version */
992                         break; /* for now we ignore it */
993                 case USB_CDC_ACM_TYPE:
994                         ac_management_function = buffer[3];
995                         break;
996                 case USB_CDC_CALL_MANAGEMENT_TYPE:
997                         call_management_function = buffer[3];
998                         call_interface_num = buffer[4];
999                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1000                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1001                         break;
1002                 default:
1003                         /* there are LOTS more CDC descriptors that
1004                          * could legitimately be found here.
1005                          */
1006                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1007                                         "type %02x, length %d\n",
1008                                         buffer[2], buffer[0]);
1009                         break;
1010                 }
1011 next_desc:
1012                 buflen -= buffer[0];
1013                 buffer += buffer[0];
1014         }
1015
1016         if (!union_header) {
1017                 if (call_interface_num > 0) {
1018                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1019                         /* quirks for Droids MuIn LCD */
1020                         if (quirks & NO_DATA_INTERFACE)
1021                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
1022                         else
1023                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1024                         control_interface = intf;
1025                 } else {
1026                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1027                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1028                                 return -ENODEV;
1029                         } else {
1030                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1031                                 combined_interfaces = 1;
1032                                 control_interface = data_interface = intf;
1033                                 goto look_for_collapsed_interface;
1034                         }
1035                 }
1036         } else {
1037                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1038                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1039                 if (!control_interface || !data_interface) {
1040                         dev_dbg(&intf->dev, "no interfaces\n");
1041                         return -ENODEV;
1042                 }
1043         }
1044
1045         if (data_interface_num != call_interface_num)
1046                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1047
1048         if (control_interface == data_interface) {
1049                 /* some broken devices designed for windows work this way */
1050                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1051                 combined_interfaces = 1;
1052                 /* a popular other OS doesn't use it */
1053                 quirks |= NO_CAP_LINE;
1054                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1055                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1056                         return -EINVAL;
1057                 }
1058 look_for_collapsed_interface:
1059                 for (i = 0; i < 3; i++) {
1060                         struct usb_endpoint_descriptor *ep;
1061                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1062
1063                         if (usb_endpoint_is_int_in(ep))
1064                                 epctrl = ep;
1065                         else if (usb_endpoint_is_bulk_out(ep))
1066                                 epwrite = ep;
1067                         else if (usb_endpoint_is_bulk_in(ep))
1068                                 epread = ep;
1069                         else
1070                                 return -EINVAL;
1071                 }
1072                 if (!epctrl || !epread || !epwrite)
1073                         return -ENODEV;
1074                 else
1075                         goto made_compressed_probe;
1076         }
1077
1078 skip_normal_probe:
1079
1080         /*workaround for switched interfaces */
1081         if (data_interface->cur_altsetting->desc.bInterfaceClass
1082                                                 != CDC_DATA_INTERFACE_TYPE) {
1083                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1084                                                 == CDC_DATA_INTERFACE_TYPE) {
1085                         struct usb_interface *t;
1086                         dev_dbg(&intf->dev,
1087                                 "Your device has switched interfaces.\n");
1088                         t = control_interface;
1089                         control_interface = data_interface;
1090                         data_interface = t;
1091                 } else {
1092                         return -EINVAL;
1093                 }
1094         }
1095
1096         /* Accept probe requests only for the control interface */
1097         if (!combined_interfaces && intf != control_interface)
1098                 return -ENODEV;
1099
1100         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1101                 /* valid in this context */
1102                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1103                 return -EBUSY;
1104         }
1105
1106
1107         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1108                 return -EINVAL;
1109
1110         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1111         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1112         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1113
1114
1115         /* workaround for switched endpoints */
1116         if (!usb_endpoint_dir_in(epread)) {
1117                 /* descriptors are swapped */
1118                 struct usb_endpoint_descriptor *t;
1119                 dev_dbg(&intf->dev,
1120                         "The data interface has switched endpoints\n");
1121                 t = epread;
1122                 epread = epwrite;
1123                 epwrite = t;
1124         }
1125 made_compressed_probe:
1126         dev_dbg(&intf->dev, "interfaces are valid\n");
1127
1128         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1129         if (acm == NULL) {
1130                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1131                 goto alloc_fail;
1132         }
1133
1134         minor = acm_alloc_minor(acm);
1135         if (minor == ACM_TTY_MINORS) {
1136                 dev_err(&intf->dev, "no more free acm devices\n");
1137                 kfree(acm);
1138                 return -ENODEV;
1139         }
1140
1141         ctrlsize = usb_endpoint_maxp(epctrl);
1142         readsize = usb_endpoint_maxp(epread) *
1143                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1144         acm->combined_interfaces = combined_interfaces;
1145         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1146         acm->control = control_interface;
1147         acm->data = data_interface;
1148         acm->minor = minor;
1149         acm->dev = usb_dev;
1150         acm->ctrl_caps = ac_management_function;
1151         if (quirks & NO_CAP_LINE)
1152                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1153         acm->ctrlsize = ctrlsize;
1154         acm->readsize = readsize;
1155         acm->rx_buflimit = num_rx_buf;
1156         INIT_WORK(&acm->work, acm_softint);
1157         spin_lock_init(&acm->write_lock);
1158         spin_lock_init(&acm->read_lock);
1159         mutex_init(&acm->mutex);
1160         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1161         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1162         if (acm->is_int_ep)
1163                 acm->bInterval = epread->bInterval;
1164         tty_port_init(&acm->port);
1165         acm->port.ops = &acm_port_ops;
1166
1167         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1168         if (!buf) {
1169                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1170                 goto alloc_fail2;
1171         }
1172         acm->ctrl_buffer = buf;
1173
1174         if (acm_write_buffers_alloc(acm) < 0) {
1175                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1176                 goto alloc_fail4;
1177         }
1178
1179         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1180         if (!acm->ctrlurb) {
1181                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1182                 goto alloc_fail5;
1183         }
1184         for (i = 0; i < num_rx_buf; i++) {
1185                 struct acm_rb *rb = &(acm->read_buffers[i]);
1186                 struct urb *urb;
1187
1188                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1189                                                                 &rb->dma);
1190                 if (!rb->base) {
1191                         dev_err(&intf->dev, "out of memory "
1192                                         "(read bufs usb_alloc_coherent)\n");
1193                         goto alloc_fail6;
1194                 }
1195                 rb->index = i;
1196                 rb->instance = acm;
1197
1198                 urb = usb_alloc_urb(0, GFP_KERNEL);
1199                 if (!urb) {
1200                         dev_err(&intf->dev,
1201                                 "out of memory (read urbs usb_alloc_urb)\n");
1202                         goto alloc_fail6;
1203                 }
1204                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1205                 urb->transfer_dma = rb->dma;
1206                 if (acm->is_int_ep) {
1207                         usb_fill_int_urb(urb, acm->dev,
1208                                          acm->rx_endpoint,
1209                                          rb->base,
1210                                          acm->readsize,
1211                                          acm_read_bulk_callback, rb,
1212                                          acm->bInterval);
1213                 } else {
1214                         usb_fill_bulk_urb(urb, acm->dev,
1215                                           acm->rx_endpoint,
1216                                           rb->base,
1217                                           acm->readsize,
1218                                           acm_read_bulk_callback, rb);
1219                 }
1220
1221                 acm->read_urbs[i] = urb;
1222                 __set_bit(i, &acm->read_urbs_free);
1223         }
1224         for (i = 0; i < ACM_NW; i++) {
1225                 struct acm_wb *snd = &(acm->wb[i]);
1226
1227                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1228                 if (snd->urb == NULL) {
1229                         dev_err(&intf->dev,
1230                                 "out of memory (write urbs usb_alloc_urb)\n");
1231                         goto alloc_fail7;
1232                 }
1233
1234                 if (usb_endpoint_xfer_int(epwrite))
1235                         usb_fill_int_urb(snd->urb, usb_dev,
1236                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1237                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1238                 else
1239                         usb_fill_bulk_urb(snd->urb, usb_dev,
1240                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1241                                 NULL, acm->writesize, acm_write_bulk, snd);
1242                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1243                 snd->instance = acm;
1244         }
1245
1246         usb_set_intfdata(intf, acm);
1247
1248         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1249         if (i < 0)
1250                 goto alloc_fail7;
1251
1252         if (cfd) { /* export the country data */
1253                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1254                 if (!acm->country_codes)
1255                         goto skip_countries;
1256                 acm->country_code_size = cfd->bLength - 4;
1257                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1258                                                         cfd->bLength - 4);
1259                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1260
1261                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1262                 if (i < 0) {
1263                         kfree(acm->country_codes);
1264                         acm->country_codes = NULL;
1265                         acm->country_code_size = 0;
1266                         goto skip_countries;
1267                 }
1268
1269                 i = device_create_file(&intf->dev,
1270                                                 &dev_attr_iCountryCodeRelDate);
1271                 if (i < 0) {
1272                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1273                         kfree(acm->country_codes);
1274                         acm->country_codes = NULL;
1275                         acm->country_code_size = 0;
1276                         goto skip_countries;
1277                 }
1278         }
1279
1280 skip_countries:
1281         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1282                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1283                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1284                          /* works around buggy devices */
1285                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1286         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1287         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1288
1289         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1290
1291         acm_set_control(acm, acm->ctrlout);
1292
1293         acm->line.dwDTERate = cpu_to_le32(9600);
1294         acm->line.bDataBits = 8;
1295         acm_set_line(acm, &acm->line);
1296
1297         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1298         usb_set_intfdata(data_interface, acm);
1299
1300         usb_get_intf(control_interface);
1301         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1302
1303         return 0;
1304 alloc_fail7:
1305         for (i = 0; i < ACM_NW; i++)
1306                 usb_free_urb(acm->wb[i].urb);
1307 alloc_fail6:
1308         for (i = 0; i < num_rx_buf; i++)
1309                 usb_free_urb(acm->read_urbs[i]);
1310         acm_read_buffers_free(acm);
1311         usb_free_urb(acm->ctrlurb);
1312 alloc_fail5:
1313         acm_write_buffers_free(acm);
1314 alloc_fail4:
1315         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1316 alloc_fail2:
1317         acm_release_minor(acm);
1318         kfree(acm);
1319 alloc_fail:
1320         return -ENOMEM;
1321 }
1322
1323 static void stop_data_traffic(struct acm *acm)
1324 {
1325         int i;
1326
1327         dev_dbg(&acm->control->dev, "%s\n", __func__);
1328
1329         usb_kill_urb(acm->ctrlurb);
1330         for (i = 0; i < ACM_NW; i++)
1331                 usb_kill_urb(acm->wb[i].urb);
1332         for (i = 0; i < acm->rx_buflimit; i++)
1333                 usb_kill_urb(acm->read_urbs[i]);
1334
1335         cancel_work_sync(&acm->work);
1336 }
1337
1338 static void acm_disconnect(struct usb_interface *intf)
1339 {
1340         struct acm *acm = usb_get_intfdata(intf);
1341         struct usb_device *usb_dev = interface_to_usbdev(intf);
1342         struct tty_struct *tty;
1343         int i;
1344
1345         dev_dbg(&intf->dev, "%s\n", __func__);
1346
1347         /* sibling interface is already cleaning up */
1348         if (!acm)
1349                 return;
1350
1351         mutex_lock(&acm->mutex);
1352         acm->disconnected = true;
1353         if (acm->country_codes) {
1354                 device_remove_file(&acm->control->dev,
1355                                 &dev_attr_wCountryCodes);
1356                 device_remove_file(&acm->control->dev,
1357                                 &dev_attr_iCountryCodeRelDate);
1358         }
1359         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1360         usb_set_intfdata(acm->control, NULL);
1361         usb_set_intfdata(acm->data, NULL);
1362         mutex_unlock(&acm->mutex);
1363
1364         tty = tty_port_tty_get(&acm->port);
1365         if (tty) {
1366                 tty_vhangup(tty);
1367                 tty_kref_put(tty);
1368         }
1369
1370         stop_data_traffic(acm);
1371
1372         usb_free_urb(acm->ctrlurb);
1373         for (i = 0; i < ACM_NW; i++)
1374                 usb_free_urb(acm->wb[i].urb);
1375         for (i = 0; i < acm->rx_buflimit; i++)
1376                 usb_free_urb(acm->read_urbs[i]);
1377         acm_write_buffers_free(acm);
1378         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1379         acm_read_buffers_free(acm);
1380
1381         if (!acm->combined_interfaces)
1382                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1383                                         acm->data : acm->control);
1384
1385         tty_port_put(&acm->port);
1386 }
1387
1388 #ifdef CONFIG_PM
1389 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1390 {
1391         struct acm *acm = usb_get_intfdata(intf);
1392         int cnt;
1393
1394         if (PMSG_IS_AUTO(message)) {
1395                 int b;
1396
1397                 spin_lock_irq(&acm->write_lock);
1398                 b = acm->transmitting;
1399                 spin_unlock_irq(&acm->write_lock);
1400                 if (b)
1401                         return -EBUSY;
1402         }
1403
1404         spin_lock_irq(&acm->read_lock);
1405         spin_lock(&acm->write_lock);
1406         cnt = acm->susp_count++;
1407         spin_unlock(&acm->write_lock);
1408         spin_unlock_irq(&acm->read_lock);
1409
1410         if (cnt)
1411                 return 0;
1412
1413         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1414                 stop_data_traffic(acm);
1415
1416         return 0;
1417 }
1418
1419 static int acm_resume(struct usb_interface *intf)
1420 {
1421         struct acm *acm = usb_get_intfdata(intf);
1422         struct acm_wb *wb;
1423         int rv = 0;
1424         int cnt;
1425
1426         spin_lock_irq(&acm->read_lock);
1427         acm->susp_count -= 1;
1428         cnt = acm->susp_count;
1429         spin_unlock_irq(&acm->read_lock);
1430
1431         if (cnt)
1432                 return 0;
1433
1434         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1435                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1436
1437                 spin_lock_irq(&acm->write_lock);
1438                 if (acm->delayed_wb) {
1439                         wb = acm->delayed_wb;
1440                         acm->delayed_wb = NULL;
1441                         spin_unlock_irq(&acm->write_lock);
1442                         acm_start_wb(acm, wb);
1443                 } else {
1444                         spin_unlock_irq(&acm->write_lock);
1445                 }
1446
1447                 /*
1448                  * delayed error checking because we must
1449                  * do the write path at all cost
1450                  */
1451                 if (rv < 0)
1452                         goto err_out;
1453
1454                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1455         }
1456
1457 err_out:
1458         return rv;
1459 }
1460
1461 static int acm_reset_resume(struct usb_interface *intf)
1462 {
1463         struct acm *acm = usb_get_intfdata(intf);
1464         struct tty_struct *tty;
1465
1466         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1467                 tty = tty_port_tty_get(&acm->port);
1468                 if (tty) {
1469                         tty_hangup(tty);
1470                         tty_kref_put(tty);
1471                 }
1472         }
1473
1474         return acm_resume(intf);
1475 }
1476
1477 #endif /* CONFIG_PM */
1478
1479 #define NOKIA_PCSUITE_ACM_INFO(x) \
1480                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1481                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1482                 USB_CDC_ACM_PROTO_VENDOR)
1483
1484 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1485                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1486                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1487                 USB_CDC_ACM_PROTO_VENDOR)
1488
1489 /*
1490  * USB driver structure.
1491  */
1492
1493 static const struct usb_device_id acm_ids[] = {
1494         /* quirky and broken devices */
1495         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1496         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1497         },
1498         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1499         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1500         },
1501         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1502         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503         },
1504         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1505         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1506         },
1507         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1508         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1509         },
1510         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1511         .driver_info = SINGLE_RX_URB,
1512         },
1513         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1514         .driver_info = SINGLE_RX_URB, /* firmware bug */
1515         },
1516         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1517         .driver_info = SINGLE_RX_URB, /* firmware bug */
1518         },
1519         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1520         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1521         },
1522         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1523         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1524         },
1525         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1526         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1527         },
1528         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1529         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1530         },
1531         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1532         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1533         },
1534         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1535         },
1536         /* Motorola H24 HSPA module: */
1537         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1538         { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1539         { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1540         { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1541         { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1542         { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1543         { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1544         { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1545
1546         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1547         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1548                                            data interface instead of
1549                                            communications interface.
1550                                            Maybe we should define a new
1551                                            quirk for this. */
1552         },
1553         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1554         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1555         },
1556         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1557         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1558         },
1559
1560         /* Nokia S60 phones expose two ACM channels. The first is
1561          * a modem and is picked up by the standard AT-command
1562          * information below. The second is 'vendor-specific' but
1563          * is treated as a serial device at the S60 end, so we want
1564          * to expose it on Linux too. */
1565         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1567         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1568         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1570         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1571         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1573         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1574         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1575         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1576         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1577         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1579         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1580         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1581         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1582         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1583         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1584         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1585         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1586         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1587         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1588         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1589         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1592         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1594         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1595         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1596         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1597         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1598         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1599         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1600         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1601         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1602         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1603         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1604         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1605         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1606         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1607         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1608         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1609         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1610         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1611         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1612         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1613         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1614         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1615         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1616         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1617         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1618         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1619         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1620         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1621         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1622         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1623
1624         /* Support for Owen devices */
1625         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1626
1627         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1628
1629         /* Support Lego NXT using pbLua firmware */
1630         { USB_DEVICE(0x0694, 0xff00),
1631         .driver_info = NOT_A_MODEM,
1632         },
1633
1634         /* Support for Droids MuIn LCD */
1635         { USB_DEVICE(0x04d8, 0x000b),
1636         .driver_info = NO_DATA_INTERFACE,
1637         },
1638
1639         /* control interfaces without any protocol set */
1640         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1641                 USB_CDC_PROTO_NONE) },
1642
1643         /* control interfaces with various AT-command sets */
1644         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1645                 USB_CDC_ACM_PROTO_AT_V25TER) },
1646         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1647                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1648         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1649                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1650         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1651                 USB_CDC_ACM_PROTO_AT_GSM) },
1652         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1653                 USB_CDC_ACM_PROTO_AT_3G) },
1654         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1655                 USB_CDC_ACM_PROTO_AT_CDMA) },
1656
1657         { }
1658 };
1659
1660 MODULE_DEVICE_TABLE(usb, acm_ids);
1661
1662 static struct usb_driver acm_driver = {
1663         .name =         "cdc_acm",
1664         .probe =        acm_probe,
1665         .disconnect =   acm_disconnect,
1666 #ifdef CONFIG_PM
1667         .suspend =      acm_suspend,
1668         .resume =       acm_resume,
1669         .reset_resume = acm_reset_resume,
1670 #endif
1671         .id_table =     acm_ids,
1672 #ifdef CONFIG_PM
1673         .supports_autosuspend = 1,
1674 #endif
1675 };
1676
1677 /*
1678  * TTY driver structures.
1679  */
1680
1681 static const struct tty_operations acm_ops = {
1682         .install =              acm_tty_install,
1683         .open =                 acm_tty_open,
1684         .close =                acm_tty_close,
1685         .cleanup =              acm_tty_cleanup,
1686         .hangup =               acm_tty_hangup,
1687         .write =                acm_tty_write,
1688         .write_room =           acm_tty_write_room,
1689         .ioctl =                acm_tty_ioctl,
1690         .throttle =             acm_tty_throttle,
1691         .unthrottle =           acm_tty_unthrottle,
1692         .chars_in_buffer =      acm_tty_chars_in_buffer,
1693         .break_ctl =            acm_tty_break_ctl,
1694         .set_termios =          acm_tty_set_termios,
1695         .tiocmget =             acm_tty_tiocmget,
1696         .tiocmset =             acm_tty_tiocmset,
1697 };
1698
1699 /*
1700  * Init / exit.
1701  */
1702
1703 static int __init acm_init(void)
1704 {
1705         int retval;
1706         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1707         if (!acm_tty_driver)
1708                 return -ENOMEM;
1709         acm_tty_driver->driver_name = "acm",
1710         acm_tty_driver->name = "ttyACM",
1711         acm_tty_driver->major = ACM_TTY_MAJOR,
1712         acm_tty_driver->minor_start = 0,
1713         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1714         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1715         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1716         acm_tty_driver->init_termios = tty_std_termios;
1717         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1718                                                                 HUPCL | CLOCAL;
1719         tty_set_operations(acm_tty_driver, &acm_ops);
1720
1721         retval = tty_register_driver(acm_tty_driver);
1722         if (retval) {
1723                 put_tty_driver(acm_tty_driver);
1724                 return retval;
1725         }
1726
1727         retval = usb_register(&acm_driver);
1728         if (retval) {
1729                 tty_unregister_driver(acm_tty_driver);
1730                 put_tty_driver(acm_tty_driver);
1731                 return retval;
1732         }
1733
1734         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1735
1736         return 0;
1737 }
1738
1739 static void __exit acm_exit(void)
1740 {
1741         usb_deregister(&acm_driver);
1742         tty_unregister_driver(acm_tty_driver);
1743         put_tty_driver(acm_tty_driver);
1744 }
1745
1746 module_init(acm_init);
1747 module_exit(acm_exit);
1748
1749 MODULE_AUTHOR(DRIVER_AUTHOR);
1750 MODULE_DESCRIPTION(DRIVER_DESC);
1751 MODULE_LICENSE("GPL");
1752 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);