USB: cdc_acm: Fix race condition when opening tty
[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@suse.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  *
11  * USB Abstract Control Model driver for USB modems and ISDN adapters
12  *
13  * Sponsored by SuSE
14  *
15  * ChangeLog:
16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
17  *      v0.10 - some more cleanups
18  *      v0.11 - fixed flow control, read error doesn't stop reads
19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
20  *              kmalloced
21  *      v0.13 - added termios, added hangup
22  *      v0.14 - sized down struct acm
23  *      v0.15 - fixed flow control again - characters could be lost
24  *      v0.16 - added code for modems with swapped data and control interfaces
25  *      v0.17 - added new style probing
26  *      v0.18 - fixed new style probing for devices with more configurations
27  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28  *      v0.20 - switched to probing on interface (rather than device) class
29  *      v0.21 - revert to probing on device for devices with multiple configs
30  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
31  *              config we want, sysadmin changes bConfigurationValue in sysfs.
32  *      v0.23 - use softirq for rx processing, as needed by tty layer
33  *      v0.24 - change probe method to evaluate CDC union descriptor
34  *      v0.25 - downstream tasks paralelized to maximize throughput
35  *      v0.26 - multiple write urbs, writesize increased
36  */
37
38 /*
39  * This program is free software; you can redistribute it and/or modify
40  * it under the terms of the GNU General Public License as published by
41  * the Free Software Foundation; either version 2 of the License, or
42  * (at your option) any later version.
43  *
44  * This program is distributed in the hope that it will be useful,
45  * but WITHOUT ANY WARRANTY; without even the implied warranty of
46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
47  * GNU General Public License for more details.
48  *
49  * You should have received a copy of the GNU General Public License
50  * along with this program; if not, write to the Free Software
51  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
52  */
53
54 #undef DEBUG
55 #undef VERBOSE_DEBUG
56
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/tty.h>
62 #include <linux/serial.h>
63 #include <linux/tty_driver.h>
64 #include <linux/tty_flip.h>
65 #include <linux/module.h>
66 #include <linux/mutex.h>
67 #include <linux/uaccess.h>
68 #include <linux/usb.h>
69 #include <linux/usb/cdc.h>
70 #include <asm/byteorder.h>
71 #include <asm/unaligned.h>
72 #include <linux/list.h>
73
74 #include "cdc-acm.h"
75
76
77 #define ACM_CLOSE_TIMEOUT       15      /* seconds to let writes drain */
78
79 /*
80  * Version Information
81  */
82 #define DRIVER_VERSION "v0.26"
83 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
84 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
85
86 static struct usb_driver acm_driver;
87 static struct tty_driver *acm_tty_driver;
88 static struct acm *acm_table[ACM_TTY_MINORS];
89
90 static DEFINE_MUTEX(open_mutex);
91
92 #define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
93
94 static const struct tty_port_operations acm_port_ops = {
95 };
96
97 #ifdef VERBOSE_DEBUG
98 #define verbose 1
99 #else
100 #define verbose 0
101 #endif
102
103 /*
104  * Functions for ACM control messages.
105  */
106
107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
108                                                         void *buf, int len)
109 {
110         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
111                 request, USB_RT_ACM, value,
112                 acm->control->altsetting[0].desc.bInterfaceNumber,
113                 buf, len, 5000);
114         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
115                                                 request, value, len, retval);
116         return retval < 0 ? retval : 0;
117 }
118
119 /* devices aren't required to support these requests.
120  * the cdc acm descriptor tells whether they do...
121  */
122 #define acm_set_control(acm, control) \
123         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124 #define acm_set_line(acm, line) \
125         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126 #define acm_send_break(acm, ms) \
127         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
128
129 /*
130  * Write buffer management.
131  * All of these assume proper locks taken by the caller.
132  */
133
134 static int acm_wb_alloc(struct acm *acm)
135 {
136         int i, wbn;
137         struct acm_wb *wb;
138
139         wbn = 0;
140         i = 0;
141         for (;;) {
142                 wb = &acm->wb[wbn];
143                 if (!wb->use) {
144                         wb->use = 1;
145                         return wbn;
146                 }
147                 wbn = (wbn + 1) % ACM_NW;
148                 if (++i >= ACM_NW)
149                         return -1;
150         }
151 }
152
153 static int acm_wb_is_avail(struct acm *acm)
154 {
155         int i, n;
156         unsigned long flags;
157
158         n = ACM_NW;
159         spin_lock_irqsave(&acm->write_lock, flags);
160         for (i = 0; i < ACM_NW; i++)
161                 n -= acm->wb[i].use;
162         spin_unlock_irqrestore(&acm->write_lock, flags);
163         return n;
164 }
165
166 /*
167  * Finish write. Caller must hold acm->write_lock
168  */
169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
170 {
171         wb->use = 0;
172         acm->transmitting--;
173 }
174
175 /*
176  * Poke write.
177  *
178  * the caller is responsible for locking
179  */
180
181 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
182 {
183         int rc;
184
185         acm->transmitting++;
186
187         wb->urb->transfer_buffer = wb->buf;
188         wb->urb->transfer_dma = wb->dmah;
189         wb->urb->transfer_buffer_length = wb->len;
190         wb->urb->dev = acm->dev;
191
192         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
193         if (rc < 0) {
194                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
195                 acm_write_done(acm, wb);
196         }
197         return rc;
198 }
199
200 static int acm_write_start(struct acm *acm, int wbn)
201 {
202         unsigned long flags;
203         struct acm_wb *wb = &acm->wb[wbn];
204         int rc;
205
206         spin_lock_irqsave(&acm->write_lock, flags);
207         if (!acm->dev) {
208                 wb->use = 0;
209                 spin_unlock_irqrestore(&acm->write_lock, flags);
210                 return -ENODEV;
211         }
212
213         dbg("%s susp_count: %d", __func__, acm->susp_count);
214         if (acm->susp_count) {
215                 acm->delayed_wb = wb;
216                 schedule_work(&acm->waker);
217                 spin_unlock_irqrestore(&acm->write_lock, flags);
218                 return 0;       /* A white lie */
219         }
220         usb_mark_last_busy(acm->dev);
221
222         rc = acm_start_wb(acm, wb);
223         spin_unlock_irqrestore(&acm->write_lock, flags);
224
225         return rc;
226
227 }
228 /*
229  * attributes exported through sysfs
230  */
231 static ssize_t show_caps
232 (struct device *dev, struct device_attribute *attr, char *buf)
233 {
234         struct usb_interface *intf = to_usb_interface(dev);
235         struct acm *acm = usb_get_intfdata(intf);
236
237         return sprintf(buf, "%d", acm->ctrl_caps);
238 }
239 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
240
241 static ssize_t show_country_codes
242 (struct device *dev, struct device_attribute *attr, char *buf)
243 {
244         struct usb_interface *intf = to_usb_interface(dev);
245         struct acm *acm = usb_get_intfdata(intf);
246
247         memcpy(buf, acm->country_codes, acm->country_code_size);
248         return acm->country_code_size;
249 }
250
251 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
252
253 static ssize_t show_country_rel_date
254 (struct device *dev, struct device_attribute *attr, char *buf)
255 {
256         struct usb_interface *intf = to_usb_interface(dev);
257         struct acm *acm = usb_get_intfdata(intf);
258
259         return sprintf(buf, "%d", acm->country_rel_date);
260 }
261
262 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
263 /*
264  * Interrupt handlers for various ACM device responses
265  */
266
267 /* control interface reports status changes with "interrupt" transfers */
268 static void acm_ctrl_irq(struct urb *urb)
269 {
270         struct acm *acm = urb->context;
271         struct usb_cdc_notification *dr = urb->transfer_buffer;
272         struct tty_struct *tty;
273         unsigned char *data;
274         int newctrl;
275         int retval;
276         int status = urb->status;
277
278         switch (status) {
279         case 0:
280                 /* success */
281                 break;
282         case -ECONNRESET:
283         case -ENOENT:
284         case -ESHUTDOWN:
285                 /* this urb is terminated, clean up */
286                 dbg("%s - urb shutting down with status: %d", __func__, status);
287                 return;
288         default:
289                 dbg("%s - nonzero urb status received: %d", __func__, status);
290                 goto exit;
291         }
292
293         if (!ACM_READY(acm))
294                 goto exit;
295
296         data = (unsigned char *)(dr + 1);
297         switch (dr->bNotificationType) {
298         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
299                 dbg("%s network", dr->wValue ?
300                                         "connected to" : "disconnected from");
301                 break;
302
303         case USB_CDC_NOTIFY_SERIAL_STATE:
304                 tty = tty_port_tty_get(&acm->port);
305                 newctrl = get_unaligned_le16(data);
306
307                 if (tty) {
308                         if (!acm->clocal &&
309                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
310                                 dbg("calling hangup");
311                                 tty_hangup(tty);
312                         }
313                         tty_kref_put(tty);
314                 }
315
316                 acm->ctrlin = newctrl;
317
318                 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
319                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
320                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
321                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
322                         acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
323                         acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
324                         acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
325                         acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
326                         break;
327
328         default:
329                 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
330                         dr->bNotificationType, dr->wIndex,
331                         dr->wLength, data[0], data[1]);
332                 break;
333         }
334 exit:
335         usb_mark_last_busy(acm->dev);
336         retval = usb_submit_urb(urb, GFP_ATOMIC);
337         if (retval)
338                 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
339                         "result %d", __func__, retval);
340 }
341
342 /* data interface returns incoming bytes, or we got unthrottled */
343 static void acm_read_bulk(struct urb *urb)
344 {
345         struct acm_rb *buf;
346         struct acm_ru *rcv = urb->context;
347         struct acm *acm = rcv->instance;
348         int status = urb->status;
349
350         dbg("Entering acm_read_bulk with status %d", status);
351
352         if (!ACM_READY(acm)) {
353                 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
354                 return;
355         }
356         usb_mark_last_busy(acm->dev);
357
358         if (status)
359                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
360
361         buf = rcv->buffer;
362         buf->size = urb->actual_length;
363
364         if (likely(status == 0)) {
365                 spin_lock(&acm->read_lock);
366                 acm->processing++;
367                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
368                 list_add_tail(&buf->list, &acm->filled_read_bufs);
369                 spin_unlock(&acm->read_lock);
370         } else {
371                 /* we drop the buffer due to an error */
372                 spin_lock(&acm->read_lock);
373                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
374                 list_add(&buf->list, &acm->spare_read_bufs);
375                 spin_unlock(&acm->read_lock);
376                 /* nevertheless the tasklet must be kicked unconditionally
377                 so the queue cannot dry up */
378         }
379         if (likely(!acm->susp_count))
380                 tasklet_schedule(&acm->urb_task);
381 }
382
383 static void acm_rx_tasklet(unsigned long _acm)
384 {
385         struct acm *acm = (void *)_acm;
386         struct acm_rb *buf;
387         struct tty_struct *tty;
388         struct acm_ru *rcv;
389         unsigned long flags;
390         unsigned char throttled;
391
392         dbg("Entering acm_rx_tasklet");
393
394         if (!ACM_READY(acm)) {
395                 dbg("acm_rx_tasklet: ACM not ready");
396                 return;
397         }
398
399         spin_lock_irqsave(&acm->throttle_lock, flags);
400         throttled = acm->throttle;
401         spin_unlock_irqrestore(&acm->throttle_lock, flags);
402         if (throttled) {
403                 dbg("acm_rx_tasklet: throttled");
404                 return;
405         }
406
407         tty = tty_port_tty_get(&acm->port);
408
409 next_buffer:
410         spin_lock_irqsave(&acm->read_lock, flags);
411         if (list_empty(&acm->filled_read_bufs)) {
412                 spin_unlock_irqrestore(&acm->read_lock, flags);
413                 goto urbs;
414         }
415         buf = list_entry(acm->filled_read_bufs.next,
416                          struct acm_rb, list);
417         list_del(&buf->list);
418         spin_unlock_irqrestore(&acm->read_lock, flags);
419
420         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
421
422         if (tty) {
423                 spin_lock_irqsave(&acm->throttle_lock, flags);
424                 throttled = acm->throttle;
425                 spin_unlock_irqrestore(&acm->throttle_lock, flags);
426                 if (!throttled) {
427                         tty_buffer_request_room(tty, buf->size);
428                         tty_insert_flip_string(tty, buf->base, buf->size);
429                         tty_flip_buffer_push(tty);
430                 } else {
431                         tty_kref_put(tty);
432                         dbg("Throttling noticed");
433                         spin_lock_irqsave(&acm->read_lock, flags);
434                         list_add(&buf->list, &acm->filled_read_bufs);
435                         spin_unlock_irqrestore(&acm->read_lock, flags);
436                         return;
437                 }
438         }
439
440         spin_lock_irqsave(&acm->read_lock, flags);
441         list_add(&buf->list, &acm->spare_read_bufs);
442         spin_unlock_irqrestore(&acm->read_lock, flags);
443         goto next_buffer;
444
445 urbs:
446         tty_kref_put(tty);
447
448         while (!list_empty(&acm->spare_read_bufs)) {
449                 spin_lock_irqsave(&acm->read_lock, flags);
450                 if (list_empty(&acm->spare_read_urbs)) {
451                         acm->processing = 0;
452                         spin_unlock_irqrestore(&acm->read_lock, flags);
453                         return;
454                 }
455                 rcv = list_entry(acm->spare_read_urbs.next,
456                                  struct acm_ru, list);
457                 list_del(&rcv->list);
458                 spin_unlock_irqrestore(&acm->read_lock, flags);
459
460                 buf = list_entry(acm->spare_read_bufs.next,
461                                  struct acm_rb, list);
462                 list_del(&buf->list);
463
464                 rcv->buffer = buf;
465
466                 if (acm->is_int_ep)
467                         usb_fill_int_urb(rcv->urb, acm->dev,
468                                          acm->rx_endpoint,
469                                          buf->base,
470                                          acm->readsize,
471                                          acm_read_bulk, rcv, acm->bInterval);
472                 else
473                         usb_fill_bulk_urb(rcv->urb, acm->dev,
474                                           acm->rx_endpoint,
475                                           buf->base,
476                                           acm->readsize,
477                                           acm_read_bulk, rcv);
478                 rcv->urb->transfer_dma = buf->dma;
479                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
480
481                 /* This shouldn't kill the driver as unsuccessful URBs are
482                    returned to the free-urbs-pool and resubmited ASAP */
483                 spin_lock_irqsave(&acm->read_lock, flags);
484                 if (acm->susp_count ||
485                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
486                         list_add(&buf->list, &acm->spare_read_bufs);
487                         list_add(&rcv->list, &acm->spare_read_urbs);
488                         acm->processing = 0;
489                         spin_unlock_irqrestore(&acm->read_lock, flags);
490                         return;
491                 } else {
492                         spin_unlock_irqrestore(&acm->read_lock, flags);
493                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
494                 }
495         }
496         spin_lock_irqsave(&acm->read_lock, flags);
497         acm->processing = 0;
498         spin_unlock_irqrestore(&acm->read_lock, flags);
499 }
500
501 /* data interface wrote those outgoing bytes */
502 static void acm_write_bulk(struct urb *urb)
503 {
504         struct acm_wb *wb = urb->context;
505         struct acm *acm = wb->instance;
506         unsigned long flags;
507
508         if (verbose || urb->status
509                         || (urb->actual_length != urb->transfer_buffer_length))
510                 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
511                         urb->actual_length,
512                         urb->transfer_buffer_length,
513                         urb->status);
514
515         spin_lock_irqsave(&acm->write_lock, flags);
516         acm_write_done(acm, wb);
517         spin_unlock_irqrestore(&acm->write_lock, flags);
518         if (ACM_READY(acm))
519                 schedule_work(&acm->work);
520         else
521                 wake_up_interruptible(&acm->drain_wait);
522 }
523
524 static void acm_softint(struct work_struct *work)
525 {
526         struct acm *acm = container_of(work, struct acm, work);
527         struct tty_struct *tty;
528
529         dev_vdbg(&acm->data->dev, "tx work\n");
530         if (!ACM_READY(acm))
531                 return;
532         tty = tty_port_tty_get(&acm->port);
533         tty_wakeup(tty);
534         tty_kref_put(tty);
535 }
536
537 static void acm_waker(struct work_struct *waker)
538 {
539         struct acm *acm = container_of(waker, struct acm, waker);
540         int rv;
541
542         rv = usb_autopm_get_interface(acm->control);
543         if (rv < 0) {
544                 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
545                 return;
546         }
547         if (acm->delayed_wb) {
548                 acm_start_wb(acm, acm->delayed_wb);
549                 acm->delayed_wb = NULL;
550         }
551         usb_autopm_put_interface(acm->control);
552 }
553
554 /*
555  * TTY handlers
556  */
557
558 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
559 {
560         struct acm *acm;
561         int rv = -ENODEV;
562         int i;
563         dbg("Entering acm_tty_open.");
564
565         mutex_lock(&open_mutex);
566
567         acm = acm_table[tty->index];
568         if (!acm || !acm->dev)
569                 goto err_out;
570         else
571                 rv = 0;
572
573         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
574
575         tty->driver_data = acm;
576         tty_port_tty_set(&acm->port, tty);
577
578         if (usb_autopm_get_interface(acm->control) < 0)
579                 goto early_bail;
580         else
581                 acm->control->needs_remote_wakeup = 1;
582
583         mutex_lock(&acm->mutex);
584         if (acm->port.count++) {
585                 usb_autopm_put_interface(acm->control);
586                 goto done;
587         }
588
589         acm->ctrlurb->dev = acm->dev;
590         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
591                 dbg("usb_submit_urb(ctrl irq) failed");
592                 goto bail_out;
593         }
594
595         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
596             (acm->ctrl_caps & USB_CDC_CAP_LINE))
597                 goto full_bailout;
598
599         usb_autopm_put_interface(acm->control);
600
601         INIT_LIST_HEAD(&acm->spare_read_urbs);
602         INIT_LIST_HEAD(&acm->spare_read_bufs);
603         INIT_LIST_HEAD(&acm->filled_read_bufs);
604
605         for (i = 0; i < acm->rx_buflimit; i++)
606                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
607         for (i = 0; i < acm->rx_buflimit; i++)
608                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
609
610         acm->throttle = 0;
611
612         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
613         rv = tty_port_block_til_ready(&acm->port, tty, filp);
614         tasklet_schedule(&acm->urb_task);
615 done:
616         mutex_unlock(&acm->mutex);
617 err_out:
618         mutex_unlock(&open_mutex);
619         return rv;
620
621 full_bailout:
622         usb_kill_urb(acm->ctrlurb);
623 bail_out:
624         usb_autopm_put_interface(acm->control);
625         acm->port.count--;
626         mutex_unlock(&acm->mutex);
627 early_bail:
628         mutex_unlock(&open_mutex);
629         tty_port_tty_set(&acm->port, NULL);
630         return -EIO;
631 }
632
633 static void acm_tty_unregister(struct acm *acm)
634 {
635         int i, nr;
636
637         nr = acm->rx_buflimit;
638         tty_unregister_device(acm_tty_driver, acm->minor);
639         usb_put_intf(acm->control);
640         acm_table[acm->minor] = NULL;
641         usb_free_urb(acm->ctrlurb);
642         for (i = 0; i < ACM_NW; i++)
643                 usb_free_urb(acm->wb[i].urb);
644         for (i = 0; i < nr; i++)
645                 usb_free_urb(acm->ru[i].urb);
646         kfree(acm->country_codes);
647         kfree(acm);
648 }
649
650 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
651
652 static void acm_port_down(struct acm *acm, int drain)
653 {
654         int i, nr = acm->rx_buflimit;
655         mutex_lock(&open_mutex);
656         if (acm->dev) {
657                 usb_autopm_get_interface(acm->control);
658                 acm_set_control(acm, acm->ctrlout = 0);
659                 /* try letting the last writes drain naturally */
660                 if (drain) {
661                         wait_event_interruptible_timeout(acm->drain_wait,
662                                 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
663                                         ACM_CLOSE_TIMEOUT * HZ);
664                 }
665                 usb_kill_urb(acm->ctrlurb);
666                 for (i = 0; i < ACM_NW; i++)
667                         usb_kill_urb(acm->wb[i].urb);
668                 for (i = 0; i < nr; i++)
669                         usb_kill_urb(acm->ru[i].urb);
670                 acm->control->needs_remote_wakeup = 0;
671                 usb_autopm_put_interface(acm->control);
672         }
673         mutex_unlock(&open_mutex);
674 }
675
676 static void acm_tty_hangup(struct tty_struct *tty)
677 {
678         struct acm *acm = tty->driver_data;
679         tty_port_hangup(&acm->port);
680         acm_port_down(acm, 0);
681 }
682
683 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
684 {
685         struct acm *acm = tty->driver_data;
686
687         /* Perform the closing process and see if we need to do the hardware
688            shutdown */
689         if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)
690                 return;
691         acm_port_down(acm, 0);
692         tty_port_close_end(&acm->port, tty);
693         mutex_lock(&open_mutex);
694         tty_port_tty_set(&acm->port, NULL);
695         if (!acm->dev)
696                 acm_tty_unregister(acm);
697         mutex_unlock(&open_mutex);
698 }
699
700 static int acm_tty_write(struct tty_struct *tty,
701                                         const unsigned char *buf, int count)
702 {
703         struct acm *acm = tty->driver_data;
704         int stat;
705         unsigned long flags;
706         int wbn;
707         struct acm_wb *wb;
708
709         dbg("Entering acm_tty_write to write %d bytes,", count);
710
711         if (!ACM_READY(acm))
712                 return -EINVAL;
713         if (!count)
714                 return 0;
715
716         spin_lock_irqsave(&acm->write_lock, flags);
717         wbn = acm_wb_alloc(acm);
718         if (wbn < 0) {
719                 spin_unlock_irqrestore(&acm->write_lock, flags);
720                 return 0;
721         }
722         wb = &acm->wb[wbn];
723
724         count = (count > acm->writesize) ? acm->writesize : count;
725         dbg("Get %d bytes...", count);
726         memcpy(wb->buf, buf, count);
727         wb->len = count;
728         spin_unlock_irqrestore(&acm->write_lock, flags);
729
730         stat = acm_write_start(acm, wbn);
731         if (stat < 0)
732                 return stat;
733         return count;
734 }
735
736 static int acm_tty_write_room(struct tty_struct *tty)
737 {
738         struct acm *acm = tty->driver_data;
739         if (!ACM_READY(acm))
740                 return -EINVAL;
741         /*
742          * Do not let the line discipline to know that we have a reserve,
743          * or it might get too enthusiastic.
744          */
745         return acm_wb_is_avail(acm) ? acm->writesize : 0;
746 }
747
748 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
749 {
750         struct acm *acm = tty->driver_data;
751         if (!ACM_READY(acm))
752                 return 0;
753         /*
754          * This is inaccurate (overcounts), but it works.
755          */
756         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
757 }
758
759 static void acm_tty_throttle(struct tty_struct *tty)
760 {
761         struct acm *acm = tty->driver_data;
762         if (!ACM_READY(acm))
763                 return;
764         spin_lock_bh(&acm->throttle_lock);
765         acm->throttle = 1;
766         spin_unlock_bh(&acm->throttle_lock);
767 }
768
769 static void acm_tty_unthrottle(struct tty_struct *tty)
770 {
771         struct acm *acm = tty->driver_data;
772         if (!ACM_READY(acm))
773                 return;
774         spin_lock_bh(&acm->throttle_lock);
775         acm->throttle = 0;
776         spin_unlock_bh(&acm->throttle_lock);
777         tasklet_schedule(&acm->urb_task);
778 }
779
780 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
781 {
782         struct acm *acm = tty->driver_data;
783         int retval;
784         if (!ACM_READY(acm))
785                 return -EINVAL;
786         retval = acm_send_break(acm, state ? 0xffff : 0);
787         if (retval < 0)
788                 dbg("send break failed");
789         return retval;
790 }
791
792 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
793 {
794         struct acm *acm = tty->driver_data;
795
796         if (!ACM_READY(acm))
797                 return -EINVAL;
798
799         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
800                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
801                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
802                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
803                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
804                TIOCM_CTS;
805 }
806
807 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
808                             unsigned int set, unsigned int clear)
809 {
810         struct acm *acm = tty->driver_data;
811         unsigned int newctrl;
812
813         if (!ACM_READY(acm))
814                 return -EINVAL;
815
816         newctrl = acm->ctrlout;
817         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
818                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
819         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
820                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
821
822         newctrl = (newctrl & ~clear) | set;
823
824         if (acm->ctrlout == newctrl)
825                 return 0;
826         return acm_set_control(acm, acm->ctrlout = newctrl);
827 }
828
829 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
830                                         unsigned int cmd, unsigned long arg)
831 {
832         struct acm *acm = tty->driver_data;
833
834         if (!ACM_READY(acm))
835                 return -EINVAL;
836
837         return -ENOIOCTLCMD;
838 }
839
840 static const __u32 acm_tty_speed[] = {
841         0, 50, 75, 110, 134, 150, 200, 300, 600,
842         1200, 1800, 2400, 4800, 9600, 19200, 38400,
843         57600, 115200, 230400, 460800, 500000, 576000,
844         921600, 1000000, 1152000, 1500000, 2000000,
845         2500000, 3000000, 3500000, 4000000
846 };
847
848 static const __u8 acm_tty_size[] = {
849         5, 6, 7, 8
850 };
851
852 static void acm_tty_set_termios(struct tty_struct *tty,
853                                                 struct ktermios *termios_old)
854 {
855         struct acm *acm = tty->driver_data;
856         struct ktermios *termios = tty->termios;
857         struct usb_cdc_line_coding newline;
858         int newctrl = acm->ctrlout;
859
860         if (!ACM_READY(acm))
861                 return;
862
863         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
864         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
865         newline.bParityType = termios->c_cflag & PARENB ?
866                                 (termios->c_cflag & PARODD ? 1 : 2) +
867                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
868         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
869         /* FIXME: Needs to clear unsupported bits in the termios */
870         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
871
872         if (!newline.dwDTERate) {
873                 newline.dwDTERate = acm->line.dwDTERate;
874                 newctrl &= ~ACM_CTRL_DTR;
875         } else
876                 newctrl |=  ACM_CTRL_DTR;
877
878         if (newctrl != acm->ctrlout)
879                 acm_set_control(acm, acm->ctrlout = newctrl);
880
881         if (memcmp(&acm->line, &newline, sizeof newline)) {
882                 memcpy(&acm->line, &newline, sizeof newline);
883                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
884                         newline.bCharFormat, newline.bParityType,
885                         newline.bDataBits);
886                 acm_set_line(acm, &acm->line);
887         }
888 }
889
890 /*
891  * USB probe and disconnect routines.
892  */
893
894 /* Little helpers: write/read buffers free */
895 static void acm_write_buffers_free(struct acm *acm)
896 {
897         int i;
898         struct acm_wb *wb;
899         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
900
901         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
902                 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
903 }
904
905 static void acm_read_buffers_free(struct acm *acm)
906 {
907         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
908         int i, n = acm->rx_buflimit;
909
910         for (i = 0; i < n; i++)
911                 usb_buffer_free(usb_dev, acm->readsize,
912                                         acm->rb[i].base, acm->rb[i].dma);
913 }
914
915 /* Little helper: write buffers allocate */
916 static int acm_write_buffers_alloc(struct acm *acm)
917 {
918         int i;
919         struct acm_wb *wb;
920
921         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
922                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
923                     &wb->dmah);
924                 if (!wb->buf) {
925                         while (i != 0) {
926                                 --i;
927                                 --wb;
928                                 usb_buffer_free(acm->dev, acm->writesize,
929                                     wb->buf, wb->dmah);
930                         }
931                         return -ENOMEM;
932                 }
933         }
934         return 0;
935 }
936
937 static int acm_probe(struct usb_interface *intf,
938                      const struct usb_device_id *id)
939 {
940         struct usb_cdc_union_desc *union_header = NULL;
941         struct usb_cdc_country_functional_desc *cfd = NULL;
942         unsigned char *buffer = intf->altsetting->extra;
943         int buflen = intf->altsetting->extralen;
944         struct usb_interface *control_interface;
945         struct usb_interface *data_interface;
946         struct usb_endpoint_descriptor *epctrl = NULL;
947         struct usb_endpoint_descriptor *epread = NULL;
948         struct usb_endpoint_descriptor *epwrite = NULL;
949         struct usb_device *usb_dev = interface_to_usbdev(intf);
950         struct acm *acm;
951         int minor;
952         int ctrlsize, readsize;
953         u8 *buf;
954         u8 ac_management_function = 0;
955         u8 call_management_function = 0;
956         int call_interface_num = -1;
957         int data_interface_num;
958         unsigned long quirks;
959         int num_rx_buf;
960         int i;
961         int combined_interfaces = 0;
962
963         /* normal quirks */
964         quirks = (unsigned long)id->driver_info;
965         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
966
967         /* handle quirks deadly to normal probing*/
968         if (quirks == NO_UNION_NORMAL) {
969                 data_interface = usb_ifnum_to_if(usb_dev, 1);
970                 control_interface = usb_ifnum_to_if(usb_dev, 0);
971                 goto skip_normal_probe;
972         }
973
974         /* normal probing*/
975         if (!buffer) {
976                 dev_err(&intf->dev, "Weird descriptor references\n");
977                 return -EINVAL;
978         }
979
980         if (!buflen) {
981                 if (intf->cur_altsetting->endpoint->extralen &&
982                                 intf->cur_altsetting->endpoint->extra) {
983                         dev_dbg(&intf->dev,
984                                 "Seeking extra descriptors on endpoint\n");
985                         buflen = intf->cur_altsetting->endpoint->extralen;
986                         buffer = intf->cur_altsetting->endpoint->extra;
987                 } else {
988                         dev_err(&intf->dev,
989                                 "Zero length descriptor references\n");
990                         return -EINVAL;
991                 }
992         }
993
994         while (buflen > 0) {
995                 if (buffer[1] != USB_DT_CS_INTERFACE) {
996                         dev_err(&intf->dev, "skipping garbage\n");
997                         goto next_desc;
998                 }
999
1000                 switch (buffer[2]) {
1001                 case USB_CDC_UNION_TYPE: /* we've found it */
1002                         if (union_header) {
1003                                 dev_err(&intf->dev, "More than one "
1004                                         "union descriptor, skipping ...\n");
1005                                 goto next_desc;
1006                         }
1007                         union_header = (struct usb_cdc_union_desc *)buffer;
1008                         break;
1009                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1010                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1011                         break;
1012                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1013                         break; /* for now we ignore it */
1014                 case USB_CDC_ACM_TYPE:
1015                         ac_management_function = buffer[3];
1016                         break;
1017                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1018                         call_management_function = buffer[3];
1019                         call_interface_num = buffer[4];
1020                         if ((call_management_function & 3) != 3)
1021                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1022                         break;
1023                 default:
1024                         /* there are LOTS more CDC descriptors that
1025                          * could legitimately be found here.
1026                          */
1027                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1028                                         "type %02x, length %d\n",
1029                                         buffer[2], buffer[0]);
1030                         break;
1031                 }
1032 next_desc:
1033                 buflen -= buffer[0];
1034                 buffer += buffer[0];
1035         }
1036
1037         if (!union_header) {
1038                 if (call_interface_num > 0) {
1039                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1040                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1041                         control_interface = intf;
1042                 } else {
1043                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1044                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1045                                 return -ENODEV;
1046                         } else {
1047                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1048                                 combined_interfaces = 1;
1049                                 control_interface = data_interface = intf;
1050                                 goto look_for_collapsed_interface;
1051                         }
1052                 }
1053         } else {
1054                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1055                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1056                 if (!control_interface || !data_interface) {
1057                         dev_dbg(&intf->dev, "no interfaces\n");
1058                         return -ENODEV;
1059                 }
1060         }
1061
1062         if (data_interface_num != call_interface_num)
1063                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1064
1065         if (control_interface == data_interface) {
1066                 /* some broken devices designed for windows work this way */
1067                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1068                 combined_interfaces = 1;
1069                 /* a popular other OS doesn't use it */
1070                 quirks |= NO_CAP_LINE;
1071                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1072                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1073                         return -EINVAL;
1074                 }
1075 look_for_collapsed_interface:
1076                 for (i = 0; i < 3; i++) {
1077                         struct usb_endpoint_descriptor *ep;
1078                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1079
1080                         if (usb_endpoint_is_int_in(ep))
1081                                 epctrl = ep;
1082                         else if (usb_endpoint_is_bulk_out(ep))
1083                                 epwrite = ep;
1084                         else if (usb_endpoint_is_bulk_in(ep))
1085                                 epread = ep;
1086                         else
1087                                 return -EINVAL;
1088                 }
1089                 if (!epctrl || !epread || !epwrite)
1090                         return -ENODEV;
1091                 else
1092                         goto made_compressed_probe;
1093         }
1094
1095 skip_normal_probe:
1096
1097         /*workaround for switched interfaces */
1098         if (data_interface->cur_altsetting->desc.bInterfaceClass
1099                                                 != CDC_DATA_INTERFACE_TYPE) {
1100                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1101                                                 == CDC_DATA_INTERFACE_TYPE) {
1102                         struct usb_interface *t;
1103                         dev_dbg(&intf->dev,
1104                                 "Your device has switched interfaces.\n");
1105                         t = control_interface;
1106                         control_interface = data_interface;
1107                         data_interface = t;
1108                 } else {
1109                         return -EINVAL;
1110                 }
1111         }
1112
1113         /* Accept probe requests only for the control interface */
1114         if (!combined_interfaces && intf != control_interface)
1115                 return -ENODEV;
1116
1117         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1118                 /* valid in this context */
1119                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1120                 return -EBUSY;
1121         }
1122
1123
1124         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1125                 return -EINVAL;
1126
1127         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1128         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1129         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1130
1131
1132         /* workaround for switched endpoints */
1133         if (!usb_endpoint_dir_in(epread)) {
1134                 /* descriptors are swapped */
1135                 struct usb_endpoint_descriptor *t;
1136                 dev_dbg(&intf->dev,
1137                         "The data interface has switched endpoints\n");
1138                 t = epread;
1139                 epread = epwrite;
1140                 epwrite = t;
1141         }
1142 made_compressed_probe:
1143         dbg("interfaces are valid");
1144         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1145
1146         if (minor == ACM_TTY_MINORS) {
1147                 dev_err(&intf->dev, "no more free acm devices\n");
1148                 return -ENODEV;
1149         }
1150
1151         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1152         if (acm == NULL) {
1153                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1154                 goto alloc_fail;
1155         }
1156
1157         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1158         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1159                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1160         acm->combined_interfaces = combined_interfaces;
1161         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1162         acm->control = control_interface;
1163         acm->data = data_interface;
1164         acm->minor = minor;
1165         acm->dev = usb_dev;
1166         acm->ctrl_caps = ac_management_function;
1167         if (quirks & NO_CAP_LINE)
1168                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1169         acm->ctrlsize = ctrlsize;
1170         acm->readsize = readsize;
1171         acm->rx_buflimit = num_rx_buf;
1172         acm->urb_task.func = acm_rx_tasklet;
1173         acm->urb_task.data = (unsigned long) acm;
1174         INIT_WORK(&acm->work, acm_softint);
1175         INIT_WORK(&acm->waker, acm_waker);
1176         init_waitqueue_head(&acm->drain_wait);
1177         spin_lock_init(&acm->throttle_lock);
1178         spin_lock_init(&acm->write_lock);
1179         spin_lock_init(&acm->read_lock);
1180         mutex_init(&acm->mutex);
1181         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1182         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1183         if (acm->is_int_ep)
1184                 acm->bInterval = epread->bInterval;
1185         tty_port_init(&acm->port);
1186         acm->port.ops = &acm_port_ops;
1187
1188         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1189         if (!buf) {
1190                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1191                 goto alloc_fail2;
1192         }
1193         acm->ctrl_buffer = buf;
1194
1195         if (acm_write_buffers_alloc(acm) < 0) {
1196                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1197                 goto alloc_fail4;
1198         }
1199
1200         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1201         if (!acm->ctrlurb) {
1202                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1203                 goto alloc_fail5;
1204         }
1205         for (i = 0; i < num_rx_buf; i++) {
1206                 struct acm_ru *rcv = &(acm->ru[i]);
1207
1208                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1209                 if (rcv->urb == NULL) {
1210                         dev_dbg(&intf->dev,
1211                                 "out of memory (read urbs usb_alloc_urb)\n");
1212                         goto alloc_fail7;
1213                 }
1214
1215                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1216                 rcv->instance = acm;
1217         }
1218         for (i = 0; i < num_rx_buf; i++) {
1219                 struct acm_rb *rb = &(acm->rb[i]);
1220
1221                 rb->base = usb_buffer_alloc(acm->dev, readsize,
1222                                 GFP_KERNEL, &rb->dma);
1223                 if (!rb->base) {
1224                         dev_dbg(&intf->dev,
1225                                 "out of memory (read bufs usb_buffer_alloc)\n");
1226                         goto alloc_fail7;
1227                 }
1228         }
1229         for (i = 0; i < ACM_NW; i++) {
1230                 struct acm_wb *snd = &(acm->wb[i]);
1231
1232                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1233                 if (snd->urb == NULL) {
1234                         dev_dbg(&intf->dev,
1235                                 "out of memory (write urbs usb_alloc_urb)");
1236                         goto alloc_fail7;
1237                 }
1238
1239                 if (usb_endpoint_xfer_int(epwrite))
1240                         usb_fill_int_urb(snd->urb, usb_dev,
1241                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1242                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1243                 else
1244                         usb_fill_bulk_urb(snd->urb, usb_dev,
1245                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1246                                 NULL, acm->writesize, acm_write_bulk, snd);
1247                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1248                 snd->instance = acm;
1249         }
1250
1251         usb_set_intfdata(intf, acm);
1252
1253         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1254         if (i < 0)
1255                 goto alloc_fail8;
1256
1257         if (cfd) { /* export the country data */
1258                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1259                 if (!acm->country_codes)
1260                         goto skip_countries;
1261                 acm->country_code_size = cfd->bLength - 4;
1262                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1263                                                         cfd->bLength - 4);
1264                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1265
1266                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1267                 if (i < 0) {
1268                         kfree(acm->country_codes);
1269                         goto skip_countries;
1270                 }
1271
1272                 i = device_create_file(&intf->dev,
1273                                                 &dev_attr_iCountryCodeRelDate);
1274                 if (i < 0) {
1275                         kfree(acm->country_codes);
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         acm_table[minor] = acm;
1304
1305         return 0;
1306 alloc_fail8:
1307         for (i = 0; i < ACM_NW; i++)
1308                 usb_free_urb(acm->wb[i].urb);
1309 alloc_fail7:
1310         acm_read_buffers_free(acm);
1311         for (i = 0; i < num_rx_buf; i++)
1312                 usb_free_urb(acm->ru[i].urb);
1313         usb_free_urb(acm->ctrlurb);
1314 alloc_fail5:
1315         acm_write_buffers_free(acm);
1316 alloc_fail4:
1317         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1318 alloc_fail2:
1319         kfree(acm);
1320 alloc_fail:
1321         return -ENOMEM;
1322 }
1323
1324 static void stop_data_traffic(struct acm *acm)
1325 {
1326         int i;
1327         dbg("Entering stop_data_traffic");
1328
1329         tasklet_disable(&acm->urb_task);
1330
1331         usb_kill_urb(acm->ctrlurb);
1332         for (i = 0; i < ACM_NW; i++)
1333                 usb_kill_urb(acm->wb[i].urb);
1334         for (i = 0; i < acm->rx_buflimit; i++)
1335                 usb_kill_urb(acm->ru[i].urb);
1336
1337         tasklet_enable(&acm->urb_task);
1338
1339         cancel_work_sync(&acm->work);
1340         cancel_work_sync(&acm->waker);
1341 }
1342
1343 static void acm_disconnect(struct usb_interface *intf)
1344 {
1345         struct acm *acm = usb_get_intfdata(intf);
1346         struct usb_device *usb_dev = interface_to_usbdev(intf);
1347         struct tty_struct *tty;
1348
1349         /* sibling interface is already cleaning up */
1350         if (!acm)
1351                 return;
1352
1353         mutex_lock(&open_mutex);
1354         if (acm->country_codes) {
1355                 device_remove_file(&acm->control->dev,
1356                                 &dev_attr_wCountryCodes);
1357                 device_remove_file(&acm->control->dev,
1358                                 &dev_attr_iCountryCodeRelDate);
1359         }
1360         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1361         acm->dev = NULL;
1362         usb_set_intfdata(acm->control, NULL);
1363         usb_set_intfdata(acm->data, NULL);
1364
1365         stop_data_traffic(acm);
1366
1367         acm_write_buffers_free(acm);
1368         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1369                                                                 acm->ctrl_dma);
1370         acm_read_buffers_free(acm);
1371
1372         if (!acm->combined_interfaces)
1373                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1374                                         acm->data : acm->control);
1375
1376         if (acm->port.count == 0) {
1377                 acm_tty_unregister(acm);
1378                 mutex_unlock(&open_mutex);
1379                 return;
1380         }
1381
1382         mutex_unlock(&open_mutex);
1383         tty = tty_port_tty_get(&acm->port);
1384         if (tty) {
1385                 tty_hangup(tty);
1386                 tty_kref_put(tty);
1387         }
1388 }
1389
1390 #ifdef CONFIG_PM
1391 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1392 {
1393         struct acm *acm = usb_get_intfdata(intf);
1394         int cnt;
1395
1396         if (message.event & PM_EVENT_AUTO) {
1397                 int b;
1398
1399                 spin_lock_irq(&acm->read_lock);
1400                 spin_lock(&acm->write_lock);
1401                 b = acm->processing + acm->transmitting;
1402                 spin_unlock(&acm->write_lock);
1403                 spin_unlock_irq(&acm->read_lock);
1404                 if (b)
1405                         return -EBUSY;
1406         }
1407
1408         spin_lock_irq(&acm->read_lock);
1409         spin_lock(&acm->write_lock);
1410         cnt = acm->susp_count++;
1411         spin_unlock(&acm->write_lock);
1412         spin_unlock_irq(&acm->read_lock);
1413
1414         if (cnt)
1415                 return 0;
1416         /*
1417         we treat opened interfaces differently,
1418         we must guard against open
1419         */
1420         mutex_lock(&acm->mutex);
1421
1422         if (acm->port.count)
1423                 stop_data_traffic(acm);
1424
1425         mutex_unlock(&acm->mutex);
1426         return 0;
1427 }
1428
1429 static int acm_resume(struct usb_interface *intf)
1430 {
1431         struct acm *acm = usb_get_intfdata(intf);
1432         int rv = 0;
1433         int cnt;
1434
1435         spin_lock_irq(&acm->read_lock);
1436         acm->susp_count -= 1;
1437         cnt = acm->susp_count;
1438         spin_unlock_irq(&acm->read_lock);
1439
1440         if (cnt)
1441                 return 0;
1442
1443         mutex_lock(&acm->mutex);
1444         if (acm->port.count) {
1445                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1446                 if (rv < 0)
1447                         goto err_out;
1448
1449                 tasklet_schedule(&acm->urb_task);
1450         }
1451
1452 err_out:
1453         mutex_unlock(&acm->mutex);
1454         return rv;
1455 }
1456
1457 #endif /* CONFIG_PM */
1458 /*
1459  * USB driver structure.
1460  */
1461
1462 static struct usb_device_id acm_ids[] = {
1463         /* quirky and broken devices */
1464         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1465         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1466         },
1467         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1468         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1469         },
1470         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1471         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1472         },
1473         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1474         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1475         },
1476         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1477         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1478         },
1479         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1480         .driver_info = SINGLE_RX_URB,
1481         },
1482         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1483         .driver_info = SINGLE_RX_URB, /* firmware bug */
1484         },
1485         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1486         .driver_info = SINGLE_RX_URB, /* firmware bug */
1487         },
1488         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1489         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1490         },
1491         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1492         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1493         },
1494         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1495         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1496         },
1497         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1498         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1499         },
1500         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1501         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1502         },
1503         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1504         },
1505         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1506         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1507                                            data interface instead of
1508                                            communications interface.
1509                                            Maybe we should define a new
1510                                            quirk for this. */
1511         },
1512         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1513         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1514         },
1515
1516         /* control interfaces with various AT-command sets */
1517         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1518                 USB_CDC_ACM_PROTO_AT_V25TER) },
1519         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1520                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1521         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1522                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1523         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1524                 USB_CDC_ACM_PROTO_AT_GSM) },
1525         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1526                 USB_CDC_ACM_PROTO_AT_3G) },
1527         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1528                 USB_CDC_ACM_PROTO_AT_CDMA) },
1529
1530         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1531         { }
1532 };
1533
1534 MODULE_DEVICE_TABLE(usb, acm_ids);
1535
1536 static struct usb_driver acm_driver = {
1537         .name =         "cdc_acm",
1538         .probe =        acm_probe,
1539         .disconnect =   acm_disconnect,
1540 #ifdef CONFIG_PM
1541         .suspend =      acm_suspend,
1542         .resume =       acm_resume,
1543 #endif
1544         .id_table =     acm_ids,
1545 #ifdef CONFIG_PM
1546         .supports_autosuspend = 1,
1547 #endif
1548 };
1549
1550 /*
1551  * TTY driver structures.
1552  */
1553
1554 static const struct tty_operations acm_ops = {
1555         .open =                 acm_tty_open,
1556         .close =                acm_tty_close,
1557         .hangup =               acm_tty_hangup,
1558         .write =                acm_tty_write,
1559         .write_room =           acm_tty_write_room,
1560         .ioctl =                acm_tty_ioctl,
1561         .throttle =             acm_tty_throttle,
1562         .unthrottle =           acm_tty_unthrottle,
1563         .chars_in_buffer =      acm_tty_chars_in_buffer,
1564         .break_ctl =            acm_tty_break_ctl,
1565         .set_termios =          acm_tty_set_termios,
1566         .tiocmget =             acm_tty_tiocmget,
1567         .tiocmset =             acm_tty_tiocmset,
1568 };
1569
1570 /*
1571  * Init / exit.
1572  */
1573
1574 static int __init acm_init(void)
1575 {
1576         int retval;
1577         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1578         if (!acm_tty_driver)
1579                 return -ENOMEM;
1580         acm_tty_driver->owner = THIS_MODULE,
1581         acm_tty_driver->driver_name = "acm",
1582         acm_tty_driver->name = "ttyACM",
1583         acm_tty_driver->major = ACM_TTY_MAJOR,
1584         acm_tty_driver->minor_start = 0,
1585         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1586         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1587         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1588         acm_tty_driver->init_termios = tty_std_termios;
1589         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1590                                                                 HUPCL | CLOCAL;
1591         tty_set_operations(acm_tty_driver, &acm_ops);
1592
1593         retval = tty_register_driver(acm_tty_driver);
1594         if (retval) {
1595                 put_tty_driver(acm_tty_driver);
1596                 return retval;
1597         }
1598
1599         retval = usb_register(&acm_driver);
1600         if (retval) {
1601                 tty_unregister_driver(acm_tty_driver);
1602                 put_tty_driver(acm_tty_driver);
1603                 return retval;
1604         }
1605
1606         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1607                DRIVER_DESC "\n");
1608
1609         return 0;
1610 }
1611
1612 static void __exit acm_exit(void)
1613 {
1614         usb_deregister(&acm_driver);
1615         tty_unregister_driver(acm_tty_driver);
1616         put_tty_driver(acm_tty_driver);
1617 }
1618
1619 module_init(acm_init);
1620 module_exit(acm_exit);
1621
1622 MODULE_AUTHOR(DRIVER_AUTHOR);
1623 MODULE_DESCRIPTION(DRIVER_DESC);
1624 MODULE_LICENSE("GPL");
1625 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);