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>
10 * Copyright (c) 2011 Johan Hovold <jhovold@gmail.com>
12 * USB Abstract Control Model driver for USB modems and ISDN adapters
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #include <linux/kernel.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/tty.h>
39 #include <linux/serial.h>
40 #include <linux/tty_driver.h>
41 #include <linux/tty_flip.h>
42 #include <linux/serial.h>
43 #include <linux/module.h>
44 #include <linux/mutex.h>
45 #include <linux/uaccess.h>
46 #include <linux/usb.h>
47 #include <linux/usb/cdc.h>
48 #include <asm/byteorder.h>
49 #include <asm/unaligned.h>
50 #include <linux/list.h>
55 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
56 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
58 static struct usb_driver acm_driver
;
59 static struct tty_driver
*acm_tty_driver
;
60 static struct acm
*acm_table
[ACM_TTY_MINORS
];
62 static DEFINE_MUTEX(acm_table_lock
);
69 * Look up an ACM structure by index. If found and not disconnected, increment
70 * its refcount and return it with its mutex held.
72 static struct acm
*acm_get_by_index(unsigned index
)
76 mutex_lock(&acm_table_lock
);
77 acm
= acm_table
[index
];
79 mutex_lock(&acm
->mutex
);
80 if (acm
->disconnected
) {
81 mutex_unlock(&acm
->mutex
);
84 tty_port_get(&acm
->port
);
85 mutex_unlock(&acm
->mutex
);
88 mutex_unlock(&acm_table_lock
);
93 * Try to find an available minor number and if found, associate it with 'acm'.
95 static int acm_alloc_minor(struct acm
*acm
)
99 mutex_lock(&acm_table_lock
);
100 for (minor
= 0; minor
< ACM_TTY_MINORS
; minor
++) {
101 if (!acm_table
[minor
]) {
102 acm_table
[minor
] = acm
;
106 mutex_unlock(&acm_table_lock
);
111 /* Release the minor number associated with 'acm'. */
112 static void acm_release_minor(struct acm
*acm
)
114 mutex_lock(&acm_table_lock
);
115 acm_table
[acm
->minor
] = NULL
;
116 mutex_unlock(&acm_table_lock
);
120 * Functions for ACM control messages.
123 static int acm_ctrl_msg(struct acm
*acm
, int request
, int value
,
126 int retval
= usb_control_msg(acm
->dev
, usb_sndctrlpipe(acm
->dev
, 0),
127 request
, USB_RT_ACM
, value
,
128 acm
->control
->altsetting
[0].desc
.bInterfaceNumber
,
130 dev_dbg(&acm
->control
->dev
,
131 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
132 __func__
, request
, value
, len
, retval
);
133 return retval
< 0 ? retval
: 0;
136 /* devices aren't required to support these requests.
137 * the cdc acm descriptor tells whether they do...
139 #define acm_set_control(acm, control) \
140 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
141 #define acm_set_line(acm, line) \
142 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
143 #define acm_send_break(acm, ms) \
144 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
147 * Write buffer management.
148 * All of these assume proper locks taken by the caller.
151 static int acm_wb_alloc(struct acm
*acm
)
164 wbn
= (wbn
+ 1) % ACM_NW
;
170 static int acm_wb_is_avail(struct acm
*acm
)
176 spin_lock_irqsave(&acm
->write_lock
, flags
);
177 for (i
= 0; i
< ACM_NW
; i
++)
179 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
184 * Finish write. Caller must hold acm->write_lock
186 static void acm_write_done(struct acm
*acm
, struct acm_wb
*wb
)
190 usb_autopm_put_interface_async(acm
->control
);
196 * the caller is responsible for locking
199 static int acm_start_wb(struct acm
*acm
, struct acm_wb
*wb
)
205 wb
->urb
->transfer_buffer
= wb
->buf
;
206 wb
->urb
->transfer_dma
= wb
->dmah
;
207 wb
->urb
->transfer_buffer_length
= wb
->len
;
208 wb
->urb
->dev
= acm
->dev
;
210 rc
= usb_submit_urb(wb
->urb
, GFP_ATOMIC
);
212 dev_err(&acm
->data
->dev
,
213 "%s - usb_submit_urb(write bulk) failed: %d\n",
215 acm_write_done(acm
, wb
);
220 static int acm_write_start(struct acm
*acm
, int wbn
)
223 struct acm_wb
*wb
= &acm
->wb
[wbn
];
226 spin_lock_irqsave(&acm
->write_lock
, flags
);
229 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
233 dev_vdbg(&acm
->data
->dev
, "%s - susp_count %d\n", __func__
,
235 usb_autopm_get_interface_async(acm
->control
);
236 if (acm
->susp_count
) {
237 if (!acm
->delayed_wb
)
238 acm
->delayed_wb
= wb
;
240 usb_autopm_put_interface_async(acm
->control
);
241 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
242 return 0; /* A white lie */
244 usb_mark_last_busy(acm
->dev
);
246 rc
= acm_start_wb(acm
, wb
);
247 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
253 * attributes exported through sysfs
255 static ssize_t show_caps
256 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
258 struct usb_interface
*intf
= to_usb_interface(dev
);
259 struct acm
*acm
= usb_get_intfdata(intf
);
261 return sprintf(buf
, "%d", acm
->ctrl_caps
);
263 static DEVICE_ATTR(bmCapabilities
, S_IRUGO
, show_caps
, NULL
);
265 static ssize_t show_country_codes
266 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
268 struct usb_interface
*intf
= to_usb_interface(dev
);
269 struct acm
*acm
= usb_get_intfdata(intf
);
271 memcpy(buf
, acm
->country_codes
, acm
->country_code_size
);
272 return acm
->country_code_size
;
275 static DEVICE_ATTR(wCountryCodes
, S_IRUGO
, show_country_codes
, NULL
);
277 static ssize_t show_country_rel_date
278 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
280 struct usb_interface
*intf
= to_usb_interface(dev
);
281 struct acm
*acm
= usb_get_intfdata(intf
);
283 return sprintf(buf
, "%d", acm
->country_rel_date
);
286 static DEVICE_ATTR(iCountryCodeRelDate
, S_IRUGO
, show_country_rel_date
, NULL
);
288 * Interrupt handlers for various ACM device responses
291 /* control interface reports status changes with "interrupt" transfers */
292 static void acm_ctrl_irq(struct urb
*urb
)
294 struct acm
*acm
= urb
->context
;
295 struct usb_cdc_notification
*dr
= urb
->transfer_buffer
;
296 struct tty_struct
*tty
;
300 int status
= urb
->status
;
309 /* this urb is terminated, clean up */
310 dev_dbg(&acm
->control
->dev
,
311 "%s - urb shutting down with status: %d\n",
315 dev_dbg(&acm
->control
->dev
,
316 "%s - nonzero urb status received: %d\n",
321 usb_mark_last_busy(acm
->dev
);
323 data
= (unsigned char *)(dr
+ 1);
324 switch (dr
->bNotificationType
) {
325 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
326 dev_dbg(&acm
->control
->dev
, "%s - network connection: %d\n",
327 __func__
, dr
->wValue
);
330 case USB_CDC_NOTIFY_SERIAL_STATE
:
331 tty
= tty_port_tty_get(&acm
->port
);
332 newctrl
= get_unaligned_le16(data
);
336 (acm
->ctrlin
& ~newctrl
& ACM_CTRL_DCD
)) {
337 dev_dbg(&acm
->control
->dev
,
338 "%s - calling hangup\n", __func__
);
344 acm
->ctrlin
= newctrl
;
346 dev_dbg(&acm
->control
->dev
,
347 "%s - input control lines: dcd%c dsr%c break%c "
348 "ring%c framing%c parity%c overrun%c\n",
350 acm
->ctrlin
& ACM_CTRL_DCD
? '+' : '-',
351 acm
->ctrlin
& ACM_CTRL_DSR
? '+' : '-',
352 acm
->ctrlin
& ACM_CTRL_BRK
? '+' : '-',
353 acm
->ctrlin
& ACM_CTRL_RI
? '+' : '-',
354 acm
->ctrlin
& ACM_CTRL_FRAMING
? '+' : '-',
355 acm
->ctrlin
& ACM_CTRL_PARITY
? '+' : '-',
356 acm
->ctrlin
& ACM_CTRL_OVERRUN
? '+' : '-');
360 dev_dbg(&acm
->control
->dev
,
361 "%s - unknown notification %d received: index %d "
362 "len %d data0 %d data1 %d\n",
364 dr
->bNotificationType
, dr
->wIndex
,
365 dr
->wLength
, data
[0], data
[1]);
369 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
371 dev_err(&acm
->control
->dev
, "%s - usb_submit_urb failed: %d\n",
375 static int acm_submit_read_urb(struct acm
*acm
, int index
, gfp_t mem_flags
)
379 if (!test_and_clear_bit(index
, &acm
->read_urbs_free
))
382 dev_vdbg(&acm
->data
->dev
, "%s - urb %d\n", __func__
, index
);
384 res
= usb_submit_urb(acm
->read_urbs
[index
], mem_flags
);
387 dev_err(&acm
->data
->dev
,
388 "%s - usb_submit_urb failed: %d\n",
391 set_bit(index
, &acm
->read_urbs_free
);
398 static int acm_submit_read_urbs(struct acm
*acm
, gfp_t mem_flags
)
403 for (i
= 0; i
< acm
->rx_buflimit
; ++i
) {
404 res
= acm_submit_read_urb(acm
, i
, mem_flags
);
412 static void acm_process_read_urb(struct acm
*acm
, struct urb
*urb
)
414 struct tty_struct
*tty
;
416 if (!urb
->actual_length
)
419 tty
= tty_port_tty_get(&acm
->port
);
423 tty_insert_flip_string(tty
, urb
->transfer_buffer
, urb
->actual_length
);
424 tty_flip_buffer_push(tty
);
429 static void acm_read_bulk_callback(struct urb
*urb
)
431 struct acm_rb
*rb
= urb
->context
;
432 struct acm
*acm
= rb
->instance
;
435 dev_vdbg(&acm
->data
->dev
, "%s - urb %d, len %d\n", __func__
,
436 rb
->index
, urb
->actual_length
);
437 set_bit(rb
->index
, &acm
->read_urbs_free
);
440 dev_dbg(&acm
->data
->dev
, "%s - disconnected\n", __func__
);
443 usb_mark_last_busy(acm
->dev
);
446 dev_dbg(&acm
->data
->dev
, "%s - non-zero urb status: %d\n",
447 __func__
, urb
->status
);
450 acm_process_read_urb(acm
, urb
);
452 /* throttle device if requested by tty */
453 spin_lock_irqsave(&acm
->read_lock
, flags
);
454 acm
->throttled
= acm
->throttle_req
;
455 if (!acm
->throttled
&& !acm
->susp_count
) {
456 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
457 acm_submit_read_urb(acm
, rb
->index
, GFP_ATOMIC
);
459 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
463 /* data interface wrote those outgoing bytes */
464 static void acm_write_bulk(struct urb
*urb
)
466 struct acm_wb
*wb
= urb
->context
;
467 struct acm
*acm
= wb
->instance
;
470 if (urb
->status
|| (urb
->actual_length
!= urb
->transfer_buffer_length
))
471 dev_vdbg(&acm
->data
->dev
, "%s - len %d/%d, status %d\n",
474 urb
->transfer_buffer_length
,
477 spin_lock_irqsave(&acm
->write_lock
, flags
);
478 acm_write_done(acm
, wb
);
479 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
480 schedule_work(&acm
->work
);
483 static void acm_softint(struct work_struct
*work
)
485 struct acm
*acm
= container_of(work
, struct acm
, work
);
486 struct tty_struct
*tty
;
488 dev_vdbg(&acm
->data
->dev
, "%s\n", __func__
);
490 tty
= tty_port_tty_get(&acm
->port
);
501 static int acm_tty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
506 dev_dbg(tty
->dev
, "%s\n", __func__
);
508 acm
= acm_get_by_index(tty
->index
);
512 retval
= tty_standard_install(driver
, tty
);
514 goto error_init_termios
;
516 tty
->driver_data
= acm
;
521 tty_port_put(&acm
->port
);
525 static int acm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
527 struct acm
*acm
= tty
->driver_data
;
529 dev_dbg(tty
->dev
, "%s\n", __func__
);
531 return tty_port_open(&acm
->port
, tty
, filp
);
534 static int acm_port_activate(struct tty_port
*port
, struct tty_struct
*tty
)
536 struct acm
*acm
= container_of(port
, struct acm
, port
);
537 int retval
= -ENODEV
;
539 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
541 mutex_lock(&acm
->mutex
);
542 if (acm
->disconnected
)
545 retval
= usb_autopm_get_interface(acm
->control
);
547 goto error_get_interface
;
550 * FIXME: Why do we need this? Allocating 64K of physically contiguous
551 * memory is really nasty...
553 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
554 acm
->control
->needs_remote_wakeup
= 1;
556 acm
->ctrlurb
->dev
= acm
->dev
;
557 if (usb_submit_urb(acm
->ctrlurb
, GFP_KERNEL
)) {
558 dev_err(&acm
->control
->dev
,
559 "%s - usb_submit_urb(ctrl irq) failed\n", __func__
);
560 goto error_submit_urb
;
563 acm
->ctrlout
= ACM_CTRL_DTR
| ACM_CTRL_RTS
;
564 if (acm_set_control(acm
, acm
->ctrlout
) < 0 &&
565 (acm
->ctrl_caps
& USB_CDC_CAP_LINE
))
566 goto error_set_control
;
568 usb_autopm_put_interface(acm
->control
);
571 * Unthrottle device in case the TTY was closed while throttled.
573 spin_lock_irq(&acm
->read_lock
);
575 acm
->throttle_req
= 0;
576 spin_unlock_irq(&acm
->read_lock
);
578 if (acm_submit_read_urbs(acm
, GFP_KERNEL
))
579 goto error_submit_read_urbs
;
581 mutex_unlock(&acm
->mutex
);
585 error_submit_read_urbs
:
587 acm_set_control(acm
, acm
->ctrlout
);
589 usb_kill_urb(acm
->ctrlurb
);
591 usb_autopm_put_interface(acm
->control
);
594 mutex_unlock(&acm
->mutex
);
598 static void acm_port_destruct(struct tty_port
*port
)
600 struct acm
*acm
= container_of(port
, struct acm
, port
);
602 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
604 tty_unregister_device(acm_tty_driver
, acm
->minor
);
605 acm_release_minor(acm
);
606 usb_put_intf(acm
->control
);
607 kfree(acm
->country_codes
);
611 static void acm_port_shutdown(struct tty_port
*port
)
613 struct acm
*acm
= container_of(port
, struct acm
, port
);
616 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
618 mutex_lock(&acm
->mutex
);
619 if (!acm
->disconnected
) {
620 usb_autopm_get_interface(acm
->control
);
621 acm_set_control(acm
, acm
->ctrlout
= 0);
622 usb_kill_urb(acm
->ctrlurb
);
623 for (i
= 0; i
< ACM_NW
; i
++)
624 usb_kill_urb(acm
->wb
[i
].urb
);
625 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
626 usb_kill_urb(acm
->read_urbs
[i
]);
627 acm
->control
->needs_remote_wakeup
= 0;
628 usb_autopm_put_interface(acm
->control
);
630 mutex_unlock(&acm
->mutex
);
633 static void acm_tty_cleanup(struct tty_struct
*tty
)
635 struct acm
*acm
= tty
->driver_data
;
636 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
637 tty_port_put(&acm
->port
);
640 static void acm_tty_hangup(struct tty_struct
*tty
)
642 struct acm
*acm
= tty
->driver_data
;
643 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
644 tty_port_hangup(&acm
->port
);
647 static void acm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
649 struct acm
*acm
= tty
->driver_data
;
650 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
651 tty_port_close(&acm
->port
, tty
, filp
);
654 static int acm_tty_write(struct tty_struct
*tty
,
655 const unsigned char *buf
, int count
)
657 struct acm
*acm
= tty
->driver_data
;
666 dev_vdbg(&acm
->data
->dev
, "%s - count %d\n", __func__
, count
);
668 spin_lock_irqsave(&acm
->write_lock
, flags
);
669 wbn
= acm_wb_alloc(acm
);
671 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
676 count
= (count
> acm
->writesize
) ? acm
->writesize
: count
;
677 dev_vdbg(&acm
->data
->dev
, "%s - write %d\n", __func__
, count
);
678 memcpy(wb
->buf
, buf
, count
);
680 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
682 stat
= acm_write_start(acm
, wbn
);
688 static int acm_tty_write_room(struct tty_struct
*tty
)
690 struct acm
*acm
= tty
->driver_data
;
692 * Do not let the line discipline to know that we have a reserve,
693 * or it might get too enthusiastic.
695 return acm_wb_is_avail(acm
) ? acm
->writesize
: 0;
698 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
)
700 struct acm
*acm
= tty
->driver_data
;
702 * if the device was unplugged then any remaining characters fell out
703 * of the connector ;)
705 if (acm
->disconnected
)
708 * This is inaccurate (overcounts), but it works.
710 return (ACM_NW
- acm_wb_is_avail(acm
)) * acm
->writesize
;
713 static void acm_tty_throttle(struct tty_struct
*tty
)
715 struct acm
*acm
= tty
->driver_data
;
717 spin_lock_irq(&acm
->read_lock
);
718 acm
->throttle_req
= 1;
719 spin_unlock_irq(&acm
->read_lock
);
722 static void acm_tty_unthrottle(struct tty_struct
*tty
)
724 struct acm
*acm
= tty
->driver_data
;
725 unsigned int was_throttled
;
727 spin_lock_irq(&acm
->read_lock
);
728 was_throttled
= acm
->throttled
;
730 acm
->throttle_req
= 0;
731 spin_unlock_irq(&acm
->read_lock
);
734 acm_submit_read_urbs(acm
, GFP_KERNEL
);
737 static int acm_tty_break_ctl(struct tty_struct
*tty
, int state
)
739 struct acm
*acm
= tty
->driver_data
;
742 retval
= acm_send_break(acm
, state
? 0xffff : 0);
744 dev_dbg(&acm
->control
->dev
, "%s - send break failed\n",
749 static int acm_tty_tiocmget(struct tty_struct
*tty
)
751 struct acm
*acm
= tty
->driver_data
;
753 return (acm
->ctrlout
& ACM_CTRL_DTR
? TIOCM_DTR
: 0) |
754 (acm
->ctrlout
& ACM_CTRL_RTS
? TIOCM_RTS
: 0) |
755 (acm
->ctrlin
& ACM_CTRL_DSR
? TIOCM_DSR
: 0) |
756 (acm
->ctrlin
& ACM_CTRL_RI
? TIOCM_RI
: 0) |
757 (acm
->ctrlin
& ACM_CTRL_DCD
? TIOCM_CD
: 0) |
761 static int acm_tty_tiocmset(struct tty_struct
*tty
,
762 unsigned int set
, unsigned int clear
)
764 struct acm
*acm
= tty
->driver_data
;
765 unsigned int newctrl
;
767 newctrl
= acm
->ctrlout
;
768 set
= (set
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
769 (set
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
770 clear
= (clear
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
771 (clear
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
773 newctrl
= (newctrl
& ~clear
) | set
;
775 if (acm
->ctrlout
== newctrl
)
777 return acm_set_control(acm
, acm
->ctrlout
= newctrl
);
780 static int get_serial_info(struct acm
*acm
, struct serial_struct __user
*info
)
782 struct serial_struct tmp
;
787 memset(&tmp
, 0, sizeof(tmp
));
788 tmp
.flags
= ASYNC_LOW_LATENCY
;
789 tmp
.xmit_fifo_size
= acm
->writesize
;
790 tmp
.baud_base
= le32_to_cpu(acm
->line
.dwDTERate
);
792 if (copy_to_user(info
, &tmp
, sizeof(tmp
)))
798 static int acm_tty_ioctl(struct tty_struct
*tty
,
799 unsigned int cmd
, unsigned long arg
)
801 struct acm
*acm
= tty
->driver_data
;
802 int rv
= -ENOIOCTLCMD
;
805 case TIOCGSERIAL
: /* gets serial port data */
806 rv
= get_serial_info(acm
, (struct serial_struct __user
*) arg
);
813 static const __u32 acm_tty_speed
[] = {
814 0, 50, 75, 110, 134, 150, 200, 300, 600,
815 1200, 1800, 2400, 4800, 9600, 19200, 38400,
816 57600, 115200, 230400, 460800, 500000, 576000,
817 921600, 1000000, 1152000, 1500000, 2000000,
818 2500000, 3000000, 3500000, 4000000
821 static const __u8 acm_tty_size
[] = {
825 static void acm_tty_set_termios(struct tty_struct
*tty
,
826 struct ktermios
*termios_old
)
828 struct acm
*acm
= tty
->driver_data
;
829 struct ktermios
*termios
= tty
->termios
;
830 struct usb_cdc_line_coding newline
;
831 int newctrl
= acm
->ctrlout
;
833 newline
.dwDTERate
= cpu_to_le32(tty_get_baud_rate(tty
));
834 newline
.bCharFormat
= termios
->c_cflag
& CSTOPB
? 2 : 0;
835 newline
.bParityType
= termios
->c_cflag
& PARENB
?
836 (termios
->c_cflag
& PARODD
? 1 : 2) +
837 (termios
->c_cflag
& CMSPAR
? 2 : 0) : 0;
838 newline
.bDataBits
= acm_tty_size
[(termios
->c_cflag
& CSIZE
) >> 4];
839 /* FIXME: Needs to clear unsupported bits in the termios */
840 acm
->clocal
= ((termios
->c_cflag
& CLOCAL
) != 0);
842 if (!newline
.dwDTERate
) {
843 newline
.dwDTERate
= acm
->line
.dwDTERate
;
844 newctrl
&= ~ACM_CTRL_DTR
;
846 newctrl
|= ACM_CTRL_DTR
;
848 if (newctrl
!= acm
->ctrlout
)
849 acm_set_control(acm
, acm
->ctrlout
= newctrl
);
851 if (memcmp(&acm
->line
, &newline
, sizeof newline
)) {
852 memcpy(&acm
->line
, &newline
, sizeof newline
);
853 dev_dbg(&acm
->control
->dev
, "%s - set line: %d %d %d %d\n",
855 le32_to_cpu(newline
.dwDTERate
),
856 newline
.bCharFormat
, newline
.bParityType
,
858 acm_set_line(acm
, &acm
->line
);
862 static const struct tty_port_operations acm_port_ops
= {
863 .shutdown
= acm_port_shutdown
,
864 .activate
= acm_port_activate
,
865 .destruct
= acm_port_destruct
,
869 * USB probe and disconnect routines.
872 /* Little helpers: write/read buffers free */
873 static void acm_write_buffers_free(struct acm
*acm
)
877 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
879 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++)
880 usb_free_coherent(usb_dev
, acm
->writesize
, wb
->buf
, wb
->dmah
);
883 static void acm_read_buffers_free(struct acm
*acm
)
885 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
888 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
889 usb_free_coherent(usb_dev
, acm
->readsize
,
890 acm
->read_buffers
[i
].base
, acm
->read_buffers
[i
].dma
);
893 /* Little helper: write buffers allocate */
894 static int acm_write_buffers_alloc(struct acm
*acm
)
899 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
900 wb
->buf
= usb_alloc_coherent(acm
->dev
, acm
->writesize
, GFP_KERNEL
,
906 usb_free_coherent(acm
->dev
, acm
->writesize
,
915 static int acm_probe(struct usb_interface
*intf
,
916 const struct usb_device_id
*id
)
918 struct usb_cdc_union_desc
*union_header
= NULL
;
919 struct usb_cdc_country_functional_desc
*cfd
= NULL
;
920 unsigned char *buffer
= intf
->altsetting
->extra
;
921 int buflen
= intf
->altsetting
->extralen
;
922 struct usb_interface
*control_interface
;
923 struct usb_interface
*data_interface
;
924 struct usb_endpoint_descriptor
*epctrl
= NULL
;
925 struct usb_endpoint_descriptor
*epread
= NULL
;
926 struct usb_endpoint_descriptor
*epwrite
= NULL
;
927 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
930 int ctrlsize
, readsize
;
932 u8 ac_management_function
= 0;
933 u8 call_management_function
= 0;
934 int call_interface_num
= -1;
935 int data_interface_num
= -1;
936 unsigned long quirks
;
939 int combined_interfaces
= 0;
942 quirks
= (unsigned long)id
->driver_info
;
943 num_rx_buf
= (quirks
== SINGLE_RX_URB
) ? 1 : ACM_NR
;
945 /* handle quirks deadly to normal probing*/
946 if (quirks
== NO_UNION_NORMAL
) {
947 data_interface
= usb_ifnum_to_if(usb_dev
, 1);
948 control_interface
= usb_ifnum_to_if(usb_dev
, 0);
949 goto skip_normal_probe
;
954 dev_err(&intf
->dev
, "Weird descriptor references\n");
959 if (intf
->cur_altsetting
->endpoint
&&
960 intf
->cur_altsetting
->endpoint
->extralen
&&
961 intf
->cur_altsetting
->endpoint
->extra
) {
963 "Seeking extra descriptors on endpoint\n");
964 buflen
= intf
->cur_altsetting
->endpoint
->extralen
;
965 buffer
= intf
->cur_altsetting
->endpoint
->extra
;
968 "Zero length descriptor references\n");
974 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
975 dev_err(&intf
->dev
, "skipping garbage\n");
980 case USB_CDC_UNION_TYPE
: /* we've found it */
982 dev_err(&intf
->dev
, "More than one "
983 "union descriptor, skipping ...\n");
986 union_header
= (struct usb_cdc_union_desc
*)buffer
;
988 case USB_CDC_COUNTRY_TYPE
: /* export through sysfs*/
989 cfd
= (struct usb_cdc_country_functional_desc
*)buffer
;
991 case USB_CDC_HEADER_TYPE
: /* maybe check version */
992 break; /* for now we ignore it */
993 case USB_CDC_ACM_TYPE
:
994 ac_management_function
= buffer
[3];
996 case USB_CDC_CALL_MANAGEMENT_TYPE
:
997 call_management_function
= buffer
[3];
998 call_interface_num
= buffer
[4];
999 if ( (quirks
& NOT_A_MODEM
) == 0 && (call_management_function
& 3) != 3)
1000 dev_err(&intf
->dev
, "This device cannot do calls on its own. It is not a modem.\n");
1003 /* there are LOTS more CDC descriptors that
1004 * could legitimately be found here.
1006 dev_dbg(&intf
->dev
, "Ignoring descriptor: "
1007 "type %02x, length %d\n",
1008 buffer
[2], buffer
[0]);
1012 buflen
-= buffer
[0];
1013 buffer
+= buffer
[0];
1016 if (!union_header
) {
1017 if (call_interface_num
> 0) {
1018 dev_dbg(&intf
->dev
, "No union descriptor, using call management descriptor\n");
1019 /* quirks for Droids MuIn LCD */
1020 if (quirks
& NO_DATA_INTERFACE
)
1021 data_interface
= usb_ifnum_to_if(usb_dev
, 0);
1023 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= call_interface_num
));
1024 control_interface
= intf
;
1026 if (intf
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1027 dev_dbg(&intf
->dev
,"No union descriptor, giving up\n");
1030 dev_warn(&intf
->dev
,"No union descriptor, testing for castrated device\n");
1031 combined_interfaces
= 1;
1032 control_interface
= data_interface
= intf
;
1033 goto look_for_collapsed_interface
;
1037 control_interface
= usb_ifnum_to_if(usb_dev
, union_header
->bMasterInterface0
);
1038 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= union_header
->bSlaveInterface0
));
1039 if (!control_interface
|| !data_interface
) {
1040 dev_dbg(&intf
->dev
, "no interfaces\n");
1045 if (data_interface_num
!= call_interface_num
)
1046 dev_dbg(&intf
->dev
, "Separate call control interface. That is not fully supported.\n");
1048 if (control_interface
== data_interface
) {
1049 /* some broken devices designed for windows work this way */
1050 dev_warn(&intf
->dev
,"Control and data interfaces are not separated!\n");
1051 combined_interfaces
= 1;
1052 /* a popular other OS doesn't use it */
1053 quirks
|= NO_CAP_LINE
;
1054 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1055 dev_err(&intf
->dev
, "This needs exactly 3 endpoints\n");
1058 look_for_collapsed_interface
:
1059 for (i
= 0; i
< 3; i
++) {
1060 struct usb_endpoint_descriptor
*ep
;
1061 ep
= &data_interface
->cur_altsetting
->endpoint
[i
].desc
;
1063 if (usb_endpoint_is_int_in(ep
))
1065 else if (usb_endpoint_is_bulk_out(ep
))
1067 else if (usb_endpoint_is_bulk_in(ep
))
1072 if (!epctrl
|| !epread
|| !epwrite
)
1075 goto made_compressed_probe
;
1080 /*workaround for switched interfaces */
1081 if (data_interface
->cur_altsetting
->desc
.bInterfaceClass
1082 != CDC_DATA_INTERFACE_TYPE
) {
1083 if (control_interface
->cur_altsetting
->desc
.bInterfaceClass
1084 == CDC_DATA_INTERFACE_TYPE
) {
1085 struct usb_interface
*t
;
1087 "Your device has switched interfaces.\n");
1088 t
= control_interface
;
1089 control_interface
= data_interface
;
1096 /* Accept probe requests only for the control interface */
1097 if (!combined_interfaces
&& intf
!= control_interface
)
1100 if (!combined_interfaces
&& usb_interface_claimed(data_interface
)) {
1101 /* valid in this context */
1102 dev_dbg(&intf
->dev
, "The data interface isn't available\n");
1107 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
< 2)
1110 epctrl
= &control_interface
->cur_altsetting
->endpoint
[0].desc
;
1111 epread
= &data_interface
->cur_altsetting
->endpoint
[0].desc
;
1112 epwrite
= &data_interface
->cur_altsetting
->endpoint
[1].desc
;
1115 /* workaround for switched endpoints */
1116 if (!usb_endpoint_dir_in(epread
)) {
1117 /* descriptors are swapped */
1118 struct usb_endpoint_descriptor
*t
;
1120 "The data interface has switched endpoints\n");
1125 made_compressed_probe
:
1126 dev_dbg(&intf
->dev
, "interfaces are valid\n");
1128 acm
= kzalloc(sizeof(struct acm
), GFP_KERNEL
);
1130 dev_err(&intf
->dev
, "out of memory (acm kzalloc)\n");
1134 minor
= acm_alloc_minor(acm
);
1135 if (minor
== ACM_TTY_MINORS
) {
1136 dev_err(&intf
->dev
, "no more free acm devices\n");
1141 ctrlsize
= usb_endpoint_maxp(epctrl
);
1142 readsize
= usb_endpoint_maxp(epread
) *
1143 (quirks
== SINGLE_RX_URB
? 1 : 2);
1144 acm
->combined_interfaces
= combined_interfaces
;
1145 acm
->writesize
= usb_endpoint_maxp(epwrite
) * 20;
1146 acm
->control
= control_interface
;
1147 acm
->data
= data_interface
;
1150 acm
->ctrl_caps
= ac_management_function
;
1151 if (quirks
& NO_CAP_LINE
)
1152 acm
->ctrl_caps
&= ~USB_CDC_CAP_LINE
;
1153 acm
->ctrlsize
= ctrlsize
;
1154 acm
->readsize
= readsize
;
1155 acm
->rx_buflimit
= num_rx_buf
;
1156 INIT_WORK(&acm
->work
, acm_softint
);
1157 spin_lock_init(&acm
->write_lock
);
1158 spin_lock_init(&acm
->read_lock
);
1159 mutex_init(&acm
->mutex
);
1160 acm
->rx_endpoint
= usb_rcvbulkpipe(usb_dev
, epread
->bEndpointAddress
);
1161 acm
->is_int_ep
= usb_endpoint_xfer_int(epread
);
1163 acm
->bInterval
= epread
->bInterval
;
1164 tty_port_init(&acm
->port
);
1165 acm
->port
.ops
= &acm_port_ops
;
1167 buf
= usb_alloc_coherent(usb_dev
, ctrlsize
, GFP_KERNEL
, &acm
->ctrl_dma
);
1169 dev_err(&intf
->dev
, "out of memory (ctrl buffer alloc)\n");
1172 acm
->ctrl_buffer
= buf
;
1174 if (acm_write_buffers_alloc(acm
) < 0) {
1175 dev_err(&intf
->dev
, "out of memory (write buffer alloc)\n");
1179 acm
->ctrlurb
= usb_alloc_urb(0, GFP_KERNEL
);
1180 if (!acm
->ctrlurb
) {
1181 dev_err(&intf
->dev
, "out of memory (ctrlurb kmalloc)\n");
1184 for (i
= 0; i
< num_rx_buf
; i
++) {
1185 struct acm_rb
*rb
= &(acm
->read_buffers
[i
]);
1188 rb
->base
= usb_alloc_coherent(acm
->dev
, readsize
, GFP_KERNEL
,
1191 dev_err(&intf
->dev
, "out of memory "
1192 "(read bufs usb_alloc_coherent)\n");
1198 urb
= usb_alloc_urb(0, GFP_KERNEL
);
1201 "out of memory (read urbs usb_alloc_urb)\n");
1204 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1205 urb
->transfer_dma
= rb
->dma
;
1206 if (acm
->is_int_ep
) {
1207 usb_fill_int_urb(urb
, acm
->dev
,
1211 acm_read_bulk_callback
, rb
,
1214 usb_fill_bulk_urb(urb
, acm
->dev
,
1218 acm_read_bulk_callback
, rb
);
1221 acm
->read_urbs
[i
] = urb
;
1222 __set_bit(i
, &acm
->read_urbs_free
);
1224 for (i
= 0; i
< ACM_NW
; i
++) {
1225 struct acm_wb
*snd
= &(acm
->wb
[i
]);
1227 snd
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1228 if (snd
->urb
== NULL
) {
1230 "out of memory (write urbs usb_alloc_urb)\n");
1234 if (usb_endpoint_xfer_int(epwrite
))
1235 usb_fill_int_urb(snd
->urb
, usb_dev
,
1236 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1237 NULL
, acm
->writesize
, acm_write_bulk
, snd
, epwrite
->bInterval
);
1239 usb_fill_bulk_urb(snd
->urb
, usb_dev
,
1240 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1241 NULL
, acm
->writesize
, acm_write_bulk
, snd
);
1242 snd
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1243 snd
->instance
= acm
;
1246 usb_set_intfdata(intf
, acm
);
1248 i
= device_create_file(&intf
->dev
, &dev_attr_bmCapabilities
);
1252 if (cfd
) { /* export the country data */
1253 acm
->country_codes
= kmalloc(cfd
->bLength
- 4, GFP_KERNEL
);
1254 if (!acm
->country_codes
)
1255 goto skip_countries
;
1256 acm
->country_code_size
= cfd
->bLength
- 4;
1257 memcpy(acm
->country_codes
, (u8
*)&cfd
->wCountyCode0
,
1259 acm
->country_rel_date
= cfd
->iCountryCodeRelDate
;
1261 i
= device_create_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1263 kfree(acm
->country_codes
);
1264 acm
->country_codes
= NULL
;
1265 acm
->country_code_size
= 0;
1266 goto skip_countries
;
1269 i
= device_create_file(&intf
->dev
,
1270 &dev_attr_iCountryCodeRelDate
);
1272 device_remove_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1273 kfree(acm
->country_codes
);
1274 acm
->country_codes
= NULL
;
1275 acm
->country_code_size
= 0;
1276 goto skip_countries
;
1281 usb_fill_int_urb(acm
->ctrlurb
, usb_dev
,
1282 usb_rcvintpipe(usb_dev
, epctrl
->bEndpointAddress
),
1283 acm
->ctrl_buffer
, ctrlsize
, acm_ctrl_irq
, acm
,
1284 /* works around buggy devices */
1285 epctrl
->bInterval
? epctrl
->bInterval
: 0xff);
1286 acm
->ctrlurb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1287 acm
->ctrlurb
->transfer_dma
= acm
->ctrl_dma
;
1289 dev_info(&intf
->dev
, "ttyACM%d: USB ACM device\n", minor
);
1291 acm_set_control(acm
, acm
->ctrlout
);
1293 acm
->line
.dwDTERate
= cpu_to_le32(9600);
1294 acm
->line
.bDataBits
= 8;
1295 acm_set_line(acm
, &acm
->line
);
1297 usb_driver_claim_interface(&acm_driver
, data_interface
, acm
);
1298 usb_set_intfdata(data_interface
, acm
);
1300 usb_get_intf(control_interface
);
1301 tty_register_device(acm_tty_driver
, minor
, &control_interface
->dev
);
1305 for (i
= 0; i
< ACM_NW
; i
++)
1306 usb_free_urb(acm
->wb
[i
].urb
);
1308 for (i
= 0; i
< num_rx_buf
; i
++)
1309 usb_free_urb(acm
->read_urbs
[i
]);
1310 acm_read_buffers_free(acm
);
1311 usb_free_urb(acm
->ctrlurb
);
1313 acm_write_buffers_free(acm
);
1315 usb_free_coherent(usb_dev
, ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1317 acm_release_minor(acm
);
1323 static void stop_data_traffic(struct acm
*acm
)
1327 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
1329 usb_kill_urb(acm
->ctrlurb
);
1330 for (i
= 0; i
< ACM_NW
; i
++)
1331 usb_kill_urb(acm
->wb
[i
].urb
);
1332 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1333 usb_kill_urb(acm
->read_urbs
[i
]);
1335 cancel_work_sync(&acm
->work
);
1338 static void acm_disconnect(struct usb_interface
*intf
)
1340 struct acm
*acm
= usb_get_intfdata(intf
);
1341 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1342 struct tty_struct
*tty
;
1345 dev_dbg(&intf
->dev
, "%s\n", __func__
);
1347 /* sibling interface is already cleaning up */
1351 mutex_lock(&acm
->mutex
);
1352 acm
->disconnected
= true;
1353 if (acm
->country_codes
) {
1354 device_remove_file(&acm
->control
->dev
,
1355 &dev_attr_wCountryCodes
);
1356 device_remove_file(&acm
->control
->dev
,
1357 &dev_attr_iCountryCodeRelDate
);
1359 device_remove_file(&acm
->control
->dev
, &dev_attr_bmCapabilities
);
1360 usb_set_intfdata(acm
->control
, NULL
);
1361 usb_set_intfdata(acm
->data
, NULL
);
1362 mutex_unlock(&acm
->mutex
);
1364 tty
= tty_port_tty_get(&acm
->port
);
1370 stop_data_traffic(acm
);
1372 usb_free_urb(acm
->ctrlurb
);
1373 for (i
= 0; i
< ACM_NW
; i
++)
1374 usb_free_urb(acm
->wb
[i
].urb
);
1375 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1376 usb_free_urb(acm
->read_urbs
[i
]);
1377 acm_write_buffers_free(acm
);
1378 usb_free_coherent(usb_dev
, acm
->ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1379 acm_read_buffers_free(acm
);
1381 if (!acm
->combined_interfaces
)
1382 usb_driver_release_interface(&acm_driver
, intf
== acm
->control
?
1383 acm
->data
: acm
->control
);
1385 tty_port_put(&acm
->port
);
1389 static int acm_suspend(struct usb_interface
*intf
, pm_message_t message
)
1391 struct acm
*acm
= usb_get_intfdata(intf
);
1394 if (PMSG_IS_AUTO(message
)) {
1397 spin_lock_irq(&acm
->write_lock
);
1398 b
= acm
->transmitting
;
1399 spin_unlock_irq(&acm
->write_lock
);
1404 spin_lock_irq(&acm
->read_lock
);
1405 spin_lock(&acm
->write_lock
);
1406 cnt
= acm
->susp_count
++;
1407 spin_unlock(&acm
->write_lock
);
1408 spin_unlock_irq(&acm
->read_lock
);
1413 if (test_bit(ASYNCB_INITIALIZED
, &acm
->port
.flags
))
1414 stop_data_traffic(acm
);
1419 static int acm_resume(struct usb_interface
*intf
)
1421 struct acm
*acm
= usb_get_intfdata(intf
);
1426 spin_lock_irq(&acm
->read_lock
);
1427 acm
->susp_count
-= 1;
1428 cnt
= acm
->susp_count
;
1429 spin_unlock_irq(&acm
->read_lock
);
1434 if (test_bit(ASYNCB_INITIALIZED
, &acm
->port
.flags
)) {
1435 rv
= usb_submit_urb(acm
->ctrlurb
, GFP_NOIO
);
1437 spin_lock_irq(&acm
->write_lock
);
1438 if (acm
->delayed_wb
) {
1439 wb
= acm
->delayed_wb
;
1440 acm
->delayed_wb
= NULL
;
1441 spin_unlock_irq(&acm
->write_lock
);
1442 acm_start_wb(acm
, wb
);
1444 spin_unlock_irq(&acm
->write_lock
);
1448 * delayed error checking because we must
1449 * do the write path at all cost
1454 rv
= acm_submit_read_urbs(acm
, GFP_NOIO
);
1461 static int acm_reset_resume(struct usb_interface
*intf
)
1463 struct acm
*acm
= usb_get_intfdata(intf
);
1464 struct tty_struct
*tty
;
1466 if (test_bit(ASYNCB_INITIALIZED
, &acm
->port
.flags
)) {
1467 tty
= tty_port_tty_get(&acm
->port
);
1474 return acm_resume(intf
);
1477 #endif /* CONFIG_PM */
1479 #define NOKIA_PCSUITE_ACM_INFO(x) \
1480 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1481 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1482 USB_CDC_ACM_PROTO_VENDOR)
1484 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1485 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1486 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1487 USB_CDC_ACM_PROTO_VENDOR)
1490 * USB driver structure.
1493 static const struct usb_device_id acm_ids
[] = {
1494 /* quirky and broken devices */
1495 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1496 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1498 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1499 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1501 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1502 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1504 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1505 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1507 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1508 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1510 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1511 .driver_info
= SINGLE_RX_URB
,
1513 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1514 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1516 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1517 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1519 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1520 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1522 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1523 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1525 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1526 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1528 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1529 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1531 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1532 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1534 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1536 /* Motorola H24 HSPA module: */
1537 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1538 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1539 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1540 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1541 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1542 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1543 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1544 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1546 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1547 .driver_info
= NO_UNION_NORMAL
, /* union descriptor misplaced on
1548 data interface instead of
1549 communications interface.
1550 Maybe we should define a new
1553 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1554 .driver_info
= NO_UNION_NORMAL
, /* reports zero length descriptor */
1556 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1557 .driver_info
= NO_UNION_NORMAL
, /* reports zero length descriptor */
1560 /* Nokia S60 phones expose two ACM channels. The first is
1561 * a modem and is picked up by the standard AT-command
1562 * information below. The second is 'vendor-specific' but
1563 * is treated as a serial device at the S60 end, so we want
1564 * to expose it on Linux too. */
1565 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1567 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1577 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1580 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1582 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1583 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1585 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1586 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1587 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1588 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1589 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1594 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1595 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1596 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1597 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1598 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1601 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1602 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1606 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1607 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1609 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1611 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1612 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1613 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1615 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1616 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1617 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1619 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1620 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1621 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1622 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1624 /* Support for Owen devices */
1625 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1627 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1629 /* Support Lego NXT using pbLua firmware */
1630 { USB_DEVICE(0x0694, 0xff00),
1631 .driver_info
= NOT_A_MODEM
,
1634 /* Support for Droids MuIn LCD */
1635 { USB_DEVICE(0x04d8, 0x000b),
1636 .driver_info
= NO_DATA_INTERFACE
,
1639 /* control interfaces without any protocol set */
1640 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1641 USB_CDC_PROTO_NONE
) },
1643 /* control interfaces with various AT-command sets */
1644 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1645 USB_CDC_ACM_PROTO_AT_V25TER
) },
1646 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1647 USB_CDC_ACM_PROTO_AT_PCCA101
) },
1648 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1649 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE
) },
1650 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1651 USB_CDC_ACM_PROTO_AT_GSM
) },
1652 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1653 USB_CDC_ACM_PROTO_AT_3G
) },
1654 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1655 USB_CDC_ACM_PROTO_AT_CDMA
) },
1660 MODULE_DEVICE_TABLE(usb
, acm_ids
);
1662 static struct usb_driver acm_driver
= {
1665 .disconnect
= acm_disconnect
,
1667 .suspend
= acm_suspend
,
1668 .resume
= acm_resume
,
1669 .reset_resume
= acm_reset_resume
,
1671 .id_table
= acm_ids
,
1673 .supports_autosuspend
= 1,
1675 .disable_hub_initiated_lpm
= 1,
1679 * TTY driver structures.
1682 static const struct tty_operations acm_ops
= {
1683 .install
= acm_tty_install
,
1684 .open
= acm_tty_open
,
1685 .close
= acm_tty_close
,
1686 .cleanup
= acm_tty_cleanup
,
1687 .hangup
= acm_tty_hangup
,
1688 .write
= acm_tty_write
,
1689 .write_room
= acm_tty_write_room
,
1690 .ioctl
= acm_tty_ioctl
,
1691 .throttle
= acm_tty_throttle
,
1692 .unthrottle
= acm_tty_unthrottle
,
1693 .chars_in_buffer
= acm_tty_chars_in_buffer
,
1694 .break_ctl
= acm_tty_break_ctl
,
1695 .set_termios
= acm_tty_set_termios
,
1696 .tiocmget
= acm_tty_tiocmget
,
1697 .tiocmset
= acm_tty_tiocmset
,
1704 static int __init
acm_init(void)
1707 acm_tty_driver
= alloc_tty_driver(ACM_TTY_MINORS
);
1708 if (!acm_tty_driver
)
1710 acm_tty_driver
->driver_name
= "acm",
1711 acm_tty_driver
->name
= "ttyACM",
1712 acm_tty_driver
->major
= ACM_TTY_MAJOR
,
1713 acm_tty_driver
->minor_start
= 0,
1714 acm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
,
1715 acm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
,
1716 acm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1717 acm_tty_driver
->init_termios
= tty_std_termios
;
1718 acm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
|
1720 tty_set_operations(acm_tty_driver
, &acm_ops
);
1722 retval
= tty_register_driver(acm_tty_driver
);
1724 put_tty_driver(acm_tty_driver
);
1728 retval
= usb_register(&acm_driver
);
1730 tty_unregister_driver(acm_tty_driver
);
1731 put_tty_driver(acm_tty_driver
);
1735 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_DESC
"\n");
1740 static void __exit
acm_exit(void)
1742 usb_deregister(&acm_driver
);
1743 tty_unregister_driver(acm_tty_driver
);
1744 put_tty_driver(acm_tty_driver
);
1747 module_init(acm_init
);
1748 module_exit(acm_exit
);
1750 MODULE_AUTHOR(DRIVER_AUTHOR
);
1751 MODULE_DESCRIPTION(DRIVER_DESC
);
1752 MODULE_LICENSE("GPL");
1753 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR
);