4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
6 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
7 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
9 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
11 * USB Abstract Control Model driver for USB modems and ISDN adapters
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
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
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.
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.
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
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>
77 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
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"
86 static struct usb_driver acm_driver;
87 static struct tty_driver *acm_tty_driver;
88 static struct acm *acm_table[ACM_TTY_MINORS];
90 static DEFINE_MUTEX(open_mutex);
92 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
94 static const struct tty_port_operations acm_port_ops = {
104 * Functions for ACM control messages.
107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
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,
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;
119 /* devices aren't required to support these requests.
120 * the cdc acm descriptor tells whether they do...
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)
130 * Write buffer management.
131 * All of these assume proper locks taken by the caller.
134 static int acm_wb_alloc(struct acm *acm)
147 wbn = (wbn + 1) % ACM_NW;
153 static int acm_wb_is_avail(struct acm *acm)
159 spin_lock_irqsave(&acm->write_lock, flags);
160 for (i = 0; i < ACM_NW; i++)
162 spin_unlock_irqrestore(&acm->write_lock, flags);
167 * Finish write. Caller must hold acm->write_lock
169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
173 usb_autopm_put_interface_async(acm->control);
179 * the caller is responsible for locking
182 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
188 wb->urb->transfer_buffer = wb->buf;
189 wb->urb->transfer_dma = wb->dmah;
190 wb->urb->transfer_buffer_length = wb->len;
191 wb->urb->dev = acm->dev;
193 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
195 dbg("usb_submit_urb(write bulk) failed: %d", rc);
196 acm_write_done(acm, wb);
201 static int acm_write_start(struct acm *acm, int wbn)
204 struct acm_wb *wb = &acm->wb[wbn];
207 spin_lock_irqsave(&acm->write_lock, flags);
210 spin_unlock_irqrestore(&acm->write_lock, flags);
214 dbg("%s susp_count: %d", __func__, acm->susp_count);
215 usb_autopm_get_interface_async(acm->control);
216 if (acm->susp_count) {
217 if (!acm->delayed_wb)
218 acm->delayed_wb = wb;
220 usb_autopm_put_interface_async(acm->control);
221 spin_unlock_irqrestore(&acm->write_lock, flags);
222 return 0; /* A white lie */
224 usb_mark_last_busy(acm->dev);
226 rc = acm_start_wb(acm, wb);
227 spin_unlock_irqrestore(&acm->write_lock, flags);
233 * attributes exported through sysfs
235 static ssize_t show_caps
236 (struct device *dev, struct device_attribute *attr, char *buf)
238 struct usb_interface *intf = to_usb_interface(dev);
239 struct acm *acm = usb_get_intfdata(intf);
241 return sprintf(buf, "%d", acm->ctrl_caps);
243 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
245 static ssize_t show_country_codes
246 (struct device *dev, struct device_attribute *attr, char *buf)
248 struct usb_interface *intf = to_usb_interface(dev);
249 struct acm *acm = usb_get_intfdata(intf);
251 memcpy(buf, acm->country_codes, acm->country_code_size);
252 return acm->country_code_size;
255 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
257 static ssize_t show_country_rel_date
258 (struct device *dev, struct device_attribute *attr, char *buf)
260 struct usb_interface *intf = to_usb_interface(dev);
261 struct acm *acm = usb_get_intfdata(intf);
263 return sprintf(buf, "%d", acm->country_rel_date);
266 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
268 * Interrupt handlers for various ACM device responses
271 /* control interface reports status changes with "interrupt" transfers */
272 static void acm_ctrl_irq(struct urb *urb)
274 struct acm *acm = urb->context;
275 struct usb_cdc_notification *dr = urb->transfer_buffer;
276 struct tty_struct *tty;
280 int status = urb->status;
289 /* this urb is terminated, clean up */
290 dbg("%s - urb shutting down with status: %d", __func__, status);
293 dbg("%s - nonzero urb status received: %d", __func__, status);
300 data = (unsigned char *)(dr + 1);
301 switch (dr->bNotificationType) {
302 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
303 dbg("%s network", dr->wValue ?
304 "connected to" : "disconnected from");
307 case USB_CDC_NOTIFY_SERIAL_STATE:
308 tty = tty_port_tty_get(&acm->port);
309 newctrl = get_unaligned_le16(data);
313 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
314 dbg("calling hangup");
320 acm->ctrlin = newctrl;
322 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
323 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
328 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
329 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
333 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
334 dr->bNotificationType, dr->wIndex,
335 dr->wLength, data[0], data[1]);
339 usb_mark_last_busy(acm->dev);
340 retval = usb_submit_urb(urb, GFP_ATOMIC);
342 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
343 "result %d", __func__, retval);
346 /* data interface returns incoming bytes, or we got unthrottled */
347 static void acm_read_bulk(struct urb *urb)
350 struct acm_ru *rcv = urb->context;
351 struct acm *acm = rcv->instance;
352 int status = urb->status;
354 dbg("Entering acm_read_bulk with status %d", status);
356 if (!ACM_READY(acm)) {
357 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
360 usb_mark_last_busy(acm->dev);
363 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
366 buf->size = urb->actual_length;
368 if (likely(status == 0)) {
369 spin_lock(&acm->read_lock);
371 list_add_tail(&rcv->list, &acm->spare_read_urbs);
372 list_add_tail(&buf->list, &acm->filled_read_bufs);
373 spin_unlock(&acm->read_lock);
375 /* we drop the buffer due to an error */
376 spin_lock(&acm->read_lock);
377 list_add_tail(&rcv->list, &acm->spare_read_urbs);
378 list_add(&buf->list, &acm->spare_read_bufs);
379 spin_unlock(&acm->read_lock);
380 /* nevertheless the tasklet must be kicked unconditionally
381 so the queue cannot dry up */
383 if (likely(!acm->susp_count))
384 tasklet_schedule(&acm->urb_task);
387 static void acm_rx_tasklet(unsigned long _acm)
389 struct acm *acm = (void *)_acm;
391 struct tty_struct *tty;
394 unsigned char throttled;
396 dbg("Entering acm_rx_tasklet");
398 if (!ACM_READY(acm)) {
399 dbg("acm_rx_tasklet: ACM not ready");
403 spin_lock_irqsave(&acm->throttle_lock, flags);
404 throttled = acm->throttle;
405 spin_unlock_irqrestore(&acm->throttle_lock, flags);
407 dbg("acm_rx_tasklet: throttled");
411 tty = tty_port_tty_get(&acm->port);
414 spin_lock_irqsave(&acm->read_lock, flags);
415 if (list_empty(&acm->filled_read_bufs)) {
416 spin_unlock_irqrestore(&acm->read_lock, flags);
419 buf = list_entry(acm->filled_read_bufs.next,
420 struct acm_rb, list);
421 list_del(&buf->list);
422 spin_unlock_irqrestore(&acm->read_lock, flags);
424 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
427 spin_lock_irqsave(&acm->throttle_lock, flags);
428 throttled = acm->throttle;
429 spin_unlock_irqrestore(&acm->throttle_lock, flags);
431 tty_insert_flip_string(tty, buf->base, buf->size);
432 tty_flip_buffer_push(tty);
435 dbg("Throttling noticed");
436 spin_lock_irqsave(&acm->read_lock, flags);
437 list_add(&buf->list, &acm->filled_read_bufs);
438 spin_unlock_irqrestore(&acm->read_lock, flags);
443 spin_lock_irqsave(&acm->read_lock, flags);
444 list_add(&buf->list, &acm->spare_read_bufs);
445 spin_unlock_irqrestore(&acm->read_lock, flags);
451 while (!list_empty(&acm->spare_read_bufs)) {
452 spin_lock_irqsave(&acm->read_lock, flags);
453 if (list_empty(&acm->spare_read_urbs)) {
455 spin_unlock_irqrestore(&acm->read_lock, flags);
458 rcv = list_entry(acm->spare_read_urbs.next,
459 struct acm_ru, list);
460 list_del(&rcv->list);
461 spin_unlock_irqrestore(&acm->read_lock, flags);
463 buf = list_entry(acm->spare_read_bufs.next,
464 struct acm_rb, list);
465 list_del(&buf->list);
470 usb_fill_int_urb(rcv->urb, acm->dev,
474 acm_read_bulk, rcv, acm->bInterval);
476 usb_fill_bulk_urb(rcv->urb, acm->dev,
481 rcv->urb->transfer_dma = buf->dma;
482 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
484 /* This shouldn't kill the driver as unsuccessful URBs are
485 returned to the free-urbs-pool and resubmited ASAP */
486 spin_lock_irqsave(&acm->read_lock, flags);
487 if (acm->susp_count ||
488 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
489 list_add(&buf->list, &acm->spare_read_bufs);
490 list_add(&rcv->list, &acm->spare_read_urbs);
492 spin_unlock_irqrestore(&acm->read_lock, flags);
495 spin_unlock_irqrestore(&acm->read_lock, flags);
496 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
499 spin_lock_irqsave(&acm->read_lock, flags);
501 spin_unlock_irqrestore(&acm->read_lock, flags);
504 /* data interface wrote those outgoing bytes */
505 static void acm_write_bulk(struct urb *urb)
507 struct acm_wb *wb = urb->context;
508 struct acm *acm = wb->instance;
511 if (verbose || urb->status
512 || (urb->actual_length != urb->transfer_buffer_length))
513 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
515 urb->transfer_buffer_length,
518 spin_lock_irqsave(&acm->write_lock, flags);
519 acm_write_done(acm, wb);
520 spin_unlock_irqrestore(&acm->write_lock, flags);
522 schedule_work(&acm->work);
524 wake_up_interruptible(&acm->drain_wait);
527 static void acm_softint(struct work_struct *work)
529 struct acm *acm = container_of(work, struct acm, work);
530 struct tty_struct *tty;
532 dev_vdbg(&acm->data->dev, "tx work\n");
535 tty = tty_port_tty_get(&acm->port);
544 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
549 dbg("Entering acm_tty_open.");
551 mutex_lock(&open_mutex);
553 acm = acm_table[tty->index];
554 if (!acm || !acm->dev)
559 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
561 tty->driver_data = acm;
562 tty_port_tty_set(&acm->port, tty);
564 if (usb_autopm_get_interface(acm->control) < 0)
567 acm->control->needs_remote_wakeup = 1;
569 mutex_lock(&acm->mutex);
570 if (acm->port.count++) {
571 mutex_unlock(&acm->mutex);
572 usb_autopm_put_interface(acm->control);
576 acm->ctrlurb->dev = acm->dev;
577 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
578 dbg("usb_submit_urb(ctrl irq) failed");
582 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
583 (acm->ctrl_caps & USB_CDC_CAP_LINE))
586 usb_autopm_put_interface(acm->control);
588 INIT_LIST_HEAD(&acm->spare_read_urbs);
589 INIT_LIST_HEAD(&acm->spare_read_bufs);
590 INIT_LIST_HEAD(&acm->filled_read_bufs);
592 for (i = 0; i < acm->rx_buflimit; i++)
593 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
594 for (i = 0; i < acm->rx_buflimit; i++)
595 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
599 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
600 rv = tty_port_block_til_ready(&acm->port, tty, filp);
601 tasklet_schedule(&acm->urb_task);
603 mutex_unlock(&acm->mutex);
605 mutex_unlock(&open_mutex);
609 usb_kill_urb(acm->ctrlurb);
612 mutex_unlock(&acm->mutex);
613 usb_autopm_put_interface(acm->control);
615 mutex_unlock(&open_mutex);
616 tty_port_tty_set(&acm->port, NULL);
620 static void acm_tty_unregister(struct acm *acm)
624 nr = acm->rx_buflimit;
625 tty_unregister_device(acm_tty_driver, acm->minor);
626 usb_put_intf(acm->control);
627 acm_table[acm->minor] = NULL;
628 usb_free_urb(acm->ctrlurb);
629 for (i = 0; i < ACM_NW; i++)
630 usb_free_urb(acm->wb[i].urb);
631 for (i = 0; i < nr; i++)
632 usb_free_urb(acm->ru[i].urb);
633 kfree(acm->country_codes);
637 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
639 static void acm_port_down(struct acm *acm)
641 int i, nr = acm->rx_buflimit;
642 mutex_lock(&open_mutex);
644 usb_autopm_get_interface(acm->control);
645 acm_set_control(acm, acm->ctrlout = 0);
646 usb_kill_urb(acm->ctrlurb);
647 for (i = 0; i < ACM_NW; i++)
648 usb_kill_urb(acm->wb[i].urb);
649 for (i = 0; i < nr; i++)
650 usb_kill_urb(acm->ru[i].urb);
651 acm->control->needs_remote_wakeup = 0;
652 usb_autopm_put_interface(acm->control);
654 mutex_unlock(&open_mutex);
657 static void acm_tty_hangup(struct tty_struct *tty)
659 struct acm *acm = tty->driver_data;
660 tty_port_hangup(&acm->port);
664 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
666 struct acm *acm = tty->driver_data;
668 /* Perform the closing process and see if we need to do the hardware
672 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
673 mutex_lock(&open_mutex);
675 tty_port_tty_set(&acm->port, NULL);
676 acm_tty_unregister(acm);
677 tty->driver_data = NULL;
679 mutex_unlock(&open_mutex);
683 tty_port_close_end(&acm->port, tty);
684 tty_port_tty_set(&acm->port, NULL);
687 static int acm_tty_write(struct tty_struct *tty,
688 const unsigned char *buf, int count)
690 struct acm *acm = tty->driver_data;
696 dbg("Entering acm_tty_write to write %d bytes,", count);
703 spin_lock_irqsave(&acm->write_lock, flags);
704 wbn = acm_wb_alloc(acm);
706 spin_unlock_irqrestore(&acm->write_lock, flags);
711 count = (count > acm->writesize) ? acm->writesize : count;
712 dbg("Get %d bytes...", count);
713 memcpy(wb->buf, buf, count);
715 spin_unlock_irqrestore(&acm->write_lock, flags);
717 stat = acm_write_start(acm, wbn);
723 static int acm_tty_write_room(struct tty_struct *tty)
725 struct acm *acm = tty->driver_data;
729 * Do not let the line discipline to know that we have a reserve,
730 * or it might get too enthusiastic.
732 return acm_wb_is_avail(acm) ? acm->writesize : 0;
735 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
737 struct acm *acm = tty->driver_data;
741 * This is inaccurate (overcounts), but it works.
743 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
746 static void acm_tty_throttle(struct tty_struct *tty)
748 struct acm *acm = tty->driver_data;
751 spin_lock_bh(&acm->throttle_lock);
753 spin_unlock_bh(&acm->throttle_lock);
756 static void acm_tty_unthrottle(struct tty_struct *tty)
758 struct acm *acm = tty->driver_data;
761 spin_lock_bh(&acm->throttle_lock);
763 spin_unlock_bh(&acm->throttle_lock);
764 tasklet_schedule(&acm->urb_task);
767 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
769 struct acm *acm = tty->driver_data;
773 retval = acm_send_break(acm, state ? 0xffff : 0);
775 dbg("send break failed");
779 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
781 struct acm *acm = tty->driver_data;
786 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
787 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
788 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
789 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
790 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
794 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
795 unsigned int set, unsigned int clear)
797 struct acm *acm = tty->driver_data;
798 unsigned int newctrl;
803 newctrl = acm->ctrlout;
804 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
805 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
806 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
807 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
809 newctrl = (newctrl & ~clear) | set;
811 if (acm->ctrlout == newctrl)
813 return acm_set_control(acm, acm->ctrlout = newctrl);
816 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
817 unsigned int cmd, unsigned long arg)
819 struct acm *acm = tty->driver_data;
827 static const __u32 acm_tty_speed[] = {
828 0, 50, 75, 110, 134, 150, 200, 300, 600,
829 1200, 1800, 2400, 4800, 9600, 19200, 38400,
830 57600, 115200, 230400, 460800, 500000, 576000,
831 921600, 1000000, 1152000, 1500000, 2000000,
832 2500000, 3000000, 3500000, 4000000
835 static const __u8 acm_tty_size[] = {
839 static void acm_tty_set_termios(struct tty_struct *tty,
840 struct ktermios *termios_old)
842 struct acm *acm = tty->driver_data;
843 struct ktermios *termios = tty->termios;
844 struct usb_cdc_line_coding newline;
845 int newctrl = acm->ctrlout;
850 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
851 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
852 newline.bParityType = termios->c_cflag & PARENB ?
853 (termios->c_cflag & PARODD ? 1 : 2) +
854 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
855 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
856 /* FIXME: Needs to clear unsupported bits in the termios */
857 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
859 if (!newline.dwDTERate) {
860 newline.dwDTERate = acm->line.dwDTERate;
861 newctrl &= ~ACM_CTRL_DTR;
863 newctrl |= ACM_CTRL_DTR;
865 if (newctrl != acm->ctrlout)
866 acm_set_control(acm, acm->ctrlout = newctrl);
868 if (memcmp(&acm->line, &newline, sizeof newline)) {
869 memcpy(&acm->line, &newline, sizeof newline);
870 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
871 newline.bCharFormat, newline.bParityType,
873 acm_set_line(acm, &acm->line);
878 * USB probe and disconnect routines.
881 /* Little helpers: write/read buffers free */
882 static void acm_write_buffers_free(struct acm *acm)
886 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
888 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
889 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
892 static void acm_read_buffers_free(struct acm *acm)
894 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
895 int i, n = acm->rx_buflimit;
897 for (i = 0; i < n; i++)
898 usb_free_coherent(usb_dev, acm->readsize,
899 acm->rb[i].base, acm->rb[i].dma);
902 /* Little helper: write buffers allocate */
903 static int acm_write_buffers_alloc(struct acm *acm)
908 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
909 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
915 usb_free_coherent(acm->dev, acm->writesize,
924 static int acm_probe(struct usb_interface *intf,
925 const struct usb_device_id *id)
927 struct usb_cdc_union_desc *union_header = NULL;
928 struct usb_cdc_country_functional_desc *cfd = NULL;
929 unsigned char *buffer = intf->altsetting->extra;
930 int buflen = intf->altsetting->extralen;
931 struct usb_interface *control_interface;
932 struct usb_interface *data_interface;
933 struct usb_endpoint_descriptor *epctrl = NULL;
934 struct usb_endpoint_descriptor *epread = NULL;
935 struct usb_endpoint_descriptor *epwrite = NULL;
936 struct usb_device *usb_dev = interface_to_usbdev(intf);
939 int ctrlsize, readsize;
941 u8 ac_management_function = 0;
942 u8 call_management_function = 0;
943 int call_interface_num = -1;
944 int data_interface_num;
945 unsigned long quirks;
948 int combined_interfaces = 0;
951 quirks = (unsigned long)id->driver_info;
952 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
954 /* handle quirks deadly to normal probing*/
955 if (quirks == NO_UNION_NORMAL) {
956 data_interface = usb_ifnum_to_if(usb_dev, 1);
957 control_interface = usb_ifnum_to_if(usb_dev, 0);
958 goto skip_normal_probe;
963 dev_err(&intf->dev, "Weird descriptor references\n");
968 if (intf->cur_altsetting->endpoint->extralen &&
969 intf->cur_altsetting->endpoint->extra) {
971 "Seeking extra descriptors on endpoint\n");
972 buflen = intf->cur_altsetting->endpoint->extralen;
973 buffer = intf->cur_altsetting->endpoint->extra;
976 "Zero length descriptor references\n");
982 if (buffer[1] != USB_DT_CS_INTERFACE) {
983 dev_err(&intf->dev, "skipping garbage\n");
988 case USB_CDC_UNION_TYPE: /* we've found it */
990 dev_err(&intf->dev, "More than one "
991 "union descriptor, skipping ...\n");
994 union_header = (struct usb_cdc_union_desc *)buffer;
996 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
997 cfd = (struct usb_cdc_country_functional_desc *)buffer;
999 case USB_CDC_HEADER_TYPE: /* maybe check version */
1000 break; /* for now we ignore it */
1001 case USB_CDC_ACM_TYPE:
1002 ac_management_function = buffer[3];
1004 case USB_CDC_CALL_MANAGEMENT_TYPE:
1005 call_management_function = buffer[3];
1006 call_interface_num = buffer[4];
1007 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1008 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1011 /* there are LOTS more CDC descriptors that
1012 * could legitimately be found here.
1014 dev_dbg(&intf->dev, "Ignoring descriptor: "
1015 "type %02x, length %d\n",
1016 buffer[2], buffer[0]);
1020 buflen -= buffer[0];
1021 buffer += buffer[0];
1024 if (!union_header) {
1025 if (call_interface_num > 0) {
1026 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1027 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1028 control_interface = intf;
1030 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1031 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1034 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1035 combined_interfaces = 1;
1036 control_interface = data_interface = intf;
1037 goto look_for_collapsed_interface;
1041 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1042 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1043 if (!control_interface || !data_interface) {
1044 dev_dbg(&intf->dev, "no interfaces\n");
1049 if (data_interface_num != call_interface_num)
1050 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1052 if (control_interface == data_interface) {
1053 /* some broken devices designed for windows work this way */
1054 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1055 combined_interfaces = 1;
1056 /* a popular other OS doesn't use it */
1057 quirks |= NO_CAP_LINE;
1058 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1059 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1062 look_for_collapsed_interface:
1063 for (i = 0; i < 3; i++) {
1064 struct usb_endpoint_descriptor *ep;
1065 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1067 if (usb_endpoint_is_int_in(ep))
1069 else if (usb_endpoint_is_bulk_out(ep))
1071 else if (usb_endpoint_is_bulk_in(ep))
1076 if (!epctrl || !epread || !epwrite)
1079 goto made_compressed_probe;
1084 /*workaround for switched interfaces */
1085 if (data_interface->cur_altsetting->desc.bInterfaceClass
1086 != CDC_DATA_INTERFACE_TYPE) {
1087 if (control_interface->cur_altsetting->desc.bInterfaceClass
1088 == CDC_DATA_INTERFACE_TYPE) {
1089 struct usb_interface *t;
1091 "Your device has switched interfaces.\n");
1092 t = control_interface;
1093 control_interface = data_interface;
1100 /* Accept probe requests only for the control interface */
1101 if (!combined_interfaces && intf != control_interface)
1104 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1105 /* valid in this context */
1106 dev_dbg(&intf->dev, "The data interface isn't available\n");
1111 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1114 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1115 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1116 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1119 /* workaround for switched endpoints */
1120 if (!usb_endpoint_dir_in(epread)) {
1121 /* descriptors are swapped */
1122 struct usb_endpoint_descriptor *t;
1124 "The data interface has switched endpoints\n");
1129 made_compressed_probe:
1130 dbg("interfaces are valid");
1131 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1133 if (minor == ACM_TTY_MINORS) {
1134 dev_err(&intf->dev, "no more free acm devices\n");
1138 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1140 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1144 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1145 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1146 (quirks == SINGLE_RX_URB ? 1 : 2);
1147 acm->combined_interfaces = combined_interfaces;
1148 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1149 acm->control = control_interface;
1150 acm->data = data_interface;
1153 acm->ctrl_caps = ac_management_function;
1154 if (quirks & NO_CAP_LINE)
1155 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1156 acm->ctrlsize = ctrlsize;
1157 acm->readsize = readsize;
1158 acm->rx_buflimit = num_rx_buf;
1159 acm->urb_task.func = acm_rx_tasklet;
1160 acm->urb_task.data = (unsigned long) acm;
1161 INIT_WORK(&acm->work, acm_softint);
1162 init_waitqueue_head(&acm->drain_wait);
1163 spin_lock_init(&acm->throttle_lock);
1164 spin_lock_init(&acm->write_lock);
1165 spin_lock_init(&acm->read_lock);
1166 mutex_init(&acm->mutex);
1167 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1168 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1170 acm->bInterval = epread->bInterval;
1171 tty_port_init(&acm->port);
1172 acm->port.ops = &acm_port_ops;
1174 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1176 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1179 acm->ctrl_buffer = buf;
1181 if (acm_write_buffers_alloc(acm) < 0) {
1182 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1186 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1187 if (!acm->ctrlurb) {
1188 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1191 for (i = 0; i < num_rx_buf; i++) {
1192 struct acm_ru *rcv = &(acm->ru[i]);
1194 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1195 if (rcv->urb == NULL) {
1197 "out of memory (read urbs usb_alloc_urb)\n");
1201 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1202 rcv->instance = acm;
1204 for (i = 0; i < num_rx_buf; i++) {
1205 struct acm_rb *rb = &(acm->rb[i]);
1207 rb->base = usb_alloc_coherent(acm->dev, readsize,
1208 GFP_KERNEL, &rb->dma);
1211 "out of memory (read bufs usb_alloc_coherent)\n");
1215 for (i = 0; i < ACM_NW; i++) {
1216 struct acm_wb *snd = &(acm->wb[i]);
1218 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1219 if (snd->urb == NULL) {
1221 "out of memory (write urbs usb_alloc_urb)");
1225 if (usb_endpoint_xfer_int(epwrite))
1226 usb_fill_int_urb(snd->urb, usb_dev,
1227 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1228 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1230 usb_fill_bulk_urb(snd->urb, usb_dev,
1231 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1232 NULL, acm->writesize, acm_write_bulk, snd);
1233 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1234 snd->instance = acm;
1237 usb_set_intfdata(intf, acm);
1239 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1243 if (cfd) { /* export the country data */
1244 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1245 if (!acm->country_codes)
1246 goto skip_countries;
1247 acm->country_code_size = cfd->bLength - 4;
1248 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1250 acm->country_rel_date = cfd->iCountryCodeRelDate;
1252 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1254 kfree(acm->country_codes);
1255 goto skip_countries;
1258 i = device_create_file(&intf->dev,
1259 &dev_attr_iCountryCodeRelDate);
1261 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1262 kfree(acm->country_codes);
1263 goto skip_countries;
1268 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1269 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1270 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1271 /* works around buggy devices */
1272 epctrl->bInterval ? epctrl->bInterval : 0xff);
1273 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1274 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1276 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1278 acm_set_control(acm, acm->ctrlout);
1280 acm->line.dwDTERate = cpu_to_le32(9600);
1281 acm->line.bDataBits = 8;
1282 acm_set_line(acm, &acm->line);
1284 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1285 usb_set_intfdata(data_interface, acm);
1287 usb_get_intf(control_interface);
1288 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1290 acm_table[minor] = acm;
1294 for (i = 0; i < ACM_NW; i++)
1295 usb_free_urb(acm->wb[i].urb);
1297 acm_read_buffers_free(acm);
1299 for (i = 0; i < num_rx_buf; i++)
1300 usb_free_urb(acm->ru[i].urb);
1301 usb_free_urb(acm->ctrlurb);
1303 acm_write_buffers_free(acm);
1305 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1312 static void stop_data_traffic(struct acm *acm)
1315 dbg("Entering stop_data_traffic");
1317 tasklet_disable(&acm->urb_task);
1319 usb_kill_urb(acm->ctrlurb);
1320 for (i = 0; i < ACM_NW; i++)
1321 usb_kill_urb(acm->wb[i].urb);
1322 for (i = 0; i < acm->rx_buflimit; i++)
1323 usb_kill_urb(acm->ru[i].urb);
1325 tasklet_enable(&acm->urb_task);
1327 cancel_work_sync(&acm->work);
1330 static void acm_disconnect(struct usb_interface *intf)
1332 struct acm *acm = usb_get_intfdata(intf);
1333 struct usb_device *usb_dev = interface_to_usbdev(intf);
1334 struct tty_struct *tty;
1336 /* sibling interface is already cleaning up */
1340 mutex_lock(&open_mutex);
1341 if (acm->country_codes) {
1342 device_remove_file(&acm->control->dev,
1343 &dev_attr_wCountryCodes);
1344 device_remove_file(&acm->control->dev,
1345 &dev_attr_iCountryCodeRelDate);
1347 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1349 usb_set_intfdata(acm->control, NULL);
1350 usb_set_intfdata(acm->data, NULL);
1352 stop_data_traffic(acm);
1354 acm_write_buffers_free(acm);
1355 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1357 acm_read_buffers_free(acm);
1359 if (!acm->combined_interfaces)
1360 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1361 acm->data : acm->control);
1363 if (acm->port.count == 0) {
1364 acm_tty_unregister(acm);
1365 mutex_unlock(&open_mutex);
1369 mutex_unlock(&open_mutex);
1370 tty = tty_port_tty_get(&acm->port);
1378 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1380 struct acm *acm = usb_get_intfdata(intf);
1383 if (message.event & PM_EVENT_AUTO) {
1386 spin_lock_irq(&acm->read_lock);
1387 spin_lock(&acm->write_lock);
1388 b = acm->processing + acm->transmitting;
1389 spin_unlock(&acm->write_lock);
1390 spin_unlock_irq(&acm->read_lock);
1395 spin_lock_irq(&acm->read_lock);
1396 spin_lock(&acm->write_lock);
1397 cnt = acm->susp_count++;
1398 spin_unlock(&acm->write_lock);
1399 spin_unlock_irq(&acm->read_lock);
1404 we treat opened interfaces differently,
1405 we must guard against open
1407 mutex_lock(&acm->mutex);
1409 if (acm->port.count)
1410 stop_data_traffic(acm);
1412 mutex_unlock(&acm->mutex);
1416 static int acm_resume(struct usb_interface *intf)
1418 struct acm *acm = usb_get_intfdata(intf);
1423 spin_lock_irq(&acm->read_lock);
1424 acm->susp_count -= 1;
1425 cnt = acm->susp_count;
1426 spin_unlock_irq(&acm->read_lock);
1431 mutex_lock(&acm->mutex);
1432 if (acm->port.count) {
1433 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1435 spin_lock_irq(&acm->write_lock);
1436 if (acm->delayed_wb) {
1437 wb = acm->delayed_wb;
1438 acm->delayed_wb = NULL;
1439 spin_unlock_irq(&acm->write_lock);
1440 acm_start_wb(acm, wb);
1442 spin_unlock_irq(&acm->write_lock);
1446 * delayed error checking because we must
1447 * do the write path at all cost
1452 tasklet_schedule(&acm->urb_task);
1456 mutex_unlock(&acm->mutex);
1460 static int acm_reset_resume(struct usb_interface *intf)
1462 struct acm *acm = usb_get_intfdata(intf);
1463 struct tty_struct *tty;
1465 mutex_lock(&acm->mutex);
1466 if (acm->port.count) {
1467 tty = tty_port_tty_get(&acm->port);
1473 mutex_unlock(&acm->mutex);
1474 return acm_resume(intf);
1477 #endif /* CONFIG_PM */
1479 #define NOKIA_PCSUITE_ACM_INFO(x) \
1480 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1481 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1482 USB_CDC_ACM_PROTO_VENDOR)
1485 * USB driver structure.
1488 static const struct usb_device_id acm_ids[] = {
1489 /* quirky and broken devices */
1490 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1491 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1493 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1494 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1496 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1497 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1499 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1500 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1502 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1503 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1505 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1506 .driver_info = SINGLE_RX_URB,
1508 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1509 .driver_info = SINGLE_RX_URB, /* firmware bug */
1511 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1512 .driver_info = SINGLE_RX_URB, /* firmware bug */
1514 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1515 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1517 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1518 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1520 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1521 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1523 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1524 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1526 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1527 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1529 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1531 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1532 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1533 data interface instead of
1534 communications interface.
1535 Maybe we should define a new
1538 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1539 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1541 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1542 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1545 /* Nokia S60 phones expose two ACM channels. The first is
1546 * a modem and is picked up by the standard AT-command
1547 * information below. The second is 'vendor-specific' but
1548 * is treated as a serial device at the S60 end, so we want
1549 * to expose it on Linux too. */
1550 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1551 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1552 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1553 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1556 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1561 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1565 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1568 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1570 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1571 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1573 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1579 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1581 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1582 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1583 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1585 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1586 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1587 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1591 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1592 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1595 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1597 /* Support Lego NXT using pbLua firmware */
1598 { USB_DEVICE(0x0694, 0xff00),
1599 .driver_info = NOT_A_MODEM,
1602 /* control interfaces with various AT-command sets */
1603 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1604 USB_CDC_ACM_PROTO_AT_V25TER) },
1605 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1606 USB_CDC_ACM_PROTO_AT_PCCA101) },
1607 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1608 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1609 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1610 USB_CDC_ACM_PROTO_AT_GSM) },
1611 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1612 USB_CDC_ACM_PROTO_AT_3G) },
1613 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1614 USB_CDC_ACM_PROTO_AT_CDMA) },
1619 MODULE_DEVICE_TABLE(usb, acm_ids);
1621 static struct usb_driver acm_driver = {
1624 .disconnect = acm_disconnect,
1626 .suspend = acm_suspend,
1627 .resume = acm_resume,
1628 .reset_resume = acm_reset_resume,
1630 .id_table = acm_ids,
1632 .supports_autosuspend = 1,
1637 * TTY driver structures.
1640 static const struct tty_operations acm_ops = {
1641 .open = acm_tty_open,
1642 .close = acm_tty_close,
1643 .hangup = acm_tty_hangup,
1644 .write = acm_tty_write,
1645 .write_room = acm_tty_write_room,
1646 .ioctl = acm_tty_ioctl,
1647 .throttle = acm_tty_throttle,
1648 .unthrottle = acm_tty_unthrottle,
1649 .chars_in_buffer = acm_tty_chars_in_buffer,
1650 .break_ctl = acm_tty_break_ctl,
1651 .set_termios = acm_tty_set_termios,
1652 .tiocmget = acm_tty_tiocmget,
1653 .tiocmset = acm_tty_tiocmset,
1660 static int __init acm_init(void)
1663 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1664 if (!acm_tty_driver)
1666 acm_tty_driver->owner = THIS_MODULE,
1667 acm_tty_driver->driver_name = "acm",
1668 acm_tty_driver->name = "ttyACM",
1669 acm_tty_driver->major = ACM_TTY_MAJOR,
1670 acm_tty_driver->minor_start = 0,
1671 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1672 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1673 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1674 acm_tty_driver->init_termios = tty_std_termios;
1675 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1677 tty_set_operations(acm_tty_driver, &acm_ops);
1679 retval = tty_register_driver(acm_tty_driver);
1681 put_tty_driver(acm_tty_driver);
1685 retval = usb_register(&acm_driver);
1687 tty_unregister_driver(acm_tty_driver);
1688 put_tty_driver(acm_tty_driver);
1692 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1698 static void __exit acm_exit(void)
1700 usb_deregister(&acm_driver);
1701 tty_unregister_driver(acm_tty_driver);
1702 put_tty_driver(acm_tty_driver);
1705 module_init(acm_init);
1706 module_exit(acm_exit);
1708 MODULE_AUTHOR(DRIVER_AUTHOR);
1709 MODULE_DESCRIPTION(DRIVER_DESC);
1710 MODULE_LICENSE("GPL");
1711 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);