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 usb_mark_last_busy(acm->dev);
302 data = (unsigned char *)(dr + 1);
303 switch (dr->bNotificationType) {
304 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
305 dbg("%s network", dr->wValue ?
306 "connected to" : "disconnected from");
309 case USB_CDC_NOTIFY_SERIAL_STATE:
310 tty = tty_port_tty_get(&acm->port);
311 newctrl = get_unaligned_le16(data);
315 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
316 dbg("calling hangup");
322 acm->ctrlin = newctrl;
324 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
325 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
328 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
329 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
330 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
331 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
335 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
336 dr->bNotificationType, dr->wIndex,
337 dr->wLength, data[0], data[1]);
341 retval = usb_submit_urb(urb, GFP_ATOMIC);
343 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
347 /* data interface returns incoming bytes, or we got unthrottled */
348 static void acm_read_bulk(struct urb *urb)
351 struct acm_ru *rcv = urb->context;
352 struct acm *acm = rcv->instance;
353 int status = urb->status;
355 dbg("Entering acm_read_bulk with status %d", status);
357 if (!ACM_READY(acm)) {
358 dev_dbg(&acm->data->dev, "%s - acm not ready\n", __func__);
361 usb_mark_last_busy(acm->dev);
364 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
368 buf->size = urb->actual_length;
370 if (likely(status == 0)) {
371 spin_lock(&acm->read_lock);
373 list_add_tail(&rcv->list, &acm->spare_read_urbs);
374 list_add_tail(&buf->list, &acm->filled_read_bufs);
375 spin_unlock(&acm->read_lock);
377 /* we drop the buffer due to an error */
378 spin_lock(&acm->read_lock);
379 list_add_tail(&rcv->list, &acm->spare_read_urbs);
380 list_add(&buf->list, &acm->spare_read_bufs);
381 spin_unlock(&acm->read_lock);
382 /* nevertheless the tasklet must be kicked unconditionally
383 so the queue cannot dry up */
385 if (likely(!acm->susp_count))
386 tasklet_schedule(&acm->urb_task);
389 static void acm_rx_tasklet(unsigned long _acm)
391 struct acm *acm = (void *)_acm;
393 struct tty_struct *tty;
396 unsigned char throttled;
398 dbg("Entering acm_rx_tasklet");
400 if (!ACM_READY(acm)) {
401 dbg("acm_rx_tasklet: ACM not ready");
405 spin_lock_irqsave(&acm->throttle_lock, flags);
406 throttled = acm->throttle;
407 spin_unlock_irqrestore(&acm->throttle_lock, flags);
409 dbg("acm_rx_tasklet: throttled");
413 tty = tty_port_tty_get(&acm->port);
416 spin_lock_irqsave(&acm->read_lock, flags);
417 if (list_empty(&acm->filled_read_bufs)) {
418 spin_unlock_irqrestore(&acm->read_lock, flags);
421 buf = list_entry(acm->filled_read_bufs.next,
422 struct acm_rb, list);
423 list_del(&buf->list);
424 spin_unlock_irqrestore(&acm->read_lock, flags);
426 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
429 spin_lock_irqsave(&acm->throttle_lock, flags);
430 throttled = acm->throttle;
431 spin_unlock_irqrestore(&acm->throttle_lock, flags);
433 tty_insert_flip_string(tty, buf->base, buf->size);
434 tty_flip_buffer_push(tty);
437 dbg("Throttling noticed");
438 spin_lock_irqsave(&acm->read_lock, flags);
439 list_add(&buf->list, &acm->filled_read_bufs);
440 spin_unlock_irqrestore(&acm->read_lock, flags);
445 spin_lock_irqsave(&acm->read_lock, flags);
446 list_add(&buf->list, &acm->spare_read_bufs);
447 spin_unlock_irqrestore(&acm->read_lock, flags);
453 while (!list_empty(&acm->spare_read_bufs)) {
454 spin_lock_irqsave(&acm->read_lock, flags);
455 if (list_empty(&acm->spare_read_urbs)) {
457 spin_unlock_irqrestore(&acm->read_lock, flags);
460 rcv = list_entry(acm->spare_read_urbs.next,
461 struct acm_ru, list);
462 list_del(&rcv->list);
463 spin_unlock_irqrestore(&acm->read_lock, flags);
465 buf = list_entry(acm->spare_read_bufs.next,
466 struct acm_rb, list);
467 list_del(&buf->list);
472 usb_fill_int_urb(rcv->urb, acm->dev,
476 acm_read_bulk, rcv, acm->bInterval);
478 usb_fill_bulk_urb(rcv->urb, acm->dev,
483 rcv->urb->transfer_dma = buf->dma;
484 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
486 /* This shouldn't kill the driver as unsuccessful URBs are
487 returned to the free-urbs-pool and resubmited ASAP */
488 spin_lock_irqsave(&acm->read_lock, flags);
489 if (acm->susp_count ||
490 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
491 list_add(&buf->list, &acm->spare_read_bufs);
492 list_add(&rcv->list, &acm->spare_read_urbs);
494 spin_unlock_irqrestore(&acm->read_lock, flags);
497 spin_unlock_irqrestore(&acm->read_lock, flags);
498 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
501 spin_lock_irqsave(&acm->read_lock, flags);
503 spin_unlock_irqrestore(&acm->read_lock, flags);
506 /* data interface wrote those outgoing bytes */
507 static void acm_write_bulk(struct urb *urb)
509 struct acm_wb *wb = urb->context;
510 struct acm *acm = wb->instance;
513 if (verbose || urb->status
514 || (urb->actual_length != urb->transfer_buffer_length))
515 dev_dbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
518 urb->transfer_buffer_length,
521 spin_lock_irqsave(&acm->write_lock, flags);
522 acm_write_done(acm, wb);
523 spin_unlock_irqrestore(&acm->write_lock, flags);
525 schedule_work(&acm->work);
527 wake_up_interruptible(&acm->drain_wait);
530 static void acm_softint(struct work_struct *work)
532 struct acm *acm = container_of(work, struct acm, work);
533 struct tty_struct *tty;
535 dev_vdbg(&acm->data->dev, "%s\n", __func__);
539 tty = tty_port_tty_get(&acm->port);
550 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
555 dbg("Entering acm_tty_open.");
557 mutex_lock(&open_mutex);
559 acm = acm_table[tty->index];
560 if (!acm || !acm->dev)
565 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
567 tty->driver_data = acm;
568 tty_port_tty_set(&acm->port, tty);
570 if (usb_autopm_get_interface(acm->control) < 0)
573 acm->control->needs_remote_wakeup = 1;
575 mutex_lock(&acm->mutex);
576 if (acm->port.count++) {
577 mutex_unlock(&acm->mutex);
578 usb_autopm_put_interface(acm->control);
582 acm->ctrlurb->dev = acm->dev;
583 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
584 dbg("usb_submit_urb(ctrl irq) failed");
588 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
589 (acm->ctrl_caps & USB_CDC_CAP_LINE))
592 usb_autopm_put_interface(acm->control);
594 INIT_LIST_HEAD(&acm->spare_read_urbs);
595 INIT_LIST_HEAD(&acm->spare_read_bufs);
596 INIT_LIST_HEAD(&acm->filled_read_bufs);
598 for (i = 0; i < acm->rx_buflimit; i++)
599 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
600 for (i = 0; i < acm->rx_buflimit; i++)
601 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
605 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
606 rv = tty_port_block_til_ready(&acm->port, tty, filp);
607 tasklet_schedule(&acm->urb_task);
609 mutex_unlock(&acm->mutex);
611 mutex_unlock(&open_mutex);
615 usb_kill_urb(acm->ctrlurb);
618 mutex_unlock(&acm->mutex);
619 usb_autopm_put_interface(acm->control);
621 mutex_unlock(&open_mutex);
622 tty_port_tty_set(&acm->port, NULL);
626 static void acm_tty_unregister(struct acm *acm)
630 nr = acm->rx_buflimit;
631 tty_unregister_device(acm_tty_driver, acm->minor);
632 usb_put_intf(acm->control);
633 acm_table[acm->minor] = NULL;
634 usb_free_urb(acm->ctrlurb);
635 for (i = 0; i < ACM_NW; i++)
636 usb_free_urb(acm->wb[i].urb);
637 for (i = 0; i < nr; i++)
638 usb_free_urb(acm->ru[i].urb);
639 kfree(acm->country_codes);
643 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
645 static void acm_port_down(struct acm *acm)
647 int i, nr = acm->rx_buflimit;
648 mutex_lock(&open_mutex);
650 usb_autopm_get_interface(acm->control);
651 acm_set_control(acm, acm->ctrlout = 0);
652 usb_kill_urb(acm->ctrlurb);
653 for (i = 0; i < ACM_NW; i++)
654 usb_kill_urb(acm->wb[i].urb);
655 tasklet_disable(&acm->urb_task);
656 for (i = 0; i < nr; i++)
657 usb_kill_urb(acm->ru[i].urb);
658 tasklet_enable(&acm->urb_task);
659 acm->control->needs_remote_wakeup = 0;
660 usb_autopm_put_interface(acm->control);
662 mutex_unlock(&open_mutex);
665 static void acm_tty_hangup(struct tty_struct *tty)
667 struct acm *acm = tty->driver_data;
668 tty_port_hangup(&acm->port);
672 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
674 struct acm *acm = tty->driver_data;
676 /* Perform the closing process and see if we need to do the hardware
680 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
681 mutex_lock(&open_mutex);
683 tty_port_tty_set(&acm->port, NULL);
684 acm_tty_unregister(acm);
685 tty->driver_data = NULL;
687 mutex_unlock(&open_mutex);
691 tty_port_close_end(&acm->port, tty);
692 tty_port_tty_set(&acm->port, NULL);
695 static int acm_tty_write(struct tty_struct *tty,
696 const unsigned char *buf, int count)
698 struct acm *acm = tty->driver_data;
704 dbg("Entering acm_tty_write to write %d bytes,", count);
711 spin_lock_irqsave(&acm->write_lock, flags);
712 wbn = acm_wb_alloc(acm);
714 spin_unlock_irqrestore(&acm->write_lock, flags);
719 count = (count > acm->writesize) ? acm->writesize : count;
720 dbg("Get %d bytes...", count);
721 memcpy(wb->buf, buf, count);
723 spin_unlock_irqrestore(&acm->write_lock, flags);
725 stat = acm_write_start(acm, wbn);
731 static int acm_tty_write_room(struct tty_struct *tty)
733 struct acm *acm = tty->driver_data;
737 * Do not let the line discipline to know that we have a reserve,
738 * or it might get too enthusiastic.
740 return acm_wb_is_avail(acm) ? acm->writesize : 0;
743 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
745 struct acm *acm = tty->driver_data;
749 * This is inaccurate (overcounts), but it works.
751 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
754 static void acm_tty_throttle(struct tty_struct *tty)
756 struct acm *acm = tty->driver_data;
759 spin_lock_bh(&acm->throttle_lock);
761 spin_unlock_bh(&acm->throttle_lock);
764 static void acm_tty_unthrottle(struct tty_struct *tty)
766 struct acm *acm = tty->driver_data;
769 spin_lock_bh(&acm->throttle_lock);
771 spin_unlock_bh(&acm->throttle_lock);
772 tasklet_schedule(&acm->urb_task);
775 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
777 struct acm *acm = tty->driver_data;
781 retval = acm_send_break(acm, state ? 0xffff : 0);
783 dbg("send break failed");
787 static int acm_tty_tiocmget(struct tty_struct *tty)
789 struct acm *acm = tty->driver_data;
794 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
795 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
796 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
797 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
798 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
802 static int acm_tty_tiocmset(struct tty_struct *tty,
803 unsigned int set, unsigned int clear)
805 struct acm *acm = tty->driver_data;
806 unsigned int newctrl;
811 newctrl = acm->ctrlout;
812 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
813 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
814 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
815 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
817 newctrl = (newctrl & ~clear) | set;
819 if (acm->ctrlout == newctrl)
821 return acm_set_control(acm, acm->ctrlout = newctrl);
824 static int acm_tty_ioctl(struct tty_struct *tty,
825 unsigned int cmd, unsigned long arg)
827 struct acm *acm = tty->driver_data;
835 static const __u32 acm_tty_speed[] = {
836 0, 50, 75, 110, 134, 150, 200, 300, 600,
837 1200, 1800, 2400, 4800, 9600, 19200, 38400,
838 57600, 115200, 230400, 460800, 500000, 576000,
839 921600, 1000000, 1152000, 1500000, 2000000,
840 2500000, 3000000, 3500000, 4000000
843 static const __u8 acm_tty_size[] = {
847 static void acm_tty_set_termios(struct tty_struct *tty,
848 struct ktermios *termios_old)
850 struct acm *acm = tty->driver_data;
851 struct ktermios *termios = tty->termios;
852 struct usb_cdc_line_coding newline;
853 int newctrl = acm->ctrlout;
858 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
859 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
860 newline.bParityType = termios->c_cflag & PARENB ?
861 (termios->c_cflag & PARODD ? 1 : 2) +
862 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
863 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
864 /* FIXME: Needs to clear unsupported bits in the termios */
865 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
867 if (!newline.dwDTERate) {
868 newline.dwDTERate = acm->line.dwDTERate;
869 newctrl &= ~ACM_CTRL_DTR;
871 newctrl |= ACM_CTRL_DTR;
873 if (newctrl != acm->ctrlout)
874 acm_set_control(acm, acm->ctrlout = newctrl);
876 if (memcmp(&acm->line, &newline, sizeof newline)) {
877 memcpy(&acm->line, &newline, sizeof newline);
878 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
879 newline.bCharFormat, newline.bParityType,
881 acm_set_line(acm, &acm->line);
886 * USB probe and disconnect routines.
889 /* Little helpers: write/read buffers free */
890 static void acm_write_buffers_free(struct acm *acm)
894 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
896 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
897 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
900 static void acm_read_buffers_free(struct acm *acm)
902 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
903 int i, n = acm->rx_buflimit;
905 for (i = 0; i < n; i++)
906 usb_free_coherent(usb_dev, acm->readsize,
907 acm->rb[i].base, acm->rb[i].dma);
910 /* Little helper: write buffers allocate */
911 static int acm_write_buffers_alloc(struct acm *acm)
916 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
917 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
923 usb_free_coherent(acm->dev, acm->writesize,
932 static int acm_probe(struct usb_interface *intf,
933 const struct usb_device_id *id)
935 struct usb_cdc_union_desc *union_header = NULL;
936 struct usb_cdc_country_functional_desc *cfd = NULL;
937 unsigned char *buffer = intf->altsetting->extra;
938 int buflen = intf->altsetting->extralen;
939 struct usb_interface *control_interface;
940 struct usb_interface *data_interface;
941 struct usb_endpoint_descriptor *epctrl = NULL;
942 struct usb_endpoint_descriptor *epread = NULL;
943 struct usb_endpoint_descriptor *epwrite = NULL;
944 struct usb_device *usb_dev = interface_to_usbdev(intf);
947 int ctrlsize, readsize;
949 u8 ac_management_function = 0;
950 u8 call_management_function = 0;
951 int call_interface_num = -1;
952 int data_interface_num;
953 unsigned long quirks;
956 int combined_interfaces = 0;
959 quirks = (unsigned long)id->driver_info;
960 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
962 /* handle quirks deadly to normal probing*/
963 if (quirks == NO_UNION_NORMAL) {
964 data_interface = usb_ifnum_to_if(usb_dev, 1);
965 control_interface = usb_ifnum_to_if(usb_dev, 0);
966 goto skip_normal_probe;
971 dev_err(&intf->dev, "Weird descriptor references\n");
976 if (intf->cur_altsetting->endpoint &&
977 intf->cur_altsetting->endpoint->extralen &&
978 intf->cur_altsetting->endpoint->extra) {
980 "Seeking extra descriptors on endpoint\n");
981 buflen = intf->cur_altsetting->endpoint->extralen;
982 buffer = intf->cur_altsetting->endpoint->extra;
985 "Zero length descriptor references\n");
991 if (buffer[1] != USB_DT_CS_INTERFACE) {
992 dev_err(&intf->dev, "skipping garbage\n");
997 case USB_CDC_UNION_TYPE: /* we've found it */
999 dev_err(&intf->dev, "More than one "
1000 "union descriptor, skipping ...\n");
1003 union_header = (struct usb_cdc_union_desc *)buffer;
1005 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1006 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1008 case USB_CDC_HEADER_TYPE: /* maybe check version */
1009 break; /* for now we ignore it */
1010 case USB_CDC_ACM_TYPE:
1011 ac_management_function = buffer[3];
1013 case USB_CDC_CALL_MANAGEMENT_TYPE:
1014 call_management_function = buffer[3];
1015 call_interface_num = buffer[4];
1016 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1017 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1020 /* there are LOTS more CDC descriptors that
1021 * could legitimately be found here.
1023 dev_dbg(&intf->dev, "Ignoring descriptor: "
1024 "type %02x, length %d\n",
1025 buffer[2], buffer[0]);
1029 buflen -= buffer[0];
1030 buffer += buffer[0];
1033 if (!union_header) {
1034 if (call_interface_num > 0) {
1035 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1036 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1037 control_interface = intf;
1039 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1040 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1043 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1044 combined_interfaces = 1;
1045 control_interface = data_interface = intf;
1046 goto look_for_collapsed_interface;
1050 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1051 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1052 if (!control_interface || !data_interface) {
1053 dev_dbg(&intf->dev, "no interfaces\n");
1058 if (data_interface_num != call_interface_num)
1059 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1061 if (control_interface == data_interface) {
1062 /* some broken devices designed for windows work this way */
1063 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1064 combined_interfaces = 1;
1065 /* a popular other OS doesn't use it */
1066 quirks |= NO_CAP_LINE;
1067 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1068 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1071 look_for_collapsed_interface:
1072 for (i = 0; i < 3; i++) {
1073 struct usb_endpoint_descriptor *ep;
1074 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1076 if (usb_endpoint_is_int_in(ep))
1078 else if (usb_endpoint_is_bulk_out(ep))
1080 else if (usb_endpoint_is_bulk_in(ep))
1085 if (!epctrl || !epread || !epwrite)
1088 goto made_compressed_probe;
1093 /*workaround for switched interfaces */
1094 if (data_interface->cur_altsetting->desc.bInterfaceClass
1095 != CDC_DATA_INTERFACE_TYPE) {
1096 if (control_interface->cur_altsetting->desc.bInterfaceClass
1097 == CDC_DATA_INTERFACE_TYPE) {
1098 struct usb_interface *t;
1100 "Your device has switched interfaces.\n");
1101 t = control_interface;
1102 control_interface = data_interface;
1109 /* Accept probe requests only for the control interface */
1110 if (!combined_interfaces && intf != control_interface)
1113 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1114 /* valid in this context */
1115 dev_dbg(&intf->dev, "The data interface isn't available\n");
1120 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1123 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1124 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1125 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1128 /* workaround for switched endpoints */
1129 if (!usb_endpoint_dir_in(epread)) {
1130 /* descriptors are swapped */
1131 struct usb_endpoint_descriptor *t;
1133 "The data interface has switched endpoints\n");
1138 made_compressed_probe:
1139 dbg("interfaces are valid");
1140 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1142 if (minor == ACM_TTY_MINORS) {
1143 dev_err(&intf->dev, "no more free acm devices\n");
1147 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1149 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1153 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1154 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1155 (quirks == SINGLE_RX_URB ? 1 : 2);
1156 acm->combined_interfaces = combined_interfaces;
1157 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1158 acm->control = control_interface;
1159 acm->data = data_interface;
1162 acm->ctrl_caps = ac_management_function;
1163 if (quirks & NO_CAP_LINE)
1164 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1165 acm->ctrlsize = ctrlsize;
1166 acm->readsize = readsize;
1167 acm->rx_buflimit = num_rx_buf;
1168 acm->urb_task.func = acm_rx_tasklet;
1169 acm->urb_task.data = (unsigned long) acm;
1170 INIT_WORK(&acm->work, acm_softint);
1171 init_waitqueue_head(&acm->drain_wait);
1172 spin_lock_init(&acm->throttle_lock);
1173 spin_lock_init(&acm->write_lock);
1174 spin_lock_init(&acm->read_lock);
1175 mutex_init(&acm->mutex);
1176 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1177 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1179 acm->bInterval = epread->bInterval;
1180 tty_port_init(&acm->port);
1181 acm->port.ops = &acm_port_ops;
1183 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1185 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1188 acm->ctrl_buffer = buf;
1190 if (acm_write_buffers_alloc(acm) < 0) {
1191 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1195 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1196 if (!acm->ctrlurb) {
1197 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1200 for (i = 0; i < num_rx_buf; i++) {
1201 struct acm_ru *rcv = &(acm->ru[i]);
1203 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1204 if (rcv->urb == NULL) {
1206 "out of memory (read urbs usb_alloc_urb)\n");
1210 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1211 rcv->instance = acm;
1213 for (i = 0; i < num_rx_buf; i++) {
1214 struct acm_rb *rb = &(acm->rb[i]);
1216 rb->base = usb_alloc_coherent(acm->dev, readsize,
1217 GFP_KERNEL, &rb->dma);
1220 "out of memory (read bufs usb_alloc_coherent)\n");
1224 for (i = 0; i < ACM_NW; i++) {
1225 struct acm_wb *snd = &(acm->wb[i]);
1227 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1228 if (snd->urb == NULL) {
1230 "out of memory (write urbs usb_alloc_urb)\n");
1234 if (usb_endpoint_xfer_int(epwrite))
1235 usb_fill_int_urb(snd->urb, usb_dev,
1236 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1237 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1239 usb_fill_bulk_urb(snd->urb, usb_dev,
1240 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1241 NULL, acm->writesize, acm_write_bulk, snd);
1242 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1243 snd->instance = acm;
1246 usb_set_intfdata(intf, acm);
1248 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1252 if (cfd) { /* export the country data */
1253 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1254 if (!acm->country_codes)
1255 goto skip_countries;
1256 acm->country_code_size = cfd->bLength - 4;
1257 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1259 acm->country_rel_date = cfd->iCountryCodeRelDate;
1261 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1263 kfree(acm->country_codes);
1264 goto skip_countries;
1267 i = device_create_file(&intf->dev,
1268 &dev_attr_iCountryCodeRelDate);
1270 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1271 kfree(acm->country_codes);
1272 goto skip_countries;
1277 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1278 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1279 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1280 /* works around buggy devices */
1281 epctrl->bInterval ? epctrl->bInterval : 0xff);
1282 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1283 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1285 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1287 acm_set_control(acm, acm->ctrlout);
1289 acm->line.dwDTERate = cpu_to_le32(9600);
1290 acm->line.bDataBits = 8;
1291 acm_set_line(acm, &acm->line);
1293 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1294 usb_set_intfdata(data_interface, acm);
1296 usb_get_intf(control_interface);
1297 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1299 acm_table[minor] = acm;
1303 for (i = 0; i < ACM_NW; i++)
1304 usb_free_urb(acm->wb[i].urb);
1306 acm_read_buffers_free(acm);
1308 for (i = 0; i < num_rx_buf; i++)
1309 usb_free_urb(acm->ru[i].urb);
1310 usb_free_urb(acm->ctrlurb);
1312 acm_write_buffers_free(acm);
1314 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1321 static void stop_data_traffic(struct acm *acm)
1324 dbg("Entering stop_data_traffic");
1326 tasklet_disable(&acm->urb_task);
1328 usb_kill_urb(acm->ctrlurb);
1329 for (i = 0; i < ACM_NW; i++)
1330 usb_kill_urb(acm->wb[i].urb);
1331 for (i = 0; i < acm->rx_buflimit; i++)
1332 usb_kill_urb(acm->ru[i].urb);
1334 tasklet_enable(&acm->urb_task);
1336 cancel_work_sync(&acm->work);
1339 static void acm_disconnect(struct usb_interface *intf)
1341 struct acm *acm = usb_get_intfdata(intf);
1342 struct usb_device *usb_dev = interface_to_usbdev(intf);
1343 struct tty_struct *tty;
1345 /* sibling interface is already cleaning up */
1349 mutex_lock(&open_mutex);
1350 if (acm->country_codes) {
1351 device_remove_file(&acm->control->dev,
1352 &dev_attr_wCountryCodes);
1353 device_remove_file(&acm->control->dev,
1354 &dev_attr_iCountryCodeRelDate);
1356 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1358 usb_set_intfdata(acm->control, NULL);
1359 usb_set_intfdata(acm->data, NULL);
1361 stop_data_traffic(acm);
1363 acm_write_buffers_free(acm);
1364 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1366 acm_read_buffers_free(acm);
1368 if (!acm->combined_interfaces)
1369 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1370 acm->data : acm->control);
1372 if (acm->port.count == 0) {
1373 acm_tty_unregister(acm);
1374 mutex_unlock(&open_mutex);
1378 mutex_unlock(&open_mutex);
1379 tty = tty_port_tty_get(&acm->port);
1387 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1389 struct acm *acm = usb_get_intfdata(intf);
1392 if (message.event & PM_EVENT_AUTO) {
1395 spin_lock_irq(&acm->read_lock);
1396 spin_lock(&acm->write_lock);
1397 b = acm->processing + acm->transmitting;
1398 spin_unlock(&acm->write_lock);
1399 spin_unlock_irq(&acm->read_lock);
1404 spin_lock_irq(&acm->read_lock);
1405 spin_lock(&acm->write_lock);
1406 cnt = acm->susp_count++;
1407 spin_unlock(&acm->write_lock);
1408 spin_unlock_irq(&acm->read_lock);
1413 we treat opened interfaces differently,
1414 we must guard against open
1416 mutex_lock(&acm->mutex);
1418 if (acm->port.count)
1419 stop_data_traffic(acm);
1421 mutex_unlock(&acm->mutex);
1425 static int acm_resume(struct usb_interface *intf)
1427 struct acm *acm = usb_get_intfdata(intf);
1432 spin_lock_irq(&acm->read_lock);
1433 acm->susp_count -= 1;
1434 cnt = acm->susp_count;
1435 spin_unlock_irq(&acm->read_lock);
1440 mutex_lock(&acm->mutex);
1441 if (acm->port.count) {
1442 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1444 spin_lock_irq(&acm->write_lock);
1445 if (acm->delayed_wb) {
1446 wb = acm->delayed_wb;
1447 acm->delayed_wb = NULL;
1448 spin_unlock_irq(&acm->write_lock);
1449 acm_start_wb(acm, wb);
1451 spin_unlock_irq(&acm->write_lock);
1455 * delayed error checking because we must
1456 * do the write path at all cost
1461 tasklet_schedule(&acm->urb_task);
1465 mutex_unlock(&acm->mutex);
1469 static int acm_reset_resume(struct usb_interface *intf)
1471 struct acm *acm = usb_get_intfdata(intf);
1472 struct tty_struct *tty;
1474 mutex_lock(&acm->mutex);
1475 if (acm->port.count) {
1476 tty = tty_port_tty_get(&acm->port);
1482 mutex_unlock(&acm->mutex);
1483 return acm_resume(intf);
1486 #endif /* CONFIG_PM */
1488 #define NOKIA_PCSUITE_ACM_INFO(x) \
1489 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1490 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1491 USB_CDC_ACM_PROTO_VENDOR)
1493 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1494 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1495 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1496 USB_CDC_ACM_PROTO_VENDOR)
1499 * USB driver structure.
1502 static const struct usb_device_id acm_ids[] = {
1503 /* quirky and broken devices */
1504 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1505 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1508 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1511 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1513 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1514 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1516 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1517 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1520 .driver_info = SINGLE_RX_URB,
1522 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1523 .driver_info = SINGLE_RX_URB, /* firmware bug */
1525 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1526 .driver_info = SINGLE_RX_URB, /* firmware bug */
1528 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1529 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1532 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1534 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1535 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1537 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1538 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1540 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1541 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1543 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1545 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1546 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1547 data interface instead of
1548 communications interface.
1549 Maybe we should define a new
1552 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1553 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1555 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1556 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1559 /* Nokia S60 phones expose two ACM channels. The first is
1560 * a modem and is picked up by the standard AT-command
1561 * information below. The second is 'vendor-specific' but
1562 * is treated as a serial device at the S60 end, so we want
1563 * to expose it on Linux too. */
1564 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1566 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1579 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1582 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1583 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1584 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1585 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1586 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1587 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1593 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1594 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1596 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1597 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1598 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1600 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1602 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1605 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1606 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1609 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1611 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1612 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1613 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1615 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1616 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1617 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1619 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1621 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1623 /* Support Lego NXT using pbLua firmware */
1624 { USB_DEVICE(0x0694, 0xff00),
1625 .driver_info = NOT_A_MODEM,
1628 /* control interfaces without any protocol set */
1629 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1630 USB_CDC_PROTO_NONE) },
1632 /* control interfaces with various AT-command sets */
1633 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1634 USB_CDC_ACM_PROTO_AT_V25TER) },
1635 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1636 USB_CDC_ACM_PROTO_AT_PCCA101) },
1637 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1638 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1639 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1640 USB_CDC_ACM_PROTO_AT_GSM) },
1641 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1642 USB_CDC_ACM_PROTO_AT_3G) },
1643 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1644 USB_CDC_ACM_PROTO_AT_CDMA) },
1649 MODULE_DEVICE_TABLE(usb, acm_ids);
1651 static struct usb_driver acm_driver = {
1654 .disconnect = acm_disconnect,
1656 .suspend = acm_suspend,
1657 .resume = acm_resume,
1658 .reset_resume = acm_reset_resume,
1660 .id_table = acm_ids,
1662 .supports_autosuspend = 1,
1667 * TTY driver structures.
1670 static const struct tty_operations acm_ops = {
1671 .open = acm_tty_open,
1672 .close = acm_tty_close,
1673 .hangup = acm_tty_hangup,
1674 .write = acm_tty_write,
1675 .write_room = acm_tty_write_room,
1676 .ioctl = acm_tty_ioctl,
1677 .throttle = acm_tty_throttle,
1678 .unthrottle = acm_tty_unthrottle,
1679 .chars_in_buffer = acm_tty_chars_in_buffer,
1680 .break_ctl = acm_tty_break_ctl,
1681 .set_termios = acm_tty_set_termios,
1682 .tiocmget = acm_tty_tiocmget,
1683 .tiocmset = acm_tty_tiocmset,
1690 static int __init acm_init(void)
1693 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1694 if (!acm_tty_driver)
1696 acm_tty_driver->owner = THIS_MODULE,
1697 acm_tty_driver->driver_name = "acm",
1698 acm_tty_driver->name = "ttyACM",
1699 acm_tty_driver->major = ACM_TTY_MAJOR,
1700 acm_tty_driver->minor_start = 0,
1701 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1702 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1703 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1704 acm_tty_driver->init_termios = tty_std_termios;
1705 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1707 tty_set_operations(acm_tty_driver, &acm_ops);
1709 retval = tty_register_driver(acm_tty_driver);
1711 put_tty_driver(acm_tty_driver);
1715 retval = usb_register(&acm_driver);
1717 tty_unregister_driver(acm_tty_driver);
1718 put_tty_driver(acm_tty_driver);
1722 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1728 static void __exit acm_exit(void)
1730 usb_deregister(&acm_driver);
1731 tty_unregister_driver(acm_tty_driver);
1732 put_tty_driver(acm_tty_driver);
1735 module_init(acm_init);
1736 module_exit(acm_exit);
1738 MODULE_AUTHOR(DRIVER_AUTHOR);
1739 MODULE_DESCRIPTION(DRIVER_DESC);
1740 MODULE_LICENSE("GPL");
1741 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);