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 kmalloced
20 * v0.13 - added termios, added hangup
21 * v0.14 - sized down struct acm
22 * v0.15 - fixed flow control again - characters could be lost
23 * v0.16 - added code for modems with swapped data and control interfaces
24 * v0.17 - added new style probing
25 * v0.18 - fixed new style probing for devices with more configurations
26 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
27 * v0.20 - switched to probing on interface (rather than device) class
28 * v0.21 - revert to probing on device for devices with multiple configs
29 * v0.22 - probe only the control interface. if usbcore doesn't choose the
30 * config we want, sysadmin changes bConfigurationValue in sysfs.
31 * v0.23 - use softirq for rx processing, as needed by tty layer
32 * v0.24 - change probe method to evaluate CDC union descriptor
33 * v0.25 - downstream tasks paralelized to maximize throughput
37 * This program is free software; you can redistribute it and/or modify
38 * it under the terms of the GNU General Public License as published by
39 * the Free Software Foundation; either version 2 of the License, or
40 * (at your option) any later version.
42 * This program is distributed in the hope that it will be useful,
43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 * GNU General Public License for more details.
47 * You should have received a copy of the GNU General Public License
48 * along with this program; if not, write to the Free Software
49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
54 #include <linux/kernel.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/tty.h>
59 #include <linux/tty_driver.h>
60 #include <linux/tty_flip.h>
61 #include <linux/module.h>
62 #include <linux/mutex.h>
63 #include <asm/uaccess.h>
64 #include <linux/usb.h>
65 #include <linux/usb/cdc.h>
66 #include <asm/byteorder.h>
67 #include <asm/unaligned.h>
68 #include <linux/list.h>
75 #define DRIVER_VERSION "v0.25"
76 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
77 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
79 static struct usb_driver acm_driver
;
80 static struct tty_driver
*acm_tty_driver
;
81 static struct acm
*acm_table
[ACM_TTY_MINORS
];
83 static DEFINE_MUTEX(open_mutex
);
85 #define ACM_READY(acm) (acm && acm->dev && acm->used)
88 * Functions for ACM control messages.
91 static int acm_ctrl_msg(struct acm
*acm
, int request
, int value
, void *buf
, int len
)
93 int retval
= usb_control_msg(acm
->dev
, usb_sndctrlpipe(acm
->dev
, 0),
94 request
, USB_RT_ACM
, value
,
95 acm
->control
->altsetting
[0].desc
.bInterfaceNumber
,
97 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request
, value
, len
, retval
);
98 return retval
< 0 ? retval
: 0;
101 /* devices aren't required to support these requests.
102 * the cdc acm descriptor tells whether they do...
104 #define acm_set_control(acm, control) \
105 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
106 #define acm_set_line(acm, line) \
107 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
108 #define acm_send_break(acm, ms) \
109 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
112 * Write buffer management.
113 * All of these assume proper locks taken by the caller.
116 static int acm_wb_alloc(struct acm
*acm
)
121 wbn
= acm
->write_current
;
129 wbn
= (wbn
+ 1) % ACM_NW
;
135 static void acm_wb_free(struct acm
*acm
, int wbn
)
137 acm
->wb
[wbn
].use
= 0;
140 static int acm_wb_is_avail(struct acm
*acm
)
145 for (i
= 0; i
< ACM_NW
; i
++) {
151 static inline int acm_wb_is_used(struct acm
*acm
, int wbn
)
153 return acm
->wb
[wbn
].use
;
159 static void acm_write_done(struct acm
*acm
)
164 spin_lock_irqsave(&acm
->write_lock
, flags
);
165 acm
->write_ready
= 1;
166 wbn
= acm
->write_current
;
167 acm_wb_free(acm
, wbn
);
168 acm
->write_current
= (wbn
+ 1) % ACM_NW
;
169 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
175 static int acm_write_start(struct acm
*acm
)
182 spin_lock_irqsave(&acm
->write_lock
, flags
);
184 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
188 if (!acm
->write_ready
) {
189 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
190 return 0; /* A white lie */
193 wbn
= acm
->write_current
;
194 if (!acm_wb_is_used(acm
, wbn
)) {
195 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
200 acm
->write_ready
= 0;
201 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
203 acm
->writeurb
->transfer_buffer
= wb
->buf
;
204 acm
->writeurb
->transfer_dma
= wb
->dmah
;
205 acm
->writeurb
->transfer_buffer_length
= wb
->len
;
206 acm
->writeurb
->dev
= acm
->dev
;
208 if ((rc
= usb_submit_urb(acm
->writeurb
, GFP_ATOMIC
)) < 0) {
209 dbg("usb_submit_urb(write bulk) failed: %d", rc
);
215 * attributes exported through sysfs
217 static ssize_t show_caps
218 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
220 struct usb_interface
*intf
= to_usb_interface(dev
);
221 struct acm
*acm
= usb_get_intfdata(intf
);
223 return sprintf(buf
, "%d", acm
->ctrl_caps
);
225 static DEVICE_ATTR(bmCapabilities
, S_IRUGO
, show_caps
, NULL
);
227 static ssize_t show_country_codes
228 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
230 struct usb_interface
*intf
= to_usb_interface(dev
);
231 struct acm
*acm
= usb_get_intfdata(intf
);
233 memcpy(buf
, acm
->country_codes
, acm
->country_code_size
);
234 return acm
->country_code_size
;
237 static DEVICE_ATTR(wCountryCodes
, S_IRUGO
, show_country_codes
, NULL
);
239 static ssize_t show_country_rel_date
240 (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
242 struct usb_interface
*intf
= to_usb_interface(dev
);
243 struct acm
*acm
= usb_get_intfdata(intf
);
245 return sprintf(buf
, "%d", acm
->country_rel_date
);
248 static DEVICE_ATTR(iCountryCodeRelDate
, S_IRUGO
, show_country_rel_date
, NULL
);
250 * Interrupt handlers for various ACM device responses
253 /* control interface reports status changes with "interrupt" transfers */
254 static void acm_ctrl_irq(struct urb
*urb
)
256 struct acm
*acm
= urb
->context
;
257 struct usb_cdc_notification
*dr
= urb
->transfer_buffer
;
261 int status
= urb
->status
;
270 /* this urb is terminated, clean up */
271 dbg("%s - urb shutting down with status: %d", __FUNCTION__
, status
);
274 dbg("%s - nonzero urb status received: %d", __FUNCTION__
, status
);
281 data
= (unsigned char *)(dr
+ 1);
282 switch (dr
->bNotificationType
) {
284 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
286 dbg("%s network", dr
->wValue
? "connected to" : "disconnected from");
289 case USB_CDC_NOTIFY_SERIAL_STATE
:
291 newctrl
= le16_to_cpu(get_unaligned((__le16
*) data
));
293 if (acm
->tty
&& !acm
->clocal
&& (acm
->ctrlin
& ~newctrl
& ACM_CTRL_DCD
)) {
294 dbg("calling hangup");
295 tty_hangup(acm
->tty
);
298 acm
->ctrlin
= newctrl
;
300 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
301 acm
->ctrlin
& ACM_CTRL_DCD
? '+' : '-', acm
->ctrlin
& ACM_CTRL_DSR
? '+' : '-',
302 acm
->ctrlin
& ACM_CTRL_BRK
? '+' : '-', acm
->ctrlin
& ACM_CTRL_RI
? '+' : '-',
303 acm
->ctrlin
& ACM_CTRL_FRAMING
? '+' : '-', acm
->ctrlin
& ACM_CTRL_PARITY
? '+' : '-',
304 acm
->ctrlin
& ACM_CTRL_OVERRUN
? '+' : '-');
309 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
310 dr
->bNotificationType
, dr
->wIndex
,
311 dr
->wLength
, data
[0], data
[1]);
315 retval
= usb_submit_urb (urb
, GFP_ATOMIC
);
317 err ("%s - usb_submit_urb failed with result %d",
318 __FUNCTION__
, retval
);
321 /* data interface returns incoming bytes, or we got unthrottled */
322 static void acm_read_bulk(struct urb
*urb
)
325 struct acm_ru
*rcv
= urb
->context
;
326 struct acm
*acm
= rcv
->instance
;
327 int status
= urb
->status
;
329 dbg("Entering acm_read_bulk with status %d", status
);
335 dev_dbg(&acm
->data
->dev
, "bulk rx status %d\n", status
);
338 buf
->size
= urb
->actual_length
;
340 if (likely(status
== 0)) {
341 spin_lock(&acm
->read_lock
);
342 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
343 list_add_tail(&buf
->list
, &acm
->filled_read_bufs
);
344 spin_unlock(&acm
->read_lock
);
346 /* we drop the buffer due to an error */
347 spin_lock(&acm
->read_lock
);
348 list_add_tail(&rcv
->list
, &acm
->spare_read_urbs
);
349 list_add(&buf
->list
, &acm
->spare_read_bufs
);
350 spin_unlock(&acm
->read_lock
);
351 /* nevertheless the tasklet must be kicked unconditionally
352 so the queue cannot dry up */
354 tasklet_schedule(&acm
->urb_task
);
357 static void acm_rx_tasklet(unsigned long _acm
)
359 struct acm
*acm
= (void *)_acm
;
361 struct tty_struct
*tty
= acm
->tty
;
364 unsigned char throttled
;
365 dbg("Entering acm_rx_tasklet");
370 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
371 throttled
= acm
->throttle
;
372 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
377 spin_lock_irqsave(&acm
->read_lock
, flags
);
378 if (list_empty(&acm
->filled_read_bufs
)) {
379 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
382 buf
= list_entry(acm
->filled_read_bufs
.next
,
383 struct acm_rb
, list
);
384 list_del(&buf
->list
);
385 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
387 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf
, buf
->size
);
389 tty_buffer_request_room(tty
, buf
->size
);
390 spin_lock_irqsave(&acm
->throttle_lock
, flags
);
391 throttled
= acm
->throttle
;
392 spin_unlock_irqrestore(&acm
->throttle_lock
, flags
);
394 tty_insert_flip_string(tty
, buf
->base
, buf
->size
);
395 tty_flip_buffer_push(tty
);
398 dbg("Throttling noticed");
399 spin_lock_irqsave(&acm
->read_lock
, flags
);
400 list_add(&buf
->list
, &acm
->filled_read_bufs
);
401 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
405 spin_lock_irqsave(&acm
->read_lock
, flags
);
406 list_add(&buf
->list
, &acm
->spare_read_bufs
);
407 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
411 while (!list_empty(&acm
->spare_read_bufs
)) {
412 spin_lock_irqsave(&acm
->read_lock
, flags
);
413 if (list_empty(&acm
->spare_read_urbs
)) {
414 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
417 rcv
= list_entry(acm
->spare_read_urbs
.next
,
418 struct acm_ru
, list
);
419 list_del(&rcv
->list
);
420 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
422 buf
= list_entry(acm
->spare_read_bufs
.next
,
423 struct acm_rb
, list
);
424 list_del(&buf
->list
);
428 usb_fill_bulk_urb(rcv
->urb
, acm
->dev
,
433 rcv
->urb
->transfer_dma
= buf
->dma
;
434 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
436 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv
->urb
, rcv
, buf
);
438 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
439 free-urbs-pool and resubmited ASAP */
440 if (usb_submit_urb(rcv
->urb
, GFP_ATOMIC
) < 0) {
441 list_add(&buf
->list
, &acm
->spare_read_bufs
);
442 spin_lock_irqsave(&acm
->read_lock
, flags
);
443 list_add(&rcv
->list
, &acm
->spare_read_urbs
);
444 spin_unlock_irqrestore(&acm
->read_lock
, flags
);
450 /* data interface wrote those outgoing bytes */
451 static void acm_write_bulk(struct urb
*urb
)
453 struct acm
*acm
= (struct acm
*)urb
->context
;
455 dbg("Entering acm_write_bulk with status %d", urb
->status
);
458 acm_write_start(acm
);
460 schedule_work(&acm
->work
);
463 static void acm_softint(struct work_struct
*work
)
465 struct acm
*acm
= container_of(work
, struct acm
, work
);
466 dbg("Entering acm_softint.");
470 tty_wakeup(acm
->tty
);
477 static int acm_tty_open(struct tty_struct
*tty
, struct file
*filp
)
482 dbg("Entering acm_tty_open.");
484 mutex_lock(&open_mutex
);
486 acm
= acm_table
[tty
->index
];
487 if (!acm
|| !acm
->dev
)
492 set_bit(TTY_NO_WRITE_SPLIT
, &tty
->flags
);
493 tty
->driver_data
= acm
;
496 /* force low_latency on so that our tty_push actually forces the data through,
497 otherwise it is scheduled, and with high data rates data can get lost. */
498 tty
->low_latency
= 1;
500 if (usb_autopm_get_interface(acm
->control
) < 0)
503 mutex_lock(&acm
->mutex
);
505 usb_autopm_put_interface(acm
->control
);
510 acm
->ctrlurb
->dev
= acm
->dev
;
511 if (usb_submit_urb(acm
->ctrlurb
, GFP_KERNEL
)) {
512 dbg("usb_submit_urb(ctrl irq) failed");
516 if (0 > acm_set_control(acm
, acm
->ctrlout
= ACM_CTRL_DTR
| ACM_CTRL_RTS
) &&
517 (acm
->ctrl_caps
& USB_CDC_CAP_LINE
))
520 INIT_LIST_HEAD(&acm
->spare_read_urbs
);
521 INIT_LIST_HEAD(&acm
->spare_read_bufs
);
522 INIT_LIST_HEAD(&acm
->filled_read_bufs
);
523 for (i
= 0; i
< acm
->rx_buflimit
; i
++) {
524 list_add(&(acm
->ru
[i
].list
), &acm
->spare_read_urbs
);
526 for (i
= 0; i
< acm
->rx_buflimit
; i
++) {
527 list_add(&(acm
->rb
[i
].list
), &acm
->spare_read_bufs
);
532 tasklet_schedule(&acm
->urb_task
);
536 mutex_unlock(&acm
->mutex
);
537 mutex_unlock(&open_mutex
);
541 usb_kill_urb(acm
->ctrlurb
);
543 usb_autopm_put_interface(acm
->control
);
545 mutex_unlock(&acm
->mutex
);
547 mutex_unlock(&open_mutex
);
551 static void acm_tty_unregister(struct acm
*acm
)
555 nr
= acm
->rx_buflimit
;
556 tty_unregister_device(acm_tty_driver
, acm
->minor
);
557 usb_put_intf(acm
->control
);
558 acm_table
[acm
->minor
] = NULL
;
559 usb_free_urb(acm
->ctrlurb
);
560 usb_free_urb(acm
->writeurb
);
561 for (i
= 0; i
< nr
; i
++)
562 usb_free_urb(acm
->ru
[i
].urb
);
563 kfree(acm
->country_codes
);
567 static void acm_tty_close(struct tty_struct
*tty
, struct file
*filp
)
569 struct acm
*acm
= tty
->driver_data
;
572 if (!acm
|| !acm
->used
)
575 nr
= acm
->rx_buflimit
;
576 mutex_lock(&open_mutex
);
579 acm_set_control(acm
, acm
->ctrlout
= 0);
580 usb_kill_urb(acm
->ctrlurb
);
581 usb_kill_urb(acm
->writeurb
);
582 for (i
= 0; i
< nr
; i
++)
583 usb_kill_urb(acm
->ru
[i
].urb
);
584 usb_autopm_put_interface(acm
->control
);
586 acm_tty_unregister(acm
);
588 mutex_unlock(&open_mutex
);
591 static int acm_tty_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
593 struct acm
*acm
= tty
->driver_data
;
599 dbg("Entering acm_tty_write to write %d bytes,", count
);
606 spin_lock_irqsave(&acm
->write_lock
, flags
);
607 if ((wbn
= acm_wb_alloc(acm
)) < 0) {
608 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
609 acm_write_start(acm
);
614 count
= (count
> acm
->writesize
) ? acm
->writesize
: count
;
615 dbg("Get %d bytes...", count
);
616 memcpy(wb
->buf
, buf
, count
);
618 spin_unlock_irqrestore(&acm
->write_lock
, flags
);
620 if ((stat
= acm_write_start(acm
)) < 0)
625 static int acm_tty_write_room(struct tty_struct
*tty
)
627 struct acm
*acm
= tty
->driver_data
;
631 * Do not let the line discipline to know that we have a reserve,
632 * or it might get too enthusiastic.
634 return (acm
->write_ready
&& acm_wb_is_avail(acm
)) ? acm
->writesize
: 0;
637 static int acm_tty_chars_in_buffer(struct tty_struct
*tty
)
639 struct acm
*acm
= tty
->driver_data
;
643 * This is inaccurate (overcounts), but it works.
645 return (ACM_NW
- acm_wb_is_avail(acm
)) * acm
->writesize
;
648 static void acm_tty_throttle(struct tty_struct
*tty
)
650 struct acm
*acm
= tty
->driver_data
;
653 spin_lock_bh(&acm
->throttle_lock
);
655 spin_unlock_bh(&acm
->throttle_lock
);
658 static void acm_tty_unthrottle(struct tty_struct
*tty
)
660 struct acm
*acm
= tty
->driver_data
;
663 spin_lock_bh(&acm
->throttle_lock
);
665 spin_unlock_bh(&acm
->throttle_lock
);
666 tasklet_schedule(&acm
->urb_task
);
669 static void acm_tty_break_ctl(struct tty_struct
*tty
, int state
)
671 struct acm
*acm
= tty
->driver_data
;
674 if (acm_send_break(acm
, state
? 0xffff : 0))
675 dbg("send break failed");
678 static int acm_tty_tiocmget(struct tty_struct
*tty
, struct file
*file
)
680 struct acm
*acm
= tty
->driver_data
;
685 return (acm
->ctrlout
& ACM_CTRL_DTR
? TIOCM_DTR
: 0) |
686 (acm
->ctrlout
& ACM_CTRL_RTS
? TIOCM_RTS
: 0) |
687 (acm
->ctrlin
& ACM_CTRL_DSR
? TIOCM_DSR
: 0) |
688 (acm
->ctrlin
& ACM_CTRL_RI
? TIOCM_RI
: 0) |
689 (acm
->ctrlin
& ACM_CTRL_DCD
? TIOCM_CD
: 0) |
693 static int acm_tty_tiocmset(struct tty_struct
*tty
, struct file
*file
,
694 unsigned int set
, unsigned int clear
)
696 struct acm
*acm
= tty
->driver_data
;
697 unsigned int newctrl
;
702 newctrl
= acm
->ctrlout
;
703 set
= (set
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) | (set
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
704 clear
= (clear
& TIOCM_DTR
? ACM_CTRL_DTR
: 0) | (clear
& TIOCM_RTS
? ACM_CTRL_RTS
: 0);
706 newctrl
= (newctrl
& ~clear
) | set
;
708 if (acm
->ctrlout
== newctrl
)
710 return acm_set_control(acm
, acm
->ctrlout
= newctrl
);
713 static int acm_tty_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
715 struct acm
*acm
= tty
->driver_data
;
723 static const __u32 acm_tty_speed
[] = {
724 0, 50, 75, 110, 134, 150, 200, 300, 600,
725 1200, 1800, 2400, 4800, 9600, 19200, 38400,
726 57600, 115200, 230400, 460800, 500000, 576000,
727 921600, 1000000, 1152000, 1500000, 2000000,
728 2500000, 3000000, 3500000, 4000000
731 static const __u8 acm_tty_size
[] = {
735 static void acm_tty_set_termios(struct tty_struct
*tty
, struct ktermios
*termios_old
)
737 struct acm
*acm
= tty
->driver_data
;
738 struct ktermios
*termios
= tty
->termios
;
739 struct usb_cdc_line_coding newline
;
740 int newctrl
= acm
->ctrlout
;
745 newline
.dwDTERate
= cpu_to_le32p(acm_tty_speed
+
746 (termios
->c_cflag
& CBAUD
& ~CBAUDEX
) + (termios
->c_cflag
& CBAUDEX
? 15 : 0));
747 newline
.bCharFormat
= termios
->c_cflag
& CSTOPB
? 2 : 0;
748 newline
.bParityType
= termios
->c_cflag
& PARENB
?
749 (termios
->c_cflag
& PARODD
? 1 : 2) + (termios
->c_cflag
& CMSPAR
? 2 : 0) : 0;
750 newline
.bDataBits
= acm_tty_size
[(termios
->c_cflag
& CSIZE
) >> 4];
752 acm
->clocal
= ((termios
->c_cflag
& CLOCAL
) != 0);
754 if (!newline
.dwDTERate
) {
755 newline
.dwDTERate
= acm
->line
.dwDTERate
;
756 newctrl
&= ~ACM_CTRL_DTR
;
757 } else newctrl
|= ACM_CTRL_DTR
;
759 if (newctrl
!= acm
->ctrlout
)
760 acm_set_control(acm
, acm
->ctrlout
= newctrl
);
762 if (memcmp(&acm
->line
, &newline
, sizeof newline
)) {
763 memcpy(&acm
->line
, &newline
, sizeof newline
);
764 dbg("set line: %d %d %d %d", le32_to_cpu(newline
.dwDTERate
),
765 newline
.bCharFormat
, newline
.bParityType
,
767 acm_set_line(acm
, &acm
->line
);
772 * USB probe and disconnect routines.
775 /* Little helper: write buffers free */
776 static void acm_write_buffers_free(struct acm
*acm
)
781 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
782 usb_buffer_free(acm
->dev
, acm
->writesize
, wb
->buf
, wb
->dmah
);
786 /* Little helper: write buffers allocate */
787 static int acm_write_buffers_alloc(struct acm
*acm
)
792 for (wb
= &acm
->wb
[0], i
= 0; i
< ACM_NW
; i
++, wb
++) {
793 wb
->buf
= usb_buffer_alloc(acm
->dev
, acm
->writesize
, GFP_KERNEL
,
799 usb_buffer_free(acm
->dev
, acm
->writesize
,
808 static int acm_probe (struct usb_interface
*intf
,
809 const struct usb_device_id
*id
)
811 struct usb_cdc_union_desc
*union_header
= NULL
;
812 struct usb_cdc_country_functional_desc
*cfd
= NULL
;
813 char *buffer
= intf
->altsetting
->extra
;
814 int buflen
= intf
->altsetting
->extralen
;
815 struct usb_interface
*control_interface
;
816 struct usb_interface
*data_interface
;
817 struct usb_endpoint_descriptor
*epctrl
;
818 struct usb_endpoint_descriptor
*epread
;
819 struct usb_endpoint_descriptor
*epwrite
;
820 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
823 int ctrlsize
,readsize
;
825 u8 ac_management_function
= 0;
826 u8 call_management_function
= 0;
827 int call_interface_num
= -1;
828 int data_interface_num
;
829 unsigned long quirks
;
834 quirks
= (unsigned long)id
->driver_info
;
835 num_rx_buf
= (quirks
== SINGLE_RX_URB
) ? 1 : ACM_NR
;
837 /* handle quirks deadly to normal probing*/
838 if (quirks
== NO_UNION_NORMAL
) {
839 data_interface
= usb_ifnum_to_if(usb_dev
, 1);
840 control_interface
= usb_ifnum_to_if(usb_dev
, 0);
841 goto skip_normal_probe
;
846 err("Weird descriptor references\n");
851 if (intf
->cur_altsetting
->endpoint
->extralen
&& intf
->cur_altsetting
->endpoint
->extra
) {
852 dev_dbg(&intf
->dev
,"Seeking extra descriptors on endpoint\n");
853 buflen
= intf
->cur_altsetting
->endpoint
->extralen
;
854 buffer
= intf
->cur_altsetting
->endpoint
->extra
;
856 err("Zero length descriptor references\n");
862 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
863 err("skipping garbage\n");
867 switch (buffer
[2]) {
868 case USB_CDC_UNION_TYPE
: /* we've found it */
870 err("More than one union descriptor, skipping ...");
873 union_header
= (struct usb_cdc_union_desc
*)
876 case USB_CDC_COUNTRY_TYPE
: /* export through sysfs*/
877 cfd
= (struct usb_cdc_country_functional_desc
*)buffer
;
879 case USB_CDC_HEADER_TYPE
: /* maybe check version */
880 break; /* for now we ignore it */
881 case USB_CDC_ACM_TYPE
:
882 ac_management_function
= buffer
[3];
884 case USB_CDC_CALL_MANAGEMENT_TYPE
:
885 call_management_function
= buffer
[3];
886 call_interface_num
= buffer
[4];
887 if ((call_management_function
& 3) != 3)
888 err("This device cannot do calls on its own. It is no modem.");
892 err("Ignoring extra header, type %d, length %d", buffer
[2], buffer
[0]);
901 if (call_interface_num
> 0) {
902 dev_dbg(&intf
->dev
,"No union descriptor, using call management descriptor\n");
903 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= call_interface_num
));
904 control_interface
= intf
;
906 dev_dbg(&intf
->dev
,"No union descriptor, giving up\n");
910 control_interface
= usb_ifnum_to_if(usb_dev
, union_header
->bMasterInterface0
);
911 data_interface
= usb_ifnum_to_if(usb_dev
, (data_interface_num
= union_header
->bSlaveInterface0
));
912 if (!control_interface
|| !data_interface
) {
913 dev_dbg(&intf
->dev
,"no interfaces\n");
918 if (data_interface_num
!= call_interface_num
)
919 dev_dbg(&intf
->dev
,"Separate call control interface. That is not fully supported.\n");
923 /*workaround for switched interfaces */
924 if (data_interface
->cur_altsetting
->desc
.bInterfaceClass
!= CDC_DATA_INTERFACE_TYPE
) {
925 if (control_interface
->cur_altsetting
->desc
.bInterfaceClass
== CDC_DATA_INTERFACE_TYPE
) {
926 struct usb_interface
*t
;
927 dev_dbg(&intf
->dev
,"Your device has switched interfaces.\n");
929 t
= control_interface
;
930 control_interface
= data_interface
;
937 /* Accept probe requests only for the control interface */
938 if (intf
!= control_interface
)
941 if (usb_interface_claimed(data_interface
)) { /* valid in this context */
942 dev_dbg(&intf
->dev
,"The data interface isn't available\n");
947 if (data_interface
->cur_altsetting
->desc
.bNumEndpoints
< 2)
950 epctrl
= &control_interface
->cur_altsetting
->endpoint
[0].desc
;
951 epread
= &data_interface
->cur_altsetting
->endpoint
[0].desc
;
952 epwrite
= &data_interface
->cur_altsetting
->endpoint
[1].desc
;
955 /* workaround for switched endpoints */
956 if (!usb_endpoint_dir_in(epread
)) {
957 /* descriptors are swapped */
958 struct usb_endpoint_descriptor
*t
;
959 dev_dbg(&intf
->dev
,"The data interface has switched endpoints\n");
965 dbg("interfaces are valid");
966 for (minor
= 0; minor
< ACM_TTY_MINORS
&& acm_table
[minor
]; minor
++);
968 if (minor
== ACM_TTY_MINORS
) {
969 err("no more free acm devices");
973 if (!(acm
= kzalloc(sizeof(struct acm
), GFP_KERNEL
))) {
974 dev_dbg(&intf
->dev
, "out of memory (acm kzalloc)\n");
978 ctrlsize
= le16_to_cpu(epctrl
->wMaxPacketSize
);
979 readsize
= le16_to_cpu(epread
->wMaxPacketSize
)* ( quirks
== SINGLE_RX_URB
? 1 : 2);
980 acm
->writesize
= le16_to_cpu(epwrite
->wMaxPacketSize
);
981 acm
->control
= control_interface
;
982 acm
->data
= data_interface
;
985 acm
->ctrl_caps
= ac_management_function
;
986 acm
->ctrlsize
= ctrlsize
;
987 acm
->readsize
= readsize
;
988 acm
->rx_buflimit
= num_rx_buf
;
989 acm
->urb_task
.func
= acm_rx_tasklet
;
990 acm
->urb_task
.data
= (unsigned long) acm
;
991 INIT_WORK(&acm
->work
, acm_softint
);
992 spin_lock_init(&acm
->throttle_lock
);
993 spin_lock_init(&acm
->write_lock
);
994 spin_lock_init(&acm
->read_lock
);
995 mutex_init(&acm
->mutex
);
996 acm
->write_ready
= 1;
997 acm
->rx_endpoint
= usb_rcvbulkpipe(usb_dev
, epread
->bEndpointAddress
);
999 buf
= usb_buffer_alloc(usb_dev
, ctrlsize
, GFP_KERNEL
, &acm
->ctrl_dma
);
1001 dev_dbg(&intf
->dev
, "out of memory (ctrl buffer alloc)\n");
1004 acm
->ctrl_buffer
= buf
;
1006 if (acm_write_buffers_alloc(acm
) < 0) {
1007 dev_dbg(&intf
->dev
, "out of memory (write buffer alloc)\n");
1011 acm
->ctrlurb
= usb_alloc_urb(0, GFP_KERNEL
);
1012 if (!acm
->ctrlurb
) {
1013 dev_dbg(&intf
->dev
, "out of memory (ctrlurb kmalloc)\n");
1016 for (i
= 0; i
< num_rx_buf
; i
++) {
1017 struct acm_ru
*rcv
= &(acm
->ru
[i
]);
1019 if (!(rcv
->urb
= usb_alloc_urb(0, GFP_KERNEL
))) {
1020 dev_dbg(&intf
->dev
, "out of memory (read urbs usb_alloc_urb)\n");
1024 rcv
->urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1025 rcv
->instance
= acm
;
1027 for (i
= 0; i
< num_rx_buf
; i
++) {
1028 struct acm_rb
*buf
= &(acm
->rb
[i
]);
1030 if (!(buf
->base
= usb_buffer_alloc(acm
->dev
, readsize
, GFP_KERNEL
, &buf
->dma
))) {
1031 dev_dbg(&intf
->dev
, "out of memory (read bufs usb_buffer_alloc)\n");
1035 acm
->writeurb
= usb_alloc_urb(0, GFP_KERNEL
);
1036 if (!acm
->writeurb
) {
1037 dev_dbg(&intf
->dev
, "out of memory (writeurb kmalloc)\n");
1041 usb_set_intfdata (intf
, acm
);
1043 i
= device_create_file(&intf
->dev
, &dev_attr_bmCapabilities
);
1047 if (cfd
) { /* export the country data */
1048 acm
->country_codes
= kmalloc(cfd
->bLength
- 4, GFP_KERNEL
);
1049 if (!acm
->country_codes
)
1050 goto skip_countries
;
1051 acm
->country_code_size
= cfd
->bLength
- 4;
1052 memcpy(acm
->country_codes
, (u8
*)&cfd
->wCountyCode0
, cfd
->bLength
- 4);
1053 acm
->country_rel_date
= cfd
->iCountryCodeRelDate
;
1055 i
= device_create_file(&intf
->dev
, &dev_attr_wCountryCodes
);
1057 kfree(acm
->country_codes
);
1058 goto skip_countries
;
1061 i
= device_create_file(&intf
->dev
, &dev_attr_iCountryCodeRelDate
);
1063 kfree(acm
->country_codes
);
1064 goto skip_countries
;
1069 usb_fill_int_urb(acm
->ctrlurb
, usb_dev
, usb_rcvintpipe(usb_dev
, epctrl
->bEndpointAddress
),
1070 acm
->ctrl_buffer
, ctrlsize
, acm_ctrl_irq
, acm
, epctrl
->bInterval
);
1071 acm
->ctrlurb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
1072 acm
->ctrlurb
->transfer_dma
= acm
->ctrl_dma
;
1074 usb_fill_bulk_urb(acm
->writeurb
, usb_dev
, usb_sndbulkpipe(usb_dev
, epwrite
->bEndpointAddress
),
1075 NULL
, acm
->writesize
, acm_write_bulk
, acm
);
1076 acm
->writeurb
->transfer_flags
|= URB_NO_FSBR
| URB_NO_TRANSFER_DMA_MAP
;
1078 dev_info(&intf
->dev
, "ttyACM%d: USB ACM device\n", minor
);
1080 acm_set_control(acm
, acm
->ctrlout
);
1082 acm
->line
.dwDTERate
= cpu_to_le32(9600);
1083 acm
->line
.bDataBits
= 8;
1084 acm_set_line(acm
, &acm
->line
);
1086 usb_driver_claim_interface(&acm_driver
, data_interface
, acm
);
1088 usb_get_intf(control_interface
);
1089 tty_register_device(acm_tty_driver
, minor
, &control_interface
->dev
);
1091 acm_table
[minor
] = acm
;
1095 usb_free_urb(acm
->writeurb
);
1097 for (i
= 0; i
< num_rx_buf
; i
++)
1098 usb_buffer_free(usb_dev
, acm
->readsize
, acm
->rb
[i
].base
, acm
->rb
[i
].dma
);
1099 for (i
= 0; i
< num_rx_buf
; i
++)
1100 usb_free_urb(acm
->ru
[i
].urb
);
1101 usb_free_urb(acm
->ctrlurb
);
1103 acm_write_buffers_free(acm
);
1105 usb_buffer_free(usb_dev
, ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1112 static void stop_data_traffic(struct acm
*acm
)
1116 tasklet_disable(&acm
->urb_task
);
1118 usb_kill_urb(acm
->ctrlurb
);
1119 usb_kill_urb(acm
->writeurb
);
1120 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1121 usb_kill_urb(acm
->ru
[i
].urb
);
1123 INIT_LIST_HEAD(&acm
->filled_read_bufs
);
1124 INIT_LIST_HEAD(&acm
->spare_read_bufs
);
1126 tasklet_enable(&acm
->urb_task
);
1128 cancel_work_sync(&acm
->work
);
1131 static void acm_disconnect(struct usb_interface
*intf
)
1133 struct acm
*acm
= usb_get_intfdata(intf
);
1134 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
1137 if (!acm
|| !acm
->dev
) {
1138 dbg("disconnect on nonexisting interface");
1142 mutex_lock(&open_mutex
);
1143 if (!usb_get_intfdata(intf
)) {
1144 mutex_unlock(&open_mutex
);
1147 if (acm
->country_codes
){
1148 device_remove_file(&acm
->control
->dev
,
1149 &dev_attr_wCountryCodes
);
1150 device_remove_file(&acm
->control
->dev
,
1151 &dev_attr_iCountryCodeRelDate
);
1153 device_remove_file(&acm
->control
->dev
, &dev_attr_bmCapabilities
);
1155 usb_set_intfdata(acm
->control
, NULL
);
1156 usb_set_intfdata(acm
->data
, NULL
);
1158 stop_data_traffic(acm
);
1160 acm_write_buffers_free(acm
);
1161 usb_buffer_free(usb_dev
, acm
->ctrlsize
, acm
->ctrl_buffer
, acm
->ctrl_dma
);
1162 for (i
= 0; i
< acm
->rx_buflimit
; i
++)
1163 usb_buffer_free(usb_dev
, acm
->readsize
, acm
->rb
[i
].base
, acm
->rb
[i
].dma
);
1165 usb_driver_release_interface(&acm_driver
, intf
== acm
->control
? acm
->data
: intf
);
1168 acm_tty_unregister(acm
);
1169 mutex_unlock(&open_mutex
);
1173 mutex_unlock(&open_mutex
);
1176 tty_hangup(acm
->tty
);
1179 static int acm_suspend(struct usb_interface
*intf
, pm_message_t message
)
1181 struct acm
*acm
= usb_get_intfdata(intf
);
1183 if (acm
->susp_count
++)
1186 we treat opened interfaces differently,
1187 we must guard against open
1189 mutex_lock(&acm
->mutex
);
1192 stop_data_traffic(acm
);
1194 mutex_unlock(&acm
->mutex
);
1198 static int acm_resume(struct usb_interface
*intf
)
1200 struct acm
*acm
= usb_get_intfdata(intf
);
1203 if (--acm
->susp_count
)
1206 mutex_lock(&acm
->mutex
);
1208 rv
= usb_submit_urb(acm
->ctrlurb
, GFP_NOIO
);
1212 tasklet_schedule(&acm
->urb_task
);
1216 mutex_unlock(&acm
->mutex
);
1220 * USB driver structure.
1223 static struct usb_device_id acm_ids
[] = {
1224 /* quirky and broken devices */
1225 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1226 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1228 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1229 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1231 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1232 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1234 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1235 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1237 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1238 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1240 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1241 .driver_info
= SINGLE_RX_URB
, /* firmware bug */
1243 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1244 .driver_info
= NO_UNION_NORMAL
, /* has no union descriptor */
1247 /* control interfaces with various AT-command sets */
1248 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1249 USB_CDC_ACM_PROTO_AT_V25TER
) },
1250 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1251 USB_CDC_ACM_PROTO_AT_PCCA101
) },
1252 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1253 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE
) },
1254 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1255 USB_CDC_ACM_PROTO_AT_GSM
) },
1256 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1257 USB_CDC_ACM_PROTO_AT_3G
) },
1258 { USB_INTERFACE_INFO(USB_CLASS_COMM
, USB_CDC_SUBCLASS_ACM
,
1259 USB_CDC_ACM_PROTO_AT_CDMA
) },
1261 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1265 MODULE_DEVICE_TABLE (usb
, acm_ids
);
1267 static struct usb_driver acm_driver
= {
1270 .disconnect
= acm_disconnect
,
1271 .suspend
= acm_suspend
,
1272 .resume
= acm_resume
,
1273 .id_table
= acm_ids
,
1274 .supports_autosuspend
= 1,
1278 * TTY driver structures.
1281 static const struct tty_operations acm_ops
= {
1282 .open
= acm_tty_open
,
1283 .close
= acm_tty_close
,
1284 .write
= acm_tty_write
,
1285 .write_room
= acm_tty_write_room
,
1286 .ioctl
= acm_tty_ioctl
,
1287 .throttle
= acm_tty_throttle
,
1288 .unthrottle
= acm_tty_unthrottle
,
1289 .chars_in_buffer
= acm_tty_chars_in_buffer
,
1290 .break_ctl
= acm_tty_break_ctl
,
1291 .set_termios
= acm_tty_set_termios
,
1292 .tiocmget
= acm_tty_tiocmget
,
1293 .tiocmset
= acm_tty_tiocmset
,
1300 static int __init
acm_init(void)
1303 acm_tty_driver
= alloc_tty_driver(ACM_TTY_MINORS
);
1304 if (!acm_tty_driver
)
1306 acm_tty_driver
->owner
= THIS_MODULE
,
1307 acm_tty_driver
->driver_name
= "acm",
1308 acm_tty_driver
->name
= "ttyACM",
1309 acm_tty_driver
->major
= ACM_TTY_MAJOR
,
1310 acm_tty_driver
->minor_start
= 0,
1311 acm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
,
1312 acm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
,
1313 acm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
1314 acm_tty_driver
->init_termios
= tty_std_termios
;
1315 acm_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1316 tty_set_operations(acm_tty_driver
, &acm_ops
);
1318 retval
= tty_register_driver(acm_tty_driver
);
1320 put_tty_driver(acm_tty_driver
);
1324 retval
= usb_register(&acm_driver
);
1326 tty_unregister_driver(acm_tty_driver
);
1327 put_tty_driver(acm_tty_driver
);
1331 info(DRIVER_VERSION
":" DRIVER_DESC
);
1336 static void __exit
acm_exit(void)
1338 usb_deregister(&acm_driver
);
1339 tty_unregister_driver(acm_tty_driver
);
1340 put_tty_driver(acm_tty_driver
);
1343 module_init(acm_init
);
1344 module_exit(acm_exit
);
1346 MODULE_AUTHOR( DRIVER_AUTHOR
);
1347 MODULE_DESCRIPTION( DRIVER_DESC
);
1348 MODULE_LICENSE("GPL");