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/mutex.h>
63 #include <asm/uaccess.h>
64 #include <linux/usb.h>
65 #include <linux/usb/cdc.h>
66 #include <asm/byteorder.h>
67 #include <asm/unaligned.h>
68 #include <linux/list.h>
75 #define DRIVER_VERSION "v0.25"
76 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
77 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
79 static struct usb_driver acm_driver;
80 static struct tty_driver *acm_tty_driver;
81 static struct acm *acm_table[ACM_TTY_MINORS];
83 static DEFINE_MUTEX(open_mutex);
85 #define ACM_READY(acm) (acm && acm->dev && acm->used)
88 * Functions for ACM control messages.
91 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
93 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
94 request, USB_RT_ACM, value,
95 acm->control->altsetting[0].desc.bInterfaceNumber,
97 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
98 return retval < 0 ? retval : 0;
101 /* devices aren't required to support these requests.
102 * the cdc acm descriptor tells whether they do...
104 #define acm_set_control(acm, control) \
105 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
106 #define acm_set_line(acm, line) \
107 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
108 #define acm_send_break(acm, ms) \
109 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
112 * Write buffer management.
113 * All of these assume proper locks taken by the caller.
116 static int acm_wb_alloc(struct acm *acm)
121 wbn = acm->write_current;
129 wbn = (wbn + 1) % ACM_NW;
135 static void acm_wb_free(struct acm *acm, int wbn)
137 acm->wb[wbn].use = 0;
140 static int acm_wb_is_avail(struct acm *acm)
145 for (i = 0; i < ACM_NW; i++) {
151 static inline int acm_wb_is_used(struct acm *acm, int wbn)
153 return acm->wb[wbn].use;
159 static void acm_write_done(struct acm *acm)
164 spin_lock_irqsave(&acm->write_lock, flags);
165 acm->write_ready = 1;
166 wbn = acm->write_current;
167 acm_wb_free(acm, wbn);
168 acm->write_current = (wbn + 1) % ACM_NW;
169 spin_unlock_irqrestore(&acm->write_lock, flags);
175 static int acm_write_start(struct acm *acm)
182 spin_lock_irqsave(&acm->write_lock, flags);
184 spin_unlock_irqrestore(&acm->write_lock, flags);
188 if (!acm->write_ready) {
189 spin_unlock_irqrestore(&acm->write_lock, flags);
190 return 0; /* A white lie */
193 wbn = acm->write_current;
194 if (!acm_wb_is_used(acm, wbn)) {
195 spin_unlock_irqrestore(&acm->write_lock, flags);
200 acm->write_ready = 0;
201 spin_unlock_irqrestore(&acm->write_lock, flags);
203 acm->writeurb->transfer_buffer = wb->buf;
204 acm->writeurb->transfer_dma = wb->dmah;
205 acm->writeurb->transfer_buffer_length = wb->len;
206 acm->writeurb->dev = acm->dev;
208 if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
209 dbg("usb_submit_urb(write bulk) failed: %d", rc);
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;
261 int status = urb->status;
270 /* this urb is terminated, clean up */
271 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
274 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
281 data = (unsigned char *)(dr + 1);
282 switch (dr->bNotificationType) {
284 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
286 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
289 case USB_CDC_NOTIFY_SERIAL_STATE:
291 newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
293 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
294 dbg("calling hangup");
295 tty_hangup(acm->tty);
298 acm->ctrlin = newctrl;
300 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
301 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
302 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
303 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
304 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
309 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
310 dr->bNotificationType, dr->wIndex,
311 dr->wLength, data[0], data[1]);
315 retval = usb_submit_urb (urb, GFP_ATOMIC);
317 err ("%s - usb_submit_urb failed with result %d",
318 __FUNCTION__, retval);
321 /* data interface returns incoming bytes, or we got unthrottled */
322 static void acm_read_bulk(struct urb *urb)
325 struct acm_ru *rcv = urb->context;
326 struct acm *acm = rcv->instance;
327 int status = urb->status;
329 dbg("Entering acm_read_bulk with status %d", status);
335 dev_dbg(&acm->data->dev, "bulk rx status %d", status);
338 buf->size = urb->actual_length;
340 if (likely(status == 0)) {
341 spin_lock(&acm->read_lock);
342 list_add_tail(&rcv->list, &acm->spare_read_urbs);
343 list_add_tail(&buf->list, &acm->filled_read_bufs);
344 spin_unlock(&acm->read_lock);
346 /* we drop the buffer due to an error */
347 spin_lock(&acm->read_lock);
348 list_add_tail(&rcv->list, &acm->spare_read_urbs);
349 list_add(&buf->list, &acm->spare_read_bufs);
350 spin_unlock(&acm->read_lock);
351 /* nevertheless the tasklet must be kicked unconditionally
352 so the queue cannot dry up */
354 tasklet_schedule(&acm->urb_task);
357 static void acm_rx_tasklet(unsigned long _acm)
359 struct acm *acm = (void *)_acm;
361 struct tty_struct *tty = acm->tty;
364 unsigned char throttled;
365 dbg("Entering acm_rx_tasklet");
370 spin_lock_irqsave(&acm->throttle_lock, flags);
371 throttled = acm->throttle;
372 spin_unlock_irqrestore(&acm->throttle_lock, flags);
377 spin_lock_irqsave(&acm->read_lock, flags);
378 if (list_empty(&acm->filled_read_bufs)) {
379 spin_unlock_irqrestore(&acm->read_lock, flags);
382 buf = list_entry(acm->filled_read_bufs.next,
383 struct acm_rb, list);
384 list_del(&buf->list);
385 spin_unlock_irqrestore(&acm->read_lock, flags);
387 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
389 tty_buffer_request_room(tty, buf->size);
390 spin_lock_irqsave(&acm->throttle_lock, flags);
391 throttled = acm->throttle;
392 spin_unlock_irqrestore(&acm->throttle_lock, flags);
394 tty_insert_flip_string(tty, buf->base, buf->size);
395 tty_flip_buffer_push(tty);
398 dbg("Throttling noticed");
399 spin_lock_irqsave(&acm->read_lock, flags);
400 list_add(&buf->list, &acm->filled_read_bufs);
401 spin_unlock_irqrestore(&acm->read_lock, flags);
405 spin_lock_irqsave(&acm->read_lock, flags);
406 list_add(&buf->list, &acm->spare_read_bufs);
407 spin_unlock_irqrestore(&acm->read_lock, flags);
411 while (!list_empty(&acm->spare_read_bufs)) {
412 spin_lock_irqsave(&acm->read_lock, flags);
413 if (list_empty(&acm->spare_read_urbs)) {
414 spin_unlock_irqrestore(&acm->read_lock, flags);
417 rcv = list_entry(acm->spare_read_urbs.next,
418 struct acm_ru, list);
419 list_del(&rcv->list);
420 spin_unlock_irqrestore(&acm->read_lock, flags);
422 buf = list_entry(acm->spare_read_bufs.next,
423 struct acm_rb, list);
424 list_del(&buf->list);
428 usb_fill_bulk_urb(rcv->urb, acm->dev,
433 rcv->urb->transfer_dma = buf->dma;
434 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
436 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
438 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
439 free-urbs-pool and resubmited ASAP */
440 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
441 list_add(&buf->list, &acm->spare_read_bufs);
442 spin_lock_irqsave(&acm->read_lock, flags);
443 list_add(&rcv->list, &acm->spare_read_urbs);
444 spin_unlock_irqrestore(&acm->read_lock, flags);
450 /* data interface wrote those outgoing bytes */
451 static void acm_write_bulk(struct urb *urb)
453 struct acm *acm = (struct acm *)urb->context;
455 dbg("Entering acm_write_bulk with status %d", urb->status);
458 acm_write_start(acm);
460 schedule_work(&acm->work);
463 static void acm_softint(struct work_struct *work)
465 struct acm *acm = container_of(work, struct acm, work);
466 dbg("Entering acm_softint.");
470 tty_wakeup(acm->tty);
477 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
482 dbg("Entering acm_tty_open.");
484 mutex_lock(&open_mutex);
486 acm = acm_table[tty->index];
487 if (!acm || !acm->dev)
492 tty->driver_data = acm;
495 /* force low_latency on so that our tty_push actually forces the data through,
496 otherwise it is scheduled, and with high data rates data can get lost. */
497 tty->low_latency = 1;
503 acm->ctrlurb->dev = acm->dev;
504 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
505 dbg("usb_submit_urb(ctrl irq) failed");
509 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
510 (acm->ctrl_caps & USB_CDC_CAP_LINE))
513 INIT_LIST_HEAD(&acm->spare_read_urbs);
514 INIT_LIST_HEAD(&acm->spare_read_bufs);
515 INIT_LIST_HEAD(&acm->filled_read_bufs);
516 for (i = 0; i < acm->rx_buflimit; i++) {
517 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
519 for (i = 0; i < acm->rx_buflimit; i++) {
520 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
525 tasklet_schedule(&acm->urb_task);
529 mutex_unlock(&open_mutex);
533 usb_kill_urb(acm->ctrlurb);
536 mutex_unlock(&open_mutex);
540 static void acm_tty_unregister(struct acm *acm)
544 nr = acm->rx_buflimit;
545 tty_unregister_device(acm_tty_driver, acm->minor);
546 usb_put_intf(acm->control);
547 acm_table[acm->minor] = NULL;
548 usb_free_urb(acm->ctrlurb);
549 usb_free_urb(acm->writeurb);
550 for (i = 0; i < nr; i++)
551 usb_free_urb(acm->ru[i].urb);
552 kfree(acm->country_codes);
556 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
558 struct acm *acm = tty->driver_data;
561 if (!acm || !acm->used)
564 nr = acm->rx_buflimit;
565 mutex_lock(&open_mutex);
568 acm_set_control(acm, acm->ctrlout = 0);
569 usb_kill_urb(acm->ctrlurb);
570 usb_kill_urb(acm->writeurb);
571 for (i = 0; i < nr; i++)
572 usb_kill_urb(acm->ru[i].urb);
574 acm_tty_unregister(acm);
576 mutex_unlock(&open_mutex);
579 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
581 struct acm *acm = tty->driver_data;
587 dbg("Entering acm_tty_write to write %d bytes,", count);
594 spin_lock_irqsave(&acm->write_lock, flags);
595 if ((wbn = acm_wb_alloc(acm)) < 0) {
596 spin_unlock_irqrestore(&acm->write_lock, flags);
597 acm_write_start(acm);
602 count = (count > acm->writesize) ? acm->writesize : count;
603 dbg("Get %d bytes...", count);
604 memcpy(wb->buf, buf, count);
606 spin_unlock_irqrestore(&acm->write_lock, flags);
608 if ((stat = acm_write_start(acm)) < 0)
613 static int acm_tty_write_room(struct tty_struct *tty)
615 struct acm *acm = tty->driver_data;
619 * Do not let the line discipline to know that we have a reserve,
620 * or it might get too enthusiastic.
622 return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
625 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
627 struct acm *acm = tty->driver_data;
631 * This is inaccurate (overcounts), but it works.
633 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
636 static void acm_tty_throttle(struct tty_struct *tty)
638 struct acm *acm = tty->driver_data;
641 spin_lock_bh(&acm->throttle_lock);
643 spin_unlock_bh(&acm->throttle_lock);
646 static void acm_tty_unthrottle(struct tty_struct *tty)
648 struct acm *acm = tty->driver_data;
651 spin_lock_bh(&acm->throttle_lock);
653 spin_unlock_bh(&acm->throttle_lock);
654 tasklet_schedule(&acm->urb_task);
657 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
659 struct acm *acm = tty->driver_data;
662 if (acm_send_break(acm, state ? 0xffff : 0))
663 dbg("send break failed");
666 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
668 struct acm *acm = tty->driver_data;
673 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
674 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
675 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
676 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
677 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
681 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
682 unsigned int set, unsigned int clear)
684 struct acm *acm = tty->driver_data;
685 unsigned int newctrl;
690 newctrl = acm->ctrlout;
691 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
692 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
694 newctrl = (newctrl & ~clear) | set;
696 if (acm->ctrlout == newctrl)
698 return acm_set_control(acm, acm->ctrlout = newctrl);
701 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
703 struct acm *acm = tty->driver_data;
711 static const __u32 acm_tty_speed[] = {
712 0, 50, 75, 110, 134, 150, 200, 300, 600,
713 1200, 1800, 2400, 4800, 9600, 19200, 38400,
714 57600, 115200, 230400, 460800, 500000, 576000,
715 921600, 1000000, 1152000, 1500000, 2000000,
716 2500000, 3000000, 3500000, 4000000
719 static const __u8 acm_tty_size[] = {
723 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
725 struct acm *acm = tty->driver_data;
726 struct ktermios *termios = tty->termios;
727 struct usb_cdc_line_coding newline;
728 int newctrl = acm->ctrlout;
733 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
734 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
735 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
736 newline.bParityType = termios->c_cflag & PARENB ?
737 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
738 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
740 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
742 if (!newline.dwDTERate) {
743 newline.dwDTERate = acm->line.dwDTERate;
744 newctrl &= ~ACM_CTRL_DTR;
745 } else newctrl |= ACM_CTRL_DTR;
747 if (newctrl != acm->ctrlout)
748 acm_set_control(acm, acm->ctrlout = newctrl);
750 if (memcmp(&acm->line, &newline, sizeof newline)) {
751 memcpy(&acm->line, &newline, sizeof newline);
752 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
753 newline.bCharFormat, newline.bParityType,
755 acm_set_line(acm, &acm->line);
760 * USB probe and disconnect routines.
763 /* Little helper: write buffers free */
764 static void acm_write_buffers_free(struct acm *acm)
769 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
770 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
774 /* Little helper: write buffers allocate */
775 static int acm_write_buffers_alloc(struct acm *acm)
780 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
781 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
787 usb_buffer_free(acm->dev, acm->writesize,
796 static int acm_probe (struct usb_interface *intf,
797 const struct usb_device_id *id)
799 struct usb_cdc_union_desc *union_header = NULL;
800 struct usb_cdc_country_functional_desc *cfd = NULL;
801 char *buffer = intf->altsetting->extra;
802 int buflen = intf->altsetting->extralen;
803 struct usb_interface *control_interface;
804 struct usb_interface *data_interface;
805 struct usb_endpoint_descriptor *epctrl;
806 struct usb_endpoint_descriptor *epread;
807 struct usb_endpoint_descriptor *epwrite;
808 struct usb_device *usb_dev = interface_to_usbdev(intf);
811 int ctrlsize,readsize;
813 u8 ac_management_function = 0;
814 u8 call_management_function = 0;
815 int call_interface_num = -1;
816 int data_interface_num;
817 unsigned long quirks;
822 quirks = (unsigned long)id->driver_info;
823 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
825 /* handle quirks deadly to normal probing*/
826 if (quirks == NO_UNION_NORMAL) {
827 data_interface = usb_ifnum_to_if(usb_dev, 1);
828 control_interface = usb_ifnum_to_if(usb_dev, 0);
829 goto skip_normal_probe;
834 err("Wierd descriptor references\n");
839 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
840 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
841 buflen = intf->cur_altsetting->endpoint->extralen;
842 buffer = intf->cur_altsetting->endpoint->extra;
844 err("Zero length descriptor references\n");
850 if (buffer [1] != USB_DT_CS_INTERFACE) {
851 err("skipping garbage\n");
855 switch (buffer [2]) {
856 case USB_CDC_UNION_TYPE: /* we've found it */
858 err("More than one union descriptor, skipping ...");
861 union_header = (struct usb_cdc_union_desc *)
864 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
865 cfd = (struct usb_cdc_country_functional_desc *)buffer;
867 case USB_CDC_HEADER_TYPE: /* maybe check version */
868 break; /* for now we ignore it */
869 case USB_CDC_ACM_TYPE:
870 ac_management_function = buffer[3];
872 case USB_CDC_CALL_MANAGEMENT_TYPE:
873 call_management_function = buffer[3];
874 call_interface_num = buffer[4];
875 if ((call_management_function & 3) != 3)
876 err("This device cannot do calls on its own. It is no modem.");
880 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
889 if (call_interface_num > 0) {
890 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
891 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
892 control_interface = intf;
894 dev_dbg(&intf->dev,"No union descriptor, giving up");
898 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
899 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
900 if (!control_interface || !data_interface) {
901 dev_dbg(&intf->dev,"no interfaces");
906 if (data_interface_num != call_interface_num)
907 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
911 /*workaround for switched interfaces */
912 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
913 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
914 struct usb_interface *t;
915 dev_dbg(&intf->dev,"Your device has switched interfaces.");
917 t = control_interface;
918 control_interface = data_interface;
925 if (usb_interface_claimed(data_interface)) { /* valid in this context */
926 dev_dbg(&intf->dev,"The data interface isn't available");
931 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
934 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
935 epread = &data_interface->cur_altsetting->endpoint[0].desc;
936 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
939 /* workaround for switched endpoints */
940 if (!usb_endpoint_dir_in(epread)) {
941 /* descriptors are swapped */
942 struct usb_endpoint_descriptor *t;
943 dev_dbg(&intf->dev,"The data interface has switched endpoints");
949 dbg("interfaces are valid");
950 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
952 if (minor == ACM_TTY_MINORS) {
953 err("no more free acm devices");
957 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
958 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
962 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
963 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
964 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
965 acm->control = control_interface;
966 acm->data = data_interface;
969 acm->ctrl_caps = ac_management_function;
970 acm->ctrlsize = ctrlsize;
971 acm->readsize = readsize;
972 acm->rx_buflimit = num_rx_buf;
973 acm->urb_task.func = acm_rx_tasklet;
974 acm->urb_task.data = (unsigned long) acm;
975 INIT_WORK(&acm->work, acm_softint);
976 spin_lock_init(&acm->throttle_lock);
977 spin_lock_init(&acm->write_lock);
978 spin_lock_init(&acm->read_lock);
979 acm->write_ready = 1;
980 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
982 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
984 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
987 acm->ctrl_buffer = buf;
989 if (acm_write_buffers_alloc(acm) < 0) {
990 dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
994 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
996 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
999 for (i = 0; i < num_rx_buf; i++) {
1000 struct acm_ru *rcv = &(acm->ru[i]);
1002 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1003 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
1007 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1008 rcv->instance = acm;
1010 for (i = 0; i < num_rx_buf; i++) {
1011 struct acm_rb *buf = &(acm->rb[i]);
1013 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
1014 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
1018 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1019 if (!acm->writeurb) {
1020 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
1024 usb_set_intfdata (intf, acm);
1026 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1030 if (cfd) { /* export the country data */
1031 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1032 if (!acm->country_codes)
1033 goto skip_countries;
1034 acm->country_code_size = cfd->bLength - 4;
1035 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1036 acm->country_rel_date = cfd->iCountryCodeRelDate;
1038 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1040 kfree(acm->country_codes);
1041 goto skip_countries;
1044 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1046 kfree(acm->country_codes);
1047 goto skip_countries;
1052 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1053 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1054 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1055 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1057 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1058 NULL, acm->writesize, acm_write_bulk, acm);
1059 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1061 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1063 acm_set_control(acm, acm->ctrlout);
1065 acm->line.dwDTERate = cpu_to_le32(9600);
1066 acm->line.bDataBits = 8;
1067 acm_set_line(acm, &acm->line);
1069 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1071 usb_get_intf(control_interface);
1072 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1074 acm_table[minor] = acm;
1078 usb_free_urb(acm->writeurb);
1080 for (i = 0; i < num_rx_buf; i++)
1081 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1082 for (i = 0; i < num_rx_buf; i++)
1083 usb_free_urb(acm->ru[i].urb);
1084 usb_free_urb(acm->ctrlurb);
1086 acm_write_buffers_free(acm);
1088 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1095 static void acm_disconnect(struct usb_interface *intf)
1097 struct acm *acm = usb_get_intfdata(intf);
1098 struct usb_device *usb_dev = interface_to_usbdev(intf);
1101 if (!acm || !acm->dev) {
1102 dbg("disconnect on nonexisting interface");
1106 mutex_lock(&open_mutex);
1107 if (!usb_get_intfdata(intf)) {
1108 mutex_unlock(&open_mutex);
1111 if (acm->country_codes){
1112 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1113 device_remove_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1115 device_remove_file(&intf->dev, &dev_attr_bmCapabilities);
1117 usb_set_intfdata(acm->control, NULL);
1118 usb_set_intfdata(acm->data, NULL);
1120 tasklet_disable(&acm->urb_task);
1122 usb_kill_urb(acm->ctrlurb);
1123 usb_kill_urb(acm->writeurb);
1124 for (i = 0; i < acm->rx_buflimit; i++)
1125 usb_kill_urb(acm->ru[i].urb);
1127 INIT_LIST_HEAD(&acm->filled_read_bufs);
1128 INIT_LIST_HEAD(&acm->spare_read_bufs);
1130 tasklet_enable(&acm->urb_task);
1132 flush_scheduled_work(); /* wait for acm_softint */
1134 acm_write_buffers_free(acm);
1135 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1136 for (i = 0; i < acm->rx_buflimit; i++)
1137 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1139 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1142 acm_tty_unregister(acm);
1143 mutex_unlock(&open_mutex);
1147 mutex_unlock(&open_mutex);
1150 tty_hangup(acm->tty);
1154 * USB driver structure.
1157 static struct usb_device_id acm_ids[] = {
1158 /* quirky and broken devices */
1159 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1160 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1162 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1163 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1165 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1166 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1168 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1169 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1171 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1172 .driver_info = SINGLE_RX_URB, /* firmware bug */
1174 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1175 .driver_info = SINGLE_RX_URB, /* firmware bug */
1177 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1178 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1181 /* control interfaces with various AT-command sets */
1182 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1183 USB_CDC_ACM_PROTO_AT_V25TER) },
1184 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1185 USB_CDC_ACM_PROTO_AT_PCCA101) },
1186 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1187 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1188 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1189 USB_CDC_ACM_PROTO_AT_GSM) },
1190 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1191 USB_CDC_ACM_PROTO_AT_3G ) },
1192 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1193 USB_CDC_ACM_PROTO_AT_CDMA) },
1195 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1199 MODULE_DEVICE_TABLE (usb, acm_ids);
1201 static struct usb_driver acm_driver = {
1204 .disconnect = acm_disconnect,
1205 .id_table = acm_ids,
1209 * TTY driver structures.
1212 static const struct tty_operations acm_ops = {
1213 .open = acm_tty_open,
1214 .close = acm_tty_close,
1215 .write = acm_tty_write,
1216 .write_room = acm_tty_write_room,
1217 .ioctl = acm_tty_ioctl,
1218 .throttle = acm_tty_throttle,
1219 .unthrottle = acm_tty_unthrottle,
1220 .chars_in_buffer = acm_tty_chars_in_buffer,
1221 .break_ctl = acm_tty_break_ctl,
1222 .set_termios = acm_tty_set_termios,
1223 .tiocmget = acm_tty_tiocmget,
1224 .tiocmset = acm_tty_tiocmset,
1231 static int __init acm_init(void)
1234 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1235 if (!acm_tty_driver)
1237 acm_tty_driver->owner = THIS_MODULE,
1238 acm_tty_driver->driver_name = "acm",
1239 acm_tty_driver->name = "ttyACM",
1240 acm_tty_driver->major = ACM_TTY_MAJOR,
1241 acm_tty_driver->minor_start = 0,
1242 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1243 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1244 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1245 acm_tty_driver->init_termios = tty_std_termios;
1246 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1247 tty_set_operations(acm_tty_driver, &acm_ops);
1249 retval = tty_register_driver(acm_tty_driver);
1251 put_tty_driver(acm_tty_driver);
1255 retval = usb_register(&acm_driver);
1257 tty_unregister_driver(acm_tty_driver);
1258 put_tty_driver(acm_tty_driver);
1262 info(DRIVER_VERSION ":" DRIVER_DESC);
1267 static void __exit acm_exit(void)
1269 usb_deregister(&acm_driver);
1270 tty_unregister_driver(acm_tty_driver);
1271 put_tty_driver(acm_tty_driver);
1274 module_init(acm_init);
1275 module_exit(acm_exit);
1277 MODULE_AUTHOR( DRIVER_AUTHOR );
1278 MODULE_DESCRIPTION( DRIVER_DESC );
1279 MODULE_LICENSE("GPL");