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);
163 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
167 spin_lock_irqsave(&acm->write_lock, flags);
170 spin_unlock_irqrestore(&acm->write_lock, flags);
176 * the caller is responsible for locking
179 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
185 wb->urb->transfer_buffer = wb->buf;
186 wb->urb->transfer_dma = wb->dmah;
187 wb->urb->transfer_buffer_length = wb->len;
188 wb->urb->dev = acm->dev;
190 if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
191 dbg("usb_submit_urb(write bulk) failed: %d", rc);
192 acm_write_done(acm, wb);
197 static int acm_write_start(struct acm *acm, int wbn)
200 struct acm_wb *wb = &acm->wb[wbn];
203 spin_lock_irqsave(&acm->write_lock, flags);
206 spin_unlock_irqrestore(&acm->write_lock, flags);
210 dbg("%s susp_count: %d", __func__, acm->susp_count);
211 if (acm->susp_count) {
212 acm->delayed_wb = wb;
213 schedule_work(&acm->waker);
214 spin_unlock_irqrestore(&acm->write_lock, flags);
215 return 0; /* A white lie */
217 usb_mark_last_busy(acm->dev);
219 rc = acm_start_wb(acm, wb);
220 spin_unlock_irqrestore(&acm->write_lock, flags);
226 * attributes exported through sysfs
228 static ssize_t show_caps
229 (struct device *dev, struct device_attribute *attr, char *buf)
231 struct usb_interface *intf = to_usb_interface(dev);
232 struct acm *acm = usb_get_intfdata(intf);
234 return sprintf(buf, "%d", acm->ctrl_caps);
236 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
238 static ssize_t show_country_codes
239 (struct device *dev, struct device_attribute *attr, char *buf)
241 struct usb_interface *intf = to_usb_interface(dev);
242 struct acm *acm = usb_get_intfdata(intf);
244 memcpy(buf, acm->country_codes, acm->country_code_size);
245 return acm->country_code_size;
248 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
250 static ssize_t show_country_rel_date
251 (struct device *dev, struct device_attribute *attr, char *buf)
253 struct usb_interface *intf = to_usb_interface(dev);
254 struct acm *acm = usb_get_intfdata(intf);
256 return sprintf(buf, "%d", acm->country_rel_date);
259 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
261 * Interrupt handlers for various ACM device responses
264 /* control interface reports status changes with "interrupt" transfers */
265 static void acm_ctrl_irq(struct urb *urb)
267 struct acm *acm = urb->context;
268 struct usb_cdc_notification *dr = urb->transfer_buffer;
272 int status = urb->status;
281 /* this urb is terminated, clean up */
282 dbg("%s - urb shutting down with status: %d", __func__, status);
285 dbg("%s - nonzero urb status received: %d", __func__, status);
292 data = (unsigned char *)(dr + 1);
293 switch (dr->bNotificationType) {
295 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
297 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
300 case USB_CDC_NOTIFY_SERIAL_STATE:
302 newctrl = get_unaligned_le16(data);
304 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
305 dbg("calling hangup");
306 tty_hangup(acm->tty);
309 acm->ctrlin = newctrl;
311 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
312 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
313 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
314 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
315 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
320 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
321 dr->bNotificationType, dr->wIndex,
322 dr->wLength, data[0], data[1]);
326 usb_mark_last_busy(acm->dev);
327 retval = usb_submit_urb (urb, GFP_ATOMIC);
329 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
330 "result %d", __func__, retval);
333 /* data interface returns incoming bytes, or we got unthrottled */
334 static void acm_read_bulk(struct urb *urb)
337 struct acm_ru *rcv = urb->context;
338 struct acm *acm = rcv->instance;
339 int status = urb->status;
341 dbg("Entering acm_read_bulk with status %d", status);
343 if (!ACM_READY(acm)) {
344 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
347 usb_mark_last_busy(acm->dev);
350 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
353 buf->size = urb->actual_length;
355 if (likely(status == 0)) {
356 spin_lock(&acm->read_lock);
358 list_add_tail(&rcv->list, &acm->spare_read_urbs);
359 list_add_tail(&buf->list, &acm->filled_read_bufs);
360 spin_unlock(&acm->read_lock);
362 /* we drop the buffer due to an error */
363 spin_lock(&acm->read_lock);
364 list_add_tail(&rcv->list, &acm->spare_read_urbs);
365 list_add(&buf->list, &acm->spare_read_bufs);
366 spin_unlock(&acm->read_lock);
367 /* nevertheless the tasklet must be kicked unconditionally
368 so the queue cannot dry up */
370 if (likely(!acm->susp_count))
371 tasklet_schedule(&acm->urb_task);
374 static void acm_rx_tasklet(unsigned long _acm)
376 struct acm *acm = (void *)_acm;
378 struct tty_struct *tty = acm->tty;
381 unsigned char throttled;
383 dbg("Entering acm_rx_tasklet");
387 dbg("acm_rx_tasklet: ACM not ready");
391 spin_lock_irqsave(&acm->throttle_lock, flags);
392 throttled = acm->throttle;
393 spin_unlock_irqrestore(&acm->throttle_lock, flags);
396 dbg("acm_rx_tasklet: throttled");
401 spin_lock_irqsave(&acm->read_lock, flags);
402 if (list_empty(&acm->filled_read_bufs)) {
403 spin_unlock_irqrestore(&acm->read_lock, flags);
406 buf = list_entry(acm->filled_read_bufs.next,
407 struct acm_rb, list);
408 list_del(&buf->list);
409 spin_unlock_irqrestore(&acm->read_lock, flags);
411 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
413 tty_buffer_request_room(tty, buf->size);
414 spin_lock_irqsave(&acm->throttle_lock, flags);
415 throttled = acm->throttle;
416 spin_unlock_irqrestore(&acm->throttle_lock, flags);
418 tty_insert_flip_string(tty, buf->base, buf->size);
419 tty_flip_buffer_push(tty);
422 dbg("Throttling noticed");
423 spin_lock_irqsave(&acm->read_lock, flags);
424 list_add(&buf->list, &acm->filled_read_bufs);
425 spin_unlock_irqrestore(&acm->read_lock, flags);
429 spin_lock_irqsave(&acm->read_lock, flags);
430 list_add(&buf->list, &acm->spare_read_bufs);
431 spin_unlock_irqrestore(&acm->read_lock, flags);
435 while (!list_empty(&acm->spare_read_bufs)) {
436 spin_lock_irqsave(&acm->read_lock, flags);
437 if (list_empty(&acm->spare_read_urbs)) {
439 spin_unlock_irqrestore(&acm->read_lock, flags);
442 rcv = list_entry(acm->spare_read_urbs.next,
443 struct acm_ru, list);
444 list_del(&rcv->list);
445 spin_unlock_irqrestore(&acm->read_lock, flags);
447 buf = list_entry(acm->spare_read_bufs.next,
448 struct acm_rb, list);
449 list_del(&buf->list);
453 usb_fill_bulk_urb(rcv->urb, acm->dev,
458 rcv->urb->transfer_dma = buf->dma;
459 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
461 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
462 free-urbs-pool and resubmited ASAP */
463 spin_lock_irqsave(&acm->read_lock, flags);
464 if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
465 list_add(&buf->list, &acm->spare_read_bufs);
466 list_add(&rcv->list, &acm->spare_read_urbs);
468 spin_unlock_irqrestore(&acm->read_lock, flags);
471 spin_unlock_irqrestore(&acm->read_lock, flags);
472 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
475 spin_lock_irqsave(&acm->read_lock, flags);
477 spin_unlock_irqrestore(&acm->read_lock, flags);
480 /* data interface wrote those outgoing bytes */
481 static void acm_write_bulk(struct urb *urb)
483 struct acm_wb *wb = urb->context;
484 struct acm *acm = wb->instance;
486 if (verbose || urb->status
487 || (urb->actual_length != urb->transfer_buffer_length))
488 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
490 urb->transfer_buffer_length,
493 acm_write_done(acm, wb);
495 schedule_work(&acm->work);
497 wake_up_interruptible(&acm->drain_wait);
500 static void acm_softint(struct work_struct *work)
502 struct acm *acm = container_of(work, struct acm, work);
504 dev_vdbg(&acm->data->dev, "tx work\n");
507 tty_wakeup(acm->tty);
510 static void acm_waker(struct work_struct *waker)
512 struct acm *acm = container_of(waker, struct acm, waker);
515 rv = usb_autopm_get_interface(acm->control);
517 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
520 if (acm->delayed_wb) {
521 acm_start_wb(acm, acm->delayed_wb);
522 acm->delayed_wb = NULL;
524 usb_autopm_put_interface(acm->control);
531 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
536 dbg("Entering acm_tty_open.");
538 mutex_lock(&open_mutex);
540 acm = acm_table[tty->index];
541 if (!acm || !acm->dev)
546 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
547 tty->driver_data = acm;
550 /* force low_latency on so that our tty_push actually forces the data through,
551 otherwise it is scheduled, and with high data rates data can get lost. */
552 tty->low_latency = 1;
554 if (usb_autopm_get_interface(acm->control) < 0)
557 acm->control->needs_remote_wakeup = 1;
559 mutex_lock(&acm->mutex);
561 usb_autopm_put_interface(acm->control);
566 acm->ctrlurb->dev = acm->dev;
567 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
568 dbg("usb_submit_urb(ctrl irq) failed");
572 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
573 (acm->ctrl_caps & USB_CDC_CAP_LINE))
575 usb_autopm_put_interface(acm->control);
577 INIT_LIST_HEAD(&acm->spare_read_urbs);
578 INIT_LIST_HEAD(&acm->spare_read_bufs);
579 INIT_LIST_HEAD(&acm->filled_read_bufs);
580 for (i = 0; i < acm->rx_buflimit; i++) {
581 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
583 for (i = 0; i < acm->rx_buflimit; i++) {
584 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
589 tasklet_schedule(&acm->urb_task);
592 mutex_unlock(&acm->mutex);
594 mutex_unlock(&open_mutex);
598 usb_kill_urb(acm->ctrlurb);
600 usb_autopm_put_interface(acm->control);
602 mutex_unlock(&acm->mutex);
604 mutex_unlock(&open_mutex);
608 static void acm_tty_unregister(struct acm *acm)
612 nr = acm->rx_buflimit;
613 tty_unregister_device(acm_tty_driver, acm->minor);
614 usb_put_intf(acm->control);
615 acm_table[acm->minor] = NULL;
616 usb_free_urb(acm->ctrlurb);
617 for (i = 0; i < ACM_NW; i++)
618 usb_free_urb(acm->wb[i].urb);
619 for (i = 0; i < nr; i++)
620 usb_free_urb(acm->ru[i].urb);
621 kfree(acm->country_codes);
625 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
627 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
629 struct acm *acm = tty->driver_data;
632 if (!acm || !acm->used)
635 nr = acm->rx_buflimit;
636 mutex_lock(&open_mutex);
639 usb_autopm_get_interface(acm->control);
640 acm_set_control(acm, acm->ctrlout = 0);
642 /* try letting the last writes drain naturally */
643 wait_event_interruptible_timeout(acm->drain_wait,
644 (ACM_NW == acm_wb_is_avail(acm))
646 ACM_CLOSE_TIMEOUT * HZ);
648 usb_kill_urb(acm->ctrlurb);
649 for (i = 0; i < ACM_NW; i++)
650 usb_kill_urb(acm->wb[i].urb);
651 for (i = 0; i < nr; i++)
652 usb_kill_urb(acm->ru[i].urb);
653 acm->control->needs_remote_wakeup = 0;
654 usb_autopm_put_interface(acm->control);
656 acm_tty_unregister(acm);
658 mutex_unlock(&open_mutex);
661 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
663 struct acm *acm = tty->driver_data;
669 dbg("Entering acm_tty_write to write %d bytes,", count);
676 spin_lock_irqsave(&acm->write_lock, flags);
677 if ((wbn = acm_wb_alloc(acm)) < 0) {
678 spin_unlock_irqrestore(&acm->write_lock, flags);
683 count = (count > acm->writesize) ? acm->writesize : count;
684 dbg("Get %d bytes...", count);
685 memcpy(wb->buf, buf, count);
687 spin_unlock_irqrestore(&acm->write_lock, flags);
689 if ((stat = acm_write_start(acm, wbn)) < 0)
694 static int acm_tty_write_room(struct tty_struct *tty)
696 struct acm *acm = tty->driver_data;
700 * Do not let the line discipline to know that we have a reserve,
701 * or it might get too enthusiastic.
703 return acm_wb_is_avail(acm) ? acm->writesize : 0;
706 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
708 struct acm *acm = tty->driver_data;
712 * This is inaccurate (overcounts), but it works.
714 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
717 static void acm_tty_throttle(struct tty_struct *tty)
719 struct acm *acm = tty->driver_data;
722 spin_lock_bh(&acm->throttle_lock);
724 spin_unlock_bh(&acm->throttle_lock);
727 static void acm_tty_unthrottle(struct tty_struct *tty)
729 struct acm *acm = tty->driver_data;
732 spin_lock_bh(&acm->throttle_lock);
734 spin_unlock_bh(&acm->throttle_lock);
735 tasklet_schedule(&acm->urb_task);
738 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
740 struct acm *acm = tty->driver_data;
744 retval = acm_send_break(acm, state ? 0xffff : 0);
746 dbg("send break failed");
750 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
752 struct acm *acm = tty->driver_data;
757 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
758 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
759 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
760 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
761 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
765 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
766 unsigned int set, unsigned int clear)
768 struct acm *acm = tty->driver_data;
769 unsigned int newctrl;
774 newctrl = acm->ctrlout;
775 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
776 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
778 newctrl = (newctrl & ~clear) | set;
780 if (acm->ctrlout == newctrl)
782 return acm_set_control(acm, acm->ctrlout = newctrl);
785 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
787 struct acm *acm = tty->driver_data;
795 static const __u32 acm_tty_speed[] = {
796 0, 50, 75, 110, 134, 150, 200, 300, 600,
797 1200, 1800, 2400, 4800, 9600, 19200, 38400,
798 57600, 115200, 230400, 460800, 500000, 576000,
799 921600, 1000000, 1152000, 1500000, 2000000,
800 2500000, 3000000, 3500000, 4000000
803 static const __u8 acm_tty_size[] = {
807 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
809 struct acm *acm = tty->driver_data;
810 struct ktermios *termios = tty->termios;
811 struct usb_cdc_line_coding newline;
812 int newctrl = acm->ctrlout;
817 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
818 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
819 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
820 newline.bParityType = termios->c_cflag & PARENB ?
821 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
822 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
824 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
826 if (!newline.dwDTERate) {
827 newline.dwDTERate = acm->line.dwDTERate;
828 newctrl &= ~ACM_CTRL_DTR;
829 } else newctrl |= ACM_CTRL_DTR;
831 if (newctrl != acm->ctrlout)
832 acm_set_control(acm, acm->ctrlout = newctrl);
834 if (memcmp(&acm->line, &newline, sizeof newline)) {
835 memcpy(&acm->line, &newline, sizeof newline);
836 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
837 newline.bCharFormat, newline.bParityType,
839 acm_set_line(acm, &acm->line);
844 * USB probe and disconnect routines.
847 /* Little helpers: write/read buffers free */
848 static void acm_write_buffers_free(struct acm *acm)
853 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
854 usb_buffer_free(acm->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 dev_err(&intf->dev, "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;
938 "Zero length descriptor references\n");
944 if (buffer [1] != USB_DT_CS_INTERFACE) {
945 dev_err(&intf->dev, "skipping garbage\n");
949 switch (buffer [2]) {
950 case USB_CDC_UNION_TYPE: /* we've found it */
952 dev_err(&intf->dev, "More than one "
957 union_header = (struct usb_cdc_union_desc *)
960 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
961 cfd = (struct usb_cdc_country_functional_desc *)buffer;
963 case USB_CDC_HEADER_TYPE: /* maybe check version */
964 break; /* for now we ignore it */
965 case USB_CDC_ACM_TYPE:
966 ac_management_function = buffer[3];
968 case USB_CDC_CALL_MANAGEMENT_TYPE:
969 call_management_function = buffer[3];
970 call_interface_num = buffer[4];
971 if ((call_management_function & 3) != 3)
972 dev_err(&intf->dev, "This device "
973 "cannot do calls on its own. "
974 "It is no modem.\n");
977 /* there are LOTS more CDC descriptors that
978 * could legitimately be found here.
980 dev_dbg(&intf->dev, "Ignoring descriptor: "
981 "type %02x, length %d\n",
982 buffer[2], buffer[0]);
991 if (call_interface_num > 0) {
992 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
993 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
994 control_interface = intf;
996 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1000 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1001 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1002 if (!control_interface || !data_interface) {
1003 dev_dbg(&intf->dev,"no interfaces\n");
1008 if (data_interface_num != call_interface_num)
1009 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
1013 /*workaround for switched interfaces */
1014 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
1015 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
1016 struct usb_interface *t;
1017 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
1019 t = control_interface;
1020 control_interface = data_interface;
1027 /* Accept probe requests only for the control interface */
1028 if (intf != control_interface)
1031 if (usb_interface_claimed(data_interface)) { /* valid in this context */
1032 dev_dbg(&intf->dev,"The data interface isn't available\n");
1037 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1040 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1041 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1042 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1045 /* workaround for switched endpoints */
1046 if (!usb_endpoint_dir_in(epread)) {
1047 /* descriptors are swapped */
1048 struct usb_endpoint_descriptor *t;
1049 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
1055 dbg("interfaces are valid");
1056 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1058 if (minor == ACM_TTY_MINORS) {
1059 dev_err(&intf->dev, "no more free acm devices\n");
1063 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
1064 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1068 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1069 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
1070 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1071 acm->control = control_interface;
1072 acm->data = data_interface;
1075 acm->ctrl_caps = ac_management_function;
1076 acm->ctrlsize = ctrlsize;
1077 acm->readsize = readsize;
1078 acm->rx_buflimit = num_rx_buf;
1079 acm->urb_task.func = acm_rx_tasklet;
1080 acm->urb_task.data = (unsigned long) acm;
1081 INIT_WORK(&acm->work, acm_softint);
1082 INIT_WORK(&acm->waker, acm_waker);
1083 init_waitqueue_head(&acm->drain_wait);
1084 spin_lock_init(&acm->throttle_lock);
1085 spin_lock_init(&acm->write_lock);
1086 spin_lock_init(&acm->read_lock);
1087 mutex_init(&acm->mutex);
1088 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1090 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1092 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1095 acm->ctrl_buffer = buf;
1097 if (acm_write_buffers_alloc(acm) < 0) {
1098 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1102 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1103 if (!acm->ctrlurb) {
1104 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1107 for (i = 0; i < num_rx_buf; i++) {
1108 struct acm_ru *rcv = &(acm->ru[i]);
1110 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1111 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1115 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1116 rcv->instance = acm;
1118 for (i = 0; i < num_rx_buf; i++) {
1119 struct acm_rb *rb = &(acm->rb[i]);
1121 rb->base = usb_buffer_alloc(acm->dev, readsize,
1122 GFP_KERNEL, &rb->dma);
1124 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1128 for(i = 0; i < ACM_NW; i++)
1130 struct acm_wb *snd = &(acm->wb[i]);
1132 if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1133 dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
1137 usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1138 NULL, acm->writesize, acm_write_bulk, snd);
1139 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1140 snd->instance = acm;
1143 usb_set_intfdata (intf, acm);
1145 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1149 if (cfd) { /* export the country data */
1150 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1151 if (!acm->country_codes)
1152 goto skip_countries;
1153 acm->country_code_size = cfd->bLength - 4;
1154 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1155 acm->country_rel_date = cfd->iCountryCodeRelDate;
1157 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1159 kfree(acm->country_codes);
1160 goto skip_countries;
1163 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1165 kfree(acm->country_codes);
1166 goto skip_countries;
1171 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1172 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1173 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1174 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1176 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1178 acm_set_control(acm, acm->ctrlout);
1180 acm->line.dwDTERate = cpu_to_le32(9600);
1181 acm->line.bDataBits = 8;
1182 acm_set_line(acm, &acm->line);
1184 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1185 usb_set_intfdata(data_interface, acm);
1187 usb_get_intf(control_interface);
1188 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1190 acm_table[minor] = acm;
1194 for (i = 0; i < ACM_NW; i++)
1195 usb_free_urb(acm->wb[i].urb);
1197 acm_read_buffers_free(acm);
1198 for (i = 0; i < num_rx_buf; i++)
1199 usb_free_urb(acm->ru[i].urb);
1200 usb_free_urb(acm->ctrlurb);
1202 acm_write_buffers_free(acm);
1204 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1211 static void stop_data_traffic(struct acm *acm)
1214 dbg("Entering stop_data_traffic");
1216 tasklet_disable(&acm->urb_task);
1218 usb_kill_urb(acm->ctrlurb);
1219 for(i = 0; i < ACM_NW; i++)
1220 usb_kill_urb(acm->wb[i].urb);
1221 for (i = 0; i < acm->rx_buflimit; i++)
1222 usb_kill_urb(acm->ru[i].urb);
1224 tasklet_enable(&acm->urb_task);
1226 cancel_work_sync(&acm->work);
1227 cancel_work_sync(&acm->waker);
1230 static void acm_disconnect(struct usb_interface *intf)
1232 struct acm *acm = usb_get_intfdata(intf);
1233 struct usb_device *usb_dev = interface_to_usbdev(intf);
1235 /* sibling interface is already cleaning up */
1239 mutex_lock(&open_mutex);
1240 if (acm->country_codes){
1241 device_remove_file(&acm->control->dev,
1242 &dev_attr_wCountryCodes);
1243 device_remove_file(&acm->control->dev,
1244 &dev_attr_iCountryCodeRelDate);
1246 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1248 usb_set_intfdata(acm->control, NULL);
1249 usb_set_intfdata(acm->data, NULL);
1251 stop_data_traffic(acm);
1253 acm_write_buffers_free(acm);
1254 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1255 acm_read_buffers_free(acm);
1257 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1258 acm->data : acm->control);
1261 acm_tty_unregister(acm);
1262 mutex_unlock(&open_mutex);
1266 mutex_unlock(&open_mutex);
1269 tty_hangup(acm->tty);
1273 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1275 struct acm *acm = usb_get_intfdata(intf);
1278 if (acm->dev->auto_pm) {
1281 spin_lock_irq(&acm->read_lock);
1282 spin_lock(&acm->write_lock);
1283 b = acm->processing + acm->transmitting;
1284 spin_unlock(&acm->write_lock);
1285 spin_unlock_irq(&acm->read_lock);
1290 spin_lock_irq(&acm->read_lock);
1291 spin_lock(&acm->write_lock);
1292 cnt = acm->susp_count++;
1293 spin_unlock(&acm->write_lock);
1294 spin_unlock_irq(&acm->read_lock);
1299 we treat opened interfaces differently,
1300 we must guard against open
1302 mutex_lock(&acm->mutex);
1305 stop_data_traffic(acm);
1307 mutex_unlock(&acm->mutex);
1311 static int acm_resume(struct usb_interface *intf)
1313 struct acm *acm = usb_get_intfdata(intf);
1317 spin_lock_irq(&acm->read_lock);
1318 acm->susp_count -= 1;
1319 cnt = acm->susp_count;
1320 spin_unlock_irq(&acm->read_lock);
1325 mutex_lock(&acm->mutex);
1327 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1331 tasklet_schedule(&acm->urb_task);
1335 mutex_unlock(&acm->mutex);
1339 #endif /* CONFIG_PM */
1341 * USB driver structure.
1344 static struct usb_device_id acm_ids[] = {
1345 /* quirky and broken devices */
1346 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1347 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1349 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1350 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1352 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1353 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1355 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1356 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1358 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1359 .driver_info = SINGLE_RX_URB, /* firmware bug */
1361 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1362 .driver_info = SINGLE_RX_URB, /* firmware bug */
1364 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1365 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1367 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1368 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1370 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1371 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1374 /* control interfaces with various AT-command sets */
1375 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1376 USB_CDC_ACM_PROTO_AT_V25TER) },
1377 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1378 USB_CDC_ACM_PROTO_AT_PCCA101) },
1379 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1380 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1381 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1382 USB_CDC_ACM_PROTO_AT_GSM) },
1383 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1384 USB_CDC_ACM_PROTO_AT_3G ) },
1385 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1386 USB_CDC_ACM_PROTO_AT_CDMA) },
1388 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1392 MODULE_DEVICE_TABLE (usb, acm_ids);
1394 static struct usb_driver acm_driver = {
1397 .disconnect = acm_disconnect,
1399 .suspend = acm_suspend,
1400 .resume = acm_resume,
1402 .id_table = acm_ids,
1404 .supports_autosuspend = 1,
1409 * TTY driver structures.
1412 static const struct tty_operations acm_ops = {
1413 .open = acm_tty_open,
1414 .close = acm_tty_close,
1415 .write = acm_tty_write,
1416 .write_room = acm_tty_write_room,
1417 .ioctl = acm_tty_ioctl,
1418 .throttle = acm_tty_throttle,
1419 .unthrottle = acm_tty_unthrottle,
1420 .chars_in_buffer = acm_tty_chars_in_buffer,
1421 .break_ctl = acm_tty_break_ctl,
1422 .set_termios = acm_tty_set_termios,
1423 .tiocmget = acm_tty_tiocmget,
1424 .tiocmset = acm_tty_tiocmset,
1431 static int __init acm_init(void)
1434 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1435 if (!acm_tty_driver)
1437 acm_tty_driver->owner = THIS_MODULE,
1438 acm_tty_driver->driver_name = "acm",
1439 acm_tty_driver->name = "ttyACM",
1440 acm_tty_driver->major = ACM_TTY_MAJOR,
1441 acm_tty_driver->minor_start = 0,
1442 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1443 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1444 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1445 acm_tty_driver->init_termios = tty_std_termios;
1446 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1447 tty_set_operations(acm_tty_driver, &acm_ops);
1449 retval = tty_register_driver(acm_tty_driver);
1451 put_tty_driver(acm_tty_driver);
1455 retval = usb_register(&acm_driver);
1457 tty_unregister_driver(acm_tty_driver);
1458 put_tty_driver(acm_tty_driver);
1462 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1468 static void __exit acm_exit(void)
1470 usb_deregister(&acm_driver);
1471 tty_unregister_driver(acm_tty_driver);
1472 put_tty_driver(acm_tty_driver);
1475 module_init(acm_init);
1476 module_exit(acm_exit);
1478 MODULE_AUTHOR( DRIVER_AUTHOR );
1479 MODULE_DESCRIPTION( DRIVER_DESC );
1480 MODULE_LICENSE("GPL");