4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@suse.cz>
6 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
7 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
9 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
11 * USB Abstract Control Model driver for USB modems and ISDN adapters
16 * v0.9 - thorough cleaning, URBification, almost a rewrite
17 * v0.10 - some more cleanups
18 * v0.11 - fixed flow control, read error doesn't stop reads
19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm
21 * v0.13 - added termios, added hangup
22 * v0.14 - sized down struct acm
23 * v0.15 - fixed flow control again - characters could be lost
24 * v0.16 - added code for modems with swapped data and control interfaces
25 * v0.17 - added new style probing
26 * v0.18 - fixed new style probing for devices with more configurations
27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28 * v0.20 - switched to probing on interface (rather than device) class
29 * v0.21 - revert to probing on device for devices with multiple configs
30 * v0.22 - probe only the control interface. if usbcore doesn't choose the
31 * config we want, sysadmin changes bConfigurationValue in sysfs.
32 * v0.23 - use softirq for rx processing, as needed by tty layer
33 * v0.24 - change probe method to evaluate CDC union descriptor
34 * v0.25 - downstream tasks paralelized to maximize throughput
35 * v0.26 - multiple write urbs, writesize increased
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 * GNU General Public License for more details.
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/tty.h>
62 #include <linux/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_buffer_request_room(tty
, buf
->size
);
433 tty_insert_flip_string(tty
, buf
->base
, buf
->size
);
434 tty_flip_buffer_push(tty
);
437 dbg("Throttling noticed");
438 spin_lock_irqsave(&acm
->read_lock
, flags
);
439 list_add(&buf
->list
, &acm
->filled_read_bufs
);
440 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
445 spin_lock_irqsave(&acm
->read_lock
, flags
);
446 list_add(&buf
->list
, &acm
->spare_read_bufs
);
447 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
453 while (!list_empty(&acm
->spare_read_bufs
)) {
454 spin_lock_irqsave(&acm
->read_lock
, flags
);
455 if (list_empty(&acm
->spare_read_urbs
)) {
457 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
460 rcv
= list_entry(acm
->spare_read_urbs
.next
,
461 struct acm_ru
, list
);
462 list_del(&rcv
->list
);
463 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
465 buf
= list_entry(acm
->spare_read_bufs
.next
,
466 struct acm_rb
, list
);
467 list_del(&buf
->list
);
472 usb_fill_int_urb(rcv
->urb
, acm
->dev
,
476 acm_read_bulk
, rcv
, acm
->bInterval
);
478 usb_fill_bulk_urb(rcv
->urb
, acm
->dev
,
483 rcv
->urb
->transfer_dma
= buf
->dma
;
484 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
486 /* This shouldn't kill the driver as unsuccessful URBs are
487 returned to the free-urbs-pool and resubmited ASAP */
488 spin_lock_irqsave(&acm
->read_lock
, flags
);
489 if (acm
->susp_count
||
490 usb_submit_urb(rcv
->urb
, GFP_ATOMIC
) < 0) {
491 list_add(&buf
->list
, &acm
->spare_read_bufs
);
492 list_add(&rcv
->list
, &acm
->spare_read_urbs
);
494 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
497 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
498 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv
->urb
, rcv
, buf
);
501 spin_lock_irqsave(&acm
->read_lock
, flags
);
503 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
506 /* data interface wrote those outgoing bytes */
507 static void acm_write_bulk(struct urb
*urb
)
509 struct acm_wb
*wb
= urb
->context
;
510 struct acm
*acm
= wb
->instance
;
513 if (verbose
|| urb
->status
514 || (urb
->actual_length
!= urb
->transfer_buffer_length
))
515 dev_dbg(&acm
->data
->dev
, "tx %d/%d bytes -- > %d\n",
517 urb
->transfer_buffer_length
,
520 spin_lock_irqsave(&acm
->write_lock
, flags
);
521 acm_write_done(acm
, wb
);
522 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
524 schedule_work(&acm
->work
);
526 wake_up_interruptible(&acm
->drain_wait
);
529 static void acm_softint(struct work_struct
*work
)
531 struct acm
*acm
= container_of(work
, struct acm
, work
);
532 struct tty_struct
*tty
;
534 dev_vdbg(&acm
->data
->dev
, "tx work\n");
537 tty
= tty_port_tty_get(&acm
->port
);
548 static int acm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
553 dbg("Entering acm_tty_open.");
555 mutex_lock(&open_mutex
);
557 acm
= acm_table
[tty
->index
];
558 if (!acm
|| !acm
->dev
)
563 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
565 tty
->driver_data
= acm
;
566 tty_port_tty_set(&acm
->port
, tty
);
568 if (usb_autopm_get_interface(acm
->control
) < 0)
571 acm
->control
->needs_remote_wakeup
= 1;
573 mutex_lock(&acm
->mutex
);
574 if (acm
->port
.count
++) {
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
);
614 usb_autopm_put_interface(acm
->control
);
616 mutex_unlock(&acm
->mutex
);
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
, int drain
)
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 /* try letting the last writes drain naturally */
651 wait_event_interruptible_timeout(acm
->drain_wait
,
652 (ACM_NW
== acm_wb_is_avail(acm
)) || !acm
->dev
,
653 ACM_CLOSE_TIMEOUT
* HZ
);
655 usb_kill_urb(acm
->ctrlurb
);
656 for (i
= 0; i
< ACM_NW
; i
++)
657 usb_kill_urb(acm
->wb
[i
].urb
);
658 tasklet_disable(&acm
->urb_task
);
659 for (i
= 0; i
< nr
; i
++)
660 usb_kill_urb(acm
->ru
[i
].urb
);
661 tasklet_enable(&acm
->urb_task
);
662 acm
->control
->needs_remote_wakeup
= 0;
663 usb_autopm_put_interface(acm
->control
);
665 mutex_unlock(&open_mutex
);
668 static void acm_tty_hangup(struct tty_struct
*tty
)
670 struct acm
*acm
= tty
->driver_data
;
671 tty_port_hangup(&acm
->port
);
672 acm_port_down(acm
, 0);
675 static void acm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
677 struct acm
*acm
= tty
->driver_data
;
679 /* Perform the closing process and see if we need to do the hardware
683 if (tty_port_close_start(&acm
->port
, tty
, filp
) == 0) {
684 mutex_lock(&open_mutex
);
686 tty_port_tty_set(&acm
->port
, NULL
);
687 acm_tty_unregister(acm
);
688 tty
->driver_data
= NULL
;
690 mutex_unlock(&open_mutex
);
693 acm_port_down(acm
, 0);
694 tty_port_close_end(&acm
->port
, tty
);
695 tty_port_tty_set(&acm
->port
, NULL
);
698 static int acm_tty_write(struct tty_struct
*tty
,
699 const unsigned char *buf
, int count
)
701 struct acm
*acm
= tty
->driver_data
;
707 dbg("Entering acm_tty_write to write %d bytes,", count
);
714 spin_lock_irqsave(&acm
->write_lock
, flags
);
715 wbn
= acm_wb_alloc(acm
);
717 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
722 count
= (count
> acm
->writesize
) ? acm
->writesize
: count
;
723 dbg("Get %d bytes...", count
);
724 memcpy(wb
->buf
, buf
, count
);
726 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
728 stat
= acm_write_start(acm
, wbn
);
734 static int acm_tty_write_room(struct tty_struct
*tty
)
736 struct acm
*acm
= tty
->driver_data
;
740 * Do not let the line discipline to know that we have a reserve,
741 * or it might get too enthusiastic.
743 return acm_wb_is_avail(acm
) ? acm
->writesize
: 0;
746 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
)
748 struct acm
*acm
= tty
->driver_data
;
752 * This is inaccurate (overcounts), but it works.
754 return (ACM_NW
- acm_wb_is_avail(acm
)) * acm
->writesize
;
757 static void acm_tty_throttle(struct tty_struct
*tty
)
759 struct acm
*acm
= tty
->driver_data
;
762 spin_lock_bh(&acm
->throttle_lock
);
764 spin_unlock_bh(&acm
->throttle_lock
);
767 static void acm_tty_unthrottle(struct tty_struct
*tty
)
769 struct acm
*acm
= tty
->driver_data
;
772 spin_lock_bh(&acm
->throttle_lock
);
774 spin_unlock_bh(&acm
->throttle_lock
);
775 tasklet_schedule(&acm
->urb_task
);
778 static int acm_tty_break_ctl(struct tty_struct
*tty
, int state
)
780 struct acm
*acm
= tty
->driver_data
;
784 retval
= acm_send_break(acm
, state
? 0xffff : 0);
786 dbg("send break failed");
790 static int acm_tty_tiocmget(struct tty_struct
*tty
, struct file
*file
)
792 struct acm
*acm
= tty
->driver_data
;
797 return (acm
->ctrlout
& ACM_CTRL_DTR
? TIOCM_DTR
: 0) |
798 (acm
->ctrlout
& ACM_CTRL_RTS
? TIOCM_RTS
: 0) |
799 (acm
->ctrlin
& ACM_CTRL_DSR
? TIOCM_DSR
: 0) |
800 (acm
->ctrlin
& ACM_CTRL_RI
? TIOCM_RI
: 0) |
801 (acm
->ctrlin
& ACM_CTRL_DCD
? TIOCM_CD
: 0) |
805 static int acm_tty_tiocmset(struct tty_struct
*tty
, struct file
*file
,
806 unsigned int set
, unsigned int clear
)
808 struct acm
*acm
= tty
->driver_data
;
809 unsigned int newctrl
;
814 newctrl
= acm
->ctrlout
;
815 set
= (set
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
816 (set
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
817 clear
= (clear
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
818 (clear
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
820 newctrl
= (newctrl
& ~clear
) | set
;
822 if (acm
->ctrlout
== newctrl
)
824 return acm_set_control(acm
, acm
->ctrlout
= newctrl
);
827 static int acm_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
828 unsigned int cmd
, unsigned long arg
)
830 struct acm
*acm
= tty
->driver_data
;
838 static const __u32 acm_tty_speed
[] = {
839 0, 50, 75, 110, 134, 150, 200, 300, 600,
840 1200, 1800, 2400, 4800, 9600, 19200, 38400,
841 57600, 115200, 230400, 460800, 500000, 576000,
842 921600, 1000000, 1152000, 1500000, 2000000,
843 2500000, 3000000, 3500000, 4000000
846 static const __u8 acm_tty_size
[] = {
850 static void acm_tty_set_termios(struct tty_struct
*tty
,
851 struct ktermios
*termios_old
)
853 struct acm
*acm
= tty
->driver_data
;
854 struct ktermios
*termios
= tty
->termios
;
855 struct usb_cdc_line_coding newline
;
856 int newctrl
= acm
->ctrlout
;
861 newline
.dwDTERate
= cpu_to_le32(tty_get_baud_rate(tty
));
862 newline
.bCharFormat
= termios
->c_cflag
& CSTOPB
? 2 : 0;
863 newline
.bParityType
= termios
->c_cflag
& PARENB
?
864 (termios
->c_cflag
& PARODD
? 1 : 2) +
865 (termios
->c_cflag
& CMSPAR
? 2 : 0) : 0;
866 newline
.bDataBits
= acm_tty_size
[(termios
->c_cflag
& CSIZE
) >> 4];
867 /* FIXME: Needs to clear unsupported bits in the termios */
868 acm
->clocal
= ((termios
->c_cflag
& CLOCAL
) != 0);
870 if (!newline
.dwDTERate
) {
871 newline
.dwDTERate
= acm
->line
.dwDTERate
;
872 newctrl
&= ~ACM_CTRL_DTR
;
874 newctrl
|= ACM_CTRL_DTR
;
876 if (newctrl
!= acm
->ctrlout
)
877 acm_set_control(acm
, acm
->ctrlout
= newctrl
);
879 if (memcmp(&acm
->line
, &newline
, sizeof newline
)) {
880 memcpy(&acm
->line
, &newline
, sizeof newline
);
881 dbg("set line: %d %d %d %d", le32_to_cpu(newline
.dwDTERate
),
882 newline
.bCharFormat
, newline
.bParityType
,
884 acm_set_line(acm
, &acm
->line
);
889 * USB probe and disconnect routines.
892 /* Little helpers: write/read buffers free */
893 static void acm_write_buffers_free(struct acm
*acm
)
897 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
899 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++)
900 usb_buffer_free(usb_dev
, acm
->writesize
, wb
->buf
, wb
->dmah
);
903 static void acm_read_buffers_free(struct acm
*acm
)
905 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
906 int i
, n
= acm
->rx_buflimit
;
908 for (i
= 0; i
< n
; i
++)
909 usb_buffer_free(usb_dev
, acm
->readsize
,
910 acm
->rb
[i
].base
, acm
->rb
[i
].dma
);
913 /* Little helper: write buffers allocate */
914 static int acm_write_buffers_alloc(struct acm
*acm
)
919 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
920 wb
->buf
= usb_buffer_alloc(acm
->dev
, acm
->writesize
, GFP_KERNEL
,
926 usb_buffer_free(acm
->dev
, acm
->writesize
,
935 static int acm_probe(struct usb_interface
*intf
,
936 const struct usb_device_id
*id
)
938 struct usb_cdc_union_desc
*union_header
= NULL
;
939 struct usb_cdc_country_functional_desc
*cfd
= NULL
;
940 unsigned char *buffer
= intf
->altsetting
->extra
;
941 int buflen
= intf
->altsetting
->extralen
;
942 struct usb_interface
*control_interface
;
943 struct usb_interface
*data_interface
;
944 struct usb_endpoint_descriptor
*epctrl
= NULL
;
945 struct usb_endpoint_descriptor
*epread
= NULL
;
946 struct usb_endpoint_descriptor
*epwrite
= NULL
;
947 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
950 int ctrlsize
, readsize
;
952 u8 ac_management_function
= 0;
953 u8 call_management_function
= 0;
954 int call_interface_num
= -1;
955 int data_interface_num
;
956 unsigned long quirks
;
959 int combined_interfaces
= 0;
962 quirks
= (unsigned long)id
->driver_info
;
963 num_rx_buf
= (quirks
== SINGLE_RX_URB
) ? 1 : ACM_NR
;
965 /* handle quirks deadly to normal probing*/
966 if (quirks
== NO_UNION_NORMAL
) {
967 data_interface
= usb_ifnum_to_if(usb_dev
, 1);
968 control_interface
= usb_ifnum_to_if(usb_dev
, 0);
969 goto skip_normal_probe
;
974 dev_err(&intf
->dev
, "Weird descriptor references\n");
979 if (intf
->cur_altsetting
->endpoint
->extralen
&&
980 intf
->cur_altsetting
->endpoint
->extra
) {
982 "Seeking extra descriptors on endpoint\n");
983 buflen
= intf
->cur_altsetting
->endpoint
->extralen
;
984 buffer
= intf
->cur_altsetting
->endpoint
->extra
;
987 "Zero length descriptor references\n");
993 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
994 dev_err(&intf
->dev
, "skipping garbage\n");
999 case USB_CDC_UNION_TYPE
: /* we've found it */
1001 dev_err(&intf
->dev
, "More than one "
1002 "union descriptor, skipping ...\n");
1005 union_header
= (struct usb_cdc_union_desc
*)buffer
;
1007 case USB_CDC_COUNTRY_TYPE
: /* export through sysfs*/
1008 cfd
= (struct usb_cdc_country_functional_desc
*)buffer
;
1010 case USB_CDC_HEADER_TYPE
: /* maybe check version */
1011 break; /* for now we ignore it */
1012 case USB_CDC_ACM_TYPE
:
1013 ac_management_function
= buffer
[3];
1015 case USB_CDC_CALL_MANAGEMENT_TYPE
:
1016 call_management_function
= buffer
[3];
1017 call_interface_num
= buffer
[4];
1018 if ((call_management_function
& 3) != 3)
1019 dev_err(&intf
->dev
, "This device cannot do calls on its own. It is not a modem.\n");
1022 /* there are LOTS more CDC descriptors that
1023 * could legitimately be found here.
1025 dev_dbg(&intf
->dev
, "Ignoring descriptor: "
1026 "type %02x, length %d\n",
1027 buffer
[2], buffer
[0]);
1031 buflen
-= buffer
[0];
1032 buffer
+= buffer
[0];
1035 if (!union_header
) {
1036 if (call_interface_num
> 0) {
1037 dev_dbg(&intf
->dev
, "No union descriptor, using call management descriptor\n");
1038 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= call_interface_num
));
1039 control_interface
= intf
;
1041 if (intf
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1042 dev_dbg(&intf
->dev
,"No union descriptor, giving up\n");
1045 dev_warn(&intf
->dev
,"No union descriptor, testing for castrated device\n");
1046 combined_interfaces
= 1;
1047 control_interface
= data_interface
= intf
;
1048 goto look_for_collapsed_interface
;
1052 control_interface
= usb_ifnum_to_if(usb_dev
, union_header
->bMasterInterface0
);
1053 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= union_header
->bSlaveInterface0
));
1054 if (!control_interface
|| !data_interface
) {
1055 dev_dbg(&intf
->dev
, "no interfaces\n");
1060 if (data_interface_num
!= call_interface_num
)
1061 dev_dbg(&intf
->dev
, "Separate call control interface. That is not fully supported.\n");
1063 if (control_interface
== data_interface
) {
1064 /* some broken devices designed for windows work this way */
1065 dev_warn(&intf
->dev
,"Control and data interfaces are not separated!\n");
1066 combined_interfaces
= 1;
1067 /* a popular other OS doesn't use it */
1068 quirks
|= NO_CAP_LINE
;
1069 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1070 dev_err(&intf
->dev
, "This needs exactly 3 endpoints\n");
1073 look_for_collapsed_interface
:
1074 for (i
= 0; i
< 3; i
++) {
1075 struct usb_endpoint_descriptor
*ep
;
1076 ep
= &data_interface
->cur_altsetting
->endpoint
[i
].desc
;
1078 if (usb_endpoint_is_int_in(ep
))
1080 else if (usb_endpoint_is_bulk_out(ep
))
1082 else if (usb_endpoint_is_bulk_in(ep
))
1087 if (!epctrl
|| !epread
|| !epwrite
)
1090 goto made_compressed_probe
;
1095 /*workaround for switched interfaces */
1096 if (data_interface
->cur_altsetting
->desc
.bInterfaceClass
1097 != CDC_DATA_INTERFACE_TYPE
) {
1098 if (control_interface
->cur_altsetting
->desc
.bInterfaceClass
1099 == CDC_DATA_INTERFACE_TYPE
) {
1100 struct usb_interface
*t
;
1102 "Your device has switched interfaces.\n");
1103 t
= control_interface
;
1104 control_interface
= data_interface
;
1111 /* Accept probe requests only for the control interface */
1112 if (!combined_interfaces
&& intf
!= control_interface
)
1115 if (!combined_interfaces
&& usb_interface_claimed(data_interface
)) {
1116 /* valid in this context */
1117 dev_dbg(&intf
->dev
, "The data interface isn't available\n");
1122 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
< 2)
1125 epctrl
= &control_interface
->cur_altsetting
->endpoint
[0].desc
;
1126 epread
= &data_interface
->cur_altsetting
->endpoint
[0].desc
;
1127 epwrite
= &data_interface
->cur_altsetting
->endpoint
[1].desc
;
1130 /* workaround for switched endpoints */
1131 if (!usb_endpoint_dir_in(epread
)) {
1132 /* descriptors are swapped */
1133 struct usb_endpoint_descriptor
*t
;
1135 "The data interface has switched endpoints\n");
1140 made_compressed_probe
:
1141 dbg("interfaces are valid");
1142 for (minor
= 0; minor
< ACM_TTY_MINORS
&& acm_table
[minor
]; minor
++);
1144 if (minor
== ACM_TTY_MINORS
) {
1145 dev_err(&intf
->dev
, "no more free acm devices\n");
1149 acm
= kzalloc(sizeof(struct acm
), GFP_KERNEL
);
1151 dev_dbg(&intf
->dev
, "out of memory (acm kzalloc)\n");
1155 ctrlsize
= le16_to_cpu(epctrl
->wMaxPacketSize
);
1156 readsize
= le16_to_cpu(epread
->wMaxPacketSize
) *
1157 (quirks
== SINGLE_RX_URB
? 1 : 2);
1158 acm
->combined_interfaces
= combined_interfaces
;
1159 acm
->writesize
= le16_to_cpu(epwrite
->wMaxPacketSize
) * 20;
1160 acm
->control
= control_interface
;
1161 acm
->data
= data_interface
;
1164 acm
->ctrl_caps
= ac_management_function
;
1165 if (quirks
& NO_CAP_LINE
)
1166 acm
->ctrl_caps
&= ~USB_CDC_CAP_LINE
;
1167 acm
->ctrlsize
= ctrlsize
;
1168 acm
->readsize
= readsize
;
1169 acm
->rx_buflimit
= num_rx_buf
;
1170 acm
->urb_task
.func
= acm_rx_tasklet
;
1171 acm
->urb_task
.data
= (unsigned long) acm
;
1172 INIT_WORK(&acm
->work
, acm_softint
);
1173 init_waitqueue_head(&acm
->drain_wait
);
1174 spin_lock_init(&acm
->throttle_lock
);
1175 spin_lock_init(&acm
->write_lock
);
1176 spin_lock_init(&acm
->read_lock
);
1177 mutex_init(&acm
->mutex
);
1178 acm
->rx_endpoint
= usb_rcvbulkpipe(usb_dev
, epread
->bEndpointAddress
);
1179 acm
->is_int_ep
= usb_endpoint_xfer_int(epread
);
1181 acm
->bInterval
= epread
->bInterval
;
1182 tty_port_init(&acm
->port
);
1183 acm
->port
.ops
= &acm_port_ops
;
1185 buf
= usb_buffer_alloc(usb_dev
, ctrlsize
, GFP_KERNEL
, &acm
->ctrl_dma
);
1187 dev_dbg(&intf
->dev
, "out of memory (ctrl buffer alloc)\n");
1190 acm
->ctrl_buffer
= buf
;
1192 if (acm_write_buffers_alloc(acm
) < 0) {
1193 dev_dbg(&intf
->dev
, "out of memory (write buffer alloc)\n");
1197 acm
->ctrlurb
= usb_alloc_urb(0, GFP_KERNEL
);
1198 if (!acm
->ctrlurb
) {
1199 dev_dbg(&intf
->dev
, "out of memory (ctrlurb kmalloc)\n");
1202 for (i
= 0; i
< num_rx_buf
; i
++) {
1203 struct acm_ru
*rcv
= &(acm
->ru
[i
]);
1205 rcv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1206 if (rcv
->urb
== NULL
) {
1208 "out of memory (read urbs usb_alloc_urb)\n");
1212 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1213 rcv
->instance
= acm
;
1215 for (i
= 0; i
< num_rx_buf
; i
++) {
1216 struct acm_rb
*rb
= &(acm
->rb
[i
]);
1218 rb
->base
= usb_buffer_alloc(acm
->dev
, readsize
,
1219 GFP_KERNEL
, &rb
->dma
);
1222 "out of memory (read bufs usb_buffer_alloc)\n");
1226 for (i
= 0; i
< ACM_NW
; i
++) {
1227 struct acm_wb
*snd
= &(acm
->wb
[i
]);
1229 snd
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1230 if (snd
->urb
== NULL
) {
1232 "out of memory (write urbs usb_alloc_urb)");
1236 if (usb_endpoint_xfer_int(epwrite
))
1237 usb_fill_int_urb(snd
->urb
, usb_dev
,
1238 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1239 NULL
, acm
->writesize
, acm_write_bulk
, snd
, epwrite
->bInterval
);
1241 usb_fill_bulk_urb(snd
->urb
, usb_dev
,
1242 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1243 NULL
, acm
->writesize
, acm_write_bulk
, snd
);
1244 snd
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1245 snd
->instance
= acm
;
1248 usb_set_intfdata(intf
, acm
);
1250 i
= device_create_file(&intf
->dev
, &dev_attr_bmCapabilities
);
1254 if (cfd
) { /* export the country data */
1255 acm
->country_codes
= kmalloc(cfd
->bLength
- 4, GFP_KERNEL
);
1256 if (!acm
->country_codes
)
1257 goto skip_countries
;
1258 acm
->country_code_size
= cfd
->bLength
- 4;
1259 memcpy(acm
->country_codes
, (u8
*)&cfd
->wCountyCode0
,
1261 acm
->country_rel_date
= cfd
->iCountryCodeRelDate
;
1263 i
= device_create_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1265 kfree(acm
->country_codes
);
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 goto skip_countries
;
1279 usb_fill_int_urb(acm
->ctrlurb
, usb_dev
,
1280 usb_rcvintpipe(usb_dev
, epctrl
->bEndpointAddress
),
1281 acm
->ctrl_buffer
, ctrlsize
, acm_ctrl_irq
, acm
,
1282 /* works around buggy devices */
1283 epctrl
->bInterval
? epctrl
->bInterval
: 0xff);
1284 acm
->ctrlurb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1285 acm
->ctrlurb
->transfer_dma
= acm
->ctrl_dma
;
1287 dev_info(&intf
->dev
, "ttyACM%d: USB ACM device\n", minor
);
1289 acm_set_control(acm
, acm
->ctrlout
);
1291 acm
->line
.dwDTERate
= cpu_to_le32(9600);
1292 acm
->line
.bDataBits
= 8;
1293 acm_set_line(acm
, &acm
->line
);
1295 usb_driver_claim_interface(&acm_driver
, data_interface
, acm
);
1296 usb_set_intfdata(data_interface
, acm
);
1298 usb_get_intf(control_interface
);
1299 tty_register_device(acm_tty_driver
, minor
, &control_interface
->dev
);
1301 acm_table
[minor
] = acm
;
1305 for (i
= 0; i
< ACM_NW
; i
++)
1306 usb_free_urb(acm
->wb
[i
].urb
);
1308 acm_read_buffers_free(acm
);
1310 for (i
= 0; i
< num_rx_buf
; i
++)
1311 usb_free_urb(acm
->ru
[i
].urb
);
1312 usb_free_urb(acm
->ctrlurb
);
1314 acm_write_buffers_free(acm
);
1316 usb_buffer_free(usb_dev
, ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1323 static void stop_data_traffic(struct acm
*acm
)
1326 dbg("Entering stop_data_traffic");
1328 tasklet_disable(&acm
->urb_task
);
1330 usb_kill_urb(acm
->ctrlurb
);
1331 for (i
= 0; i
< ACM_NW
; i
++)
1332 usb_kill_urb(acm
->wb
[i
].urb
);
1333 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1334 usb_kill_urb(acm
->ru
[i
].urb
);
1336 tasklet_enable(&acm
->urb_task
);
1338 cancel_work_sync(&acm
->work
);
1341 static void acm_disconnect(struct usb_interface
*intf
)
1343 struct acm
*acm
= usb_get_intfdata(intf
);
1344 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1345 struct tty_struct
*tty
;
1347 /* sibling interface is already cleaning up */
1351 mutex_lock(&open_mutex
);
1352 if (acm
->country_codes
) {
1353 device_remove_file(&acm
->control
->dev
,
1354 &dev_attr_wCountryCodes
);
1355 device_remove_file(&acm
->control
->dev
,
1356 &dev_attr_iCountryCodeRelDate
);
1358 device_remove_file(&acm
->control
->dev
, &dev_attr_bmCapabilities
);
1360 usb_set_intfdata(acm
->control
, NULL
);
1361 usb_set_intfdata(acm
->data
, NULL
);
1363 stop_data_traffic(acm
);
1365 acm_write_buffers_free(acm
);
1366 usb_buffer_free(usb_dev
, acm
->ctrlsize
, acm
->ctrl_buffer
,
1368 acm_read_buffers_free(acm
);
1370 if (!acm
->combined_interfaces
)
1371 usb_driver_release_interface(&acm_driver
, intf
== acm
->control
?
1372 acm
->data
: acm
->control
);
1374 if (acm
->port
.count
== 0) {
1375 acm_tty_unregister(acm
);
1376 mutex_unlock(&open_mutex
);
1380 mutex_unlock(&open_mutex
);
1381 tty
= tty_port_tty_get(&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 (message
.event
& PM_EVENT_AUTO
) {
1397 spin_lock_irq(&acm
->read_lock
);
1398 spin_lock(&acm
->write_lock
);
1399 b
= acm
->processing
+ acm
->transmitting
;
1400 spin_unlock(&acm
->write_lock
);
1401 spin_unlock_irq(&acm
->read_lock
);
1406 spin_lock_irq(&acm
->read_lock
);
1407 spin_lock(&acm
->write_lock
);
1408 cnt
= acm
->susp_count
++;
1409 spin_unlock(&acm
->write_lock
);
1410 spin_unlock_irq(&acm
->read_lock
);
1415 we treat opened interfaces differently,
1416 we must guard against open
1418 mutex_lock(&acm
->mutex
);
1420 if (acm
->port
.count
)
1421 stop_data_traffic(acm
);
1423 mutex_unlock(&acm
->mutex
);
1427 static int acm_resume(struct usb_interface
*intf
)
1429 struct acm
*acm
= usb_get_intfdata(intf
);
1434 spin_lock_irq(&acm
->read_lock
);
1435 acm
->susp_count
-= 1;
1436 cnt
= acm
->susp_count
;
1437 spin_unlock_irq(&acm
->read_lock
);
1442 mutex_lock(&acm
->mutex
);
1443 if (acm
->port
.count
) {
1444 rv
= usb_submit_urb(acm
->ctrlurb
, GFP_NOIO
);
1446 spin_lock_irq(&acm
->write_lock
);
1447 if (acm
->delayed_wb
) {
1448 wb
= acm
->delayed_wb
;
1449 acm
->delayed_wb
= NULL
;
1450 spin_unlock_irq(&acm
->write_lock
);
1451 acm_start_wb(acm
, wb
);
1453 spin_unlock_irq(&acm
->write_lock
);
1457 * delayed error checking because we must
1458 * do the write path at all cost
1463 tasklet_schedule(&acm
->urb_task
);
1467 mutex_unlock(&acm
->mutex
);
1471 #endif /* CONFIG_PM */
1473 #define NOKIA_PCSUITE_ACM_INFO(x) \
1474 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1475 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1476 USB_CDC_ACM_PROTO_VENDOR)
1479 * USB driver structure.
1482 static struct usb_device_id acm_ids
[] = {
1483 /* quirky and broken devices */
1484 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1485 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1487 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1488 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1490 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1491 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1493 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1494 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1496 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1497 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1499 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1500 .driver_info
= SINGLE_RX_URB
,
1502 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1503 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1505 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1506 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1508 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1509 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1511 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1512 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1514 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1515 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1517 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1518 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1520 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1521 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1523 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1525 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1526 .driver_info
= NO_UNION_NORMAL
, /* union descriptor misplaced on
1527 data interface instead of
1528 communications interface.
1529 Maybe we should define a new
1532 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1533 .driver_info
= NO_UNION_NORMAL
, /* reports zero length descriptor */
1536 /* Nokia S60 phones expose two ACM channels. The first is
1537 * a modem and is picked up by the standard AT-command
1538 * information below. The second is 'vendor-specific' but
1539 * is treated as a serial device at the S60 end, so we want
1540 * to expose it on Linux too. */
1541 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1542 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1543 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1544 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1545 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1546 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1547 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1548 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1549 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1550 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1551 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1552 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1553 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1556 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1559 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1561 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1562 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1563 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1564 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1565 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1573 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1577 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1582 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1583 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1585 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1587 /* control interfaces with various AT-command sets */
1588 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1589 USB_CDC_ACM_PROTO_AT_V25TER
) },
1590 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1591 USB_CDC_ACM_PROTO_AT_PCCA101
) },
1592 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1593 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE
) },
1594 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1595 USB_CDC_ACM_PROTO_AT_GSM
) },
1596 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1597 USB_CDC_ACM_PROTO_AT_3G
) },
1598 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1599 USB_CDC_ACM_PROTO_AT_CDMA
) },
1604 MODULE_DEVICE_TABLE(usb
, acm_ids
);
1606 static struct usb_driver acm_driver
= {
1609 .disconnect
= acm_disconnect
,
1611 .suspend
= acm_suspend
,
1612 .resume
= acm_resume
,
1614 .id_table
= acm_ids
,
1616 .supports_autosuspend
= 1,
1621 * TTY driver structures.
1624 static const struct tty_operations acm_ops
= {
1625 .open
= acm_tty_open
,
1626 .close
= acm_tty_close
,
1627 .hangup
= acm_tty_hangup
,
1628 .write
= acm_tty_write
,
1629 .write_room
= acm_tty_write_room
,
1630 .ioctl
= acm_tty_ioctl
,
1631 .throttle
= acm_tty_throttle
,
1632 .unthrottle
= acm_tty_unthrottle
,
1633 .chars_in_buffer
= acm_tty_chars_in_buffer
,
1634 .break_ctl
= acm_tty_break_ctl
,
1635 .set_termios
= acm_tty_set_termios
,
1636 .tiocmget
= acm_tty_tiocmget
,
1637 .tiocmset
= acm_tty_tiocmset
,
1644 static int __init
acm_init(void)
1647 acm_tty_driver
= alloc_tty_driver(ACM_TTY_MINORS
);
1648 if (!acm_tty_driver
)
1650 acm_tty_driver
->owner
= THIS_MODULE
,
1651 acm_tty_driver
->driver_name
= "acm",
1652 acm_tty_driver
->name
= "ttyACM",
1653 acm_tty_driver
->major
= ACM_TTY_MAJOR
,
1654 acm_tty_driver
->minor_start
= 0,
1655 acm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
,
1656 acm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
,
1657 acm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1658 acm_tty_driver
->init_termios
= tty_std_termios
;
1659 acm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
|
1661 tty_set_operations(acm_tty_driver
, &acm_ops
);
1663 retval
= tty_register_driver(acm_tty_driver
);
1665 put_tty_driver(acm_tty_driver
);
1669 retval
= usb_register(&acm_driver
);
1671 tty_unregister_driver(acm_tty_driver
);
1672 put_tty_driver(acm_tty_driver
);
1676 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1682 static void __exit
acm_exit(void)
1684 usb_deregister(&acm_driver
);
1685 tty_unregister_driver(acm_tty_driver
);
1686 put_tty_driver(acm_tty_driver
);
1689 module_init(acm_init
);
1690 module_exit(acm_exit
);
1692 MODULE_AUTHOR(DRIVER_AUTHOR
);
1693 MODULE_DESCRIPTION(DRIVER_DESC
);
1694 MODULE_LICENSE("GPL");
1695 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR
);