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/tty_driver.h>
63 #include <linux/tty_flip.h>
64 #include <linux/module.h>
65 #include <linux/mutex.h>
66 #include <linux/uaccess.h>
67 #include <linux/usb.h>
68 #include <linux/usb/cdc.h>
69 #include <asm/byteorder.h>
70 #include <asm/unaligned.h>
71 #include <linux/list.h>
76 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
81 #define DRIVER_VERSION "v0.26"
82 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
83 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
85 static struct usb_driver acm_driver;
86 static struct tty_driver *acm_tty_driver;
87 static struct acm *acm_table[ACM_TTY_MINORS];
89 static DEFINE_MUTEX(open_mutex);
91 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
93 static const struct tty_port_operations acm_port_ops = {
103 * Functions for ACM control messages.
106 static int acm_ctrl_msg(struct acm *acm, int request, int value,
109 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
110 request, USB_RT_ACM, value,
111 acm->control->altsetting[0].desc.bInterfaceNumber,
113 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
114 request, value, len, retval);
115 return retval < 0 ? retval : 0;
118 /* devices aren't required to support these requests.
119 * the cdc acm descriptor tells whether they do...
121 #define acm_set_control(acm, control) \
122 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
123 #define acm_set_line(acm, line) \
124 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
125 #define acm_send_break(acm, ms) \
126 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
129 * Write buffer management.
130 * All of these assume proper locks taken by the caller.
133 static int acm_wb_alloc(struct acm *acm)
146 wbn = (wbn + 1) % ACM_NW;
152 static int acm_wb_is_avail(struct acm *acm)
158 spin_lock_irqsave(&acm->write_lock, flags);
159 for (i = 0; i < ACM_NW; i++)
161 spin_unlock_irqrestore(&acm->write_lock, flags);
166 * Finish write. Caller must hold acm->write_lock
168 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
177 * the caller is responsible for locking
180 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
186 wb->urb->transfer_buffer = wb->buf;
187 wb->urb->transfer_dma = wb->dmah;
188 wb->urb->transfer_buffer_length = wb->len;
189 wb->urb->dev = acm->dev;
191 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
193 dbg("usb_submit_urb(write bulk) failed: %d", rc);
194 acm_write_done(acm, wb);
199 static int acm_write_start(struct acm *acm, int wbn)
202 struct acm_wb *wb = &acm->wb[wbn];
205 spin_lock_irqsave(&acm->write_lock, flags);
208 spin_unlock_irqrestore(&acm->write_lock, flags);
212 dbg("%s susp_count: %d", __func__, acm->susp_count);
213 if (acm->susp_count) {
214 acm->delayed_wb = wb;
215 schedule_work(&acm->waker);
216 spin_unlock_irqrestore(&acm->write_lock, flags);
217 return 0; /* A white lie */
219 usb_mark_last_busy(acm->dev);
221 rc = acm_start_wb(acm, wb);
222 spin_unlock_irqrestore(&acm->write_lock, flags);
228 * attributes exported through sysfs
230 static ssize_t show_caps
231 (struct device *dev, struct device_attribute *attr, char *buf)
233 struct usb_interface *intf = to_usb_interface(dev);
234 struct acm *acm = usb_get_intfdata(intf);
236 return sprintf(buf, "%d", acm->ctrl_caps);
238 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
240 static ssize_t show_country_codes
241 (struct device *dev, struct device_attribute *attr, char *buf)
243 struct usb_interface *intf = to_usb_interface(dev);
244 struct acm *acm = usb_get_intfdata(intf);
246 memcpy(buf, acm->country_codes, acm->country_code_size);
247 return acm->country_code_size;
250 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
252 static ssize_t show_country_rel_date
253 (struct device *dev, struct device_attribute *attr, char *buf)
255 struct usb_interface *intf = to_usb_interface(dev);
256 struct acm *acm = usb_get_intfdata(intf);
258 return sprintf(buf, "%d", acm->country_rel_date);
261 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
263 * Interrupt handlers for various ACM device responses
266 /* control interface reports status changes with "interrupt" transfers */
267 static void acm_ctrl_irq(struct urb *urb)
269 struct acm *acm = urb->context;
270 struct usb_cdc_notification *dr = urb->transfer_buffer;
271 struct tty_struct *tty;
275 int status = urb->status;
284 /* this urb is terminated, clean up */
285 dbg("%s - urb shutting down with status: %d", __func__, status);
288 dbg("%s - nonzero urb status received: %d", __func__, status);
295 data = (unsigned char *)(dr + 1);
296 switch (dr->bNotificationType) {
297 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
298 dbg("%s network", dr->wValue ?
299 "connected to" : "disconnected from");
302 case USB_CDC_NOTIFY_SERIAL_STATE:
303 tty = tty_port_tty_get(&acm->port);
304 newctrl = get_unaligned_le16(data);
308 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
309 dbg("calling hangup");
315 acm->ctrlin = newctrl;
317 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
318 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
319 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
320 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
321 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
322 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
323 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
328 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
329 dr->bNotificationType, dr->wIndex,
330 dr->wLength, data[0], data[1]);
334 usb_mark_last_busy(acm->dev);
335 retval = usb_submit_urb(urb, GFP_ATOMIC);
337 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
338 "result %d", __func__, retval);
341 /* data interface returns incoming bytes, or we got unthrottled */
342 static void acm_read_bulk(struct urb *urb)
345 struct acm_ru *rcv = urb->context;
346 struct acm *acm = rcv->instance;
347 int status = urb->status;
349 dbg("Entering acm_read_bulk with status %d", status);
351 if (!ACM_READY(acm)) {
352 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
355 usb_mark_last_busy(acm->dev);
358 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
361 buf->size = urb->actual_length;
363 if (likely(status == 0)) {
364 spin_lock(&acm->read_lock);
366 list_add_tail(&rcv->list, &acm->spare_read_urbs);
367 list_add_tail(&buf->list, &acm->filled_read_bufs);
368 spin_unlock(&acm->read_lock);
370 /* we drop the buffer due to an error */
371 spin_lock(&acm->read_lock);
372 list_add_tail(&rcv->list, &acm->spare_read_urbs);
373 list_add(&buf->list, &acm->spare_read_bufs);
374 spin_unlock(&acm->read_lock);
375 /* nevertheless the tasklet must be kicked unconditionally
376 so the queue cannot dry up */
378 if (likely(!acm->susp_count))
379 tasklet_schedule(&acm->urb_task);
382 static void acm_rx_tasklet(unsigned long _acm)
384 struct acm *acm = (void *)_acm;
386 struct tty_struct *tty;
389 unsigned char throttled;
391 dbg("Entering acm_rx_tasklet");
393 if (!ACM_READY(acm)) {
394 dbg("acm_rx_tasklet: ACM not ready");
398 spin_lock_irqsave(&acm->throttle_lock, flags);
399 throttled = acm->throttle;
400 spin_unlock_irqrestore(&acm->throttle_lock, flags);
402 dbg("acm_rx_tasklet: throttled");
406 tty = tty_port_tty_get(&acm->port);
409 spin_lock_irqsave(&acm->read_lock, flags);
410 if (list_empty(&acm->filled_read_bufs)) {
411 spin_unlock_irqrestore(&acm->read_lock, flags);
414 buf = list_entry(acm->filled_read_bufs.next,
415 struct acm_rb, list);
416 list_del(&buf->list);
417 spin_unlock_irqrestore(&acm->read_lock, flags);
419 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
422 spin_lock_irqsave(&acm->throttle_lock, flags);
423 throttled = acm->throttle;
424 spin_unlock_irqrestore(&acm->throttle_lock, flags);
426 tty_buffer_request_room(tty, buf->size);
427 tty_insert_flip_string(tty, buf->base, buf->size);
428 tty_flip_buffer_push(tty);
431 dbg("Throttling noticed");
432 spin_lock_irqsave(&acm->read_lock, flags);
433 list_add(&buf->list, &acm->filled_read_bufs);
434 spin_unlock_irqrestore(&acm->read_lock, flags);
439 spin_lock_irqsave(&acm->read_lock, flags);
440 list_add(&buf->list, &acm->spare_read_bufs);
441 spin_unlock_irqrestore(&acm->read_lock, flags);
447 while (!list_empty(&acm->spare_read_bufs)) {
448 spin_lock_irqsave(&acm->read_lock, flags);
449 if (list_empty(&acm->spare_read_urbs)) {
451 spin_unlock_irqrestore(&acm->read_lock, flags);
454 rcv = list_entry(acm->spare_read_urbs.next,
455 struct acm_ru, list);
456 list_del(&rcv->list);
457 spin_unlock_irqrestore(&acm->read_lock, flags);
459 buf = list_entry(acm->spare_read_bufs.next,
460 struct acm_rb, list);
461 list_del(&buf->list);
465 usb_fill_bulk_urb(rcv->urb, acm->dev,
470 rcv->urb->transfer_dma = buf->dma;
471 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
473 /* This shouldn't kill the driver as unsuccessful URBs are
474 returned to the free-urbs-pool and resubmited ASAP */
475 spin_lock_irqsave(&acm->read_lock, flags);
476 if (acm->susp_count ||
477 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
478 list_add(&buf->list, &acm->spare_read_bufs);
479 list_add(&rcv->list, &acm->spare_read_urbs);
481 spin_unlock_irqrestore(&acm->read_lock, flags);
484 spin_unlock_irqrestore(&acm->read_lock, flags);
485 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
488 spin_lock_irqsave(&acm->read_lock, flags);
490 spin_unlock_irqrestore(&acm->read_lock, flags);
493 /* data interface wrote those outgoing bytes */
494 static void acm_write_bulk(struct urb *urb)
496 struct acm_wb *wb = urb->context;
497 struct acm *acm = wb->instance;
500 if (verbose || urb->status
501 || (urb->actual_length != urb->transfer_buffer_length))
502 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
504 urb->transfer_buffer_length,
507 spin_lock_irqsave(&acm->write_lock, flags);
508 acm_write_done(acm, wb);
509 spin_unlock_irqrestore(&acm->write_lock, flags);
511 schedule_work(&acm->work);
513 wake_up_interruptible(&acm->drain_wait);
516 static void acm_softint(struct work_struct *work)
518 struct acm *acm = container_of(work, struct acm, work);
519 struct tty_struct *tty;
521 dev_vdbg(&acm->data->dev, "tx work\n");
524 tty = tty_port_tty_get(&acm->port);
529 static void acm_waker(struct work_struct *waker)
531 struct acm *acm = container_of(waker, struct acm, waker);
534 rv = usb_autopm_get_interface(acm->control);
536 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
539 if (acm->delayed_wb) {
540 acm_start_wb(acm, acm->delayed_wb);
541 acm->delayed_wb = NULL;
543 usb_autopm_put_interface(acm->control);
550 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
555 dbg("Entering acm_tty_open.");
557 mutex_lock(&open_mutex);
559 acm = acm_table[tty->index];
560 if (!acm || !acm->dev)
565 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
567 tty->driver_data = acm;
568 tty_port_tty_set(&acm->port, tty);
570 if (usb_autopm_get_interface(acm->control) < 0)
573 acm->control->needs_remote_wakeup = 1;
575 mutex_lock(&acm->mutex);
576 if (acm->port.count++) {
577 usb_autopm_put_interface(acm->control);
581 acm->ctrlurb->dev = acm->dev;
582 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
583 dbg("usb_submit_urb(ctrl irq) failed");
587 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
588 (acm->ctrl_caps & USB_CDC_CAP_LINE))
591 usb_autopm_put_interface(acm->control);
593 INIT_LIST_HEAD(&acm->spare_read_urbs);
594 INIT_LIST_HEAD(&acm->spare_read_bufs);
595 INIT_LIST_HEAD(&acm->filled_read_bufs);
597 for (i = 0; i < acm->rx_buflimit; i++)
598 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
599 for (i = 0; i < acm->rx_buflimit; i++)
600 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
604 tasklet_schedule(&acm->urb_task);
605 rv = tty_port_block_til_ready(&acm->port, tty, filp);
607 mutex_unlock(&acm->mutex);
609 mutex_unlock(&open_mutex);
613 usb_kill_urb(acm->ctrlurb);
615 usb_autopm_put_interface(acm->control);
617 mutex_unlock(&acm->mutex);
619 mutex_unlock(&open_mutex);
620 tty_port_tty_set(&acm->port, NULL);
624 static void acm_tty_unregister(struct acm *acm)
628 nr = acm->rx_buflimit;
629 tty_unregister_device(acm_tty_driver, acm->minor);
630 usb_put_intf(acm->control);
631 acm_table[acm->minor] = NULL;
632 usb_free_urb(acm->ctrlurb);
633 for (i = 0; i < ACM_NW; i++)
634 usb_free_urb(acm->wb[i].urb);
635 for (i = 0; i < nr; i++)
636 usb_free_urb(acm->ru[i].urb);
637 kfree(acm->country_codes);
641 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
643 static void acm_port_down(struct acm *acm, int drain)
645 int i, nr = acm->rx_buflimit;
646 mutex_lock(&open_mutex);
648 usb_autopm_get_interface(acm->control);
649 acm_set_control(acm, acm->ctrlout = 0);
650 /* try letting the last writes drain naturally */
652 wait_event_interruptible_timeout(acm->drain_wait,
653 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
654 ACM_CLOSE_TIMEOUT * HZ);
656 usb_kill_urb(acm->ctrlurb);
657 for (i = 0; i < ACM_NW; i++)
658 usb_kill_urb(acm->wb[i].urb);
659 for (i = 0; i < nr; i++)
660 usb_kill_urb(acm->ru[i].urb);
661 acm->control->needs_remote_wakeup = 0;
662 usb_autopm_put_interface(acm->control);
664 mutex_unlock(&open_mutex);
667 static void acm_tty_hangup(struct tty_struct *tty)
669 struct acm *acm = tty->driver_data;
670 tty_port_hangup(&acm->port);
671 acm_port_down(acm, 0);
674 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
676 struct acm *acm = tty->driver_data;
678 /* Perform the closing process and see if we need to do the hardware
680 if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)
682 acm_port_down(acm, 0);
683 tty_port_close_end(&acm->port, tty);
684 mutex_lock(&open_mutex);
685 tty_port_tty_set(&acm->port, NULL);
687 acm_tty_unregister(acm);
688 mutex_unlock(&open_mutex);
691 static int acm_tty_write(struct tty_struct *tty,
692 const unsigned char *buf, int count)
694 struct acm *acm = tty->driver_data;
700 dbg("Entering acm_tty_write to write %d bytes,", count);
707 spin_lock_irqsave(&acm->write_lock, flags);
708 wbn = acm_wb_alloc(acm);
710 spin_unlock_irqrestore(&acm->write_lock, flags);
715 count = (count > acm->writesize) ? acm->writesize : count;
716 dbg("Get %d bytes...", count);
717 memcpy(wb->buf, buf, count);
719 spin_unlock_irqrestore(&acm->write_lock, flags);
721 stat = acm_write_start(acm, wbn);
727 static int acm_tty_write_room(struct tty_struct *tty)
729 struct acm *acm = tty->driver_data;
733 * Do not let the line discipline to know that we have a reserve,
734 * or it might get too enthusiastic.
736 return acm_wb_is_avail(acm) ? acm->writesize : 0;
739 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
741 struct acm *acm = tty->driver_data;
745 * This is inaccurate (overcounts), but it works.
747 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
750 static void acm_tty_throttle(struct tty_struct *tty)
752 struct acm *acm = tty->driver_data;
755 spin_lock_bh(&acm->throttle_lock);
757 spin_unlock_bh(&acm->throttle_lock);
760 static void acm_tty_unthrottle(struct tty_struct *tty)
762 struct acm *acm = tty->driver_data;
765 spin_lock_bh(&acm->throttle_lock);
767 spin_unlock_bh(&acm->throttle_lock);
768 tasklet_schedule(&acm->urb_task);
771 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
773 struct acm *acm = tty->driver_data;
777 retval = acm_send_break(acm, state ? 0xffff : 0);
779 dbg("send break failed");
783 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
785 struct acm *acm = tty->driver_data;
790 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
791 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
792 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
793 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
794 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
798 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
799 unsigned int set, unsigned int clear)
801 struct acm *acm = tty->driver_data;
802 unsigned int newctrl;
807 newctrl = acm->ctrlout;
808 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
809 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
810 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
811 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
813 newctrl = (newctrl & ~clear) | set;
815 if (acm->ctrlout == newctrl)
817 return acm_set_control(acm, acm->ctrlout = newctrl);
820 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
821 unsigned int cmd, unsigned long arg)
823 struct acm *acm = tty->driver_data;
831 static const __u32 acm_tty_speed[] = {
832 0, 50, 75, 110, 134, 150, 200, 300, 600,
833 1200, 1800, 2400, 4800, 9600, 19200, 38400,
834 57600, 115200, 230400, 460800, 500000, 576000,
835 921600, 1000000, 1152000, 1500000, 2000000,
836 2500000, 3000000, 3500000, 4000000
839 static const __u8 acm_tty_size[] = {
843 static void acm_tty_set_termios(struct tty_struct *tty,
844 struct ktermios *termios_old)
846 struct acm *acm = tty->driver_data;
847 struct ktermios *termios = tty->termios;
848 struct usb_cdc_line_coding newline;
849 int newctrl = acm->ctrlout;
854 /* FIXME: Needs to support the tty_baud interface */
855 /* FIXME: Broken on sparc */
856 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
857 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
858 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
859 newline.bParityType = termios->c_cflag & PARENB ?
860 (termios->c_cflag & PARODD ? 1 : 2) +
861 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
862 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
863 /* FIXME: Needs to clear unsupported bits in the termios */
864 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
866 if (!newline.dwDTERate) {
867 newline.dwDTERate = acm->line.dwDTERate;
868 newctrl &= ~ACM_CTRL_DTR;
870 newctrl |= ACM_CTRL_DTR;
872 if (newctrl != acm->ctrlout)
873 acm_set_control(acm, acm->ctrlout = newctrl);
875 if (memcmp(&acm->line, &newline, sizeof newline)) {
876 memcpy(&acm->line, &newline, sizeof newline);
877 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
878 newline.bCharFormat, newline.bParityType,
880 acm_set_line(acm, &acm->line);
885 * USB probe and disconnect routines.
888 /* Little helpers: write/read buffers free */
889 static void acm_write_buffers_free(struct acm *acm)
893 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
895 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
896 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
899 static void acm_read_buffers_free(struct acm *acm)
901 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
902 int i, n = acm->rx_buflimit;
904 for (i = 0; i < n; i++)
905 usb_buffer_free(usb_dev, acm->readsize,
906 acm->rb[i].base, acm->rb[i].dma);
909 /* Little helper: write buffers allocate */
910 static int acm_write_buffers_alloc(struct acm *acm)
915 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
916 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
922 usb_buffer_free(acm->dev, acm->writesize,
931 static int acm_probe(struct usb_interface *intf,
932 const struct usb_device_id *id)
934 struct usb_cdc_union_desc *union_header = NULL;
935 struct usb_cdc_country_functional_desc *cfd = NULL;
936 unsigned char *buffer = intf->altsetting->extra;
937 int buflen = intf->altsetting->extralen;
938 struct usb_interface *control_interface;
939 struct usb_interface *data_interface;
940 struct usb_endpoint_descriptor *epctrl = NULL;
941 struct usb_endpoint_descriptor *epread = NULL;
942 struct usb_endpoint_descriptor *epwrite = NULL;
943 struct usb_device *usb_dev = interface_to_usbdev(intf);
946 int ctrlsize, readsize;
948 u8 ac_management_function = 0;
949 u8 call_management_function = 0;
950 int call_interface_num = -1;
951 int data_interface_num;
952 unsigned long quirks;
955 int combined_interfaces = 0;
958 quirks = (unsigned long)id->driver_info;
959 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
961 /* handle quirks deadly to normal probing*/
962 if (quirks == NO_UNION_NORMAL) {
963 data_interface = usb_ifnum_to_if(usb_dev, 1);
964 control_interface = usb_ifnum_to_if(usb_dev, 0);
965 goto skip_normal_probe;
970 dev_err(&intf->dev, "Weird descriptor references\n");
975 if (intf->cur_altsetting->endpoint->extralen &&
976 intf->cur_altsetting->endpoint->extra) {
978 "Seeking extra descriptors on endpoint\n");
979 buflen = intf->cur_altsetting->endpoint->extralen;
980 buffer = intf->cur_altsetting->endpoint->extra;
983 "Zero length descriptor references\n");
989 if (buffer[1] != USB_DT_CS_INTERFACE) {
990 dev_err(&intf->dev, "skipping garbage\n");
995 case USB_CDC_UNION_TYPE: /* we've found it */
997 dev_err(&intf->dev, "More than one "
998 "union descriptor, skipping ...\n");
1001 union_header = (struct usb_cdc_union_desc *)buffer;
1003 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1004 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1006 case USB_CDC_HEADER_TYPE: /* maybe check version */
1007 break; /* for now we ignore it */
1008 case USB_CDC_ACM_TYPE:
1009 ac_management_function = buffer[3];
1011 case USB_CDC_CALL_MANAGEMENT_TYPE:
1012 call_management_function = buffer[3];
1013 call_interface_num = buffer[4];
1014 if ((call_management_function & 3) != 3)
1015 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1018 /* there are LOTS more CDC descriptors that
1019 * could legitimately be found here.
1021 dev_dbg(&intf->dev, "Ignoring descriptor: "
1022 "type %02x, length %d\n",
1023 buffer[2], buffer[0]);
1027 buflen -= buffer[0];
1028 buffer += buffer[0];
1031 if (!union_header) {
1032 if (call_interface_num > 0) {
1033 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1034 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1035 control_interface = intf;
1037 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1038 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1041 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1042 combined_interfaces = 1;
1043 control_interface = data_interface = intf;
1044 goto look_for_collapsed_interface;
1048 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1049 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1050 if (!control_interface || !data_interface) {
1051 dev_dbg(&intf->dev, "no interfaces\n");
1056 if (data_interface_num != call_interface_num)
1057 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1059 if (control_interface == data_interface) {
1060 /* some broken devices designed for windows work this way */
1061 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1062 combined_interfaces = 1;
1063 /* a popular other OS doesn't use it */
1064 quirks |= NO_CAP_LINE;
1065 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1066 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1069 look_for_collapsed_interface:
1070 for (i = 0; i < 3; i++) {
1071 struct usb_endpoint_descriptor *ep;
1072 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1074 if (usb_endpoint_is_int_in(ep))
1076 else if (usb_endpoint_is_bulk_out(ep))
1078 else if (usb_endpoint_is_bulk_in(ep))
1083 if (!epctrl || !epread || !epwrite)
1086 goto made_compressed_probe;
1091 /*workaround for switched interfaces */
1092 if (data_interface->cur_altsetting->desc.bInterfaceClass
1093 != CDC_DATA_INTERFACE_TYPE) {
1094 if (control_interface->cur_altsetting->desc.bInterfaceClass
1095 == CDC_DATA_INTERFACE_TYPE) {
1096 struct usb_interface *t;
1098 "Your device has switched interfaces.\n");
1099 t = control_interface;
1100 control_interface = data_interface;
1107 /* Accept probe requests only for the control interface */
1108 if (!combined_interfaces && intf != control_interface)
1111 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1112 /* valid in this context */
1113 dev_dbg(&intf->dev, "The data interface isn't available\n");
1118 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1121 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1122 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1123 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1126 /* workaround for switched endpoints */
1127 if (!usb_endpoint_dir_in(epread)) {
1128 /* descriptors are swapped */
1129 struct usb_endpoint_descriptor *t;
1131 "The data interface has switched endpoints\n");
1136 made_compressed_probe:
1137 dbg("interfaces are valid");
1138 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1140 if (minor == ACM_TTY_MINORS) {
1141 dev_err(&intf->dev, "no more free acm devices\n");
1145 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1147 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1151 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1152 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1153 (quirks == SINGLE_RX_URB ? 1 : 2);
1154 acm->combined_interfaces = combined_interfaces;
1155 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1156 acm->control = control_interface;
1157 acm->data = data_interface;
1160 acm->ctrl_caps = ac_management_function;
1161 if (quirks & NO_CAP_LINE)
1162 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1163 acm->ctrlsize = ctrlsize;
1164 acm->readsize = readsize;
1165 acm->rx_buflimit = num_rx_buf;
1166 acm->urb_task.func = acm_rx_tasklet;
1167 acm->urb_task.data = (unsigned long) acm;
1168 INIT_WORK(&acm->work, acm_softint);
1169 INIT_WORK(&acm->waker, acm_waker);
1170 init_waitqueue_head(&acm->drain_wait);
1171 spin_lock_init(&acm->throttle_lock);
1172 spin_lock_init(&acm->write_lock);
1173 spin_lock_init(&acm->read_lock);
1174 mutex_init(&acm->mutex);
1175 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1176 tty_port_init(&acm->port);
1177 acm->port.ops = &acm_port_ops;
1179 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1181 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1184 acm->ctrl_buffer = buf;
1186 if (acm_write_buffers_alloc(acm) < 0) {
1187 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1191 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1192 if (!acm->ctrlurb) {
1193 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1196 for (i = 0; i < num_rx_buf; i++) {
1197 struct acm_ru *rcv = &(acm->ru[i]);
1199 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1200 if (rcv->urb == NULL) {
1202 "out of memory (read urbs usb_alloc_urb)\n");
1206 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1207 rcv->instance = acm;
1209 for (i = 0; i < num_rx_buf; i++) {
1210 struct acm_rb *rb = &(acm->rb[i]);
1212 rb->base = usb_buffer_alloc(acm->dev, readsize,
1213 GFP_KERNEL, &rb->dma);
1216 "out of memory (read bufs usb_buffer_alloc)\n");
1220 for (i = 0; i < ACM_NW; i++) {
1221 struct acm_wb *snd = &(acm->wb[i]);
1223 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1224 if (snd->urb == NULL) {
1226 "out of memory (write urbs usb_alloc_urb)");
1230 usb_fill_bulk_urb(snd->urb, usb_dev,
1231 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1232 NULL, acm->writesize, acm_write_bulk, snd);
1233 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1234 snd->instance = acm;
1237 usb_set_intfdata(intf, acm);
1239 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1243 if (cfd) { /* export the country data */
1244 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1245 if (!acm->country_codes)
1246 goto skip_countries;
1247 acm->country_code_size = cfd->bLength - 4;
1248 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1250 acm->country_rel_date = cfd->iCountryCodeRelDate;
1252 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1254 kfree(acm->country_codes);
1255 goto skip_countries;
1258 i = device_create_file(&intf->dev,
1259 &dev_attr_iCountryCodeRelDate);
1261 kfree(acm->country_codes);
1262 goto skip_countries;
1267 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1268 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1269 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1270 /* works around buggy devices */
1271 epctrl->bInterval ? epctrl->bInterval : 0xff);
1272 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1273 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1275 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1277 acm_set_control(acm, acm->ctrlout);
1279 acm->line.dwDTERate = cpu_to_le32(9600);
1280 acm->line.bDataBits = 8;
1281 acm_set_line(acm, &acm->line);
1283 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1284 usb_set_intfdata(data_interface, acm);
1286 usb_get_intf(control_interface);
1287 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1289 acm_table[minor] = acm;
1293 for (i = 0; i < ACM_NW; i++)
1294 usb_free_urb(acm->wb[i].urb);
1296 acm_read_buffers_free(acm);
1297 for (i = 0; i < num_rx_buf; i++)
1298 usb_free_urb(acm->ru[i].urb);
1299 usb_free_urb(acm->ctrlurb);
1301 acm_write_buffers_free(acm);
1303 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1310 static void stop_data_traffic(struct acm *acm)
1313 dbg("Entering stop_data_traffic");
1315 tasklet_disable(&acm->urb_task);
1317 usb_kill_urb(acm->ctrlurb);
1318 for (i = 0; i < ACM_NW; i++)
1319 usb_kill_urb(acm->wb[i].urb);
1320 for (i = 0; i < acm->rx_buflimit; i++)
1321 usb_kill_urb(acm->ru[i].urb);
1323 tasklet_enable(&acm->urb_task);
1325 cancel_work_sync(&acm->work);
1326 cancel_work_sync(&acm->waker);
1329 static void acm_disconnect(struct usb_interface *intf)
1331 struct acm *acm = usb_get_intfdata(intf);
1332 struct usb_device *usb_dev = interface_to_usbdev(intf);
1333 struct tty_struct *tty;
1335 /* sibling interface is already cleaning up */
1339 mutex_lock(&open_mutex);
1340 if (acm->country_codes) {
1341 device_remove_file(&acm->control->dev,
1342 &dev_attr_wCountryCodes);
1343 device_remove_file(&acm->control->dev,
1344 &dev_attr_iCountryCodeRelDate);
1346 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1348 usb_set_intfdata(acm->control, NULL);
1349 usb_set_intfdata(acm->data, NULL);
1351 stop_data_traffic(acm);
1353 acm_write_buffers_free(acm);
1354 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1356 acm_read_buffers_free(acm);
1358 if (!acm->combined_interfaces)
1359 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1360 acm->data : acm->control);
1362 if (acm->port.count == 0) {
1363 acm_tty_unregister(acm);
1364 mutex_unlock(&open_mutex);
1368 mutex_unlock(&open_mutex);
1369 tty = tty_port_tty_get(&acm->port);
1377 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1379 struct acm *acm = usb_get_intfdata(intf);
1382 if (message.event & PM_EVENT_AUTO) {
1385 spin_lock_irq(&acm->read_lock);
1386 spin_lock(&acm->write_lock);
1387 b = acm->processing + acm->transmitting;
1388 spin_unlock(&acm->write_lock);
1389 spin_unlock_irq(&acm->read_lock);
1394 spin_lock_irq(&acm->read_lock);
1395 spin_lock(&acm->write_lock);
1396 cnt = acm->susp_count++;
1397 spin_unlock(&acm->write_lock);
1398 spin_unlock_irq(&acm->read_lock);
1403 we treat opened interfaces differently,
1404 we must guard against open
1406 mutex_lock(&acm->mutex);
1408 if (acm->port.count)
1409 stop_data_traffic(acm);
1411 mutex_unlock(&acm->mutex);
1415 static int acm_resume(struct usb_interface *intf)
1417 struct acm *acm = usb_get_intfdata(intf);
1421 spin_lock_irq(&acm->read_lock);
1422 acm->susp_count -= 1;
1423 cnt = acm->susp_count;
1424 spin_unlock_irq(&acm->read_lock);
1429 mutex_lock(&acm->mutex);
1430 if (acm->port.count) {
1431 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1435 tasklet_schedule(&acm->urb_task);
1439 mutex_unlock(&acm->mutex);
1443 #endif /* CONFIG_PM */
1445 * USB driver structure.
1448 static struct usb_device_id acm_ids[] = {
1449 /* quirky and broken devices */
1450 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1451 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1453 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1454 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1456 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1457 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1459 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1460 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1462 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1463 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1465 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1466 .driver_info = SINGLE_RX_URB,
1468 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1469 .driver_info = SINGLE_RX_URB, /* firmware bug */
1471 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1472 .driver_info = SINGLE_RX_URB, /* firmware bug */
1474 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1475 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1477 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1478 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1480 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1481 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1483 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1484 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1486 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1487 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1489 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1491 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1492 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1493 data interface instead of
1494 communications interface.
1495 Maybe we should define a new
1498 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1499 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1502 /* control interfaces with various AT-command sets */
1503 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1504 USB_CDC_ACM_PROTO_AT_V25TER) },
1505 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1506 USB_CDC_ACM_PROTO_AT_PCCA101) },
1507 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1508 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1509 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1510 USB_CDC_ACM_PROTO_AT_GSM) },
1511 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1512 USB_CDC_ACM_PROTO_AT_3G) },
1513 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1514 USB_CDC_ACM_PROTO_AT_CDMA) },
1516 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1520 MODULE_DEVICE_TABLE(usb, acm_ids);
1522 static struct usb_driver acm_driver = {
1525 .disconnect = acm_disconnect,
1527 .suspend = acm_suspend,
1528 .resume = acm_resume,
1530 .id_table = acm_ids,
1532 .supports_autosuspend = 1,
1537 * TTY driver structures.
1540 static const struct tty_operations acm_ops = {
1541 .open = acm_tty_open,
1542 .close = acm_tty_close,
1543 .hangup = acm_tty_hangup,
1544 .write = acm_tty_write,
1545 .write_room = acm_tty_write_room,
1546 .ioctl = acm_tty_ioctl,
1547 .throttle = acm_tty_throttle,
1548 .unthrottle = acm_tty_unthrottle,
1549 .chars_in_buffer = acm_tty_chars_in_buffer,
1550 .break_ctl = acm_tty_break_ctl,
1551 .set_termios = acm_tty_set_termios,
1552 .tiocmget = acm_tty_tiocmget,
1553 .tiocmset = acm_tty_tiocmset,
1560 static int __init acm_init(void)
1563 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1564 if (!acm_tty_driver)
1566 acm_tty_driver->owner = THIS_MODULE,
1567 acm_tty_driver->driver_name = "acm",
1568 acm_tty_driver->name = "ttyACM",
1569 acm_tty_driver->major = ACM_TTY_MAJOR,
1570 acm_tty_driver->minor_start = 0,
1571 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1572 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1573 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1574 acm_tty_driver->init_termios = tty_std_termios;
1575 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1577 tty_set_operations(acm_tty_driver, &acm_ops);
1579 retval = tty_register_driver(acm_tty_driver);
1581 put_tty_driver(acm_tty_driver);
1585 retval = usb_register(&acm_driver);
1587 tty_unregister_driver(acm_tty_driver);
1588 put_tty_driver(acm_tty_driver);
1592 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1598 static void __exit acm_exit(void)
1600 usb_deregister(&acm_driver);
1601 tty_unregister_driver(acm_tty_driver);
1602 put_tty_driver(acm_tty_driver);
1605 module_init(acm_init);
1606 module_exit(acm_exit);
1608 MODULE_AUTHOR(DRIVER_AUTHOR);
1609 MODULE_DESCRIPTION(DRIVER_DESC);
1610 MODULE_LICENSE("GPL");
1611 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);