4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@suse.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>
11 * USB Abstract Control Model driver for USB modems and ISDN adapters
16 * v0.9 - thorough cleaning, URBification, almost a rewrite
17 * v0.10 - some more cleanups
18 * v0.11 - fixed flow control, read error doesn't stop reads
19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
20 * v0.13 - added termios, added hangup
21 * v0.14 - sized down struct acm
22 * v0.15 - fixed flow control again - characters could be lost
23 * v0.16 - added code for modems with swapped data and control interfaces
24 * v0.17 - added new style probing
25 * v0.18 - fixed new style probing for devices with more configurations
26 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
27 * v0.20 - switched to probing on interface (rather than device) class
28 * v0.21 - revert to probing on device for devices with multiple configs
29 * v0.22 - probe only the control interface. if usbcore doesn't choose the
30 * config we want, sysadmin changes bConfigurationValue in sysfs.
31 * v0.23 - use softirq for rx processing, as needed by tty layer
32 * v0.24 - change probe method to evaluate CDC union descriptor
33 * v0.25 - downstream tasks paralelized to maximize throughput
37 * This program is free software; you can redistribute it and/or modify
38 * it under the terms of the GNU General Public License as published by
39 * the Free Software Foundation; either version 2 of the License, or
40 * (at your option) any later version.
42 * This program is distributed in the hope that it will be useful,
43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 * GNU General Public License for more details.
47 * You should have received a copy of the GNU General Public License
48 * along with this program; if not, write to the Free Software
49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
54 #include <linux/kernel.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/tty.h>
59 #include <linux/tty_driver.h>
60 #include <linux/tty_flip.h>
61 #include <linux/module.h>
62 #include <linux/smp_lock.h>
63 #include <linux/mutex.h>
64 #include <asm/uaccess.h>
65 #include <linux/usb.h>
66 #include <linux/usb/cdc.h>
67 #include <asm/byteorder.h>
68 #include <asm/unaligned.h>
69 #include <linux/list.h>
76 #define DRIVER_VERSION "v0.25"
77 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
78 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
80 static struct usb_driver acm_driver;
81 static struct tty_driver *acm_tty_driver;
82 static struct acm *acm_table[ACM_TTY_MINORS];
84 static DEFINE_MUTEX(open_mutex);
86 #define ACM_READY(acm) (acm && acm->dev && acm->used)
89 * Functions for ACM control messages.
92 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
94 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
95 request, USB_RT_ACM, value,
96 acm->control->altsetting[0].desc.bInterfaceNumber,
98 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
99 return retval < 0 ? retval : 0;
102 /* devices aren't required to support these requests.
103 * the cdc acm descriptor tells whether they do...
105 #define acm_set_control(acm, control) \
106 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
107 #define acm_set_line(acm, line) \
108 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
109 #define acm_send_break(acm, ms) \
110 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
113 * Write buffer management.
114 * All of these assume proper locks taken by the caller.
117 static int acm_wb_alloc(struct acm *acm)
122 wbn = acm->write_current;
130 wbn = (wbn + 1) % ACM_NW;
136 static void acm_wb_free(struct acm *acm, int wbn)
138 acm->wb[wbn].use = 0;
141 static int acm_wb_is_avail(struct acm *acm)
146 for (i = 0; i < ACM_NW; i++) {
152 static inline int acm_wb_is_used(struct acm *acm, int wbn)
154 return acm->wb[wbn].use;
160 static void acm_write_done(struct acm *acm)
165 spin_lock_irqsave(&acm->write_lock, flags);
166 acm->write_ready = 1;
167 wbn = acm->write_current;
168 acm_wb_free(acm, wbn);
169 acm->write_current = (wbn + 1) % ACM_NW;
170 spin_unlock_irqrestore(&acm->write_lock, flags);
176 static int acm_write_start(struct acm *acm)
183 spin_lock_irqsave(&acm->write_lock, flags);
185 spin_unlock_irqrestore(&acm->write_lock, flags);
189 if (!acm->write_ready) {
190 spin_unlock_irqrestore(&acm->write_lock, flags);
191 return 0; /* A white lie */
194 wbn = acm->write_current;
195 if (!acm_wb_is_used(acm, wbn)) {
196 spin_unlock_irqrestore(&acm->write_lock, flags);
201 acm->write_ready = 0;
202 spin_unlock_irqrestore(&acm->write_lock, flags);
204 acm->writeurb->transfer_buffer = wb->buf;
205 acm->writeurb->transfer_dma = wb->dmah;
206 acm->writeurb->transfer_buffer_length = wb->len;
207 acm->writeurb->dev = acm->dev;
209 if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
210 dbg("usb_submit_urb(write bulk) failed: %d", rc);
217 * Interrupt handlers for various ACM device responses
220 /* control interface reports status changes with "interrupt" transfers */
221 static void acm_ctrl_irq(struct urb *urb)
223 struct acm *acm = urb->context;
224 struct usb_cdc_notification *dr = urb->transfer_buffer;
229 switch (urb->status) {
236 /* this urb is terminated, clean up */
237 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
240 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
247 data = (unsigned char *)(dr + 1);
248 switch (dr->bNotificationType) {
250 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
252 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
255 case USB_CDC_NOTIFY_SERIAL_STATE:
257 newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
259 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
260 dbg("calling hangup");
261 tty_hangup(acm->tty);
264 acm->ctrlin = newctrl;
266 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
267 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
268 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
269 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
270 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
275 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
276 dr->bNotificationType, dr->wIndex,
277 dr->wLength, data[0], data[1]);
281 status = usb_submit_urb (urb, GFP_ATOMIC);
283 err ("%s - usb_submit_urb failed with result %d",
284 __FUNCTION__, status);
287 /* data interface returns incoming bytes, or we got unthrottled */
288 static void acm_read_bulk(struct urb *urb)
291 struct acm_ru *rcv = urb->context;
292 struct acm *acm = rcv->instance;
293 int status = urb->status;
294 dbg("Entering acm_read_bulk with status %d", urb->status);
300 dev_dbg(&acm->data->dev, "bulk rx status %d", status);
303 buf->size = urb->actual_length;
305 if (likely(status == 0)) {
306 spin_lock(&acm->read_lock);
307 list_add_tail(&rcv->list, &acm->spare_read_urbs);
308 list_add_tail(&buf->list, &acm->filled_read_bufs);
309 spin_unlock(&acm->read_lock);
311 /* we drop the buffer due to an error */
312 spin_lock(&acm->read_lock);
313 list_add_tail(&rcv->list, &acm->spare_read_urbs);
314 list_add(&buf->list, &acm->spare_read_bufs);
315 spin_unlock(&acm->read_lock);
316 /* nevertheless the tasklet must be kicked unconditionally
317 so the queue cannot dry up */
319 tasklet_schedule(&acm->urb_task);
322 static void acm_rx_tasklet(unsigned long _acm)
324 struct acm *acm = (void *)_acm;
326 struct tty_struct *tty = acm->tty;
329 unsigned char throttled;
330 dbg("Entering acm_rx_tasklet");
335 spin_lock_irqsave(&acm->throttle_lock, flags);
336 throttled = acm->throttle;
337 spin_unlock_irqrestore(&acm->throttle_lock, flags);
342 spin_lock_irqsave(&acm->read_lock, flags);
343 if (list_empty(&acm->filled_read_bufs)) {
344 spin_unlock_irqrestore(&acm->read_lock, flags);
347 buf = list_entry(acm->filled_read_bufs.next,
348 struct acm_rb, list);
349 list_del(&buf->list);
350 spin_unlock_irqrestore(&acm->read_lock, flags);
352 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
354 tty_buffer_request_room(tty, buf->size);
355 spin_lock_irqsave(&acm->throttle_lock, flags);
356 throttled = acm->throttle;
357 spin_unlock_irqrestore(&acm->throttle_lock, flags);
359 tty_insert_flip_string(tty, buf->base, buf->size);
360 tty_flip_buffer_push(tty);
363 dbg("Throttling noticed");
364 spin_lock_irqsave(&acm->read_lock, flags);
365 list_add(&buf->list, &acm->filled_read_bufs);
366 spin_unlock_irqrestore(&acm->read_lock, flags);
370 spin_lock_irqsave(&acm->read_lock, flags);
371 list_add(&buf->list, &acm->spare_read_bufs);
372 spin_unlock_irqrestore(&acm->read_lock, flags);
376 while (!list_empty(&acm->spare_read_bufs)) {
377 spin_lock_irqsave(&acm->read_lock, flags);
378 if (list_empty(&acm->spare_read_urbs)) {
379 spin_unlock_irqrestore(&acm->read_lock, flags);
382 rcv = list_entry(acm->spare_read_urbs.next,
383 struct acm_ru, list);
384 list_del(&rcv->list);
385 spin_unlock_irqrestore(&acm->read_lock, flags);
387 buf = list_entry(acm->spare_read_bufs.next,
388 struct acm_rb, list);
389 list_del(&buf->list);
393 usb_fill_bulk_urb(rcv->urb, acm->dev,
398 rcv->urb->transfer_dma = buf->dma;
399 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
401 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
403 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
404 free-urbs-pool and resubmited ASAP */
405 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
406 list_add(&buf->list, &acm->spare_read_bufs);
407 spin_lock_irqsave(&acm->read_lock, flags);
408 list_add(&rcv->list, &acm->spare_read_urbs);
409 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 *acm = (struct acm *)urb->context;
420 dbg("Entering acm_write_bulk with status %d", urb->status);
423 acm_write_start(acm);
425 schedule_work(&acm->work);
428 static void acm_softint(struct work_struct *work)
430 struct acm *acm = container_of(work, struct acm, work);
431 dbg("Entering acm_softint.");
435 tty_wakeup(acm->tty);
442 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
447 dbg("Entering acm_tty_open.");
449 mutex_lock(&open_mutex);
451 acm = acm_table[tty->index];
452 if (!acm || !acm->dev)
457 tty->driver_data = acm;
460 /* force low_latency on so that our tty_push actually forces the data through,
461 otherwise it is scheduled, and with high data rates data can get lost. */
462 tty->low_latency = 1;
468 acm->ctrlurb->dev = acm->dev;
469 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
470 dbg("usb_submit_urb(ctrl irq) failed");
474 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
475 (acm->ctrl_caps & USB_CDC_CAP_LINE))
478 INIT_LIST_HEAD(&acm->spare_read_urbs);
479 INIT_LIST_HEAD(&acm->spare_read_bufs);
480 INIT_LIST_HEAD(&acm->filled_read_bufs);
481 for (i = 0; i < acm->rx_buflimit; i++) {
482 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
484 for (i = 0; i < acm->rx_buflimit; i++) {
485 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
490 tasklet_schedule(&acm->urb_task);
494 mutex_unlock(&open_mutex);
498 usb_kill_urb(acm->ctrlurb);
501 mutex_unlock(&open_mutex);
505 static void acm_tty_unregister(struct acm *acm)
509 nr = acm->rx_buflimit;
510 tty_unregister_device(acm_tty_driver, acm->minor);
511 usb_put_intf(acm->control);
512 acm_table[acm->minor] = NULL;
513 usb_free_urb(acm->ctrlurb);
514 usb_free_urb(acm->writeurb);
515 for (i = 0; i < nr; i++)
516 usb_free_urb(acm->ru[i].urb);
520 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
522 struct acm *acm = tty->driver_data;
525 if (!acm || !acm->used)
528 nr = acm->rx_buflimit;
529 mutex_lock(&open_mutex);
532 acm_set_control(acm, acm->ctrlout = 0);
533 usb_kill_urb(acm->ctrlurb);
534 usb_kill_urb(acm->writeurb);
535 for (i = 0; i < nr; i++)
536 usb_kill_urb(acm->ru[i].urb);
538 acm_tty_unregister(acm);
540 mutex_unlock(&open_mutex);
543 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
545 struct acm *acm = tty->driver_data;
551 dbg("Entering acm_tty_write to write %d bytes,", count);
558 spin_lock_irqsave(&acm->write_lock, flags);
559 if ((wbn = acm_wb_alloc(acm)) < 0) {
560 spin_unlock_irqrestore(&acm->write_lock, flags);
561 acm_write_start(acm);
566 count = (count > acm->writesize) ? acm->writesize : count;
567 dbg("Get %d bytes...", count);
568 memcpy(wb->buf, buf, count);
570 spin_unlock_irqrestore(&acm->write_lock, flags);
572 if ((stat = acm_write_start(acm)) < 0)
577 static int acm_tty_write_room(struct tty_struct *tty)
579 struct acm *acm = tty->driver_data;
583 * Do not let the line discipline to know that we have a reserve,
584 * or it might get too enthusiastic.
586 return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
589 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
591 struct acm *acm = tty->driver_data;
595 * This is inaccurate (overcounts), but it works.
597 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
600 static void acm_tty_throttle(struct tty_struct *tty)
602 struct acm *acm = tty->driver_data;
605 spin_lock_bh(&acm->throttle_lock);
607 spin_unlock_bh(&acm->throttle_lock);
610 static void acm_tty_unthrottle(struct tty_struct *tty)
612 struct acm *acm = tty->driver_data;
615 spin_lock_bh(&acm->throttle_lock);
617 spin_unlock_bh(&acm->throttle_lock);
618 tasklet_schedule(&acm->urb_task);
621 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
623 struct acm *acm = tty->driver_data;
626 if (acm_send_break(acm, state ? 0xffff : 0))
627 dbg("send break failed");
630 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
632 struct acm *acm = tty->driver_data;
637 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
638 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
639 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
640 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
641 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
645 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
646 unsigned int set, unsigned int clear)
648 struct acm *acm = tty->driver_data;
649 unsigned int newctrl;
654 newctrl = acm->ctrlout;
655 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
656 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
658 newctrl = (newctrl & ~clear) | set;
660 if (acm->ctrlout == newctrl)
662 return acm_set_control(acm, acm->ctrlout = newctrl);
665 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
667 struct acm *acm = tty->driver_data;
675 static const __u32 acm_tty_speed[] = {
676 0, 50, 75, 110, 134, 150, 200, 300, 600,
677 1200, 1800, 2400, 4800, 9600, 19200, 38400,
678 57600, 115200, 230400, 460800, 500000, 576000,
679 921600, 1000000, 1152000, 1500000, 2000000,
680 2500000, 3000000, 3500000, 4000000
683 static const __u8 acm_tty_size[] = {
687 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
689 struct acm *acm = tty->driver_data;
690 struct ktermios *termios = tty->termios;
691 struct usb_cdc_line_coding newline;
692 int newctrl = acm->ctrlout;
697 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
698 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
699 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
700 newline.bParityType = termios->c_cflag & PARENB ?
701 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
702 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
704 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
706 if (!newline.dwDTERate) {
707 newline.dwDTERate = acm->line.dwDTERate;
708 newctrl &= ~ACM_CTRL_DTR;
709 } else newctrl |= ACM_CTRL_DTR;
711 if (newctrl != acm->ctrlout)
712 acm_set_control(acm, acm->ctrlout = newctrl);
714 if (memcmp(&acm->line, &newline, sizeof newline)) {
715 memcpy(&acm->line, &newline, sizeof newline);
716 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
717 newline.bCharFormat, newline.bParityType,
719 acm_set_line(acm, &acm->line);
724 * USB probe and disconnect routines.
727 /* Little helper: write buffers free */
728 static void acm_write_buffers_free(struct acm *acm)
733 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
734 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
738 /* Little helper: write buffers allocate */
739 static int acm_write_buffers_alloc(struct acm *acm)
744 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
745 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
751 usb_buffer_free(acm->dev, acm->writesize,
760 static int acm_probe (struct usb_interface *intf,
761 const struct usb_device_id *id)
763 struct usb_cdc_union_desc *union_header = NULL;
764 char *buffer = intf->altsetting->extra;
765 int buflen = intf->altsetting->extralen;
766 struct usb_interface *control_interface;
767 struct usb_interface *data_interface;
768 struct usb_endpoint_descriptor *epctrl;
769 struct usb_endpoint_descriptor *epread;
770 struct usb_endpoint_descriptor *epwrite;
771 struct usb_device *usb_dev = interface_to_usbdev(intf);
774 int ctrlsize,readsize;
776 u8 ac_management_function = 0;
777 u8 call_management_function = 0;
778 int call_interface_num = -1;
779 int data_interface_num;
780 unsigned long quirks;
785 quirks = (unsigned long)id->driver_info;
786 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
788 /* handle quirks deadly to normal probing*/
789 if (quirks == NO_UNION_NORMAL) {
790 data_interface = usb_ifnum_to_if(usb_dev, 1);
791 control_interface = usb_ifnum_to_if(usb_dev, 0);
792 goto skip_normal_probe;
797 err("Wierd descriptor references\n");
802 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
803 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
804 buflen = intf->cur_altsetting->endpoint->extralen;
805 buffer = intf->cur_altsetting->endpoint->extra;
807 err("Zero length descriptor references\n");
813 if (buffer [1] != USB_DT_CS_INTERFACE) {
814 err("skipping garbage\n");
818 switch (buffer [2]) {
819 case USB_CDC_UNION_TYPE: /* we've found it */
821 err("More than one union descriptor, skipping ...");
824 union_header = (struct usb_cdc_union_desc *)
827 case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */
828 break; /* for now we ignore it */
829 case USB_CDC_HEADER_TYPE: /* maybe check version */
830 break; /* for now we ignore it */
831 case USB_CDC_ACM_TYPE:
832 ac_management_function = buffer[3];
834 case USB_CDC_CALL_MANAGEMENT_TYPE:
835 call_management_function = buffer[3];
836 call_interface_num = buffer[4];
837 if ((call_management_function & 3) != 3)
838 err("This device cannot do calls on its own. It is no modem.");
842 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
851 if (call_interface_num > 0) {
852 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
853 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
854 control_interface = intf;
856 dev_dbg(&intf->dev,"No union descriptor, giving up");
860 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
861 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
862 if (!control_interface || !data_interface) {
863 dev_dbg(&intf->dev,"no interfaces");
868 if (data_interface_num != call_interface_num)
869 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
873 /*workaround for switched interfaces */
874 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
875 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
876 struct usb_interface *t;
877 dev_dbg(&intf->dev,"Your device has switched interfaces.");
879 t = control_interface;
880 control_interface = data_interface;
887 if (usb_interface_claimed(data_interface)) { /* valid in this context */
888 dev_dbg(&intf->dev,"The data interface isn't available");
893 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
896 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
897 epread = &data_interface->cur_altsetting->endpoint[0].desc;
898 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
901 /* workaround for switched endpoints */
902 if (!usb_endpoint_dir_in(epread)) {
903 /* descriptors are swapped */
904 struct usb_endpoint_descriptor *t;
905 dev_dbg(&intf->dev,"The data interface has switched endpoints");
911 dbg("interfaces are valid");
912 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
914 if (minor == ACM_TTY_MINORS) {
915 err("no more free acm devices");
919 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
920 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
924 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
925 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
926 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
927 acm->control = control_interface;
928 acm->data = data_interface;
931 acm->ctrl_caps = ac_management_function;
932 acm->ctrlsize = ctrlsize;
933 acm->readsize = readsize;
934 acm->rx_buflimit = num_rx_buf;
935 acm->urb_task.func = acm_rx_tasklet;
936 acm->urb_task.data = (unsigned long) acm;
937 INIT_WORK(&acm->work, acm_softint);
938 spin_lock_init(&acm->throttle_lock);
939 spin_lock_init(&acm->write_lock);
940 spin_lock_init(&acm->read_lock);
941 acm->write_ready = 1;
942 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
944 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
946 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
949 acm->ctrl_buffer = buf;
951 if (acm_write_buffers_alloc(acm) < 0) {
952 dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
956 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
958 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
961 for (i = 0; i < num_rx_buf; i++) {
962 struct acm_ru *rcv = &(acm->ru[i]);
964 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
965 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
969 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
972 for (i = 0; i < num_rx_buf; i++) {
973 struct acm_rb *buf = &(acm->rb[i]);
975 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
976 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
980 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
981 if (!acm->writeurb) {
982 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
986 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
987 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
988 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
989 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
991 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
992 NULL, acm->writesize, acm_write_bulk, acm);
993 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
995 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
997 acm_set_control(acm, acm->ctrlout);
999 acm->line.dwDTERate = cpu_to_le32(9600);
1000 acm->line.bDataBits = 8;
1001 acm_set_line(acm, &acm->line);
1003 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1005 usb_get_intf(control_interface);
1006 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1008 acm_table[minor] = acm;
1009 usb_set_intfdata (intf, acm);
1013 for (i = 0; i < num_rx_buf; i++)
1014 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1015 for (i = 0; i < num_rx_buf; i++)
1016 usb_free_urb(acm->ru[i].urb);
1017 usb_free_urb(acm->ctrlurb);
1019 acm_write_buffers_free(acm);
1021 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1028 static void acm_disconnect(struct usb_interface *intf)
1030 struct acm *acm = usb_get_intfdata (intf);
1031 struct usb_device *usb_dev = interface_to_usbdev(intf);
1034 if (!acm || !acm->dev) {
1035 dbg("disconnect on nonexisting interface");
1039 mutex_lock(&open_mutex);
1040 if (!usb_get_intfdata(intf)) {
1041 mutex_unlock(&open_mutex);
1045 usb_set_intfdata(acm->control, NULL);
1046 usb_set_intfdata(acm->data, NULL);
1048 tasklet_disable(&acm->urb_task);
1050 usb_kill_urb(acm->ctrlurb);
1051 usb_kill_urb(acm->writeurb);
1052 for (i = 0; i < acm->rx_buflimit; i++)
1053 usb_kill_urb(acm->ru[i].urb);
1055 INIT_LIST_HEAD(&acm->filled_read_bufs);
1056 INIT_LIST_HEAD(&acm->spare_read_bufs);
1058 tasklet_enable(&acm->urb_task);
1060 flush_scheduled_work(); /* wait for acm_softint */
1062 acm_write_buffers_free(acm);
1063 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1064 for (i = 0; i < acm->rx_buflimit; i++)
1065 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1067 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1070 acm_tty_unregister(acm);
1071 mutex_unlock(&open_mutex);
1075 mutex_unlock(&open_mutex);
1078 tty_hangup(acm->tty);
1082 * USB driver structure.
1085 static struct usb_device_id acm_ids[] = {
1086 /* quirky and broken devices */
1087 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1088 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1090 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1091 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1093 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1094 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1096 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1097 .driver_info = SINGLE_RX_URB, /* firmware bug */
1099 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1100 .driver_info = SINGLE_RX_URB, /* firmware bug */
1102 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1103 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1106 /* control interfaces with various AT-command sets */
1107 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1108 USB_CDC_ACM_PROTO_AT_V25TER) },
1109 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1110 USB_CDC_ACM_PROTO_AT_PCCA101) },
1111 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1112 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1113 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1114 USB_CDC_ACM_PROTO_AT_GSM) },
1115 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1116 USB_CDC_ACM_PROTO_AT_3G ) },
1117 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1118 USB_CDC_ACM_PROTO_AT_CDMA) },
1120 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1124 MODULE_DEVICE_TABLE (usb, acm_ids);
1126 static struct usb_driver acm_driver = {
1129 .disconnect = acm_disconnect,
1130 .id_table = acm_ids,
1134 * TTY driver structures.
1137 static const struct tty_operations acm_ops = {
1138 .open = acm_tty_open,
1139 .close = acm_tty_close,
1140 .write = acm_tty_write,
1141 .write_room = acm_tty_write_room,
1142 .ioctl = acm_tty_ioctl,
1143 .throttle = acm_tty_throttle,
1144 .unthrottle = acm_tty_unthrottle,
1145 .chars_in_buffer = acm_tty_chars_in_buffer,
1146 .break_ctl = acm_tty_break_ctl,
1147 .set_termios = acm_tty_set_termios,
1148 .tiocmget = acm_tty_tiocmget,
1149 .tiocmset = acm_tty_tiocmset,
1156 static int __init acm_init(void)
1159 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1160 if (!acm_tty_driver)
1162 acm_tty_driver->owner = THIS_MODULE,
1163 acm_tty_driver->driver_name = "acm",
1164 acm_tty_driver->name = "ttyACM",
1165 acm_tty_driver->major = ACM_TTY_MAJOR,
1166 acm_tty_driver->minor_start = 0,
1167 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1168 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1169 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1170 acm_tty_driver->init_termios = tty_std_termios;
1171 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1172 tty_set_operations(acm_tty_driver, &acm_ops);
1174 retval = tty_register_driver(acm_tty_driver);
1176 put_tty_driver(acm_tty_driver);
1180 retval = usb_register(&acm_driver);
1182 tty_unregister_driver(acm_tty_driver);
1183 put_tty_driver(acm_tty_driver);
1187 info(DRIVER_VERSION ":" DRIVER_DESC);
1192 static void __exit acm_exit(void)
1194 usb_deregister(&acm_driver);
1195 tty_unregister_driver(acm_tty_driver);
1196 put_tty_driver(acm_tty_driver);
1199 module_init(acm_init);
1200 module_exit(acm_exit);
1202 MODULE_AUTHOR( DRIVER_AUTHOR );
1203 MODULE_DESCRIPTION( DRIVER_DESC );
1204 MODULE_LICENSE("GPL");