4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.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
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 #include <linux/kernel.h>
34 #include <linux/errno.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/tty.h>
38 #include <linux/serial.h>
39 #include <linux/tty_driver.h>
40 #include <linux/tty_flip.h>
41 #include <linux/module.h>
42 #include <linux/mutex.h>
43 #include <linux/uaccess.h>
44 #include <linux/usb.h>
45 #include <linux/usb/cdc.h>
46 #include <asm/byteorder.h>
47 #include <asm/unaligned.h>
48 #include <linux/list.h>
53 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
54 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
56 static struct usb_driver acm_driver;
57 static struct tty_driver *acm_tty_driver;
58 static struct acm *acm_table[ACM_TTY_MINORS];
60 static DEFINE_MUTEX(open_mutex);
62 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
64 static const struct tty_port_operations acm_port_ops = {
68 * Functions for ACM control messages.
71 static int acm_ctrl_msg(struct acm *acm, int request, int value,
74 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
75 request, USB_RT_ACM, value,
76 acm->control->altsetting[0].desc.bInterfaceNumber,
78 dev_dbg(&acm->control->dev,
79 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
80 __func__, request, value, len, retval);
81 return retval < 0 ? retval : 0;
84 /* devices aren't required to support these requests.
85 * the cdc acm descriptor tells whether they do...
87 #define acm_set_control(acm, control) \
88 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
89 #define acm_set_line(acm, line) \
90 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
91 #define acm_send_break(acm, ms) \
92 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
95 * Write buffer management.
96 * All of these assume proper locks taken by the caller.
99 static int acm_wb_alloc(struct acm *acm)
112 wbn = (wbn + 1) % ACM_NW;
118 static int acm_wb_is_avail(struct acm *acm)
124 spin_lock_irqsave(&acm->write_lock, flags);
125 for (i = 0; i < ACM_NW; i++)
127 spin_unlock_irqrestore(&acm->write_lock, flags);
132 * Finish write. Caller must hold acm->write_lock
134 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
138 usb_autopm_put_interface_async(acm->control);
144 * the caller is responsible for locking
147 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
153 wb->urb->transfer_buffer = wb->buf;
154 wb->urb->transfer_dma = wb->dmah;
155 wb->urb->transfer_buffer_length = wb->len;
156 wb->urb->dev = acm->dev;
158 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
160 dev_err(&acm->data->dev,
161 "%s - usb_submit_urb(write bulk) failed: %d\n",
163 acm_write_done(acm, wb);
168 static int acm_write_start(struct acm *acm, int wbn)
171 struct acm_wb *wb = &acm->wb[wbn];
174 spin_lock_irqsave(&acm->write_lock, flags);
177 spin_unlock_irqrestore(&acm->write_lock, flags);
181 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
183 usb_autopm_get_interface_async(acm->control);
184 if (acm->susp_count) {
185 if (!acm->delayed_wb)
186 acm->delayed_wb = wb;
188 usb_autopm_put_interface_async(acm->control);
189 spin_unlock_irqrestore(&acm->write_lock, flags);
190 return 0; /* A white lie */
192 usb_mark_last_busy(acm->dev);
194 rc = acm_start_wb(acm, wb);
195 spin_unlock_irqrestore(&acm->write_lock, flags);
201 * attributes exported through sysfs
203 static ssize_t show_caps
204 (struct device *dev, struct device_attribute *attr, char *buf)
206 struct usb_interface *intf = to_usb_interface(dev);
207 struct acm *acm = usb_get_intfdata(intf);
209 return sprintf(buf, "%d", acm->ctrl_caps);
211 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
213 static ssize_t show_country_codes
214 (struct device *dev, struct device_attribute *attr, char *buf)
216 struct usb_interface *intf = to_usb_interface(dev);
217 struct acm *acm = usb_get_intfdata(intf);
219 memcpy(buf, acm->country_codes, acm->country_code_size);
220 return acm->country_code_size;
223 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
225 static ssize_t show_country_rel_date
226 (struct device *dev, struct device_attribute *attr, char *buf)
228 struct usb_interface *intf = to_usb_interface(dev);
229 struct acm *acm = usb_get_intfdata(intf);
231 return sprintf(buf, "%d", acm->country_rel_date);
234 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
236 * Interrupt handlers for various ACM device responses
239 /* control interface reports status changes with "interrupt" transfers */
240 static void acm_ctrl_irq(struct urb *urb)
242 struct acm *acm = urb->context;
243 struct usb_cdc_notification *dr = urb->transfer_buffer;
244 struct tty_struct *tty;
248 int status = urb->status;
257 /* this urb is terminated, clean up */
258 dev_dbg(&acm->control->dev,
259 "%s - urb shutting down with status: %d\n",
263 dev_dbg(&acm->control->dev,
264 "%s - nonzero urb status received: %d\n",
272 usb_mark_last_busy(acm->dev);
274 data = (unsigned char *)(dr + 1);
275 switch (dr->bNotificationType) {
276 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
277 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
278 __func__, dr->wValue);
281 case USB_CDC_NOTIFY_SERIAL_STATE:
282 tty = tty_port_tty_get(&acm->port);
283 newctrl = get_unaligned_le16(data);
287 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
288 dev_dbg(&acm->control->dev,
289 "%s - calling hangup\n", __func__);
295 acm->ctrlin = newctrl;
297 dev_dbg(&acm->control->dev,
298 "%s - input control lines: dcd%c dsr%c break%c "
299 "ring%c framing%c parity%c overrun%c\n",
301 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
302 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
303 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
304 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
305 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
306 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
307 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
311 dev_dbg(&acm->control->dev,
312 "%s - unknown notification %d received: index %d "
313 "len %d data0 %d data1 %d\n",
315 dr->bNotificationType, dr->wIndex,
316 dr->wLength, data[0], data[1]);
320 retval = usb_submit_urb(urb, GFP_ATOMIC);
322 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
326 /* data interface returns incoming bytes, or we got unthrottled */
327 static void acm_read_bulk(struct urb *urb)
330 struct acm_ru *rcv = urb->context;
331 struct acm *acm = rcv->instance;
332 int status = urb->status;
334 dev_vdbg(&acm->data->dev, "%s - status %d\n", __func__, status);
336 if (!ACM_READY(acm)) {
337 dev_dbg(&acm->data->dev, "%s - acm not ready\n", __func__);
340 usb_mark_last_busy(acm->dev);
343 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
347 buf->size = urb->actual_length;
349 if (likely(status == 0)) {
350 spin_lock(&acm->read_lock);
352 list_add_tail(&rcv->list, &acm->spare_read_urbs);
353 list_add_tail(&buf->list, &acm->filled_read_bufs);
354 spin_unlock(&acm->read_lock);
356 /* we drop the buffer due to an error */
357 spin_lock(&acm->read_lock);
358 list_add_tail(&rcv->list, &acm->spare_read_urbs);
359 list_add(&buf->list, &acm->spare_read_bufs);
360 spin_unlock(&acm->read_lock);
361 /* nevertheless the tasklet must be kicked unconditionally
362 so the queue cannot dry up */
364 if (likely(!acm->susp_count))
365 tasklet_schedule(&acm->urb_task);
368 static void acm_rx_tasklet(unsigned long _acm)
370 struct acm *acm = (void *)_acm;
372 struct tty_struct *tty;
375 unsigned char throttled;
377 dev_vdbg(&acm->data->dev, "%s\n", __func__);
379 if (!ACM_READY(acm)) {
380 dev_dbg(&acm->data->dev, "%s - acm not ready\n", __func__);
384 spin_lock_irqsave(&acm->throttle_lock, flags);
385 throttled = acm->throttle;
386 spin_unlock_irqrestore(&acm->throttle_lock, flags);
388 dev_dbg(&acm->data->dev, "%s - throttled\n", __func__);
392 tty = tty_port_tty_get(&acm->port);
395 spin_lock_irqsave(&acm->read_lock, flags);
396 if (list_empty(&acm->filled_read_bufs)) {
397 spin_unlock_irqrestore(&acm->read_lock, flags);
400 buf = list_entry(acm->filled_read_bufs.next,
401 struct acm_rb, list);
402 list_del(&buf->list);
403 spin_unlock_irqrestore(&acm->read_lock, flags);
405 dev_vdbg(&acm->data->dev, "%s - processing buf 0x%p, size = %d\n",
406 __func__, buf, buf->size);
408 spin_lock_irqsave(&acm->throttle_lock, flags);
409 throttled = acm->throttle;
410 spin_unlock_irqrestore(&acm->throttle_lock, flags);
412 tty_insert_flip_string(tty, buf->base, buf->size);
413 tty_flip_buffer_push(tty);
416 dev_dbg(&acm->data->dev, "%s - throttling noticed\n",
418 spin_lock_irqsave(&acm->read_lock, flags);
419 list_add(&buf->list, &acm->filled_read_bufs);
420 spin_unlock_irqrestore(&acm->read_lock, flags);
425 spin_lock_irqsave(&acm->read_lock, flags);
426 list_add(&buf->list, &acm->spare_read_bufs);
427 spin_unlock_irqrestore(&acm->read_lock, flags);
433 while (!list_empty(&acm->spare_read_bufs)) {
434 spin_lock_irqsave(&acm->read_lock, flags);
435 if (list_empty(&acm->spare_read_urbs)) {
437 spin_unlock_irqrestore(&acm->read_lock, flags);
440 rcv = list_entry(acm->spare_read_urbs.next,
441 struct acm_ru, list);
442 list_del(&rcv->list);
443 spin_unlock_irqrestore(&acm->read_lock, flags);
445 buf = list_entry(acm->spare_read_bufs.next,
446 struct acm_rb, list);
447 list_del(&buf->list);
452 usb_fill_int_urb(rcv->urb, acm->dev,
456 acm_read_bulk, rcv, acm->bInterval);
458 usb_fill_bulk_urb(rcv->urb, acm->dev,
463 rcv->urb->transfer_dma = buf->dma;
464 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
466 /* This shouldn't kill the driver as unsuccessful URBs are
467 returned to the free-urbs-pool and resubmited ASAP */
468 spin_lock_irqsave(&acm->read_lock, flags);
469 if (acm->susp_count ||
470 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
471 list_add(&buf->list, &acm->spare_read_bufs);
472 list_add(&rcv->list, &acm->spare_read_urbs);
474 spin_unlock_irqrestore(&acm->read_lock, flags);
477 spin_unlock_irqrestore(&acm->read_lock, flags);
478 dev_vdbg(&acm->data->dev,
479 "%s - sending urb 0x%p, rcv 0x%p, buf 0x%p\n",
480 __func__, rcv->urb, rcv, buf);
483 spin_lock_irqsave(&acm->read_lock, flags);
485 spin_unlock_irqrestore(&acm->read_lock, flags);
488 /* data interface wrote those outgoing bytes */
489 static void acm_write_bulk(struct urb *urb)
491 struct acm_wb *wb = urb->context;
492 struct acm *acm = wb->instance;
495 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
496 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
499 urb->transfer_buffer_length,
502 spin_lock_irqsave(&acm->write_lock, flags);
503 acm_write_done(acm, wb);
504 spin_unlock_irqrestore(&acm->write_lock, flags);
506 schedule_work(&acm->work);
509 static void acm_softint(struct work_struct *work)
511 struct acm *acm = container_of(work, struct acm, work);
512 struct tty_struct *tty;
514 dev_vdbg(&acm->data->dev, "%s\n", __func__);
518 tty = tty_port_tty_get(&acm->port);
529 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
535 mutex_lock(&open_mutex);
537 acm = acm_table[tty->index];
538 if (!acm || !acm->dev)
543 dev_dbg(&acm->control->dev, "%s\n", __func__);
545 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
547 tty->driver_data = acm;
548 tty_port_tty_set(&acm->port, tty);
550 if (usb_autopm_get_interface(acm->control) < 0)
553 acm->control->needs_remote_wakeup = 1;
555 mutex_lock(&acm->mutex);
556 if (acm->port.count++) {
557 mutex_unlock(&acm->mutex);
558 usb_autopm_put_interface(acm->control);
562 acm->ctrlurb->dev = acm->dev;
563 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
564 dev_err(&acm->control->dev,
565 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
569 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
570 (acm->ctrl_caps & USB_CDC_CAP_LINE))
573 usb_autopm_put_interface(acm->control);
575 INIT_LIST_HEAD(&acm->spare_read_urbs);
576 INIT_LIST_HEAD(&acm->spare_read_bufs);
577 INIT_LIST_HEAD(&acm->filled_read_bufs);
579 for (i = 0; i < acm->rx_buflimit; i++)
580 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
581 for (i = 0; i < acm->rx_buflimit; i++)
582 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
586 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
587 rv = tty_port_block_til_ready(&acm->port, tty, filp);
588 tasklet_schedule(&acm->urb_task);
590 mutex_unlock(&acm->mutex);
592 mutex_unlock(&open_mutex);
596 usb_kill_urb(acm->ctrlurb);
599 mutex_unlock(&acm->mutex);
600 usb_autopm_put_interface(acm->control);
602 mutex_unlock(&open_mutex);
603 tty_port_tty_set(&acm->port, NULL);
607 static void acm_tty_unregister(struct acm *acm)
611 nr = acm->rx_buflimit;
612 tty_unregister_device(acm_tty_driver, acm->minor);
613 usb_put_intf(acm->control);
614 acm_table[acm->minor] = NULL;
615 usb_free_urb(acm->ctrlurb);
616 for (i = 0; i < ACM_NW; i++)
617 usb_free_urb(acm->wb[i].urb);
618 for (i = 0; i < nr; i++)
619 usb_free_urb(acm->ru[i].urb);
620 kfree(acm->country_codes);
624 static void acm_port_down(struct acm *acm)
626 int i, nr = acm->rx_buflimit;
627 mutex_lock(&open_mutex);
629 usb_autopm_get_interface(acm->control);
630 acm_set_control(acm, acm->ctrlout = 0);
631 usb_kill_urb(acm->ctrlurb);
632 for (i = 0; i < ACM_NW; i++)
633 usb_kill_urb(acm->wb[i].urb);
634 tasklet_disable(&acm->urb_task);
635 for (i = 0; i < nr; i++)
636 usb_kill_urb(acm->ru[i].urb);
637 tasklet_enable(&acm->urb_task);
638 acm->control->needs_remote_wakeup = 0;
639 usb_autopm_put_interface(acm->control);
641 mutex_unlock(&open_mutex);
644 static void acm_tty_hangup(struct tty_struct *tty)
646 struct acm *acm = tty->driver_data;
647 tty_port_hangup(&acm->port);
651 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
653 struct acm *acm = tty->driver_data;
655 /* Perform the closing process and see if we need to do the hardware
659 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
660 mutex_lock(&open_mutex);
662 tty_port_tty_set(&acm->port, NULL);
663 acm_tty_unregister(acm);
664 tty->driver_data = NULL;
666 mutex_unlock(&open_mutex);
670 tty_port_close_end(&acm->port, tty);
671 tty_port_tty_set(&acm->port, NULL);
674 static int acm_tty_write(struct tty_struct *tty,
675 const unsigned char *buf, int count)
677 struct acm *acm = tty->driver_data;
688 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
690 spin_lock_irqsave(&acm->write_lock, flags);
691 wbn = acm_wb_alloc(acm);
693 spin_unlock_irqrestore(&acm->write_lock, flags);
698 count = (count > acm->writesize) ? acm->writesize : count;
699 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
700 memcpy(wb->buf, buf, count);
702 spin_unlock_irqrestore(&acm->write_lock, flags);
704 stat = acm_write_start(acm, wbn);
710 static int acm_tty_write_room(struct tty_struct *tty)
712 struct acm *acm = tty->driver_data;
716 * Do not let the line discipline to know that we have a reserve,
717 * or it might get too enthusiastic.
719 return acm_wb_is_avail(acm) ? acm->writesize : 0;
722 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
724 struct acm *acm = tty->driver_data;
728 * This is inaccurate (overcounts), but it works.
730 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
733 static void acm_tty_throttle(struct tty_struct *tty)
735 struct acm *acm = tty->driver_data;
738 spin_lock_bh(&acm->throttle_lock);
740 spin_unlock_bh(&acm->throttle_lock);
743 static void acm_tty_unthrottle(struct tty_struct *tty)
745 struct acm *acm = tty->driver_data;
748 spin_lock_bh(&acm->throttle_lock);
750 spin_unlock_bh(&acm->throttle_lock);
751 tasklet_schedule(&acm->urb_task);
754 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
756 struct acm *acm = tty->driver_data;
760 retval = acm_send_break(acm, state ? 0xffff : 0);
762 dev_dbg(&acm->control->dev, "%s - send break failed\n",
767 static int acm_tty_tiocmget(struct tty_struct *tty)
769 struct acm *acm = tty->driver_data;
774 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
775 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
776 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
777 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
778 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
782 static int acm_tty_tiocmset(struct tty_struct *tty,
783 unsigned int set, unsigned int clear)
785 struct acm *acm = tty->driver_data;
786 unsigned int newctrl;
791 newctrl = acm->ctrlout;
792 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
793 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
794 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
795 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
797 newctrl = (newctrl & ~clear) | set;
799 if (acm->ctrlout == newctrl)
801 return acm_set_control(acm, acm->ctrlout = newctrl);
804 static int acm_tty_ioctl(struct tty_struct *tty,
805 unsigned int cmd, unsigned long arg)
807 struct acm *acm = tty->driver_data;
815 static const __u32 acm_tty_speed[] = {
816 0, 50, 75, 110, 134, 150, 200, 300, 600,
817 1200, 1800, 2400, 4800, 9600, 19200, 38400,
818 57600, 115200, 230400, 460800, 500000, 576000,
819 921600, 1000000, 1152000, 1500000, 2000000,
820 2500000, 3000000, 3500000, 4000000
823 static const __u8 acm_tty_size[] = {
827 static void acm_tty_set_termios(struct tty_struct *tty,
828 struct ktermios *termios_old)
830 struct acm *acm = tty->driver_data;
831 struct ktermios *termios = tty->termios;
832 struct usb_cdc_line_coding newline;
833 int newctrl = acm->ctrlout;
838 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
839 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
840 newline.bParityType = termios->c_cflag & PARENB ?
841 (termios->c_cflag & PARODD ? 1 : 2) +
842 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
843 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
844 /* FIXME: Needs to clear unsupported bits in the termios */
845 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
847 if (!newline.dwDTERate) {
848 newline.dwDTERate = acm->line.dwDTERate;
849 newctrl &= ~ACM_CTRL_DTR;
851 newctrl |= ACM_CTRL_DTR;
853 if (newctrl != acm->ctrlout)
854 acm_set_control(acm, acm->ctrlout = newctrl);
856 if (memcmp(&acm->line, &newline, sizeof newline)) {
857 memcpy(&acm->line, &newline, sizeof newline);
858 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
860 le32_to_cpu(newline.dwDTERate),
861 newline.bCharFormat, newline.bParityType,
863 acm_set_line(acm, &acm->line);
868 * USB probe and disconnect routines.
871 /* Little helpers: write/read buffers free */
872 static void acm_write_buffers_free(struct acm *acm)
876 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
878 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
879 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
882 static void acm_read_buffers_free(struct acm *acm)
884 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
885 int i, n = acm->rx_buflimit;
887 for (i = 0; i < n; i++)
888 usb_free_coherent(usb_dev, acm->readsize,
889 acm->rb[i].base, acm->rb[i].dma);
892 /* Little helper: write buffers allocate */
893 static int acm_write_buffers_alloc(struct acm *acm)
898 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
899 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
905 usb_free_coherent(acm->dev, acm->writesize,
914 static int acm_probe(struct usb_interface *intf,
915 const struct usb_device_id *id)
917 struct usb_cdc_union_desc *union_header = NULL;
918 struct usb_cdc_country_functional_desc *cfd = NULL;
919 unsigned char *buffer = intf->altsetting->extra;
920 int buflen = intf->altsetting->extralen;
921 struct usb_interface *control_interface;
922 struct usb_interface *data_interface;
923 struct usb_endpoint_descriptor *epctrl = NULL;
924 struct usb_endpoint_descriptor *epread = NULL;
925 struct usb_endpoint_descriptor *epwrite = NULL;
926 struct usb_device *usb_dev = interface_to_usbdev(intf);
929 int ctrlsize, readsize;
931 u8 ac_management_function = 0;
932 u8 call_management_function = 0;
933 int call_interface_num = -1;
934 int data_interface_num;
935 unsigned long quirks;
938 int combined_interfaces = 0;
941 quirks = (unsigned long)id->driver_info;
942 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
944 /* handle quirks deadly to normal probing*/
945 if (quirks == NO_UNION_NORMAL) {
946 data_interface = usb_ifnum_to_if(usb_dev, 1);
947 control_interface = usb_ifnum_to_if(usb_dev, 0);
948 goto skip_normal_probe;
953 dev_err(&intf->dev, "Weird descriptor references\n");
958 if (intf->cur_altsetting->endpoint &&
959 intf->cur_altsetting->endpoint->extralen &&
960 intf->cur_altsetting->endpoint->extra) {
962 "Seeking extra descriptors on endpoint\n");
963 buflen = intf->cur_altsetting->endpoint->extralen;
964 buffer = intf->cur_altsetting->endpoint->extra;
967 "Zero length descriptor references\n");
973 if (buffer[1] != USB_DT_CS_INTERFACE) {
974 dev_err(&intf->dev, "skipping garbage\n");
979 case USB_CDC_UNION_TYPE: /* we've found it */
981 dev_err(&intf->dev, "More than one "
982 "union descriptor, skipping ...\n");
985 union_header = (struct usb_cdc_union_desc *)buffer;
987 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
988 cfd = (struct usb_cdc_country_functional_desc *)buffer;
990 case USB_CDC_HEADER_TYPE: /* maybe check version */
991 break; /* for now we ignore it */
992 case USB_CDC_ACM_TYPE:
993 ac_management_function = buffer[3];
995 case USB_CDC_CALL_MANAGEMENT_TYPE:
996 call_management_function = buffer[3];
997 call_interface_num = buffer[4];
998 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
999 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1002 /* there are LOTS more CDC descriptors that
1003 * could legitimately be found here.
1005 dev_dbg(&intf->dev, "Ignoring descriptor: "
1006 "type %02x, length %d\n",
1007 buffer[2], buffer[0]);
1011 buflen -= buffer[0];
1012 buffer += buffer[0];
1015 if (!union_header) {
1016 if (call_interface_num > 0) {
1017 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1018 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1019 control_interface = intf;
1021 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1022 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1025 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1026 combined_interfaces = 1;
1027 control_interface = data_interface = intf;
1028 goto look_for_collapsed_interface;
1032 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1033 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1034 if (!control_interface || !data_interface) {
1035 dev_dbg(&intf->dev, "no interfaces\n");
1040 if (data_interface_num != call_interface_num)
1041 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1043 if (control_interface == data_interface) {
1044 /* some broken devices designed for windows work this way */
1045 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1046 combined_interfaces = 1;
1047 /* a popular other OS doesn't use it */
1048 quirks |= NO_CAP_LINE;
1049 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1050 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1053 look_for_collapsed_interface:
1054 for (i = 0; i < 3; i++) {
1055 struct usb_endpoint_descriptor *ep;
1056 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1058 if (usb_endpoint_is_int_in(ep))
1060 else if (usb_endpoint_is_bulk_out(ep))
1062 else if (usb_endpoint_is_bulk_in(ep))
1067 if (!epctrl || !epread || !epwrite)
1070 goto made_compressed_probe;
1075 /*workaround for switched interfaces */
1076 if (data_interface->cur_altsetting->desc.bInterfaceClass
1077 != CDC_DATA_INTERFACE_TYPE) {
1078 if (control_interface->cur_altsetting->desc.bInterfaceClass
1079 == CDC_DATA_INTERFACE_TYPE) {
1080 struct usb_interface *t;
1082 "Your device has switched interfaces.\n");
1083 t = control_interface;
1084 control_interface = data_interface;
1091 /* Accept probe requests only for the control interface */
1092 if (!combined_interfaces && intf != control_interface)
1095 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1096 /* valid in this context */
1097 dev_dbg(&intf->dev, "The data interface isn't available\n");
1102 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1105 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1106 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1107 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1110 /* workaround for switched endpoints */
1111 if (!usb_endpoint_dir_in(epread)) {
1112 /* descriptors are swapped */
1113 struct usb_endpoint_descriptor *t;
1115 "The data interface has switched endpoints\n");
1120 made_compressed_probe:
1121 dev_dbg(&intf->dev, "interfaces are valid\n");
1122 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1124 if (minor == ACM_TTY_MINORS) {
1125 dev_err(&intf->dev, "no more free acm devices\n");
1129 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1131 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1135 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1136 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1137 (quirks == SINGLE_RX_URB ? 1 : 2);
1138 acm->combined_interfaces = combined_interfaces;
1139 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1140 acm->control = control_interface;
1141 acm->data = data_interface;
1144 acm->ctrl_caps = ac_management_function;
1145 if (quirks & NO_CAP_LINE)
1146 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1147 acm->ctrlsize = ctrlsize;
1148 acm->readsize = readsize;
1149 acm->rx_buflimit = num_rx_buf;
1150 acm->urb_task.func = acm_rx_tasklet;
1151 acm->urb_task.data = (unsigned long) acm;
1152 INIT_WORK(&acm->work, acm_softint);
1153 spin_lock_init(&acm->throttle_lock);
1154 spin_lock_init(&acm->write_lock);
1155 spin_lock_init(&acm->read_lock);
1156 mutex_init(&acm->mutex);
1157 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1158 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1160 acm->bInterval = epread->bInterval;
1161 tty_port_init(&acm->port);
1162 acm->port.ops = &acm_port_ops;
1164 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1166 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1169 acm->ctrl_buffer = buf;
1171 if (acm_write_buffers_alloc(acm) < 0) {
1172 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1176 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1177 if (!acm->ctrlurb) {
1178 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1181 for (i = 0; i < num_rx_buf; i++) {
1182 struct acm_ru *rcv = &(acm->ru[i]);
1184 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1185 if (rcv->urb == NULL) {
1187 "out of memory (read urbs usb_alloc_urb)\n");
1191 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1192 rcv->instance = acm;
1194 for (i = 0; i < num_rx_buf; i++) {
1195 struct acm_rb *rb = &(acm->rb[i]);
1197 rb->base = usb_alloc_coherent(acm->dev, readsize,
1198 GFP_KERNEL, &rb->dma);
1201 "out of memory (read bufs usb_alloc_coherent)\n");
1205 for (i = 0; i < ACM_NW; i++) {
1206 struct acm_wb *snd = &(acm->wb[i]);
1208 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1209 if (snd->urb == NULL) {
1211 "out of memory (write urbs usb_alloc_urb)\n");
1215 if (usb_endpoint_xfer_int(epwrite))
1216 usb_fill_int_urb(snd->urb, usb_dev,
1217 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1218 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1220 usb_fill_bulk_urb(snd->urb, usb_dev,
1221 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1222 NULL, acm->writesize, acm_write_bulk, snd);
1223 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1224 snd->instance = acm;
1227 usb_set_intfdata(intf, acm);
1229 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1233 if (cfd) { /* export the country data */
1234 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1235 if (!acm->country_codes)
1236 goto skip_countries;
1237 acm->country_code_size = cfd->bLength - 4;
1238 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1240 acm->country_rel_date = cfd->iCountryCodeRelDate;
1242 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1244 kfree(acm->country_codes);
1245 goto skip_countries;
1248 i = device_create_file(&intf->dev,
1249 &dev_attr_iCountryCodeRelDate);
1251 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1252 kfree(acm->country_codes);
1253 goto skip_countries;
1258 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1259 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1260 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1261 /* works around buggy devices */
1262 epctrl->bInterval ? epctrl->bInterval : 0xff);
1263 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1264 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1266 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1268 acm_set_control(acm, acm->ctrlout);
1270 acm->line.dwDTERate = cpu_to_le32(9600);
1271 acm->line.bDataBits = 8;
1272 acm_set_line(acm, &acm->line);
1274 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1275 usb_set_intfdata(data_interface, acm);
1277 usb_get_intf(control_interface);
1278 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1280 acm_table[minor] = acm;
1284 for (i = 0; i < ACM_NW; i++)
1285 usb_free_urb(acm->wb[i].urb);
1287 acm_read_buffers_free(acm);
1289 for (i = 0; i < num_rx_buf; i++)
1290 usb_free_urb(acm->ru[i].urb);
1291 usb_free_urb(acm->ctrlurb);
1293 acm_write_buffers_free(acm);
1295 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1302 static void stop_data_traffic(struct acm *acm)
1306 dev_dbg(&acm->control->dev, "%s\n", __func__);
1308 tasklet_disable(&acm->urb_task);
1310 usb_kill_urb(acm->ctrlurb);
1311 for (i = 0; i < ACM_NW; i++)
1312 usb_kill_urb(acm->wb[i].urb);
1313 for (i = 0; i < acm->rx_buflimit; i++)
1314 usb_kill_urb(acm->ru[i].urb);
1316 tasklet_enable(&acm->urb_task);
1318 cancel_work_sync(&acm->work);
1321 static void acm_disconnect(struct usb_interface *intf)
1323 struct acm *acm = usb_get_intfdata(intf);
1324 struct usb_device *usb_dev = interface_to_usbdev(intf);
1325 struct tty_struct *tty;
1327 /* sibling interface is already cleaning up */
1331 mutex_lock(&open_mutex);
1332 if (acm->country_codes) {
1333 device_remove_file(&acm->control->dev,
1334 &dev_attr_wCountryCodes);
1335 device_remove_file(&acm->control->dev,
1336 &dev_attr_iCountryCodeRelDate);
1338 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1340 usb_set_intfdata(acm->control, NULL);
1341 usb_set_intfdata(acm->data, NULL);
1343 stop_data_traffic(acm);
1345 acm_write_buffers_free(acm);
1346 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1348 acm_read_buffers_free(acm);
1350 if (!acm->combined_interfaces)
1351 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1352 acm->data : acm->control);
1354 if (acm->port.count == 0) {
1355 acm_tty_unregister(acm);
1356 mutex_unlock(&open_mutex);
1360 mutex_unlock(&open_mutex);
1361 tty = tty_port_tty_get(&acm->port);
1369 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1371 struct acm *acm = usb_get_intfdata(intf);
1374 if (message.event & PM_EVENT_AUTO) {
1377 spin_lock_irq(&acm->read_lock);
1378 spin_lock(&acm->write_lock);
1379 b = acm->processing + acm->transmitting;
1380 spin_unlock(&acm->write_lock);
1381 spin_unlock_irq(&acm->read_lock);
1386 spin_lock_irq(&acm->read_lock);
1387 spin_lock(&acm->write_lock);
1388 cnt = acm->susp_count++;
1389 spin_unlock(&acm->write_lock);
1390 spin_unlock_irq(&acm->read_lock);
1395 we treat opened interfaces differently,
1396 we must guard against open
1398 mutex_lock(&acm->mutex);
1400 if (acm->port.count)
1401 stop_data_traffic(acm);
1403 mutex_unlock(&acm->mutex);
1407 static int acm_resume(struct usb_interface *intf)
1409 struct acm *acm = usb_get_intfdata(intf);
1414 spin_lock_irq(&acm->read_lock);
1415 acm->susp_count -= 1;
1416 cnt = acm->susp_count;
1417 spin_unlock_irq(&acm->read_lock);
1422 mutex_lock(&acm->mutex);
1423 if (acm->port.count) {
1424 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1426 spin_lock_irq(&acm->write_lock);
1427 if (acm->delayed_wb) {
1428 wb = acm->delayed_wb;
1429 acm->delayed_wb = NULL;
1430 spin_unlock_irq(&acm->write_lock);
1431 acm_start_wb(acm, wb);
1433 spin_unlock_irq(&acm->write_lock);
1437 * delayed error checking because we must
1438 * do the write path at all cost
1443 tasklet_schedule(&acm->urb_task);
1447 mutex_unlock(&acm->mutex);
1451 static int acm_reset_resume(struct usb_interface *intf)
1453 struct acm *acm = usb_get_intfdata(intf);
1454 struct tty_struct *tty;
1456 mutex_lock(&acm->mutex);
1457 if (acm->port.count) {
1458 tty = tty_port_tty_get(&acm->port);
1464 mutex_unlock(&acm->mutex);
1465 return acm_resume(intf);
1468 #endif /* CONFIG_PM */
1470 #define NOKIA_PCSUITE_ACM_INFO(x) \
1471 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1472 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1473 USB_CDC_ACM_PROTO_VENDOR)
1475 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1476 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1477 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1478 USB_CDC_ACM_PROTO_VENDOR)
1481 * USB driver structure.
1484 static const struct usb_device_id acm_ids[] = {
1485 /* quirky and broken devices */
1486 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1487 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1489 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1490 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1492 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1493 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1496 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1499 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1502 .driver_info = SINGLE_RX_URB,
1504 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1505 .driver_info = SINGLE_RX_URB, /* firmware bug */
1507 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1508 .driver_info = SINGLE_RX_URB, /* firmware bug */
1510 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1511 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1513 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1514 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1516 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1517 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1520 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1523 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1527 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1528 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1529 data interface instead of
1530 communications interface.
1531 Maybe we should define a new
1534 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1535 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1537 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1538 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1541 /* Nokia S60 phones expose two ACM channels. The first is
1542 * a modem and is picked up by the standard AT-command
1543 * information below. The second is 'vendor-specific' but
1544 * is treated as a serial device at the S60 end, so we want
1545 * to expose it on Linux too. */
1546 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1547 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1548 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1549 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1550 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1551 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1552 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1553 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1556 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1561 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1564 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1565 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1566 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1567 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1569 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1578 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1579 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1582 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1583 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1585 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1586 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1587 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1588 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1593 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1594 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1596 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1597 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1598 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1601 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1603 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1605 /* Support Lego NXT using pbLua firmware */
1606 { USB_DEVICE(0x0694, 0xff00),
1607 .driver_info = NOT_A_MODEM,
1610 /* control interfaces without any protocol set */
1611 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1612 USB_CDC_PROTO_NONE) },
1614 /* control interfaces with various AT-command sets */
1615 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1616 USB_CDC_ACM_PROTO_AT_V25TER) },
1617 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1618 USB_CDC_ACM_PROTO_AT_PCCA101) },
1619 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1620 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1621 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1622 USB_CDC_ACM_PROTO_AT_GSM) },
1623 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1624 USB_CDC_ACM_PROTO_AT_3G) },
1625 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1626 USB_CDC_ACM_PROTO_AT_CDMA) },
1631 MODULE_DEVICE_TABLE(usb, acm_ids);
1633 static struct usb_driver acm_driver = {
1636 .disconnect = acm_disconnect,
1638 .suspend = acm_suspend,
1639 .resume = acm_resume,
1640 .reset_resume = acm_reset_resume,
1642 .id_table = acm_ids,
1644 .supports_autosuspend = 1,
1649 * TTY driver structures.
1652 static const struct tty_operations acm_ops = {
1653 .open = acm_tty_open,
1654 .close = acm_tty_close,
1655 .hangup = acm_tty_hangup,
1656 .write = acm_tty_write,
1657 .write_room = acm_tty_write_room,
1658 .ioctl = acm_tty_ioctl,
1659 .throttle = acm_tty_throttle,
1660 .unthrottle = acm_tty_unthrottle,
1661 .chars_in_buffer = acm_tty_chars_in_buffer,
1662 .break_ctl = acm_tty_break_ctl,
1663 .set_termios = acm_tty_set_termios,
1664 .tiocmget = acm_tty_tiocmget,
1665 .tiocmset = acm_tty_tiocmset,
1672 static int __init acm_init(void)
1675 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1676 if (!acm_tty_driver)
1678 acm_tty_driver->owner = THIS_MODULE,
1679 acm_tty_driver->driver_name = "acm",
1680 acm_tty_driver->name = "ttyACM",
1681 acm_tty_driver->major = ACM_TTY_MAJOR,
1682 acm_tty_driver->minor_start = 0,
1683 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1684 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1685 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1686 acm_tty_driver->init_termios = tty_std_termios;
1687 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1689 tty_set_operations(acm_tty_driver, &acm_ops);
1691 retval = tty_register_driver(acm_tty_driver);
1693 put_tty_driver(acm_tty_driver);
1697 retval = usb_register(&acm_driver);
1699 tty_unregister_driver(acm_tty_driver);
1700 put_tty_driver(acm_tty_driver);
1704 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1709 static void __exit acm_exit(void)
1711 usb_deregister(&acm_driver);
1712 tty_unregister_driver(acm_tty_driver);
1713 put_tty_driver(acm_tty_driver);
1716 module_init(acm_init);
1717 module_exit(acm_exit);
1719 MODULE_AUTHOR(DRIVER_AUTHOR);
1720 MODULE_DESCRIPTION(DRIVER_DESC);
1721 MODULE_LICENSE("GPL");
1722 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);