4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
6 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
7 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
9 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
10 * Copyright (c) 2011 Johan Hovold <jhovold@gmail.com>
12 * USB Abstract Control Model driver for USB modems and ISDN adapters
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #include <linux/kernel.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/tty.h>
39 #include <linux/serial.h>
40 #include <linux/tty_driver.h>
41 #include <linux/tty_flip.h>
42 #include <linux/serial.h>
43 #include <linux/module.h>
44 #include <linux/mutex.h>
45 #include <linux/uaccess.h>
46 #include <linux/usb.h>
47 #include <linux/usb/cdc.h>
48 #include <asm/byteorder.h>
49 #include <asm/unaligned.h>
50 #include <linux/list.h>
55 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
56 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
58 static struct usb_driver acm_driver;
59 static struct tty_driver *acm_tty_driver;
60 static struct acm *acm_table[ACM_TTY_MINORS];
62 static DEFINE_MUTEX(acm_table_lock);
69 * Look up an ACM structure by index. If found and not disconnected, increment
70 * its refcount and return it with its mutex held.
72 static struct acm *acm_get_by_index(unsigned index)
76 mutex_lock(&acm_table_lock);
77 acm = acm_table[index];
79 mutex_lock(&acm->mutex);
80 if (acm->disconnected) {
81 mutex_unlock(&acm->mutex);
84 tty_port_get(&acm->port);
85 mutex_unlock(&acm->mutex);
88 mutex_unlock(&acm_table_lock);
93 * Try to find an available minor number and if found, associate it with 'acm'.
95 static int acm_alloc_minor(struct acm *acm)
99 mutex_lock(&acm_table_lock);
100 for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
101 if (!acm_table[minor]) {
102 acm_table[minor] = acm;
106 mutex_unlock(&acm_table_lock);
111 /* Release the minor number associated with 'acm'. */
112 static void acm_release_minor(struct acm *acm)
114 mutex_lock(&acm_table_lock);
115 acm_table[acm->minor] = NULL;
116 mutex_unlock(&acm_table_lock);
120 * Functions for ACM control messages.
123 static int acm_ctrl_msg(struct acm *acm, int request, int value,
126 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
127 request, USB_RT_ACM, value,
128 acm->control->altsetting[0].desc.bInterfaceNumber,
130 dev_dbg(&acm->control->dev,
131 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
132 __func__, request, value, len, retval);
133 return retval < 0 ? retval : 0;
136 /* devices aren't required to support these requests.
137 * the cdc acm descriptor tells whether they do...
139 #define acm_set_control(acm, control) \
140 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
141 #define acm_set_line(acm, line) \
142 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
143 #define acm_send_break(acm, ms) \
144 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
147 * Write buffer management.
148 * All of these assume proper locks taken by the caller.
151 static int acm_wb_alloc(struct acm *acm)
164 wbn = (wbn + 1) % ACM_NW;
170 static int acm_wb_is_avail(struct acm *acm)
176 spin_lock_irqsave(&acm->write_lock, flags);
177 for (i = 0; i < ACM_NW; i++)
179 spin_unlock_irqrestore(&acm->write_lock, flags);
184 * Finish write. Caller must hold acm->write_lock
186 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
190 usb_autopm_put_interface_async(acm->control);
196 * the caller is responsible for locking
199 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
205 wb->urb->transfer_buffer = wb->buf;
206 wb->urb->transfer_dma = wb->dmah;
207 wb->urb->transfer_buffer_length = wb->len;
208 wb->urb->dev = acm->dev;
210 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
212 dev_err(&acm->data->dev,
213 "%s - usb_submit_urb(write bulk) failed: %d\n",
215 acm_write_done(acm, wb);
220 static int acm_write_start(struct acm *acm, int wbn)
223 struct acm_wb *wb = &acm->wb[wbn];
226 spin_lock_irqsave(&acm->write_lock, flags);
229 spin_unlock_irqrestore(&acm->write_lock, flags);
233 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
235 usb_autopm_get_interface_async(acm->control);
236 if (acm->susp_count) {
237 if (!acm->delayed_wb)
238 acm->delayed_wb = wb;
240 usb_autopm_put_interface_async(acm->control);
241 spin_unlock_irqrestore(&acm->write_lock, flags);
242 return 0; /* A white lie */
244 usb_mark_last_busy(acm->dev);
246 rc = acm_start_wb(acm, wb);
247 spin_unlock_irqrestore(&acm->write_lock, flags);
253 * attributes exported through sysfs
255 static ssize_t show_caps
256 (struct device *dev, struct device_attribute *attr, char *buf)
258 struct usb_interface *intf = to_usb_interface(dev);
259 struct acm *acm = usb_get_intfdata(intf);
261 return sprintf(buf, "%d", acm->ctrl_caps);
263 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
265 static ssize_t show_country_codes
266 (struct device *dev, struct device_attribute *attr, char *buf)
268 struct usb_interface *intf = to_usb_interface(dev);
269 struct acm *acm = usb_get_intfdata(intf);
271 memcpy(buf, acm->country_codes, acm->country_code_size);
272 return acm->country_code_size;
275 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
277 static ssize_t show_country_rel_date
278 (struct device *dev, struct device_attribute *attr, char *buf)
280 struct usb_interface *intf = to_usb_interface(dev);
281 struct acm *acm = usb_get_intfdata(intf);
283 return sprintf(buf, "%d", acm->country_rel_date);
286 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
288 * Interrupt handlers for various ACM device responses
291 /* control interface reports status changes with "interrupt" transfers */
292 static void acm_ctrl_irq(struct urb *urb)
294 struct acm *acm = urb->context;
295 struct usb_cdc_notification *dr = urb->transfer_buffer;
296 struct tty_struct *tty;
300 int status = urb->status;
309 /* this urb is terminated, clean up */
310 dev_dbg(&acm->control->dev,
311 "%s - urb shutting down with status: %d\n",
315 dev_dbg(&acm->control->dev,
316 "%s - nonzero urb status received: %d\n",
321 usb_mark_last_busy(acm->dev);
323 data = (unsigned char *)(dr + 1);
324 switch (dr->bNotificationType) {
325 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
326 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
327 __func__, dr->wValue);
330 case USB_CDC_NOTIFY_SERIAL_STATE:
331 tty = tty_port_tty_get(&acm->port);
332 newctrl = get_unaligned_le16(data);
336 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
337 dev_dbg(&acm->control->dev,
338 "%s - calling hangup\n", __func__);
344 acm->ctrlin = newctrl;
346 dev_dbg(&acm->control->dev,
347 "%s - input control lines: dcd%c dsr%c break%c "
348 "ring%c framing%c parity%c overrun%c\n",
350 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
351 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
352 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
353 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
354 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
355 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
356 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
360 dev_dbg(&acm->control->dev,
361 "%s - unknown notification %d received: index %d "
362 "len %d data0 %d data1 %d\n",
364 dr->bNotificationType, dr->wIndex,
365 dr->wLength, data[0], data[1]);
369 retval = usb_submit_urb(urb, GFP_ATOMIC);
371 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
375 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
379 if (!test_and_clear_bit(index, &acm->read_urbs_free))
382 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
384 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
387 dev_err(&acm->data->dev,
388 "%s - usb_submit_urb failed: %d\n",
391 set_bit(index, &acm->read_urbs_free);
398 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
403 for (i = 0; i < acm->rx_buflimit; ++i) {
404 res = acm_submit_read_urb(acm, i, mem_flags);
412 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
414 struct tty_struct *tty;
416 if (!urb->actual_length)
419 tty = tty_port_tty_get(&acm->port);
423 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
424 tty_flip_buffer_push(tty);
429 static void acm_read_bulk_callback(struct urb *urb)
431 struct acm_rb *rb = urb->context;
432 struct acm *acm = rb->instance;
435 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
436 rb->index, urb->actual_length);
437 set_bit(rb->index, &acm->read_urbs_free);
440 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
443 usb_mark_last_busy(acm->dev);
446 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
447 __func__, urb->status);
450 acm_process_read_urb(acm, urb);
452 /* throttle device if requested by tty */
453 spin_lock_irqsave(&acm->read_lock, flags);
454 acm->throttled = acm->throttle_req;
455 if (!acm->throttled && !acm->susp_count) {
456 spin_unlock_irqrestore(&acm->read_lock, flags);
457 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
459 spin_unlock_irqrestore(&acm->read_lock, flags);
463 /* data interface wrote those outgoing bytes */
464 static void acm_write_bulk(struct urb *urb)
466 struct acm_wb *wb = urb->context;
467 struct acm *acm = wb->instance;
470 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
471 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
474 urb->transfer_buffer_length,
477 spin_lock_irqsave(&acm->write_lock, flags);
478 acm_write_done(acm, wb);
479 spin_unlock_irqrestore(&acm->write_lock, flags);
480 schedule_work(&acm->work);
483 static void acm_softint(struct work_struct *work)
485 struct acm *acm = container_of(work, struct acm, work);
486 struct tty_struct *tty;
488 dev_vdbg(&acm->data->dev, "%s\n", __func__);
490 tty = tty_port_tty_get(&acm->port);
501 static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
506 dev_dbg(tty->dev, "%s\n", __func__);
508 acm = acm_get_by_index(tty->index);
512 retval = tty_init_termios(tty);
514 goto error_init_termios;
516 tty->driver_data = acm;
518 /* Final install (we use the default method) */
519 tty_driver_kref_get(driver);
521 driver->ttys[tty->index] = tty;
526 tty_port_put(&acm->port);
530 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
532 struct acm *acm = tty->driver_data;
534 dev_dbg(tty->dev, "%s\n", __func__);
536 return tty_port_open(&acm->port, tty, filp);
539 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
541 struct acm *acm = container_of(port, struct acm, port);
542 int retval = -ENODEV;
544 dev_dbg(&acm->control->dev, "%s\n", __func__);
546 mutex_lock(&acm->mutex);
547 if (acm->disconnected)
550 retval = usb_autopm_get_interface(acm->control);
552 goto error_get_interface;
555 * FIXME: Why do we need this? Allocating 64K of physically contiguous
556 * memory is really nasty...
558 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
559 acm->control->needs_remote_wakeup = 1;
561 acm->ctrlurb->dev = acm->dev;
562 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
563 dev_err(&acm->control->dev,
564 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
565 goto error_submit_urb;
568 acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
569 if (acm_set_control(acm, acm->ctrlout) < 0 &&
570 (acm->ctrl_caps & USB_CDC_CAP_LINE))
571 goto error_set_control;
573 usb_autopm_put_interface(acm->control);
575 if (acm_submit_read_urbs(acm, GFP_KERNEL))
576 goto error_submit_read_urbs;
578 mutex_unlock(&acm->mutex);
582 error_submit_read_urbs:
584 acm_set_control(acm, acm->ctrlout);
586 usb_kill_urb(acm->ctrlurb);
588 usb_autopm_put_interface(acm->control);
591 mutex_unlock(&acm->mutex);
595 static void acm_port_destruct(struct tty_port *port)
597 struct acm *acm = container_of(port, struct acm, port);
599 dev_dbg(&acm->control->dev, "%s\n", __func__);
601 tty_unregister_device(acm_tty_driver, acm->minor);
602 acm_release_minor(acm);
603 usb_put_intf(acm->control);
604 kfree(acm->country_codes);
608 static void acm_port_shutdown(struct tty_port *port)
610 struct acm *acm = container_of(port, struct acm, port);
613 dev_dbg(&acm->control->dev, "%s\n", __func__);
615 mutex_lock(&acm->mutex);
616 if (!acm->disconnected) {
617 usb_autopm_get_interface(acm->control);
618 acm_set_control(acm, acm->ctrlout = 0);
619 usb_kill_urb(acm->ctrlurb);
620 for (i = 0; i < ACM_NW; i++)
621 usb_kill_urb(acm->wb[i].urb);
622 for (i = 0; i < acm->rx_buflimit; i++)
623 usb_kill_urb(acm->read_urbs[i]);
624 acm->control->needs_remote_wakeup = 0;
625 usb_autopm_put_interface(acm->control);
627 mutex_unlock(&acm->mutex);
630 static void acm_tty_cleanup(struct tty_struct *tty)
632 struct acm *acm = tty->driver_data;
633 dev_dbg(&acm->control->dev, "%s\n", __func__);
634 tty_port_put(&acm->port);
637 static void acm_tty_hangup(struct tty_struct *tty)
639 struct acm *acm = tty->driver_data;
640 dev_dbg(&acm->control->dev, "%s\n", __func__);
641 tty_port_hangup(&acm->port);
644 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
646 struct acm *acm = tty->driver_data;
647 dev_dbg(&acm->control->dev, "%s\n", __func__);
648 tty_port_close(&acm->port, tty, filp);
651 static int acm_tty_write(struct tty_struct *tty,
652 const unsigned char *buf, int count)
654 struct acm *acm = tty->driver_data;
663 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
665 spin_lock_irqsave(&acm->write_lock, flags);
666 wbn = acm_wb_alloc(acm);
668 spin_unlock_irqrestore(&acm->write_lock, flags);
673 count = (count > acm->writesize) ? acm->writesize : count;
674 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
675 memcpy(wb->buf, buf, count);
677 spin_unlock_irqrestore(&acm->write_lock, flags);
679 stat = acm_write_start(acm, wbn);
685 static int acm_tty_write_room(struct tty_struct *tty)
687 struct acm *acm = tty->driver_data;
689 * Do not let the line discipline to know that we have a reserve,
690 * or it might get too enthusiastic.
692 return acm_wb_is_avail(acm) ? acm->writesize : 0;
695 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
697 struct acm *acm = tty->driver_data;
699 * if the device was unplugged then any remaining characters fell out
700 * of the connector ;)
702 if (acm->disconnected)
705 * This is inaccurate (overcounts), but it works.
707 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
710 static void acm_tty_throttle(struct tty_struct *tty)
712 struct acm *acm = tty->driver_data;
714 spin_lock_irq(&acm->read_lock);
715 acm->throttle_req = 1;
716 spin_unlock_irq(&acm->read_lock);
719 static void acm_tty_unthrottle(struct tty_struct *tty)
721 struct acm *acm = tty->driver_data;
722 unsigned int was_throttled;
724 spin_lock_irq(&acm->read_lock);
725 was_throttled = acm->throttled;
727 acm->throttle_req = 0;
728 spin_unlock_irq(&acm->read_lock);
731 acm_submit_read_urbs(acm, GFP_KERNEL);
734 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
736 struct acm *acm = tty->driver_data;
739 retval = acm_send_break(acm, state ? 0xffff : 0);
741 dev_dbg(&acm->control->dev, "%s - send break failed\n",
746 static int acm_tty_tiocmget(struct tty_struct *tty)
748 struct acm *acm = tty->driver_data;
750 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
751 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
752 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
753 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
754 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
758 static int acm_tty_tiocmset(struct tty_struct *tty,
759 unsigned int set, unsigned int clear)
761 struct acm *acm = tty->driver_data;
762 unsigned int newctrl;
764 newctrl = acm->ctrlout;
765 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
766 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
767 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
768 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
770 newctrl = (newctrl & ~clear) | set;
772 if (acm->ctrlout == newctrl)
774 return acm_set_control(acm, acm->ctrlout = newctrl);
777 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
779 struct serial_struct tmp;
784 memset(&tmp, 0, sizeof(tmp));
785 tmp.flags = ASYNC_LOW_LATENCY;
786 tmp.xmit_fifo_size = acm->writesize;
787 tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
789 if (copy_to_user(info, &tmp, sizeof(tmp)))
795 static int acm_tty_ioctl(struct tty_struct *tty,
796 unsigned int cmd, unsigned long arg)
798 struct acm *acm = tty->driver_data;
799 int rv = -ENOIOCTLCMD;
802 case TIOCGSERIAL: /* gets serial port data */
803 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
810 static const __u32 acm_tty_speed[] = {
811 0, 50, 75, 110, 134, 150, 200, 300, 600,
812 1200, 1800, 2400, 4800, 9600, 19200, 38400,
813 57600, 115200, 230400, 460800, 500000, 576000,
814 921600, 1000000, 1152000, 1500000, 2000000,
815 2500000, 3000000, 3500000, 4000000
818 static const __u8 acm_tty_size[] = {
822 static void acm_tty_set_termios(struct tty_struct *tty,
823 struct ktermios *termios_old)
825 struct acm *acm = tty->driver_data;
826 struct ktermios *termios = tty->termios;
827 struct usb_cdc_line_coding newline;
828 int newctrl = acm->ctrlout;
830 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
831 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
832 newline.bParityType = termios->c_cflag & PARENB ?
833 (termios->c_cflag & PARODD ? 1 : 2) +
834 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
835 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
836 /* FIXME: Needs to clear unsupported bits in the termios */
837 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
839 if (!newline.dwDTERate) {
840 newline.dwDTERate = acm->line.dwDTERate;
841 newctrl &= ~ACM_CTRL_DTR;
843 newctrl |= ACM_CTRL_DTR;
845 if (newctrl != acm->ctrlout)
846 acm_set_control(acm, acm->ctrlout = newctrl);
848 if (memcmp(&acm->line, &newline, sizeof newline)) {
849 memcpy(&acm->line, &newline, sizeof newline);
850 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
852 le32_to_cpu(newline.dwDTERate),
853 newline.bCharFormat, newline.bParityType,
855 acm_set_line(acm, &acm->line);
859 static const struct tty_port_operations acm_port_ops = {
860 .shutdown = acm_port_shutdown,
861 .activate = acm_port_activate,
862 .destruct = acm_port_destruct,
866 * USB probe and disconnect routines.
869 /* Little helpers: write/read buffers free */
870 static void acm_write_buffers_free(struct acm *acm)
874 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
876 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
877 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
880 static void acm_read_buffers_free(struct acm *acm)
882 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
885 for (i = 0; i < acm->rx_buflimit; i++)
886 usb_free_coherent(usb_dev, acm->readsize,
887 acm->read_buffers[i].base, acm->read_buffers[i].dma);
890 /* Little helper: write buffers allocate */
891 static int acm_write_buffers_alloc(struct acm *acm)
896 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
897 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
903 usb_free_coherent(acm->dev, acm->writesize,
912 static int acm_probe(struct usb_interface *intf,
913 const struct usb_device_id *id)
915 struct usb_cdc_union_desc *union_header = NULL;
916 struct usb_cdc_country_functional_desc *cfd = NULL;
917 unsigned char *buffer = intf->altsetting->extra;
918 int buflen = intf->altsetting->extralen;
919 struct usb_interface *control_interface;
920 struct usb_interface *data_interface;
921 struct usb_endpoint_descriptor *epctrl = NULL;
922 struct usb_endpoint_descriptor *epread = NULL;
923 struct usb_endpoint_descriptor *epwrite = NULL;
924 struct usb_device *usb_dev = interface_to_usbdev(intf);
927 int ctrlsize, readsize;
929 u8 ac_management_function = 0;
930 u8 call_management_function = 0;
931 int call_interface_num = -1;
932 int data_interface_num = -1;
933 unsigned long quirks;
936 int combined_interfaces = 0;
939 quirks = (unsigned long)id->driver_info;
940 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
942 /* handle quirks deadly to normal probing*/
943 if (quirks == NO_UNION_NORMAL) {
944 data_interface = usb_ifnum_to_if(usb_dev, 1);
945 control_interface = usb_ifnum_to_if(usb_dev, 0);
946 goto skip_normal_probe;
951 dev_err(&intf->dev, "Weird descriptor references\n");
956 if (intf->cur_altsetting->endpoint &&
957 intf->cur_altsetting->endpoint->extralen &&
958 intf->cur_altsetting->endpoint->extra) {
960 "Seeking extra descriptors on endpoint\n");
961 buflen = intf->cur_altsetting->endpoint->extralen;
962 buffer = intf->cur_altsetting->endpoint->extra;
965 "Zero length descriptor references\n");
971 if (buffer[1] != USB_DT_CS_INTERFACE) {
972 dev_err(&intf->dev, "skipping garbage\n");
977 case USB_CDC_UNION_TYPE: /* we've found it */
979 dev_err(&intf->dev, "More than one "
980 "union descriptor, skipping ...\n");
983 union_header = (struct usb_cdc_union_desc *)buffer;
985 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
986 cfd = (struct usb_cdc_country_functional_desc *)buffer;
988 case USB_CDC_HEADER_TYPE: /* maybe check version */
989 break; /* for now we ignore it */
990 case USB_CDC_ACM_TYPE:
991 ac_management_function = buffer[3];
993 case USB_CDC_CALL_MANAGEMENT_TYPE:
994 call_management_function = buffer[3];
995 call_interface_num = buffer[4];
996 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
997 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1000 /* there are LOTS more CDC descriptors that
1001 * could legitimately be found here.
1003 dev_dbg(&intf->dev, "Ignoring descriptor: "
1004 "type %02x, length %d\n",
1005 buffer[2], buffer[0]);
1009 buflen -= buffer[0];
1010 buffer += buffer[0];
1013 if (!union_header) {
1014 if (call_interface_num > 0) {
1015 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1016 /* quirks for Droids MuIn LCD */
1017 if (quirks & NO_DATA_INTERFACE)
1018 data_interface = usb_ifnum_to_if(usb_dev, 0);
1020 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1021 control_interface = intf;
1023 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1024 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1027 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1028 combined_interfaces = 1;
1029 control_interface = data_interface = intf;
1030 goto look_for_collapsed_interface;
1034 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1035 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1036 if (!control_interface || !data_interface) {
1037 dev_dbg(&intf->dev, "no interfaces\n");
1042 if (data_interface_num != call_interface_num)
1043 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1045 if (control_interface == data_interface) {
1046 /* some broken devices designed for windows work this way */
1047 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1048 combined_interfaces = 1;
1049 /* a popular other OS doesn't use it */
1050 quirks |= NO_CAP_LINE;
1051 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1052 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1055 look_for_collapsed_interface:
1056 for (i = 0; i < 3; i++) {
1057 struct usb_endpoint_descriptor *ep;
1058 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1060 if (usb_endpoint_is_int_in(ep))
1062 else if (usb_endpoint_is_bulk_out(ep))
1064 else if (usb_endpoint_is_bulk_in(ep))
1069 if (!epctrl || !epread || !epwrite)
1072 goto made_compressed_probe;
1077 /*workaround for switched interfaces */
1078 if (data_interface->cur_altsetting->desc.bInterfaceClass
1079 != CDC_DATA_INTERFACE_TYPE) {
1080 if (control_interface->cur_altsetting->desc.bInterfaceClass
1081 == CDC_DATA_INTERFACE_TYPE) {
1082 struct usb_interface *t;
1084 "Your device has switched interfaces.\n");
1085 t = control_interface;
1086 control_interface = data_interface;
1093 /* Accept probe requests only for the control interface */
1094 if (!combined_interfaces && intf != control_interface)
1097 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1098 /* valid in this context */
1099 dev_dbg(&intf->dev, "The data interface isn't available\n");
1104 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1107 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1108 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1109 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1112 /* workaround for switched endpoints */
1113 if (!usb_endpoint_dir_in(epread)) {
1114 /* descriptors are swapped */
1115 struct usb_endpoint_descriptor *t;
1117 "The data interface has switched endpoints\n");
1122 made_compressed_probe:
1123 dev_dbg(&intf->dev, "interfaces are valid\n");
1125 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1127 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1131 minor = acm_alloc_minor(acm);
1132 if (minor == ACM_TTY_MINORS) {
1133 dev_err(&intf->dev, "no more free acm devices\n");
1138 ctrlsize = usb_endpoint_maxp(epctrl);
1139 readsize = usb_endpoint_maxp(epread) *
1140 (quirks == SINGLE_RX_URB ? 1 : 2);
1141 acm->combined_interfaces = combined_interfaces;
1142 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1143 acm->control = control_interface;
1144 acm->data = data_interface;
1147 acm->ctrl_caps = ac_management_function;
1148 if (quirks & NO_CAP_LINE)
1149 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1150 acm->ctrlsize = ctrlsize;
1151 acm->readsize = readsize;
1152 acm->rx_buflimit = num_rx_buf;
1153 INIT_WORK(&acm->work, acm_softint);
1154 spin_lock_init(&acm->write_lock);
1155 spin_lock_init(&acm->read_lock);
1156 mutex_init(&acm->mutex);
1157 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1158 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1160 acm->bInterval = epread->bInterval;
1161 tty_port_init(&acm->port);
1162 acm->port.ops = &acm_port_ops;
1164 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1166 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1169 acm->ctrl_buffer = buf;
1171 if (acm_write_buffers_alloc(acm) < 0) {
1172 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1176 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1177 if (!acm->ctrlurb) {
1178 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1181 for (i = 0; i < num_rx_buf; i++) {
1182 struct acm_rb *rb = &(acm->read_buffers[i]);
1185 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1188 dev_err(&intf->dev, "out of memory "
1189 "(read bufs usb_alloc_coherent)\n");
1195 urb = usb_alloc_urb(0, GFP_KERNEL);
1198 "out of memory (read urbs usb_alloc_urb)\n");
1201 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1202 urb->transfer_dma = rb->dma;
1203 if (acm->is_int_ep) {
1204 usb_fill_int_urb(urb, acm->dev,
1208 acm_read_bulk_callback, rb,
1211 usb_fill_bulk_urb(urb, acm->dev,
1215 acm_read_bulk_callback, rb);
1218 acm->read_urbs[i] = urb;
1219 __set_bit(i, &acm->read_urbs_free);
1221 for (i = 0; i < ACM_NW; i++) {
1222 struct acm_wb *snd = &(acm->wb[i]);
1224 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1225 if (snd->urb == NULL) {
1227 "out of memory (write urbs usb_alloc_urb)\n");
1231 if (usb_endpoint_xfer_int(epwrite))
1232 usb_fill_int_urb(snd->urb, usb_dev,
1233 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1234 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1236 usb_fill_bulk_urb(snd->urb, usb_dev,
1237 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1238 NULL, acm->writesize, acm_write_bulk, snd);
1239 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1240 snd->instance = acm;
1243 usb_set_intfdata(intf, acm);
1245 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1249 if (cfd) { /* export the country data */
1250 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1251 if (!acm->country_codes)
1252 goto skip_countries;
1253 acm->country_code_size = cfd->bLength - 4;
1254 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1256 acm->country_rel_date = cfd->iCountryCodeRelDate;
1258 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1260 kfree(acm->country_codes);
1261 acm->country_codes = NULL;
1262 acm->country_code_size = 0;
1263 goto skip_countries;
1266 i = device_create_file(&intf->dev,
1267 &dev_attr_iCountryCodeRelDate);
1269 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1270 kfree(acm->country_codes);
1271 acm->country_codes = NULL;
1272 acm->country_code_size = 0;
1273 goto skip_countries;
1278 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1279 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1280 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1281 /* works around buggy devices */
1282 epctrl->bInterval ? epctrl->bInterval : 0xff);
1283 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1284 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1286 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1288 acm_set_control(acm, acm->ctrlout);
1290 acm->line.dwDTERate = cpu_to_le32(9600);
1291 acm->line.bDataBits = 8;
1292 acm_set_line(acm, &acm->line);
1294 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1295 usb_set_intfdata(data_interface, acm);
1297 usb_get_intf(control_interface);
1298 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1302 for (i = 0; i < ACM_NW; i++)
1303 usb_free_urb(acm->wb[i].urb);
1305 for (i = 0; i < num_rx_buf; i++)
1306 usb_free_urb(acm->read_urbs[i]);
1307 acm_read_buffers_free(acm);
1308 usb_free_urb(acm->ctrlurb);
1310 acm_write_buffers_free(acm);
1312 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1314 acm_release_minor(acm);
1320 static void stop_data_traffic(struct acm *acm)
1324 dev_dbg(&acm->control->dev, "%s\n", __func__);
1326 usb_kill_urb(acm->ctrlurb);
1327 for (i = 0; i < ACM_NW; i++)
1328 usb_kill_urb(acm->wb[i].urb);
1329 for (i = 0; i < acm->rx_buflimit; i++)
1330 usb_kill_urb(acm->read_urbs[i]);
1332 cancel_work_sync(&acm->work);
1335 static void acm_disconnect(struct usb_interface *intf)
1337 struct acm *acm = usb_get_intfdata(intf);
1338 struct usb_device *usb_dev = interface_to_usbdev(intf);
1339 struct tty_struct *tty;
1342 dev_dbg(&intf->dev, "%s\n", __func__);
1344 /* sibling interface is already cleaning up */
1348 mutex_lock(&acm->mutex);
1349 acm->disconnected = true;
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);
1357 usb_set_intfdata(acm->control, NULL);
1358 usb_set_intfdata(acm->data, NULL);
1359 mutex_unlock(&acm->mutex);
1361 tty = tty_port_tty_get(&acm->port);
1367 stop_data_traffic(acm);
1369 usb_free_urb(acm->ctrlurb);
1370 for (i = 0; i < ACM_NW; i++)
1371 usb_free_urb(acm->wb[i].urb);
1372 for (i = 0; i < acm->rx_buflimit; i++)
1373 usb_free_urb(acm->read_urbs[i]);
1374 acm_write_buffers_free(acm);
1375 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1376 acm_read_buffers_free(acm);
1378 if (!acm->combined_interfaces)
1379 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1380 acm->data : acm->control);
1382 tty_port_put(&acm->port);
1386 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1388 struct acm *acm = usb_get_intfdata(intf);
1391 if (PMSG_IS_AUTO(message)) {
1394 spin_lock_irq(&acm->write_lock);
1395 b = acm->transmitting;
1396 spin_unlock_irq(&acm->write_lock);
1401 spin_lock_irq(&acm->read_lock);
1402 spin_lock(&acm->write_lock);
1403 cnt = acm->susp_count++;
1404 spin_unlock(&acm->write_lock);
1405 spin_unlock_irq(&acm->read_lock);
1410 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1411 stop_data_traffic(acm);
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 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1432 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1434 spin_lock_irq(&acm->write_lock);
1435 if (acm->delayed_wb) {
1436 wb = acm->delayed_wb;
1437 acm->delayed_wb = NULL;
1438 spin_unlock_irq(&acm->write_lock);
1439 acm_start_wb(acm, wb);
1441 spin_unlock_irq(&acm->write_lock);
1445 * delayed error checking because we must
1446 * do the write path at all cost
1451 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1458 static int acm_reset_resume(struct usb_interface *intf)
1460 struct acm *acm = usb_get_intfdata(intf);
1461 struct tty_struct *tty;
1463 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1464 tty = tty_port_tty_get(&acm->port);
1471 return acm_resume(intf);
1474 #endif /* CONFIG_PM */
1476 #define NOKIA_PCSUITE_ACM_INFO(x) \
1477 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1478 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1479 USB_CDC_ACM_PROTO_VENDOR)
1481 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1482 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1483 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1484 USB_CDC_ACM_PROTO_VENDOR)
1487 * USB driver structure.
1490 static const struct usb_device_id acm_ids[] = {
1491 /* quirky and broken devices */
1492 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1493 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1496 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1499 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1502 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1505 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1508 .driver_info = SINGLE_RX_URB,
1510 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1511 .driver_info = SINGLE_RX_URB, /* firmware bug */
1513 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1514 .driver_info = SINGLE_RX_URB, /* firmware bug */
1516 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1517 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1520 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1523 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1526 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1529 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1533 /* Motorola H24 HSPA module: */
1534 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1535 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1536 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1537 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1538 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1539 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1540 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1541 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1543 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1544 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1545 data interface instead of
1546 communications interface.
1547 Maybe we should define a new
1550 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1551 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1553 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1554 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1557 /* Nokia S60 phones expose two ACM channels. The first is
1558 * a modem and is picked up by the standard AT-command
1559 * information below. The second is 'vendor-specific' but
1560 * is treated as a serial device at the S60 end, so we want
1561 * to expose it on Linux too. */
1562 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1564 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1577 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1580 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1581 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1582 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1583 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1585 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1586 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1587 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1588 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1591 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1593 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1594 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1596 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1597 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1598 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1602 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1603 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1604 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1606 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1609 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1611 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1612 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1613 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1614 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1615 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1616 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1617 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1619 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1621 /* Support for Owen devices */
1622 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1624 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1626 /* Support Lego NXT using pbLua firmware */
1627 { USB_DEVICE(0x0694, 0xff00),
1628 .driver_info = NOT_A_MODEM,
1631 /* Support for Droids MuIn LCD */
1632 { USB_DEVICE(0x04d8, 0x000b),
1633 .driver_info = NO_DATA_INTERFACE,
1636 /* control interfaces without any protocol set */
1637 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1638 USB_CDC_PROTO_NONE) },
1640 /* control interfaces with various AT-command sets */
1641 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1642 USB_CDC_ACM_PROTO_AT_V25TER) },
1643 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1644 USB_CDC_ACM_PROTO_AT_PCCA101) },
1645 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1646 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1647 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1648 USB_CDC_ACM_PROTO_AT_GSM) },
1649 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1650 USB_CDC_ACM_PROTO_AT_3G) },
1651 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1652 USB_CDC_ACM_PROTO_AT_CDMA) },
1657 MODULE_DEVICE_TABLE(usb, acm_ids);
1659 static struct usb_driver acm_driver = {
1662 .disconnect = acm_disconnect,
1664 .suspend = acm_suspend,
1665 .resume = acm_resume,
1666 .reset_resume = acm_reset_resume,
1668 .id_table = acm_ids,
1670 .supports_autosuspend = 1,
1675 * TTY driver structures.
1678 static const struct tty_operations acm_ops = {
1679 .install = acm_tty_install,
1680 .open = acm_tty_open,
1681 .close = acm_tty_close,
1682 .cleanup = acm_tty_cleanup,
1683 .hangup = acm_tty_hangup,
1684 .write = acm_tty_write,
1685 .write_room = acm_tty_write_room,
1686 .ioctl = acm_tty_ioctl,
1687 .throttle = acm_tty_throttle,
1688 .unthrottle = acm_tty_unthrottle,
1689 .chars_in_buffer = acm_tty_chars_in_buffer,
1690 .break_ctl = acm_tty_break_ctl,
1691 .set_termios = acm_tty_set_termios,
1692 .tiocmget = acm_tty_tiocmget,
1693 .tiocmset = acm_tty_tiocmset,
1700 static int __init acm_init(void)
1703 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1704 if (!acm_tty_driver)
1706 acm_tty_driver->owner = THIS_MODULE,
1707 acm_tty_driver->driver_name = "acm",
1708 acm_tty_driver->name = "ttyACM",
1709 acm_tty_driver->major = ACM_TTY_MAJOR,
1710 acm_tty_driver->minor_start = 0,
1711 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1712 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1713 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1714 acm_tty_driver->init_termios = tty_std_termios;
1715 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1717 tty_set_operations(acm_tty_driver, &acm_ops);
1719 retval = tty_register_driver(acm_tty_driver);
1721 put_tty_driver(acm_tty_driver);
1725 retval = usb_register(&acm_driver);
1727 tty_unregister_driver(acm_tty_driver);
1728 put_tty_driver(acm_tty_driver);
1732 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1737 static void __exit acm_exit(void)
1739 usb_deregister(&acm_driver);
1740 tty_unregister_driver(acm_tty_driver);
1741 put_tty_driver(acm_tty_driver);
1744 module_init(acm_init);
1745 module_exit(acm_exit);
1747 MODULE_AUTHOR(DRIVER_AUTHOR);
1748 MODULE_DESCRIPTION(DRIVER_DESC);
1749 MODULE_LICENSE("GPL");
1750 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);