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
16 * v0.9 - thorough cleaning, URBification, almost a rewrite
17 * v0.10 - some more cleanups
18 * v0.11 - fixed flow control, read error doesn't stop reads
19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm
21 * v0.13 - added termios, added hangup
22 * v0.14 - sized down struct acm
23 * v0.15 - fixed flow control again - characters could be lost
24 * v0.16 - added code for modems with swapped data and control interfaces
25 * v0.17 - added new style probing
26 * v0.18 - fixed new style probing for devices with more configurations
27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28 * v0.20 - switched to probing on interface (rather than device) class
29 * v0.21 - revert to probing on device for devices with multiple configs
30 * v0.22 - probe only the control interface. if usbcore doesn't choose the
31 * config we want, sysadmin changes bConfigurationValue in sysfs.
32 * v0.23 - use softirq for rx processing, as needed by tty layer
33 * v0.24 - change probe method to evaluate CDC union descriptor
34 * v0.25 - downstream tasks paralelized to maximize throughput
35 * v0.26 - multiple write urbs, writesize increased
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 * GNU General Public License for more details.
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/tty.h>
62 #include <linux/serial.h>
63 #include <linux/tty_driver.h>
64 #include <linux/tty_flip.h>
65 #include <linux/module.h>
66 #include <linux/mutex.h>
67 #include <linux/uaccess.h>
68 #include <linux/usb.h>
69 #include <linux/usb/cdc.h>
70 #include <asm/byteorder.h>
71 #include <asm/unaligned.h>
72 #include <linux/list.h>
77 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
82 #define DRIVER_VERSION "v0.26"
83 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
84 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
86 static struct usb_driver acm_driver
;
87 static struct tty_driver
*acm_tty_driver
;
88 static struct acm
*acm_table
[ACM_TTY_MINORS
];
90 static DEFINE_MUTEX(open_mutex
);
92 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
94 static const struct tty_port_operations acm_port_ops
= {
104 * Functions for ACM control messages.
107 static int acm_ctrl_msg(struct acm
*acm
, int request
, int value
,
110 int retval
= usb_control_msg(acm
->dev
, usb_sndctrlpipe(acm
->dev
, 0),
111 request
, USB_RT_ACM
, value
,
112 acm
->control
->altsetting
[0].desc
.bInterfaceNumber
,
114 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
115 request
, value
, len
, retval
);
116 return retval
< 0 ? retval
: 0;
119 /* devices aren't required to support these requests.
120 * the cdc acm descriptor tells whether they do...
122 #define acm_set_control(acm, control) \
123 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124 #define acm_set_line(acm, line) \
125 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126 #define acm_send_break(acm, ms) \
127 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
130 * Write buffer management.
131 * All of these assume proper locks taken by the caller.
134 static int acm_wb_alloc(struct acm
*acm
)
147 wbn
= (wbn
+ 1) % ACM_NW
;
153 static int acm_wb_is_avail(struct acm
*acm
)
159 spin_lock_irqsave(&acm
->write_lock
, flags
);
160 for (i
= 0; i
< ACM_NW
; i
++)
162 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
167 * Finish write. Caller must hold acm->write_lock
169 static void acm_write_done(struct acm
*acm
, struct acm_wb
*wb
)
173 usb_autopm_put_interface_async(acm
->control
);
179 * the caller is responsible for locking
182 static int acm_start_wb(struct acm
*acm
, struct acm_wb
*wb
)
188 wb
->urb
->transfer_buffer
= wb
->buf
;
189 wb
->urb
->transfer_dma
= wb
->dmah
;
190 wb
->urb
->transfer_buffer_length
= wb
->len
;
191 wb
->urb
->dev
= acm
->dev
;
193 rc
= usb_submit_urb(wb
->urb
, GFP_ATOMIC
);
195 dbg("usb_submit_urb(write bulk) failed: %d", rc
);
196 acm_write_done(acm
, wb
);
201 static int acm_write_start(struct acm
*acm
, int wbn
)
204 struct acm_wb
*wb
= &acm
->wb
[wbn
];
207 spin_lock_irqsave(&acm
->write_lock
, flags
);
210 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
214 dbg("%s susp_count: %d", __func__
, acm
->susp_count
);
215 usb_autopm_get_interface_async(acm
->control
);
216 if (acm
->susp_count
) {
217 if (!acm
->delayed_wb
)
218 acm
->delayed_wb
= wb
;
220 usb_autopm_put_interface_async(acm
->control
);
221 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
222 return 0; /* A white lie */
224 usb_mark_last_busy(acm
->dev
);
226 rc
= acm_start_wb(acm
, wb
);
227 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
233 * attributes exported through sysfs
235 static ssize_t show_caps
236 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
238 struct usb_interface
*intf
= to_usb_interface(dev
);
239 struct acm
*acm
= usb_get_intfdata(intf
);
241 return sprintf(buf
, "%d", acm
->ctrl_caps
);
243 static DEVICE_ATTR(bmCapabilities
, S_IRUGO
, show_caps
, NULL
);
245 static ssize_t show_country_codes
246 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
248 struct usb_interface
*intf
= to_usb_interface(dev
);
249 struct acm
*acm
= usb_get_intfdata(intf
);
251 memcpy(buf
, acm
->country_codes
, acm
->country_code_size
);
252 return acm
->country_code_size
;
255 static DEVICE_ATTR(wCountryCodes
, S_IRUGO
, show_country_codes
, NULL
);
257 static ssize_t show_country_rel_date
258 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
260 struct usb_interface
*intf
= to_usb_interface(dev
);
261 struct acm
*acm
= usb_get_intfdata(intf
);
263 return sprintf(buf
, "%d", acm
->country_rel_date
);
266 static DEVICE_ATTR(iCountryCodeRelDate
, S_IRUGO
, show_country_rel_date
, NULL
);
268 * Interrupt handlers for various ACM device responses
271 /* control interface reports status changes with "interrupt" transfers */
272 static void acm_ctrl_irq(struct urb
*urb
)
274 struct acm
*acm
= urb
->context
;
275 struct usb_cdc_notification
*dr
= urb
->transfer_buffer
;
276 struct tty_struct
*tty
;
280 int status
= urb
->status
;
289 /* this urb is terminated, clean up */
290 dbg("%s - urb shutting down with status: %d", __func__
, status
);
293 dbg("%s - nonzero urb status received: %d", __func__
, status
);
300 usb_mark_last_busy(acm
->dev
);
302 data
= (unsigned char *)(dr
+ 1);
303 switch (dr
->bNotificationType
) {
304 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
305 dbg("%s network", dr
->wValue
?
306 "connected to" : "disconnected from");
309 case USB_CDC_NOTIFY_SERIAL_STATE
:
310 tty
= tty_port_tty_get(&acm
->port
);
311 newctrl
= get_unaligned_le16(data
);
315 (acm
->ctrlin
& ~newctrl
& ACM_CTRL_DCD
)) {
316 dbg("calling hangup");
322 acm
->ctrlin
= newctrl
;
324 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
325 acm
->ctrlin
& ACM_CTRL_DCD
? '+' : '-',
326 acm
->ctrlin
& ACM_CTRL_DSR
? '+' : '-',
327 acm
->ctrlin
& ACM_CTRL_BRK
? '+' : '-',
328 acm
->ctrlin
& ACM_CTRL_RI
? '+' : '-',
329 acm
->ctrlin
& ACM_CTRL_FRAMING
? '+' : '-',
330 acm
->ctrlin
& ACM_CTRL_PARITY
? '+' : '-',
331 acm
->ctrlin
& ACM_CTRL_OVERRUN
? '+' : '-');
335 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
336 dr
->bNotificationType
, dr
->wIndex
,
337 dr
->wLength
, data
[0], data
[1]);
341 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
343 dev_err(&urb
->dev
->dev
, "%s - usb_submit_urb failed with "
344 "result %d", __func__
, retval
);
347 /* data interface returns incoming bytes, or we got unthrottled */
348 static void acm_read_bulk(struct urb
*urb
)
351 struct acm_ru
*rcv
= urb
->context
;
352 struct acm
*acm
= rcv
->instance
;
353 int status
= urb
->status
;
355 dbg("Entering acm_read_bulk with status %d", status
);
357 if (!ACM_READY(acm
)) {
358 dev_dbg(&acm
->data
->dev
, "Aborting, acm not ready");
361 usb_mark_last_busy(acm
->dev
);
364 dev_dbg(&acm
->data
->dev
, "bulk rx status %d\n", status
);
367 buf
->size
= urb
->actual_length
;
369 if (likely(status
== 0)) {
370 spin_lock(&acm
->read_lock
);
372 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
373 list_add_tail(&buf
->list
, &acm
->filled_read_bufs
);
374 spin_unlock(&acm
->read_lock
);
376 /* we drop the buffer due to an error */
377 spin_lock(&acm
->read_lock
);
378 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
379 list_add(&buf
->list
, &acm
->spare_read_bufs
);
380 spin_unlock(&acm
->read_lock
);
381 /* nevertheless the tasklet must be kicked unconditionally
382 so the queue cannot dry up */
384 if (likely(!acm
->susp_count
))
385 tasklet_schedule(&acm
->urb_task
);
388 static void acm_rx_tasklet(unsigned long _acm
)
390 struct acm
*acm
= (void *)_acm
;
392 struct tty_struct
*tty
;
395 unsigned char throttled
;
397 dbg("Entering acm_rx_tasklet");
399 if (!ACM_READY(acm
)) {
400 dbg("acm_rx_tasklet: ACM not ready");
404 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
405 throttled
= acm
->throttle
;
406 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
408 dbg("acm_rx_tasklet: throttled");
412 tty
= tty_port_tty_get(&acm
->port
);
415 spin_lock_irqsave(&acm
->read_lock
, flags
);
416 if (list_empty(&acm
->filled_read_bufs
)) {
417 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
420 buf
= list_entry(acm
->filled_read_bufs
.next
,
421 struct acm_rb
, list
);
422 list_del(&buf
->list
);
423 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
425 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf
, buf
->size
);
428 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
429 throttled
= acm
->throttle
;
430 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
432 tty_insert_flip_string(tty
, buf
->base
, buf
->size
);
433 tty_flip_buffer_push(tty
);
436 dbg("Throttling noticed");
437 spin_lock_irqsave(&acm
->read_lock
, flags
);
438 list_add(&buf
->list
, &acm
->filled_read_bufs
);
439 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
444 spin_lock_irqsave(&acm
->read_lock
, flags
);
445 list_add(&buf
->list
, &acm
->spare_read_bufs
);
446 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
452 while (!list_empty(&acm
->spare_read_bufs
)) {
453 spin_lock_irqsave(&acm
->read_lock
, flags
);
454 if (list_empty(&acm
->spare_read_urbs
)) {
456 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
459 rcv
= list_entry(acm
->spare_read_urbs
.next
,
460 struct acm_ru
, list
);
461 list_del(&rcv
->list
);
462 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
464 buf
= list_entry(acm
->spare_read_bufs
.next
,
465 struct acm_rb
, list
);
466 list_del(&buf
->list
);
471 usb_fill_int_urb(rcv
->urb
, acm
->dev
,
475 acm_read_bulk
, rcv
, acm
->bInterval
);
477 usb_fill_bulk_urb(rcv
->urb
, acm
->dev
,
482 rcv
->urb
->transfer_dma
= buf
->dma
;
483 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
485 /* This shouldn't kill the driver as unsuccessful URBs are
486 returned to the free-urbs-pool and resubmited ASAP */
487 spin_lock_irqsave(&acm
->read_lock
, flags
);
488 if (acm
->susp_count
||
489 usb_submit_urb(rcv
->urb
, GFP_ATOMIC
) < 0) {
490 list_add(&buf
->list
, &acm
->spare_read_bufs
);
491 list_add(&rcv
->list
, &acm
->spare_read_urbs
);
493 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
496 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
497 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv
->urb
, rcv
, buf
);
500 spin_lock_irqsave(&acm
->read_lock
, flags
);
502 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
505 /* data interface wrote those outgoing bytes */
506 static void acm_write_bulk(struct urb
*urb
)
508 struct acm_wb
*wb
= urb
->context
;
509 struct acm
*acm
= wb
->instance
;
512 if (verbose
|| urb
->status
513 || (urb
->actual_length
!= urb
->transfer_buffer_length
))
514 dev_dbg(&acm
->data
->dev
, "tx %d/%d bytes -- > %d\n",
516 urb
->transfer_buffer_length
,
519 spin_lock_irqsave(&acm
->write_lock
, flags
);
520 acm_write_done(acm
, wb
);
521 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
523 schedule_work(&acm
->work
);
525 wake_up_interruptible(&acm
->drain_wait
);
528 static void acm_softint(struct work_struct
*work
)
530 struct acm
*acm
= container_of(work
, struct acm
, work
);
531 struct tty_struct
*tty
;
533 dev_vdbg(&acm
->data
->dev
, "tx work\n");
536 tty
= tty_port_tty_get(&acm
->port
);
547 static int acm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
552 dbg("Entering acm_tty_open.");
554 mutex_lock(&open_mutex
);
556 acm
= acm_table
[tty
->index
];
557 if (!acm
|| !acm
->dev
)
562 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
564 tty
->driver_data
= acm
;
565 tty_port_tty_set(&acm
->port
, tty
);
567 if (usb_autopm_get_interface(acm
->control
) < 0)
570 acm
->control
->needs_remote_wakeup
= 1;
572 mutex_lock(&acm
->mutex
);
573 if (acm
->port
.count
++) {
574 mutex_unlock(&acm
->mutex
);
575 usb_autopm_put_interface(acm
->control
);
579 acm
->ctrlurb
->dev
= acm
->dev
;
580 if (usb_submit_urb(acm
->ctrlurb
, GFP_KERNEL
)) {
581 dbg("usb_submit_urb(ctrl irq) failed");
585 if (0 > acm_set_control(acm
, acm
->ctrlout
= ACM_CTRL_DTR
| ACM_CTRL_RTS
) &&
586 (acm
->ctrl_caps
& USB_CDC_CAP_LINE
))
589 usb_autopm_put_interface(acm
->control
);
591 INIT_LIST_HEAD(&acm
->spare_read_urbs
);
592 INIT_LIST_HEAD(&acm
->spare_read_bufs
);
593 INIT_LIST_HEAD(&acm
->filled_read_bufs
);
595 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
596 list_add(&(acm
->ru
[i
].list
), &acm
->spare_read_urbs
);
597 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
598 list_add(&(acm
->rb
[i
].list
), &acm
->spare_read_bufs
);
602 set_bit(ASYNCB_INITIALIZED
, &acm
->port
.flags
);
603 rv
= tty_port_block_til_ready(&acm
->port
, tty
, filp
);
604 tasklet_schedule(&acm
->urb_task
);
606 mutex_unlock(&acm
->mutex
);
608 mutex_unlock(&open_mutex
);
612 usb_kill_urb(acm
->ctrlurb
);
615 mutex_unlock(&acm
->mutex
);
616 usb_autopm_put_interface(acm
->control
);
618 mutex_unlock(&open_mutex
);
619 tty_port_tty_set(&acm
->port
, NULL
);
623 static void acm_tty_unregister(struct acm
*acm
)
627 nr
= acm
->rx_buflimit
;
628 tty_unregister_device(acm_tty_driver
, acm
->minor
);
629 usb_put_intf(acm
->control
);
630 acm_table
[acm
->minor
] = NULL
;
631 usb_free_urb(acm
->ctrlurb
);
632 for (i
= 0; i
< ACM_NW
; i
++)
633 usb_free_urb(acm
->wb
[i
].urb
);
634 for (i
= 0; i
< nr
; i
++)
635 usb_free_urb(acm
->ru
[i
].urb
);
636 kfree(acm
->country_codes
);
640 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
);
642 static void acm_port_down(struct acm
*acm
)
644 int i
, nr
= acm
->rx_buflimit
;
645 mutex_lock(&open_mutex
);
647 usb_autopm_get_interface(acm
->control
);
648 acm_set_control(acm
, acm
->ctrlout
= 0);
649 usb_kill_urb(acm
->ctrlurb
);
650 for (i
= 0; i
< ACM_NW
; i
++)
651 usb_kill_urb(acm
->wb
[i
].urb
);
652 tasklet_disable(&acm
->urb_task
);
653 for (i
= 0; i
< nr
; i
++)
654 usb_kill_urb(acm
->ru
[i
].urb
);
655 tasklet_enable(&acm
->urb_task
);
656 acm
->control
->needs_remote_wakeup
= 0;
657 usb_autopm_put_interface(acm
->control
);
659 mutex_unlock(&open_mutex
);
662 static void acm_tty_hangup(struct tty_struct
*tty
)
664 struct acm
*acm
= tty
->driver_data
;
665 tty_port_hangup(&acm
->port
);
669 static void acm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
671 struct acm
*acm
= tty
->driver_data
;
673 /* Perform the closing process and see if we need to do the hardware
677 if (tty_port_close_start(&acm
->port
, tty
, filp
) == 0) {
678 mutex_lock(&open_mutex
);
680 tty_port_tty_set(&acm
->port
, NULL
);
681 acm_tty_unregister(acm
);
682 tty
->driver_data
= NULL
;
684 mutex_unlock(&open_mutex
);
688 tty_port_close_end(&acm
->port
, tty
);
689 tty_port_tty_set(&acm
->port
, NULL
);
692 static int acm_tty_write(struct tty_struct
*tty
,
693 const unsigned char *buf
, int count
)
695 struct acm
*acm
= tty
->driver_data
;
701 dbg("Entering acm_tty_write to write %d bytes,", count
);
708 spin_lock_irqsave(&acm
->write_lock
, flags
);
709 wbn
= acm_wb_alloc(acm
);
711 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
716 count
= (count
> acm
->writesize
) ? acm
->writesize
: count
;
717 dbg("Get %d bytes...", count
);
718 memcpy(wb
->buf
, buf
, count
);
720 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
722 stat
= acm_write_start(acm
, wbn
);
728 static int acm_tty_write_room(struct tty_struct
*tty
)
730 struct acm
*acm
= tty
->driver_data
;
734 * Do not let the line discipline to know that we have a reserve,
735 * or it might get too enthusiastic.
737 return acm_wb_is_avail(acm
) ? acm
->writesize
: 0;
740 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
)
742 struct acm
*acm
= tty
->driver_data
;
746 * This is inaccurate (overcounts), but it works.
748 return (ACM_NW
- acm_wb_is_avail(acm
)) * acm
->writesize
;
751 static void acm_tty_throttle(struct tty_struct
*tty
)
753 struct acm
*acm
= tty
->driver_data
;
756 spin_lock_bh(&acm
->throttle_lock
);
758 spin_unlock_bh(&acm
->throttle_lock
);
761 static void acm_tty_unthrottle(struct tty_struct
*tty
)
763 struct acm
*acm
= tty
->driver_data
;
766 spin_lock_bh(&acm
->throttle_lock
);
768 spin_unlock_bh(&acm
->throttle_lock
);
769 tasklet_schedule(&acm
->urb_task
);
772 static int acm_tty_break_ctl(struct tty_struct
*tty
, int state
)
774 struct acm
*acm
= tty
->driver_data
;
778 retval
= acm_send_break(acm
, state
? 0xffff : 0);
780 dbg("send break failed");
784 static int acm_tty_tiocmget(struct tty_struct
*tty
, struct file
*file
)
786 struct acm
*acm
= tty
->driver_data
;
791 return (acm
->ctrlout
& ACM_CTRL_DTR
? TIOCM_DTR
: 0) |
792 (acm
->ctrlout
& ACM_CTRL_RTS
? TIOCM_RTS
: 0) |
793 (acm
->ctrlin
& ACM_CTRL_DSR
? TIOCM_DSR
: 0) |
794 (acm
->ctrlin
& ACM_CTRL_RI
? TIOCM_RI
: 0) |
795 (acm
->ctrlin
& ACM_CTRL_DCD
? TIOCM_CD
: 0) |
799 static int acm_tty_tiocmset(struct tty_struct
*tty
, struct file
*file
,
800 unsigned int set
, unsigned int clear
)
802 struct acm
*acm
= tty
->driver_data
;
803 unsigned int newctrl
;
808 newctrl
= acm
->ctrlout
;
809 set
= (set
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
810 (set
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
811 clear
= (clear
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
812 (clear
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
814 newctrl
= (newctrl
& ~clear
) | set
;
816 if (acm
->ctrlout
== newctrl
)
818 return acm_set_control(acm
, acm
->ctrlout
= newctrl
);
821 static int acm_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
822 unsigned int cmd
, unsigned long arg
)
824 struct acm
*acm
= tty
->driver_data
;
832 static const __u32 acm_tty_speed
[] = {
833 0, 50, 75, 110, 134, 150, 200, 300, 600,
834 1200, 1800, 2400, 4800, 9600, 19200, 38400,
835 57600, 115200, 230400, 460800, 500000, 576000,
836 921600, 1000000, 1152000, 1500000, 2000000,
837 2500000, 3000000, 3500000, 4000000
840 static const __u8 acm_tty_size
[] = {
844 static void acm_tty_set_termios(struct tty_struct
*tty
,
845 struct ktermios
*termios_old
)
847 struct acm
*acm
= tty
->driver_data
;
848 struct ktermios
*termios
= tty
->termios
;
849 struct usb_cdc_line_coding newline
;
850 int newctrl
= acm
->ctrlout
;
855 newline
.dwDTERate
= cpu_to_le32(tty_get_baud_rate(tty
));
856 newline
.bCharFormat
= termios
->c_cflag
& CSTOPB
? 2 : 0;
857 newline
.bParityType
= termios
->c_cflag
& PARENB
?
858 (termios
->c_cflag
& PARODD
? 1 : 2) +
859 (termios
->c_cflag
& CMSPAR
? 2 : 0) : 0;
860 newline
.bDataBits
= acm_tty_size
[(termios
->c_cflag
& CSIZE
) >> 4];
861 /* FIXME: Needs to clear unsupported bits in the termios */
862 acm
->clocal
= ((termios
->c_cflag
& CLOCAL
) != 0);
864 if (!newline
.dwDTERate
) {
865 newline
.dwDTERate
= acm
->line
.dwDTERate
;
866 newctrl
&= ~ACM_CTRL_DTR
;
868 newctrl
|= ACM_CTRL_DTR
;
870 if (newctrl
!= acm
->ctrlout
)
871 acm_set_control(acm
, acm
->ctrlout
= newctrl
);
873 if (memcmp(&acm
->line
, &newline
, sizeof newline
)) {
874 memcpy(&acm
->line
, &newline
, sizeof newline
);
875 dbg("set line: %d %d %d %d", le32_to_cpu(newline
.dwDTERate
),
876 newline
.bCharFormat
, newline
.bParityType
,
878 acm_set_line(acm
, &acm
->line
);
883 * USB probe and disconnect routines.
886 /* Little helpers: write/read buffers free */
887 static void acm_write_buffers_free(struct acm
*acm
)
891 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
893 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++)
894 usb_free_coherent(usb_dev
, acm
->writesize
, wb
->buf
, wb
->dmah
);
897 static void acm_read_buffers_free(struct acm
*acm
)
899 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
900 int i
, n
= acm
->rx_buflimit
;
902 for (i
= 0; i
< n
; i
++)
903 usb_free_coherent(usb_dev
, acm
->readsize
,
904 acm
->rb
[i
].base
, acm
->rb
[i
].dma
);
907 /* Little helper: write buffers allocate */
908 static int acm_write_buffers_alloc(struct acm
*acm
)
913 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
914 wb
->buf
= usb_alloc_coherent(acm
->dev
, acm
->writesize
, GFP_KERNEL
,
920 usb_free_coherent(acm
->dev
, acm
->writesize
,
929 static int acm_probe(struct usb_interface
*intf
,
930 const struct usb_device_id
*id
)
932 struct usb_cdc_union_desc
*union_header
= NULL
;
933 struct usb_cdc_country_functional_desc
*cfd
= NULL
;
934 unsigned char *buffer
= intf
->altsetting
->extra
;
935 int buflen
= intf
->altsetting
->extralen
;
936 struct usb_interface
*control_interface
;
937 struct usb_interface
*data_interface
;
938 struct usb_endpoint_descriptor
*epctrl
= NULL
;
939 struct usb_endpoint_descriptor
*epread
= NULL
;
940 struct usb_endpoint_descriptor
*epwrite
= NULL
;
941 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
944 int ctrlsize
, readsize
;
946 u8 ac_management_function
= 0;
947 u8 call_management_function
= 0;
948 int call_interface_num
= -1;
949 int data_interface_num
= -1;
950 unsigned long quirks
;
953 int combined_interfaces
= 0;
956 quirks
= (unsigned long)id
->driver_info
;
957 num_rx_buf
= (quirks
== SINGLE_RX_URB
) ? 1 : ACM_NR
;
959 /* handle quirks deadly to normal probing*/
960 if (quirks
== NO_UNION_NORMAL
) {
961 data_interface
= usb_ifnum_to_if(usb_dev
, 1);
962 control_interface
= usb_ifnum_to_if(usb_dev
, 0);
963 goto skip_normal_probe
;
968 dev_err(&intf
->dev
, "Weird descriptor references\n");
973 if (intf
->cur_altsetting
->endpoint
&&
974 intf
->cur_altsetting
->endpoint
->extralen
&&
975 intf
->cur_altsetting
->endpoint
->extra
) {
977 "Seeking extra descriptors on endpoint\n");
978 buflen
= intf
->cur_altsetting
->endpoint
->extralen
;
979 buffer
= intf
->cur_altsetting
->endpoint
->extra
;
982 "Zero length descriptor references\n");
988 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
989 dev_err(&intf
->dev
, "skipping garbage\n");
994 case USB_CDC_UNION_TYPE
: /* we've found it */
996 dev_err(&intf
->dev
, "More than one "
997 "union descriptor, skipping ...\n");
1000 union_header
= (struct usb_cdc_union_desc
*)buffer
;
1002 case USB_CDC_COUNTRY_TYPE
: /* export through sysfs*/
1003 cfd
= (struct usb_cdc_country_functional_desc
*)buffer
;
1005 case USB_CDC_HEADER_TYPE
: /* maybe check version */
1006 break; /* for now we ignore it */
1007 case USB_CDC_ACM_TYPE
:
1008 ac_management_function
= buffer
[3];
1010 case USB_CDC_CALL_MANAGEMENT_TYPE
:
1011 call_management_function
= buffer
[3];
1012 call_interface_num
= buffer
[4];
1013 if ( (quirks
& NOT_A_MODEM
) == 0 && (call_management_function
& 3) != 3)
1014 dev_err(&intf
->dev
, "This device cannot do calls on its own. It is not a modem.\n");
1017 /* there are LOTS more CDC descriptors that
1018 * could legitimately be found here.
1020 dev_dbg(&intf
->dev
, "Ignoring descriptor: "
1021 "type %02x, length %d\n",
1022 buffer
[2], buffer
[0]);
1026 buflen
-= buffer
[0];
1027 buffer
+= buffer
[0];
1030 if (!union_header
) {
1031 if (call_interface_num
> 0) {
1032 dev_dbg(&intf
->dev
, "No union descriptor, using call management descriptor\n");
1033 /* quirks for Droids MuIn LCD */
1034 if (quirks
& NO_DATA_INTERFACE
)
1035 data_interface
= usb_ifnum_to_if(usb_dev
, 0);
1037 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= call_interface_num
));
1038 control_interface
= intf
;
1040 if (intf
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1041 dev_dbg(&intf
->dev
,"No union descriptor, giving up\n");
1044 dev_warn(&intf
->dev
,"No union descriptor, testing for castrated device\n");
1045 combined_interfaces
= 1;
1046 control_interface
= data_interface
= intf
;
1047 goto look_for_collapsed_interface
;
1051 control_interface
= usb_ifnum_to_if(usb_dev
, union_header
->bMasterInterface0
);
1052 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= union_header
->bSlaveInterface0
));
1053 if (!control_interface
|| !data_interface
) {
1054 dev_dbg(&intf
->dev
, "no interfaces\n");
1059 if (data_interface_num
!= call_interface_num
)
1060 dev_dbg(&intf
->dev
, "Separate call control interface. That is not fully supported.\n");
1062 if (control_interface
== data_interface
) {
1063 /* some broken devices designed for windows work this way */
1064 dev_warn(&intf
->dev
,"Control and data interfaces are not separated!\n");
1065 combined_interfaces
= 1;
1066 /* a popular other OS doesn't use it */
1067 quirks
|= NO_CAP_LINE
;
1068 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1069 dev_err(&intf
->dev
, "This needs exactly 3 endpoints\n");
1072 look_for_collapsed_interface
:
1073 for (i
= 0; i
< 3; i
++) {
1074 struct usb_endpoint_descriptor
*ep
;
1075 ep
= &data_interface
->cur_altsetting
->endpoint
[i
].desc
;
1077 if (usb_endpoint_is_int_in(ep
))
1079 else if (usb_endpoint_is_bulk_out(ep
))
1081 else if (usb_endpoint_is_bulk_in(ep
))
1086 if (!epctrl
|| !epread
|| !epwrite
)
1089 goto made_compressed_probe
;
1094 /*workaround for switched interfaces */
1095 if (data_interface
->cur_altsetting
->desc
.bInterfaceClass
1096 != CDC_DATA_INTERFACE_TYPE
) {
1097 if (control_interface
->cur_altsetting
->desc
.bInterfaceClass
1098 == CDC_DATA_INTERFACE_TYPE
) {
1099 struct usb_interface
*t
;
1101 "Your device has switched interfaces.\n");
1102 t
= control_interface
;
1103 control_interface
= data_interface
;
1110 /* Accept probe requests only for the control interface */
1111 if (!combined_interfaces
&& intf
!= control_interface
)
1114 if (!combined_interfaces
&& usb_interface_claimed(data_interface
)) {
1115 /* valid in this context */
1116 dev_dbg(&intf
->dev
, "The data interface isn't available\n");
1121 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
< 2)
1124 epctrl
= &control_interface
->cur_altsetting
->endpoint
[0].desc
;
1125 epread
= &data_interface
->cur_altsetting
->endpoint
[0].desc
;
1126 epwrite
= &data_interface
->cur_altsetting
->endpoint
[1].desc
;
1129 /* workaround for switched endpoints */
1130 if (!usb_endpoint_dir_in(epread
)) {
1131 /* descriptors are swapped */
1132 struct usb_endpoint_descriptor
*t
;
1134 "The data interface has switched endpoints\n");
1139 made_compressed_probe
:
1140 dbg("interfaces are valid");
1141 for (minor
= 0; minor
< ACM_TTY_MINORS
&& acm_table
[minor
]; minor
++);
1143 if (minor
== ACM_TTY_MINORS
) {
1144 dev_err(&intf
->dev
, "no more free acm devices\n");
1148 acm
= kzalloc(sizeof(struct acm
), GFP_KERNEL
);
1150 dev_dbg(&intf
->dev
, "out of memory (acm kzalloc)\n");
1154 ctrlsize
= le16_to_cpu(epctrl
->wMaxPacketSize
);
1155 readsize
= le16_to_cpu(epread
->wMaxPacketSize
) *
1156 (quirks
== SINGLE_RX_URB
? 1 : 2);
1157 acm
->combined_interfaces
= combined_interfaces
;
1158 acm
->writesize
= le16_to_cpu(epwrite
->wMaxPacketSize
) * 20;
1159 acm
->control
= control_interface
;
1160 acm
->data
= data_interface
;
1163 acm
->ctrl_caps
= ac_management_function
;
1164 if (quirks
& NO_CAP_LINE
)
1165 acm
->ctrl_caps
&= ~USB_CDC_CAP_LINE
;
1166 acm
->ctrlsize
= ctrlsize
;
1167 acm
->readsize
= readsize
;
1168 acm
->rx_buflimit
= num_rx_buf
;
1169 acm
->urb_task
.func
= acm_rx_tasklet
;
1170 acm
->urb_task
.data
= (unsigned long) acm
;
1171 INIT_WORK(&acm
->work
, acm_softint
);
1172 init_waitqueue_head(&acm
->drain_wait
);
1173 spin_lock_init(&acm
->throttle_lock
);
1174 spin_lock_init(&acm
->write_lock
);
1175 spin_lock_init(&acm
->read_lock
);
1176 mutex_init(&acm
->mutex
);
1177 acm
->rx_endpoint
= usb_rcvbulkpipe(usb_dev
, epread
->bEndpointAddress
);
1178 acm
->is_int_ep
= usb_endpoint_xfer_int(epread
);
1180 acm
->bInterval
= epread
->bInterval
;
1181 tty_port_init(&acm
->port
);
1182 acm
->port
.ops
= &acm_port_ops
;
1184 buf
= usb_alloc_coherent(usb_dev
, ctrlsize
, GFP_KERNEL
, &acm
->ctrl_dma
);
1186 dev_dbg(&intf
->dev
, "out of memory (ctrl buffer alloc)\n");
1189 acm
->ctrl_buffer
= buf
;
1191 if (acm_write_buffers_alloc(acm
) < 0) {
1192 dev_dbg(&intf
->dev
, "out of memory (write buffer alloc)\n");
1196 acm
->ctrlurb
= usb_alloc_urb(0, GFP_KERNEL
);
1197 if (!acm
->ctrlurb
) {
1198 dev_dbg(&intf
->dev
, "out of memory (ctrlurb kmalloc)\n");
1201 for (i
= 0; i
< num_rx_buf
; i
++) {
1202 struct acm_ru
*rcv
= &(acm
->ru
[i
]);
1204 rcv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1205 if (rcv
->urb
== NULL
) {
1207 "out of memory (read urbs usb_alloc_urb)\n");
1211 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1212 rcv
->instance
= acm
;
1214 for (i
= 0; i
< num_rx_buf
; i
++) {
1215 struct acm_rb
*rb
= &(acm
->rb
[i
]);
1217 rb
->base
= usb_alloc_coherent(acm
->dev
, readsize
,
1218 GFP_KERNEL
, &rb
->dma
);
1221 "out of memory (read bufs usb_alloc_coherent)\n");
1225 for (i
= 0; i
< ACM_NW
; i
++) {
1226 struct acm_wb
*snd
= &(acm
->wb
[i
]);
1228 snd
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1229 if (snd
->urb
== NULL
) {
1231 "out of memory (write urbs usb_alloc_urb)");
1235 if (usb_endpoint_xfer_int(epwrite
))
1236 usb_fill_int_urb(snd
->urb
, usb_dev
,
1237 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1238 NULL
, acm
->writesize
, acm_write_bulk
, snd
, epwrite
->bInterval
);
1240 usb_fill_bulk_urb(snd
->urb
, usb_dev
,
1241 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1242 NULL
, acm
->writesize
, acm_write_bulk
, snd
);
1243 snd
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1244 snd
->instance
= acm
;
1247 usb_set_intfdata(intf
, acm
);
1249 i
= device_create_file(&intf
->dev
, &dev_attr_bmCapabilities
);
1253 if (cfd
) { /* export the country data */
1254 acm
->country_codes
= kmalloc(cfd
->bLength
- 4, GFP_KERNEL
);
1255 if (!acm
->country_codes
)
1256 goto skip_countries
;
1257 acm
->country_code_size
= cfd
->bLength
- 4;
1258 memcpy(acm
->country_codes
, (u8
*)&cfd
->wCountyCode0
,
1260 acm
->country_rel_date
= cfd
->iCountryCodeRelDate
;
1262 i
= device_create_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1264 kfree(acm
->country_codes
);
1265 goto skip_countries
;
1268 i
= device_create_file(&intf
->dev
,
1269 &dev_attr_iCountryCodeRelDate
);
1271 device_remove_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1272 kfree(acm
->country_codes
);
1273 goto skip_countries
;
1278 usb_fill_int_urb(acm
->ctrlurb
, usb_dev
,
1279 usb_rcvintpipe(usb_dev
, epctrl
->bEndpointAddress
),
1280 acm
->ctrl_buffer
, ctrlsize
, acm_ctrl_irq
, acm
,
1281 /* works around buggy devices */
1282 epctrl
->bInterval
? epctrl
->bInterval
: 0xff);
1283 acm
->ctrlurb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1284 acm
->ctrlurb
->transfer_dma
= acm
->ctrl_dma
;
1286 dev_info(&intf
->dev
, "ttyACM%d: USB ACM device\n", minor
);
1288 acm_set_control(acm
, acm
->ctrlout
);
1290 acm
->line
.dwDTERate
= cpu_to_le32(9600);
1291 acm
->line
.bDataBits
= 8;
1292 acm_set_line(acm
, &acm
->line
);
1294 usb_driver_claim_interface(&acm_driver
, data_interface
, acm
);
1295 usb_set_intfdata(data_interface
, acm
);
1297 usb_get_intf(control_interface
);
1298 tty_register_device(acm_tty_driver
, minor
, &control_interface
->dev
);
1300 acm_table
[minor
] = acm
;
1304 for (i
= 0; i
< ACM_NW
; i
++)
1305 usb_free_urb(acm
->wb
[i
].urb
);
1307 acm_read_buffers_free(acm
);
1309 for (i
= 0; i
< num_rx_buf
; i
++)
1310 usb_free_urb(acm
->ru
[i
].urb
);
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
);
1322 static void stop_data_traffic(struct acm
*acm
)
1325 dbg("Entering stop_data_traffic");
1327 tasklet_disable(&acm
->urb_task
);
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
->ru
[i
].urb
);
1335 tasklet_enable(&acm
->urb_task
);
1337 cancel_work_sync(&acm
->work
);
1340 static void acm_disconnect(struct usb_interface
*intf
)
1342 struct acm
*acm
= usb_get_intfdata(intf
);
1343 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1344 struct tty_struct
*tty
;
1346 /* sibling interface is already cleaning up */
1350 mutex_lock(&open_mutex
);
1351 if (acm
->country_codes
) {
1352 device_remove_file(&acm
->control
->dev
,
1353 &dev_attr_wCountryCodes
);
1354 device_remove_file(&acm
->control
->dev
,
1355 &dev_attr_iCountryCodeRelDate
);
1357 device_remove_file(&acm
->control
->dev
, &dev_attr_bmCapabilities
);
1359 usb_set_intfdata(acm
->control
, NULL
);
1360 usb_set_intfdata(acm
->data
, NULL
);
1362 stop_data_traffic(acm
);
1364 acm_write_buffers_free(acm
);
1365 usb_free_coherent(usb_dev
, acm
->ctrlsize
, acm
->ctrl_buffer
,
1367 acm_read_buffers_free(acm
);
1369 if (!acm
->combined_interfaces
)
1370 usb_driver_release_interface(&acm_driver
, intf
== acm
->control
?
1371 acm
->data
: acm
->control
);
1373 if (acm
->port
.count
== 0) {
1374 acm_tty_unregister(acm
);
1375 mutex_unlock(&open_mutex
);
1379 mutex_unlock(&open_mutex
);
1380 tty
= tty_port_tty_get(&acm
->port
);
1388 static int acm_suspend(struct usb_interface
*intf
, pm_message_t message
)
1390 struct acm
*acm
= usb_get_intfdata(intf
);
1393 if (message
.event
& PM_EVENT_AUTO
) {
1396 spin_lock_irq(&acm
->read_lock
);
1397 spin_lock(&acm
->write_lock
);
1398 b
= acm
->processing
+ acm
->transmitting
;
1399 spin_unlock(&acm
->write_lock
);
1400 spin_unlock_irq(&acm
->read_lock
);
1405 spin_lock_irq(&acm
->read_lock
);
1406 spin_lock(&acm
->write_lock
);
1407 cnt
= acm
->susp_count
++;
1408 spin_unlock(&acm
->write_lock
);
1409 spin_unlock_irq(&acm
->read_lock
);
1414 we treat opened interfaces differently,
1415 we must guard against open
1417 mutex_lock(&acm
->mutex
);
1419 if (acm
->port
.count
)
1420 stop_data_traffic(acm
);
1422 mutex_unlock(&acm
->mutex
);
1426 static int acm_resume(struct usb_interface
*intf
)
1428 struct acm
*acm
= usb_get_intfdata(intf
);
1433 spin_lock_irq(&acm
->read_lock
);
1434 acm
->susp_count
-= 1;
1435 cnt
= acm
->susp_count
;
1436 spin_unlock_irq(&acm
->read_lock
);
1441 mutex_lock(&acm
->mutex
);
1442 if (acm
->port
.count
) {
1443 rv
= usb_submit_urb(acm
->ctrlurb
, GFP_NOIO
);
1445 spin_lock_irq(&acm
->write_lock
);
1446 if (acm
->delayed_wb
) {
1447 wb
= acm
->delayed_wb
;
1448 acm
->delayed_wb
= NULL
;
1449 spin_unlock_irq(&acm
->write_lock
);
1450 acm_start_wb(acm
, wb
);
1452 spin_unlock_irq(&acm
->write_lock
);
1456 * delayed error checking because we must
1457 * do the write path at all cost
1462 tasklet_schedule(&acm
->urb_task
);
1466 mutex_unlock(&acm
->mutex
);
1470 static int acm_reset_resume(struct usb_interface
*intf
)
1472 struct acm
*acm
= usb_get_intfdata(intf
);
1473 struct tty_struct
*tty
;
1475 mutex_lock(&acm
->mutex
);
1476 if (acm
->port
.count
) {
1477 tty
= tty_port_tty_get(&acm
->port
);
1483 mutex_unlock(&acm
->mutex
);
1484 return acm_resume(intf
);
1487 #endif /* CONFIG_PM */
1489 #define NOKIA_PCSUITE_ACM_INFO(x) \
1490 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1491 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1492 USB_CDC_ACM_PROTO_VENDOR)
1494 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1495 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1496 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1497 USB_CDC_ACM_PROTO_VENDOR)
1500 * USB driver structure.
1503 static const struct usb_device_id acm_ids
[] = {
1504 /* quirky and broken devices */
1505 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1506 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1508 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1509 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1511 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1512 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1514 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1515 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1517 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1518 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1520 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1521 .driver_info
= SINGLE_RX_URB
,
1523 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1524 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1526 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1527 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1529 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1530 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1532 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1533 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1535 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1536 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1538 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1539 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1541 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1542 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1544 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
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 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1622 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1624 /* Support Lego NXT using pbLua firmware */
1625 { USB_DEVICE(0x0694, 0xff00),
1626 .driver_info
= NOT_A_MODEM
,
1629 /* Support for Droids MuIn LCD */
1630 { USB_DEVICE(0x04d8, 0x000b),
1631 .driver_info
= NO_DATA_INTERFACE
,
1634 /* control interfaces without any protocol set */
1635 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1636 USB_CDC_PROTO_NONE
) },
1638 /* control interfaces with various AT-command sets */
1639 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1640 USB_CDC_ACM_PROTO_AT_V25TER
) },
1641 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1642 USB_CDC_ACM_PROTO_AT_PCCA101
) },
1643 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1644 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE
) },
1645 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1646 USB_CDC_ACM_PROTO_AT_GSM
) },
1647 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1648 USB_CDC_ACM_PROTO_AT_3G
) },
1649 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1650 USB_CDC_ACM_PROTO_AT_CDMA
) },
1655 MODULE_DEVICE_TABLE(usb
, acm_ids
);
1657 static struct usb_driver acm_driver
= {
1660 .disconnect
= acm_disconnect
,
1662 .suspend
= acm_suspend
,
1663 .resume
= acm_resume
,
1664 .reset_resume
= acm_reset_resume
,
1666 .id_table
= acm_ids
,
1668 .supports_autosuspend
= 1,
1673 * TTY driver structures.
1676 static const struct tty_operations acm_ops
= {
1677 .open
= acm_tty_open
,
1678 .close
= acm_tty_close
,
1679 .hangup
= acm_tty_hangup
,
1680 .write
= acm_tty_write
,
1681 .write_room
= acm_tty_write_room
,
1682 .ioctl
= acm_tty_ioctl
,
1683 .throttle
= acm_tty_throttle
,
1684 .unthrottle
= acm_tty_unthrottle
,
1685 .chars_in_buffer
= acm_tty_chars_in_buffer
,
1686 .break_ctl
= acm_tty_break_ctl
,
1687 .set_termios
= acm_tty_set_termios
,
1688 .tiocmget
= acm_tty_tiocmget
,
1689 .tiocmset
= acm_tty_tiocmset
,
1696 static int __init
acm_init(void)
1699 acm_tty_driver
= alloc_tty_driver(ACM_TTY_MINORS
);
1700 if (!acm_tty_driver
)
1702 acm_tty_driver
->owner
= THIS_MODULE
,
1703 acm_tty_driver
->driver_name
= "acm",
1704 acm_tty_driver
->name
= "ttyACM",
1705 acm_tty_driver
->major
= ACM_TTY_MAJOR
,
1706 acm_tty_driver
->minor_start
= 0,
1707 acm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
,
1708 acm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
,
1709 acm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1710 acm_tty_driver
->init_termios
= tty_std_termios
;
1711 acm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
|
1713 tty_set_operations(acm_tty_driver
, &acm_ops
);
1715 retval
= tty_register_driver(acm_tty_driver
);
1717 put_tty_driver(acm_tty_driver
);
1721 retval
= usb_register(&acm_driver
);
1723 tty_unregister_driver(acm_tty_driver
);
1724 put_tty_driver(acm_tty_driver
);
1728 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1734 static void __exit
acm_exit(void)
1736 usb_deregister(&acm_driver
);
1737 tty_unregister_driver(acm_tty_driver
);
1738 put_tty_driver(acm_tty_driver
);
1741 module_init(acm_init
);
1742 module_exit(acm_exit
);
1744 MODULE_AUTHOR(DRIVER_AUTHOR
);
1745 MODULE_DESCRIPTION(DRIVER_DESC
);
1746 MODULE_LICENSE("GPL");
1747 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR
);