1 /*
2 * cdc-acm.c
3 *
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>
10 *
11 * USB Abstract Control Model driver for USB modems and ISDN adapters
12 *
13 * Sponsored by SuSE
14 *
15 * ChangeLog:
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
34 * v0.26 - multiple write urbs, writesize increased
35 */
36
37 /*
38 * This program is free software; you can redistribute it and/or modify
39 * it under the terms of the GNU General Public License as published by
40 * the Free Software Foundation; either version 2 of the License, or
41 * (at your option) any later version.
42 *
43 * This program is distributed in the hope that it will be useful,
44 * but WITHOUT ANY WARRANTY; without even the implied warranty of
45 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
46 * GNU General Public License for more details.
47 *
48 * You should have received a copy of the GNU General Public License
49 * along with this program; if not, write to the Free Software
50 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
51 */
52
53 #undef DEBUG
54 #undef VERBOSE_DEBUG
55
56 #include <linux/kernel.h>
57 #include <linux/errno.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #include <linux/tty.h>
61 #include <linux/tty_driver.h>
62 #include <linux/tty_flip.h>
63 #include <linux/module.h>
64 #include <linux/mutex.h>
65 #include <asm/uaccess.h>
66 #include <linux/usb.h>
67 #include <linux/usb/cdc.h>
68 #include <asm/byteorder.h>
69 #include <asm/unaligned.h>
70 #include <linux/list.h>
71
72 #include "cdc-acm.h"
73
74
75 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
76
77 /*
78 * Version Information
79 */
80 #define DRIVER_VERSION "v0.26"
81 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
82 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
83
84 static struct usb_driver acm_driver;
85 static struct tty_driver *acm_tty_driver;
86 static struct acm *acm_table[ACM_TTY_MINORS];
87
88 static DEFINE_MUTEX(open_mutex);
89
90 #define ACM_READY(acm) (acm && acm->dev && acm->used)
91
92 #ifdef VERBOSE_DEBUG
93 #define verbose 1
94 #else
95 #define verbose 0
96 #endif
97
98 /*
99 * Functions for ACM control messages.
100 */
101
acm_ctrl_msg(struct acm * acm,int request,int value,void * buf,int len)102 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
103 {
104 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
105 request, USB_RT_ACM, value,
106 acm->control->altsetting[0].desc.bInterfaceNumber,
107 buf, len, 5000);
108 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
109 return retval < 0 ? retval : 0;
110 }
111
112 /* devices aren't required to support these requests.
113 * the cdc acm descriptor tells whether they do...
114 */
115 #define acm_set_control(acm, control) \
116 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
117 #define acm_set_line(acm, line) \
118 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
119 #define acm_send_break(acm, ms) \
120 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
121
122 /*
123 * Write buffer management.
124 * All of these assume proper locks taken by the caller.
125 */
126
acm_wb_alloc(struct acm * acm)127 static int acm_wb_alloc(struct acm *acm)
128 {
129 int i, wbn;
130 struct acm_wb *wb;
131
132 wbn = 0;
133 i = 0;
134 for (;;) {
135 wb = &acm->wb[wbn];
136 if (!wb->use) {
137 wb->use = 1;
138 return wbn;
139 }
140 wbn = (wbn + 1) % ACM_NW;
141 if (++i >= ACM_NW)
142 return -1;
143 }
144 }
145
acm_wb_is_avail(struct acm * acm)146 static int acm_wb_is_avail(struct acm *acm)
147 {
148 int i, n;
149 unsigned long flags;
150
151 n = ACM_NW;
152 spin_lock_irqsave(&acm->write_lock, flags);
153 for (i = 0; i < ACM_NW; i++) {
154 n -= acm->wb[i].use;
155 }
156 spin_unlock_irqrestore(&acm->write_lock, flags);
157 return n;
158 }
159
160 /*
161 * Finish write. Caller must hold acm->write_lock
162 */
acm_write_done(struct acm * acm,struct acm_wb * wb)163 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
164 {
165 wb->use = 0;
166 acm->transmitting--;
167 }
168
169 /*
170 * Poke write.
171 *
172 * the caller is responsible for locking
173 */
174
acm_start_wb(struct acm * acm,struct acm_wb * wb)175 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
176 {
177 int rc;
178
179 acm->transmitting++;
180
181 wb->urb->transfer_buffer = wb->buf;
182 wb->urb->transfer_dma = wb->dmah;
183 wb->urb->transfer_buffer_length = wb->len;
184 wb->urb->dev = acm->dev;
185
186 if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
187 dbg("usb_submit_urb(write bulk) failed: %d", rc);
188 acm_write_done(acm, wb);
189 }
190 return rc;
191 }
192
acm_write_start(struct acm * acm,int wbn)193 static int acm_write_start(struct acm *acm, int wbn)
194 {
195 unsigned long flags;
196 struct acm_wb *wb = &acm->wb[wbn];
197 int rc;
198
199 spin_lock_irqsave(&acm->write_lock, flags);
200 if (!acm->dev) {
201 wb->use = 0;
202 spin_unlock_irqrestore(&acm->write_lock, flags);
203 return -ENODEV;
204 }
205
206 dbg("%s susp_count: %d", __func__, acm->susp_count);
207 if (acm->susp_count) {
208 acm->delayed_wb = wb;
209 schedule_work(&acm->waker);
210 spin_unlock_irqrestore(&acm->write_lock, flags);
211 return 0; /* A white lie */
212 }
213 usb_mark_last_busy(acm->dev);
214
215 rc = acm_start_wb(acm, wb);
216 spin_unlock_irqrestore(&acm->write_lock, flags);
217
218 return rc;
219
220 }
221 /*
222 * attributes exported through sysfs
223 */
show_caps(struct device * dev,struct device_attribute * attr,char * buf)224 static ssize_t show_caps
225 (struct device *dev, struct device_attribute *attr, char *buf)
226 {
227 struct usb_interface *intf = to_usb_interface(dev);
228 struct acm *acm = usb_get_intfdata(intf);
229
230 return sprintf(buf, "%d", acm->ctrl_caps);
231 }
232 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
233
show_country_codes(struct device * dev,struct device_attribute * attr,char * buf)234 static ssize_t show_country_codes
235 (struct device *dev, struct device_attribute *attr, char *buf)
236 {
237 struct usb_interface *intf = to_usb_interface(dev);
238 struct acm *acm = usb_get_intfdata(intf);
239
240 memcpy(buf, acm->country_codes, acm->country_code_size);
241 return acm->country_code_size;
242 }
243
244 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
245
show_country_rel_date(struct device * dev,struct device_attribute * attr,char * buf)246 static ssize_t show_country_rel_date
247 (struct device *dev, struct device_attribute *attr, char *buf)
248 {
249 struct usb_interface *intf = to_usb_interface(dev);
250 struct acm *acm = usb_get_intfdata(intf);
251
252 return sprintf(buf, "%d", acm->country_rel_date);
253 }
254
255 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
256 /*
257 * Interrupt handlers for various ACM device responses
258 */
259
260 /* control interface reports status changes with "interrupt" transfers */
acm_ctrl_irq(struct urb * urb)261 static void acm_ctrl_irq(struct urb *urb)
262 {
263 struct acm *acm = urb->context;
264 struct usb_cdc_notification *dr = urb->transfer_buffer;
265 unsigned char *data;
266 int newctrl;
267 int retval;
268 int status = urb->status;
269
270 switch (status) {
271 case 0:
272 /* success */
273 break;
274 case -ECONNRESET:
275 case -ENOENT:
276 case -ESHUTDOWN:
277 /* this urb is terminated, clean up */
278 dbg("%s - urb shutting down with status: %d", __func__, status);
279 return;
280 default:
281 dbg("%s - nonzero urb status received: %d", __func__, status);
282 goto exit;
283 }
284
285 if (!ACM_READY(acm))
286 goto exit;
287
288 data = (unsigned char *)(dr + 1);
289 switch (dr->bNotificationType) {
290
291 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
292
293 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
294 break;
295
296 case USB_CDC_NOTIFY_SERIAL_STATE:
297
298 newctrl = get_unaligned_le16(data);
299
300 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
301 dbg("calling hangup");
302 tty_hangup(acm->tty);
303 }
304
305 acm->ctrlin = newctrl;
306
307 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
308 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
309 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
310 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
311 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
312
313 break;
314
315 default:
316 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
317 dr->bNotificationType, dr->wIndex,
318 dr->wLength, data[0], data[1]);
319 break;
320 }
321 exit:
322 usb_mark_last_busy(acm->dev);
323 retval = usb_submit_urb (urb, GFP_ATOMIC);
324 if (retval)
325 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
326 "result %d", __func__, retval);
327 }
328
329 /* data interface returns incoming bytes, or we got unthrottled */
acm_read_bulk(struct urb * urb)330 static void acm_read_bulk(struct urb *urb)
331 {
332 struct acm_rb *buf;
333 struct acm_ru *rcv = urb->context;
334 struct acm *acm = rcv->instance;
335 int status = urb->status;
336
337 dbg("Entering acm_read_bulk with status %d", status);
338
339 if (!ACM_READY(acm)) {
340 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
341 return;
342 }
343 usb_mark_last_busy(acm->dev);
344
345 if (status)
346 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
347
348 buf = rcv->buffer;
349 buf->size = urb->actual_length;
350
351 if (likely(status == 0)) {
352 spin_lock(&acm->read_lock);
353 acm->processing++;
354 list_add_tail(&rcv->list, &acm->spare_read_urbs);
355 list_add_tail(&buf->list, &acm->filled_read_bufs);
356 spin_unlock(&acm->read_lock);
357 } else {
358 /* we drop the buffer due to an error */
359 spin_lock(&acm->read_lock);
360 list_add_tail(&rcv->list, &acm->spare_read_urbs);
361 list_add(&buf->list, &acm->spare_read_bufs);
362 spin_unlock(&acm->read_lock);
363 /* nevertheless the tasklet must be kicked unconditionally
364 so the queue cannot dry up */
365 }
366 if (likely(!acm->susp_count))
367 tasklet_schedule(&acm->urb_task);
368 }
369
acm_rx_tasklet(unsigned long _acm)370 static void acm_rx_tasklet(unsigned long _acm)
371 {
372 struct acm *acm = (void *)_acm;
373 struct acm_rb *buf;
374 struct tty_struct *tty = acm->tty;
375 struct acm_ru *rcv;
376 unsigned long flags;
377 unsigned char throttled;
378
379 dbg("Entering acm_rx_tasklet");
380
381 if (!ACM_READY(acm))
382 {
383 dbg("acm_rx_tasklet: ACM not ready");
384 return;
385 }
386
387 spin_lock_irqsave(&acm->throttle_lock, flags);
388 throttled = acm->throttle;
389 spin_unlock_irqrestore(&acm->throttle_lock, flags);
390 if (throttled)
391 {
392 dbg("acm_rx_tasklet: throttled");
393 return;
394 }
395
396 next_buffer:
397 spin_lock_irqsave(&acm->read_lock, flags);
398 if (list_empty(&acm->filled_read_bufs)) {
399 spin_unlock_irqrestore(&acm->read_lock, flags);
400 goto urbs;
401 }
402 buf = list_entry(acm->filled_read_bufs.next,
403 struct acm_rb, list);
404 list_del(&buf->list);
405 spin_unlock_irqrestore(&acm->read_lock, flags);
406
407 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
408
409 tty_buffer_request_room(tty, buf->size);
410 spin_lock_irqsave(&acm->throttle_lock, flags);
411 throttled = acm->throttle;
412 spin_unlock_irqrestore(&acm->throttle_lock, flags);
413 if (!throttled)
414 tty_insert_flip_string(tty, buf->base, buf->size);
415 tty_flip_buffer_push(tty);
416
417 if (throttled) {
418 dbg("Throttling noticed");
419 spin_lock_irqsave(&acm->read_lock, flags);
420 list_add(&buf->list, &acm->filled_read_bufs);
421 spin_unlock_irqrestore(&acm->read_lock, flags);
422 return;
423 }
424
425 spin_lock_irqsave(&acm->read_lock, flags);
426 list_add(&buf->list, &acm->spare_read_bufs);
427 spin_unlock_irqrestore(&acm->read_lock, flags);
428 goto next_buffer;
429
430 urbs:
431 while (!list_empty(&acm->spare_read_bufs)) {
432 spin_lock_irqsave(&acm->read_lock, flags);
433 if (list_empty(&acm->spare_read_urbs)) {
434 acm->processing = 0;
435 spin_unlock_irqrestore(&acm->read_lock, flags);
436 return;
437 }
438 rcv = list_entry(acm->spare_read_urbs.next,
439 struct acm_ru, list);
440 list_del(&rcv->list);
441 spin_unlock_irqrestore(&acm->read_lock, flags);
442
443 buf = list_entry(acm->spare_read_bufs.next,
444 struct acm_rb, list);
445 list_del(&buf->list);
446
447 rcv->buffer = buf;
448
449 usb_fill_bulk_urb(rcv->urb, acm->dev,
450 acm->rx_endpoint,
451 buf->base,
452 acm->readsize,
453 acm_read_bulk, rcv);
454 rcv->urb->transfer_dma = buf->dma;
455 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
456
457 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
458 free-urbs-pool and resubmited ASAP */
459 spin_lock_irqsave(&acm->read_lock, flags);
460 if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
461 list_add(&buf->list, &acm->spare_read_bufs);
462 list_add(&rcv->list, &acm->spare_read_urbs);
463 acm->processing = 0;
464 spin_unlock_irqrestore(&acm->read_lock, flags);
465 return;
466 } else {
467 spin_unlock_irqrestore(&acm->read_lock, flags);
468 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
469 }
470 }
471 spin_lock_irqsave(&acm->read_lock, flags);
472 acm->processing = 0;
473 spin_unlock_irqrestore(&acm->read_lock, flags);
474 }
475
476 /* data interface wrote those outgoing bytes */
acm_write_bulk(struct urb * urb)477 static void acm_write_bulk(struct urb *urb)
478 {
479 struct acm_wb *wb = urb->context;
480 struct acm *acm = wb->instance;
481 unsigned long flags;
482
483 if (verbose || urb->status
484 || (urb->actual_length != urb->transfer_buffer_length))
485 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
486 urb->actual_length,
487 urb->transfer_buffer_length,
488 urb->status);
489
490 spin_lock_irqsave(&acm->write_lock, flags);
491 acm_write_done(acm, wb);
492 spin_unlock_irqrestore(&acm->write_lock, flags);
493 if (ACM_READY(acm))
494 schedule_work(&acm->work);
495 else
496 wake_up_interruptible(&acm->drain_wait);
497 }
498
acm_softint(struct work_struct * work)499 static void acm_softint(struct work_struct *work)
500 {
501 struct acm *acm = container_of(work, struct acm, work);
502
503 dev_vdbg(&acm->data->dev, "tx work\n");
504 if (!ACM_READY(acm))
505 return;
506 tty_wakeup(acm->tty);
507 }
508
acm_waker(struct work_struct * waker)509 static void acm_waker(struct work_struct *waker)
510 {
511 struct acm *acm = container_of(waker, struct acm, waker);
512 int rv;
513
514 rv = usb_autopm_get_interface(acm->control);
515 if (rv < 0) {
516 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
517 return;
518 }
519 if (acm->delayed_wb) {
520 acm_start_wb(acm, acm->delayed_wb);
521 acm->delayed_wb = NULL;
522 }
523 usb_autopm_put_interface(acm->control);
524 }
525
526 /*
527 * TTY handlers
528 */
529
acm_tty_open(struct tty_struct * tty,struct file * filp)530 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
531 {
532 struct acm *acm;
533 int rv = -EINVAL;
534 int i;
535 dbg("Entering acm_tty_open.");
536
537 mutex_lock(&open_mutex);
538
539 acm = acm_table[tty->index];
540 if (!acm || !acm->dev)
541 goto err_out;
542 else
543 rv = 0;
544
545 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
546 tty->driver_data = acm;
547 acm->tty = tty;
548
549 /* force low_latency on so that our tty_push actually forces the data through,
550 otherwise it is scheduled, and with high data rates data can get lost. */
551 tty->low_latency = 1;
552
553 if (usb_autopm_get_interface(acm->control) < 0)
554 goto early_bail;
555 else
556 acm->control->needs_remote_wakeup = 1;
557
558 mutex_lock(&acm->mutex);
559 if (acm->used++) {
560 usb_autopm_put_interface(acm->control);
561 goto done;
562 }
563
564
565 acm->ctrlurb->dev = acm->dev;
566 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
567 dbg("usb_submit_urb(ctrl irq) failed");
568 goto bail_out;
569 }
570
571 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
572 (acm->ctrl_caps & USB_CDC_CAP_LINE))
573 goto full_bailout;
574 usb_autopm_put_interface(acm->control);
575
576 INIT_LIST_HEAD(&acm->spare_read_urbs);
577 INIT_LIST_HEAD(&acm->spare_read_bufs);
578 INIT_LIST_HEAD(&acm->filled_read_bufs);
579 for (i = 0; i < acm->rx_buflimit; i++) {
580 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
581 }
582 for (i = 0; i < acm->rx_buflimit; i++) {
583 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
584 }
585
586 acm->throttle = 0;
587
588 tasklet_schedule(&acm->urb_task);
589
590 done:
591 mutex_unlock(&acm->mutex);
592 err_out:
593 mutex_unlock(&open_mutex);
594 return rv;
595
596 full_bailout:
597 usb_kill_urb(acm->ctrlurb);
598 bail_out:
599 usb_autopm_put_interface(acm->control);
600 acm->used--;
601 mutex_unlock(&acm->mutex);
602 early_bail:
603 mutex_unlock(&open_mutex);
604 return -EIO;
605 }
606
acm_tty_unregister(struct acm * acm)607 static void acm_tty_unregister(struct acm *acm)
608 {
609 int i,nr;
610
611 nr = acm->rx_buflimit;
612 tty_unregister_device(acm_tty_driver, acm->minor);
613 usb_put_intf(acm->control);
614 acm_table[acm->minor] = NULL;
615 usb_free_urb(acm->ctrlurb);
616 for (i = 0; i < ACM_NW; i++)
617 usb_free_urb(acm->wb[i].urb);
618 for (i = 0; i < nr; i++)
619 usb_free_urb(acm->ru[i].urb);
620 kfree(acm->country_codes);
621 kfree(acm);
622 }
623
624 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
625
acm_tty_close(struct tty_struct * tty,struct file * filp)626 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
627 {
628 struct acm *acm = tty->driver_data;
629 int i,nr;
630
631 if (!acm || !acm->used)
632 return;
633
634 nr = acm->rx_buflimit;
635 mutex_lock(&open_mutex);
636 if (!--acm->used) {
637 if (acm->dev) {
638 usb_autopm_get_interface(acm->control);
639 acm_set_control(acm, acm->ctrlout = 0);
640
641 /* try letting the last writes drain naturally */
642 wait_event_interruptible_timeout(acm->drain_wait,
643 (ACM_NW == acm_wb_is_avail(acm))
644 || !acm->dev,
645 ACM_CLOSE_TIMEOUT * HZ);
646
647 usb_kill_urb(acm->ctrlurb);
648 for (i = 0; i < ACM_NW; i++)
649 usb_kill_urb(acm->wb[i].urb);
650 for (i = 0; i < nr; i++)
651 usb_kill_urb(acm->ru[i].urb);
652 acm->control->needs_remote_wakeup = 0;
653 usb_autopm_put_interface(acm->control);
654 } else
655 acm_tty_unregister(acm);
656 }
657 mutex_unlock(&open_mutex);
658 }
659
acm_tty_write(struct tty_struct * tty,const unsigned char * buf,int count)660 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
661 {
662 struct acm *acm = tty->driver_data;
663 int stat;
664 unsigned long flags;
665 int wbn;
666 struct acm_wb *wb;
667
668 dbg("Entering acm_tty_write to write %d bytes,", count);
669
670 if (!ACM_READY(acm))
671 return -EINVAL;
672 if (!count)
673 return 0;
674
675 spin_lock_irqsave(&acm->write_lock, flags);
676 if ((wbn = acm_wb_alloc(acm)) < 0) {
677 spin_unlock_irqrestore(&acm->write_lock, flags);
678 return 0;
679 }
680 wb = &acm->wb[wbn];
681
682 count = (count > acm->writesize) ? acm->writesize : count;
683 dbg("Get %d bytes...", count);
684 memcpy(wb->buf, buf, count);
685 wb->len = count;
686 spin_unlock_irqrestore(&acm->write_lock, flags);
687
688 if ((stat = acm_write_start(acm, wbn)) < 0)
689 return stat;
690 return count;
691 }
692
acm_tty_write_room(struct tty_struct * tty)693 static int acm_tty_write_room(struct tty_struct *tty)
694 {
695 struct acm *acm = tty->driver_data;
696 if (!ACM_READY(acm))
697 return -EINVAL;
698 /*
699 * Do not let the line discipline to know that we have a reserve,
700 * or it might get too enthusiastic.
701 */
702 return acm_wb_is_avail(acm) ? acm->writesize : 0;
703 }
704
acm_tty_chars_in_buffer(struct tty_struct * tty)705 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
706 {
707 struct acm *acm = tty->driver_data;
708 if (!ACM_READY(acm))
709 return -EINVAL;
710 /*
711 * This is inaccurate (overcounts), but it works.
712 */
713 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
714 }
715
acm_tty_throttle(struct tty_struct * tty)716 static void acm_tty_throttle(struct tty_struct *tty)
717 {
718 struct acm *acm = tty->driver_data;
719 if (!ACM_READY(acm))
720 return;
721 spin_lock_bh(&acm->throttle_lock);
722 acm->throttle = 1;
723 spin_unlock_bh(&acm->throttle_lock);
724 }
725
acm_tty_unthrottle(struct tty_struct * tty)726 static void acm_tty_unthrottle(struct tty_struct *tty)
727 {
728 struct acm *acm = tty->driver_data;
729 if (!ACM_READY(acm))
730 return;
731 spin_lock_bh(&acm->throttle_lock);
732 acm->throttle = 0;
733 spin_unlock_bh(&acm->throttle_lock);
734 tasklet_schedule(&acm->urb_task);
735 }
736
acm_tty_break_ctl(struct tty_struct * tty,int state)737 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
738 {
739 struct acm *acm = tty->driver_data;
740 int retval;
741 if (!ACM_READY(acm))
742 return -EINVAL;
743 retval = acm_send_break(acm, state ? 0xffff : 0);
744 if (retval < 0)
745 dbg("send break failed");
746 return retval;
747 }
748
acm_tty_tiocmget(struct tty_struct * tty,struct file * file)749 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
750 {
751 struct acm *acm = tty->driver_data;
752
753 if (!ACM_READY(acm))
754 return -EINVAL;
755
756 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
757 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
758 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
759 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
760 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
761 TIOCM_CTS;
762 }
763
acm_tty_tiocmset(struct tty_struct * tty,struct file * file,unsigned int set,unsigned int clear)764 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
765 unsigned int set, unsigned int clear)
766 {
767 struct acm *acm = tty->driver_data;
768 unsigned int newctrl;
769
770 if (!ACM_READY(acm))
771 return -EINVAL;
772
773 newctrl = acm->ctrlout;
774 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
775 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
776
777 newctrl = (newctrl & ~clear) | set;
778
779 if (acm->ctrlout == newctrl)
780 return 0;
781 return acm_set_control(acm, acm->ctrlout = newctrl);
782 }
783
acm_tty_ioctl(struct tty_struct * tty,struct file * file,unsigned int cmd,unsigned long arg)784 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
785 {
786 struct acm *acm = tty->driver_data;
787
788 if (!ACM_READY(acm))
789 return -EINVAL;
790
791 return -ENOIOCTLCMD;
792 }
793
794 static const __u32 acm_tty_speed[] = {
795 0, 50, 75, 110, 134, 150, 200, 300, 600,
796 1200, 1800, 2400, 4800, 9600, 19200, 38400,
797 57600, 115200, 230400, 460800, 500000, 576000,
798 921600, 1000000, 1152000, 1500000, 2000000,
799 2500000, 3000000, 3500000, 4000000
800 };
801
802 static const __u8 acm_tty_size[] = {
803 5, 6, 7, 8
804 };
805
acm_tty_set_termios(struct tty_struct * tty,struct ktermios * termios_old)806 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
807 {
808 struct acm *acm = tty->driver_data;
809 struct ktermios *termios = tty->termios;
810 struct usb_cdc_line_coding newline;
811 int newctrl = acm->ctrlout;
812
813 if (!ACM_READY(acm))
814 return;
815
816 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
817 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
818 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
819 newline.bParityType = termios->c_cflag & PARENB ?
820 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
821 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
822
823 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
824
825 if (!newline.dwDTERate) {
826 newline.dwDTERate = acm->line.dwDTERate;
827 newctrl &= ~ACM_CTRL_DTR;
828 } else newctrl |= ACM_CTRL_DTR;
829
830 if (newctrl != acm->ctrlout)
831 acm_set_control(acm, acm->ctrlout = newctrl);
832
833 if (memcmp(&acm->line, &newline, sizeof newline)) {
834 memcpy(&acm->line, &newline, sizeof newline);
835 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
836 newline.bCharFormat, newline.bParityType,
837 newline.bDataBits);
838 acm_set_line(acm, &acm->line);
839 }
840 }
841
842 /*
843 * USB probe and disconnect routines.
844 */
845
846 /* Little helpers: write/read buffers free */
acm_write_buffers_free(struct acm * acm)847 static void acm_write_buffers_free(struct acm *acm)
848 {
849 int i;
850 struct acm_wb *wb;
851 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
852
853 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
854 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
855 }
856 }
857
acm_read_buffers_free(struct acm * acm)858 static void acm_read_buffers_free(struct acm *acm)
859 {
860 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
861 int i, n = acm->rx_buflimit;
862
863 for (i = 0; i < n; i++)
864 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
865 }
866
867 /* Little helper: write buffers allocate */
acm_write_buffers_alloc(struct acm * acm)868 static int acm_write_buffers_alloc(struct acm *acm)
869 {
870 int i;
871 struct acm_wb *wb;
872
873 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
874 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
875 &wb->dmah);
876 if (!wb->buf) {
877 while (i != 0) {
878 --i;
879 --wb;
880 usb_buffer_free(acm->dev, acm->writesize,
881 wb->buf, wb->dmah);
882 }
883 return -ENOMEM;
884 }
885 }
886 return 0;
887 }
888
acm_probe(struct usb_interface * intf,const struct usb_device_id * id)889 static int acm_probe (struct usb_interface *intf,
890 const struct usb_device_id *id)
891 {
892 struct usb_cdc_union_desc *union_header = NULL;
893 struct usb_cdc_country_functional_desc *cfd = NULL;
894 unsigned char *buffer = intf->altsetting->extra;
895 int buflen = intf->altsetting->extralen;
896 struct usb_interface *control_interface;
897 struct usb_interface *data_interface;
898 struct usb_endpoint_descriptor *epctrl;
899 struct usb_endpoint_descriptor *epread;
900 struct usb_endpoint_descriptor *epwrite;
901 struct usb_device *usb_dev = interface_to_usbdev(intf);
902 struct acm *acm;
903 int minor;
904 int ctrlsize,readsize;
905 u8 *buf;
906 u8 ac_management_function = 0;
907 u8 call_management_function = 0;
908 int call_interface_num = -1;
909 int data_interface_num;
910 unsigned long quirks;
911 int num_rx_buf;
912 int i;
913
914 /* normal quirks */
915 quirks = (unsigned long)id->driver_info;
916 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
917
918 /* handle quirks deadly to normal probing*/
919 if (quirks == NO_UNION_NORMAL) {
920 data_interface = usb_ifnum_to_if(usb_dev, 1);
921 control_interface = usb_ifnum_to_if(usb_dev, 0);
922 goto skip_normal_probe;
923 }
924
925 /* normal probing*/
926 if (!buffer) {
927 dev_err(&intf->dev, "Weird descriptor references\n");
928 return -EINVAL;
929 }
930
931 if (!buflen) {
932 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
933 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
934 buflen = intf->cur_altsetting->endpoint->extralen;
935 buffer = intf->cur_altsetting->endpoint->extra;
936 } else {
937 dev_err(&intf->dev,
938 "Zero length descriptor references\n");
939 return -EINVAL;
940 }
941 }
942
943 while (buflen > 0) {
944 if (buffer [1] != USB_DT_CS_INTERFACE) {
945 dev_err(&intf->dev, "skipping garbage\n");
946 goto next_desc;
947 }
948
949 switch (buffer [2]) {
950 case USB_CDC_UNION_TYPE: /* we've found it */
951 if (union_header) {
952 dev_err(&intf->dev, "More than one "
953 "union descriptor, "
954 "skipping ...\n");
955 goto next_desc;
956 }
957 union_header = (struct usb_cdc_union_desc *)
958 buffer;
959 break;
960 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
961 cfd = (struct usb_cdc_country_functional_desc *)buffer;
962 break;
963 case USB_CDC_HEADER_TYPE: /* maybe check version */
964 break; /* for now we ignore it */
965 case USB_CDC_ACM_TYPE:
966 ac_management_function = buffer[3];
967 break;
968 case USB_CDC_CALL_MANAGEMENT_TYPE:
969 call_management_function = buffer[3];
970 call_interface_num = buffer[4];
971 if ((call_management_function & 3) != 3)
972 dev_err(&intf->dev, "This device "
973 "cannot do calls on its own. "
974 "It is no modem.\n");
975 break;
976 default:
977 /* there are LOTS more CDC descriptors that
978 * could legitimately be found here.
979 */
980 dev_dbg(&intf->dev, "Ignoring descriptor: "
981 "type %02x, length %d\n",
982 buffer[2], buffer[0]);
983 break;
984 }
985 next_desc:
986 buflen -= buffer[0];
987 buffer += buffer[0];
988 }
989
990 if (!union_header) {
991 if (call_interface_num > 0) {
992 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
993 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
994 control_interface = intf;
995 } else {
996 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
997 return -ENODEV;
998 }
999 } else {
1000 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1001 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1002 if (!control_interface || !data_interface) {
1003 dev_dbg(&intf->dev,"no interfaces\n");
1004 return -ENODEV;
1005 }
1006 }
1007
1008 if (data_interface_num != call_interface_num)
1009 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
1010
1011 skip_normal_probe:
1012
1013 /*workaround for switched interfaces */
1014 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
1015 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
1016 struct usb_interface *t;
1017 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
1018
1019 t = control_interface;
1020 control_interface = data_interface;
1021 data_interface = t;
1022 } else {
1023 return -EINVAL;
1024 }
1025 }
1026
1027 /* Accept probe requests only for the control interface */
1028 if (intf != control_interface)
1029 return -ENODEV;
1030
1031 if (usb_interface_claimed(data_interface)) { /* valid in this context */
1032 dev_dbg(&intf->dev,"The data interface isn't available\n");
1033 return -EBUSY;
1034 }
1035
1036
1037 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1038 return -EINVAL;
1039
1040 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1041 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1042 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1043
1044
1045 /* workaround for switched endpoints */
1046 if (!usb_endpoint_dir_in(epread)) {
1047 /* descriptors are swapped */
1048 struct usb_endpoint_descriptor *t;
1049 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
1050
1051 t = epread;
1052 epread = epwrite;
1053 epwrite = t;
1054 }
1055 dbg("interfaces are valid");
1056 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1057
1058 if (minor == ACM_TTY_MINORS) {
1059 dev_err(&intf->dev, "no more free acm devices\n");
1060 return -ENODEV;
1061 }
1062
1063 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
1064 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1065 goto alloc_fail;
1066 }
1067
1068 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1069 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
1070 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1071 acm->control = control_interface;
1072 acm->data = data_interface;
1073 acm->minor = minor;
1074 acm->dev = usb_dev;
1075 acm->ctrl_caps = ac_management_function;
1076 acm->ctrlsize = ctrlsize;
1077 acm->readsize = readsize;
1078 acm->rx_buflimit = num_rx_buf;
1079 acm->urb_task.func = acm_rx_tasklet;
1080 acm->urb_task.data = (unsigned long) acm;
1081 INIT_WORK(&acm->work, acm_softint);
1082 INIT_WORK(&acm->waker, acm_waker);
1083 init_waitqueue_head(&acm->drain_wait);
1084 spin_lock_init(&acm->throttle_lock);
1085 spin_lock_init(&acm->write_lock);
1086 spin_lock_init(&acm->read_lock);
1087 mutex_init(&acm->mutex);
1088 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1089
1090 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1091 if (!buf) {
1092 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1093 goto alloc_fail2;
1094 }
1095 acm->ctrl_buffer = buf;
1096
1097 if (acm_write_buffers_alloc(acm) < 0) {
1098 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1099 goto alloc_fail4;
1100 }
1101
1102 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1103 if (!acm->ctrlurb) {
1104 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1105 goto alloc_fail5;
1106 }
1107 for (i = 0; i < num_rx_buf; i++) {
1108 struct acm_ru *rcv = &(acm->ru[i]);
1109
1110 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1111 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1112 goto alloc_fail7;
1113 }
1114
1115 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1116 rcv->instance = acm;
1117 }
1118 for (i = 0; i < num_rx_buf; i++) {
1119 struct acm_rb *rb = &(acm->rb[i]);
1120
1121 rb->base = usb_buffer_alloc(acm->dev, readsize,
1122 GFP_KERNEL, &rb->dma);
1123 if (!rb->base) {
1124 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1125 goto alloc_fail7;
1126 }
1127 }
1128 for(i = 0; i < ACM_NW; i++)
1129 {
1130 struct acm_wb *snd = &(acm->wb[i]);
1131
1132 if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1133 dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
1134 goto alloc_fail7;
1135 }
1136
1137 usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1138 NULL, acm->writesize, acm_write_bulk, snd);
1139 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1140 snd->instance = acm;
1141 }
1142
1143 usb_set_intfdata (intf, acm);
1144
1145 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1146 if (i < 0)
1147 goto alloc_fail8;
1148
1149 if (cfd) { /* export the country data */
1150 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1151 if (!acm->country_codes)
1152 goto skip_countries;
1153 acm->country_code_size = cfd->bLength - 4;
1154 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1155 acm->country_rel_date = cfd->iCountryCodeRelDate;
1156
1157 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1158 if (i < 0) {
1159 kfree(acm->country_codes);
1160 goto skip_countries;
1161 }
1162
1163 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1164 if (i < 0) {
1165 kfree(acm->country_codes);
1166 goto skip_countries;
1167 }
1168 }
1169
1170 skip_countries:
1171 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1172 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1173 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1174 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1175
1176 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1177
1178 acm_set_control(acm, acm->ctrlout);
1179
1180 acm->line.dwDTERate = cpu_to_le32(9600);
1181 acm->line.bDataBits = 8;
1182 acm_set_line(acm, &acm->line);
1183
1184 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1185 usb_set_intfdata(data_interface, acm);
1186
1187 usb_get_intf(control_interface);
1188 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1189
1190 acm_table[minor] = acm;
1191
1192 return 0;
1193 alloc_fail8:
1194 for (i = 0; i < ACM_NW; i++)
1195 usb_free_urb(acm->wb[i].urb);
1196 alloc_fail7:
1197 acm_read_buffers_free(acm);
1198 for (i = 0; i < num_rx_buf; i++)
1199 usb_free_urb(acm->ru[i].urb);
1200 usb_free_urb(acm->ctrlurb);
1201 alloc_fail5:
1202 acm_write_buffers_free(acm);
1203 alloc_fail4:
1204 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1205 alloc_fail2:
1206 kfree(acm);
1207 alloc_fail:
1208 return -ENOMEM;
1209 }
1210
stop_data_traffic(struct acm * acm)1211 static void stop_data_traffic(struct acm *acm)
1212 {
1213 int i;
1214 dbg("Entering stop_data_traffic");
1215
1216 tasklet_disable(&acm->urb_task);
1217
1218 usb_kill_urb(acm->ctrlurb);
1219 for(i = 0; i < ACM_NW; i++)
1220 usb_kill_urb(acm->wb[i].urb);
1221 for (i = 0; i < acm->rx_buflimit; i++)
1222 usb_kill_urb(acm->ru[i].urb);
1223
1224 tasklet_enable(&acm->urb_task);
1225
1226 cancel_work_sync(&acm->work);
1227 cancel_work_sync(&acm->waker);
1228 }
1229
acm_disconnect(struct usb_interface * intf)1230 static void acm_disconnect(struct usb_interface *intf)
1231 {
1232 struct acm *acm = usb_get_intfdata(intf);
1233 struct usb_device *usb_dev = interface_to_usbdev(intf);
1234
1235 /* sibling interface is already cleaning up */
1236 if (!acm)
1237 return;
1238
1239 mutex_lock(&open_mutex);
1240 if (acm->country_codes){
1241 device_remove_file(&acm->control->dev,
1242 &dev_attr_wCountryCodes);
1243 device_remove_file(&acm->control->dev,
1244 &dev_attr_iCountryCodeRelDate);
1245 }
1246 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1247 acm->dev = NULL;
1248 usb_set_intfdata(acm->control, NULL);
1249 usb_set_intfdata(acm->data, NULL);
1250
1251 stop_data_traffic(acm);
1252
1253 acm_write_buffers_free(acm);
1254 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1255 acm_read_buffers_free(acm);
1256
1257 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1258 acm->data : acm->control);
1259
1260 if (!acm->used) {
1261 acm_tty_unregister(acm);
1262 mutex_unlock(&open_mutex);
1263 return;
1264 }
1265
1266 mutex_unlock(&open_mutex);
1267
1268 if (acm->tty)
1269 tty_hangup(acm->tty);
1270 }
1271
1272 #ifdef CONFIG_PM
acm_suspend(struct usb_interface * intf,pm_message_t message)1273 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1274 {
1275 struct acm *acm = usb_get_intfdata(intf);
1276 int cnt;
1277
1278 if (message.event & PM_EVENT_AUTO) {
1279 int b;
1280
1281 spin_lock_irq(&acm->read_lock);
1282 spin_lock(&acm->write_lock);
1283 b = acm->processing + acm->transmitting;
1284 spin_unlock(&acm->write_lock);
1285 spin_unlock_irq(&acm->read_lock);
1286 if (b)
1287 return -EBUSY;
1288 }
1289
1290 spin_lock_irq(&acm->read_lock);
1291 spin_lock(&acm->write_lock);
1292 cnt = acm->susp_count++;
1293 spin_unlock(&acm->write_lock);
1294 spin_unlock_irq(&acm->read_lock);
1295
1296 if (cnt)
1297 return 0;
1298 /*
1299 we treat opened interfaces differently,
1300 we must guard against open
1301 */
1302 mutex_lock(&acm->mutex);
1303
1304 if (acm->used)
1305 stop_data_traffic(acm);
1306
1307 mutex_unlock(&acm->mutex);
1308 return 0;
1309 }
1310
acm_resume(struct usb_interface * intf)1311 static int acm_resume(struct usb_interface *intf)
1312 {
1313 struct acm *acm = usb_get_intfdata(intf);
1314 int rv = 0;
1315 int cnt;
1316
1317 spin_lock_irq(&acm->read_lock);
1318 acm->susp_count -= 1;
1319 cnt = acm->susp_count;
1320 spin_unlock_irq(&acm->read_lock);
1321
1322 if (cnt)
1323 return 0;
1324
1325 mutex_lock(&acm->mutex);
1326 if (acm->used) {
1327 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1328 if (rv < 0)
1329 goto err_out;
1330
1331 tasklet_schedule(&acm->urb_task);
1332 }
1333
1334 err_out:
1335 mutex_unlock(&acm->mutex);
1336 return rv;
1337 }
1338
1339 #endif /* CONFIG_PM */
1340 /*
1341 * USB driver structure.
1342 */
1343
1344 static struct usb_device_id acm_ids[] = {
1345 /* quirky and broken devices */
1346 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1347 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1348 },
1349 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1350 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1351 },
1352 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1353 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1354 },
1355 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1356 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1357 },
1358 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1359 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1360 },
1361 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1362 .driver_info = SINGLE_RX_URB, /* firmware bug */
1363 },
1364 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1365 .driver_info = SINGLE_RX_URB, /* firmware bug */
1366 },
1367 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1368 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1369 },
1370 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1371 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1372 },
1373 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1374 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1375 },
1376 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1377 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1378 },
1379 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1380 },
1381 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1382 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1383 data interface instead of
1384 communications interface.
1385 Maybe we should define a new
1386 quirk for this. */
1387 },
1388
1389 /* control interfaces with various AT-command sets */
1390 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1391 USB_CDC_ACM_PROTO_AT_V25TER) },
1392 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1393 USB_CDC_ACM_PROTO_AT_PCCA101) },
1394 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1395 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1396 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1397 USB_CDC_ACM_PROTO_AT_GSM) },
1398 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1399 USB_CDC_ACM_PROTO_AT_3G ) },
1400 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1401 USB_CDC_ACM_PROTO_AT_CDMA) },
1402
1403 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1404 { }
1405 };
1406
1407 MODULE_DEVICE_TABLE (usb, acm_ids);
1408
1409 static struct usb_driver acm_driver = {
1410 .name = "cdc_acm",
1411 .probe = acm_probe,
1412 .disconnect = acm_disconnect,
1413 #ifdef CONFIG_PM
1414 .suspend = acm_suspend,
1415 .resume = acm_resume,
1416 #endif
1417 .id_table = acm_ids,
1418 #ifdef CONFIG_PM
1419 .supports_autosuspend = 1,
1420 #endif
1421 };
1422
1423 /*
1424 * TTY driver structures.
1425 */
1426
1427 static const struct tty_operations acm_ops = {
1428 .open = acm_tty_open,
1429 .close = acm_tty_close,
1430 .write = acm_tty_write,
1431 .write_room = acm_tty_write_room,
1432 .ioctl = acm_tty_ioctl,
1433 .throttle = acm_tty_throttle,
1434 .unthrottle = acm_tty_unthrottle,
1435 .chars_in_buffer = acm_tty_chars_in_buffer,
1436 .break_ctl = acm_tty_break_ctl,
1437 .set_termios = acm_tty_set_termios,
1438 .tiocmget = acm_tty_tiocmget,
1439 .tiocmset = acm_tty_tiocmset,
1440 };
1441
1442 /*
1443 * Init / exit.
1444 */
1445
acm_init(void)1446 static int __init acm_init(void)
1447 {
1448 int retval;
1449 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1450 if (!acm_tty_driver)
1451 return -ENOMEM;
1452 acm_tty_driver->owner = THIS_MODULE,
1453 acm_tty_driver->driver_name = "acm",
1454 acm_tty_driver->name = "ttyACM",
1455 acm_tty_driver->major = ACM_TTY_MAJOR,
1456 acm_tty_driver->minor_start = 0,
1457 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1458 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1459 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1460 acm_tty_driver->init_termios = tty_std_termios;
1461 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1462 tty_set_operations(acm_tty_driver, &acm_ops);
1463
1464 retval = tty_register_driver(acm_tty_driver);
1465 if (retval) {
1466 put_tty_driver(acm_tty_driver);
1467 return retval;
1468 }
1469
1470 retval = usb_register(&acm_driver);
1471 if (retval) {
1472 tty_unregister_driver(acm_tty_driver);
1473 put_tty_driver(acm_tty_driver);
1474 return retval;
1475 }
1476
1477 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1478 DRIVER_DESC "\n");
1479
1480 return 0;
1481 }
1482
acm_exit(void)1483 static void __exit acm_exit(void)
1484 {
1485 usb_deregister(&acm_driver);
1486 tty_unregister_driver(acm_tty_driver);
1487 put_tty_driver(acm_tty_driver);
1488 }
1489
1490 module_init(acm_init);
1491 module_exit(acm_exit);
1492
1493 MODULE_AUTHOR( DRIVER_AUTHOR );
1494 MODULE_DESCRIPTION( DRIVER_DESC );
1495 MODULE_LICENSE("GPL");
1496
1497