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 if (le16_to_cpu(dr->wLength) != 2) {
297 dev_dbg(&acm->control->dev,
298 "%s - malformed serial state\n", __func__);
302 tty = tty_port_tty_get(&acm->port);
303 newctrl = get_unaligned_le16(data);
307 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
308 dev_dbg(&acm->control->dev,
309 "%s - calling hangup\n", __func__);
315 acm->ctrlin = newctrl;
317 dev_dbg(&acm->control->dev,
318 "%s - input control lines: dcd%c dsr%c break%c "
319 "ring%c framing%c parity%c overrun%c\n",
321 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
322 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
323 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
331 dev_dbg(&acm->control->dev,
332 "%s - unknown notification %d received: index %d len %d\n",
334 dr->bNotificationType, dr->wIndex, dr->wLength);
339 retval = usb_submit_urb(urb, GFP_ATOMIC);
341 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
345 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
349 if (!test_and_clear_bit(index, &acm->read_urbs_free))
352 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
354 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
357 dev_err(&acm->data->dev,
358 "%s - usb_submit_urb failed: %d\n",
361 set_bit(index, &acm->read_urbs_free);
368 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
373 for (i = 0; i < acm->rx_buflimit; ++i) {
374 res = acm_submit_read_urb(acm, i, mem_flags);
382 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
384 struct tty_struct *tty;
386 if (!urb->actual_length)
389 tty = tty_port_tty_get(&acm->port);
393 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
394 tty_flip_buffer_push(tty);
399 static void acm_read_bulk_callback(struct urb *urb)
401 struct acm_rb *rb = urb->context;
402 struct acm *acm = rb->instance;
405 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
406 rb->index, urb->actual_length);
407 set_bit(rb->index, &acm->read_urbs_free);
410 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
413 usb_mark_last_busy(acm->dev);
416 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
417 __func__, urb->status);
420 acm_process_read_urb(acm, urb);
422 /* throttle device if requested by tty */
423 spin_lock_irqsave(&acm->read_lock, flags);
424 acm->throttled = acm->throttle_req;
425 if (!acm->throttled && !acm->susp_count) {
426 spin_unlock_irqrestore(&acm->read_lock, flags);
427 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
429 spin_unlock_irqrestore(&acm->read_lock, flags);
433 /* data interface wrote those outgoing bytes */
434 static void acm_write_bulk(struct urb *urb)
436 struct acm_wb *wb = urb->context;
437 struct acm *acm = wb->instance;
440 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
441 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
444 urb->transfer_buffer_length,
447 spin_lock_irqsave(&acm->write_lock, flags);
448 acm_write_done(acm, wb);
449 spin_unlock_irqrestore(&acm->write_lock, flags);
451 schedule_work(&acm->work);
454 static void acm_softint(struct work_struct *work)
456 struct acm *acm = container_of(work, struct acm, work);
457 struct tty_struct *tty;
459 dev_vdbg(&acm->data->dev, "%s\n", __func__);
463 tty = tty_port_tty_get(&acm->port);
474 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
479 mutex_lock(&open_mutex);
481 acm = acm_table[tty->index];
482 if (!acm || !acm->dev)
487 dev_dbg(&acm->control->dev, "%s\n", __func__);
489 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
491 tty->driver_data = acm;
492 tty_port_tty_set(&acm->port, tty);
494 if (usb_autopm_get_interface(acm->control) < 0)
497 acm->control->needs_remote_wakeup = 1;
499 mutex_lock(&acm->mutex);
500 if (acm->port.count++) {
501 mutex_unlock(&acm->mutex);
502 usb_autopm_put_interface(acm->control);
506 acm->ctrlurb->dev = acm->dev;
507 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
508 dev_err(&acm->control->dev,
509 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
513 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
514 (acm->ctrl_caps & USB_CDC_CAP_LINE))
517 usb_autopm_put_interface(acm->control);
520 * Unthrottle device in case the TTY was closed while throttled.
522 spin_lock_irq(&acm->read_lock);
524 acm->throttle_req = 0;
525 spin_unlock_irq(&acm->read_lock);
527 if (acm_submit_read_urbs(acm, GFP_KERNEL))
530 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
531 rv = tty_port_block_til_ready(&acm->port, tty, filp);
533 mutex_unlock(&acm->mutex);
535 mutex_unlock(&open_mutex);
540 mutex_unlock(&acm->mutex);
541 usb_autopm_put_interface(acm->control);
543 mutex_unlock(&open_mutex);
544 tty_port_tty_set(&acm->port, NULL);
548 static void acm_tty_unregister(struct acm *acm)
552 tty_unregister_device(acm_tty_driver, acm->minor);
553 usb_put_intf(acm->control);
554 acm_table[acm->minor] = NULL;
555 usb_free_urb(acm->ctrlurb);
556 for (i = 0; i < ACM_NW; i++)
557 usb_free_urb(acm->wb[i].urb);
558 for (i = 0; i < acm->rx_buflimit; i++)
559 usb_free_urb(acm->read_urbs[i]);
560 kfree(acm->country_codes);
564 static void acm_port_down(struct acm *acm)
571 usb_autopm_get_interface(acm->control);
572 acm_set_control(acm, acm->ctrlout = 0);
575 urb = usb_get_from_anchor(&acm->delayed);
580 usb_autopm_put_interface_async(acm->control);
583 usb_kill_urb(acm->ctrlurb);
584 for (i = 0; i < ACM_NW; i++)
585 usb_kill_urb(acm->wb[i].urb);
586 for (i = 0; i < acm->rx_buflimit; i++)
587 usb_kill_urb(acm->read_urbs[i]);
588 acm->control->needs_remote_wakeup = 0;
589 usb_autopm_put_interface(acm->control);
593 static void acm_tty_hangup(struct tty_struct *tty)
597 mutex_lock(&open_mutex);
598 acm = tty->driver_data;
603 tty_port_hangup(&acm->port);
607 mutex_unlock(&open_mutex);
610 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
612 struct acm *acm = tty->driver_data;
614 /* Perform the closing process and see if we need to do the hardware
619 mutex_lock(&open_mutex);
620 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
622 tty_port_tty_set(&acm->port, NULL);
623 acm_tty_unregister(acm);
624 tty->driver_data = NULL;
626 mutex_unlock(&open_mutex);
630 tty_port_close_end(&acm->port, tty);
631 tty_port_tty_set(&acm->port, NULL);
632 mutex_unlock(&open_mutex);
635 static int acm_tty_write(struct tty_struct *tty,
636 const unsigned char *buf, int count)
638 struct acm *acm = tty->driver_data;
649 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
651 spin_lock_irqsave(&acm->write_lock, flags);
652 wbn = acm_wb_alloc(acm);
654 spin_unlock_irqrestore(&acm->write_lock, flags);
659 count = (count > acm->writesize) ? acm->writesize : count;
660 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
661 memcpy(wb->buf, buf, count);
663 spin_unlock_irqrestore(&acm->write_lock, flags);
665 stat = acm_write_start(acm, wbn);
671 static int acm_tty_write_room(struct tty_struct *tty)
673 struct acm *acm = tty->driver_data;
677 * Do not let the line discipline to know that we have a reserve,
678 * or it might get too enthusiastic.
680 return acm_wb_is_avail(acm) ? acm->writesize : 0;
683 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
685 struct acm *acm = tty->driver_data;
689 * This is inaccurate (overcounts), but it works.
691 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
694 static void acm_tty_throttle(struct tty_struct *tty)
696 struct acm *acm = tty->driver_data;
701 spin_lock_irq(&acm->read_lock);
702 acm->throttle_req = 1;
703 spin_unlock_irq(&acm->read_lock);
706 static void acm_tty_unthrottle(struct tty_struct *tty)
708 struct acm *acm = tty->driver_data;
709 unsigned int was_throttled;
714 spin_lock_irq(&acm->read_lock);
715 was_throttled = acm->throttled;
717 acm->throttle_req = 0;
718 spin_unlock_irq(&acm->read_lock);
721 acm_submit_read_urbs(acm, GFP_KERNEL);
724 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
726 struct acm *acm = tty->driver_data;
730 retval = acm_send_break(acm, state ? 0xffff : 0);
732 dev_dbg(&acm->control->dev, "%s - send break failed\n",
737 static int acm_tty_tiocmget(struct tty_struct *tty)
739 struct acm *acm = tty->driver_data;
744 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
745 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
746 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
747 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
748 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
752 static int acm_tty_tiocmset(struct tty_struct *tty,
753 unsigned int set, unsigned int clear)
755 struct acm *acm = tty->driver_data;
756 unsigned int newctrl;
761 newctrl = acm->ctrlout;
762 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
763 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
764 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
765 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
767 newctrl = (newctrl & ~clear) | set;
769 if (acm->ctrlout == newctrl)
771 return acm_set_control(acm, acm->ctrlout = newctrl);
774 static int acm_tty_ioctl(struct tty_struct *tty,
775 unsigned int cmd, unsigned long arg)
777 struct acm *acm = tty->driver_data;
785 static const __u32 acm_tty_speed[] = {
786 0, 50, 75, 110, 134, 150, 200, 300, 600,
787 1200, 1800, 2400, 4800, 9600, 19200, 38400,
788 57600, 115200, 230400, 460800, 500000, 576000,
789 921600, 1000000, 1152000, 1500000, 2000000,
790 2500000, 3000000, 3500000, 4000000
793 static void acm_tty_set_termios(struct tty_struct *tty,
794 struct ktermios *termios_old)
796 struct acm *acm = tty->driver_data;
797 struct ktermios *termios = tty->termios;
798 struct usb_cdc_line_coding newline;
799 int newctrl = acm->ctrlout;
804 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
805 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
806 newline.bParityType = termios->c_cflag & PARENB ?
807 (termios->c_cflag & PARODD ? 1 : 2) +
808 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
809 switch (termios->c_cflag & CSIZE) {
811 newline.bDataBits = 5;
814 newline.bDataBits = 6;
817 newline.bDataBits = 7;
821 newline.bDataBits = 8;
824 /* FIXME: Needs to clear unsupported bits in the termios */
825 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
827 if (C_BAUD(tty) == B0) {
828 newline.dwDTERate = acm->line.dwDTERate;
829 newctrl &= ~ACM_CTRL_DTR;
830 } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
831 newctrl |= ACM_CTRL_DTR;
834 if (newctrl != acm->ctrlout)
835 acm_set_control(acm, acm->ctrlout = newctrl);
837 if (memcmp(&acm->line, &newline, sizeof newline)) {
838 memcpy(&acm->line, &newline, sizeof newline);
839 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
841 le32_to_cpu(newline.dwDTERate),
842 newline.bCharFormat, newline.bParityType,
844 acm_set_line(acm, &acm->line);
849 * USB probe and disconnect routines.
852 /* Little helpers: write/read buffers free */
853 static void acm_write_buffers_free(struct acm *acm)
857 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
859 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
860 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
863 static void acm_read_buffers_free(struct acm *acm)
865 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
868 for (i = 0; i < acm->rx_buflimit; i++)
869 usb_free_coherent(usb_dev, acm->readsize,
870 acm->read_buffers[i].base, acm->read_buffers[i].dma);
873 /* Little helper: write buffers allocate */
874 static int acm_write_buffers_alloc(struct acm *acm)
879 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
880 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
886 usb_free_coherent(acm->dev, acm->writesize,
895 static int acm_probe(struct usb_interface *intf,
896 const struct usb_device_id *id)
898 struct usb_cdc_union_desc *union_header = NULL;
899 struct usb_cdc_country_functional_desc *cfd = NULL;
900 unsigned char *buffer = intf->altsetting->extra;
901 int buflen = intf->altsetting->extralen;
902 struct usb_interface *control_interface;
903 struct usb_interface *data_interface;
904 struct usb_endpoint_descriptor *epctrl = NULL;
905 struct usb_endpoint_descriptor *epread = NULL;
906 struct usb_endpoint_descriptor *epwrite = NULL;
907 struct usb_device *usb_dev = interface_to_usbdev(intf);
910 int ctrlsize, readsize;
912 u8 ac_management_function = 0;
913 u8 call_management_function = 0;
914 int call_interface_num = -1;
915 int data_interface_num = -1;
916 unsigned long quirks;
919 unsigned int elength = 0;
920 int combined_interfaces = 0;
923 quirks = (unsigned long)id->driver_info;
925 if (quirks == IGNORE_DEVICE)
928 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
930 /* handle quirks deadly to normal probing*/
931 if (quirks == NO_UNION_NORMAL) {
932 data_interface = usb_ifnum_to_if(usb_dev, 1);
933 control_interface = usb_ifnum_to_if(usb_dev, 0);
935 if (!data_interface || !control_interface)
937 goto skip_normal_probe;
942 dev_err(&intf->dev, "Weird descriptor references\n");
947 if (intf->cur_altsetting->endpoint &&
948 intf->cur_altsetting->endpoint->extralen &&
949 intf->cur_altsetting->endpoint->extra) {
951 "Seeking extra descriptors on endpoint\n");
952 buflen = intf->cur_altsetting->endpoint->extralen;
953 buffer = intf->cur_altsetting->endpoint->extra;
956 "Zero length descriptor references\n");
964 dev_err(&intf->dev, "skipping garbage byte\n");
968 if (buffer[1] != USB_DT_CS_INTERFACE) {
969 dev_err(&intf->dev, "skipping garbage\n");
974 case USB_CDC_UNION_TYPE: /* we've found it */
975 if (elength < sizeof(struct usb_cdc_union_desc))
978 dev_err(&intf->dev, "More than one "
979 "union descriptor, skipping ...\n");
982 union_header = (struct usb_cdc_union_desc *)buffer;
984 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
985 if (elength < sizeof(struct usb_cdc_country_functional_desc))
987 cfd = (struct usb_cdc_country_functional_desc *)buffer;
989 case USB_CDC_HEADER_TYPE: /* maybe check version */
990 break; /* for now we ignore it */
991 case USB_CDC_ACM_TYPE:
994 ac_management_function = buffer[3];
996 case USB_CDC_CALL_MANAGEMENT_TYPE:
999 call_management_function = buffer[3];
1000 call_interface_num = buffer[4];
1001 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1002 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1006 * there are LOTS more CDC descriptors that
1007 * could legitimately be found here.
1009 dev_dbg(&intf->dev, "Ignoring descriptor: "
1010 "type %02x, length %ud\n",
1011 buffer[2], elength);
1019 if (!union_header) {
1020 if (call_interface_num > 0) {
1021 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1022 /* quirks for Droids MuIn LCD */
1023 if (quirks & NO_DATA_INTERFACE)
1024 data_interface = usb_ifnum_to_if(usb_dev, 0);
1026 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1027 control_interface = intf;
1029 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1030 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1033 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1034 combined_interfaces = 1;
1035 control_interface = data_interface = intf;
1036 goto look_for_collapsed_interface;
1040 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1041 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1044 if (!control_interface || !data_interface) {
1045 dev_dbg(&intf->dev, "no interfaces\n");
1049 if (data_interface_num != call_interface_num)
1050 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1052 if (control_interface == data_interface) {
1053 /* some broken devices designed for windows work this way */
1054 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1055 combined_interfaces = 1;
1056 /* a popular other OS doesn't use it */
1057 quirks |= NO_CAP_LINE;
1058 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1059 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1062 look_for_collapsed_interface:
1063 for (i = 0; i < 3; i++) {
1064 struct usb_endpoint_descriptor *ep;
1065 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1067 if (usb_endpoint_is_int_in(ep))
1069 else if (usb_endpoint_is_bulk_out(ep))
1071 else if (usb_endpoint_is_bulk_in(ep))
1076 if (!epctrl || !epread || !epwrite)
1079 goto made_compressed_probe;
1084 /*workaround for switched interfaces */
1085 if (data_interface->cur_altsetting->desc.bInterfaceClass
1086 != CDC_DATA_INTERFACE_TYPE) {
1087 if (control_interface->cur_altsetting->desc.bInterfaceClass
1088 == CDC_DATA_INTERFACE_TYPE) {
1089 struct usb_interface *t;
1091 "Your device has switched interfaces.\n");
1092 t = control_interface;
1093 control_interface = data_interface;
1100 /* Accept probe requests only for the control interface */
1101 if (!combined_interfaces && intf != control_interface)
1104 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1105 /* valid in this context */
1106 dev_dbg(&intf->dev, "The data interface isn't available\n");
1111 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1112 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1115 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1116 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1117 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1120 /* workaround for switched endpoints */
1121 if (!usb_endpoint_dir_in(epread)) {
1122 /* descriptors are swapped */
1123 struct usb_endpoint_descriptor *t;
1125 "The data interface has switched endpoints\n");
1130 made_compressed_probe:
1131 dev_dbg(&intf->dev, "interfaces are valid\n");
1132 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1134 if (minor == ACM_TTY_MINORS) {
1135 dev_err(&intf->dev, "no more free acm devices\n");
1139 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1141 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1145 ctrlsize = usb_endpoint_maxp(epctrl);
1146 readsize = usb_endpoint_maxp(epread) *
1147 (quirks == SINGLE_RX_URB ? 1 : 2);
1148 acm->combined_interfaces = combined_interfaces;
1149 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1150 acm->control = control_interface;
1151 acm->data = data_interface;
1154 acm->ctrl_caps = ac_management_function;
1155 if (quirks & NO_CAP_LINE)
1156 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1157 acm->ctrlsize = ctrlsize;
1158 acm->readsize = readsize;
1159 acm->rx_buflimit = num_rx_buf;
1160 INIT_WORK(&acm->work, acm_softint);
1161 spin_lock_init(&acm->write_lock);
1162 spin_lock_init(&acm->read_lock);
1163 mutex_init(&acm->mutex);
1164 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1166 acm->bInterval = epread->bInterval;
1167 tty_port_init(&acm->port);
1168 acm->port.ops = &acm_port_ops;
1169 init_usb_anchor(&acm->delayed);
1171 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1173 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1176 acm->ctrl_buffer = buf;
1178 if (acm_write_buffers_alloc(acm) < 0) {
1179 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1183 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1184 if (!acm->ctrlurb) {
1185 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1188 for (i = 0; i < num_rx_buf; i++) {
1189 struct acm_rb *rb = &(acm->read_buffers[i]);
1192 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1195 dev_err(&intf->dev, "out of memory "
1196 "(read bufs usb_alloc_coherent)\n");
1202 urb = usb_alloc_urb(0, GFP_KERNEL);
1205 "out of memory (read urbs usb_alloc_urb)\n");
1208 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1209 urb->transfer_dma = rb->dma;
1210 if (acm->is_int_ep) {
1211 usb_fill_int_urb(urb, acm->dev,
1212 usb_rcvintpipe(usb_dev, epread->bEndpointAddress),
1215 acm_read_bulk_callback, rb,
1218 usb_fill_bulk_urb(urb, acm->dev,
1219 usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress),
1222 acm_read_bulk_callback, rb);
1225 acm->read_urbs[i] = urb;
1226 __set_bit(i, &acm->read_urbs_free);
1228 for (i = 0; i < ACM_NW; i++) {
1229 struct acm_wb *snd = &(acm->wb[i]);
1231 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1232 if (snd->urb == NULL) {
1234 "out of memory (write urbs usb_alloc_urb)\n");
1238 if (usb_endpoint_xfer_int(epwrite))
1239 usb_fill_int_urb(snd->urb, usb_dev,
1240 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1241 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1243 usb_fill_bulk_urb(snd->urb, usb_dev,
1244 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1245 NULL, acm->writesize, acm_write_bulk, snd);
1246 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1247 if (quirks & SEND_ZERO_PACKET)
1248 snd->urb->transfer_flags |= URB_ZERO_PACKET;
1249 snd->instance = acm;
1252 usb_set_intfdata(intf, acm);
1254 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1258 if (cfd) { /* export the country data */
1259 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1260 if (!acm->country_codes)
1261 goto skip_countries;
1262 acm->country_code_size = cfd->bLength - 4;
1263 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1265 acm->country_rel_date = cfd->iCountryCodeRelDate;
1267 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1269 kfree(acm->country_codes);
1270 acm->country_codes = NULL;
1271 acm->country_code_size = 0;
1272 goto skip_countries;
1275 i = device_create_file(&intf->dev,
1276 &dev_attr_iCountryCodeRelDate);
1278 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1279 kfree(acm->country_codes);
1280 acm->country_codes = NULL;
1281 acm->country_code_size = 0;
1282 goto skip_countries;
1287 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1288 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1289 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1290 /* works around buggy devices */
1291 epctrl->bInterval ? epctrl->bInterval : 0xff);
1292 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1293 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1295 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1297 acm_set_control(acm, acm->ctrlout);
1299 acm->line.dwDTERate = cpu_to_le32(9600);
1300 acm->line.bDataBits = 8;
1301 acm_set_line(acm, &acm->line);
1303 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1304 usb_set_intfdata(data_interface, acm);
1306 usb_get_intf(control_interface);
1307 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1309 acm_table[minor] = acm;
1311 if (quirks & CLEAR_HALT_CONDITIONS) {
1312 usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress));
1313 usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress));
1318 for (i = 0; i < ACM_NW; i++)
1319 usb_free_urb(acm->wb[i].urb);
1321 for (i = 0; i < num_rx_buf; i++)
1322 usb_free_urb(acm->read_urbs[i]);
1323 acm_read_buffers_free(acm);
1324 usb_free_urb(acm->ctrlurb);
1326 acm_write_buffers_free(acm);
1328 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1335 static void stop_data_traffic(struct acm *acm)
1339 dev_dbg(&acm->control->dev, "%s\n", __func__);
1341 usb_kill_urb(acm->ctrlurb);
1342 for (i = 0; i < ACM_NW; i++)
1343 usb_kill_urb(acm->wb[i].urb);
1344 for (i = 0; i < acm->rx_buflimit; i++)
1345 usb_kill_urb(acm->read_urbs[i]);
1347 cancel_work_sync(&acm->work);
1350 static void acm_disconnect(struct usb_interface *intf)
1352 struct acm *acm = usb_get_intfdata(intf);
1353 struct usb_device *usb_dev = interface_to_usbdev(intf);
1354 struct tty_struct *tty;
1356 /* sibling interface is already cleaning up */
1360 mutex_lock(&open_mutex);
1361 if (acm->country_codes) {
1362 device_remove_file(&acm->control->dev,
1363 &dev_attr_wCountryCodes);
1364 device_remove_file(&acm->control->dev,
1365 &dev_attr_iCountryCodeRelDate);
1367 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1369 usb_set_intfdata(acm->control, NULL);
1370 usb_set_intfdata(acm->data, NULL);
1372 stop_data_traffic(acm);
1374 acm_write_buffers_free(acm);
1375 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1377 acm_read_buffers_free(acm);
1379 if (!acm->combined_interfaces)
1380 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1381 acm->data : acm->control);
1383 if (acm->port.count == 0) {
1384 acm_tty_unregister(acm);
1385 mutex_unlock(&open_mutex);
1389 mutex_unlock(&open_mutex);
1390 tty = tty_port_tty_get(&acm->port);
1398 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1400 struct acm *acm = usb_get_intfdata(intf);
1403 spin_lock_irq(&acm->read_lock);
1404 spin_lock(&acm->write_lock);
1405 if (PMSG_IS_AUTO(message)) {
1406 if (acm->transmitting) {
1407 spin_unlock(&acm->write_lock);
1408 spin_unlock_irq(&acm->read_lock);
1412 cnt = acm->susp_count++;
1413 spin_unlock(&acm->write_lock);
1414 spin_unlock_irq(&acm->read_lock);
1419 we treat opened interfaces differently,
1420 we must guard against open
1422 mutex_lock(&acm->mutex);
1424 if (acm->port.count)
1425 stop_data_traffic(acm);
1427 mutex_unlock(&acm->mutex);
1431 static int acm_resume(struct usb_interface *intf)
1433 struct acm *acm = usb_get_intfdata(intf);
1437 mutex_lock(&acm->mutex);
1438 spin_lock_irq(&acm->read_lock);
1439 spin_lock(&acm->write_lock);
1441 if (--acm->susp_count)
1444 if (acm->port.count) {
1445 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1448 urb = usb_get_from_anchor(&acm->delayed);
1452 acm_start_wb(acm, urb->context);
1456 * delayed error checking because we must
1457 * do the write path at all cost
1462 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1465 spin_unlock(&acm->write_lock);
1466 spin_unlock_irq(&acm->read_lock);
1467 mutex_unlock(&acm->mutex);
1472 static int acm_reset_resume(struct usb_interface *intf)
1474 struct acm *acm = usb_get_intfdata(intf);
1475 struct tty_struct *tty;
1477 mutex_lock(&acm->mutex);
1478 if (acm->port.count) {
1479 tty = tty_port_tty_get(&acm->port);
1485 mutex_unlock(&acm->mutex);
1486 return acm_resume(intf);
1489 #endif /* CONFIG_PM */
1491 #define NOKIA_PCSUITE_ACM_INFO(x) \
1492 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1493 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1494 USB_CDC_ACM_PROTO_VENDOR)
1496 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1497 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1498 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1499 USB_CDC_ACM_PROTO_VENDOR)
1502 * USB driver structure.
1505 static const struct usb_device_id acm_ids[] = {
1506 /* quirky and broken devices */
1507 { USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1508 .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1509 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1510 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1512 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1513 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1515 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1516 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1518 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1519 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1521 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1522 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1524 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1525 .driver_info = SINGLE_RX_URB,
1527 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1528 .driver_info = SINGLE_RX_URB, /* firmware bug */
1530 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1531 .driver_info = SINGLE_RX_URB, /* firmware bug */
1533 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1534 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1536 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1537 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1539 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1540 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1542 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1543 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1545 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1546 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1548 { USB_DEVICE(0x2184, 0x001c) }, /* GW Instek AFG-2225 */
1549 { USB_DEVICE(0x2184, 0x0036) }, /* GW Instek AFG-125 */
1550 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1552 /* Motorola H24 HSPA module: */
1553 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1554 { USB_DEVICE(0x22b8, 0x2d92), /* modem + diagnostics */
1555 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1557 { USB_DEVICE(0x22b8, 0x2d93), /* modem + AT port */
1558 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1560 { USB_DEVICE(0x22b8, 0x2d95), /* modem + AT port + diagnostics */
1561 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1563 { USB_DEVICE(0x22b8, 0x2d96), /* modem + NMEA */
1564 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1566 { USB_DEVICE(0x22b8, 0x2d97), /* modem + diagnostics + NMEA */
1567 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1569 { USB_DEVICE(0x22b8, 0x2d99), /* modem + AT port + NMEA */
1570 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1572 { USB_DEVICE(0x22b8, 0x2d9a), /* modem + AT port + diagnostics + NMEA */
1573 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1576 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1577 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1578 data interface instead of
1579 communications interface.
1580 Maybe we should define a new
1583 { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1584 .driver_info = NO_UNION_NORMAL,
1586 { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1587 .driver_info = NO_UNION_NORMAL,
1589 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1590 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1592 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1593 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1595 { USB_DEVICE(0xfff0, 0x0100), /* DATECS FP-2000 */
1596 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1598 { USB_DEVICE(0x09d8, 0x0320), /* Elatec GmbH TWN3 */
1599 .driver_info = NO_UNION_NORMAL, /* has misplaced union descriptor */
1602 { USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */
1603 .driver_info = CLEAR_HALT_CONDITIONS,
1606 /* Nokia S60 phones expose two ACM channels. The first is
1607 * a modem and is picked up by the standard AT-command
1608 * information below. The second is 'vendor-specific' but
1609 * is treated as a serial device at the S60 end, so we want
1610 * to expose it on Linux too. */
1611 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1612 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1613 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1615 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1616 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1617 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1619 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1620 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1621 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1622 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1623 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1624 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1625 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1626 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1627 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1628 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1629 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1630 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1631 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1632 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1633 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1634 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1635 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1636 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1637 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1638 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1639 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1640 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1641 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1642 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1643 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1644 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1645 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1646 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1647 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1648 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1649 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1650 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1651 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1652 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1653 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1654 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1655 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1656 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1657 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1658 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1659 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1660 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1661 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1662 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1663 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1664 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1665 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1666 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1667 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1668 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1670 /* Support for Owen devices */
1671 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1673 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1675 /* Support Lego NXT using pbLua firmware */
1676 { USB_DEVICE(0x0694, 0xff00),
1677 .driver_info = NOT_A_MODEM,
1680 /* Support for Droids MuIn LCD */
1681 { USB_DEVICE(0x04d8, 0x000b),
1682 .driver_info = NO_DATA_INTERFACE,
1685 /*Samsung phone in firmware update mode */
1686 { USB_DEVICE(0x04e8, 0x685d),
1687 .driver_info = IGNORE_DEVICE,
1690 /* Exclude Infineon Flash Loader utility */
1691 { USB_DEVICE(0x058b, 0x0041),
1692 .driver_info = IGNORE_DEVICE,
1695 /* control interfaces without any protocol set */
1696 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1697 USB_CDC_PROTO_NONE) },
1699 /* control interfaces with various AT-command sets */
1700 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1701 USB_CDC_ACM_PROTO_AT_V25TER) },
1702 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1703 USB_CDC_ACM_PROTO_AT_PCCA101) },
1704 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1705 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1706 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1707 USB_CDC_ACM_PROTO_AT_GSM) },
1708 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1709 USB_CDC_ACM_PROTO_AT_3G) },
1710 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1711 USB_CDC_ACM_PROTO_AT_CDMA) },
1713 { USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */
1714 .driver_info = SEND_ZERO_PACKET,
1720 MODULE_DEVICE_TABLE(usb, acm_ids);
1722 static struct usb_driver acm_driver = {
1725 .disconnect = acm_disconnect,
1727 .suspend = acm_suspend,
1728 .resume = acm_resume,
1729 .reset_resume = acm_reset_resume,
1731 .id_table = acm_ids,
1733 .supports_autosuspend = 1,
1738 * TTY driver structures.
1741 static const struct tty_operations acm_ops = {
1742 .open = acm_tty_open,
1743 .close = acm_tty_close,
1744 .hangup = acm_tty_hangup,
1745 .write = acm_tty_write,
1746 .write_room = acm_tty_write_room,
1747 .ioctl = acm_tty_ioctl,
1748 .throttle = acm_tty_throttle,
1749 .unthrottle = acm_tty_unthrottle,
1750 .chars_in_buffer = acm_tty_chars_in_buffer,
1751 .break_ctl = acm_tty_break_ctl,
1752 .set_termios = acm_tty_set_termios,
1753 .tiocmget = acm_tty_tiocmget,
1754 .tiocmset = acm_tty_tiocmset,
1761 static int __init acm_init(void)
1764 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1765 if (!acm_tty_driver)
1767 acm_tty_driver->owner = THIS_MODULE,
1768 acm_tty_driver->driver_name = "acm",
1769 acm_tty_driver->name = "ttyACM",
1770 acm_tty_driver->major = ACM_TTY_MAJOR,
1771 acm_tty_driver->minor_start = 0,
1772 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1773 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1774 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1775 acm_tty_driver->init_termios = tty_std_termios;
1776 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1778 tty_set_operations(acm_tty_driver, &acm_ops);
1780 retval = tty_register_driver(acm_tty_driver);
1782 put_tty_driver(acm_tty_driver);
1786 retval = usb_register(&acm_driver);
1788 tty_unregister_driver(acm_tty_driver);
1789 put_tty_driver(acm_tty_driver);
1793 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1798 static void __exit acm_exit(void)
1800 usb_deregister(&acm_driver);
1801 tty_unregister_driver(acm_tty_driver);
1802 put_tty_driver(acm_tty_driver);
1805 module_init(acm_init);
1806 module_exit(acm_exit);
1808 MODULE_AUTHOR(DRIVER_AUTHOR);
1809 MODULE_DESCRIPTION(DRIVER_DESC);
1810 MODULE_LICENSE("GPL");
1811 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);