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(open_mutex);
63 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
65 static const struct tty_port_operations acm_port_ops = {
69 * Functions for ACM control messages.
72 static int acm_ctrl_msg(struct acm *acm, int request, int value,
77 retval = usb_autopm_get_interface(acm->control);
81 retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
82 request, USB_RT_ACM, value,
83 acm->control->altsetting[0].desc.bInterfaceNumber,
86 dev_dbg(&acm->control->dev,
87 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
88 __func__, request, value, len, retval);
90 usb_autopm_put_interface(acm->control);
92 return retval < 0 ? retval : 0;
95 /* devices aren't required to support these requests.
96 * the cdc acm descriptor tells whether they do...
98 #define acm_set_control(acm, control) \
99 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
100 #define acm_set_line(acm, line) \
101 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
102 #define acm_send_break(acm, ms) \
103 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
106 * Write buffer management.
107 * All of these assume proper locks taken by the caller.
110 static int acm_wb_alloc(struct acm *acm)
123 wbn = (wbn + 1) % ACM_NW;
129 static int acm_wb_is_avail(struct acm *acm)
135 spin_lock_irqsave(&acm->write_lock, flags);
136 for (i = 0; i < ACM_NW; i++)
138 spin_unlock_irqrestore(&acm->write_lock, flags);
143 * Finish write. Caller must hold acm->write_lock
145 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
149 usb_autopm_put_interface_async(acm->control);
155 * the caller is responsible for locking
158 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
164 wb->urb->transfer_buffer = wb->buf;
165 wb->urb->transfer_dma = wb->dmah;
166 wb->urb->transfer_buffer_length = wb->len;
167 wb->urb->dev = acm->dev;
169 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
171 dev_err(&acm->data->dev,
172 "%s - usb_submit_urb(write bulk) failed: %d\n",
174 acm_write_done(acm, wb);
179 static int acm_write_start(struct acm *acm, int wbn)
182 struct acm_wb *wb = &acm->wb[wbn];
185 spin_lock_irqsave(&acm->write_lock, flags);
188 spin_unlock_irqrestore(&acm->write_lock, flags);
192 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
194 rc = usb_autopm_get_interface_async(acm->control);
197 spin_unlock_irqrestore(&acm->write_lock, flags);
201 if (acm->susp_count) {
202 usb_anchor_urb(wb->urb, &acm->delayed);
203 spin_unlock_irqrestore(&acm->write_lock, flags);
206 usb_mark_last_busy(acm->dev);
208 rc = acm_start_wb(acm, wb);
209 spin_unlock_irqrestore(&acm->write_lock, flags);
215 * attributes exported through sysfs
217 static ssize_t show_caps
218 (struct device *dev, struct device_attribute *attr, char *buf)
220 struct usb_interface *intf = to_usb_interface(dev);
221 struct acm *acm = usb_get_intfdata(intf);
223 return sprintf(buf, "%d", acm->ctrl_caps);
225 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
227 static ssize_t show_country_codes
228 (struct device *dev, struct device_attribute *attr, char *buf)
230 struct usb_interface *intf = to_usb_interface(dev);
231 struct acm *acm = usb_get_intfdata(intf);
233 memcpy(buf, acm->country_codes, acm->country_code_size);
234 return acm->country_code_size;
237 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
239 static ssize_t show_country_rel_date
240 (struct device *dev, struct device_attribute *attr, char *buf)
242 struct usb_interface *intf = to_usb_interface(dev);
243 struct acm *acm = usb_get_intfdata(intf);
245 return sprintf(buf, "%d", acm->country_rel_date);
248 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
250 * Interrupt handlers for various ACM device responses
253 /* control interface reports status changes with "interrupt" transfers */
254 static void acm_ctrl_irq(struct urb *urb)
256 struct acm *acm = urb->context;
257 struct usb_cdc_notification *dr = urb->transfer_buffer;
258 struct tty_struct *tty;
262 int status = urb->status;
271 /* this urb is terminated, clean up */
272 dev_dbg(&acm->control->dev,
273 "%s - urb shutting down with status: %d\n",
277 dev_dbg(&acm->control->dev,
278 "%s - nonzero urb status received: %d\n",
286 usb_mark_last_busy(acm->dev);
288 data = (unsigned char *)(dr + 1);
289 switch (dr->bNotificationType) {
290 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
291 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
292 __func__, dr->wValue);
295 case USB_CDC_NOTIFY_SERIAL_STATE:
296 tty = tty_port_tty_get(&acm->port);
297 newctrl = get_unaligned_le16(data);
301 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
302 dev_dbg(&acm->control->dev,
303 "%s - calling hangup\n", __func__);
309 acm->ctrlin = newctrl;
311 dev_dbg(&acm->control->dev,
312 "%s - input control lines: dcd%c dsr%c break%c "
313 "ring%c framing%c parity%c overrun%c\n",
315 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
316 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
317 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
318 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
319 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
320 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
321 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
325 dev_dbg(&acm->control->dev,
326 "%s - unknown notification %d received: index %d "
327 "len %d data0 %d data1 %d\n",
329 dr->bNotificationType, dr->wIndex,
330 dr->wLength, data[0], data[1]);
334 retval = usb_submit_urb(urb, GFP_ATOMIC);
336 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
340 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
344 if (!test_and_clear_bit(index, &acm->read_urbs_free))
347 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
349 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
352 dev_err(&acm->data->dev,
353 "%s - usb_submit_urb failed: %d\n",
356 set_bit(index, &acm->read_urbs_free);
363 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
368 for (i = 0; i < acm->rx_buflimit; ++i) {
369 res = acm_submit_read_urb(acm, i, mem_flags);
377 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
379 struct tty_struct *tty;
381 if (!urb->actual_length)
384 tty = tty_port_tty_get(&acm->port);
388 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
389 tty_flip_buffer_push(tty);
394 static void acm_read_bulk_callback(struct urb *urb)
396 struct acm_rb *rb = urb->context;
397 struct acm *acm = rb->instance;
400 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
401 rb->index, urb->actual_length);
402 set_bit(rb->index, &acm->read_urbs_free);
405 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
408 usb_mark_last_busy(acm->dev);
411 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
412 __func__, urb->status);
415 acm_process_read_urb(acm, urb);
417 /* throttle device if requested by tty */
418 spin_lock_irqsave(&acm->read_lock, flags);
419 acm->throttled = acm->throttle_req;
420 if (!acm->throttled && !acm->susp_count) {
421 spin_unlock_irqrestore(&acm->read_lock, flags);
422 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
424 spin_unlock_irqrestore(&acm->read_lock, flags);
428 /* data interface wrote those outgoing bytes */
429 static void acm_write_bulk(struct urb *urb)
431 struct acm_wb *wb = urb->context;
432 struct acm *acm = wb->instance;
435 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
436 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
439 urb->transfer_buffer_length,
442 spin_lock_irqsave(&acm->write_lock, flags);
443 acm_write_done(acm, wb);
444 spin_unlock_irqrestore(&acm->write_lock, flags);
446 schedule_work(&acm->work);
449 static void acm_softint(struct work_struct *work)
451 struct acm *acm = container_of(work, struct acm, work);
452 struct tty_struct *tty;
454 dev_vdbg(&acm->data->dev, "%s\n", __func__);
458 tty = tty_port_tty_get(&acm->port);
469 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
474 mutex_lock(&open_mutex);
476 acm = acm_table[tty->index];
477 if (!acm || !acm->dev)
482 dev_dbg(&acm->control->dev, "%s\n", __func__);
484 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
486 tty->driver_data = acm;
487 tty_port_tty_set(&acm->port, tty);
489 if (usb_autopm_get_interface(acm->control) < 0)
492 acm->control->needs_remote_wakeup = 1;
494 mutex_lock(&acm->mutex);
495 if (acm->port.count++) {
496 mutex_unlock(&acm->mutex);
497 usb_autopm_put_interface(acm->control);
501 acm->ctrlurb->dev = acm->dev;
502 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
503 dev_err(&acm->control->dev,
504 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
508 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
509 (acm->ctrl_caps & USB_CDC_CAP_LINE))
512 usb_autopm_put_interface(acm->control);
515 * Unthrottle device in case the TTY was closed while throttled.
517 spin_lock_irq(&acm->read_lock);
519 acm->throttle_req = 0;
520 spin_unlock_irq(&acm->read_lock);
522 if (acm_submit_read_urbs(acm, GFP_KERNEL))
525 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
526 rv = tty_port_block_til_ready(&acm->port, tty, filp);
528 mutex_unlock(&acm->mutex);
530 mutex_unlock(&open_mutex);
535 mutex_unlock(&acm->mutex);
536 usb_autopm_put_interface(acm->control);
538 mutex_unlock(&open_mutex);
539 tty_port_tty_set(&acm->port, NULL);
543 static void acm_tty_unregister(struct acm *acm)
547 tty_unregister_device(acm_tty_driver, acm->minor);
548 usb_put_intf(acm->control);
549 acm_table[acm->minor] = NULL;
550 usb_free_urb(acm->ctrlurb);
551 for (i = 0; i < ACM_NW; i++)
552 usb_free_urb(acm->wb[i].urb);
553 for (i = 0; i < acm->rx_buflimit; i++)
554 usb_free_urb(acm->read_urbs[i]);
555 kfree(acm->country_codes);
559 static void acm_port_down(struct acm *acm)
566 usb_autopm_get_interface(acm->control);
567 acm_set_control(acm, acm->ctrlout = 0);
570 urb = usb_get_from_anchor(&acm->delayed);
575 usb_autopm_put_interface_async(acm->control);
578 usb_kill_urb(acm->ctrlurb);
579 for (i = 0; i < ACM_NW; i++)
580 usb_kill_urb(acm->wb[i].urb);
581 for (i = 0; i < acm->rx_buflimit; i++)
582 usb_kill_urb(acm->read_urbs[i]);
583 acm->control->needs_remote_wakeup = 0;
584 usb_autopm_put_interface(acm->control);
588 static void acm_tty_hangup(struct tty_struct *tty)
592 mutex_lock(&open_mutex);
593 acm = tty->driver_data;
598 tty_port_hangup(&acm->port);
602 mutex_unlock(&open_mutex);
605 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
607 struct acm *acm = tty->driver_data;
609 /* Perform the closing process and see if we need to do the hardware
614 mutex_lock(&open_mutex);
615 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
617 tty_port_tty_set(&acm->port, NULL);
618 acm_tty_unregister(acm);
619 tty->driver_data = NULL;
621 mutex_unlock(&open_mutex);
625 tty_port_close_end(&acm->port, tty);
626 tty_port_tty_set(&acm->port, NULL);
627 mutex_unlock(&open_mutex);
630 static int acm_tty_write(struct tty_struct *tty,
631 const unsigned char *buf, int count)
633 struct acm *acm = tty->driver_data;
644 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
646 spin_lock_irqsave(&acm->write_lock, flags);
647 wbn = acm_wb_alloc(acm);
649 spin_unlock_irqrestore(&acm->write_lock, flags);
654 count = (count > acm->writesize) ? acm->writesize : count;
655 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
656 memcpy(wb->buf, buf, count);
658 spin_unlock_irqrestore(&acm->write_lock, flags);
660 stat = acm_write_start(acm, wbn);
666 static int acm_tty_write_room(struct tty_struct *tty)
668 struct acm *acm = tty->driver_data;
672 * Do not let the line discipline to know that we have a reserve,
673 * or it might get too enthusiastic.
675 return acm_wb_is_avail(acm) ? acm->writesize : 0;
678 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
680 struct acm *acm = tty->driver_data;
684 * This is inaccurate (overcounts), but it works.
686 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
689 static void acm_tty_throttle(struct tty_struct *tty)
691 struct acm *acm = tty->driver_data;
696 spin_lock_irq(&acm->read_lock);
697 acm->throttle_req = 1;
698 spin_unlock_irq(&acm->read_lock);
701 static void acm_tty_unthrottle(struct tty_struct *tty)
703 struct acm *acm = tty->driver_data;
704 unsigned int was_throttled;
709 spin_lock_irq(&acm->read_lock);
710 was_throttled = acm->throttled;
712 acm->throttle_req = 0;
713 spin_unlock_irq(&acm->read_lock);
716 acm_submit_read_urbs(acm, GFP_KERNEL);
719 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
721 struct acm *acm = tty->driver_data;
725 retval = acm_send_break(acm, state ? 0xffff : 0);
727 dev_dbg(&acm->control->dev, "%s - send break failed\n",
732 static int acm_tty_tiocmget(struct tty_struct *tty)
734 struct acm *acm = tty->driver_data;
739 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
740 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
741 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
742 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
743 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
747 static int acm_tty_tiocmset(struct tty_struct *tty,
748 unsigned int set, unsigned int clear)
750 struct acm *acm = tty->driver_data;
751 unsigned int newctrl;
756 newctrl = acm->ctrlout;
757 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
758 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
759 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
760 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
762 newctrl = (newctrl & ~clear) | set;
764 if (acm->ctrlout == newctrl)
766 return acm_set_control(acm, acm->ctrlout = newctrl);
769 static int acm_tty_ioctl(struct tty_struct *tty,
770 unsigned int cmd, unsigned long arg)
772 struct acm *acm = tty->driver_data;
780 static const __u32 acm_tty_speed[] = {
781 0, 50, 75, 110, 134, 150, 200, 300, 600,
782 1200, 1800, 2400, 4800, 9600, 19200, 38400,
783 57600, 115200, 230400, 460800, 500000, 576000,
784 921600, 1000000, 1152000, 1500000, 2000000,
785 2500000, 3000000, 3500000, 4000000
788 static void acm_tty_set_termios(struct tty_struct *tty,
789 struct ktermios *termios_old)
791 struct acm *acm = tty->driver_data;
792 struct ktermios *termios = tty->termios;
793 struct usb_cdc_line_coding newline;
794 int newctrl = acm->ctrlout;
799 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
800 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
801 newline.bParityType = termios->c_cflag & PARENB ?
802 (termios->c_cflag & PARODD ? 1 : 2) +
803 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
804 switch (termios->c_cflag & CSIZE) {
806 newline.bDataBits = 5;
809 newline.bDataBits = 6;
812 newline.bDataBits = 7;
816 newline.bDataBits = 8;
819 /* FIXME: Needs to clear unsupported bits in the termios */
820 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
822 if (C_BAUD(tty) == B0) {
823 newline.dwDTERate = acm->line.dwDTERate;
824 newctrl &= ~ACM_CTRL_DTR;
825 } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
826 newctrl |= ACM_CTRL_DTR;
829 if (newctrl != acm->ctrlout)
830 acm_set_control(acm, acm->ctrlout = newctrl);
832 if (memcmp(&acm->line, &newline, sizeof newline)) {
833 memcpy(&acm->line, &newline, sizeof newline);
834 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
836 le32_to_cpu(newline.dwDTERate),
837 newline.bCharFormat, newline.bParityType,
839 acm_set_line(acm, &acm->line);
844 * USB probe and disconnect routines.
847 /* Little helpers: write/read buffers free */
848 static void acm_write_buffers_free(struct acm *acm)
852 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
854 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
855 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
858 static void acm_read_buffers_free(struct acm *acm)
860 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
863 for (i = 0; i < acm->rx_buflimit; i++)
864 usb_free_coherent(usb_dev, acm->readsize,
865 acm->read_buffers[i].base, acm->read_buffers[i].dma);
868 /* Little helper: write buffers allocate */
869 static int acm_write_buffers_alloc(struct acm *acm)
874 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
875 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
881 usb_free_coherent(acm->dev, acm->writesize,
890 static int acm_probe(struct usb_interface *intf,
891 const struct usb_device_id *id)
893 struct usb_cdc_union_desc *union_header = NULL;
894 struct usb_cdc_country_functional_desc *cfd = NULL;
895 unsigned char *buffer = intf->altsetting->extra;
896 int buflen = intf->altsetting->extralen;
897 struct usb_interface *control_interface;
898 struct usb_interface *data_interface;
899 struct usb_endpoint_descriptor *epctrl = NULL;
900 struct usb_endpoint_descriptor *epread = NULL;
901 struct usb_endpoint_descriptor *epwrite = NULL;
902 struct usb_device *usb_dev = interface_to_usbdev(intf);
905 int ctrlsize, readsize;
907 u8 ac_management_function = 0;
908 u8 call_management_function = 0;
909 int call_interface_num = -1;
910 int data_interface_num = -1;
911 unsigned long quirks;
914 unsigned int elength = 0;
915 int combined_interfaces = 0;
918 quirks = (unsigned long)id->driver_info;
920 if (quirks == IGNORE_DEVICE)
923 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
925 /* handle quirks deadly to normal probing*/
926 if (quirks == NO_UNION_NORMAL) {
927 data_interface = usb_ifnum_to_if(usb_dev, 1);
928 control_interface = usb_ifnum_to_if(usb_dev, 0);
930 if (!data_interface || !control_interface)
932 goto skip_normal_probe;
937 dev_err(&intf->dev, "Weird descriptor references\n");
942 if (intf->cur_altsetting->endpoint &&
943 intf->cur_altsetting->endpoint->extralen &&
944 intf->cur_altsetting->endpoint->extra) {
946 "Seeking extra descriptors on endpoint\n");
947 buflen = intf->cur_altsetting->endpoint->extralen;
948 buffer = intf->cur_altsetting->endpoint->extra;
951 "Zero length descriptor references\n");
959 dev_err(&intf->dev, "skipping garbage byte\n");
963 if (buffer[1] != USB_DT_CS_INTERFACE) {
964 dev_err(&intf->dev, "skipping garbage\n");
969 case USB_CDC_UNION_TYPE: /* we've found it */
970 if (elength < sizeof(struct usb_cdc_union_desc))
973 dev_err(&intf->dev, "More than one "
974 "union descriptor, skipping ...\n");
977 union_header = (struct usb_cdc_union_desc *)buffer;
979 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
980 if (elength < sizeof(struct usb_cdc_country_functional_desc))
982 cfd = (struct usb_cdc_country_functional_desc *)buffer;
984 case USB_CDC_HEADER_TYPE: /* maybe check version */
985 break; /* for now we ignore it */
986 case USB_CDC_ACM_TYPE:
989 ac_management_function = buffer[3];
991 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");
1001 * there are LOTS more CDC descriptors that
1002 * could legitimately be found here.
1004 dev_dbg(&intf->dev, "Ignoring descriptor: "
1005 "type %02x, length %ud\n",
1006 buffer[2], elength);
1014 if (!union_header) {
1015 if (call_interface_num > 0) {
1016 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1017 /* quirks for Droids MuIn LCD */
1018 if (quirks & NO_DATA_INTERFACE)
1019 data_interface = usb_ifnum_to_if(usb_dev, 0);
1021 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1022 control_interface = intf;
1024 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1025 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1028 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1029 combined_interfaces = 1;
1030 control_interface = data_interface = intf;
1031 goto look_for_collapsed_interface;
1035 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1036 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1039 if (!control_interface || !data_interface) {
1040 dev_dbg(&intf->dev, "no interfaces\n");
1044 if (data_interface_num != call_interface_num)
1045 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1047 if (control_interface == data_interface) {
1048 /* some broken devices designed for windows work this way */
1049 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1050 combined_interfaces = 1;
1051 /* a popular other OS doesn't use it */
1052 quirks |= NO_CAP_LINE;
1053 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1054 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1057 look_for_collapsed_interface:
1058 for (i = 0; i < 3; i++) {
1059 struct usb_endpoint_descriptor *ep;
1060 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1062 if (usb_endpoint_is_int_in(ep))
1064 else if (usb_endpoint_is_bulk_out(ep))
1066 else if (usb_endpoint_is_bulk_in(ep))
1071 if (!epctrl || !epread || !epwrite)
1074 goto made_compressed_probe;
1079 /*workaround for switched interfaces */
1080 if (data_interface->cur_altsetting->desc.bInterfaceClass
1081 != CDC_DATA_INTERFACE_TYPE) {
1082 if (control_interface->cur_altsetting->desc.bInterfaceClass
1083 == CDC_DATA_INTERFACE_TYPE) {
1084 struct usb_interface *t;
1086 "Your device has switched interfaces.\n");
1087 t = control_interface;
1088 control_interface = data_interface;
1095 /* Accept probe requests only for the control interface */
1096 if (!combined_interfaces && intf != control_interface)
1099 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1100 /* valid in this context */
1101 dev_dbg(&intf->dev, "The data interface isn't available\n");
1106 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1107 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1110 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1111 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1112 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1115 /* workaround for switched endpoints */
1116 if (!usb_endpoint_dir_in(epread)) {
1117 /* descriptors are swapped */
1118 struct usb_endpoint_descriptor *t;
1120 "The data interface has switched endpoints\n");
1125 made_compressed_probe:
1126 dev_dbg(&intf->dev, "interfaces are valid\n");
1127 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1129 if (minor == ACM_TTY_MINORS) {
1130 dev_err(&intf->dev, "no more free acm devices\n");
1134 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1136 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1140 ctrlsize = usb_endpoint_maxp(epctrl);
1141 readsize = usb_endpoint_maxp(epread) *
1142 (quirks == SINGLE_RX_URB ? 1 : 2);
1143 acm->combined_interfaces = combined_interfaces;
1144 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1145 acm->control = control_interface;
1146 acm->data = data_interface;
1149 acm->ctrl_caps = ac_management_function;
1150 if (quirks & NO_CAP_LINE)
1151 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1152 acm->ctrlsize = ctrlsize;
1153 acm->readsize = readsize;
1154 acm->rx_buflimit = num_rx_buf;
1155 INIT_WORK(&acm->work, acm_softint);
1156 spin_lock_init(&acm->write_lock);
1157 spin_lock_init(&acm->read_lock);
1158 mutex_init(&acm->mutex);
1159 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1160 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1162 acm->bInterval = epread->bInterval;
1163 tty_port_init(&acm->port);
1164 acm->port.ops = &acm_port_ops;
1165 init_usb_anchor(&acm->delayed);
1167 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1169 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1172 acm->ctrl_buffer = buf;
1174 if (acm_write_buffers_alloc(acm) < 0) {
1175 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1179 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1180 if (!acm->ctrlurb) {
1181 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1184 for (i = 0; i < num_rx_buf; i++) {
1185 struct acm_rb *rb = &(acm->read_buffers[i]);
1188 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1191 dev_err(&intf->dev, "out of memory "
1192 "(read bufs usb_alloc_coherent)\n");
1198 urb = usb_alloc_urb(0, GFP_KERNEL);
1201 "out of memory (read urbs usb_alloc_urb)\n");
1204 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1205 urb->transfer_dma = rb->dma;
1206 if (acm->is_int_ep) {
1207 usb_fill_int_urb(urb, acm->dev,
1211 acm_read_bulk_callback, rb,
1214 usb_fill_bulk_urb(urb, acm->dev,
1218 acm_read_bulk_callback, rb);
1221 acm->read_urbs[i] = urb;
1222 __set_bit(i, &acm->read_urbs_free);
1224 for (i = 0; i < ACM_NW; i++) {
1225 struct acm_wb *snd = &(acm->wb[i]);
1227 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1228 if (snd->urb == NULL) {
1230 "out of memory (write urbs usb_alloc_urb)\n");
1234 if (usb_endpoint_xfer_int(epwrite))
1235 usb_fill_int_urb(snd->urb, usb_dev,
1236 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1237 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1239 usb_fill_bulk_urb(snd->urb, usb_dev,
1240 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1241 NULL, acm->writesize, acm_write_bulk, snd);
1242 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1243 if (quirks & SEND_ZERO_PACKET)
1244 snd->urb->transfer_flags |= URB_ZERO_PACKET;
1245 snd->instance = acm;
1248 usb_set_intfdata(intf, acm);
1250 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1254 if (cfd) { /* export the country data */
1255 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1256 if (!acm->country_codes)
1257 goto skip_countries;
1258 acm->country_code_size = cfd->bLength - 4;
1259 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1261 acm->country_rel_date = cfd->iCountryCodeRelDate;
1263 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1265 kfree(acm->country_codes);
1266 acm->country_codes = NULL;
1267 acm->country_code_size = 0;
1268 goto skip_countries;
1271 i = device_create_file(&intf->dev,
1272 &dev_attr_iCountryCodeRelDate);
1274 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1275 kfree(acm->country_codes);
1276 acm->country_codes = NULL;
1277 acm->country_code_size = 0;
1278 goto skip_countries;
1283 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1284 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1285 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1286 /* works around buggy devices */
1287 epctrl->bInterval ? epctrl->bInterval : 0xff);
1288 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1289 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1291 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1293 acm_set_control(acm, acm->ctrlout);
1295 acm->line.dwDTERate = cpu_to_le32(9600);
1296 acm->line.bDataBits = 8;
1297 acm_set_line(acm, &acm->line);
1299 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1300 usb_set_intfdata(data_interface, acm);
1302 usb_get_intf(control_interface);
1303 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1305 acm_table[minor] = acm;
1307 if (quirks & CLEAR_HALT_CONDITIONS) {
1308 usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress));
1309 usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress));
1314 for (i = 0; i < ACM_NW; i++)
1315 usb_free_urb(acm->wb[i].urb);
1317 for (i = 0; i < num_rx_buf; i++)
1318 usb_free_urb(acm->read_urbs[i]);
1319 acm_read_buffers_free(acm);
1320 usb_free_urb(acm->ctrlurb);
1322 acm_write_buffers_free(acm);
1324 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1331 static void stop_data_traffic(struct acm *acm)
1335 dev_dbg(&acm->control->dev, "%s\n", __func__);
1337 usb_kill_urb(acm->ctrlurb);
1338 for (i = 0; i < ACM_NW; i++)
1339 usb_kill_urb(acm->wb[i].urb);
1340 for (i = 0; i < acm->rx_buflimit; i++)
1341 usb_kill_urb(acm->read_urbs[i]);
1343 cancel_work_sync(&acm->work);
1346 static void acm_disconnect(struct usb_interface *intf)
1348 struct acm *acm = usb_get_intfdata(intf);
1349 struct usb_device *usb_dev = interface_to_usbdev(intf);
1350 struct tty_struct *tty;
1352 /* sibling interface is already cleaning up */
1356 mutex_lock(&open_mutex);
1357 if (acm->country_codes) {
1358 device_remove_file(&acm->control->dev,
1359 &dev_attr_wCountryCodes);
1360 device_remove_file(&acm->control->dev,
1361 &dev_attr_iCountryCodeRelDate);
1363 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1365 usb_set_intfdata(acm->control, NULL);
1366 usb_set_intfdata(acm->data, NULL);
1368 stop_data_traffic(acm);
1370 acm_write_buffers_free(acm);
1371 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1373 acm_read_buffers_free(acm);
1375 if (!acm->combined_interfaces)
1376 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1377 acm->data : acm->control);
1379 if (acm->port.count == 0) {
1380 acm_tty_unregister(acm);
1381 mutex_unlock(&open_mutex);
1385 mutex_unlock(&open_mutex);
1386 tty = tty_port_tty_get(&acm->port);
1394 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1396 struct acm *acm = usb_get_intfdata(intf);
1399 spin_lock_irq(&acm->read_lock);
1400 spin_lock(&acm->write_lock);
1401 if (PMSG_IS_AUTO(message)) {
1402 if (acm->transmitting) {
1403 spin_unlock(&acm->write_lock);
1404 spin_unlock_irq(&acm->read_lock);
1408 cnt = acm->susp_count++;
1409 spin_unlock(&acm->write_lock);
1410 spin_unlock_irq(&acm->read_lock);
1415 we treat opened interfaces differently,
1416 we must guard against open
1418 mutex_lock(&acm->mutex);
1420 if (acm->port.count)
1421 stop_data_traffic(acm);
1423 mutex_unlock(&acm->mutex);
1427 static int acm_resume(struct usb_interface *intf)
1429 struct acm *acm = usb_get_intfdata(intf);
1433 mutex_lock(&acm->mutex);
1434 spin_lock_irq(&acm->read_lock);
1435 spin_lock(&acm->write_lock);
1437 if (--acm->susp_count)
1440 if (acm->port.count) {
1441 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1444 urb = usb_get_from_anchor(&acm->delayed);
1448 acm_start_wb(acm, urb->context);
1452 * delayed error checking because we must
1453 * do the write path at all cost
1458 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1461 spin_unlock(&acm->write_lock);
1462 spin_unlock_irq(&acm->read_lock);
1463 mutex_unlock(&acm->mutex);
1468 static int acm_reset_resume(struct usb_interface *intf)
1470 struct acm *acm = usb_get_intfdata(intf);
1471 struct tty_struct *tty;
1473 mutex_lock(&acm->mutex);
1474 if (acm->port.count) {
1475 tty = tty_port_tty_get(&acm->port);
1481 mutex_unlock(&acm->mutex);
1482 return acm_resume(intf);
1485 #endif /* CONFIG_PM */
1487 #define NOKIA_PCSUITE_ACM_INFO(x) \
1488 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1489 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1490 USB_CDC_ACM_PROTO_VENDOR)
1492 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1493 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1494 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1495 USB_CDC_ACM_PROTO_VENDOR)
1498 * USB driver structure.
1501 static const struct usb_device_id acm_ids[] = {
1502 /* quirky and broken devices */
1503 { USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1504 .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1505 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1506 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1508 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1509 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1511 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1512 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1514 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1515 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1517 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1518 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1520 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1521 .driver_info = SINGLE_RX_URB,
1523 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1524 .driver_info = SINGLE_RX_URB, /* firmware bug */
1526 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1527 .driver_info = SINGLE_RX_URB, /* firmware bug */
1529 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1530 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1532 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1533 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1535 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1536 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1538 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1539 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1541 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1542 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1544 { USB_DEVICE(0x2184, 0x001c) }, /* GW Instek AFG-2225 */
1545 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1547 /* Motorola H24 HSPA module: */
1548 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1549 { USB_DEVICE(0x22b8, 0x2d92), /* modem + diagnostics */
1550 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1552 { USB_DEVICE(0x22b8, 0x2d93), /* modem + AT port */
1553 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1555 { USB_DEVICE(0x22b8, 0x2d95), /* modem + AT port + diagnostics */
1556 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1558 { USB_DEVICE(0x22b8, 0x2d96), /* modem + NMEA */
1559 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1561 { USB_DEVICE(0x22b8, 0x2d97), /* modem + diagnostics + NMEA */
1562 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1564 { USB_DEVICE(0x22b8, 0x2d99), /* modem + AT port + NMEA */
1565 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1567 { USB_DEVICE(0x22b8, 0x2d9a), /* modem + AT port + diagnostics + NMEA */
1568 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1571 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1572 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1573 data interface instead of
1574 communications interface.
1575 Maybe we should define a new
1578 { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1579 .driver_info = NO_UNION_NORMAL,
1581 { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1582 .driver_info = NO_UNION_NORMAL,
1584 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1585 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1587 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1588 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1591 { USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */
1592 .driver_info = CLEAR_HALT_CONDITIONS,
1595 /* Nokia S60 phones expose two ACM channels. The first is
1596 * a modem and is picked up by the standard AT-command
1597 * information below. The second is 'vendor-specific' but
1598 * is treated as a serial device at the S60 end, so we want
1599 * to expose it on Linux too. */
1600 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1602 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1606 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1609 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1611 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1612 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1613 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1615 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1616 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1617 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1618 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1619 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1620 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1621 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1622 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1623 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1624 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1625 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1626 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1627 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1628 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1629 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1630 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1631 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1632 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1633 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1634 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1635 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1636 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1637 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1638 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1639 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1640 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1641 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1642 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1643 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1644 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1645 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1646 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1647 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1648 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1649 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1650 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1651 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1652 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1653 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1654 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1655 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1656 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1657 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1659 /* Support for Owen devices */
1660 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1662 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1664 /* Support Lego NXT using pbLua firmware */
1665 { USB_DEVICE(0x0694, 0xff00),
1666 .driver_info = NOT_A_MODEM,
1669 /* Support for Droids MuIn LCD */
1670 { USB_DEVICE(0x04d8, 0x000b),
1671 .driver_info = NO_DATA_INTERFACE,
1674 /*Samsung phone in firmware update mode */
1675 { USB_DEVICE(0x04e8, 0x685d),
1676 .driver_info = IGNORE_DEVICE,
1679 /* Exclude Infineon Flash Loader utility */
1680 { USB_DEVICE(0x058b, 0x0041),
1681 .driver_info = IGNORE_DEVICE,
1684 /* control interfaces without any protocol set */
1685 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1686 USB_CDC_PROTO_NONE) },
1688 /* control interfaces with various AT-command sets */
1689 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1690 USB_CDC_ACM_PROTO_AT_V25TER) },
1691 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1692 USB_CDC_ACM_PROTO_AT_PCCA101) },
1693 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1694 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1695 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1696 USB_CDC_ACM_PROTO_AT_GSM) },
1697 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1698 USB_CDC_ACM_PROTO_AT_3G) },
1699 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1700 USB_CDC_ACM_PROTO_AT_CDMA) },
1702 { USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */
1703 .driver_info = SEND_ZERO_PACKET,
1709 MODULE_DEVICE_TABLE(usb, acm_ids);
1711 static struct usb_driver acm_driver = {
1714 .disconnect = acm_disconnect,
1716 .suspend = acm_suspend,
1717 .resume = acm_resume,
1718 .reset_resume = acm_reset_resume,
1720 .id_table = acm_ids,
1722 .supports_autosuspend = 1,
1727 * TTY driver structures.
1730 static const struct tty_operations acm_ops = {
1731 .open = acm_tty_open,
1732 .close = acm_tty_close,
1733 .hangup = acm_tty_hangup,
1734 .write = acm_tty_write,
1735 .write_room = acm_tty_write_room,
1736 .ioctl = acm_tty_ioctl,
1737 .throttle = acm_tty_throttle,
1738 .unthrottle = acm_tty_unthrottle,
1739 .chars_in_buffer = acm_tty_chars_in_buffer,
1740 .break_ctl = acm_tty_break_ctl,
1741 .set_termios = acm_tty_set_termios,
1742 .tiocmget = acm_tty_tiocmget,
1743 .tiocmset = acm_tty_tiocmset,
1750 static int __init acm_init(void)
1753 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1754 if (!acm_tty_driver)
1756 acm_tty_driver->owner = THIS_MODULE,
1757 acm_tty_driver->driver_name = "acm",
1758 acm_tty_driver->name = "ttyACM",
1759 acm_tty_driver->major = ACM_TTY_MAJOR,
1760 acm_tty_driver->minor_start = 0,
1761 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1762 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1763 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1764 acm_tty_driver->init_termios = tty_std_termios;
1765 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1767 tty_set_operations(acm_tty_driver, &acm_ops);
1769 retval = tty_register_driver(acm_tty_driver);
1771 put_tty_driver(acm_tty_driver);
1775 retval = usb_register(&acm_driver);
1777 tty_unregister_driver(acm_tty_driver);
1778 put_tty_driver(acm_tty_driver);
1782 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1787 static void __exit acm_exit(void)
1789 usb_deregister(&acm_driver);
1790 tty_unregister_driver(acm_tty_driver);
1791 put_tty_driver(acm_tty_driver);
1794 module_init(acm_init);
1795 module_exit(acm_exit);
1797 MODULE_AUTHOR(DRIVER_AUTHOR);
1798 MODULE_DESCRIPTION(DRIVER_DESC);
1799 MODULE_LICENSE("GPL");
1800 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);