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