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