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/module.h>
43 #include <linux/mutex.h>
44 #include <linux/uaccess.h>
45 #include <linux/usb.h>
46 #include <linux/usb/cdc.h>
47 #include <asm/byteorder.h>
48 #include <asm/unaligned.h>
49 #include <linux/list.h>
54 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
55 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
57 static struct usb_driver acm_driver;
58 static struct tty_driver *acm_tty_driver;
59 static struct acm *acm_table[ACM_TTY_MINORS];
61 static DEFINE_MUTEX(acm_table_lock);
68 * Look up an ACM structure by index. If found and not disconnected, increment
69 * its refcount and return it with its mutex held.
71 static struct acm *acm_get_by_index(unsigned index)
75 mutex_lock(&acm_table_lock);
76 acm = acm_table[index];
78 mutex_lock(&acm->mutex);
79 if (acm->disconnected) {
80 mutex_unlock(&acm->mutex);
83 tty_port_get(&acm->port);
84 mutex_unlock(&acm->mutex);
87 mutex_unlock(&acm_table_lock);
92 * Try to find an available minor number and if found, associate it with 'acm'.
94 static int acm_alloc_minor(struct acm *acm)
98 mutex_lock(&acm_table_lock);
99 for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
100 if (!acm_table[minor]) {
101 acm_table[minor] = acm;
105 mutex_unlock(&acm_table_lock);
110 /* Release the minor number associated with 'acm'. */
111 static void acm_release_minor(struct acm *acm)
113 mutex_lock(&acm_table_lock);
114 acm_table[acm->minor] = NULL;
115 mutex_unlock(&acm_table_lock);
119 * Functions for ACM control messages.
122 static int acm_ctrl_msg(struct acm *acm, int request, int value,
125 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
126 request, USB_RT_ACM, value,
127 acm->control->altsetting[0].desc.bInterfaceNumber,
129 dev_dbg(&acm->control->dev,
130 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
131 __func__, request, value, len, retval);
132 return retval < 0 ? retval : 0;
135 /* devices aren't required to support these requests.
136 * the cdc acm descriptor tells whether they do...
138 #define acm_set_control(acm, control) \
139 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
140 #define acm_set_line(acm, line) \
141 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
142 #define acm_send_break(acm, ms) \
143 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
146 * Write buffer management.
147 * All of these assume proper locks taken by the caller.
150 static int acm_wb_alloc(struct acm *acm)
163 wbn = (wbn + 1) % ACM_NW;
169 static int acm_wb_is_avail(struct acm *acm)
175 spin_lock_irqsave(&acm->write_lock, flags);
176 for (i = 0; i < ACM_NW; i++)
178 spin_unlock_irqrestore(&acm->write_lock, flags);
183 * Finish write. Caller must hold acm->write_lock
185 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
189 usb_autopm_put_interface_async(acm->control);
195 * the caller is responsible for locking
198 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
204 wb->urb->transfer_buffer = wb->buf;
205 wb->urb->transfer_dma = wb->dmah;
206 wb->urb->transfer_buffer_length = wb->len;
207 wb->urb->dev = acm->dev;
209 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
211 dev_err(&acm->data->dev,
212 "%s - usb_submit_urb(write bulk) failed: %d\n",
214 acm_write_done(acm, wb);
219 static int acm_write_start(struct acm *acm, int wbn)
222 struct acm_wb *wb = &acm->wb[wbn];
225 spin_lock_irqsave(&acm->write_lock, flags);
228 spin_unlock_irqrestore(&acm->write_lock, flags);
232 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
234 usb_autopm_get_interface_async(acm->control);
235 if (acm->susp_count) {
236 if (!acm->delayed_wb)
237 acm->delayed_wb = wb;
239 usb_autopm_put_interface_async(acm->control);
240 spin_unlock_irqrestore(&acm->write_lock, flags);
241 return 0; /* A white lie */
243 usb_mark_last_busy(acm->dev);
245 rc = acm_start_wb(acm, wb);
246 spin_unlock_irqrestore(&acm->write_lock, flags);
252 * attributes exported through sysfs
254 static ssize_t show_caps
255 (struct device *dev, struct device_attribute *attr, char *buf)
257 struct usb_interface *intf = to_usb_interface(dev);
258 struct acm *acm = usb_get_intfdata(intf);
260 return sprintf(buf, "%d", acm->ctrl_caps);
262 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
264 static ssize_t show_country_codes
265 (struct device *dev, struct device_attribute *attr, char *buf)
267 struct usb_interface *intf = to_usb_interface(dev);
268 struct acm *acm = usb_get_intfdata(intf);
270 memcpy(buf, acm->country_codes, acm->country_code_size);
271 return acm->country_code_size;
274 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
276 static ssize_t show_country_rel_date
277 (struct device *dev, struct device_attribute *attr, char *buf)
279 struct usb_interface *intf = to_usb_interface(dev);
280 struct acm *acm = usb_get_intfdata(intf);
282 return sprintf(buf, "%d", acm->country_rel_date);
285 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
287 * Interrupt handlers for various ACM device responses
290 /* control interface reports status changes with "interrupt" transfers */
291 static void acm_ctrl_irq(struct urb *urb)
293 struct acm *acm = urb->context;
294 struct usb_cdc_notification *dr = urb->transfer_buffer;
295 struct tty_struct *tty;
299 int status = urb->status;
308 /* this urb is terminated, clean up */
309 dev_dbg(&acm->control->dev,
310 "%s - urb shutting down with status: %d\n",
314 dev_dbg(&acm->control->dev,
315 "%s - nonzero urb status received: %d\n",
320 usb_mark_last_busy(acm->dev);
322 data = (unsigned char *)(dr + 1);
323 switch (dr->bNotificationType) {
324 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
325 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
326 __func__, dr->wValue);
329 case USB_CDC_NOTIFY_SERIAL_STATE:
330 tty = tty_port_tty_get(&acm->port);
331 newctrl = get_unaligned_le16(data);
335 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
336 dev_dbg(&acm->control->dev,
337 "%s - calling hangup\n", __func__);
343 acm->ctrlin = newctrl;
345 dev_dbg(&acm->control->dev,
346 "%s - input control lines: dcd%c dsr%c break%c "
347 "ring%c framing%c parity%c overrun%c\n",
349 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
350 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
351 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
352 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
353 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
354 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
355 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
359 dev_dbg(&acm->control->dev,
360 "%s - unknown notification %d received: index %d "
361 "len %d data0 %d data1 %d\n",
363 dr->bNotificationType, dr->wIndex,
364 dr->wLength, data[0], data[1]);
368 retval = usb_submit_urb(urb, GFP_ATOMIC);
370 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
374 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
378 if (!test_and_clear_bit(index, &acm->read_urbs_free))
381 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
383 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
386 dev_err(&acm->data->dev,
387 "%s - usb_submit_urb failed: %d\n",
390 set_bit(index, &acm->read_urbs_free);
397 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
402 for (i = 0; i < acm->rx_buflimit; ++i) {
403 res = acm_submit_read_urb(acm, i, mem_flags);
411 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
413 struct tty_struct *tty;
415 if (!urb->actual_length)
418 tty = tty_port_tty_get(&acm->port);
422 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
423 tty_flip_buffer_push(tty);
428 static void acm_read_bulk_callback(struct urb *urb)
430 struct acm_rb *rb = urb->context;
431 struct acm *acm = rb->instance;
434 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
435 rb->index, urb->actual_length);
436 set_bit(rb->index, &acm->read_urbs_free);
439 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
442 usb_mark_last_busy(acm->dev);
445 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
446 __func__, urb->status);
449 acm_process_read_urb(acm, urb);
451 /* throttle device if requested by tty */
452 spin_lock_irqsave(&acm->read_lock, flags);
453 acm->throttled = acm->throttle_req;
454 if (!acm->throttled && !acm->susp_count) {
455 spin_unlock_irqrestore(&acm->read_lock, flags);
456 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
458 spin_unlock_irqrestore(&acm->read_lock, flags);
462 /* data interface wrote those outgoing bytes */
463 static void acm_write_bulk(struct urb *urb)
465 struct acm_wb *wb = urb->context;
466 struct acm *acm = wb->instance;
469 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
470 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
473 urb->transfer_buffer_length,
476 spin_lock_irqsave(&acm->write_lock, flags);
477 acm_write_done(acm, wb);
478 spin_unlock_irqrestore(&acm->write_lock, flags);
479 schedule_work(&acm->work);
482 static void acm_softint(struct work_struct *work)
484 struct acm *acm = container_of(work, struct acm, work);
485 struct tty_struct *tty;
487 dev_vdbg(&acm->data->dev, "%s\n", __func__);
489 tty = tty_port_tty_get(&acm->port);
500 static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
505 dev_dbg(tty->dev, "%s\n", __func__);
507 acm = acm_get_by_index(tty->index);
511 retval = tty_standard_install(driver, tty);
513 goto error_init_termios;
515 tty->driver_data = acm;
520 tty_port_put(&acm->port);
524 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
526 struct acm *acm = tty->driver_data;
528 dev_dbg(tty->dev, "%s\n", __func__);
530 return tty_port_open(&acm->port, tty, filp);
533 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
535 struct acm *acm = container_of(port, struct acm, port);
536 int retval = -ENODEV;
538 dev_dbg(&acm->control->dev, "%s\n", __func__);
540 mutex_lock(&acm->mutex);
541 if (acm->disconnected)
544 retval = usb_autopm_get_interface(acm->control);
546 goto error_get_interface;
549 * FIXME: Why do we need this? Allocating 64K of physically contiguous
550 * memory is really nasty...
552 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
553 acm->control->needs_remote_wakeup = 1;
555 acm->ctrlurb->dev = acm->dev;
556 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
557 dev_err(&acm->control->dev,
558 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
559 goto error_submit_urb;
562 acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
563 if (acm_set_control(acm, acm->ctrlout) < 0 &&
564 (acm->ctrl_caps & USB_CDC_CAP_LINE))
565 goto error_set_control;
567 usb_autopm_put_interface(acm->control);
570 * Unthrottle device in case the TTY was closed while throttled.
572 spin_lock_irq(&acm->read_lock);
574 acm->throttle_req = 0;
575 spin_unlock_irq(&acm->read_lock);
577 if (acm_submit_read_urbs(acm, GFP_KERNEL))
578 goto error_submit_read_urbs;
580 mutex_unlock(&acm->mutex);
584 error_submit_read_urbs:
586 acm_set_control(acm, acm->ctrlout);
588 usb_kill_urb(acm->ctrlurb);
590 usb_autopm_put_interface(acm->control);
593 mutex_unlock(&acm->mutex);
597 static void acm_port_destruct(struct tty_port *port)
599 struct acm *acm = container_of(port, struct acm, port);
601 dev_dbg(&acm->control->dev, "%s\n", __func__);
603 tty_unregister_device(acm_tty_driver, acm->minor);
604 acm_release_minor(acm);
605 usb_put_intf(acm->control);
606 kfree(acm->country_codes);
610 static void acm_port_shutdown(struct tty_port *port)
612 struct acm *acm = container_of(port, struct acm, port);
615 dev_dbg(&acm->control->dev, "%s\n", __func__);
617 mutex_lock(&acm->mutex);
618 if (!acm->disconnected) {
619 usb_autopm_get_interface(acm->control);
620 acm_set_control(acm, acm->ctrlout = 0);
621 usb_kill_urb(acm->ctrlurb);
622 for (i = 0; i < ACM_NW; i++)
623 usb_kill_urb(acm->wb[i].urb);
624 for (i = 0; i < acm->rx_buflimit; i++)
625 usb_kill_urb(acm->read_urbs[i]);
626 acm->control->needs_remote_wakeup = 0;
627 usb_autopm_put_interface(acm->control);
629 mutex_unlock(&acm->mutex);
632 static void acm_tty_cleanup(struct tty_struct *tty)
634 struct acm *acm = tty->driver_data;
635 dev_dbg(&acm->control->dev, "%s\n", __func__);
636 tty_port_put(&acm->port);
639 static void acm_tty_hangup(struct tty_struct *tty)
641 struct acm *acm = tty->driver_data;
642 dev_dbg(&acm->control->dev, "%s\n", __func__);
643 tty_port_hangup(&acm->port);
646 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
648 struct acm *acm = tty->driver_data;
649 dev_dbg(&acm->control->dev, "%s\n", __func__);
650 tty_port_close(&acm->port, tty, filp);
653 static int acm_tty_write(struct tty_struct *tty,
654 const unsigned char *buf, int count)
656 struct acm *acm = tty->driver_data;
665 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
667 spin_lock_irqsave(&acm->write_lock, flags);
668 wbn = acm_wb_alloc(acm);
670 spin_unlock_irqrestore(&acm->write_lock, flags);
675 count = (count > acm->writesize) ? acm->writesize : count;
676 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
677 memcpy(wb->buf, buf, count);
679 spin_unlock_irqrestore(&acm->write_lock, flags);
681 stat = acm_write_start(acm, wbn);
687 static int acm_tty_write_room(struct tty_struct *tty)
689 struct acm *acm = tty->driver_data;
691 * Do not let the line discipline to know that we have a reserve,
692 * or it might get too enthusiastic.
694 return acm_wb_is_avail(acm) ? acm->writesize : 0;
697 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
699 struct acm *acm = tty->driver_data;
701 * if the device was unplugged then any remaining characters fell out
702 * of the connector ;)
704 if (acm->disconnected)
707 * This is inaccurate (overcounts), but it works.
709 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
712 static void acm_tty_throttle(struct tty_struct *tty)
714 struct acm *acm = tty->driver_data;
716 spin_lock_irq(&acm->read_lock);
717 acm->throttle_req = 1;
718 spin_unlock_irq(&acm->read_lock);
721 static void acm_tty_unthrottle(struct tty_struct *tty)
723 struct acm *acm = tty->driver_data;
724 unsigned int was_throttled;
726 spin_lock_irq(&acm->read_lock);
727 was_throttled = acm->throttled;
729 acm->throttle_req = 0;
730 spin_unlock_irq(&acm->read_lock);
733 acm_submit_read_urbs(acm, GFP_KERNEL);
736 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
738 struct acm *acm = tty->driver_data;
741 retval = acm_send_break(acm, state ? 0xffff : 0);
743 dev_dbg(&acm->control->dev, "%s - send break failed\n",
748 static int acm_tty_tiocmget(struct tty_struct *tty)
750 struct acm *acm = tty->driver_data;
752 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
753 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
754 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
755 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
756 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
760 static int acm_tty_tiocmset(struct tty_struct *tty,
761 unsigned int set, unsigned int clear)
763 struct acm *acm = tty->driver_data;
764 unsigned int newctrl;
766 newctrl = acm->ctrlout;
767 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
768 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
769 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
770 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
772 newctrl = (newctrl & ~clear) | set;
774 if (acm->ctrlout == newctrl)
776 return acm_set_control(acm, acm->ctrlout = newctrl);
779 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
781 struct serial_struct tmp;
786 memset(&tmp, 0, sizeof(tmp));
787 tmp.flags = ASYNC_LOW_LATENCY;
788 tmp.xmit_fifo_size = acm->writesize;
789 tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
790 tmp.close_delay = acm->port.close_delay / 10;
791 tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
792 ASYNC_CLOSING_WAIT_NONE :
793 acm->port.closing_wait / 10;
795 if (copy_to_user(info, &tmp, sizeof(tmp)))
801 static int set_serial_info(struct acm *acm,
802 struct serial_struct __user *newinfo)
804 struct serial_struct new_serial;
805 unsigned int closing_wait, close_delay;
808 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
811 close_delay = new_serial.close_delay * 10;
812 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
813 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
815 mutex_lock(&acm->port.mutex);
817 if (!capable(CAP_SYS_ADMIN)) {
818 if ((close_delay != acm->port.close_delay) ||
819 (closing_wait != acm->port.closing_wait))
822 retval = -EOPNOTSUPP;
824 acm->port.close_delay = close_delay;
825 acm->port.closing_wait = closing_wait;
828 mutex_unlock(&acm->port.mutex);
832 static int acm_tty_ioctl(struct tty_struct *tty,
833 unsigned int cmd, unsigned long arg)
835 struct acm *acm = tty->driver_data;
836 int rv = -ENOIOCTLCMD;
839 case TIOCGSERIAL: /* gets serial port data */
840 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
843 rv = set_serial_info(acm, (struct serial_struct __user *) arg);
850 static const __u32 acm_tty_speed[] = {
851 0, 50, 75, 110, 134, 150, 200, 300, 600,
852 1200, 1800, 2400, 4800, 9600, 19200, 38400,
853 57600, 115200, 230400, 460800, 500000, 576000,
854 921600, 1000000, 1152000, 1500000, 2000000,
855 2500000, 3000000, 3500000, 4000000
858 static void acm_tty_set_termios(struct tty_struct *tty,
859 struct ktermios *termios_old)
861 struct acm *acm = tty->driver_data;
862 struct ktermios *termios = &tty->termios;
863 struct usb_cdc_line_coding newline;
864 int newctrl = acm->ctrlout;
866 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
867 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
868 newline.bParityType = termios->c_cflag & PARENB ?
869 (termios->c_cflag & PARODD ? 1 : 2) +
870 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
871 switch (termios->c_cflag & CSIZE) {
873 newline.bDataBits = 5;
876 newline.bDataBits = 6;
879 newline.bDataBits = 7;
883 newline.bDataBits = 8;
886 /* FIXME: Needs to clear unsupported bits in the termios */
887 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
889 if (!newline.dwDTERate) {
890 newline.dwDTERate = acm->line.dwDTERate;
891 newctrl &= ~ACM_CTRL_DTR;
893 newctrl |= ACM_CTRL_DTR;
895 if (newctrl != acm->ctrlout)
896 acm_set_control(acm, acm->ctrlout = newctrl);
898 if (memcmp(&acm->line, &newline, sizeof newline)) {
899 memcpy(&acm->line, &newline, sizeof newline);
900 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
902 le32_to_cpu(newline.dwDTERate),
903 newline.bCharFormat, newline.bParityType,
905 acm_set_line(acm, &acm->line);
909 static const struct tty_port_operations acm_port_ops = {
910 .shutdown = acm_port_shutdown,
911 .activate = acm_port_activate,
912 .destruct = acm_port_destruct,
916 * USB probe and disconnect routines.
919 /* Little helpers: write/read buffers free */
920 static void acm_write_buffers_free(struct acm *acm)
924 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
926 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
927 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
930 static void acm_read_buffers_free(struct acm *acm)
932 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
935 for (i = 0; i < acm->rx_buflimit; i++)
936 usb_free_coherent(usb_dev, acm->readsize,
937 acm->read_buffers[i].base, acm->read_buffers[i].dma);
940 /* Little helper: write buffers allocate */
941 static int acm_write_buffers_alloc(struct acm *acm)
946 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
947 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
953 usb_free_coherent(acm->dev, acm->writesize,
962 static int acm_probe(struct usb_interface *intf,
963 const struct usb_device_id *id)
965 struct usb_cdc_union_desc *union_header = NULL;
966 struct usb_cdc_country_functional_desc *cfd = NULL;
967 unsigned char *buffer = intf->altsetting->extra;
968 int buflen = intf->altsetting->extralen;
969 struct usb_interface *control_interface;
970 struct usb_interface *data_interface;
971 struct usb_endpoint_descriptor *epctrl = NULL;
972 struct usb_endpoint_descriptor *epread = NULL;
973 struct usb_endpoint_descriptor *epwrite = NULL;
974 struct usb_device *usb_dev = interface_to_usbdev(intf);
977 int ctrlsize, readsize;
979 u8 ac_management_function = 0;
980 u8 call_management_function = 0;
981 int call_interface_num = -1;
982 int data_interface_num = -1;
983 unsigned long quirks;
986 int combined_interfaces = 0;
989 quirks = (unsigned long)id->driver_info;
990 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
992 /* handle quirks deadly to normal probing*/
993 if (quirks == NO_UNION_NORMAL) {
994 data_interface = usb_ifnum_to_if(usb_dev, 1);
995 control_interface = usb_ifnum_to_if(usb_dev, 0);
996 goto skip_normal_probe;
1001 dev_err(&intf->dev, "Weird descriptor references\n");
1006 if (intf->cur_altsetting->endpoint &&
1007 intf->cur_altsetting->endpoint->extralen &&
1008 intf->cur_altsetting->endpoint->extra) {
1010 "Seeking extra descriptors on endpoint\n");
1011 buflen = intf->cur_altsetting->endpoint->extralen;
1012 buffer = intf->cur_altsetting->endpoint->extra;
1015 "Zero length descriptor references\n");
1020 while (buflen > 0) {
1021 if (buffer[1] != USB_DT_CS_INTERFACE) {
1022 dev_err(&intf->dev, "skipping garbage\n");
1026 switch (buffer[2]) {
1027 case USB_CDC_UNION_TYPE: /* we've found it */
1029 dev_err(&intf->dev, "More than one "
1030 "union descriptor, skipping ...\n");
1033 union_header = (struct usb_cdc_union_desc *)buffer;
1035 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1036 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1038 case USB_CDC_HEADER_TYPE: /* maybe check version */
1039 break; /* for now we ignore it */
1040 case USB_CDC_ACM_TYPE:
1041 ac_management_function = buffer[3];
1043 case USB_CDC_CALL_MANAGEMENT_TYPE:
1044 call_management_function = buffer[3];
1045 call_interface_num = buffer[4];
1046 if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1047 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1050 /* there are LOTS more CDC descriptors that
1051 * could legitimately be found here.
1053 dev_dbg(&intf->dev, "Ignoring descriptor: "
1054 "type %02x, length %d\n",
1055 buffer[2], buffer[0]);
1059 buflen -= buffer[0];
1060 buffer += buffer[0];
1063 if (!union_header) {
1064 if (call_interface_num > 0) {
1065 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1066 /* quirks for Droids MuIn LCD */
1067 if (quirks & NO_DATA_INTERFACE)
1068 data_interface = usb_ifnum_to_if(usb_dev, 0);
1070 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1071 control_interface = intf;
1073 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1074 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1077 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1078 combined_interfaces = 1;
1079 control_interface = data_interface = intf;
1080 goto look_for_collapsed_interface;
1084 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1085 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1086 if (!control_interface || !data_interface) {
1087 dev_dbg(&intf->dev, "no interfaces\n");
1092 if (data_interface_num != call_interface_num)
1093 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1095 if (control_interface == data_interface) {
1096 /* some broken devices designed for windows work this way */
1097 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1098 combined_interfaces = 1;
1099 /* a popular other OS doesn't use it */
1100 quirks |= NO_CAP_LINE;
1101 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1102 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1105 look_for_collapsed_interface:
1106 for (i = 0; i < 3; i++) {
1107 struct usb_endpoint_descriptor *ep;
1108 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1110 if (usb_endpoint_is_int_in(ep))
1112 else if (usb_endpoint_is_bulk_out(ep))
1114 else if (usb_endpoint_is_bulk_in(ep))
1119 if (!epctrl || !epread || !epwrite)
1122 goto made_compressed_probe;
1127 /*workaround for switched interfaces */
1128 if (data_interface->cur_altsetting->desc.bInterfaceClass
1129 != CDC_DATA_INTERFACE_TYPE) {
1130 if (control_interface->cur_altsetting->desc.bInterfaceClass
1131 == CDC_DATA_INTERFACE_TYPE) {
1132 struct usb_interface *t;
1134 "Your device has switched interfaces.\n");
1135 t = control_interface;
1136 control_interface = data_interface;
1143 /* Accept probe requests only for the control interface */
1144 if (!combined_interfaces && intf != control_interface)
1147 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1148 /* valid in this context */
1149 dev_dbg(&intf->dev, "The data interface isn't available\n");
1154 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1155 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1158 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1159 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1160 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1163 /* workaround for switched endpoints */
1164 if (!usb_endpoint_dir_in(epread)) {
1165 /* descriptors are swapped */
1166 struct usb_endpoint_descriptor *t;
1168 "The data interface has switched endpoints\n");
1173 made_compressed_probe:
1174 dev_dbg(&intf->dev, "interfaces are valid\n");
1176 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1178 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1182 minor = acm_alloc_minor(acm);
1183 if (minor == ACM_TTY_MINORS) {
1184 dev_err(&intf->dev, "no more free acm devices\n");
1189 ctrlsize = usb_endpoint_maxp(epctrl);
1190 readsize = usb_endpoint_maxp(epread) *
1191 (quirks == SINGLE_RX_URB ? 1 : 2);
1192 acm->combined_interfaces = combined_interfaces;
1193 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1194 acm->control = control_interface;
1195 acm->data = data_interface;
1198 acm->ctrl_caps = ac_management_function;
1199 if (quirks & NO_CAP_LINE)
1200 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1201 acm->ctrlsize = ctrlsize;
1202 acm->readsize = readsize;
1203 acm->rx_buflimit = num_rx_buf;
1204 INIT_WORK(&acm->work, acm_softint);
1205 spin_lock_init(&acm->write_lock);
1206 spin_lock_init(&acm->read_lock);
1207 mutex_init(&acm->mutex);
1208 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1209 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1211 acm->bInterval = epread->bInterval;
1212 tty_port_init(&acm->port);
1213 acm->port.ops = &acm_port_ops;
1215 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1217 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1220 acm->ctrl_buffer = buf;
1222 if (acm_write_buffers_alloc(acm) < 0) {
1223 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1227 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1228 if (!acm->ctrlurb) {
1229 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1232 for (i = 0; i < num_rx_buf; i++) {
1233 struct acm_rb *rb = &(acm->read_buffers[i]);
1236 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1239 dev_err(&intf->dev, "out of memory "
1240 "(read bufs usb_alloc_coherent)\n");
1246 urb = usb_alloc_urb(0, GFP_KERNEL);
1249 "out of memory (read urbs usb_alloc_urb)\n");
1252 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1253 urb->transfer_dma = rb->dma;
1254 if (acm->is_int_ep) {
1255 usb_fill_int_urb(urb, acm->dev,
1259 acm_read_bulk_callback, rb,
1262 usb_fill_bulk_urb(urb, acm->dev,
1266 acm_read_bulk_callback, rb);
1269 acm->read_urbs[i] = urb;
1270 __set_bit(i, &acm->read_urbs_free);
1272 for (i = 0; i < ACM_NW; i++) {
1273 struct acm_wb *snd = &(acm->wb[i]);
1275 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1276 if (snd->urb == NULL) {
1278 "out of memory (write urbs usb_alloc_urb)\n");
1282 if (usb_endpoint_xfer_int(epwrite))
1283 usb_fill_int_urb(snd->urb, usb_dev,
1284 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1285 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1287 usb_fill_bulk_urb(snd->urb, usb_dev,
1288 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1289 NULL, acm->writesize, acm_write_bulk, snd);
1290 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1291 snd->instance = acm;
1294 usb_set_intfdata(intf, acm);
1296 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1300 if (cfd) { /* export the country data */
1301 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1302 if (!acm->country_codes)
1303 goto skip_countries;
1304 acm->country_code_size = cfd->bLength - 4;
1305 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1307 acm->country_rel_date = cfd->iCountryCodeRelDate;
1309 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1311 kfree(acm->country_codes);
1312 acm->country_codes = NULL;
1313 acm->country_code_size = 0;
1314 goto skip_countries;
1317 i = device_create_file(&intf->dev,
1318 &dev_attr_iCountryCodeRelDate);
1320 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1321 kfree(acm->country_codes);
1322 acm->country_codes = NULL;
1323 acm->country_code_size = 0;
1324 goto skip_countries;
1329 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1330 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1331 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1332 /* works around buggy devices */
1333 epctrl->bInterval ? epctrl->bInterval : 0xff);
1334 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1335 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1337 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1339 acm_set_control(acm, acm->ctrlout);
1341 acm->line.dwDTERate = cpu_to_le32(9600);
1342 acm->line.bDataBits = 8;
1343 acm_set_line(acm, &acm->line);
1345 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1346 usb_set_intfdata(data_interface, acm);
1348 usb_get_intf(control_interface);
1349 tty_port_register_device(&acm->port, acm_tty_driver, minor,
1350 &control_interface->dev);
1354 for (i = 0; i < ACM_NW; i++)
1355 usb_free_urb(acm->wb[i].urb);
1357 for (i = 0; i < num_rx_buf; i++)
1358 usb_free_urb(acm->read_urbs[i]);
1359 acm_read_buffers_free(acm);
1360 usb_free_urb(acm->ctrlurb);
1362 acm_write_buffers_free(acm);
1364 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1366 acm_release_minor(acm);
1372 static void stop_data_traffic(struct acm *acm)
1376 dev_dbg(&acm->control->dev, "%s\n", __func__);
1378 usb_kill_urb(acm->ctrlurb);
1379 for (i = 0; i < ACM_NW; i++)
1380 usb_kill_urb(acm->wb[i].urb);
1381 for (i = 0; i < acm->rx_buflimit; i++)
1382 usb_kill_urb(acm->read_urbs[i]);
1384 cancel_work_sync(&acm->work);
1387 static void acm_disconnect(struct usb_interface *intf)
1389 struct acm *acm = usb_get_intfdata(intf);
1390 struct usb_device *usb_dev = interface_to_usbdev(intf);
1391 struct tty_struct *tty;
1394 dev_dbg(&intf->dev, "%s\n", __func__);
1396 /* sibling interface is already cleaning up */
1400 mutex_lock(&acm->mutex);
1401 acm->disconnected = true;
1402 if (acm->country_codes) {
1403 device_remove_file(&acm->control->dev,
1404 &dev_attr_wCountryCodes);
1405 device_remove_file(&acm->control->dev,
1406 &dev_attr_iCountryCodeRelDate);
1408 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1409 usb_set_intfdata(acm->control, NULL);
1410 usb_set_intfdata(acm->data, NULL);
1411 mutex_unlock(&acm->mutex);
1413 tty = tty_port_tty_get(&acm->port);
1419 stop_data_traffic(acm);
1421 usb_free_urb(acm->ctrlurb);
1422 for (i = 0; i < ACM_NW; i++)
1423 usb_free_urb(acm->wb[i].urb);
1424 for (i = 0; i < acm->rx_buflimit; i++)
1425 usb_free_urb(acm->read_urbs[i]);
1426 acm_write_buffers_free(acm);
1427 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1428 acm_read_buffers_free(acm);
1430 if (!acm->combined_interfaces)
1431 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1432 acm->data : acm->control);
1434 tty_port_put(&acm->port);
1438 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1440 struct acm *acm = usb_get_intfdata(intf);
1443 if (PMSG_IS_AUTO(message)) {
1446 spin_lock_irq(&acm->write_lock);
1447 b = acm->transmitting;
1448 spin_unlock_irq(&acm->write_lock);
1453 spin_lock_irq(&acm->read_lock);
1454 spin_lock(&acm->write_lock);
1455 cnt = acm->susp_count++;
1456 spin_unlock(&acm->write_lock);
1457 spin_unlock_irq(&acm->read_lock);
1462 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1463 stop_data_traffic(acm);
1468 static int acm_resume(struct usb_interface *intf)
1470 struct acm *acm = usb_get_intfdata(intf);
1475 spin_lock_irq(&acm->read_lock);
1476 acm->susp_count -= 1;
1477 cnt = acm->susp_count;
1478 spin_unlock_irq(&acm->read_lock);
1483 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1484 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1486 spin_lock_irq(&acm->write_lock);
1487 if (acm->delayed_wb) {
1488 wb = acm->delayed_wb;
1489 acm->delayed_wb = NULL;
1490 spin_unlock_irq(&acm->write_lock);
1491 acm_start_wb(acm, wb);
1493 spin_unlock_irq(&acm->write_lock);
1497 * delayed error checking because we must
1498 * do the write path at all cost
1503 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1510 static int acm_reset_resume(struct usb_interface *intf)
1512 struct acm *acm = usb_get_intfdata(intf);
1513 struct tty_struct *tty;
1515 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1516 tty = tty_port_tty_get(&acm->port);
1523 return acm_resume(intf);
1526 #endif /* CONFIG_PM */
1528 #define NOKIA_PCSUITE_ACM_INFO(x) \
1529 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1530 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1531 USB_CDC_ACM_PROTO_VENDOR)
1533 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1534 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1535 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1536 USB_CDC_ACM_PROTO_VENDOR)
1539 * USB driver structure.
1542 static const struct usb_device_id acm_ids[] = {
1543 /* quirky and broken devices */
1544 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1545 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1547 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1548 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1550 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1551 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1553 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1554 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1556 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1557 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1559 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1560 .driver_info = SINGLE_RX_URB,
1562 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1563 .driver_info = SINGLE_RX_URB, /* firmware bug */
1565 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1566 .driver_info = SINGLE_RX_URB, /* firmware bug */
1568 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1569 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1571 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1572 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1574 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1575 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1577 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1578 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1580 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1581 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1583 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1585 /* Motorola H24 HSPA module: */
1586 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1587 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1588 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1589 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1590 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1591 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1592 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1593 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1595 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1596 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1597 data interface instead of
1598 communications interface.
1599 Maybe we should define a new
1602 { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1603 .driver_info = NO_UNION_NORMAL,
1605 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1606 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1608 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1609 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1612 /* Nokia S60 phones expose two ACM channels. The first is
1613 * a modem and is picked up by the standard AT-command
1614 * information below. The second is 'vendor-specific' but
1615 * is treated as a serial device at the S60 end, so we want
1616 * to expose it on Linux too. */
1617 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1619 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1620 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1621 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1622 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1623 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1624 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1625 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1626 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1627 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1628 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1629 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1630 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1631 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1632 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1633 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1634 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1635 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1636 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1637 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1638 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1639 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1640 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1641 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1642 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1643 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1644 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1645 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1646 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1647 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1648 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1649 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1650 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1651 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1652 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1653 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1654 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1655 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1656 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1657 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1658 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1659 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1660 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1661 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1662 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1663 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1664 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1665 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1666 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1667 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1668 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1669 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1670 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1671 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1672 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1673 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1674 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1676 /* Support for Owen devices */
1677 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1679 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1681 /* Support Lego NXT using pbLua firmware */
1682 { USB_DEVICE(0x0694, 0xff00),
1683 .driver_info = NOT_A_MODEM,
1686 /* Support for Droids MuIn LCD */
1687 { USB_DEVICE(0x04d8, 0x000b),
1688 .driver_info = NO_DATA_INTERFACE,
1691 /* control interfaces without any protocol set */
1692 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1693 USB_CDC_PROTO_NONE) },
1695 /* control interfaces with various AT-command sets */
1696 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1697 USB_CDC_ACM_PROTO_AT_V25TER) },
1698 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1699 USB_CDC_ACM_PROTO_AT_PCCA101) },
1700 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1701 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1702 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1703 USB_CDC_ACM_PROTO_AT_GSM) },
1704 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1705 USB_CDC_ACM_PROTO_AT_3G) },
1706 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1707 USB_CDC_ACM_PROTO_AT_CDMA) },
1712 MODULE_DEVICE_TABLE(usb, acm_ids);
1714 static struct usb_driver acm_driver = {
1717 .disconnect = acm_disconnect,
1719 .suspend = acm_suspend,
1720 .resume = acm_resume,
1721 .reset_resume = acm_reset_resume,
1723 .id_table = acm_ids,
1725 .supports_autosuspend = 1,
1727 .disable_hub_initiated_lpm = 1,
1731 * TTY driver structures.
1734 static const struct tty_operations acm_ops = {
1735 .install = acm_tty_install,
1736 .open = acm_tty_open,
1737 .close = acm_tty_close,
1738 .cleanup = acm_tty_cleanup,
1739 .hangup = acm_tty_hangup,
1740 .write = acm_tty_write,
1741 .write_room = acm_tty_write_room,
1742 .ioctl = acm_tty_ioctl,
1743 .throttle = acm_tty_throttle,
1744 .unthrottle = acm_tty_unthrottle,
1745 .chars_in_buffer = acm_tty_chars_in_buffer,
1746 .break_ctl = acm_tty_break_ctl,
1747 .set_termios = acm_tty_set_termios,
1748 .tiocmget = acm_tty_tiocmget,
1749 .tiocmset = acm_tty_tiocmset,
1756 static int __init acm_init(void)
1759 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1760 if (!acm_tty_driver)
1762 acm_tty_driver->driver_name = "acm",
1763 acm_tty_driver->name = "ttyACM",
1764 acm_tty_driver->major = ACM_TTY_MAJOR,
1765 acm_tty_driver->minor_start = 0,
1766 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1767 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1768 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1769 acm_tty_driver->init_termios = tty_std_termios;
1770 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1772 tty_set_operations(acm_tty_driver, &acm_ops);
1774 retval = tty_register_driver(acm_tty_driver);
1776 put_tty_driver(acm_tty_driver);
1780 retval = usb_register(&acm_driver);
1782 tty_unregister_driver(acm_tty_driver);
1783 put_tty_driver(acm_tty_driver);
1787 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1792 static void __exit acm_exit(void)
1794 usb_deregister(&acm_driver);
1795 tty_unregister_driver(acm_tty_driver);
1796 put_tty_driver(acm_tty_driver);
1799 module_init(acm_init);
1800 module_exit(acm_exit);
1802 MODULE_AUTHOR(DRIVER_AUTHOR);
1803 MODULE_DESCRIPTION(DRIVER_DESC);
1804 MODULE_LICENSE("GPL");
1805 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);