4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
6 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
7 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
9 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
11 * USB Abstract Control Model driver for USB modems and ISDN adapters
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 #include <linux/kernel.h>
34 #include <linux/errno.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/tty.h>
38 #include <linux/serial.h>
39 #include <linux/tty_driver.h>
40 #include <linux/tty_flip.h>
41 #include <linux/module.h>
42 #include <linux/mutex.h>
43 #include <linux/uaccess.h>
44 #include <linux/usb.h>
45 #include <linux/usb/cdc.h>
46 #include <asm/byteorder.h>
47 #include <asm/unaligned.h>
48 #include <linux/list.h>
53 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
56 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
57 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
59 static struct usb_driver acm_driver
;
60 static struct tty_driver
*acm_tty_driver
;
61 static struct acm
*acm_table
[ACM_TTY_MINORS
];
63 static DEFINE_MUTEX(open_mutex
);
65 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
67 static const struct tty_port_operations acm_port_ops
= {
71 * Functions for ACM control messages.
74 static int acm_ctrl_msg(struct acm
*acm
, int request
, int value
,
77 int retval
= usb_control_msg(acm
->dev
, usb_sndctrlpipe(acm
->dev
, 0),
78 request
, USB_RT_ACM
, value
,
79 acm
->control
->altsetting
[0].desc
.bInterfaceNumber
,
81 dev_dbg(&acm
->control
->dev
,
82 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
83 __func__
, request
, value
, len
, retval
);
84 return retval
< 0 ? retval
: 0;
87 /* devices aren't required to support these requests.
88 * the cdc acm descriptor tells whether they do...
90 #define acm_set_control(acm, control) \
91 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
92 #define acm_set_line(acm, line) \
93 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
94 #define acm_send_break(acm, ms) \
95 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
98 * Write buffer management.
99 * All of these assume proper locks taken by the caller.
102 static int acm_wb_alloc(struct acm
*acm
)
115 wbn
= (wbn
+ 1) % ACM_NW
;
121 static int acm_wb_is_avail(struct acm
*acm
)
127 spin_lock_irqsave(&acm
->write_lock
, flags
);
128 for (i
= 0; i
< ACM_NW
; i
++)
130 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
135 * Finish write. Caller must hold acm->write_lock
137 static void acm_write_done(struct acm
*acm
, struct acm_wb
*wb
)
141 usb_autopm_put_interface_async(acm
->control
);
147 * the caller is responsible for locking
150 static int acm_start_wb(struct acm
*acm
, struct acm_wb
*wb
)
156 wb
->urb
->transfer_buffer
= wb
->buf
;
157 wb
->urb
->transfer_dma
= wb
->dmah
;
158 wb
->urb
->transfer_buffer_length
= wb
->len
;
159 wb
->urb
->dev
= acm
->dev
;
161 rc
= usb_submit_urb(wb
->urb
, GFP_ATOMIC
);
163 dev_err(&acm
->data
->dev
,
164 "%s - usb_submit_urb(write bulk) failed: %d\n",
166 acm_write_done(acm
, wb
);
171 static int acm_write_start(struct acm
*acm
, int wbn
)
174 struct acm_wb
*wb
= &acm
->wb
[wbn
];
177 spin_lock_irqsave(&acm
->write_lock
, flags
);
180 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
184 dev_vdbg(&acm
->data
->dev
, "%s - susp_count %d\n", __func__
,
186 usb_autopm_get_interface_async(acm
->control
);
187 if (acm
->susp_count
) {
188 if (!acm
->delayed_wb
)
189 acm
->delayed_wb
= wb
;
191 usb_autopm_put_interface_async(acm
->control
);
192 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
193 return 0; /* A white lie */
195 usb_mark_last_busy(acm
->dev
);
197 rc
= acm_start_wb(acm
, wb
);
198 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
204 * attributes exported through sysfs
206 static ssize_t show_caps
207 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
209 struct usb_interface
*intf
= to_usb_interface(dev
);
210 struct acm
*acm
= usb_get_intfdata(intf
);
212 return sprintf(buf
, "%d", acm
->ctrl_caps
);
214 static DEVICE_ATTR(bmCapabilities
, S_IRUGO
, show_caps
, NULL
);
216 static ssize_t show_country_codes
217 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
219 struct usb_interface
*intf
= to_usb_interface(dev
);
220 struct acm
*acm
= usb_get_intfdata(intf
);
222 memcpy(buf
, acm
->country_codes
, acm
->country_code_size
);
223 return acm
->country_code_size
;
226 static DEVICE_ATTR(wCountryCodes
, S_IRUGO
, show_country_codes
, NULL
);
228 static ssize_t show_country_rel_date
229 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
231 struct usb_interface
*intf
= to_usb_interface(dev
);
232 struct acm
*acm
= usb_get_intfdata(intf
);
234 return sprintf(buf
, "%d", acm
->country_rel_date
);
237 static DEVICE_ATTR(iCountryCodeRelDate
, S_IRUGO
, show_country_rel_date
, NULL
);
239 * Interrupt handlers for various ACM device responses
242 /* control interface reports status changes with "interrupt" transfers */
243 static void acm_ctrl_irq(struct urb
*urb
)
245 struct acm
*acm
= urb
->context
;
246 struct usb_cdc_notification
*dr
= urb
->transfer_buffer
;
247 struct tty_struct
*tty
;
251 int status
= urb
->status
;
260 /* this urb is terminated, clean up */
261 dev_dbg(&acm
->control
->dev
,
262 "%s - urb shutting down with status: %d\n",
266 dev_dbg(&acm
->control
->dev
,
267 "%s - nonzero urb status received: %d\n",
275 usb_mark_last_busy(acm
->dev
);
277 data
= (unsigned char *)(dr
+ 1);
278 switch (dr
->bNotificationType
) {
279 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
280 dev_dbg(&acm
->control
->dev
, "%s - network connection: %d\n",
281 __func__
, dr
->wValue
);
284 case USB_CDC_NOTIFY_SERIAL_STATE
:
285 tty
= tty_port_tty_get(&acm
->port
);
286 newctrl
= get_unaligned_le16(data
);
290 (acm
->ctrlin
& ~newctrl
& ACM_CTRL_DCD
)) {
291 dev_dbg(&acm
->control
->dev
,
292 "%s - calling hangup\n", __func__
);
298 acm
->ctrlin
= newctrl
;
300 dev_dbg(&acm
->control
->dev
,
301 "%s - input control lines: dcd%c dsr%c break%c "
302 "ring%c framing%c parity%c overrun%c\n",
304 acm
->ctrlin
& ACM_CTRL_DCD
? '+' : '-',
305 acm
->ctrlin
& ACM_CTRL_DSR
? '+' : '-',
306 acm
->ctrlin
& ACM_CTRL_BRK
? '+' : '-',
307 acm
->ctrlin
& ACM_CTRL_RI
? '+' : '-',
308 acm
->ctrlin
& ACM_CTRL_FRAMING
? '+' : '-',
309 acm
->ctrlin
& ACM_CTRL_PARITY
? '+' : '-',
310 acm
->ctrlin
& ACM_CTRL_OVERRUN
? '+' : '-');
314 dev_dbg(&acm
->control
->dev
,
315 "%s - unknown notification %d received: index %d "
316 "len %d data0 %d data1 %d\n",
318 dr
->bNotificationType
, dr
->wIndex
,
319 dr
->wLength
, data
[0], data
[1]);
323 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
325 dev_err(&acm
->control
->dev
, "%s - usb_submit_urb failed: %d\n",
329 /* data interface returns incoming bytes, or we got unthrottled */
330 static void acm_read_bulk(struct urb
*urb
)
333 struct acm_ru
*rcv
= urb
->context
;
334 struct acm
*acm
= rcv
->instance
;
335 int status
= urb
->status
;
337 dev_vdbg(&acm
->data
->dev
, "%s - status %d\n", __func__
, status
);
339 if (!ACM_READY(acm
)) {
340 dev_dbg(&acm
->data
->dev
, "%s - acm not ready\n", __func__
);
343 usb_mark_last_busy(acm
->dev
);
346 dev_dbg(&acm
->data
->dev
, "%s - non-zero urb status: %d\n",
350 buf
->size
= urb
->actual_length
;
352 if (likely(status
== 0)) {
353 spin_lock(&acm
->read_lock
);
355 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
356 list_add_tail(&buf
->list
, &acm
->filled_read_bufs
);
357 spin_unlock(&acm
->read_lock
);
359 /* we drop the buffer due to an error */
360 spin_lock(&acm
->read_lock
);
361 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
362 list_add(&buf
->list
, &acm
->spare_read_bufs
);
363 spin_unlock(&acm
->read_lock
);
364 /* nevertheless the tasklet must be kicked unconditionally
365 so the queue cannot dry up */
367 if (likely(!acm
->susp_count
))
368 tasklet_schedule(&acm
->urb_task
);
371 static void acm_rx_tasklet(unsigned long _acm
)
373 struct acm
*acm
= (void *)_acm
;
375 struct tty_struct
*tty
;
378 unsigned char throttled
;
380 dev_vdbg(&acm
->data
->dev
, "%s\n", __func__
);
382 if (!ACM_READY(acm
)) {
383 dev_dbg(&acm
->data
->dev
, "%s - acm not ready\n", __func__
);
387 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
388 throttled
= acm
->throttle
;
389 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
391 dev_dbg(&acm
->data
->dev
, "%s - throttled\n", __func__
);
395 tty
= tty_port_tty_get(&acm
->port
);
398 spin_lock_irqsave(&acm
->read_lock
, flags
);
399 if (list_empty(&acm
->filled_read_bufs
)) {
400 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
403 buf
= list_entry(acm
->filled_read_bufs
.next
,
404 struct acm_rb
, list
);
405 list_del(&buf
->list
);
406 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
408 dev_vdbg(&acm
->data
->dev
, "%s - processing buf 0x%p, size = %d\n",
409 __func__
, buf
, buf
->size
);
411 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
412 throttled
= acm
->throttle
;
413 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
415 tty_insert_flip_string(tty
, buf
->base
, buf
->size
);
416 tty_flip_buffer_push(tty
);
419 dev_dbg(&acm
->data
->dev
, "%s - throttling noticed\n",
421 spin_lock_irqsave(&acm
->read_lock
, flags
);
422 list_add(&buf
->list
, &acm
->filled_read_bufs
);
423 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
428 spin_lock_irqsave(&acm
->read_lock
, flags
);
429 list_add(&buf
->list
, &acm
->spare_read_bufs
);
430 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
436 while (!list_empty(&acm
->spare_read_bufs
)) {
437 spin_lock_irqsave(&acm
->read_lock
, flags
);
438 if (list_empty(&acm
->spare_read_urbs
)) {
440 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
443 rcv
= list_entry(acm
->spare_read_urbs
.next
,
444 struct acm_ru
, list
);
445 list_del(&rcv
->list
);
446 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
448 buf
= list_entry(acm
->spare_read_bufs
.next
,
449 struct acm_rb
, list
);
450 list_del(&buf
->list
);
455 usb_fill_int_urb(rcv
->urb
, acm
->dev
,
459 acm_read_bulk
, rcv
, acm
->bInterval
);
461 usb_fill_bulk_urb(rcv
->urb
, acm
->dev
,
466 rcv
->urb
->transfer_dma
= buf
->dma
;
467 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
469 /* This shouldn't kill the driver as unsuccessful URBs are
470 returned to the free-urbs-pool and resubmited ASAP */
471 spin_lock_irqsave(&acm
->read_lock
, flags
);
472 if (acm
->susp_count
||
473 usb_submit_urb(rcv
->urb
, GFP_ATOMIC
) < 0) {
474 list_add(&buf
->list
, &acm
->spare_read_bufs
);
475 list_add(&rcv
->list
, &acm
->spare_read_urbs
);
477 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
480 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
481 dev_vdbg(&acm
->data
->dev
,
482 "%s - sending urb 0x%p, rcv 0x%p, buf 0x%p\n",
483 __func__
, rcv
->urb
, rcv
, buf
);
486 spin_lock_irqsave(&acm
->read_lock
, flags
);
488 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
491 /* data interface wrote those outgoing bytes */
492 static void acm_write_bulk(struct urb
*urb
)
494 struct acm_wb
*wb
= urb
->context
;
495 struct acm
*acm
= wb
->instance
;
498 if (urb
->status
|| (urb
->actual_length
!= urb
->transfer_buffer_length
))
499 dev_vdbg(&acm
->data
->dev
, "%s - len %d/%d, status %d\n",
502 urb
->transfer_buffer_length
,
505 spin_lock_irqsave(&acm
->write_lock
, flags
);
506 acm_write_done(acm
, wb
);
507 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
509 schedule_work(&acm
->work
);
511 wake_up_interruptible(&acm
->drain_wait
);
514 static void acm_softint(struct work_struct
*work
)
516 struct acm
*acm
= container_of(work
, struct acm
, work
);
517 struct tty_struct
*tty
;
519 dev_vdbg(&acm
->data
->dev
, "%s\n", __func__
);
523 tty
= tty_port_tty_get(&acm
->port
);
534 static int acm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
540 mutex_lock(&open_mutex
);
542 acm
= acm_table
[tty
->index
];
543 if (!acm
|| !acm
->dev
)
548 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
550 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
552 tty
->driver_data
= acm
;
553 tty_port_tty_set(&acm
->port
, tty
);
555 if (usb_autopm_get_interface(acm
->control
) < 0)
558 acm
->control
->needs_remote_wakeup
= 1;
560 mutex_lock(&acm
->mutex
);
561 if (acm
->port
.count
++) {
562 mutex_unlock(&acm
->mutex
);
563 usb_autopm_put_interface(acm
->control
);
567 acm
->ctrlurb
->dev
= acm
->dev
;
568 if (usb_submit_urb(acm
->ctrlurb
, GFP_KERNEL
)) {
569 dev_err(&acm
->control
->dev
,
570 "%s - usb_submit_urb(ctrl irq) failed\n", __func__
);
574 if (0 > acm_set_control(acm
, acm
->ctrlout
= ACM_CTRL_DTR
| ACM_CTRL_RTS
) &&
575 (acm
->ctrl_caps
& USB_CDC_CAP_LINE
))
578 usb_autopm_put_interface(acm
->control
);
580 INIT_LIST_HEAD(&acm
->spare_read_urbs
);
581 INIT_LIST_HEAD(&acm
->spare_read_bufs
);
582 INIT_LIST_HEAD(&acm
->filled_read_bufs
);
584 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
585 list_add(&(acm
->ru
[i
].list
), &acm
->spare_read_urbs
);
586 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
587 list_add(&(acm
->rb
[i
].list
), &acm
->spare_read_bufs
);
591 set_bit(ASYNCB_INITIALIZED
, &acm
->port
.flags
);
592 rv
= tty_port_block_til_ready(&acm
->port
, tty
, filp
);
593 tasklet_schedule(&acm
->urb_task
);
595 mutex_unlock(&acm
->mutex
);
597 mutex_unlock(&open_mutex
);
601 usb_kill_urb(acm
->ctrlurb
);
604 mutex_unlock(&acm
->mutex
);
605 usb_autopm_put_interface(acm
->control
);
607 mutex_unlock(&open_mutex
);
608 tty_port_tty_set(&acm
->port
, NULL
);
612 static void acm_tty_unregister(struct acm
*acm
)
616 nr
= acm
->rx_buflimit
;
617 tty_unregister_device(acm_tty_driver
, acm
->minor
);
618 usb_put_intf(acm
->control
);
619 acm_table
[acm
->minor
] = NULL
;
620 usb_free_urb(acm
->ctrlurb
);
621 for (i
= 0; i
< ACM_NW
; i
++)
622 usb_free_urb(acm
->wb
[i
].urb
);
623 for (i
= 0; i
< nr
; i
++)
624 usb_free_urb(acm
->ru
[i
].urb
);
625 kfree(acm
->country_codes
);
629 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
);
631 static void acm_port_down(struct acm
*acm
)
633 int i
, nr
= acm
->rx_buflimit
;
634 mutex_lock(&open_mutex
);
636 usb_autopm_get_interface(acm
->control
);
637 acm_set_control(acm
, acm
->ctrlout
= 0);
638 usb_kill_urb(acm
->ctrlurb
);
639 for (i
= 0; i
< ACM_NW
; i
++)
640 usb_kill_urb(acm
->wb
[i
].urb
);
641 tasklet_disable(&acm
->urb_task
);
642 for (i
= 0; i
< nr
; i
++)
643 usb_kill_urb(acm
->ru
[i
].urb
);
644 tasklet_enable(&acm
->urb_task
);
645 acm
->control
->needs_remote_wakeup
= 0;
646 usb_autopm_put_interface(acm
->control
);
648 mutex_unlock(&open_mutex
);
651 static void acm_tty_hangup(struct tty_struct
*tty
)
653 struct acm
*acm
= tty
->driver_data
;
654 tty_port_hangup(&acm
->port
);
658 static void acm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
660 struct acm
*acm
= tty
->driver_data
;
662 /* Perform the closing process and see if we need to do the hardware
666 if (tty_port_close_start(&acm
->port
, tty
, filp
) == 0) {
667 mutex_lock(&open_mutex
);
669 tty_port_tty_set(&acm
->port
, NULL
);
670 acm_tty_unregister(acm
);
671 tty
->driver_data
= NULL
;
673 mutex_unlock(&open_mutex
);
677 tty_port_close_end(&acm
->port
, tty
);
678 tty_port_tty_set(&acm
->port
, NULL
);
681 static int acm_tty_write(struct tty_struct
*tty
,
682 const unsigned char *buf
, int count
)
684 struct acm
*acm
= tty
->driver_data
;
695 dev_vdbg(&acm
->data
->dev
, "%s - count %d\n", __func__
, count
);
697 spin_lock_irqsave(&acm
->write_lock
, flags
);
698 wbn
= acm_wb_alloc(acm
);
700 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
705 count
= (count
> acm
->writesize
) ? acm
->writesize
: count
;
706 dev_vdbg(&acm
->data
->dev
, "%s - write %d\n", __func__
, count
);
707 memcpy(wb
->buf
, buf
, count
);
709 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
711 stat
= acm_write_start(acm
, wbn
);
717 static int acm_tty_write_room(struct tty_struct
*tty
)
719 struct acm
*acm
= tty
->driver_data
;
723 * Do not let the line discipline to know that we have a reserve,
724 * or it might get too enthusiastic.
726 return acm_wb_is_avail(acm
) ? acm
->writesize
: 0;
729 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
)
731 struct acm
*acm
= tty
->driver_data
;
735 * This is inaccurate (overcounts), but it works.
737 return (ACM_NW
- acm_wb_is_avail(acm
)) * acm
->writesize
;
740 static void acm_tty_throttle(struct tty_struct
*tty
)
742 struct acm
*acm
= tty
->driver_data
;
745 spin_lock_bh(&acm
->throttle_lock
);
747 spin_unlock_bh(&acm
->throttle_lock
);
750 static void acm_tty_unthrottle(struct tty_struct
*tty
)
752 struct acm
*acm
= tty
->driver_data
;
755 spin_lock_bh(&acm
->throttle_lock
);
757 spin_unlock_bh(&acm
->throttle_lock
);
758 tasklet_schedule(&acm
->urb_task
);
761 static int acm_tty_break_ctl(struct tty_struct
*tty
, int state
)
763 struct acm
*acm
= tty
->driver_data
;
767 retval
= acm_send_break(acm
, state
? 0xffff : 0);
769 dev_dbg(&acm
->control
->dev
, "%s - send break failed\n",
774 static int acm_tty_tiocmget(struct tty_struct
*tty
)
776 struct acm
*acm
= tty
->driver_data
;
781 return (acm
->ctrlout
& ACM_CTRL_DTR
? TIOCM_DTR
: 0) |
782 (acm
->ctrlout
& ACM_CTRL_RTS
? TIOCM_RTS
: 0) |
783 (acm
->ctrlin
& ACM_CTRL_DSR
? TIOCM_DSR
: 0) |
784 (acm
->ctrlin
& ACM_CTRL_RI
? TIOCM_RI
: 0) |
785 (acm
->ctrlin
& ACM_CTRL_DCD
? TIOCM_CD
: 0) |
789 static int acm_tty_tiocmset(struct tty_struct
*tty
,
790 unsigned int set
, unsigned int clear
)
792 struct acm
*acm
= tty
->driver_data
;
793 unsigned int newctrl
;
798 newctrl
= acm
->ctrlout
;
799 set
= (set
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
800 (set
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
801 clear
= (clear
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) |
802 (clear
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
804 newctrl
= (newctrl
& ~clear
) | set
;
806 if (acm
->ctrlout
== newctrl
)
808 return acm_set_control(acm
, acm
->ctrlout
= newctrl
);
811 static int acm_tty_ioctl(struct tty_struct
*tty
,
812 unsigned int cmd
, unsigned long arg
)
814 struct acm
*acm
= tty
->driver_data
;
822 static const __u32 acm_tty_speed
[] = {
823 0, 50, 75, 110, 134, 150, 200, 300, 600,
824 1200, 1800, 2400, 4800, 9600, 19200, 38400,
825 57600, 115200, 230400, 460800, 500000, 576000,
826 921600, 1000000, 1152000, 1500000, 2000000,
827 2500000, 3000000, 3500000, 4000000
830 static const __u8 acm_tty_size
[] = {
834 static void acm_tty_set_termios(struct tty_struct
*tty
,
835 struct ktermios
*termios_old
)
837 struct acm
*acm
= tty
->driver_data
;
838 struct ktermios
*termios
= tty
->termios
;
839 struct usb_cdc_line_coding newline
;
840 int newctrl
= acm
->ctrlout
;
845 newline
.dwDTERate
= cpu_to_le32(tty_get_baud_rate(tty
));
846 newline
.bCharFormat
= termios
->c_cflag
& CSTOPB
? 2 : 0;
847 newline
.bParityType
= termios
->c_cflag
& PARENB
?
848 (termios
->c_cflag
& PARODD
? 1 : 2) +
849 (termios
->c_cflag
& CMSPAR
? 2 : 0) : 0;
850 newline
.bDataBits
= acm_tty_size
[(termios
->c_cflag
& CSIZE
) >> 4];
851 /* FIXME: Needs to clear unsupported bits in the termios */
852 acm
->clocal
= ((termios
->c_cflag
& CLOCAL
) != 0);
854 if (!newline
.dwDTERate
) {
855 newline
.dwDTERate
= acm
->line
.dwDTERate
;
856 newctrl
&= ~ACM_CTRL_DTR
;
858 newctrl
|= ACM_CTRL_DTR
;
860 if (newctrl
!= acm
->ctrlout
)
861 acm_set_control(acm
, acm
->ctrlout
= newctrl
);
863 if (memcmp(&acm
->line
, &newline
, sizeof newline
)) {
864 memcpy(&acm
->line
, &newline
, sizeof newline
);
865 dev_dbg(&acm
->control
->dev
, "%s - set line: %d %d %d %d\n",
867 le32_to_cpu(newline
.dwDTERate
),
868 newline
.bCharFormat
, newline
.bParityType
,
870 acm_set_line(acm
, &acm
->line
);
875 * USB probe and disconnect routines.
878 /* Little helpers: write/read buffers free */
879 static void acm_write_buffers_free(struct acm
*acm
)
883 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
885 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++)
886 usb_free_coherent(usb_dev
, acm
->writesize
, wb
->buf
, wb
->dmah
);
889 static void acm_read_buffers_free(struct acm
*acm
)
891 struct usb_device
*usb_dev
= interface_to_usbdev(acm
->control
);
892 int i
, n
= acm
->rx_buflimit
;
894 for (i
= 0; i
< n
; i
++)
895 usb_free_coherent(usb_dev
, acm
->readsize
,
896 acm
->rb
[i
].base
, acm
->rb
[i
].dma
);
899 /* Little helper: write buffers allocate */
900 static int acm_write_buffers_alloc(struct acm
*acm
)
905 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
906 wb
->buf
= usb_alloc_coherent(acm
->dev
, acm
->writesize
, GFP_KERNEL
,
912 usb_free_coherent(acm
->dev
, acm
->writesize
,
921 static int acm_probe(struct usb_interface
*intf
,
922 const struct usb_device_id
*id
)
924 struct usb_cdc_union_desc
*union_header
= NULL
;
925 struct usb_cdc_country_functional_desc
*cfd
= NULL
;
926 unsigned char *buffer
= intf
->altsetting
->extra
;
927 int buflen
= intf
->altsetting
->extralen
;
928 struct usb_interface
*control_interface
;
929 struct usb_interface
*data_interface
;
930 struct usb_endpoint_descriptor
*epctrl
= NULL
;
931 struct usb_endpoint_descriptor
*epread
= NULL
;
932 struct usb_endpoint_descriptor
*epwrite
= NULL
;
933 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
936 int ctrlsize
, readsize
;
938 u8 ac_management_function
= 0;
939 u8 call_management_function
= 0;
940 int call_interface_num
= -1;
941 int data_interface_num
;
942 unsigned long quirks
;
945 int combined_interfaces
= 0;
948 quirks
= (unsigned long)id
->driver_info
;
949 num_rx_buf
= (quirks
== SINGLE_RX_URB
) ? 1 : ACM_NR
;
951 /* handle quirks deadly to normal probing*/
952 if (quirks
== NO_UNION_NORMAL
) {
953 data_interface
= usb_ifnum_to_if(usb_dev
, 1);
954 control_interface
= usb_ifnum_to_if(usb_dev
, 0);
955 goto skip_normal_probe
;
960 dev_err(&intf
->dev
, "Weird descriptor references\n");
965 if (intf
->cur_altsetting
->endpoint
&&
966 intf
->cur_altsetting
->endpoint
->extralen
&&
967 intf
->cur_altsetting
->endpoint
->extra
) {
969 "Seeking extra descriptors on endpoint\n");
970 buflen
= intf
->cur_altsetting
->endpoint
->extralen
;
971 buffer
= intf
->cur_altsetting
->endpoint
->extra
;
974 "Zero length descriptor references\n");
980 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
981 dev_err(&intf
->dev
, "skipping garbage\n");
986 case USB_CDC_UNION_TYPE
: /* we've found it */
988 dev_err(&intf
->dev
, "More than one "
989 "union descriptor, skipping ...\n");
992 union_header
= (struct usb_cdc_union_desc
*)buffer
;
994 case USB_CDC_COUNTRY_TYPE
: /* export through sysfs*/
995 cfd
= (struct usb_cdc_country_functional_desc
*)buffer
;
997 case USB_CDC_HEADER_TYPE
: /* maybe check version */
998 break; /* for now we ignore it */
999 case USB_CDC_ACM_TYPE
:
1000 ac_management_function
= buffer
[3];
1002 case USB_CDC_CALL_MANAGEMENT_TYPE
:
1003 call_management_function
= buffer
[3];
1004 call_interface_num
= buffer
[4];
1005 if ( (quirks
& NOT_A_MODEM
) == 0 && (call_management_function
& 3) != 3)
1006 dev_err(&intf
->dev
, "This device cannot do calls on its own. It is not a modem.\n");
1009 /* there are LOTS more CDC descriptors that
1010 * could legitimately be found here.
1012 dev_dbg(&intf
->dev
, "Ignoring descriptor: "
1013 "type %02x, length %d\n",
1014 buffer
[2], buffer
[0]);
1018 buflen
-= buffer
[0];
1019 buffer
+= buffer
[0];
1022 if (!union_header
) {
1023 if (call_interface_num
> 0) {
1024 dev_dbg(&intf
->dev
, "No union descriptor, using call management descriptor\n");
1025 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= call_interface_num
));
1026 control_interface
= intf
;
1028 if (intf
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1029 dev_dbg(&intf
->dev
,"No union descriptor, giving up\n");
1032 dev_warn(&intf
->dev
,"No union descriptor, testing for castrated device\n");
1033 combined_interfaces
= 1;
1034 control_interface
= data_interface
= intf
;
1035 goto look_for_collapsed_interface
;
1039 control_interface
= usb_ifnum_to_if(usb_dev
, union_header
->bMasterInterface0
);
1040 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= union_header
->bSlaveInterface0
));
1041 if (!control_interface
|| !data_interface
) {
1042 dev_dbg(&intf
->dev
, "no interfaces\n");
1047 if (data_interface_num
!= call_interface_num
)
1048 dev_dbg(&intf
->dev
, "Separate call control interface. That is not fully supported.\n");
1050 if (control_interface
== data_interface
) {
1051 /* some broken devices designed for windows work this way */
1052 dev_warn(&intf
->dev
,"Control and data interfaces are not separated!\n");
1053 combined_interfaces
= 1;
1054 /* a popular other OS doesn't use it */
1055 quirks
|= NO_CAP_LINE
;
1056 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
!= 3) {
1057 dev_err(&intf
->dev
, "This needs exactly 3 endpoints\n");
1060 look_for_collapsed_interface
:
1061 for (i
= 0; i
< 3; i
++) {
1062 struct usb_endpoint_descriptor
*ep
;
1063 ep
= &data_interface
->cur_altsetting
->endpoint
[i
].desc
;
1065 if (usb_endpoint_is_int_in(ep
))
1067 else if (usb_endpoint_is_bulk_out(ep
))
1069 else if (usb_endpoint_is_bulk_in(ep
))
1074 if (!epctrl
|| !epread
|| !epwrite
)
1077 goto made_compressed_probe
;
1082 /*workaround for switched interfaces */
1083 if (data_interface
->cur_altsetting
->desc
.bInterfaceClass
1084 != CDC_DATA_INTERFACE_TYPE
) {
1085 if (control_interface
->cur_altsetting
->desc
.bInterfaceClass
1086 == CDC_DATA_INTERFACE_TYPE
) {
1087 struct usb_interface
*t
;
1089 "Your device has switched interfaces.\n");
1090 t
= control_interface
;
1091 control_interface
= data_interface
;
1098 /* Accept probe requests only for the control interface */
1099 if (!combined_interfaces
&& intf
!= control_interface
)
1102 if (!combined_interfaces
&& usb_interface_claimed(data_interface
)) {
1103 /* valid in this context */
1104 dev_dbg(&intf
->dev
, "The data interface isn't available\n");
1109 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
< 2)
1112 epctrl
= &control_interface
->cur_altsetting
->endpoint
[0].desc
;
1113 epread
= &data_interface
->cur_altsetting
->endpoint
[0].desc
;
1114 epwrite
= &data_interface
->cur_altsetting
->endpoint
[1].desc
;
1117 /* workaround for switched endpoints */
1118 if (!usb_endpoint_dir_in(epread
)) {
1119 /* descriptors are swapped */
1120 struct usb_endpoint_descriptor
*t
;
1122 "The data interface has switched endpoints\n");
1127 made_compressed_probe
:
1128 dev_dbg(&intf
->dev
, "interfaces are valid\n");
1129 for (minor
= 0; minor
< ACM_TTY_MINORS
&& acm_table
[minor
]; minor
++);
1131 if (minor
== ACM_TTY_MINORS
) {
1132 dev_err(&intf
->dev
, "no more free acm devices\n");
1136 acm
= kzalloc(sizeof(struct acm
), GFP_KERNEL
);
1138 dev_err(&intf
->dev
, "out of memory (acm kzalloc)\n");
1142 ctrlsize
= le16_to_cpu(epctrl
->wMaxPacketSize
);
1143 readsize
= le16_to_cpu(epread
->wMaxPacketSize
) *
1144 (quirks
== SINGLE_RX_URB
? 1 : 2);
1145 acm
->combined_interfaces
= combined_interfaces
;
1146 acm
->writesize
= le16_to_cpu(epwrite
->wMaxPacketSize
) * 20;
1147 acm
->control
= control_interface
;
1148 acm
->data
= data_interface
;
1151 acm
->ctrl_caps
= ac_management_function
;
1152 if (quirks
& NO_CAP_LINE
)
1153 acm
->ctrl_caps
&= ~USB_CDC_CAP_LINE
;
1154 acm
->ctrlsize
= ctrlsize
;
1155 acm
->readsize
= readsize
;
1156 acm
->rx_buflimit
= num_rx_buf
;
1157 acm
->urb_task
.func
= acm_rx_tasklet
;
1158 acm
->urb_task
.data
= (unsigned long) acm
;
1159 INIT_WORK(&acm
->work
, acm_softint
);
1160 init_waitqueue_head(&acm
->drain_wait
);
1161 spin_lock_init(&acm
->throttle_lock
);
1162 spin_lock_init(&acm
->write_lock
);
1163 spin_lock_init(&acm
->read_lock
);
1164 mutex_init(&acm
->mutex
);
1165 acm
->rx_endpoint
= usb_rcvbulkpipe(usb_dev
, epread
->bEndpointAddress
);
1166 acm
->is_int_ep
= usb_endpoint_xfer_int(epread
);
1168 acm
->bInterval
= epread
->bInterval
;
1169 tty_port_init(&acm
->port
);
1170 acm
->port
.ops
= &acm_port_ops
;
1172 buf
= usb_alloc_coherent(usb_dev
, ctrlsize
, GFP_KERNEL
, &acm
->ctrl_dma
);
1174 dev_err(&intf
->dev
, "out of memory (ctrl buffer alloc)\n");
1177 acm
->ctrl_buffer
= buf
;
1179 if (acm_write_buffers_alloc(acm
) < 0) {
1180 dev_err(&intf
->dev
, "out of memory (write buffer alloc)\n");
1184 acm
->ctrlurb
= usb_alloc_urb(0, GFP_KERNEL
);
1185 if (!acm
->ctrlurb
) {
1186 dev_err(&intf
->dev
, "out of memory (ctrlurb kmalloc)\n");
1189 for (i
= 0; i
< num_rx_buf
; i
++) {
1190 struct acm_ru
*rcv
= &(acm
->ru
[i
]);
1192 rcv
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1193 if (rcv
->urb
== NULL
) {
1195 "out of memory (read urbs usb_alloc_urb)\n");
1199 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1200 rcv
->instance
= acm
;
1202 for (i
= 0; i
< num_rx_buf
; i
++) {
1203 struct acm_rb
*rb
= &(acm
->rb
[i
]);
1205 rb
->base
= usb_alloc_coherent(acm
->dev
, readsize
,
1206 GFP_KERNEL
, &rb
->dma
);
1209 "out of memory (read bufs usb_alloc_coherent)\n");
1213 for (i
= 0; i
< ACM_NW
; i
++) {
1214 struct acm_wb
*snd
= &(acm
->wb
[i
]);
1216 snd
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
1217 if (snd
->urb
== NULL
) {
1219 "out of memory (write urbs usb_alloc_urb)\n");
1223 if (usb_endpoint_xfer_int(epwrite
))
1224 usb_fill_int_urb(snd
->urb
, usb_dev
,
1225 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1226 NULL
, acm
->writesize
, acm_write_bulk
, snd
, epwrite
->bInterval
);
1228 usb_fill_bulk_urb(snd
->urb
, usb_dev
,
1229 usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1230 NULL
, acm
->writesize
, acm_write_bulk
, snd
);
1231 snd
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1232 snd
->instance
= acm
;
1235 usb_set_intfdata(intf
, acm
);
1237 i
= device_create_file(&intf
->dev
, &dev_attr_bmCapabilities
);
1241 if (cfd
) { /* export the country data */
1242 acm
->country_codes
= kmalloc(cfd
->bLength
- 4, GFP_KERNEL
);
1243 if (!acm
->country_codes
)
1244 goto skip_countries
;
1245 acm
->country_code_size
= cfd
->bLength
- 4;
1246 memcpy(acm
->country_codes
, (u8
*)&cfd
->wCountyCode0
,
1248 acm
->country_rel_date
= cfd
->iCountryCodeRelDate
;
1250 i
= device_create_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1252 kfree(acm
->country_codes
);
1253 goto skip_countries
;
1256 i
= device_create_file(&intf
->dev
,
1257 &dev_attr_iCountryCodeRelDate
);
1259 device_remove_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1260 kfree(acm
->country_codes
);
1261 goto skip_countries
;
1266 usb_fill_int_urb(acm
->ctrlurb
, usb_dev
,
1267 usb_rcvintpipe(usb_dev
, epctrl
->bEndpointAddress
),
1268 acm
->ctrl_buffer
, ctrlsize
, acm_ctrl_irq
, acm
,
1269 /* works around buggy devices */
1270 epctrl
->bInterval
? epctrl
->bInterval
: 0xff);
1271 acm
->ctrlurb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1272 acm
->ctrlurb
->transfer_dma
= acm
->ctrl_dma
;
1274 dev_info(&intf
->dev
, "ttyACM%d: USB ACM device\n", minor
);
1276 acm_set_control(acm
, acm
->ctrlout
);
1278 acm
->line
.dwDTERate
= cpu_to_le32(9600);
1279 acm
->line
.bDataBits
= 8;
1280 acm_set_line(acm
, &acm
->line
);
1282 usb_driver_claim_interface(&acm_driver
, data_interface
, acm
);
1283 usb_set_intfdata(data_interface
, acm
);
1285 usb_get_intf(control_interface
);
1286 tty_register_device(acm_tty_driver
, minor
, &control_interface
->dev
);
1288 acm_table
[minor
] = acm
;
1292 for (i
= 0; i
< ACM_NW
; i
++)
1293 usb_free_urb(acm
->wb
[i
].urb
);
1295 acm_read_buffers_free(acm
);
1297 for (i
= 0; i
< num_rx_buf
; i
++)
1298 usb_free_urb(acm
->ru
[i
].urb
);
1299 usb_free_urb(acm
->ctrlurb
);
1301 acm_write_buffers_free(acm
);
1303 usb_free_coherent(usb_dev
, ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1310 static void stop_data_traffic(struct acm
*acm
)
1314 dev_dbg(&acm
->control
->dev
, "%s\n", __func__
);
1316 tasklet_disable(&acm
->urb_task
);
1318 usb_kill_urb(acm
->ctrlurb
);
1319 for (i
= 0; i
< ACM_NW
; i
++)
1320 usb_kill_urb(acm
->wb
[i
].urb
);
1321 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1322 usb_kill_urb(acm
->ru
[i
].urb
);
1324 tasklet_enable(&acm
->urb_task
);
1326 cancel_work_sync(&acm
->work
);
1329 static void acm_disconnect(struct usb_interface
*intf
)
1331 struct acm
*acm
= usb_get_intfdata(intf
);
1332 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1333 struct tty_struct
*tty
;
1335 /* sibling interface is already cleaning up */
1339 mutex_lock(&open_mutex
);
1340 if (acm
->country_codes
) {
1341 device_remove_file(&acm
->control
->dev
,
1342 &dev_attr_wCountryCodes
);
1343 device_remove_file(&acm
->control
->dev
,
1344 &dev_attr_iCountryCodeRelDate
);
1346 device_remove_file(&acm
->control
->dev
, &dev_attr_bmCapabilities
);
1348 usb_set_intfdata(acm
->control
, NULL
);
1349 usb_set_intfdata(acm
->data
, NULL
);
1351 stop_data_traffic(acm
);
1353 acm_write_buffers_free(acm
);
1354 usb_free_coherent(usb_dev
, acm
->ctrlsize
, acm
->ctrl_buffer
,
1356 acm_read_buffers_free(acm
);
1358 if (!acm
->combined_interfaces
)
1359 usb_driver_release_interface(&acm_driver
, intf
== acm
->control
?
1360 acm
->data
: acm
->control
);
1362 if (acm
->port
.count
== 0) {
1363 acm_tty_unregister(acm
);
1364 mutex_unlock(&open_mutex
);
1368 mutex_unlock(&open_mutex
);
1369 tty
= tty_port_tty_get(&acm
->port
);
1377 static int acm_suspend(struct usb_interface
*intf
, pm_message_t message
)
1379 struct acm
*acm
= usb_get_intfdata(intf
);
1382 if (message
.event
& PM_EVENT_AUTO
) {
1385 spin_lock_irq(&acm
->read_lock
);
1386 spin_lock(&acm
->write_lock
);
1387 b
= acm
->processing
+ acm
->transmitting
;
1388 spin_unlock(&acm
->write_lock
);
1389 spin_unlock_irq(&acm
->read_lock
);
1394 spin_lock_irq(&acm
->read_lock
);
1395 spin_lock(&acm
->write_lock
);
1396 cnt
= acm
->susp_count
++;
1397 spin_unlock(&acm
->write_lock
);
1398 spin_unlock_irq(&acm
->read_lock
);
1403 we treat opened interfaces differently,
1404 we must guard against open
1406 mutex_lock(&acm
->mutex
);
1408 if (acm
->port
.count
)
1409 stop_data_traffic(acm
);
1411 mutex_unlock(&acm
->mutex
);
1415 static int acm_resume(struct usb_interface
*intf
)
1417 struct acm
*acm
= usb_get_intfdata(intf
);
1422 spin_lock_irq(&acm
->read_lock
);
1423 acm
->susp_count
-= 1;
1424 cnt
= acm
->susp_count
;
1425 spin_unlock_irq(&acm
->read_lock
);
1430 mutex_lock(&acm
->mutex
);
1431 if (acm
->port
.count
) {
1432 rv
= usb_submit_urb(acm
->ctrlurb
, GFP_NOIO
);
1434 spin_lock_irq(&acm
->write_lock
);
1435 if (acm
->delayed_wb
) {
1436 wb
= acm
->delayed_wb
;
1437 acm
->delayed_wb
= NULL
;
1438 spin_unlock_irq(&acm
->write_lock
);
1439 acm_start_wb(acm
, wb
);
1441 spin_unlock_irq(&acm
->write_lock
);
1445 * delayed error checking because we must
1446 * do the write path at all cost
1451 tasklet_schedule(&acm
->urb_task
);
1455 mutex_unlock(&acm
->mutex
);
1459 static int acm_reset_resume(struct usb_interface
*intf
)
1461 struct acm
*acm
= usb_get_intfdata(intf
);
1462 struct tty_struct
*tty
;
1464 mutex_lock(&acm
->mutex
);
1465 if (acm
->port
.count
) {
1466 tty
= tty_port_tty_get(&acm
->port
);
1472 mutex_unlock(&acm
->mutex
);
1473 return acm_resume(intf
);
1476 #endif /* CONFIG_PM */
1478 #define NOKIA_PCSUITE_ACM_INFO(x) \
1479 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1480 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1481 USB_CDC_ACM_PROTO_VENDOR)
1483 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1484 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1485 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1486 USB_CDC_ACM_PROTO_VENDOR)
1489 * USB driver structure.
1492 static const struct usb_device_id acm_ids
[] = {
1493 /* quirky and broken devices */
1494 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1495 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1497 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1498 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1500 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1501 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1503 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1504 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1506 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1507 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1509 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1510 .driver_info
= SINGLE_RX_URB
,
1512 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1513 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1515 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1516 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1518 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1519 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1521 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1522 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1524 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1525 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1527 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1528 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1530 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1531 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1533 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1535 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1536 .driver_info
= NO_UNION_NORMAL
, /* union descriptor misplaced on
1537 data interface instead of
1538 communications interface.
1539 Maybe we should define a new
1542 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1543 .driver_info
= NO_UNION_NORMAL
, /* reports zero length descriptor */
1545 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1546 .driver_info
= NO_UNION_NORMAL
, /* reports zero length descriptor */
1549 /* Nokia S60 phones expose two ACM channels. The first is
1550 * a modem and is picked up by the standard AT-command
1551 * information below. The second is 'vendor-specific' but
1552 * is treated as a serial device at the S60 end, so we want
1553 * to expose it on Linux too. */
1554 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1555 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1556 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1561 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1569 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1572 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1573 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1574 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1575 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1576 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1577 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1578 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1582 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1583 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1584 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1585 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1586 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1587 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1590 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1594 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1596 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1597 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1598 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1601 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1602 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1605 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1606 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1609 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1611 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1613 /* Support Lego NXT using pbLua firmware */
1614 { USB_DEVICE(0x0694, 0xff00),
1615 .driver_info
= NOT_A_MODEM
,
1618 /* control interfaces without any protocol set */
1619 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1620 USB_CDC_PROTO_NONE
) },
1622 /* control interfaces with various AT-command sets */
1623 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1624 USB_CDC_ACM_PROTO_AT_V25TER
) },
1625 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1626 USB_CDC_ACM_PROTO_AT_PCCA101
) },
1627 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1628 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE
) },
1629 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1630 USB_CDC_ACM_PROTO_AT_GSM
) },
1631 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1632 USB_CDC_ACM_PROTO_AT_3G
) },
1633 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1634 USB_CDC_ACM_PROTO_AT_CDMA
) },
1639 MODULE_DEVICE_TABLE(usb
, acm_ids
);
1641 static struct usb_driver acm_driver
= {
1644 .disconnect
= acm_disconnect
,
1646 .suspend
= acm_suspend
,
1647 .resume
= acm_resume
,
1648 .reset_resume
= acm_reset_resume
,
1650 .id_table
= acm_ids
,
1652 .supports_autosuspend
= 1,
1657 * TTY driver structures.
1660 static const struct tty_operations acm_ops
= {
1661 .open
= acm_tty_open
,
1662 .close
= acm_tty_close
,
1663 .hangup
= acm_tty_hangup
,
1664 .write
= acm_tty_write
,
1665 .write_room
= acm_tty_write_room
,
1666 .ioctl
= acm_tty_ioctl
,
1667 .throttle
= acm_tty_throttle
,
1668 .unthrottle
= acm_tty_unthrottle
,
1669 .chars_in_buffer
= acm_tty_chars_in_buffer
,
1670 .break_ctl
= acm_tty_break_ctl
,
1671 .set_termios
= acm_tty_set_termios
,
1672 .tiocmget
= acm_tty_tiocmget
,
1673 .tiocmset
= acm_tty_tiocmset
,
1680 static int __init
acm_init(void)
1683 acm_tty_driver
= alloc_tty_driver(ACM_TTY_MINORS
);
1684 if (!acm_tty_driver
)
1686 acm_tty_driver
->owner
= THIS_MODULE
,
1687 acm_tty_driver
->driver_name
= "acm",
1688 acm_tty_driver
->name
= "ttyACM",
1689 acm_tty_driver
->major
= ACM_TTY_MAJOR
,
1690 acm_tty_driver
->minor_start
= 0,
1691 acm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
,
1692 acm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
,
1693 acm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1694 acm_tty_driver
->init_termios
= tty_std_termios
;
1695 acm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
|
1697 tty_set_operations(acm_tty_driver
, &acm_ops
);
1699 retval
= tty_register_driver(acm_tty_driver
);
1701 put_tty_driver(acm_tty_driver
);
1705 retval
= usb_register(&acm_driver
);
1707 tty_unregister_driver(acm_tty_driver
);
1708 put_tty_driver(acm_tty_driver
);
1712 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_DESC
"\n");
1717 static void __exit
acm_exit(void)
1719 usb_deregister(&acm_driver
);
1720 tty_unregister_driver(acm_tty_driver
);
1721 put_tty_driver(acm_tty_driver
);
1724 module_init(acm_init
);
1725 module_exit(acm_exit
);
1727 MODULE_AUTHOR(DRIVER_AUTHOR
);
1728 MODULE_DESCRIPTION(DRIVER_DESC
);
1729 MODULE_LICENSE("GPL");
1730 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR
);