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_init_termios(tty);
513 goto error_init_termios;
515 tty->driver_data = acm;
517 /* Final install (we use the default method) */
518 tty_driver_kref_get(driver);
520 driver->ttys[tty->index] = tty;
525 tty_port_put(&acm->port);
529 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
531 struct acm *acm = tty->driver_data;
533 dev_dbg(tty->dev, "%s\n", __func__);
535 return tty_port_open(&acm->port, tty, filp);
538 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
540 struct acm *acm = container_of(port, struct acm, port);
541 int retval = -ENODEV;
543 dev_dbg(&acm->control->dev, "%s\n", __func__);
545 mutex_lock(&acm->mutex);
546 if (acm->disconnected)
549 retval = usb_autopm_get_interface(acm->control);
551 goto error_get_interface;
554 * FIXME: Why do we need this? Allocating 64K of physically contiguous
555 * memory is really nasty...
557 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
558 acm->control->needs_remote_wakeup = 1;
560 acm->ctrlurb->dev = acm->dev;
561 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
562 dev_err(&acm->control->dev,
563 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
564 goto error_submit_urb;
567 acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
568 if (acm_set_control(acm, acm->ctrlout) < 0 &&
569 (acm->ctrl_caps & USB_CDC_CAP_LINE))
570 goto error_set_control;
572 usb_autopm_put_interface(acm->control);
574 if (acm_submit_read_urbs(acm, GFP_KERNEL))
575 goto error_submit_read_urbs;
577 mutex_unlock(&acm->mutex);
581 error_submit_read_urbs:
583 acm_set_control(acm, acm->ctrlout);
585 usb_kill_urb(acm->ctrlurb);
587 usb_autopm_put_interface(acm->control);
590 mutex_unlock(&acm->mutex);
594 static void acm_port_destruct(struct tty_port *port)
596 struct acm *acm = container_of(port, struct acm, port);
598 dev_dbg(&acm->control->dev, "%s\n", __func__);
600 tty_unregister_device(acm_tty_driver, acm->minor);
601 acm_release_minor(acm);
602 usb_put_intf(acm->control);
603 kfree(acm->country_codes);
607 static void acm_port_shutdown(struct tty_port *port)
609 struct acm *acm = container_of(port, struct acm, port);
612 dev_dbg(&acm->control->dev, "%s\n", __func__);
614 mutex_lock(&acm->mutex);
615 if (!acm->disconnected) {
616 usb_autopm_get_interface(acm->control);
617 acm_set_control(acm, acm->ctrlout = 0);
618 usb_kill_urb(acm->ctrlurb);
619 for (i = 0; i < ACM_NW; i++)
620 usb_kill_urb(acm->wb[i].urb);
621 for (i = 0; i < acm->rx_buflimit; i++)
622 usb_kill_urb(acm->read_urbs[i]);
623 acm->control->needs_remote_wakeup = 0;
624 usb_autopm_put_interface(acm->control);
626 mutex_unlock(&acm->mutex);
629 static void acm_tty_cleanup(struct tty_struct *tty)
631 struct acm *acm = tty->driver_data;
632 dev_dbg(&acm->control->dev, "%s\n", __func__);
633 tty_port_put(&acm->port);
636 static void acm_tty_hangup(struct tty_struct *tty)
638 struct acm *acm = tty->driver_data;
639 dev_dbg(&acm->control->dev, "%s\n", __func__);
640 tty_port_hangup(&acm->port);
643 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
645 struct acm *acm = tty->driver_data;
646 dev_dbg(&acm->control->dev, "%s\n", __func__);
647 tty_port_close(&acm->port, tty, filp);
650 static int acm_tty_write(struct tty_struct *tty,
651 const unsigned char *buf, int count)
653 struct acm *acm = tty->driver_data;
662 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
664 spin_lock_irqsave(&acm->write_lock, flags);
665 wbn = acm_wb_alloc(acm);
667 spin_unlock_irqrestore(&acm->write_lock, flags);
672 count = (count > acm->writesize) ? acm->writesize : count;
673 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
674 memcpy(wb->buf, buf, count);
676 spin_unlock_irqrestore(&acm->write_lock, flags);
678 stat = acm_write_start(acm, wbn);
684 static int acm_tty_write_room(struct tty_struct *tty)
686 struct acm *acm = tty->driver_data;
688 * Do not let the line discipline to know that we have a reserve,
689 * or it might get too enthusiastic.
691 return acm_wb_is_avail(acm) ? acm->writesize : 0;
694 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
696 struct acm *acm = tty->driver_data;
698 * if the device was unplugged then any remaining characters fell out
699 * of the connector ;)
701 if (acm->disconnected)
704 * This is inaccurate (overcounts), but it works.
706 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
709 static void acm_tty_throttle(struct tty_struct *tty)
711 struct acm *acm = tty->driver_data;
713 spin_lock_irq(&acm->read_lock);
714 acm->throttle_req = 1;
715 spin_unlock_irq(&acm->read_lock);
718 static void acm_tty_unthrottle(struct tty_struct *tty)
720 struct acm *acm = tty->driver_data;
721 unsigned int was_throttled;
723 spin_lock_irq(&acm->read_lock);
724 was_throttled = acm->throttled;
726 acm->throttle_req = 0;
727 spin_unlock_irq(&acm->read_lock);
730 acm_submit_read_urbs(acm, GFP_KERNEL);
733 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
735 struct acm *acm = tty->driver_data;
738 retval = acm_send_break(acm, state ? 0xffff : 0);
740 dev_dbg(&acm->control->dev, "%s - send break failed\n",
745 static int acm_tty_tiocmget(struct tty_struct *tty)
747 struct acm *acm = tty->driver_data;
749 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
750 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
751 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
752 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
753 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
757 static int acm_tty_tiocmset(struct tty_struct *tty,
758 unsigned int set, unsigned int clear)
760 struct acm *acm = tty->driver_data;
761 unsigned int newctrl;
763 newctrl = acm->ctrlout;
764 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
765 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
766 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
767 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
769 newctrl = (newctrl & ~clear) | set;
771 if (acm->ctrlout == newctrl)
773 return acm_set_control(acm, acm->ctrlout = newctrl);
776 static int acm_tty_ioctl(struct tty_struct *tty,
777 unsigned int cmd, unsigned long arg)
782 static const __u32 acm_tty_speed[] = {
783 0, 50, 75, 110, 134, 150, 200, 300, 600,
784 1200, 1800, 2400, 4800, 9600, 19200, 38400,
785 57600, 115200, 230400, 460800, 500000, 576000,
786 921600, 1000000, 1152000, 1500000, 2000000,
787 2500000, 3000000, 3500000, 4000000
790 static const __u8 acm_tty_size[] = {
794 static void acm_tty_set_termios(struct tty_struct *tty,
795 struct ktermios *termios_old)
797 struct acm *acm = tty->driver_data;
798 struct ktermios *termios = tty->termios;
799 struct usb_cdc_line_coding newline;
800 int newctrl = acm->ctrlout;
802 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
803 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
804 newline.bParityType = termios->c_cflag & PARENB ?
805 (termios->c_cflag & PARODD ? 1 : 2) +
806 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
807 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
808 /* FIXME: Needs to clear unsupported bits in the termios */
809 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
811 if (!newline.dwDTERate) {
812 newline.dwDTERate = acm->line.dwDTERate;
813 newctrl &= ~ACM_CTRL_DTR;
815 newctrl |= ACM_CTRL_DTR;
817 if (newctrl != acm->ctrlout)
818 acm_set_control(acm, acm->ctrlout = newctrl);
820 if (memcmp(&acm->line, &newline, sizeof newline)) {
821 memcpy(&acm->line, &newline, sizeof newline);
822 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
824 le32_to_cpu(newline.dwDTERate),
825 newline.bCharFormat, newline.bParityType,
827 acm_set_line(acm, &acm->line);
831 static const struct tty_port_operations acm_port_ops = {
832 .shutdown = acm_port_shutdown,
833 .activate = acm_port_activate,
834 .destruct = acm_port_destruct,
838 * USB probe and disconnect routines.
841 /* Little helpers: write/read buffers free */
842 static void acm_write_buffers_free(struct acm *acm)
846 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
848 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
849 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
852 static void acm_read_buffers_free(struct acm *acm)
854 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
857 for (i = 0; i < acm->rx_buflimit; i++)
858 usb_free_coherent(usb_dev, acm->readsize,
859 acm->read_buffers[i].base, acm->read_buffers[i].dma);
862 /* Little helper: write buffers allocate */
863 static int acm_write_buffers_alloc(struct acm *acm)
868 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
869 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
875 usb_free_coherent(acm->dev, acm->writesize,
884 static int acm_probe(struct usb_interface *intf,
885 const struct usb_device_id *id)
887 struct usb_cdc_union_desc *union_header = NULL;
888 struct usb_cdc_country_functional_desc *cfd = NULL;
889 unsigned char *buffer = intf->altsetting->extra;
890 int buflen = intf->altsetting->extralen;
891 struct usb_interface *control_interface;
892 struct usb_interface *data_interface;
893 struct usb_endpoint_descriptor *epctrl = NULL;
894 struct usb_endpoint_descriptor *epread = NULL;
895 struct usb_endpoint_descriptor *epwrite = NULL;
896 struct usb_device *usb_dev = interface_to_usbdev(intf);
899 int ctrlsize, readsize;
901 u8 ac_management_function = 0;
902 u8 call_management_function = 0;
903 int call_interface_num = -1;
904 int data_interface_num = -1;
905 unsigned long quirks;
908 int combined_interfaces = 0;
911 quirks = (unsigned long)id->driver_info;
912 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
914 /* handle quirks deadly to normal probing*/
915 if (quirks == NO_UNION_NORMAL) {
916 data_interface = usb_ifnum_to_if(usb_dev, 1);
917 control_interface = usb_ifnum_to_if(usb_dev, 0);
918 goto skip_normal_probe;
923 dev_err(&intf->dev, "Weird descriptor references\n");
928 if (intf->cur_altsetting->endpoint &&
929 intf->cur_altsetting->endpoint->extralen &&
930 intf->cur_altsetting->endpoint->extra) {
932 "Seeking extra descriptors on endpoint\n");
933 buflen = intf->cur_altsetting->endpoint->extralen;
934 buffer = intf->cur_altsetting->endpoint->extra;
937 "Zero length descriptor references\n");
943 if (buffer[1] != USB_DT_CS_INTERFACE) {
944 dev_err(&intf->dev, "skipping garbage\n");
949 case USB_CDC_UNION_TYPE: /* we've found it */
951 dev_err(&intf->dev, "More than one "
952 "union descriptor, skipping ...\n");
955 union_header = (struct usb_cdc_union_desc *)buffer;
957 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
958 cfd = (struct usb_cdc_country_functional_desc *)buffer;
960 case USB_CDC_HEADER_TYPE: /* maybe check version */
961 break; /* for now we ignore it */
962 case USB_CDC_ACM_TYPE:
963 ac_management_function = buffer[3];
965 case USB_CDC_CALL_MANAGEMENT_TYPE:
966 call_management_function = buffer[3];
967 call_interface_num = buffer[4];
968 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
969 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
972 /* there are LOTS more CDC descriptors that
973 * could legitimately be found here.
975 dev_dbg(&intf->dev, "Ignoring descriptor: "
976 "type %02x, length %d\n",
977 buffer[2], buffer[0]);
986 if (call_interface_num > 0) {
987 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
988 /* quirks for Droids MuIn LCD */
989 if (quirks & NO_DATA_INTERFACE)
990 data_interface = usb_ifnum_to_if(usb_dev, 0);
992 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
993 control_interface = intf;
995 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
996 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
999 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1000 combined_interfaces = 1;
1001 control_interface = data_interface = intf;
1002 goto look_for_collapsed_interface;
1006 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1007 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1008 if (!control_interface || !data_interface) {
1009 dev_dbg(&intf->dev, "no interfaces\n");
1014 if (data_interface_num != call_interface_num)
1015 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1017 if (control_interface == data_interface) {
1018 /* some broken devices designed for windows work this way */
1019 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1020 combined_interfaces = 1;
1021 /* a popular other OS doesn't use it */
1022 quirks |= NO_CAP_LINE;
1023 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1024 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1027 look_for_collapsed_interface:
1028 for (i = 0; i < 3; i++) {
1029 struct usb_endpoint_descriptor *ep;
1030 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1032 if (usb_endpoint_is_int_in(ep))
1034 else if (usb_endpoint_is_bulk_out(ep))
1036 else if (usb_endpoint_is_bulk_in(ep))
1041 if (!epctrl || !epread || !epwrite)
1044 goto made_compressed_probe;
1049 /*workaround for switched interfaces */
1050 if (data_interface->cur_altsetting->desc.bInterfaceClass
1051 != CDC_DATA_INTERFACE_TYPE) {
1052 if (control_interface->cur_altsetting->desc.bInterfaceClass
1053 == CDC_DATA_INTERFACE_TYPE) {
1054 struct usb_interface *t;
1056 "Your device has switched interfaces.\n");
1057 t = control_interface;
1058 control_interface = data_interface;
1065 /* Accept probe requests only for the control interface */
1066 if (!combined_interfaces && intf != control_interface)
1069 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1070 /* valid in this context */
1071 dev_dbg(&intf->dev, "The data interface isn't available\n");
1076 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1079 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1080 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1081 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1084 /* workaround for switched endpoints */
1085 if (!usb_endpoint_dir_in(epread)) {
1086 /* descriptors are swapped */
1087 struct usb_endpoint_descriptor *t;
1089 "The data interface has switched endpoints\n");
1094 made_compressed_probe:
1095 dev_dbg(&intf->dev, "interfaces are valid\n");
1097 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1099 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1103 minor = acm_alloc_minor(acm);
1104 if (minor == ACM_TTY_MINORS) {
1105 dev_err(&intf->dev, "no more free acm devices\n");
1110 ctrlsize = usb_endpoint_maxp(epctrl);
1111 readsize = usb_endpoint_maxp(epread) *
1112 (quirks == SINGLE_RX_URB ? 1 : 2);
1113 acm->combined_interfaces = combined_interfaces;
1114 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1115 acm->control = control_interface;
1116 acm->data = data_interface;
1119 acm->ctrl_caps = ac_management_function;
1120 if (quirks & NO_CAP_LINE)
1121 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1122 acm->ctrlsize = ctrlsize;
1123 acm->readsize = readsize;
1124 acm->rx_buflimit = num_rx_buf;
1125 INIT_WORK(&acm->work, acm_softint);
1126 spin_lock_init(&acm->write_lock);
1127 spin_lock_init(&acm->read_lock);
1128 mutex_init(&acm->mutex);
1129 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1130 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1132 acm->bInterval = epread->bInterval;
1133 tty_port_init(&acm->port);
1134 acm->port.ops = &acm_port_ops;
1136 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1138 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1141 acm->ctrl_buffer = buf;
1143 if (acm_write_buffers_alloc(acm) < 0) {
1144 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1148 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1149 if (!acm->ctrlurb) {
1150 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1153 for (i = 0; i < num_rx_buf; i++) {
1154 struct acm_rb *rb = &(acm->read_buffers[i]);
1157 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1160 dev_err(&intf->dev, "out of memory "
1161 "(read bufs usb_alloc_coherent)\n");
1167 urb = usb_alloc_urb(0, GFP_KERNEL);
1170 "out of memory (read urbs usb_alloc_urb)\n");
1173 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1174 urb->transfer_dma = rb->dma;
1175 if (acm->is_int_ep) {
1176 usb_fill_int_urb(urb, acm->dev,
1180 acm_read_bulk_callback, rb,
1183 usb_fill_bulk_urb(urb, acm->dev,
1187 acm_read_bulk_callback, rb);
1190 acm->read_urbs[i] = urb;
1191 __set_bit(i, &acm->read_urbs_free);
1193 for (i = 0; i < ACM_NW; i++) {
1194 struct acm_wb *snd = &(acm->wb[i]);
1196 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1197 if (snd->urb == NULL) {
1199 "out of memory (write urbs usb_alloc_urb)\n");
1203 if (usb_endpoint_xfer_int(epwrite))
1204 usb_fill_int_urb(snd->urb, usb_dev,
1205 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1206 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1208 usb_fill_bulk_urb(snd->urb, usb_dev,
1209 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1210 NULL, acm->writesize, acm_write_bulk, snd);
1211 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1212 snd->instance = acm;
1215 usb_set_intfdata(intf, acm);
1217 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1221 if (cfd) { /* export the country data */
1222 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1223 if (!acm->country_codes)
1224 goto skip_countries;
1225 acm->country_code_size = cfd->bLength - 4;
1226 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1228 acm->country_rel_date = cfd->iCountryCodeRelDate;
1230 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1232 kfree(acm->country_codes);
1233 goto skip_countries;
1236 i = device_create_file(&intf->dev,
1237 &dev_attr_iCountryCodeRelDate);
1239 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1240 kfree(acm->country_codes);
1241 goto skip_countries;
1246 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1247 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1248 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1249 /* works around buggy devices */
1250 epctrl->bInterval ? epctrl->bInterval : 0xff);
1251 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1252 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1254 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1256 acm_set_control(acm, acm->ctrlout);
1258 acm->line.dwDTERate = cpu_to_le32(9600);
1259 acm->line.bDataBits = 8;
1260 acm_set_line(acm, &acm->line);
1262 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1263 usb_set_intfdata(data_interface, acm);
1265 usb_get_intf(control_interface);
1266 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1270 for (i = 0; i < ACM_NW; i++)
1271 usb_free_urb(acm->wb[i].urb);
1273 for (i = 0; i < num_rx_buf; i++)
1274 usb_free_urb(acm->read_urbs[i]);
1275 acm_read_buffers_free(acm);
1276 usb_free_urb(acm->ctrlurb);
1278 acm_write_buffers_free(acm);
1280 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1282 acm_release_minor(acm);
1288 static void stop_data_traffic(struct acm *acm)
1292 dev_dbg(&acm->control->dev, "%s\n", __func__);
1294 usb_kill_urb(acm->ctrlurb);
1295 for (i = 0; i < ACM_NW; i++)
1296 usb_kill_urb(acm->wb[i].urb);
1297 for (i = 0; i < acm->rx_buflimit; i++)
1298 usb_kill_urb(acm->read_urbs[i]);
1300 cancel_work_sync(&acm->work);
1303 static void acm_disconnect(struct usb_interface *intf)
1305 struct acm *acm = usb_get_intfdata(intf);
1306 struct usb_device *usb_dev = interface_to_usbdev(intf);
1307 struct tty_struct *tty;
1310 dev_dbg(&intf->dev, "%s\n", __func__);
1312 /* sibling interface is already cleaning up */
1316 mutex_lock(&acm->mutex);
1317 acm->disconnected = true;
1318 if (acm->country_codes) {
1319 device_remove_file(&acm->control->dev,
1320 &dev_attr_wCountryCodes);
1321 device_remove_file(&acm->control->dev,
1322 &dev_attr_iCountryCodeRelDate);
1324 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1325 usb_set_intfdata(acm->control, NULL);
1326 usb_set_intfdata(acm->data, NULL);
1327 mutex_unlock(&acm->mutex);
1329 tty = tty_port_tty_get(&acm->port);
1335 stop_data_traffic(acm);
1337 usb_free_urb(acm->ctrlurb);
1338 for (i = 0; i < ACM_NW; i++)
1339 usb_free_urb(acm->wb[i].urb);
1340 for (i = 0; i < acm->rx_buflimit; i++)
1341 usb_free_urb(acm->read_urbs[i]);
1342 acm_write_buffers_free(acm);
1343 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1344 acm_read_buffers_free(acm);
1346 if (!acm->combined_interfaces)
1347 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1348 acm->data : acm->control);
1350 tty_port_put(&acm->port);
1354 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1356 struct acm *acm = usb_get_intfdata(intf);
1359 if (PMSG_IS_AUTO(message)) {
1362 spin_lock_irq(&acm->write_lock);
1363 b = acm->transmitting;
1364 spin_unlock_irq(&acm->write_lock);
1369 spin_lock_irq(&acm->read_lock);
1370 spin_lock(&acm->write_lock);
1371 cnt = acm->susp_count++;
1372 spin_unlock(&acm->write_lock);
1373 spin_unlock_irq(&acm->read_lock);
1378 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1379 stop_data_traffic(acm);
1384 static int acm_resume(struct usb_interface *intf)
1386 struct acm *acm = usb_get_intfdata(intf);
1391 spin_lock_irq(&acm->read_lock);
1392 acm->susp_count -= 1;
1393 cnt = acm->susp_count;
1394 spin_unlock_irq(&acm->read_lock);
1399 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1400 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1402 spin_lock_irq(&acm->write_lock);
1403 if (acm->delayed_wb) {
1404 wb = acm->delayed_wb;
1405 acm->delayed_wb = NULL;
1406 spin_unlock_irq(&acm->write_lock);
1407 acm_start_wb(acm, wb);
1409 spin_unlock_irq(&acm->write_lock);
1413 * delayed error checking because we must
1414 * do the write path at all cost
1419 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1426 static int acm_reset_resume(struct usb_interface *intf)
1428 struct acm *acm = usb_get_intfdata(intf);
1429 struct tty_struct *tty;
1431 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1432 tty = tty_port_tty_get(&acm->port);
1439 return acm_resume(intf);
1442 #endif /* CONFIG_PM */
1444 #define NOKIA_PCSUITE_ACM_INFO(x) \
1445 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1446 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1447 USB_CDC_ACM_PROTO_VENDOR)
1449 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1450 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1451 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1452 USB_CDC_ACM_PROTO_VENDOR)
1455 * USB driver structure.
1458 static const struct usb_device_id acm_ids[] = {
1459 /* quirky and broken devices */
1460 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1461 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1463 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1464 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1466 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1467 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1469 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1470 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1472 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1473 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1475 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1476 .driver_info = SINGLE_RX_URB,
1478 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1479 .driver_info = SINGLE_RX_URB, /* firmware bug */
1481 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1482 .driver_info = SINGLE_RX_URB, /* firmware bug */
1484 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1485 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1487 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1488 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1490 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1491 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1493 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1494 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1496 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1497 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1499 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1501 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1502 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1503 data interface instead of
1504 communications interface.
1505 Maybe we should define a new
1508 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1509 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1511 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1512 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1515 /* Nokia S60 phones expose two ACM channels. The first is
1516 * a modem and is picked up by the standard AT-command
1517 * information below. The second is 'vendor-specific' but
1518 * is treated as a serial device at the S60 end, so we want
1519 * to expose it on Linux too. */
1520 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1521 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1522 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1523 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1524 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1525 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1526 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1527 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1528 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1529 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1530 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1531 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1532 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1533 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1534 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1535 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1536 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1537 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1538 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1539 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1540 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1541 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1542 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1543 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1544 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1545 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1546 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1547 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1548 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1549 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1550 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1551 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1552 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1553 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1556 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1561 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1562 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1567 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1572 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1577 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1579 /* Support for Owen devices */
1580 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1582 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1584 /* Support Lego NXT using pbLua firmware */
1585 { USB_DEVICE(0x0694, 0xff00),
1586 .driver_info = NOT_A_MODEM,
1589 /* Support for Droids MuIn LCD */
1590 { USB_DEVICE(0x04d8, 0x000b),
1591 .driver_info = NO_DATA_INTERFACE,
1594 /* control interfaces without any protocol set */
1595 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1596 USB_CDC_PROTO_NONE) },
1598 /* control interfaces with various AT-command sets */
1599 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1600 USB_CDC_ACM_PROTO_AT_V25TER) },
1601 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1602 USB_CDC_ACM_PROTO_AT_PCCA101) },
1603 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1604 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1605 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1606 USB_CDC_ACM_PROTO_AT_GSM) },
1607 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1608 USB_CDC_ACM_PROTO_AT_3G) },
1609 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1610 USB_CDC_ACM_PROTO_AT_CDMA) },
1615 MODULE_DEVICE_TABLE(usb, acm_ids);
1617 static struct usb_driver acm_driver = {
1620 .disconnect = acm_disconnect,
1622 .suspend = acm_suspend,
1623 .resume = acm_resume,
1624 .reset_resume = acm_reset_resume,
1626 .id_table = acm_ids,
1628 .supports_autosuspend = 1,
1633 * TTY driver structures.
1636 static const struct tty_operations acm_ops = {
1637 .install = acm_tty_install,
1638 .open = acm_tty_open,
1639 .close = acm_tty_close,
1640 .cleanup = acm_tty_cleanup,
1641 .hangup = acm_tty_hangup,
1642 .write = acm_tty_write,
1643 .write_room = acm_tty_write_room,
1644 .ioctl = acm_tty_ioctl,
1645 .throttle = acm_tty_throttle,
1646 .unthrottle = acm_tty_unthrottle,
1647 .chars_in_buffer = acm_tty_chars_in_buffer,
1648 .break_ctl = acm_tty_break_ctl,
1649 .set_termios = acm_tty_set_termios,
1650 .tiocmget = acm_tty_tiocmget,
1651 .tiocmset = acm_tty_tiocmset,
1658 static int __init acm_init(void)
1661 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1662 if (!acm_tty_driver)
1664 acm_tty_driver->owner = THIS_MODULE,
1665 acm_tty_driver->driver_name = "acm",
1666 acm_tty_driver->name = "ttyACM",
1667 acm_tty_driver->major = ACM_TTY_MAJOR,
1668 acm_tty_driver->minor_start = 0,
1669 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1670 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1671 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1672 acm_tty_driver->init_termios = tty_std_termios;
1673 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1675 tty_set_operations(acm_tty_driver, &acm_ops);
1677 retval = tty_register_driver(acm_tty_driver);
1679 put_tty_driver(acm_tty_driver);
1683 retval = usb_register(&acm_driver);
1685 tty_unregister_driver(acm_tty_driver);
1686 put_tty_driver(acm_tty_driver);
1690 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1695 static void __exit acm_exit(void)
1697 usb_deregister(&acm_driver);
1698 tty_unregister_driver(acm_tty_driver);
1699 put_tty_driver(acm_tty_driver);
1702 module_init(acm_init);
1703 module_exit(acm_exit);
1705 MODULE_AUTHOR(DRIVER_AUTHOR);
1706 MODULE_DESCRIPTION(DRIVER_DESC);
1707 MODULE_LICENSE("GPL");
1708 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);