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
21 * v0.13 - added termios, added hangup
22 * v0.14 - sized down struct acm
23 * v0.15 - fixed flow control again - characters could be lost
24 * v0.16 - added code for modems with swapped data and control interfaces
25 * v0.17 - added new style probing
26 * v0.18 - fixed new style probing for devices with more configurations
27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28 * v0.20 - switched to probing on interface (rather than device) class
29 * v0.21 - revert to probing on device for devices with multiple configs
30 * v0.22 - probe only the control interface. if usbcore doesn't choose the
31 * config we want, sysadmin changes bConfigurationValue in sysfs.
32 * v0.23 - use softirq for rx processing, as needed by tty layer
33 * v0.24 - change probe method to evaluate CDC union descriptor
34 * v0.25 - downstream tasks paralelized to maximize throughput
35 * v0.26 - multiple write urbs, writesize increased
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 * GNU General Public License for more details.
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/tty.h>
62 #include <linux/serial.h>
63 #include <linux/tty_driver.h>
64 #include <linux/tty_flip.h>
65 #include <linux/module.h>
66 #include <linux/mutex.h>
67 #include <linux/uaccess.h>
68 #include <linux/usb.h>
69 #include <linux/usb/cdc.h>
70 #include <asm/byteorder.h>
71 #include <asm/unaligned.h>
72 #include <linux/list.h>
77 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
82 #define DRIVER_VERSION "v0.26"
83 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
84 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
86 static struct usb_driver acm_driver;
87 static struct tty_driver *acm_tty_driver;
88 static struct acm *acm_table[ACM_TTY_MINORS];
90 static DEFINE_MUTEX(open_mutex);
92 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
94 static const struct tty_port_operations acm_port_ops = {
104 * Functions for ACM control messages.
107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
110 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
111 request, USB_RT_ACM, value,
112 acm->control->altsetting[0].desc.bInterfaceNumber,
114 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
115 request, value, len, retval);
116 return retval < 0 ? retval : 0;
119 /* devices aren't required to support these requests.
120 * the cdc acm descriptor tells whether they do...
122 #define acm_set_control(acm, control) \
123 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124 #define acm_set_line(acm, line) \
125 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126 #define acm_send_break(acm, ms) \
127 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
130 * Write buffer management.
131 * All of these assume proper locks taken by the caller.
134 static int acm_wb_alloc(struct acm *acm)
147 wbn = (wbn + 1) % ACM_NW;
153 static int acm_wb_is_avail(struct acm *acm)
159 spin_lock_irqsave(&acm->write_lock, flags);
160 for (i = 0; i < ACM_NW; i++)
162 spin_unlock_irqrestore(&acm->write_lock, flags);
167 * Finish write. Caller must hold acm->write_lock
169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
178 * the caller is responsible for locking
181 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
187 wb->urb->transfer_buffer = wb->buf;
188 wb->urb->transfer_dma = wb->dmah;
189 wb->urb->transfer_buffer_length = wb->len;
190 wb->urb->dev = acm->dev;
192 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
194 dbg("usb_submit_urb(write bulk) failed: %d", rc);
195 acm_write_done(acm, wb);
200 static int acm_write_start(struct acm *acm, int wbn)
203 struct acm_wb *wb = &acm->wb[wbn];
206 spin_lock_irqsave(&acm->write_lock, flags);
209 spin_unlock_irqrestore(&acm->write_lock, flags);
213 dbg("%s susp_count: %d", __func__, acm->susp_count);
214 if (acm->susp_count) {
215 acm->delayed_wb = wb;
216 schedule_work(&acm->waker);
217 spin_unlock_irqrestore(&acm->write_lock, flags);
218 return 0; /* A white lie */
220 usb_mark_last_busy(acm->dev);
222 rc = acm_start_wb(acm, wb);
223 spin_unlock_irqrestore(&acm->write_lock, flags);
229 * attributes exported through sysfs
231 static ssize_t show_caps
232 (struct device *dev, struct device_attribute *attr, char *buf)
234 struct usb_interface *intf = to_usb_interface(dev);
235 struct acm *acm = usb_get_intfdata(intf);
237 return sprintf(buf, "%d", acm->ctrl_caps);
239 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
241 static ssize_t show_country_codes
242 (struct device *dev, struct device_attribute *attr, char *buf)
244 struct usb_interface *intf = to_usb_interface(dev);
245 struct acm *acm = usb_get_intfdata(intf);
247 memcpy(buf, acm->country_codes, acm->country_code_size);
248 return acm->country_code_size;
251 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
253 static ssize_t show_country_rel_date
254 (struct device *dev, struct device_attribute *attr, char *buf)
256 struct usb_interface *intf = to_usb_interface(dev);
257 struct acm *acm = usb_get_intfdata(intf);
259 return sprintf(buf, "%d", acm->country_rel_date);
262 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
264 * Interrupt handlers for various ACM device responses
267 /* control interface reports status changes with "interrupt" transfers */
268 static void acm_ctrl_irq(struct urb *urb)
270 struct acm *acm = urb->context;
271 struct usb_cdc_notification *dr = urb->transfer_buffer;
272 struct tty_struct *tty;
276 int status = urb->status;
285 /* this urb is terminated, clean up */
286 dbg("%s - urb shutting down with status: %d", __func__, status);
289 dbg("%s - nonzero urb status received: %d", __func__, status);
296 data = (unsigned char *)(dr + 1);
297 switch (dr->bNotificationType) {
298 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
299 dbg("%s network", dr->wValue ?
300 "connected to" : "disconnected from");
303 case USB_CDC_NOTIFY_SERIAL_STATE:
304 tty = tty_port_tty_get(&acm->port);
305 newctrl = get_unaligned_le16(data);
309 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
310 dbg("calling hangup");
316 acm->ctrlin = newctrl;
318 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
319 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
320 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
321 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
322 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
323 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
329 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
330 dr->bNotificationType, dr->wIndex,
331 dr->wLength, data[0], data[1]);
335 usb_mark_last_busy(acm->dev);
336 retval = usb_submit_urb(urb, GFP_ATOMIC);
338 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
339 "result %d", __func__, retval);
342 /* data interface returns incoming bytes, or we got unthrottled */
343 static void acm_read_bulk(struct urb *urb)
346 struct acm_ru *rcv = urb->context;
347 struct acm *acm = rcv->instance;
348 int status = urb->status;
350 dbg("Entering acm_read_bulk with status %d", status);
352 if (!ACM_READY(acm)) {
353 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
356 usb_mark_last_busy(acm->dev);
359 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
362 buf->size = urb->actual_length;
364 if (likely(status == 0)) {
365 spin_lock(&acm->read_lock);
367 list_add_tail(&rcv->list, &acm->spare_read_urbs);
368 list_add_tail(&buf->list, &acm->filled_read_bufs);
369 spin_unlock(&acm->read_lock);
371 /* we drop the buffer due to an error */
372 spin_lock(&acm->read_lock);
373 list_add_tail(&rcv->list, &acm->spare_read_urbs);
374 list_add(&buf->list, &acm->spare_read_bufs);
375 spin_unlock(&acm->read_lock);
376 /* nevertheless the tasklet must be kicked unconditionally
377 so the queue cannot dry up */
379 if (likely(!acm->susp_count))
380 tasklet_schedule(&acm->urb_task);
383 static void acm_rx_tasklet(unsigned long _acm)
385 struct acm *acm = (void *)_acm;
387 struct tty_struct *tty;
390 unsigned char throttled;
392 dbg("Entering acm_rx_tasklet");
394 if (!ACM_READY(acm)) {
395 dbg("acm_rx_tasklet: ACM not ready");
399 spin_lock_irqsave(&acm->throttle_lock, flags);
400 throttled = acm->throttle;
401 spin_unlock_irqrestore(&acm->throttle_lock, flags);
403 dbg("acm_rx_tasklet: throttled");
407 tty = tty_port_tty_get(&acm->port);
410 spin_lock_irqsave(&acm->read_lock, flags);
411 if (list_empty(&acm->filled_read_bufs)) {
412 spin_unlock_irqrestore(&acm->read_lock, flags);
415 buf = list_entry(acm->filled_read_bufs.next,
416 struct acm_rb, list);
417 list_del(&buf->list);
418 spin_unlock_irqrestore(&acm->read_lock, flags);
420 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
423 spin_lock_irqsave(&acm->throttle_lock, flags);
424 throttled = acm->throttle;
425 spin_unlock_irqrestore(&acm->throttle_lock, flags);
427 tty_buffer_request_room(tty, buf->size);
428 tty_insert_flip_string(tty, buf->base, buf->size);
429 tty_flip_buffer_push(tty);
432 dbg("Throttling noticed");
433 spin_lock_irqsave(&acm->read_lock, flags);
434 list_add(&buf->list, &acm->filled_read_bufs);
435 spin_unlock_irqrestore(&acm->read_lock, flags);
440 spin_lock_irqsave(&acm->read_lock, flags);
441 list_add(&buf->list, &acm->spare_read_bufs);
442 spin_unlock_irqrestore(&acm->read_lock, flags);
448 while (!list_empty(&acm->spare_read_bufs)) {
449 spin_lock_irqsave(&acm->read_lock, flags);
450 if (list_empty(&acm->spare_read_urbs)) {
452 spin_unlock_irqrestore(&acm->read_lock, flags);
455 rcv = list_entry(acm->spare_read_urbs.next,
456 struct acm_ru, list);
457 list_del(&rcv->list);
458 spin_unlock_irqrestore(&acm->read_lock, flags);
460 buf = list_entry(acm->spare_read_bufs.next,
461 struct acm_rb, list);
462 list_del(&buf->list);
467 usb_fill_int_urb(rcv->urb, acm->dev,
471 acm_read_bulk, rcv, acm->bInterval);
473 usb_fill_bulk_urb(rcv->urb, acm->dev,
478 rcv->urb->transfer_dma = buf->dma;
479 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
481 /* This shouldn't kill the driver as unsuccessful URBs are
482 returned to the free-urbs-pool and resubmited ASAP */
483 spin_lock_irqsave(&acm->read_lock, flags);
484 if (acm->susp_count ||
485 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
486 list_add(&buf->list, &acm->spare_read_bufs);
487 list_add(&rcv->list, &acm->spare_read_urbs);
489 spin_unlock_irqrestore(&acm->read_lock, flags);
492 spin_unlock_irqrestore(&acm->read_lock, flags);
493 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
496 spin_lock_irqsave(&acm->read_lock, flags);
498 spin_unlock_irqrestore(&acm->read_lock, flags);
501 /* data interface wrote those outgoing bytes */
502 static void acm_write_bulk(struct urb *urb)
504 struct acm_wb *wb = urb->context;
505 struct acm *acm = wb->instance;
508 if (verbose || urb->status
509 || (urb->actual_length != urb->transfer_buffer_length))
510 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
512 urb->transfer_buffer_length,
515 spin_lock_irqsave(&acm->write_lock, flags);
516 acm_write_done(acm, wb);
517 spin_unlock_irqrestore(&acm->write_lock, flags);
519 schedule_work(&acm->work);
521 wake_up_interruptible(&acm->drain_wait);
524 static void acm_softint(struct work_struct *work)
526 struct acm *acm = container_of(work, struct acm, work);
527 struct tty_struct *tty;
529 dev_vdbg(&acm->data->dev, "tx work\n");
532 tty = tty_port_tty_get(&acm->port);
537 static void acm_waker(struct work_struct *waker)
539 struct acm *acm = container_of(waker, struct acm, waker);
542 rv = usb_autopm_get_interface(acm->control);
544 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
547 if (acm->delayed_wb) {
548 acm_start_wb(acm, acm->delayed_wb);
549 acm->delayed_wb = NULL;
551 usb_autopm_put_interface(acm->control);
558 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
563 dbg("Entering acm_tty_open.");
565 mutex_lock(&open_mutex);
567 acm = acm_table[tty->index];
568 if (!acm || !acm->dev)
573 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
575 tty->driver_data = acm;
576 tty_port_tty_set(&acm->port, tty);
578 if (usb_autopm_get_interface(acm->control) < 0)
581 acm->control->needs_remote_wakeup = 1;
583 mutex_lock(&acm->mutex);
584 if (acm->port.count++) {
585 usb_autopm_put_interface(acm->control);
589 acm->ctrlurb->dev = acm->dev;
590 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
591 dbg("usb_submit_urb(ctrl irq) failed");
595 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
596 (acm->ctrl_caps & USB_CDC_CAP_LINE))
599 usb_autopm_put_interface(acm->control);
601 INIT_LIST_HEAD(&acm->spare_read_urbs);
602 INIT_LIST_HEAD(&acm->spare_read_bufs);
603 INIT_LIST_HEAD(&acm->filled_read_bufs);
605 for (i = 0; i < acm->rx_buflimit; i++)
606 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
607 for (i = 0; i < acm->rx_buflimit; i++)
608 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
612 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
613 rv = tty_port_block_til_ready(&acm->port, tty, filp);
614 tasklet_schedule(&acm->urb_task);
616 mutex_unlock(&acm->mutex);
618 mutex_unlock(&open_mutex);
622 usb_kill_urb(acm->ctrlurb);
624 usb_autopm_put_interface(acm->control);
626 mutex_unlock(&acm->mutex);
628 mutex_unlock(&open_mutex);
629 tty_port_tty_set(&acm->port, NULL);
633 static void acm_tty_unregister(struct acm *acm)
637 nr = acm->rx_buflimit;
638 tty_unregister_device(acm_tty_driver, acm->minor);
639 usb_put_intf(acm->control);
640 acm_table[acm->minor] = NULL;
641 usb_free_urb(acm->ctrlurb);
642 for (i = 0; i < ACM_NW; i++)
643 usb_free_urb(acm->wb[i].urb);
644 for (i = 0; i < nr; i++)
645 usb_free_urb(acm->ru[i].urb);
646 kfree(acm->country_codes);
650 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
652 static void acm_port_down(struct acm *acm, int drain)
654 int i, nr = acm->rx_buflimit;
655 mutex_lock(&open_mutex);
657 usb_autopm_get_interface(acm->control);
658 acm_set_control(acm, acm->ctrlout = 0);
659 /* try letting the last writes drain naturally */
661 wait_event_interruptible_timeout(acm->drain_wait,
662 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
663 ACM_CLOSE_TIMEOUT * HZ);
665 usb_kill_urb(acm->ctrlurb);
666 for (i = 0; i < ACM_NW; i++)
667 usb_kill_urb(acm->wb[i].urb);
668 for (i = 0; i < nr; i++)
669 usb_kill_urb(acm->ru[i].urb);
670 acm->control->needs_remote_wakeup = 0;
671 usb_autopm_put_interface(acm->control);
673 mutex_unlock(&open_mutex);
676 static void acm_tty_hangup(struct tty_struct *tty)
678 struct acm *acm = tty->driver_data;
679 tty_port_hangup(&acm->port);
680 acm_port_down(acm, 0);
683 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
685 struct acm *acm = tty->driver_data;
687 /* Perform the closing process and see if we need to do the hardware
691 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
692 mutex_lock(&open_mutex);
694 tty_port_tty_set(&acm->port, NULL);
695 acm_tty_unregister(acm);
696 tty->driver_data = NULL;
698 mutex_unlock(&open_mutex);
701 acm_port_down(acm, 0);
702 tty_port_close_end(&acm->port, tty);
703 tty_port_tty_set(&acm->port, NULL);
706 static int acm_tty_write(struct tty_struct *tty,
707 const unsigned char *buf, int count)
709 struct acm *acm = tty->driver_data;
715 dbg("Entering acm_tty_write to write %d bytes,", count);
722 spin_lock_irqsave(&acm->write_lock, flags);
723 wbn = acm_wb_alloc(acm);
725 spin_unlock_irqrestore(&acm->write_lock, flags);
730 count = (count > acm->writesize) ? acm->writesize : count;
731 dbg("Get %d bytes...", count);
732 memcpy(wb->buf, buf, count);
734 spin_unlock_irqrestore(&acm->write_lock, flags);
736 stat = acm_write_start(acm, wbn);
742 static int acm_tty_write_room(struct tty_struct *tty)
744 struct acm *acm = tty->driver_data;
748 * Do not let the line discipline to know that we have a reserve,
749 * or it might get too enthusiastic.
751 return acm_wb_is_avail(acm) ? acm->writesize : 0;
754 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
756 struct acm *acm = tty->driver_data;
760 * This is inaccurate (overcounts), but it works.
762 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
765 static void acm_tty_throttle(struct tty_struct *tty)
767 struct acm *acm = tty->driver_data;
770 spin_lock_bh(&acm->throttle_lock);
772 spin_unlock_bh(&acm->throttle_lock);
775 static void acm_tty_unthrottle(struct tty_struct *tty)
777 struct acm *acm = tty->driver_data;
780 spin_lock_bh(&acm->throttle_lock);
782 spin_unlock_bh(&acm->throttle_lock);
783 tasklet_schedule(&acm->urb_task);
786 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
788 struct acm *acm = tty->driver_data;
792 retval = acm_send_break(acm, state ? 0xffff : 0);
794 dbg("send break failed");
798 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
800 struct acm *acm = tty->driver_data;
805 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
806 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
807 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
808 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
809 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
813 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
814 unsigned int set, unsigned int clear)
816 struct acm *acm = tty->driver_data;
817 unsigned int newctrl;
822 newctrl = acm->ctrlout;
823 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
824 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
825 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
826 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
828 newctrl = (newctrl & ~clear) | set;
830 if (acm->ctrlout == newctrl)
832 return acm_set_control(acm, acm->ctrlout = newctrl);
835 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
836 unsigned int cmd, unsigned long arg)
838 struct acm *acm = tty->driver_data;
846 static const __u32 acm_tty_speed[] = {
847 0, 50, 75, 110, 134, 150, 200, 300, 600,
848 1200, 1800, 2400, 4800, 9600, 19200, 38400,
849 57600, 115200, 230400, 460800, 500000, 576000,
850 921600, 1000000, 1152000, 1500000, 2000000,
851 2500000, 3000000, 3500000, 4000000
854 static const __u8 acm_tty_size[] = {
858 static void acm_tty_set_termios(struct tty_struct *tty,
859 struct ktermios *termios_old)
861 struct acm *acm = tty->driver_data;
862 struct ktermios *termios = tty->termios;
863 struct usb_cdc_line_coding newline;
864 int newctrl = acm->ctrlout;
869 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
870 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
871 newline.bParityType = termios->c_cflag & PARENB ?
872 (termios->c_cflag & PARODD ? 1 : 2) +
873 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
874 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
875 /* FIXME: Needs to clear unsupported bits in the termios */
876 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
878 if (!newline.dwDTERate) {
879 newline.dwDTERate = acm->line.dwDTERate;
880 newctrl &= ~ACM_CTRL_DTR;
882 newctrl |= ACM_CTRL_DTR;
884 if (newctrl != acm->ctrlout)
885 acm_set_control(acm, acm->ctrlout = newctrl);
887 if (memcmp(&acm->line, &newline, sizeof newline)) {
888 memcpy(&acm->line, &newline, sizeof newline);
889 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
890 newline.bCharFormat, newline.bParityType,
892 acm_set_line(acm, &acm->line);
897 * USB probe and disconnect routines.
900 /* Little helpers: write/read buffers free */
901 static void acm_write_buffers_free(struct acm *acm)
905 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
907 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
908 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
911 static void acm_read_buffers_free(struct acm *acm)
913 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
914 int i, n = acm->rx_buflimit;
916 for (i = 0; i < n; i++)
917 usb_buffer_free(usb_dev, acm->readsize,
918 acm->rb[i].base, acm->rb[i].dma);
921 /* Little helper: write buffers allocate */
922 static int acm_write_buffers_alloc(struct acm *acm)
927 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
928 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
934 usb_buffer_free(acm->dev, acm->writesize,
943 static int acm_probe(struct usb_interface *intf,
944 const struct usb_device_id *id)
946 struct usb_cdc_union_desc *union_header = NULL;
947 struct usb_cdc_country_functional_desc *cfd = NULL;
948 unsigned char *buffer = intf->altsetting->extra;
949 int buflen = intf->altsetting->extralen;
950 struct usb_interface *control_interface;
951 struct usb_interface *data_interface;
952 struct usb_endpoint_descriptor *epctrl = NULL;
953 struct usb_endpoint_descriptor *epread = NULL;
954 struct usb_endpoint_descriptor *epwrite = NULL;
955 struct usb_device *usb_dev = interface_to_usbdev(intf);
958 int ctrlsize, readsize;
960 u8 ac_management_function = 0;
961 u8 call_management_function = 0;
962 int call_interface_num = -1;
963 int data_interface_num;
964 unsigned long quirks;
967 int combined_interfaces = 0;
970 quirks = (unsigned long)id->driver_info;
971 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
973 /* handle quirks deadly to normal probing*/
974 if (quirks == NO_UNION_NORMAL) {
975 data_interface = usb_ifnum_to_if(usb_dev, 1);
976 control_interface = usb_ifnum_to_if(usb_dev, 0);
977 goto skip_normal_probe;
982 dev_err(&intf->dev, "Weird descriptor references\n");
987 if (intf->cur_altsetting->endpoint->extralen &&
988 intf->cur_altsetting->endpoint->extra) {
990 "Seeking extra descriptors on endpoint\n");
991 buflen = intf->cur_altsetting->endpoint->extralen;
992 buffer = intf->cur_altsetting->endpoint->extra;
995 "Zero length descriptor references\n");
1000 while (buflen > 0) {
1001 if (buffer[1] != USB_DT_CS_INTERFACE) {
1002 dev_err(&intf->dev, "skipping garbage\n");
1006 switch (buffer[2]) {
1007 case USB_CDC_UNION_TYPE: /* we've found it */
1009 dev_err(&intf->dev, "More than one "
1010 "union descriptor, skipping ...\n");
1013 union_header = (struct usb_cdc_union_desc *)buffer;
1015 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1016 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1018 case USB_CDC_HEADER_TYPE: /* maybe check version */
1019 break; /* for now we ignore it */
1020 case USB_CDC_ACM_TYPE:
1021 ac_management_function = buffer[3];
1023 case USB_CDC_CALL_MANAGEMENT_TYPE:
1024 call_management_function = buffer[3];
1025 call_interface_num = buffer[4];
1026 if ((call_management_function & 3) != 3)
1027 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1030 /* there are LOTS more CDC descriptors that
1031 * could legitimately be found here.
1033 dev_dbg(&intf->dev, "Ignoring descriptor: "
1034 "type %02x, length %d\n",
1035 buffer[2], buffer[0]);
1039 buflen -= buffer[0];
1040 buffer += buffer[0];
1043 if (!union_header) {
1044 if (call_interface_num > 0) {
1045 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1046 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1047 control_interface = intf;
1049 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1050 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1053 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1054 combined_interfaces = 1;
1055 control_interface = data_interface = intf;
1056 goto look_for_collapsed_interface;
1060 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1061 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1062 if (!control_interface || !data_interface) {
1063 dev_dbg(&intf->dev, "no interfaces\n");
1068 if (data_interface_num != call_interface_num)
1069 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1071 if (control_interface == data_interface) {
1072 /* some broken devices designed for windows work this way */
1073 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1074 combined_interfaces = 1;
1075 /* a popular other OS doesn't use it */
1076 quirks |= NO_CAP_LINE;
1077 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1078 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1081 look_for_collapsed_interface:
1082 for (i = 0; i < 3; i++) {
1083 struct usb_endpoint_descriptor *ep;
1084 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1086 if (usb_endpoint_is_int_in(ep))
1088 else if (usb_endpoint_is_bulk_out(ep))
1090 else if (usb_endpoint_is_bulk_in(ep))
1095 if (!epctrl || !epread || !epwrite)
1098 goto made_compressed_probe;
1103 /*workaround for switched interfaces */
1104 if (data_interface->cur_altsetting->desc.bInterfaceClass
1105 != CDC_DATA_INTERFACE_TYPE) {
1106 if (control_interface->cur_altsetting->desc.bInterfaceClass
1107 == CDC_DATA_INTERFACE_TYPE) {
1108 struct usb_interface *t;
1110 "Your device has switched interfaces.\n");
1111 t = control_interface;
1112 control_interface = data_interface;
1119 /* Accept probe requests only for the control interface */
1120 if (!combined_interfaces && intf != control_interface)
1123 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1124 /* valid in this context */
1125 dev_dbg(&intf->dev, "The data interface isn't available\n");
1130 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1133 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1134 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1135 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1138 /* workaround for switched endpoints */
1139 if (!usb_endpoint_dir_in(epread)) {
1140 /* descriptors are swapped */
1141 struct usb_endpoint_descriptor *t;
1143 "The data interface has switched endpoints\n");
1148 made_compressed_probe:
1149 dbg("interfaces are valid");
1150 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1152 if (minor == ACM_TTY_MINORS) {
1153 dev_err(&intf->dev, "no more free acm devices\n");
1157 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1159 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1163 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1164 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1165 (quirks == SINGLE_RX_URB ? 1 : 2);
1166 acm->combined_interfaces = combined_interfaces;
1167 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1168 acm->control = control_interface;
1169 acm->data = data_interface;
1172 acm->ctrl_caps = ac_management_function;
1173 if (quirks & NO_CAP_LINE)
1174 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1175 acm->ctrlsize = ctrlsize;
1176 acm->readsize = readsize;
1177 acm->rx_buflimit = num_rx_buf;
1178 acm->urb_task.func = acm_rx_tasklet;
1179 acm->urb_task.data = (unsigned long) acm;
1180 INIT_WORK(&acm->work, acm_softint);
1181 INIT_WORK(&acm->waker, acm_waker);
1182 init_waitqueue_head(&acm->drain_wait);
1183 spin_lock_init(&acm->throttle_lock);
1184 spin_lock_init(&acm->write_lock);
1185 spin_lock_init(&acm->read_lock);
1186 mutex_init(&acm->mutex);
1187 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1188 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1190 acm->bInterval = epread->bInterval;
1191 tty_port_init(&acm->port);
1192 acm->port.ops = &acm_port_ops;
1194 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1196 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1199 acm->ctrl_buffer = buf;
1201 if (acm_write_buffers_alloc(acm) < 0) {
1202 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1206 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1207 if (!acm->ctrlurb) {
1208 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1211 for (i = 0; i < num_rx_buf; i++) {
1212 struct acm_ru *rcv = &(acm->ru[i]);
1214 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1215 if (rcv->urb == NULL) {
1217 "out of memory (read urbs usb_alloc_urb)\n");
1221 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1222 rcv->instance = acm;
1224 for (i = 0; i < num_rx_buf; i++) {
1225 struct acm_rb *rb = &(acm->rb[i]);
1227 rb->base = usb_buffer_alloc(acm->dev, readsize,
1228 GFP_KERNEL, &rb->dma);
1231 "out of memory (read bufs usb_buffer_alloc)\n");
1235 for (i = 0; i < ACM_NW; i++) {
1236 struct acm_wb *snd = &(acm->wb[i]);
1238 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1239 if (snd->urb == NULL) {
1241 "out of memory (write urbs usb_alloc_urb)");
1245 if (usb_endpoint_xfer_int(epwrite))
1246 usb_fill_int_urb(snd->urb, usb_dev,
1247 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1248 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1250 usb_fill_bulk_urb(snd->urb, usb_dev,
1251 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1252 NULL, acm->writesize, acm_write_bulk, snd);
1253 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1254 snd->instance = acm;
1257 usb_set_intfdata(intf, acm);
1259 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1263 if (cfd) { /* export the country data */
1264 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1265 if (!acm->country_codes)
1266 goto skip_countries;
1267 acm->country_code_size = cfd->bLength - 4;
1268 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1270 acm->country_rel_date = cfd->iCountryCodeRelDate;
1272 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1274 kfree(acm->country_codes);
1275 goto skip_countries;
1278 i = device_create_file(&intf->dev,
1279 &dev_attr_iCountryCodeRelDate);
1281 kfree(acm->country_codes);
1282 goto skip_countries;
1287 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1288 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1289 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1290 /* works around buggy devices */
1291 epctrl->bInterval ? epctrl->bInterval : 0xff);
1292 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1293 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1295 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1297 acm_set_control(acm, acm->ctrlout);
1299 acm->line.dwDTERate = cpu_to_le32(9600);
1300 acm->line.bDataBits = 8;
1301 acm_set_line(acm, &acm->line);
1303 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1304 usb_set_intfdata(data_interface, acm);
1306 usb_get_intf(control_interface);
1307 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1309 acm_table[minor] = acm;
1313 for (i = 0; i < ACM_NW; i++)
1314 usb_free_urb(acm->wb[i].urb);
1316 acm_read_buffers_free(acm);
1317 for (i = 0; i < num_rx_buf; i++)
1318 usb_free_urb(acm->ru[i].urb);
1319 usb_free_urb(acm->ctrlurb);
1321 acm_write_buffers_free(acm);
1323 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1330 static void stop_data_traffic(struct acm *acm)
1333 dbg("Entering stop_data_traffic");
1335 tasklet_disable(&acm->urb_task);
1337 usb_kill_urb(acm->ctrlurb);
1338 for (i = 0; i < ACM_NW; i++)
1339 usb_kill_urb(acm->wb[i].urb);
1340 for (i = 0; i < acm->rx_buflimit; i++)
1341 usb_kill_urb(acm->ru[i].urb);
1343 tasklet_enable(&acm->urb_task);
1345 cancel_work_sync(&acm->work);
1346 cancel_work_sync(&acm->waker);
1349 static void acm_disconnect(struct usb_interface *intf)
1351 struct acm *acm = usb_get_intfdata(intf);
1352 struct usb_device *usb_dev = interface_to_usbdev(intf);
1353 struct tty_struct *tty;
1355 /* sibling interface is already cleaning up */
1359 mutex_lock(&open_mutex);
1360 if (acm->country_codes) {
1361 device_remove_file(&acm->control->dev,
1362 &dev_attr_wCountryCodes);
1363 device_remove_file(&acm->control->dev,
1364 &dev_attr_iCountryCodeRelDate);
1366 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1368 usb_set_intfdata(acm->control, NULL);
1369 usb_set_intfdata(acm->data, NULL);
1371 stop_data_traffic(acm);
1373 acm_write_buffers_free(acm);
1374 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1376 acm_read_buffers_free(acm);
1378 if (!acm->combined_interfaces)
1379 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1380 acm->data : acm->control);
1382 if (acm->port.count == 0) {
1383 acm_tty_unregister(acm);
1384 mutex_unlock(&open_mutex);
1388 mutex_unlock(&open_mutex);
1389 tty = tty_port_tty_get(&acm->port);
1397 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1399 struct acm *acm = usb_get_intfdata(intf);
1402 if (message.event & PM_EVENT_AUTO) {
1405 spin_lock_irq(&acm->read_lock);
1406 spin_lock(&acm->write_lock);
1407 b = acm->processing + acm->transmitting;
1408 spin_unlock(&acm->write_lock);
1409 spin_unlock_irq(&acm->read_lock);
1414 spin_lock_irq(&acm->read_lock);
1415 spin_lock(&acm->write_lock);
1416 cnt = acm->susp_count++;
1417 spin_unlock(&acm->write_lock);
1418 spin_unlock_irq(&acm->read_lock);
1423 we treat opened interfaces differently,
1424 we must guard against open
1426 mutex_lock(&acm->mutex);
1428 if (acm->port.count)
1429 stop_data_traffic(acm);
1431 mutex_unlock(&acm->mutex);
1435 static int acm_resume(struct usb_interface *intf)
1437 struct acm *acm = usb_get_intfdata(intf);
1441 spin_lock_irq(&acm->read_lock);
1442 acm->susp_count -= 1;
1443 cnt = acm->susp_count;
1444 spin_unlock_irq(&acm->read_lock);
1449 mutex_lock(&acm->mutex);
1450 if (acm->port.count) {
1451 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1455 tasklet_schedule(&acm->urb_task);
1459 mutex_unlock(&acm->mutex);
1463 #endif /* CONFIG_PM */
1465 * USB driver structure.
1468 static struct usb_device_id acm_ids[] = {
1469 /* quirky and broken devices */
1470 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1471 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1473 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1474 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1476 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1477 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1479 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1480 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1482 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1483 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1485 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1486 .driver_info = SINGLE_RX_URB,
1488 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1489 .driver_info = SINGLE_RX_URB, /* firmware bug */
1491 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1492 .driver_info = SINGLE_RX_URB, /* firmware bug */
1494 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1495 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1497 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1498 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1500 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1501 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1504 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1506 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1507 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1509 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1511 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1512 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1513 data interface instead of
1514 communications interface.
1515 Maybe we should define a new
1518 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1519 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1522 /* control interfaces with various AT-command sets */
1523 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1524 USB_CDC_ACM_PROTO_AT_V25TER) },
1525 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1526 USB_CDC_ACM_PROTO_AT_PCCA101) },
1527 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1528 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1529 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1530 USB_CDC_ACM_PROTO_AT_GSM) },
1531 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1532 USB_CDC_ACM_PROTO_AT_3G) },
1533 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1534 USB_CDC_ACM_PROTO_AT_CDMA) },
1536 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1540 MODULE_DEVICE_TABLE(usb, acm_ids);
1542 static struct usb_driver acm_driver = {
1545 .disconnect = acm_disconnect,
1547 .suspend = acm_suspend,
1548 .resume = acm_resume,
1550 .id_table = acm_ids,
1552 .supports_autosuspend = 1,
1557 * TTY driver structures.
1560 static const struct tty_operations acm_ops = {
1561 .open = acm_tty_open,
1562 .close = acm_tty_close,
1563 .hangup = acm_tty_hangup,
1564 .write = acm_tty_write,
1565 .write_room = acm_tty_write_room,
1566 .ioctl = acm_tty_ioctl,
1567 .throttle = acm_tty_throttle,
1568 .unthrottle = acm_tty_unthrottle,
1569 .chars_in_buffer = acm_tty_chars_in_buffer,
1570 .break_ctl = acm_tty_break_ctl,
1571 .set_termios = acm_tty_set_termios,
1572 .tiocmget = acm_tty_tiocmget,
1573 .tiocmset = acm_tty_tiocmset,
1580 static int __init acm_init(void)
1583 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1584 if (!acm_tty_driver)
1586 acm_tty_driver->owner = THIS_MODULE,
1587 acm_tty_driver->driver_name = "acm",
1588 acm_tty_driver->name = "ttyACM",
1589 acm_tty_driver->major = ACM_TTY_MAJOR,
1590 acm_tty_driver->minor_start = 0,
1591 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1592 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1593 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1594 acm_tty_driver->init_termios = tty_std_termios;
1595 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1597 tty_set_operations(acm_tty_driver, &acm_ops);
1599 retval = tty_register_driver(acm_tty_driver);
1601 put_tty_driver(acm_tty_driver);
1605 retval = usb_register(&acm_driver);
1607 tty_unregister_driver(acm_tty_driver);
1608 put_tty_driver(acm_tty_driver);
1612 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1618 static void __exit acm_exit(void)
1620 usb_deregister(&acm_driver);
1621 tty_unregister_driver(acm_tty_driver);
1622 put_tty_driver(acm_tty_driver);
1625 module_init(acm_init);
1626 module_exit(acm_exit);
1628 MODULE_AUTHOR(DRIVER_AUTHOR);
1629 MODULE_DESCRIPTION(DRIVER_DESC);
1630 MODULE_LICENSE("GPL");
1631 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);