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>
10 * USB Abstract Control Model driver for USB modems and ISDN adapters
15 * v0.9 - thorough cleaning, URBification, almost a rewrite
16 * v0.10 - some more cleanups
17 * v0.11 - fixed flow control, read error doesn't stop reads
18 * v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
19 * v0.13 - added termios, added hangup
20 * v0.14 - sized down struct acm
21 * v0.15 - fixed flow control again - characters could be lost
22 * v0.16 - added code for modems with swapped data and control interfaces
23 * v0.17 - added new style probing
24 * v0.18 - fixed new style probing for devices with more configurations
25 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
26 * v0.20 - switched to probing on interface (rather than device) class
27 * v0.21 - revert to probing on device for devices with multiple configs
28 * v0.22 - probe only the control interface. if usbcore doesn't choose the
29 * config we want, sysadmin changes bConfigurationValue in sysfs.
30 * v0.23 - use softirq for rx processing, as needed by tty layer
31 * v0.24 - change probe method to evaluate CDC union descriptor
35 * This program is free software; you can redistribute it and/or modify
36 * it under the terms of the GNU General Public License as published by
37 * the Free Software Foundation; either version 2 of the License, or
38 * (at your option) any later version.
40 * This program is distributed in the hope that it will be useful,
41 * but WITHOUT ANY WARRANTY; without even the implied warranty of
42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
43 * GNU General Public License for more details.
45 * You should have received a copy of the GNU General Public License
46 * along with this program; if not, write to the Free Software
47 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
52 #include <linux/kernel.h>
53 #include <linux/errno.h>
54 #include <linux/init.h>
55 #include <linux/slab.h>
56 #include <linux/tty.h>
57 #include <linux/tty_driver.h>
58 #include <linux/tty_flip.h>
59 #include <linux/module.h>
60 #include <linux/smp_lock.h>
61 #include <asm/uaccess.h>
62 #include <linux/usb.h>
63 #include <asm/byteorder.h>
64 #include <asm/unaligned.h>
71 #define DRIVER_VERSION "v0.23"
72 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik"
73 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
75 static struct usb_driver acm_driver;
76 static struct tty_driver *acm_tty_driver;
77 static struct acm *acm_table[ACM_TTY_MINORS];
79 static DECLARE_MUTEX(open_sem);
81 #define ACM_READY(acm) (acm && acm->dev && acm->used)
84 * Functions for ACM control messages.
87 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
89 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
90 request, USB_RT_ACM, value,
91 acm->control->altsetting[0].desc.bInterfaceNumber,
93 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
94 return retval < 0 ? retval : 0;
97 /* devices aren't required to support these requests.
98 * the cdc acm descriptor tells whether they do...
100 #define acm_set_control(acm, control) acm_ctrl_msg(acm, ACM_REQ_SET_CONTROL, control, NULL, 0)
101 #define acm_set_line(acm, line) acm_ctrl_msg(acm, ACM_REQ_SET_LINE, 0, line, sizeof(struct acm_line))
102 #define acm_send_break(acm, ms) acm_ctrl_msg(acm, ACM_REQ_SEND_BREAK, ms, NULL, 0)
105 * Interrupt handlers for various ACM device responses
108 /* control interface reports status changes with "interrupt" transfers */
109 static void acm_ctrl_irq(struct urb *urb, struct pt_regs *regs)
111 struct acm *acm = urb->context;
112 struct usb_ctrlrequest *dr = urb->transfer_buffer;
117 switch (urb->status) {
124 /* this urb is terminated, clean up */
125 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
128 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
135 data = (unsigned char *)(dr + 1);
136 switch (dr->bRequest) {
138 case ACM_IRQ_NETWORK:
140 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
143 case ACM_IRQ_LINE_STATE:
145 newctrl = le16_to_cpu(get_unaligned((__u16 *) data));
147 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
148 dbg("calling hangup");
149 tty_hangup(acm->tty);
152 acm->ctrlin = newctrl;
154 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
155 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
156 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
157 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
158 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
163 dbg("unknown control event received: request %d index %d len %d data0 %d data1 %d",
164 dr->bRequest, dr->wIndex, dr->wLength, data[0], data[1]);
168 status = usb_submit_urb (urb, GFP_ATOMIC);
170 err ("%s - usb_submit_urb failed with result %d",
171 __FUNCTION__, status);
174 /* data interface returns incoming bytes, or we got unthrottled */
175 static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
177 struct acm *acm = urb->context;
178 dbg("Entering acm_read_bulk with status %d\n", urb->status);
184 dev_dbg(&acm->data->dev, "bulk rx status %d\n", urb->status);
186 /* calling tty_flip_buffer_push() in_irq() isn't allowed */
187 tasklet_schedule(&acm->bh);
190 static void acm_rx_tasklet(unsigned long _acm)
192 struct acm *acm = (void *)_acm;
193 struct urb *urb = acm->readurb;
194 struct tty_struct *tty = acm->tty;
195 unsigned char *data = urb->transfer_buffer;
197 dbg("Entering acm_rx_tasklet");
199 if (urb->actual_length > 0 && !acm->throttle) {
200 for (i = 0; i < urb->actual_length && !acm->throttle; i++) {
201 /* if we insert more than TTY_FLIPBUF_SIZE characters,
203 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
204 tty_flip_buffer_push(tty);
206 tty_insert_flip_char(tty, data[i], 0);
208 dbg("Handed %d bytes to tty layer", i+1);
209 tty_flip_buffer_push(tty);
212 spin_lock(&acm->throttle_lock);
214 dbg("Throtteling noticed");
215 memmove(data, data + i, urb->actual_length - i);
216 urb->actual_length -= i;
217 acm->resubmit_to_unthrottle = 1;
218 spin_unlock(&acm->throttle_lock);
221 spin_unlock(&acm->throttle_lock);
223 urb->actual_length = 0;
226 i = usb_submit_urb(urb, GFP_ATOMIC);
228 dev_dbg(&acm->data->dev, "bulk rx resubmit %d\n", i);
231 /* data interface wrote those outgoing bytes */
232 static void acm_write_bulk(struct urb *urb, struct pt_regs *regs)
234 struct acm *acm = (struct acm *)urb->context;
235 dbg("Entering acm_write_bulk with status %d\n", urb->status);
241 dbg("nonzero write bulk status received: %d", urb->status);
243 schedule_work(&acm->work);
245 acm->ready_for_write = 1;
248 static void acm_softint(void *private)
250 struct acm *acm = private;
251 struct tty_struct *tty = acm->tty;
252 dbg("Entering acm_softint.\n");
257 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup)
258 (tty->ldisc.write_wakeup)(tty);
260 wake_up_interruptible(&tty->write_wait);
267 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
269 struct acm *acm = acm_table[tty->index];
270 dbg("Entering acm_tty_open.\n");
272 if (!acm || !acm->dev)
275 tty->driver_data = acm;
284 acm->ctrlurb->dev = acm->dev;
285 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
286 dbg("usb_submit_urb(ctrl irq) failed");
290 acm->readurb->dev = acm->dev;
291 if (usb_submit_urb(acm->readurb, GFP_KERNEL)) {
292 dbg("usb_submit_urb(read bulk) failed");
293 goto bail_out_and_unlink;
296 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
299 /* force low_latency on so that our tty_push actually forces the data through,
300 otherwise it is scheduled, and with high data rates data can get lost. */
301 tty->low_latency = 1;
309 usb_unlink_urb(acm->readurb);
311 usb_unlink_urb(acm->ctrlurb);
317 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
319 struct acm *acm = tty->driver_data;
321 if (!acm || !acm->used)
327 acm_set_control(acm, acm->ctrlout = 0);
328 usb_unlink_urb(acm->ctrlurb);
329 usb_unlink_urb(acm->writeurb);
330 usb_unlink_urb(acm->readurb);
332 tty_unregister_device(acm_tty_driver, acm->minor);
333 acm_table[acm->minor] = NULL;
334 usb_free_urb(acm->ctrlurb);
335 usb_free_urb(acm->readurb);
336 usb_free_urb(acm->writeurb);
343 static int acm_tty_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
345 struct acm *acm = tty->driver_data;
347 dbg("Entering acm_tty_write to write %d bytes from %s space,\n", count, from_user ? "user" : "kernel");
351 if (!acm->ready_for_write)
356 count = (count > acm->writesize) ? acm->writesize : count;
358 dbg("Get %d bytes from %s space...", count, from_user ? "user" : "kernel");
360 if (copy_from_user(acm->write_buffer, (void __user *)buf, count))
363 memcpy(acm->write_buffer, buf, count);
364 dbg(" Successfully copied.\n");
366 acm->writeurb->transfer_buffer_length = count;
367 acm->writeurb->dev = acm->dev;
369 acm->ready_for_write = 0;
370 stat = usb_submit_urb(acm->writeurb, GFP_NOIO);
372 dbg("usb_submit_urb(write bulk) failed");
373 acm->ready_for_write = 1;
380 static int acm_tty_write_room(struct tty_struct *tty)
382 struct acm *acm = tty->driver_data;
385 return !acm->ready_for_write ? 0 : acm->writesize;
388 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
390 struct acm *acm = tty->driver_data;
393 return !acm->ready_for_write ? acm->writeurb->transfer_buffer_length : 0;
396 static void acm_tty_throttle(struct tty_struct *tty)
398 struct acm *acm = tty->driver_data;
401 spin_lock_bh(&acm->throttle_lock);
403 spin_unlock_bh(&acm->throttle_lock);
406 static void acm_tty_unthrottle(struct tty_struct *tty)
408 struct acm *acm = tty->driver_data;
411 spin_lock_bh(&acm->throttle_lock);
413 spin_unlock_bh(&acm->throttle_lock);
414 if (acm->resubmit_to_unthrottle) {
415 acm->resubmit_to_unthrottle = 0;
416 acm_read_bulk(acm->readurb, NULL);
420 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
422 struct acm *acm = tty->driver_data;
425 if (acm_send_break(acm, state ? 0xffff : 0))
426 dbg("send break failed");
429 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
431 struct acm *acm = tty->driver_data;
436 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
437 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
438 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
439 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
440 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
444 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
445 unsigned int set, unsigned int clear)
447 struct acm *acm = tty->driver_data;
448 unsigned int newctrl;
453 newctrl = acm->ctrlout;
454 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
455 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
457 newctrl = (newctrl & ~clear) | set;
459 if (acm->ctrlout == newctrl)
461 return acm_set_control(acm, acm->ctrlout = newctrl);
464 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
466 struct acm *acm = tty->driver_data;
474 static __u32 acm_tty_speed[] = {
475 0, 50, 75, 110, 134, 150, 200, 300, 600,
476 1200, 1800, 2400, 4800, 9600, 19200, 38400,
477 57600, 115200, 230400, 460800, 500000, 576000,
478 921600, 1000000, 1152000, 1500000, 2000000,
479 2500000, 3000000, 3500000, 4000000
482 static __u8 acm_tty_size[] = {
486 static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
488 struct acm *acm = tty->driver_data;
489 struct termios *termios = tty->termios;
490 struct acm_line newline;
491 int newctrl = acm->ctrlout;
496 newline.speed = cpu_to_le32p(acm_tty_speed +
497 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
498 newline.stopbits = termios->c_cflag & CSTOPB ? 2 : 0;
499 newline.parity = termios->c_cflag & PARENB ?
500 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
501 newline.databits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
503 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
505 if (!newline.speed) {
506 newline.speed = acm->line.speed;
507 newctrl &= ~ACM_CTRL_DTR;
508 } else newctrl |= ACM_CTRL_DTR;
510 if (newctrl != acm->ctrlout)
511 acm_set_control(acm, acm->ctrlout = newctrl);
513 if (memcmp(&acm->line, &newline, sizeof(struct acm_line))) {
514 memcpy(&acm->line, &newline, sizeof(struct acm_line));
515 dbg("set line: %d %d %d %d", newline.speed, newline.stopbits, newline.parity, newline.databits);
516 acm_set_line(acm, &acm->line);
521 * USB probe and disconnect routines.
524 static int acm_probe (struct usb_interface *intf,
525 const struct usb_device_id *id)
527 struct union_desc *union_header = NULL;
528 char *buffer = intf->altsetting->extra;
529 int buflen = intf->altsetting->extralen;
530 struct usb_interface *control_interface;
531 struct usb_interface *data_interface;
532 struct usb_endpoint_descriptor *epctrl;
533 struct usb_endpoint_descriptor *epread;
534 struct usb_endpoint_descriptor *epwrite;
535 struct usb_device *usb_dev = interface_to_usbdev(intf);
538 int ctrlsize,readsize;
540 u8 ac_management_function = 0;
541 u8 call_management_function = 0;
542 int call_interface_num = -1;
543 int data_interface_num;
546 err("Wierd descriptor references");
551 if (buffer [1] != USB_DT_CS_INTERFACE) {
552 err("skipping garbage");
556 switch (buffer [2]) {
557 case CDC_UNION_TYPE: /* we've found it */
559 err("More than one union descriptor, skipping ...");
562 union_header = (struct union_desc *)buffer;
564 case CDC_COUNTRY_TYPE: /* maybe somehow export */
565 break; /* for now we ignore it */
566 case CDC_AC_MANAGEMENT_TYPE:
567 ac_management_function = buffer[3];
569 case CDC_CALL_MANAGEMENT_TYPE:
570 call_management_function = buffer[3];
571 call_interface_num = buffer[4];
572 if ((call_management_function & 3) != 3)
573 err("This device cannot do calls on its own. It is no modem.");
577 err("Ignoring extra header");
586 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
590 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
591 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
592 if (!control_interface || !data_interface) {
593 dev_dbg(&intf->dev,"no interfaces\n");
597 if (data_interface_num != call_interface_num)
598 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
600 if (usb_interface_claimed(data_interface)) { /* valid in this context */
601 dev_dbg(&intf->dev,"The data interface isn't available\n");
605 /*workaround for switched interfaces */
606 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
607 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
608 struct usb_interface *t;
609 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
611 t = control_interface;
612 control_interface = data_interface;
618 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
621 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
622 epread = &data_interface->cur_altsetting->endpoint[0].desc;
623 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
626 /* workaround for switched endpoints */
627 if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
628 /* descriptors are swapped */
629 struct usb_endpoint_descriptor *t;
630 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
636 dbg("interfaces are valid");
637 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
639 if (acm_table[minor]) {
640 err("no more free acm devices");
644 if (!(acm = kmalloc(sizeof(struct acm), GFP_KERNEL))) {
645 dev_dbg(&intf->dev, "out of memory (acm kmalloc)\n");
648 memset(acm, 0, sizeof(struct acm));
650 ctrlsize = epctrl->wMaxPacketSize;
651 readsize = epread->wMaxPacketSize;
652 acm->writesize = epwrite->wMaxPacketSize;
653 acm->control = control_interface;
654 acm->data = data_interface;
657 acm->ctrl_caps = ac_management_function;
658 acm->ctrlsize = ctrlsize;
659 acm->readsize = readsize;
660 acm->bh.func = acm_rx_tasklet;
661 acm->bh.data = (unsigned long) acm;
662 INIT_WORK(&acm->work, acm_softint, acm);
663 spin_lock_init(&acm->throttle_lock);
664 acm->ready_for_write = 1;
666 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
668 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
671 acm->ctrl_buffer = buf;
673 buf = usb_buffer_alloc(usb_dev, readsize, GFP_KERNEL, &acm->read_dma);
675 dev_dbg(&intf->dev, "out of memory (read buffer alloc)\n");
678 acm->read_buffer = buf;
680 buf = usb_buffer_alloc(usb_dev, acm->writesize, GFP_KERNEL, &acm->write_dma);
682 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
685 acm->write_buffer = buf;
687 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
689 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
692 acm->readurb = usb_alloc_urb(0, GFP_KERNEL);
694 dev_dbg(&intf->dev, "out of memory (readurb kmalloc)\n");
697 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
698 if (!acm->writeurb) {
699 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
703 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
704 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
705 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
706 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
708 usb_fill_bulk_urb(acm->readurb, usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress),
709 acm->read_buffer, readsize, acm_read_bulk, acm);
710 acm->readurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
711 acm->readurb->transfer_dma = acm->read_dma;
713 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
714 acm->write_buffer, acm->writesize, acm_write_bulk, acm);
715 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
716 acm->writeurb->transfer_dma = acm->write_dma;
718 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
720 acm_set_control(acm, acm->ctrlout);
722 acm->line.speed = cpu_to_le32(9600);
723 acm->line.databits = 8;
724 acm_set_line(acm, &acm->line);
726 usb_driver_claim_interface(&acm_driver, data_interface, acm);
728 tty_register_device(acm_tty_driver, minor, &intf->dev);
730 acm_table[minor] = acm;
731 usb_set_intfdata (intf, acm);
735 usb_free_urb(acm->readurb);
737 usb_free_urb(acm->ctrlurb);
739 usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
741 usb_buffer_free(usb_dev, readsize, acm->read_buffer, acm->read_dma);
743 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
750 static void acm_disconnect(struct usb_interface *intf)
752 struct acm *acm = usb_get_intfdata (intf);
753 struct usb_device *usb_dev = interface_to_usbdev(intf);
755 if (!acm || !acm->dev) {
756 dbg("disconnect on nonexisting interface");
762 usb_set_intfdata (intf, NULL);
764 usb_unlink_urb(acm->ctrlurb);
765 usb_unlink_urb(acm->readurb);
766 usb_unlink_urb(acm->writeurb);
768 flush_scheduled_work(); /* wait for acm_softint */
770 usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
771 usb_buffer_free(usb_dev, acm->readsize, acm->read_buffer, acm->read_dma);
772 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
774 usb_driver_release_interface(&acm_driver, acm->data);
777 tty_unregister_device(acm_tty_driver, acm->minor);
778 acm_table[acm->minor] = NULL;
779 usb_free_urb(acm->ctrlurb);
780 usb_free_urb(acm->readurb);
781 usb_free_urb(acm->writeurb);
790 tty_hangup(acm->tty);
794 * USB driver structure.
797 static struct usb_device_id acm_ids[] = {
798 /* control interfaces with various AT-command sets */
799 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 1) },
800 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 2) },
801 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 3) },
802 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 4) },
803 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 5) },
804 { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 6) },
806 /* NOTE: COMM/2/0xff is likely MSFT RNDIS ... NOT a modem!! */
810 MODULE_DEVICE_TABLE (usb, acm_ids);
812 static struct usb_driver acm_driver = {
813 .owner = THIS_MODULE,
816 .disconnect = acm_disconnect,
821 * TTY driver structures.
824 static struct tty_operations acm_ops = {
825 .open = acm_tty_open,
826 .close = acm_tty_close,
827 .write = acm_tty_write,
828 .write_room = acm_tty_write_room,
829 .ioctl = acm_tty_ioctl,
830 .throttle = acm_tty_throttle,
831 .unthrottle = acm_tty_unthrottle,
832 .chars_in_buffer = acm_tty_chars_in_buffer,
833 .break_ctl = acm_tty_break_ctl,
834 .set_termios = acm_tty_set_termios,
835 .tiocmget = acm_tty_tiocmget,
836 .tiocmset = acm_tty_tiocmset,
843 static int __init acm_init(void)
846 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
849 acm_tty_driver->owner = THIS_MODULE,
850 acm_tty_driver->driver_name = "acm",
851 acm_tty_driver->name = "ttyACM",
852 acm_tty_driver->devfs_name = "usb/acm/",
853 acm_tty_driver->major = ACM_TTY_MAJOR,
854 acm_tty_driver->minor_start = 0,
855 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
856 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
857 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
858 acm_tty_driver->init_termios = tty_std_termios;
859 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
860 tty_set_operations(acm_tty_driver, &acm_ops);
862 retval = tty_register_driver(acm_tty_driver);
864 put_tty_driver(acm_tty_driver);
868 retval = usb_register(&acm_driver);
870 tty_unregister_driver(acm_tty_driver);
871 put_tty_driver(acm_tty_driver);
875 info(DRIVER_VERSION ":" DRIVER_DESC);
880 static void __exit acm_exit(void)
882 usb_deregister(&acm_driver);
883 tty_unregister_driver(acm_tty_driver);
884 put_tty_driver(acm_tty_driver);
887 module_init(acm_init);
888 module_exit(acm_exit);
890 MODULE_AUTHOR( DRIVER_AUTHOR );
891 MODULE_DESCRIPTION( DRIVER_DESC );
892 MODULE_LICENSE("GPL");