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
34 * v0.26 - multiple write urbs, writesize increased
38 * This program is free software; you can redistribute it and/or modify
39 * it under the terms of the GNU General Public License as published by
40 * the Free Software Foundation; either version 2 of the License, or
41 * (at your option) any later version.
43 * This program is distributed in the hope that it will be useful,
44 * but WITHOUT ANY WARRANTY; without even the implied warranty of
45 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
46 * GNU General Public License for more details.
48 * You should have received a copy of the GNU General Public License
49 * along with this program; if not, write to the Free Software
50 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
56 #include <linux/kernel.h>
57 #include <linux/errno.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #include <linux/tty.h>
61 #include <linux/tty_driver.h>
62 #include <linux/tty_flip.h>
63 #include <linux/module.h>
64 #include <linux/mutex.h>
65 #include <asm/uaccess.h>
66 #include <linux/usb.h>
67 #include <linux/usb/cdc.h>
68 #include <asm/byteorder.h>
69 #include <asm/unaligned.h>
70 #include <linux/list.h>
75 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
80 #define DRIVER_VERSION "v0.26"
81 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
82 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
84 static struct usb_driver acm_driver;
85 static struct tty_driver *acm_tty_driver;
86 static struct acm *acm_table[ACM_TTY_MINORS];
88 static DEFINE_MUTEX(open_mutex);
90 #define ACM_READY(acm) (acm && acm->dev && acm->used)
99 * Functions for ACM control messages.
102 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
104 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
105 request, USB_RT_ACM, value,
106 acm->control->altsetting[0].desc.bInterfaceNumber,
108 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
109 return retval < 0 ? retval : 0;
112 /* devices aren't required to support these requests.
113 * the cdc acm descriptor tells whether they do...
115 #define acm_set_control(acm, control) \
116 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
117 #define acm_set_line(acm, line) \
118 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
119 #define acm_send_break(acm, ms) \
120 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
123 * Write buffer management.
124 * All of these assume proper locks taken by the caller.
127 static int acm_wb_alloc(struct acm *acm)
140 wbn = (wbn + 1) % ACM_NW;
146 static int acm_wb_is_avail(struct acm *acm)
152 spin_lock_irqsave(&acm->write_lock, flags);
153 for (i = 0; i < ACM_NW; i++) {
156 spin_unlock_irqrestore(&acm->write_lock, flags);
161 * Finish write. Caller must hold acm->write_lock
163 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
172 * the caller is responsible for locking
175 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
181 wb->urb->transfer_buffer = wb->buf;
182 wb->urb->transfer_dma = wb->dmah;
183 wb->urb->transfer_buffer_length = wb->len;
184 wb->urb->dev = acm->dev;
186 if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
187 dbg("usb_submit_urb(write bulk) failed: %d", rc);
188 acm_write_done(acm, wb);
193 static int acm_write_start(struct acm *acm, int wbn)
196 struct acm_wb *wb = &acm->wb[wbn];
199 spin_lock_irqsave(&acm->write_lock, flags);
202 spin_unlock_irqrestore(&acm->write_lock, flags);
206 dbg("%s susp_count: %d", __func__, acm->susp_count);
207 if (acm->susp_count) {
208 acm->delayed_wb = wb;
209 schedule_work(&acm->waker);
210 spin_unlock_irqrestore(&acm->write_lock, flags);
211 return 0; /* A white lie */
213 usb_mark_last_busy(acm->dev);
215 rc = acm_start_wb(acm, wb);
216 spin_unlock_irqrestore(&acm->write_lock, flags);
222 * attributes exported through sysfs
224 static ssize_t show_caps
225 (struct device *dev, struct device_attribute *attr, char *buf)
227 struct usb_interface *intf = to_usb_interface(dev);
228 struct acm *acm = usb_get_intfdata(intf);
230 return sprintf(buf, "%d", acm->ctrl_caps);
232 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
234 static ssize_t show_country_codes
235 (struct device *dev, struct device_attribute *attr, char *buf)
237 struct usb_interface *intf = to_usb_interface(dev);
238 struct acm *acm = usb_get_intfdata(intf);
240 memcpy(buf, acm->country_codes, acm->country_code_size);
241 return acm->country_code_size;
244 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
246 static ssize_t show_country_rel_date
247 (struct device *dev, struct device_attribute *attr, char *buf)
249 struct usb_interface *intf = to_usb_interface(dev);
250 struct acm *acm = usb_get_intfdata(intf);
252 return sprintf(buf, "%d", acm->country_rel_date);
255 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
257 * Interrupt handlers for various ACM device responses
260 /* control interface reports status changes with "interrupt" transfers */
261 static void acm_ctrl_irq(struct urb *urb)
263 struct acm *acm = urb->context;
264 struct usb_cdc_notification *dr = urb->transfer_buffer;
268 int status = urb->status;
277 /* this urb is terminated, clean up */
278 dbg("%s - urb shutting down with status: %d", __func__, status);
281 dbg("%s - nonzero urb status received: %d", __func__, status);
288 data = (unsigned char *)(dr + 1);
289 switch (dr->bNotificationType) {
291 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
293 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
296 case USB_CDC_NOTIFY_SERIAL_STATE:
298 newctrl = get_unaligned_le16(data);
300 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
301 dbg("calling hangup");
302 tty_hangup(acm->tty);
305 acm->ctrlin = newctrl;
307 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
308 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
309 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
310 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
311 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
316 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
317 dr->bNotificationType, dr->wIndex,
318 dr->wLength, data[0], data[1]);
322 usb_mark_last_busy(acm->dev);
323 retval = usb_submit_urb (urb, GFP_ATOMIC);
325 err ("%s - usb_submit_urb failed with result %d",
329 /* data interface returns incoming bytes, or we got unthrottled */
330 static void acm_read_bulk(struct urb *urb)
333 struct acm_ru *rcv = urb->context;
334 struct acm *acm = rcv->instance;
335 int status = urb->status;
337 dbg("Entering acm_read_bulk with status %d", status);
339 if (!ACM_READY(acm)) {
340 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
343 usb_mark_last_busy(acm->dev);
346 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
349 buf->size = urb->actual_length;
351 if (likely(status == 0)) {
352 spin_lock(&acm->read_lock);
354 list_add_tail(&rcv->list, &acm->spare_read_urbs);
355 list_add_tail(&buf->list, &acm->filled_read_bufs);
356 spin_unlock(&acm->read_lock);
358 /* we drop the buffer due to an error */
359 spin_lock(&acm->read_lock);
360 list_add_tail(&rcv->list, &acm->spare_read_urbs);
361 list_add(&buf->list, &acm->spare_read_bufs);
362 spin_unlock(&acm->read_lock);
363 /* nevertheless the tasklet must be kicked unconditionally
364 so the queue cannot dry up */
366 if (likely(!acm->susp_count))
367 tasklet_schedule(&acm->urb_task);
370 static void acm_rx_tasklet(unsigned long _acm)
372 struct acm *acm = (void *)_acm;
374 struct tty_struct *tty = acm->tty;
377 unsigned char throttled;
379 dbg("Entering acm_rx_tasklet");
383 dbg("acm_rx_tasklet: ACM not ready");
387 spin_lock_irqsave(&acm->throttle_lock, flags);
388 throttled = acm->throttle;
389 spin_unlock_irqrestore(&acm->throttle_lock, flags);
392 dbg("acm_rx_tasklet: throttled");
397 spin_lock_irqsave(&acm->read_lock, flags);
398 if (list_empty(&acm->filled_read_bufs)) {
399 spin_unlock_irqrestore(&acm->read_lock, flags);
402 buf = list_entry(acm->filled_read_bufs.next,
403 struct acm_rb, list);
404 list_del(&buf->list);
405 spin_unlock_irqrestore(&acm->read_lock, flags);
407 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
409 tty_buffer_request_room(tty, buf->size);
410 spin_lock_irqsave(&acm->throttle_lock, flags);
411 throttled = acm->throttle;
412 spin_unlock_irqrestore(&acm->throttle_lock, flags);
414 tty_insert_flip_string(tty, buf->base, buf->size);
415 tty_flip_buffer_push(tty);
418 dbg("Throttling noticed");
419 spin_lock_irqsave(&acm->read_lock, flags);
420 list_add(&buf->list, &acm->filled_read_bufs);
421 spin_unlock_irqrestore(&acm->read_lock, flags);
425 spin_lock_irqsave(&acm->read_lock, flags);
426 list_add(&buf->list, &acm->spare_read_bufs);
427 spin_unlock_irqrestore(&acm->read_lock, flags);
431 while (!list_empty(&acm->spare_read_bufs)) {
432 spin_lock_irqsave(&acm->read_lock, flags);
433 if (list_empty(&acm->spare_read_urbs)) {
435 spin_unlock_irqrestore(&acm->read_lock, flags);
438 rcv = list_entry(acm->spare_read_urbs.next,
439 struct acm_ru, list);
440 list_del(&rcv->list);
441 spin_unlock_irqrestore(&acm->read_lock, flags);
443 buf = list_entry(acm->spare_read_bufs.next,
444 struct acm_rb, list);
445 list_del(&buf->list);
449 usb_fill_bulk_urb(rcv->urb, acm->dev,
454 rcv->urb->transfer_dma = buf->dma;
455 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
457 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
458 free-urbs-pool and resubmited ASAP */
459 spin_lock_irqsave(&acm->read_lock, flags);
460 if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
461 list_add(&buf->list, &acm->spare_read_bufs);
462 list_add(&rcv->list, &acm->spare_read_urbs);
464 spin_unlock_irqrestore(&acm->read_lock, flags);
467 spin_unlock_irqrestore(&acm->read_lock, flags);
468 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
471 spin_lock_irqsave(&acm->read_lock, flags);
473 spin_unlock_irqrestore(&acm->read_lock, flags);
476 /* data interface wrote those outgoing bytes */
477 static void acm_write_bulk(struct urb *urb)
479 struct acm_wb *wb = urb->context;
480 struct acm *acm = wb->instance;
483 if (verbose || urb->status
484 || (urb->actual_length != urb->transfer_buffer_length))
485 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
487 urb->transfer_buffer_length,
490 spin_lock_irqsave(&acm->write_lock, flags);
491 acm_write_done(acm, wb);
492 spin_unlock_irqrestore(&acm->write_lock, flags);
494 schedule_work(&acm->work);
496 wake_up_interruptible(&acm->drain_wait);
499 static void acm_softint(struct work_struct *work)
501 struct acm *acm = container_of(work, struct acm, work);
503 dev_vdbg(&acm->data->dev, "tx work\n");
506 tty_wakeup(acm->tty);
509 static void acm_waker(struct work_struct *waker)
511 struct acm *acm = container_of(waker, struct acm, waker);
514 rv = usb_autopm_get_interface(acm->control);
516 err("Autopm failure in %s", __func__);
519 if (acm->delayed_wb) {
520 acm_start_wb(acm, acm->delayed_wb);
521 acm->delayed_wb = NULL;
523 usb_autopm_put_interface(acm->control);
530 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
535 dbg("Entering acm_tty_open.");
537 mutex_lock(&open_mutex);
539 acm = acm_table[tty->index];
540 if (!acm || !acm->dev)
545 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
546 tty->driver_data = acm;
549 /* force low_latency on so that our tty_push actually forces the data through,
550 otherwise it is scheduled, and with high data rates data can get lost. */
551 tty->low_latency = 1;
553 if (usb_autopm_get_interface(acm->control) < 0)
556 acm->control->needs_remote_wakeup = 1;
558 mutex_lock(&acm->mutex);
560 usb_autopm_put_interface(acm->control);
565 acm->ctrlurb->dev = acm->dev;
566 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
567 dbg("usb_submit_urb(ctrl irq) failed");
571 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
572 (acm->ctrl_caps & USB_CDC_CAP_LINE))
574 usb_autopm_put_interface(acm->control);
576 INIT_LIST_HEAD(&acm->spare_read_urbs);
577 INIT_LIST_HEAD(&acm->spare_read_bufs);
578 INIT_LIST_HEAD(&acm->filled_read_bufs);
579 for (i = 0; i < acm->rx_buflimit; i++) {
580 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
582 for (i = 0; i < acm->rx_buflimit; i++) {
583 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
588 tasklet_schedule(&acm->urb_task);
591 mutex_unlock(&acm->mutex);
593 mutex_unlock(&open_mutex);
597 usb_kill_urb(acm->ctrlurb);
599 usb_autopm_put_interface(acm->control);
601 mutex_unlock(&acm->mutex);
603 mutex_unlock(&open_mutex);
607 static void acm_tty_unregister(struct acm *acm)
611 nr = acm->rx_buflimit;
612 tty_unregister_device(acm_tty_driver, acm->minor);
613 usb_put_intf(acm->control);
614 acm_table[acm->minor] = NULL;
615 usb_free_urb(acm->ctrlurb);
616 for (i = 0; i < ACM_NW; i++)
617 usb_free_urb(acm->wb[i].urb);
618 for (i = 0; i < nr; i++)
619 usb_free_urb(acm->ru[i].urb);
620 kfree(acm->country_codes);
624 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
626 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
628 struct acm *acm = tty->driver_data;
631 if (!acm || !acm->used)
634 nr = acm->rx_buflimit;
635 mutex_lock(&open_mutex);
638 usb_autopm_get_interface(acm->control);
639 acm_set_control(acm, acm->ctrlout = 0);
641 /* try letting the last writes drain naturally */
642 wait_event_interruptible_timeout(acm->drain_wait,
643 (ACM_NW == acm_wb_is_avail(acm))
645 ACM_CLOSE_TIMEOUT * HZ);
647 usb_kill_urb(acm->ctrlurb);
648 for (i = 0; i < ACM_NW; i++)
649 usb_kill_urb(acm->wb[i].urb);
650 for (i = 0; i < nr; i++)
651 usb_kill_urb(acm->ru[i].urb);
652 acm->control->needs_remote_wakeup = 0;
653 usb_autopm_put_interface(acm->control);
655 acm_tty_unregister(acm);
657 mutex_unlock(&open_mutex);
660 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
662 struct acm *acm = tty->driver_data;
668 dbg("Entering acm_tty_write to write %d bytes,", count);
675 spin_lock_irqsave(&acm->write_lock, flags);
676 if ((wbn = acm_wb_alloc(acm)) < 0) {
677 spin_unlock_irqrestore(&acm->write_lock, flags);
682 count = (count > acm->writesize) ? acm->writesize : count;
683 dbg("Get %d bytes...", count);
684 memcpy(wb->buf, buf, count);
686 spin_unlock_irqrestore(&acm->write_lock, flags);
688 if ((stat = acm_write_start(acm, wbn)) < 0)
693 static int acm_tty_write_room(struct tty_struct *tty)
695 struct acm *acm = tty->driver_data;
699 * Do not let the line discipline to know that we have a reserve,
700 * or it might get too enthusiastic.
702 return acm_wb_is_avail(acm) ? acm->writesize : 0;
705 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
707 struct acm *acm = tty->driver_data;
711 * This is inaccurate (overcounts), but it works.
713 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
716 static void acm_tty_throttle(struct tty_struct *tty)
718 struct acm *acm = tty->driver_data;
721 spin_lock_bh(&acm->throttle_lock);
723 spin_unlock_bh(&acm->throttle_lock);
726 static void acm_tty_unthrottle(struct tty_struct *tty)
728 struct acm *acm = tty->driver_data;
731 spin_lock_bh(&acm->throttle_lock);
733 spin_unlock_bh(&acm->throttle_lock);
734 tasklet_schedule(&acm->urb_task);
737 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
739 struct acm *acm = tty->driver_data;
743 retval = acm_send_break(acm, state ? 0xffff : 0);
745 dbg("send break failed");
749 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
751 struct acm *acm = tty->driver_data;
756 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
757 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
758 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
759 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
760 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
764 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
765 unsigned int set, unsigned int clear)
767 struct acm *acm = tty->driver_data;
768 unsigned int newctrl;
773 newctrl = acm->ctrlout;
774 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
775 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
777 newctrl = (newctrl & ~clear) | set;
779 if (acm->ctrlout == newctrl)
781 return acm_set_control(acm, acm->ctrlout = newctrl);
784 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
786 struct acm *acm = tty->driver_data;
794 static const __u32 acm_tty_speed[] = {
795 0, 50, 75, 110, 134, 150, 200, 300, 600,
796 1200, 1800, 2400, 4800, 9600, 19200, 38400,
797 57600, 115200, 230400, 460800, 500000, 576000,
798 921600, 1000000, 1152000, 1500000, 2000000,
799 2500000, 3000000, 3500000, 4000000
802 static const __u8 acm_tty_size[] = {
806 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
808 struct acm *acm = tty->driver_data;
809 struct ktermios *termios = tty->termios;
810 struct usb_cdc_line_coding newline;
811 int newctrl = acm->ctrlout;
816 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
817 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
818 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
819 newline.bParityType = termios->c_cflag & PARENB ?
820 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
821 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
823 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
825 if (!newline.dwDTERate) {
826 newline.dwDTERate = acm->line.dwDTERate;
827 newctrl &= ~ACM_CTRL_DTR;
828 } else newctrl |= ACM_CTRL_DTR;
830 if (newctrl != acm->ctrlout)
831 acm_set_control(acm, acm->ctrlout = newctrl);
833 if (memcmp(&acm->line, &newline, sizeof newline)) {
834 memcpy(&acm->line, &newline, sizeof newline);
835 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
836 newline.bCharFormat, newline.bParityType,
838 acm_set_line(acm, &acm->line);
843 * USB probe and disconnect routines.
846 /* Little helpers: write/read buffers free */
847 static void acm_write_buffers_free(struct acm *acm)
851 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
853 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
854 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
858 static void acm_read_buffers_free(struct acm *acm)
860 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
861 int i, n = acm->rx_buflimit;
863 for (i = 0; i < n; i++)
864 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
867 /* Little helper: write buffers allocate */
868 static int acm_write_buffers_alloc(struct acm *acm)
873 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
874 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
880 usb_buffer_free(acm->dev, acm->writesize,
889 static int acm_probe (struct usb_interface *intf,
890 const struct usb_device_id *id)
892 struct usb_cdc_union_desc *union_header = NULL;
893 struct usb_cdc_country_functional_desc *cfd = NULL;
894 unsigned char *buffer = intf->altsetting->extra;
895 int buflen = intf->altsetting->extralen;
896 struct usb_interface *control_interface;
897 struct usb_interface *data_interface;
898 struct usb_endpoint_descriptor *epctrl;
899 struct usb_endpoint_descriptor *epread;
900 struct usb_endpoint_descriptor *epwrite;
901 struct usb_device *usb_dev = interface_to_usbdev(intf);
904 int ctrlsize,readsize;
906 u8 ac_management_function = 0;
907 u8 call_management_function = 0;
908 int call_interface_num = -1;
909 int data_interface_num;
910 unsigned long quirks;
915 quirks = (unsigned long)id->driver_info;
916 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
918 /* handle quirks deadly to normal probing*/
919 if (quirks == NO_UNION_NORMAL) {
920 data_interface = usb_ifnum_to_if(usb_dev, 1);
921 control_interface = usb_ifnum_to_if(usb_dev, 0);
922 goto skip_normal_probe;
927 err("Weird descriptor references\n");
932 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
933 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
934 buflen = intf->cur_altsetting->endpoint->extralen;
935 buffer = intf->cur_altsetting->endpoint->extra;
937 err("Zero length descriptor references\n");
943 if (buffer [1] != USB_DT_CS_INTERFACE) {
944 err("skipping garbage\n");
948 switch (buffer [2]) {
949 case USB_CDC_UNION_TYPE: /* we've found it */
951 err("More than one union descriptor, skipping ...");
954 union_header = (struct usb_cdc_union_desc *)
957 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
958 cfd = (struct usb_cdc_country_functional_desc *)buffer;
960 case USB_CDC_HEADER_TYPE: /* maybe check version */
961 break; /* for now we ignore it */
962 case USB_CDC_ACM_TYPE:
963 ac_management_function = buffer[3];
965 case USB_CDC_CALL_MANAGEMENT_TYPE:
966 call_management_function = buffer[3];
967 call_interface_num = buffer[4];
968 if ((call_management_function & 3) != 3)
969 err("This device cannot do calls on its own. It is no modem.");
972 /* there are LOTS more CDC descriptors that
973 * could legitimately be found here.
975 dev_dbg(&intf->dev, "Ignoring descriptor: "
976 "type %02x, length %d\n",
977 buffer[2], buffer[0]);
986 if (call_interface_num > 0) {
987 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
988 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
989 control_interface = intf;
991 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
995 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
996 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
997 if (!control_interface || !data_interface) {
998 dev_dbg(&intf->dev,"no interfaces\n");
1003 if (data_interface_num != call_interface_num)
1004 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
1008 /*workaround for switched interfaces */
1009 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
1010 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
1011 struct usb_interface *t;
1012 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
1014 t = control_interface;
1015 control_interface = data_interface;
1022 /* Accept probe requests only for the control interface */
1023 if (intf != control_interface)
1026 if (usb_interface_claimed(data_interface)) { /* valid in this context */
1027 dev_dbg(&intf->dev,"The data interface isn't available\n");
1032 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1035 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1036 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1037 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1040 /* workaround for switched endpoints */
1041 if (!usb_endpoint_dir_in(epread)) {
1042 /* descriptors are swapped */
1043 struct usb_endpoint_descriptor *t;
1044 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
1050 dbg("interfaces are valid");
1051 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1053 if (minor == ACM_TTY_MINORS) {
1054 err("no more free acm devices");
1058 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
1059 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1063 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1064 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
1065 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1066 acm->control = control_interface;
1067 acm->data = data_interface;
1070 acm->ctrl_caps = ac_management_function;
1071 acm->ctrlsize = ctrlsize;
1072 acm->readsize = readsize;
1073 acm->rx_buflimit = num_rx_buf;
1074 acm->urb_task.func = acm_rx_tasklet;
1075 acm->urb_task.data = (unsigned long) acm;
1076 INIT_WORK(&acm->work, acm_softint);
1077 INIT_WORK(&acm->waker, acm_waker);
1078 init_waitqueue_head(&acm->drain_wait);
1079 spin_lock_init(&acm->throttle_lock);
1080 spin_lock_init(&acm->write_lock);
1081 spin_lock_init(&acm->read_lock);
1082 mutex_init(&acm->mutex);
1083 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1085 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1087 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1090 acm->ctrl_buffer = buf;
1092 if (acm_write_buffers_alloc(acm) < 0) {
1093 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1097 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1098 if (!acm->ctrlurb) {
1099 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1102 for (i = 0; i < num_rx_buf; i++) {
1103 struct acm_ru *rcv = &(acm->ru[i]);
1105 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1106 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1110 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1111 rcv->instance = acm;
1113 for (i = 0; i < num_rx_buf; i++) {
1114 struct acm_rb *rb = &(acm->rb[i]);
1116 rb->base = usb_buffer_alloc(acm->dev, readsize,
1117 GFP_KERNEL, &rb->dma);
1119 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1123 for(i = 0; i < ACM_NW; i++)
1125 struct acm_wb *snd = &(acm->wb[i]);
1127 if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1128 dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
1132 usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1133 NULL, acm->writesize, acm_write_bulk, snd);
1134 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1135 snd->instance = acm;
1138 usb_set_intfdata (intf, acm);
1140 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1144 if (cfd) { /* export the country data */
1145 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1146 if (!acm->country_codes)
1147 goto skip_countries;
1148 acm->country_code_size = cfd->bLength - 4;
1149 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1150 acm->country_rel_date = cfd->iCountryCodeRelDate;
1152 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1154 kfree(acm->country_codes);
1155 goto skip_countries;
1158 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1160 kfree(acm->country_codes);
1161 goto skip_countries;
1166 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1167 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1168 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1169 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1171 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1173 acm_set_control(acm, acm->ctrlout);
1175 acm->line.dwDTERate = cpu_to_le32(9600);
1176 acm->line.bDataBits = 8;
1177 acm_set_line(acm, &acm->line);
1179 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1180 usb_set_intfdata(data_interface, acm);
1182 usb_get_intf(control_interface);
1183 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1185 acm_table[minor] = acm;
1189 for (i = 0; i < ACM_NW; i++)
1190 usb_free_urb(acm->wb[i].urb);
1192 acm_read_buffers_free(acm);
1193 for (i = 0; i < num_rx_buf; i++)
1194 usb_free_urb(acm->ru[i].urb);
1195 usb_free_urb(acm->ctrlurb);
1197 acm_write_buffers_free(acm);
1199 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1206 static void stop_data_traffic(struct acm *acm)
1209 dbg("Entering stop_data_traffic");
1211 tasklet_disable(&acm->urb_task);
1213 usb_kill_urb(acm->ctrlurb);
1214 for(i = 0; i < ACM_NW; i++)
1215 usb_kill_urb(acm->wb[i].urb);
1216 for (i = 0; i < acm->rx_buflimit; i++)
1217 usb_kill_urb(acm->ru[i].urb);
1219 tasklet_enable(&acm->urb_task);
1221 cancel_work_sync(&acm->work);
1222 cancel_work_sync(&acm->waker);
1225 static void acm_disconnect(struct usb_interface *intf)
1227 struct acm *acm = usb_get_intfdata(intf);
1228 struct usb_device *usb_dev = interface_to_usbdev(intf);
1230 /* sibling interface is already cleaning up */
1234 mutex_lock(&open_mutex);
1235 if (acm->country_codes){
1236 device_remove_file(&acm->control->dev,
1237 &dev_attr_wCountryCodes);
1238 device_remove_file(&acm->control->dev,
1239 &dev_attr_iCountryCodeRelDate);
1241 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1243 usb_set_intfdata(acm->control, NULL);
1244 usb_set_intfdata(acm->data, NULL);
1246 stop_data_traffic(acm);
1248 acm_write_buffers_free(acm);
1249 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1250 acm_read_buffers_free(acm);
1252 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1253 acm->data : acm->control);
1256 acm_tty_unregister(acm);
1257 mutex_unlock(&open_mutex);
1261 mutex_unlock(&open_mutex);
1264 tty_hangup(acm->tty);
1268 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1270 struct acm *acm = usb_get_intfdata(intf);
1273 if (acm->dev->auto_pm) {
1276 spin_lock_irq(&acm->read_lock);
1277 spin_lock(&acm->write_lock);
1278 b = acm->processing + acm->transmitting;
1279 spin_unlock(&acm->write_lock);
1280 spin_unlock_irq(&acm->read_lock);
1285 spin_lock_irq(&acm->read_lock);
1286 spin_lock(&acm->write_lock);
1287 cnt = acm->susp_count++;
1288 spin_unlock(&acm->write_lock);
1289 spin_unlock_irq(&acm->read_lock);
1294 we treat opened interfaces differently,
1295 we must guard against open
1297 mutex_lock(&acm->mutex);
1300 stop_data_traffic(acm);
1302 mutex_unlock(&acm->mutex);
1306 static int acm_resume(struct usb_interface *intf)
1308 struct acm *acm = usb_get_intfdata(intf);
1312 spin_lock_irq(&acm->read_lock);
1313 acm->susp_count -= 1;
1314 cnt = acm->susp_count;
1315 spin_unlock_irq(&acm->read_lock);
1320 mutex_lock(&acm->mutex);
1322 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1326 tasklet_schedule(&acm->urb_task);
1330 mutex_unlock(&acm->mutex);
1334 #endif /* CONFIG_PM */
1336 * USB driver structure.
1339 static struct usb_device_id acm_ids[] = {
1340 /* quirky and broken devices */
1341 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1342 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1344 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1345 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1347 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1348 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1350 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1351 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1353 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1354 .driver_info = SINGLE_RX_URB, /* firmware bug */
1356 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1357 .driver_info = SINGLE_RX_URB, /* firmware bug */
1359 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1360 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1362 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1363 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1365 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1366 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1369 /* control interfaces with various AT-command sets */
1370 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1371 USB_CDC_ACM_PROTO_AT_V25TER) },
1372 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1373 USB_CDC_ACM_PROTO_AT_PCCA101) },
1374 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1375 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1376 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1377 USB_CDC_ACM_PROTO_AT_GSM) },
1378 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1379 USB_CDC_ACM_PROTO_AT_3G ) },
1380 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1381 USB_CDC_ACM_PROTO_AT_CDMA) },
1383 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1387 MODULE_DEVICE_TABLE (usb, acm_ids);
1389 static struct usb_driver acm_driver = {
1392 .disconnect = acm_disconnect,
1394 .suspend = acm_suspend,
1395 .resume = acm_resume,
1397 .id_table = acm_ids,
1399 .supports_autosuspend = 1,
1404 * TTY driver structures.
1407 static const struct tty_operations acm_ops = {
1408 .open = acm_tty_open,
1409 .close = acm_tty_close,
1410 .write = acm_tty_write,
1411 .write_room = acm_tty_write_room,
1412 .ioctl = acm_tty_ioctl,
1413 .throttle = acm_tty_throttle,
1414 .unthrottle = acm_tty_unthrottle,
1415 .chars_in_buffer = acm_tty_chars_in_buffer,
1416 .break_ctl = acm_tty_break_ctl,
1417 .set_termios = acm_tty_set_termios,
1418 .tiocmget = acm_tty_tiocmget,
1419 .tiocmset = acm_tty_tiocmset,
1426 static int __init acm_init(void)
1429 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1430 if (!acm_tty_driver)
1432 acm_tty_driver->owner = THIS_MODULE,
1433 acm_tty_driver->driver_name = "acm",
1434 acm_tty_driver->name = "ttyACM",
1435 acm_tty_driver->major = ACM_TTY_MAJOR,
1436 acm_tty_driver->minor_start = 0,
1437 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1438 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1439 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1440 acm_tty_driver->init_termios = tty_std_termios;
1441 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1442 tty_set_operations(acm_tty_driver, &acm_ops);
1444 retval = tty_register_driver(acm_tty_driver);
1446 put_tty_driver(acm_tty_driver);
1450 retval = usb_register(&acm_driver);
1452 tty_unregister_driver(acm_tty_driver);
1453 put_tty_driver(acm_tty_driver);
1457 info(DRIVER_VERSION ":" DRIVER_DESC);
1462 static void __exit acm_exit(void)
1464 usb_deregister(&acm_driver);
1465 tty_unregister_driver(acm_tty_driver);
1466 put_tty_driver(acm_tty_driver);
1469 module_init(acm_init);
1470 module_exit(acm_exit);
1472 MODULE_AUTHOR( DRIVER_AUTHOR );
1473 MODULE_DESCRIPTION( DRIVER_DESC );
1474 MODULE_LICENSE("GPL");