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,
75 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
76 request, USB_RT_ACM, value,
77 acm->control->altsetting[0].desc.bInterfaceNumber,
79 dev_dbg(&acm->control->dev,
80 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
81 __func__, request, value, len, retval);
82 return retval < 0 ? retval : 0;
85 /* devices aren't required to support these requests.
86 * the cdc acm descriptor tells whether they do...
88 #define acm_set_control(acm, control) \
89 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
90 #define acm_set_line(acm, line) \
91 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
92 #define acm_send_break(acm, ms) \
93 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
96 * Write buffer management.
97 * All of these assume proper locks taken by the caller.
100 static int acm_wb_alloc(struct acm *acm)
113 wbn = (wbn + 1) % ACM_NW;
119 static int acm_wb_is_avail(struct acm *acm)
125 spin_lock_irqsave(&acm->write_lock, flags);
126 for (i = 0; i < ACM_NW; i++)
128 spin_unlock_irqrestore(&acm->write_lock, flags);
133 * Finish write. Caller must hold acm->write_lock
135 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
139 usb_autopm_put_interface_async(acm->control);
145 * the caller is responsible for locking
148 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
154 wb->urb->transfer_buffer = wb->buf;
155 wb->urb->transfer_dma = wb->dmah;
156 wb->urb->transfer_buffer_length = wb->len;
157 wb->urb->dev = acm->dev;
159 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
161 dev_err(&acm->data->dev,
162 "%s - usb_submit_urb(write bulk) failed: %d\n",
164 acm_write_done(acm, wb);
169 static int acm_write_start(struct acm *acm, int wbn)
172 struct acm_wb *wb = &acm->wb[wbn];
175 spin_lock_irqsave(&acm->write_lock, flags);
178 spin_unlock_irqrestore(&acm->write_lock, flags);
182 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
184 usb_autopm_get_interface_async(acm->control);
185 if (acm->susp_count) {
186 if (!acm->delayed_wb)
187 acm->delayed_wb = wb;
189 usb_autopm_put_interface_async(acm->control);
190 spin_unlock_irqrestore(&acm->write_lock, flags);
191 return 0; /* A white lie */
193 usb_mark_last_busy(acm->dev);
195 rc = acm_start_wb(acm, wb);
196 spin_unlock_irqrestore(&acm->write_lock, flags);
202 * attributes exported through sysfs
204 static ssize_t show_caps
205 (struct device *dev, struct device_attribute *attr, char *buf)
207 struct usb_interface *intf = to_usb_interface(dev);
208 struct acm *acm = usb_get_intfdata(intf);
210 return sprintf(buf, "%d", acm->ctrl_caps);
212 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
214 static ssize_t show_country_codes
215 (struct device *dev, struct device_attribute *attr, char *buf)
217 struct usb_interface *intf = to_usb_interface(dev);
218 struct acm *acm = usb_get_intfdata(intf);
220 memcpy(buf, acm->country_codes, acm->country_code_size);
221 return acm->country_code_size;
224 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
226 static ssize_t show_country_rel_date
227 (struct device *dev, struct device_attribute *attr, char *buf)
229 struct usb_interface *intf = to_usb_interface(dev);
230 struct acm *acm = usb_get_intfdata(intf);
232 return sprintf(buf, "%d", acm->country_rel_date);
235 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
237 * Interrupt handlers for various ACM device responses
240 /* control interface reports status changes with "interrupt" transfers */
241 static void acm_ctrl_irq(struct urb *urb)
243 struct acm *acm = urb->context;
244 struct usb_cdc_notification *dr = urb->transfer_buffer;
245 struct tty_struct *tty;
249 int status = urb->status;
258 /* this urb is terminated, clean up */
259 dev_dbg(&acm->control->dev,
260 "%s - urb shutting down with status: %d\n",
264 dev_dbg(&acm->control->dev,
265 "%s - nonzero urb status received: %d\n",
273 usb_mark_last_busy(acm->dev);
275 data = (unsigned char *)(dr + 1);
276 switch (dr->bNotificationType) {
277 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
278 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
279 __func__, dr->wValue);
282 case USB_CDC_NOTIFY_SERIAL_STATE:
283 tty = tty_port_tty_get(&acm->port);
284 newctrl = get_unaligned_le16(data);
288 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
289 dev_dbg(&acm->control->dev,
290 "%s - calling hangup\n", __func__);
296 acm->ctrlin = newctrl;
298 dev_dbg(&acm->control->dev,
299 "%s - input control lines: dcd%c dsr%c break%c "
300 "ring%c framing%c parity%c overrun%c\n",
302 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
303 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
304 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
305 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
306 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
307 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
308 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
312 dev_dbg(&acm->control->dev,
313 "%s - unknown notification %d received: index %d "
314 "len %d data0 %d data1 %d\n",
316 dr->bNotificationType, dr->wIndex,
317 dr->wLength, data[0], data[1]);
321 retval = usb_submit_urb(urb, GFP_ATOMIC);
323 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
327 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
331 if (!test_and_clear_bit(index, &acm->read_urbs_free))
334 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
336 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
339 dev_err(&acm->data->dev,
340 "%s - usb_submit_urb failed: %d\n",
343 set_bit(index, &acm->read_urbs_free);
350 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
355 for (i = 0; i < acm->rx_buflimit; ++i) {
356 res = acm_submit_read_urb(acm, i, mem_flags);
364 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
366 struct tty_struct *tty;
368 if (!urb->actual_length)
371 tty = tty_port_tty_get(&acm->port);
375 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
376 tty_flip_buffer_push(tty);
381 static void acm_read_bulk_callback(struct urb *urb)
383 struct acm_rb *rb = urb->context;
384 struct acm *acm = rb->instance;
387 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
388 rb->index, urb->actual_length);
389 set_bit(rb->index, &acm->read_urbs_free);
392 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
395 usb_mark_last_busy(acm->dev);
398 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
399 __func__, urb->status);
402 acm_process_read_urb(acm, urb);
404 /* throttle device if requested by tty */
405 spin_lock_irqsave(&acm->read_lock, flags);
406 acm->throttled = acm->throttle_req;
407 if (!acm->throttled && !acm->susp_count) {
408 spin_unlock_irqrestore(&acm->read_lock, flags);
409 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
411 spin_unlock_irqrestore(&acm->read_lock, flags);
415 /* data interface wrote those outgoing bytes */
416 static void acm_write_bulk(struct urb *urb)
418 struct acm_wb *wb = urb->context;
419 struct acm *acm = wb->instance;
422 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
423 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
426 urb->transfer_buffer_length,
429 spin_lock_irqsave(&acm->write_lock, flags);
430 acm_write_done(acm, wb);
431 spin_unlock_irqrestore(&acm->write_lock, flags);
433 schedule_work(&acm->work);
436 static void acm_softint(struct work_struct *work)
438 struct acm *acm = container_of(work, struct acm, work);
439 struct tty_struct *tty;
441 dev_vdbg(&acm->data->dev, "%s\n", __func__);
445 tty = tty_port_tty_get(&acm->port);
456 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
461 mutex_lock(&open_mutex);
463 acm = acm_table[tty->index];
464 if (!acm || !acm->dev)
469 dev_dbg(&acm->control->dev, "%s\n", __func__);
471 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
473 tty->driver_data = acm;
474 tty_port_tty_set(&acm->port, tty);
476 if (usb_autopm_get_interface(acm->control) < 0)
479 acm->control->needs_remote_wakeup = 1;
481 mutex_lock(&acm->mutex);
482 if (acm->port.count++) {
483 mutex_unlock(&acm->mutex);
484 usb_autopm_put_interface(acm->control);
488 acm->ctrlurb->dev = acm->dev;
489 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
490 dev_err(&acm->control->dev,
491 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
495 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
496 (acm->ctrl_caps & USB_CDC_CAP_LINE))
499 usb_autopm_put_interface(acm->control);
502 * Unthrottle device in case the TTY was closed while throttled.
504 spin_lock_irq(&acm->read_lock);
506 acm->throttle_req = 0;
507 spin_unlock_irq(&acm->read_lock);
509 if (acm_submit_read_urbs(acm, GFP_KERNEL))
512 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
513 rv = tty_port_block_til_ready(&acm->port, tty, filp);
515 mutex_unlock(&acm->mutex);
517 mutex_unlock(&open_mutex);
522 mutex_unlock(&acm->mutex);
523 usb_autopm_put_interface(acm->control);
525 mutex_unlock(&open_mutex);
526 tty_port_tty_set(&acm->port, NULL);
530 static void acm_tty_unregister(struct acm *acm)
534 tty_unregister_device(acm_tty_driver, acm->minor);
535 usb_put_intf(acm->control);
536 acm_table[acm->minor] = NULL;
537 usb_free_urb(acm->ctrlurb);
538 for (i = 0; i < ACM_NW; i++)
539 usb_free_urb(acm->wb[i].urb);
540 for (i = 0; i < acm->rx_buflimit; i++)
541 usb_free_urb(acm->read_urbs[i]);
542 kfree(acm->country_codes);
546 static void acm_port_down(struct acm *acm)
551 usb_autopm_get_interface(acm->control);
552 acm_set_control(acm, acm->ctrlout = 0);
553 usb_kill_urb(acm->ctrlurb);
554 for (i = 0; i < ACM_NW; i++)
555 usb_kill_urb(acm->wb[i].urb);
556 for (i = 0; i < acm->rx_buflimit; i++)
557 usb_kill_urb(acm->read_urbs[i]);
558 acm->control->needs_remote_wakeup = 0;
559 usb_autopm_put_interface(acm->control);
563 static void acm_tty_hangup(struct tty_struct *tty)
567 mutex_lock(&open_mutex);
568 acm = tty->driver_data;
573 tty_port_hangup(&acm->port);
577 mutex_unlock(&open_mutex);
580 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
582 struct acm *acm = tty->driver_data;
584 /* Perform the closing process and see if we need to do the hardware
589 mutex_lock(&open_mutex);
590 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
592 tty_port_tty_set(&acm->port, NULL);
593 acm_tty_unregister(acm);
594 tty->driver_data = NULL;
596 mutex_unlock(&open_mutex);
600 tty_port_close_end(&acm->port, tty);
601 tty_port_tty_set(&acm->port, NULL);
602 mutex_unlock(&open_mutex);
605 static int acm_tty_write(struct tty_struct *tty,
606 const unsigned char *buf, int count)
608 struct acm *acm = tty->driver_data;
619 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
621 spin_lock_irqsave(&acm->write_lock, flags);
622 wbn = acm_wb_alloc(acm);
624 spin_unlock_irqrestore(&acm->write_lock, flags);
629 count = (count > acm->writesize) ? acm->writesize : count;
630 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
631 memcpy(wb->buf, buf, count);
633 spin_unlock_irqrestore(&acm->write_lock, flags);
635 stat = acm_write_start(acm, wbn);
641 static int acm_tty_write_room(struct tty_struct *tty)
643 struct acm *acm = tty->driver_data;
647 * Do not let the line discipline to know that we have a reserve,
648 * or it might get too enthusiastic.
650 return acm_wb_is_avail(acm) ? acm->writesize : 0;
653 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
655 struct acm *acm = tty->driver_data;
659 * This is inaccurate (overcounts), but it works.
661 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
664 static void acm_tty_throttle(struct tty_struct *tty)
666 struct acm *acm = tty->driver_data;
671 spin_lock_irq(&acm->read_lock);
672 acm->throttle_req = 1;
673 spin_unlock_irq(&acm->read_lock);
676 static void acm_tty_unthrottle(struct tty_struct *tty)
678 struct acm *acm = tty->driver_data;
679 unsigned int was_throttled;
684 spin_lock_irq(&acm->read_lock);
685 was_throttled = acm->throttled;
687 acm->throttle_req = 0;
688 spin_unlock_irq(&acm->read_lock);
691 acm_submit_read_urbs(acm, GFP_KERNEL);
694 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
696 struct acm *acm = tty->driver_data;
700 retval = acm_send_break(acm, state ? 0xffff : 0);
702 dev_dbg(&acm->control->dev, "%s - send break failed\n",
707 static int acm_tty_tiocmget(struct tty_struct *tty)
709 struct acm *acm = tty->driver_data;
714 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
715 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
716 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
717 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
718 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
722 static int acm_tty_tiocmset(struct tty_struct *tty,
723 unsigned int set, unsigned int clear)
725 struct acm *acm = tty->driver_data;
726 unsigned int newctrl;
731 newctrl = acm->ctrlout;
732 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
733 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
734 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
735 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
737 newctrl = (newctrl & ~clear) | set;
739 if (acm->ctrlout == newctrl)
741 return acm_set_control(acm, acm->ctrlout = newctrl);
744 static int acm_tty_ioctl(struct tty_struct *tty,
745 unsigned int cmd, unsigned long arg)
747 struct acm *acm = tty->driver_data;
755 static const __u32 acm_tty_speed[] = {
756 0, 50, 75, 110, 134, 150, 200, 300, 600,
757 1200, 1800, 2400, 4800, 9600, 19200, 38400,
758 57600, 115200, 230400, 460800, 500000, 576000,
759 921600, 1000000, 1152000, 1500000, 2000000,
760 2500000, 3000000, 3500000, 4000000
763 static const __u8 acm_tty_size[] = {
767 static void acm_tty_set_termios(struct tty_struct *tty,
768 struct ktermios *termios_old)
770 struct acm *acm = tty->driver_data;
771 struct ktermios *termios = tty->termios;
772 struct usb_cdc_line_coding newline;
773 int newctrl = acm->ctrlout;
778 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
779 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
780 newline.bParityType = termios->c_cflag & PARENB ?
781 (termios->c_cflag & PARODD ? 1 : 2) +
782 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
783 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
784 /* FIXME: Needs to clear unsupported bits in the termios */
785 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
787 if (!newline.dwDTERate) {
788 newline.dwDTERate = acm->line.dwDTERate;
789 newctrl &= ~ACM_CTRL_DTR;
791 newctrl |= ACM_CTRL_DTR;
793 if (newctrl != acm->ctrlout)
794 acm_set_control(acm, acm->ctrlout = newctrl);
796 if (memcmp(&acm->line, &newline, sizeof newline)) {
797 memcpy(&acm->line, &newline, sizeof newline);
798 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
800 le32_to_cpu(newline.dwDTERate),
801 newline.bCharFormat, newline.bParityType,
803 acm_set_line(acm, &acm->line);
808 * USB probe and disconnect routines.
811 /* Little helpers: write/read buffers free */
812 static void acm_write_buffers_free(struct acm *acm)
816 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
818 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
819 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
822 static void acm_read_buffers_free(struct acm *acm)
824 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
827 for (i = 0; i < acm->rx_buflimit; i++)
828 usb_free_coherent(usb_dev, acm->readsize,
829 acm->read_buffers[i].base, acm->read_buffers[i].dma);
832 /* Little helper: write buffers allocate */
833 static int acm_write_buffers_alloc(struct acm *acm)
838 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
839 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
845 usb_free_coherent(acm->dev, acm->writesize,
854 static int acm_probe(struct usb_interface *intf,
855 const struct usb_device_id *id)
857 struct usb_cdc_union_desc *union_header = NULL;
858 struct usb_cdc_country_functional_desc *cfd = NULL;
859 unsigned char *buffer = intf->altsetting->extra;
860 int buflen = intf->altsetting->extralen;
861 struct usb_interface *control_interface;
862 struct usb_interface *data_interface;
863 struct usb_endpoint_descriptor *epctrl = NULL;
864 struct usb_endpoint_descriptor *epread = NULL;
865 struct usb_endpoint_descriptor *epwrite = NULL;
866 struct usb_device *usb_dev = interface_to_usbdev(intf);
869 int ctrlsize, readsize;
871 u8 ac_management_function = 0;
872 u8 call_management_function = 0;
873 int call_interface_num = -1;
874 int data_interface_num = -1;
875 unsigned long quirks;
878 int combined_interfaces = 0;
881 quirks = (unsigned long)id->driver_info;
882 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
884 /* handle quirks deadly to normal probing*/
885 if (quirks == NO_UNION_NORMAL) {
886 data_interface = usb_ifnum_to_if(usb_dev, 1);
887 control_interface = usb_ifnum_to_if(usb_dev, 0);
888 goto skip_normal_probe;
893 dev_err(&intf->dev, "Weird descriptor references\n");
898 if (intf->cur_altsetting->endpoint &&
899 intf->cur_altsetting->endpoint->extralen &&
900 intf->cur_altsetting->endpoint->extra) {
902 "Seeking extra descriptors on endpoint\n");
903 buflen = intf->cur_altsetting->endpoint->extralen;
904 buffer = intf->cur_altsetting->endpoint->extra;
907 "Zero length descriptor references\n");
913 if (buffer[1] != USB_DT_CS_INTERFACE) {
914 dev_err(&intf->dev, "skipping garbage\n");
919 case USB_CDC_UNION_TYPE: /* we've found it */
921 dev_err(&intf->dev, "More than one "
922 "union descriptor, skipping ...\n");
925 union_header = (struct usb_cdc_union_desc *)buffer;
927 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
928 cfd = (struct usb_cdc_country_functional_desc *)buffer;
930 case USB_CDC_HEADER_TYPE: /* maybe check version */
931 break; /* for now we ignore it */
932 case USB_CDC_ACM_TYPE:
933 ac_management_function = buffer[3];
935 case USB_CDC_CALL_MANAGEMENT_TYPE:
936 call_management_function = buffer[3];
937 call_interface_num = buffer[4];
938 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
939 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
942 /* there are LOTS more CDC descriptors that
943 * could legitimately be found here.
945 dev_dbg(&intf->dev, "Ignoring descriptor: "
946 "type %02x, length %d\n",
947 buffer[2], buffer[0]);
956 if (call_interface_num > 0) {
957 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
958 /* quirks for Droids MuIn LCD */
959 if (quirks & NO_DATA_INTERFACE)
960 data_interface = usb_ifnum_to_if(usb_dev, 0);
962 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
963 control_interface = intf;
965 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
966 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
969 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
970 combined_interfaces = 1;
971 control_interface = data_interface = intf;
972 goto look_for_collapsed_interface;
976 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
977 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
978 if (!control_interface || !data_interface) {
979 dev_dbg(&intf->dev, "no interfaces\n");
984 if (data_interface_num != call_interface_num)
985 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
987 if (control_interface == data_interface) {
988 /* some broken devices designed for windows work this way */
989 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
990 combined_interfaces = 1;
991 /* a popular other OS doesn't use it */
992 quirks |= NO_CAP_LINE;
993 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
994 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
997 look_for_collapsed_interface:
998 for (i = 0; i < 3; i++) {
999 struct usb_endpoint_descriptor *ep;
1000 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1002 if (usb_endpoint_is_int_in(ep))
1004 else if (usb_endpoint_is_bulk_out(ep))
1006 else if (usb_endpoint_is_bulk_in(ep))
1011 if (!epctrl || !epread || !epwrite)
1014 goto made_compressed_probe;
1019 /*workaround for switched interfaces */
1020 if (data_interface->cur_altsetting->desc.bInterfaceClass
1021 != CDC_DATA_INTERFACE_TYPE) {
1022 if (control_interface->cur_altsetting->desc.bInterfaceClass
1023 == CDC_DATA_INTERFACE_TYPE) {
1024 struct usb_interface *t;
1026 "Your device has switched interfaces.\n");
1027 t = control_interface;
1028 control_interface = data_interface;
1035 /* Accept probe requests only for the control interface */
1036 if (!combined_interfaces && intf != control_interface)
1039 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1040 /* valid in this context */
1041 dev_dbg(&intf->dev, "The data interface isn't available\n");
1046 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1047 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1050 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1051 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1052 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1055 /* workaround for switched endpoints */
1056 if (!usb_endpoint_dir_in(epread)) {
1057 /* descriptors are swapped */
1058 struct usb_endpoint_descriptor *t;
1060 "The data interface has switched endpoints\n");
1065 made_compressed_probe:
1066 dev_dbg(&intf->dev, "interfaces are valid\n");
1067 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1069 if (minor == ACM_TTY_MINORS) {
1070 dev_err(&intf->dev, "no more free acm devices\n");
1074 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1076 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1080 ctrlsize = usb_endpoint_maxp(epctrl);
1081 readsize = usb_endpoint_maxp(epread) *
1082 (quirks == SINGLE_RX_URB ? 1 : 2);
1083 acm->combined_interfaces = combined_interfaces;
1084 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1085 acm->control = control_interface;
1086 acm->data = data_interface;
1089 acm->ctrl_caps = ac_management_function;
1090 if (quirks & NO_CAP_LINE)
1091 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1092 acm->ctrlsize = ctrlsize;
1093 acm->readsize = readsize;
1094 acm->rx_buflimit = num_rx_buf;
1095 INIT_WORK(&acm->work, acm_softint);
1096 spin_lock_init(&acm->write_lock);
1097 spin_lock_init(&acm->read_lock);
1098 mutex_init(&acm->mutex);
1099 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1100 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1102 acm->bInterval = epread->bInterval;
1103 tty_port_init(&acm->port);
1104 acm->port.ops = &acm_port_ops;
1106 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1108 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1111 acm->ctrl_buffer = buf;
1113 if (acm_write_buffers_alloc(acm) < 0) {
1114 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1118 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1119 if (!acm->ctrlurb) {
1120 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1123 for (i = 0; i < num_rx_buf; i++) {
1124 struct acm_rb *rb = &(acm->read_buffers[i]);
1127 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1130 dev_err(&intf->dev, "out of memory "
1131 "(read bufs usb_alloc_coherent)\n");
1137 urb = usb_alloc_urb(0, GFP_KERNEL);
1140 "out of memory (read urbs usb_alloc_urb)\n");
1143 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1144 urb->transfer_dma = rb->dma;
1145 if (acm->is_int_ep) {
1146 usb_fill_int_urb(urb, acm->dev,
1150 acm_read_bulk_callback, rb,
1153 usb_fill_bulk_urb(urb, acm->dev,
1157 acm_read_bulk_callback, rb);
1160 acm->read_urbs[i] = urb;
1161 __set_bit(i, &acm->read_urbs_free);
1163 for (i = 0; i < ACM_NW; i++) {
1164 struct acm_wb *snd = &(acm->wb[i]);
1166 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1167 if (snd->urb == NULL) {
1169 "out of memory (write urbs usb_alloc_urb)\n");
1173 if (usb_endpoint_xfer_int(epwrite))
1174 usb_fill_int_urb(snd->urb, usb_dev,
1175 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1176 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1178 usb_fill_bulk_urb(snd->urb, usb_dev,
1179 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1180 NULL, acm->writesize, acm_write_bulk, snd);
1181 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1182 snd->instance = acm;
1185 usb_set_intfdata(intf, acm);
1187 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1191 if (cfd) { /* export the country data */
1192 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1193 if (!acm->country_codes)
1194 goto skip_countries;
1195 acm->country_code_size = cfd->bLength - 4;
1196 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1198 acm->country_rel_date = cfd->iCountryCodeRelDate;
1200 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1202 kfree(acm->country_codes);
1203 acm->country_codes = NULL;
1204 acm->country_code_size = 0;
1205 goto skip_countries;
1208 i = device_create_file(&intf->dev,
1209 &dev_attr_iCountryCodeRelDate);
1211 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1212 kfree(acm->country_codes);
1213 acm->country_codes = NULL;
1214 acm->country_code_size = 0;
1215 goto skip_countries;
1220 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1221 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1222 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1223 /* works around buggy devices */
1224 epctrl->bInterval ? epctrl->bInterval : 0xff);
1225 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1226 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1228 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1230 acm_set_control(acm, acm->ctrlout);
1232 acm->line.dwDTERate = cpu_to_le32(9600);
1233 acm->line.bDataBits = 8;
1234 acm_set_line(acm, &acm->line);
1236 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1237 usb_set_intfdata(data_interface, acm);
1239 usb_get_intf(control_interface);
1240 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1242 acm_table[minor] = acm;
1246 for (i = 0; i < ACM_NW; i++)
1247 usb_free_urb(acm->wb[i].urb);
1249 for (i = 0; i < num_rx_buf; i++)
1250 usb_free_urb(acm->read_urbs[i]);
1251 acm_read_buffers_free(acm);
1252 usb_free_urb(acm->ctrlurb);
1254 acm_write_buffers_free(acm);
1256 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1263 static void stop_data_traffic(struct acm *acm)
1267 dev_dbg(&acm->control->dev, "%s\n", __func__);
1269 usb_kill_urb(acm->ctrlurb);
1270 for (i = 0; i < ACM_NW; i++)
1271 usb_kill_urb(acm->wb[i].urb);
1272 for (i = 0; i < acm->rx_buflimit; i++)
1273 usb_kill_urb(acm->read_urbs[i]);
1275 cancel_work_sync(&acm->work);
1278 static void acm_disconnect(struct usb_interface *intf)
1280 struct acm *acm = usb_get_intfdata(intf);
1281 struct usb_device *usb_dev = interface_to_usbdev(intf);
1282 struct tty_struct *tty;
1284 /* sibling interface is already cleaning up */
1288 mutex_lock(&open_mutex);
1289 if (acm->country_codes) {
1290 device_remove_file(&acm->control->dev,
1291 &dev_attr_wCountryCodes);
1292 device_remove_file(&acm->control->dev,
1293 &dev_attr_iCountryCodeRelDate);
1295 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1297 usb_set_intfdata(acm->control, NULL);
1298 usb_set_intfdata(acm->data, NULL);
1300 stop_data_traffic(acm);
1302 acm_write_buffers_free(acm);
1303 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1305 acm_read_buffers_free(acm);
1307 if (!acm->combined_interfaces)
1308 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1309 acm->data : acm->control);
1311 if (acm->port.count == 0) {
1312 acm_tty_unregister(acm);
1313 mutex_unlock(&open_mutex);
1317 mutex_unlock(&open_mutex);
1318 tty = tty_port_tty_get(&acm->port);
1326 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1328 struct acm *acm = usb_get_intfdata(intf);
1331 if (PMSG_IS_AUTO(message)) {
1334 spin_lock_irq(&acm->write_lock);
1335 b = acm->transmitting;
1336 spin_unlock_irq(&acm->write_lock);
1341 spin_lock_irq(&acm->read_lock);
1342 spin_lock(&acm->write_lock);
1343 cnt = acm->susp_count++;
1344 spin_unlock(&acm->write_lock);
1345 spin_unlock_irq(&acm->read_lock);
1350 we treat opened interfaces differently,
1351 we must guard against open
1353 mutex_lock(&acm->mutex);
1355 if (acm->port.count)
1356 stop_data_traffic(acm);
1358 mutex_unlock(&acm->mutex);
1362 static int acm_resume(struct usb_interface *intf)
1364 struct acm *acm = usb_get_intfdata(intf);
1369 spin_lock_irq(&acm->read_lock);
1370 acm->susp_count -= 1;
1371 cnt = acm->susp_count;
1372 spin_unlock_irq(&acm->read_lock);
1377 mutex_lock(&acm->mutex);
1378 if (acm->port.count) {
1379 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1381 spin_lock_irq(&acm->write_lock);
1382 if (acm->delayed_wb) {
1383 wb = acm->delayed_wb;
1384 acm->delayed_wb = NULL;
1385 spin_unlock_irq(&acm->write_lock);
1386 acm_start_wb(acm, wb);
1388 spin_unlock_irq(&acm->write_lock);
1392 * delayed error checking because we must
1393 * do the write path at all cost
1398 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1402 mutex_unlock(&acm->mutex);
1406 static int acm_reset_resume(struct usb_interface *intf)
1408 struct acm *acm = usb_get_intfdata(intf);
1409 struct tty_struct *tty;
1411 mutex_lock(&acm->mutex);
1412 if (acm->port.count) {
1413 tty = tty_port_tty_get(&acm->port);
1419 mutex_unlock(&acm->mutex);
1420 return acm_resume(intf);
1423 #endif /* CONFIG_PM */
1425 #define NOKIA_PCSUITE_ACM_INFO(x) \
1426 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1427 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1428 USB_CDC_ACM_PROTO_VENDOR)
1430 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1431 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1432 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1433 USB_CDC_ACM_PROTO_VENDOR)
1436 * USB driver structure.
1439 static const struct usb_device_id acm_ids[] = {
1440 /* quirky and broken devices */
1441 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1442 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1444 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1445 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1447 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1448 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1450 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1451 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1453 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1454 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1456 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1457 .driver_info = SINGLE_RX_URB,
1459 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1460 .driver_info = SINGLE_RX_URB, /* firmware bug */
1462 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1463 .driver_info = SINGLE_RX_URB, /* firmware bug */
1465 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1466 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1468 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1469 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1471 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1472 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1474 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1475 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1477 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1478 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1480 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1482 /* Motorola H24 HSPA module: */
1483 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1484 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1485 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1486 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1487 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1488 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1489 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1490 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1492 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1493 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1494 data interface instead of
1495 communications interface.
1496 Maybe we should define a new
1499 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1500 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1502 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1503 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1506 /* Nokia S60 phones expose two ACM channels. The first is
1507 * a modem and is picked up by the standard AT-command
1508 * information below. The second is 'vendor-specific' but
1509 * is treated as a serial device at the S60 end, so we want
1510 * to expose it on Linux too. */
1511 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1512 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1513 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1514 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1515 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1516 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1517 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1518 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1519 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1520 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1521 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1522 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1523 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1524 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1525 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1526 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1527 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1528 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1529 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1530 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1531 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1532 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1533 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1534 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1535 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1536 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1537 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1538 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1539 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1540 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1541 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1542 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1543 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1544 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1545 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1546 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1547 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1548 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1549 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1550 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1551 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1552 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1553 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1556 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1558 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1561 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1562 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1563 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1568 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1570 /* Support for Owen devices */
1571 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1573 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1575 /* Support Lego NXT using pbLua firmware */
1576 { USB_DEVICE(0x0694, 0xff00),
1577 .driver_info = NOT_A_MODEM,
1580 /* Support for Droids MuIn LCD */
1581 { USB_DEVICE(0x04d8, 0x000b),
1582 .driver_info = NO_DATA_INTERFACE,
1585 /* control interfaces without any protocol set */
1586 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1587 USB_CDC_PROTO_NONE) },
1589 /* control interfaces with various AT-command sets */
1590 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1591 USB_CDC_ACM_PROTO_AT_V25TER) },
1592 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1593 USB_CDC_ACM_PROTO_AT_PCCA101) },
1594 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1595 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1596 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1597 USB_CDC_ACM_PROTO_AT_GSM) },
1598 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1599 USB_CDC_ACM_PROTO_AT_3G) },
1600 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1601 USB_CDC_ACM_PROTO_AT_CDMA) },
1606 MODULE_DEVICE_TABLE(usb, acm_ids);
1608 static struct usb_driver acm_driver = {
1611 .disconnect = acm_disconnect,
1613 .suspend = acm_suspend,
1614 .resume = acm_resume,
1615 .reset_resume = acm_reset_resume,
1617 .id_table = acm_ids,
1619 .supports_autosuspend = 1,
1624 * TTY driver structures.
1627 static const struct tty_operations acm_ops = {
1628 .open = acm_tty_open,
1629 .close = acm_tty_close,
1630 .hangup = acm_tty_hangup,
1631 .write = acm_tty_write,
1632 .write_room = acm_tty_write_room,
1633 .ioctl = acm_tty_ioctl,
1634 .throttle = acm_tty_throttle,
1635 .unthrottle = acm_tty_unthrottle,
1636 .chars_in_buffer = acm_tty_chars_in_buffer,
1637 .break_ctl = acm_tty_break_ctl,
1638 .set_termios = acm_tty_set_termios,
1639 .tiocmget = acm_tty_tiocmget,
1640 .tiocmset = acm_tty_tiocmset,
1647 static int __init acm_init(void)
1650 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1651 if (!acm_tty_driver)
1653 acm_tty_driver->owner = THIS_MODULE,
1654 acm_tty_driver->driver_name = "acm",
1655 acm_tty_driver->name = "ttyACM",
1656 acm_tty_driver->major = ACM_TTY_MAJOR,
1657 acm_tty_driver->minor_start = 0,
1658 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1659 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1660 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1661 acm_tty_driver->init_termios = tty_std_termios;
1662 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1664 tty_set_operations(acm_tty_driver, &acm_ops);
1666 retval = tty_register_driver(acm_tty_driver);
1668 put_tty_driver(acm_tty_driver);
1672 retval = usb_register(&acm_driver);
1674 tty_unregister_driver(acm_tty_driver);
1675 put_tty_driver(acm_tty_driver);
1679 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1684 static void __exit acm_exit(void)
1686 usb_deregister(&acm_driver);
1687 tty_unregister_driver(acm_tty_driver);
1688 put_tty_driver(acm_tty_driver);
1691 module_init(acm_init);
1692 module_exit(acm_exit);
1694 MODULE_AUTHOR(DRIVER_AUTHOR);
1695 MODULE_DESCRIPTION(DRIVER_DESC);
1696 MODULE_LICENSE("GPL");
1697 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);