?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / usb / class / cdc-acm.c
blob98b700bcfa7c20f9a265d3a4f8201b2f8202de4e
1 /*
2 * cdc-acm.c
3 *
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>
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
20 * kmalloced
21 * v0.13 - added termios, added hangup
22 * v0.14 - sized down struct acm
23 * v0.15 - fixed flow control again - characters could be lost
24 * v0.16 - added code for modems with swapped data and control interfaces
25 * v0.17 - added new style probing
26 * v0.18 - fixed new style probing for devices with more configurations
27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28 * v0.20 - switched to probing on interface (rather than device) class
29 * v0.21 - revert to probing on device for devices with multiple configs
30 * v0.22 - probe only the control interface. if usbcore doesn't choose the
31 * config we want, sysadmin changes bConfigurationValue in sysfs.
32 * v0.23 - use softirq for rx processing, as needed by tty layer
33 * v0.24 - change probe method to evaluate CDC union descriptor
34 * v0.25 - downstream tasks paralelized to maximize throughput
35 * v0.26 - multiple write urbs, writesize increased
36 */
37
38 /*
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
43 *
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 * GNU General Public License for more details.
48 *
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
52 */
53
54 #undef DEBUG
55 #undef VERBOSE_DEBUG
56
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/init.h>
60 #include <linux/slab.h>
61 #include <linux/tty.h>
62 #include <linux/serial.h>
63 #include <linux/tty_driver.h>
64 #include <linux/tty_flip.h>
65 #include <linux/module.h>
66 #include <linux/mutex.h>
67 #include <linux/uaccess.h>
68 #include <linux/usb.h>
69 #include <linux/usb/cdc.h>
70 #include <asm/byteorder.h>
71 #include <asm/unaligned.h>
72 #include <linux/list.h>
73
74 #include "cdc-acm.h"
75
76
77 #define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
78
79 /*
80 * Version Information
81 */
82 #define DRIVER_VERSION "v0.26"
83 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
84 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
85
86 static struct usb_driver acm_driver;
87 static struct tty_driver *acm_tty_driver;
88 static struct acm *acm_table[ACM_TTY_MINORS];
89
90 static DEFINE_MUTEX(open_mutex);
91
92 #define ACM_READY(acm) (acm && acm->dev && acm->port.count)
93
94 static const struct tty_port_operations acm_port_ops = {
95 };
96
97 #ifdef VERBOSE_DEBUG
98 #define verbose 1
99 #else
100 #define verbose 0
101 #endif
102
103 /*
104 * Functions for ACM control messages.
105 */
106
107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
108 void *buf, int len)
109 {
110 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
111 request, USB_RT_ACM, value,
112 acm->control->altsetting[0].desc.bInterfaceNumber,
113 buf, len, 5000);
114 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
115 request, value, len, retval);
116 return retval < 0 ? retval : 0;
117 }
118
119 /* devices aren't required to support these requests.
120 * the cdc acm descriptor tells whether they do...
121 */
122 #define acm_set_control(acm, control) \
123 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124 #define acm_set_line(acm, line) \
125 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126 #define acm_send_break(acm, ms) \
127 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
128
129 /*
130 * Write buffer management.
131 * All of these assume proper locks taken by the caller.
132 */
133
134 static int acm_wb_alloc(struct acm *acm)
135 {
136 int i, wbn;
137 struct acm_wb *wb;
138
139 wbn = 0;
140 i = 0;
141 for (;;) {
142 wb = &acm->wb[wbn];
143 if (!wb->use) {
144 wb->use = 1;
145 return wbn;
146 }
147 wbn = (wbn + 1) % ACM_NW;
148 if (++i >= ACM_NW)
149 return -1;
150 }
151 }
152
153 static int acm_wb_is_avail(struct acm *acm)
154 {
155 int i, n;
156 unsigned long flags;
157
158 n = ACM_NW;
159 spin_lock_irqsave(&acm->write_lock, flags);
160 for (i = 0; i < ACM_NW; i++)
161 n -= acm->wb[i].use;
162 spin_unlock_irqrestore(&acm->write_lock, flags);
163 return n;
164 }
165
166 /*
167 * Finish write. Caller must hold acm->write_lock
168 */
169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
170 {
171 wb->use = 0;
172 acm->transmitting--;
173 usb_autopm_put_interface_async(acm->control);
174 }
175
176 /*
177 * Poke write.
178 *
179 * the caller is responsible for locking
180 */
181
182 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
183 {
184 int rc;
185
186 acm->transmitting++;
187
188 wb->urb->transfer_buffer = wb->buf;
189 wb->urb->transfer_dma = wb->dmah;
190 wb->urb->transfer_buffer_length = wb->len;
191 wb->urb->dev = acm->dev;
192
193 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
194 if (rc < 0) {
195 dbg("usb_submit_urb(write bulk) failed: %d", rc);
196 acm_write_done(acm, wb);
197 }
198 return rc;
199 }
200
201 static int acm_write_start(struct acm *acm, int wbn)
202 {
203 unsigned long flags;
204 struct acm_wb *wb = &acm->wb[wbn];
205 int rc;
206
207 spin_lock_irqsave(&acm->write_lock, flags);
208 if (!acm->dev) {
209 wb->use = 0;
210 spin_unlock_irqrestore(&acm->write_lock, flags);
211 return -ENODEV;
212 }
213
214 dbg("%s susp_count: %d", __func__, acm->susp_count);
215 usb_autopm_get_interface_async(acm->control);
216 if (acm->susp_count) {
217 if (!acm->delayed_wb)
218 acm->delayed_wb = wb;
219 else
220 usb_autopm_put_interface_async(acm->control);
221 spin_unlock_irqrestore(&acm->write_lock, flags);
222 return 0; /* A white lie */
223 }
224 usb_mark_last_busy(acm->dev);
225
226 rc = acm_start_wb(acm, wb);
227 spin_unlock_irqrestore(&acm->write_lock, flags);
228
229 return rc;
230
231 }
232 /*
233 * attributes exported through sysfs
234 */
235 static ssize_t show_caps
236 (struct device *dev, struct device_attribute *attr, char *buf)
237 {
238 struct usb_interface *intf = to_usb_interface(dev);
239 struct acm *acm = usb_get_intfdata(intf);
240
241 return sprintf(buf, "%d", acm->ctrl_caps);
242 }
243 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
244
245 static ssize_t show_country_codes
246 (struct device *dev, struct device_attribute *attr, char *buf)
247 {
248 struct usb_interface *intf = to_usb_interface(dev);
249 struct acm *acm = usb_get_intfdata(intf);
250
251 memcpy(buf, acm->country_codes, acm->country_code_size);
252 return acm->country_code_size;
253 }
254
255 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
256
257 static ssize_t show_country_rel_date
258 (struct device *dev, struct device_attribute *attr, char *buf)
259 {
260 struct usb_interface *intf = to_usb_interface(dev);
261 struct acm *acm = usb_get_intfdata(intf);
262
263 return sprintf(buf, "%d", acm->country_rel_date);
264 }
265
266 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
267 /*
268 * Interrupt handlers for various ACM device responses
269 */
270
271 /* control interface reports status changes with "interrupt" transfers */
272 static void acm_ctrl_irq(struct urb *urb)
273 {
274 struct acm *acm = urb->context;
275 struct usb_cdc_notification *dr = urb->transfer_buffer;
276 struct tty_struct *tty;
277 unsigned char *data;
278 int newctrl;
279 int retval;
280 int status = urb->status;
281
282 switch (status) {
283 case 0:
284 /* success */
285 break;
286 case -ECONNRESET:
287 case -ENOENT:
288 case -ESHUTDOWN:
289 /* this urb is terminated, clean up */
290 dbg("%s - urb shutting down with status: %d", __func__, status);
291 return;
292 default:
293 dbg("%s - nonzero urb status received: %d", __func__, status);
294 goto exit;
295 }
296
297 if (!ACM_READY(acm))
298 goto exit;
299
300 data = (unsigned char *)(dr + 1);
301 switch (dr->bNotificationType) {
302 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
303 dbg("%s network", dr->wValue ?
304 "connected to" : "disconnected from");
305 break;
306
307 case USB_CDC_NOTIFY_SERIAL_STATE:
308 tty = tty_port_tty_get(&acm->port);
309 newctrl = get_unaligned_le16(data);
310
311 if (tty) {
312 if (!acm->clocal &&
313 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
314 dbg("calling hangup");
315 tty_hangup(tty);
316 }
317 tty_kref_put(tty);
318 }
319
320 acm->ctrlin = newctrl;
321
322 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
323 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
328 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
329 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
330 break;
331
332 default:
333 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
334 dr->bNotificationType, dr->wIndex,
335 dr->wLength, data[0], data[1]);
336 break;
337 }
338 exit:
339 usb_mark_last_busy(acm->dev);
340 retval = usb_submit_urb(urb, GFP_ATOMIC);
341 if (retval)
342 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
343 "result %d", __func__, retval);
344 }
345
346 /* data interface returns incoming bytes, or we got unthrottled */
347 static void acm_read_bulk(struct urb *urb)
348 {
349 struct acm_rb *buf;
350 struct acm_ru *rcv = urb->context;
351 struct acm *acm = rcv->instance;
352 int status = urb->status;
353
354 dbg("Entering acm_read_bulk with status %d", status);
355
356 if (!ACM_READY(acm)) {
357 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
358 return;
359 }
360 usb_mark_last_busy(acm->dev);
361
362 if (status)
363 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
364
365 buf = rcv->buffer;
366 buf->size = urb->actual_length;
367
368 if (likely(status == 0)) {
369 spin_lock(&acm->read_lock);
370 acm->processing++;
371 list_add_tail(&rcv->list, &acm->spare_read_urbs);
372 list_add_tail(&buf->list, &acm->filled_read_bufs);
373 spin_unlock(&acm->read_lock);
374 } else {
375 /* we drop the buffer due to an error */
376 spin_lock(&acm->read_lock);
377 list_add_tail(&rcv->list, &acm->spare_read_urbs);
378 list_add(&buf->list, &acm->spare_read_bufs);
379 spin_unlock(&acm->read_lock);
380 /* nevertheless the tasklet must be kicked unconditionally
381 so the queue cannot dry up */
382 }
383 if (likely(!acm->susp_count))
384 tasklet_schedule(&acm->urb_task);
385 }
386
387 static void acm_rx_tasklet(unsigned long _acm)
388 {
389 struct acm *acm = (void *)_acm;
390 struct acm_rb *buf;
391 struct tty_struct *tty;
392 struct acm_ru *rcv;
393 unsigned long flags;
394 unsigned char throttled;
395
396 dbg("Entering acm_rx_tasklet");
397
398 if (!ACM_READY(acm)) {
399 dbg("acm_rx_tasklet: ACM not ready");
400 return;
401 }
402
403 spin_lock_irqsave(&acm->throttle_lock, flags);
404 throttled = acm->throttle;
405 spin_unlock_irqrestore(&acm->throttle_lock, flags);
406 if (throttled) {
407 dbg("acm_rx_tasklet: throttled");
408 return;
409 }
410
411 tty = tty_port_tty_get(&acm->port);
412
413 next_buffer:
414 spin_lock_irqsave(&acm->read_lock, flags);
415 if (list_empty(&acm->filled_read_bufs)) {
416 spin_unlock_irqrestore(&acm->read_lock, flags);
417 goto urbs;
418 }
419 buf = list_entry(acm->filled_read_bufs.next,
420 struct acm_rb, list);
421 list_del(&buf->list);
422 spin_unlock_irqrestore(&acm->read_lock, flags);
423
424 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
425
426 if (tty) {
427 spin_lock_irqsave(&acm->throttle_lock, flags);
428 throttled = acm->throttle;
429 spin_unlock_irqrestore(&acm->throttle_lock, flags);
430 if (!throttled) {
431 tty_insert_flip_string(tty, buf->base, buf->size);
432 tty_flip_buffer_push(tty);
433 } else {
434 tty_kref_put(tty);
435 dbg("Throttling noticed");
436 spin_lock_irqsave(&acm->read_lock, flags);
437 list_add(&buf->list, &acm->filled_read_bufs);
438 spin_unlock_irqrestore(&acm->read_lock, flags);
439 return;
440 }
441 }
442
443 spin_lock_irqsave(&acm->read_lock, flags);
444 list_add(&buf->list, &acm->spare_read_bufs);
445 spin_unlock_irqrestore(&acm->read_lock, flags);
446 goto next_buffer;
447
448 urbs:
449 tty_kref_put(tty);
450
451 while (!list_empty(&acm->spare_read_bufs)) {
452 spin_lock_irqsave(&acm->read_lock, flags);
453 if (list_empty(&acm->spare_read_urbs)) {
454 acm->processing = 0;
455 spin_unlock_irqrestore(&acm->read_lock, flags);
456 return;
457 }
458 rcv = list_entry(acm->spare_read_urbs.next,
459 struct acm_ru, list);
460 list_del(&rcv->list);
461 spin_unlock_irqrestore(&acm->read_lock, flags);
462
463 buf = list_entry(acm->spare_read_bufs.next,
464 struct acm_rb, list);
465 list_del(&buf->list);
466
467 rcv->buffer = buf;
468
469 if (acm->is_int_ep)
470 usb_fill_int_urb(rcv->urb, acm->dev,
471 acm->rx_endpoint,
472 buf->base,
473 acm->readsize,
474 acm_read_bulk, rcv, acm->bInterval);
475 else
476 usb_fill_bulk_urb(rcv->urb, acm->dev,
477 acm->rx_endpoint,
478 buf->base,
479 acm->readsize,
480 acm_read_bulk, rcv);
481 rcv->urb->transfer_dma = buf->dma;
482 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
483
484 /* This shouldn't kill the driver as unsuccessful URBs are
485 returned to the free-urbs-pool and resubmited ASAP */
486 spin_lock_irqsave(&acm->read_lock, flags);
487 if (acm->susp_count ||
488 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
489 list_add(&buf->list, &acm->spare_read_bufs);
490 list_add(&rcv->list, &acm->spare_read_urbs);
491 acm->processing = 0;
492 spin_unlock_irqrestore(&acm->read_lock, flags);
493 return;
494 } else {
495 spin_unlock_irqrestore(&acm->read_lock, flags);
496 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
497 }
498 }
499 spin_lock_irqsave(&acm->read_lock, flags);
500 acm->processing = 0;
501 spin_unlock_irqrestore(&acm->read_lock, flags);
502 }
503
504 /* data interface wrote those outgoing bytes */
505 static void acm_write_bulk(struct urb *urb)
506 {
507 struct acm_wb *wb = urb->context;
508 struct acm *acm = wb->instance;
509 unsigned long flags;
510
511 if (verbose || urb->status
512 || (urb->actual_length != urb->transfer_buffer_length))
513 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
514 urb->actual_length,
515 urb->transfer_buffer_length,
516 urb->status);
517
518 spin_lock_irqsave(&acm->write_lock, flags);
519 acm_write_done(acm, wb);
520 spin_unlock_irqrestore(&acm->write_lock, flags);
521 if (ACM_READY(acm))
522 schedule_work(&acm->work);
523 else
524 wake_up_interruptible(&acm->drain_wait);
525 }
526
527 static void acm_softint(struct work_struct *work)
528 {
529 struct acm *acm = container_of(work, struct acm, work);
530 struct tty_struct *tty;
531
532 dev_vdbg(&acm->data->dev, "tx work\n");
533 if (!ACM_READY(acm))
534 return;
535 tty = tty_port_tty_get(&acm->port);
536 tty_wakeup(tty);
537 tty_kref_put(tty);
538 }
539
540 /*
541 * TTY handlers
542 */
543
544 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
545 {
546 struct acm *acm;
547 int rv = -ENODEV;
548 int i;
549 dbg("Entering acm_tty_open.");
550
551 mutex_lock(&open_mutex);
552
553 acm = acm_table[tty->index];
554 if (!acm || !acm->dev)
555 goto out;
556 else
557 rv = 0;
558
559 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
560
561 tty->driver_data = acm;
562 tty_port_tty_set(&acm->port, tty);
563
564 if (usb_autopm_get_interface(acm->control) < 0)
565 goto early_bail;
566 else
567 acm->control->needs_remote_wakeup = 1;
568
569 mutex_lock(&acm->mutex);
570 if (acm->port.count++) {
571 mutex_unlock(&acm->mutex);
572 usb_autopm_put_interface(acm->control);
573 goto out;
574 }
575
576 acm->ctrlurb->dev = acm->dev;
577 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
578 dbg("usb_submit_urb(ctrl irq) failed");
579 goto bail_out;
580 }
581
582 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
583 (acm->ctrl_caps & USB_CDC_CAP_LINE))
584 goto full_bailout;
585
586 usb_autopm_put_interface(acm->control);
587
588 INIT_LIST_HEAD(&acm->spare_read_urbs);
589 INIT_LIST_HEAD(&acm->spare_read_bufs);
590 INIT_LIST_HEAD(&acm->filled_read_bufs);
591
592 for (i = 0; i < acm->rx_buflimit; i++)
593 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
594 for (i = 0; i < acm->rx_buflimit; i++)
595 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
596
597 acm->throttle = 0;
598
599 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
600 rv = tty_port_block_til_ready(&acm->port, tty, filp);
601 tasklet_schedule(&acm->urb_task);
602
603 mutex_unlock(&acm->mutex);
604 out:
605 mutex_unlock(&open_mutex);
606 return rv;
607
608 full_bailout:
609 usb_kill_urb(acm->ctrlurb);
610 bail_out:
611 acm->port.count--;
612 mutex_unlock(&acm->mutex);
613 usb_autopm_put_interface(acm->control);
614 early_bail:
615 mutex_unlock(&open_mutex);
616 tty_port_tty_set(&acm->port, NULL);
617 return -EIO;
618 }
619
620 static void acm_tty_unregister(struct acm *acm)
621 {
622 int i, nr;
623
624 nr = acm->rx_buflimit;
625 tty_unregister_device(acm_tty_driver, acm->minor);
626 usb_put_intf(acm->control);
627 acm_table[acm->minor] = NULL;
628 usb_free_urb(acm->ctrlurb);
629 for (i = 0; i < ACM_NW; i++)
630 usb_free_urb(acm->wb[i].urb);
631 for (i = 0; i < nr; i++)
632 usb_free_urb(acm->ru[i].urb);
633 kfree(acm->country_codes);
634 kfree(acm);
635 }
636
637 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
638
639 static void acm_port_down(struct acm *acm)
640 {
641 int i, nr = acm->rx_buflimit;
642 mutex_lock(&open_mutex);
643 if (acm->dev) {
644 usb_autopm_get_interface(acm->control);
645 acm_set_control(acm, acm->ctrlout = 0);
646 usb_kill_urb(acm->ctrlurb);
647 for (i = 0; i < ACM_NW; i++)
648 usb_kill_urb(acm->wb[i].urb);
649 for (i = 0; i < nr; i++)
650 usb_kill_urb(acm->ru[i].urb);
651 acm->control->needs_remote_wakeup = 0;
652 usb_autopm_put_interface(acm->control);
653 }
654 mutex_unlock(&open_mutex);
655 }
656
657 static void acm_tty_hangup(struct tty_struct *tty)
658 {
659 struct acm *acm = tty->driver_data;
660 tty_port_hangup(&acm->port);
661 acm_port_down(acm);
662 }
663
664 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
665 {
666 struct acm *acm = tty->driver_data;
667
668 /* Perform the closing process and see if we need to do the hardware
669 shutdown */
670 if (!acm)
671 return;
672 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
673 mutex_lock(&open_mutex);
674 if (!acm->dev) {
675 tty_port_tty_set(&acm->port, NULL);
676 acm_tty_unregister(acm);
677 tty->driver_data = NULL;
678 }
679 mutex_unlock(&open_mutex);
680 return;
681 }
682 acm_port_down(acm);
683 tty_port_close_end(&acm->port, tty);
684 tty_port_tty_set(&acm->port, NULL);
685 }
686
687 static int acm_tty_write(struct tty_struct *tty,
688 const unsigned char *buf, int count)
689 {
690 struct acm *acm = tty->driver_data;
691 int stat;
692 unsigned long flags;
693 int wbn;
694 struct acm_wb *wb;
695
696 dbg("Entering acm_tty_write to write %d bytes,", count);
697
698 if (!ACM_READY(acm))
699 return -EINVAL;
700 if (!count)
701 return 0;
702
703 spin_lock_irqsave(&acm->write_lock, flags);
704 wbn = acm_wb_alloc(acm);
705 if (wbn < 0) {
706 spin_unlock_irqrestore(&acm->write_lock, flags);
707 return 0;
708 }
709 wb = &acm->wb[wbn];
710
711 count = (count > acm->writesize) ? acm->writesize : count;
712 dbg("Get %d bytes...", count);
713 memcpy(wb->buf, buf, count);
714 wb->len = count;
715 spin_unlock_irqrestore(&acm->write_lock, flags);
716
717 stat = acm_write_start(acm, wbn);
718 if (stat < 0)
719 return stat;
720 return count;
721 }
722
723 static int acm_tty_write_room(struct tty_struct *tty)
724 {
725 struct acm *acm = tty->driver_data;
726 if (!ACM_READY(acm))
727 return -EINVAL;
728 /*
729 * Do not let the line discipline to know that we have a reserve,
730 * or it might get too enthusiastic.
731 */
732 return acm_wb_is_avail(acm) ? acm->writesize : 0;
733 }
734
735 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
736 {
737 struct acm *acm = tty->driver_data;
738 if (!ACM_READY(acm))
739 return 0;
740 /*
741 * This is inaccurate (overcounts), but it works.
742 */
743 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
744 }
745
746 static void acm_tty_throttle(struct tty_struct *tty)
747 {
748 struct acm *acm = tty->driver_data;
749 if (!ACM_READY(acm))
750 return;
751 spin_lock_bh(&acm->throttle_lock);
752 acm->throttle = 1;
753 spin_unlock_bh(&acm->throttle_lock);
754 }
755
756 static void acm_tty_unthrottle(struct tty_struct *tty)
757 {
758 struct acm *acm = tty->driver_data;
759 if (!ACM_READY(acm))
760 return;
761 spin_lock_bh(&acm->throttle_lock);
762 acm->throttle = 0;
763 spin_unlock_bh(&acm->throttle_lock);
764 tasklet_schedule(&acm->urb_task);
765 }
766
767 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
768 {
769 struct acm *acm = tty->driver_data;
770 int retval;
771 if (!ACM_READY(acm))
772 return -EINVAL;
773 retval = acm_send_break(acm, state ? 0xffff : 0);
774 if (retval < 0)
775 dbg("send break failed");
776 return retval;
777 }
778
779 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
780 {
781 struct acm *acm = tty->driver_data;
782
783 if (!ACM_READY(acm))
784 return -EINVAL;
785
786 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
787 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
788 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
789 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
790 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
791 TIOCM_CTS;
792 }
793
794 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
795 unsigned int set, unsigned int clear)
796 {
797 struct acm *acm = tty->driver_data;
798 unsigned int newctrl;
799
800 if (!ACM_READY(acm))
801 return -EINVAL;
802
803 newctrl = acm->ctrlout;
804 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
805 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
806 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
807 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
808
809 newctrl = (newctrl & ~clear) | set;
810
811 if (acm->ctrlout == newctrl)
812 return 0;
813 return acm_set_control(acm, acm->ctrlout = newctrl);
814 }
815
816 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
817 unsigned int cmd, unsigned long arg)
818 {
819 struct acm *acm = tty->driver_data;
820
821 if (!ACM_READY(acm))
822 return -EINVAL;
823
824 return -ENOIOCTLCMD;
825 }
826
827 static const __u32 acm_tty_speed[] = {
828 0, 50, 75, 110, 134, 150, 200, 300, 600,
829 1200, 1800, 2400, 4800, 9600, 19200, 38400,
830 57600, 115200, 230400, 460800, 500000, 576000,
831 921600, 1000000, 1152000, 1500000, 2000000,
832 2500000, 3000000, 3500000, 4000000
833 };
834
835 static const __u8 acm_tty_size[] = {
836 5, 6, 7, 8
837 };
838
839 static void acm_tty_set_termios(struct tty_struct *tty,
840 struct ktermios *termios_old)
841 {
842 struct acm *acm = tty->driver_data;
843 struct ktermios *termios = tty->termios;
844 struct usb_cdc_line_coding newline;
845 int newctrl = acm->ctrlout;
846
847 if (!ACM_READY(acm))
848 return;
849
850 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
851 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
852 newline.bParityType = termios->c_cflag & PARENB ?
853 (termios->c_cflag & PARODD ? 1 : 2) +
854 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
855 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
856 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
857
858 if (!newline.dwDTERate) {
859 newline.dwDTERate = acm->line.dwDTERate;
860 newctrl &= ~ACM_CTRL_DTR;
861 } else
862 newctrl |= ACM_CTRL_DTR;
863
864 if (newctrl != acm->ctrlout)
865 acm_set_control(acm, acm->ctrlout = newctrl);
866
867 if (memcmp(&acm->line, &newline, sizeof newline)) {
868 memcpy(&acm->line, &newline, sizeof newline);
869 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
870 newline.bCharFormat, newline.bParityType,
871 newline.bDataBits);
872 acm_set_line(acm, &acm->line);
873 }
874 }
875
876 /*
877 * USB probe and disconnect routines.
878 */
879
880 /* Little helpers: write/read buffers free */
881 static void acm_write_buffers_free(struct acm *acm)
882 {
883 int i;
884 struct acm_wb *wb;
885 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
886
887 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
888 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
889 }
890
891 static void acm_read_buffers_free(struct acm *acm)
892 {
893 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
894 int i, n = acm->rx_buflimit;
895
896 for (i = 0; i < n; i++)
897 usb_free_coherent(usb_dev, acm->readsize,
898 acm->rb[i].base, acm->rb[i].dma);
899 }
900
901 /* Little helper: write buffers allocate */
902 static int acm_write_buffers_alloc(struct acm *acm)
903 {
904 int i;
905 struct acm_wb *wb;
906
907 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
908 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
909 &wb->dmah);
910 if (!wb->buf) {
911 while (i != 0) {
912 --i;
913 --wb;
914 usb_free_coherent(acm->dev, acm->writesize,
915 wb->buf, wb->dmah);
916 }
917 return -ENOMEM;
918 }
919 }
920 return 0;
921 }
922
923 static int acm_probe(struct usb_interface *intf,
924 const struct usb_device_id *id)
925 {
926 struct usb_cdc_union_desc *union_header = NULL;
927 struct usb_cdc_country_functional_desc *cfd = NULL;
928 unsigned char *buffer = intf->altsetting->extra;
929 int buflen = intf->altsetting->extralen;
930 struct usb_interface *control_interface;
931 struct usb_interface *data_interface;
932 struct usb_endpoint_descriptor *epctrl = NULL;
933 struct usb_endpoint_descriptor *epread = NULL;
934 struct usb_endpoint_descriptor *epwrite = NULL;
935 struct usb_device *usb_dev = interface_to_usbdev(intf);
936 struct acm *acm;
937 int minor;
938 int ctrlsize, readsize;
939 u8 *buf;
940 u8 ac_management_function = 0;
941 u8 call_management_function = 0;
942 int call_interface_num = -1;
943 int data_interface_num;
944 unsigned long quirks;
945 int num_rx_buf;
946 int i;
947 int combined_interfaces = 0;
948
949 /* normal quirks */
950 quirks = (unsigned long)id->driver_info;
951 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
952
953 /* handle quirks deadly to normal probing*/
954 if (quirks == NO_UNION_NORMAL) {
955 data_interface = usb_ifnum_to_if(usb_dev, 1);
956 control_interface = usb_ifnum_to_if(usb_dev, 0);
957 goto skip_normal_probe;
958 }
959
960 /* normal probing*/
961 if (!buffer) {
962 dev_err(&intf->dev, "Weird descriptor references\n");
963 return -EINVAL;
964 }
965
966 if (!buflen) {
967 if (intf->cur_altsetting->endpoint &&
968 intf->cur_altsetting->endpoint->extralen &&
969 intf->cur_altsetting->endpoint->extra) {
970 dev_dbg(&intf->dev,
971 "Seeking extra descriptors on endpoint\n");
972 buflen = intf->cur_altsetting->endpoint->extralen;
973 buffer = intf->cur_altsetting->endpoint->extra;
974 } else {
975 dev_err(&intf->dev,
976 "Zero length descriptor references\n");
977 return -EINVAL;
978 }
979 }
980
981 while (buflen > 0) {
982 if (buffer[1] != USB_DT_CS_INTERFACE) {
983 dev_err(&intf->dev, "skipping garbage\n");
984 goto next_desc;
985 }
986
987 switch (buffer[2]) {
988 case USB_CDC_UNION_TYPE: /* we've found it */
989 if (union_header) {
990 dev_err(&intf->dev, "More than one "
991 "union descriptor, skipping ...\n");
992 goto next_desc;
993 }
994 union_header = (struct usb_cdc_union_desc *)buffer;
995 break;
996 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
997 cfd = (struct usb_cdc_country_functional_desc *)buffer;
998 break;
999 case USB_CDC_HEADER_TYPE: /* maybe check version */
1000 break; /* for now we ignore it */
1001 case USB_CDC_ACM_TYPE:
1002 ac_management_function = buffer[3];
1003 break;
1004 case USB_CDC_CALL_MANAGEMENT_TYPE:
1005 call_management_function = buffer[3];
1006 call_interface_num = buffer[4];
1007 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1008 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1009 break;
1010 default:
1011 /* there are LOTS more CDC descriptors that
1012 * could legitimately be found here.
1013 */
1014 dev_dbg(&intf->dev, "Ignoring descriptor: "
1015 "type %02x, length %d\n",
1016 buffer[2], buffer[0]);
1017 break;
1018 }
1019 next_desc:
1020 buflen -= buffer[0];
1021 buffer += buffer[0];
1022 }
1023
1024 if (!union_header) {
1025 if (call_interface_num > 0) {
1026 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1027 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1028 control_interface = intf;
1029 } else {
1030 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1031 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1032 return -ENODEV;
1033 } else {
1034 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1035 combined_interfaces = 1;
1036 control_interface = data_interface = intf;
1037 goto look_for_collapsed_interface;
1038 }
1039 }
1040 } else {
1041 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1042 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1043 if (!control_interface || !data_interface) {
1044 dev_dbg(&intf->dev, "no interfaces\n");
1045 return -ENODEV;
1046 }
1047 }
1048
1049 if (data_interface_num != call_interface_num)
1050 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1051
1052 if (control_interface == data_interface) {
1053 /* some broken devices designed for windows work this way */
1054 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1055 combined_interfaces = 1;
1056 /* a popular other OS doesn't use it */
1057 quirks |= NO_CAP_LINE;
1058 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1059 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1060 return -EINVAL;
1061 }
1062 look_for_collapsed_interface:
1063 for (i = 0; i < 3; i++) {
1064 struct usb_endpoint_descriptor *ep;
1065 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1066
1067 if (usb_endpoint_is_int_in(ep))
1068 epctrl = ep;
1069 else if (usb_endpoint_is_bulk_out(ep))
1070 epwrite = ep;
1071 else if (usb_endpoint_is_bulk_in(ep))
1072 epread = ep;
1073 else
1074 return -EINVAL;
1075 }
1076 if (!epctrl || !epread || !epwrite)
1077 return -ENODEV;
1078 else
1079 goto made_compressed_probe;
1080 }
1081
1082 skip_normal_probe:
1083
1084 if (data_interface->cur_altsetting->desc.bInterfaceClass
1085 != CDC_DATA_INTERFACE_TYPE) {
1086 if (control_interface->cur_altsetting->desc.bInterfaceClass
1087 == CDC_DATA_INTERFACE_TYPE) {
1088 struct usb_interface *t;
1089 dev_dbg(&intf->dev,
1090 "Your device has switched interfaces.\n");
1091 t = control_interface;
1092 control_interface = data_interface;
1093 data_interface = t;
1094 } else {
1095 return -EINVAL;
1096 }
1097 }
1098
1099 /* Accept probe requests only for the control interface */
1100 if (!combined_interfaces && intf != control_interface)
1101 return -ENODEV;
1102
1103 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1104 /* valid in this context */
1105 dev_dbg(&intf->dev, "The data interface isn't available\n");
1106 return -EBUSY;
1107 }
1108
1109
1110 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1111 return -EINVAL;
1112
1113 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1114 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1115 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1116
1117
1118 if (!usb_endpoint_dir_in(epread)) {
1119 /* descriptors are swapped */
1120 struct usb_endpoint_descriptor *t;
1121 dev_dbg(&intf->dev,
1122 "The data interface has switched endpoints\n");
1123 t = epread;
1124 epread = epwrite;
1125 epwrite = t;
1126 }
1127 made_compressed_probe:
1128 dbg("interfaces are valid");
1129 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1130
1131 if (minor == ACM_TTY_MINORS) {
1132 dev_err(&intf->dev, "no more free acm devices\n");
1133 return -ENODEV;
1134 }
1135
1136 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1137 if (acm == NULL) {
1138 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1139 goto alloc_fail;
1140 }
1141
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;
1149 acm->minor = minor;
1150 acm->dev = usb_dev;
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);
1167 if (acm->is_int_ep)
1168 acm->bInterval = epread->bInterval;
1169 tty_port_init(&acm->port);
1170 acm->port.ops = &acm_port_ops;
1171
1172 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1173 if (!buf) {
1174 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1175 goto alloc_fail2;
1176 }
1177 acm->ctrl_buffer = buf;
1178
1179 if (acm_write_buffers_alloc(acm) < 0) {
1180 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1181 goto alloc_fail4;
1182 }
1183
1184 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1185 if (!acm->ctrlurb) {
1186 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1187 goto alloc_fail5;
1188 }
1189 for (i = 0; i < num_rx_buf; i++) {
1190 struct acm_ru *rcv = &(acm->ru[i]);
1191
1192 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1193 if (rcv->urb == NULL) {
1194 dev_dbg(&intf->dev,
1195 "out of memory (read urbs usb_alloc_urb)\n");
1196 goto alloc_fail6;
1197 }
1198
1199 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1200 rcv->instance = acm;
1201 }
1202 for (i = 0; i < num_rx_buf; i++) {
1203 struct acm_rb *rb = &(acm->rb[i]);
1204
1205 rb->base = usb_alloc_coherent(acm->dev, readsize,
1206 GFP_KERNEL, &rb->dma);
1207 if (!rb->base) {
1208 dev_dbg(&intf->dev,
1209 "out of memory (read bufs usb_alloc_coherent)\n");
1210 goto alloc_fail7;
1211 }
1212 }
1213 for (i = 0; i < ACM_NW; i++) {
1214 struct acm_wb *snd = &(acm->wb[i]);
1215
1216 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1217 if (snd->urb == NULL) {
1218 dev_dbg(&intf->dev,
1219 "out of memory (write urbs usb_alloc_urb)");
1220 goto alloc_fail8;
1221 }
1222
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);
1227 else
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;
1233 }
1234
1235 usb_set_intfdata(intf, acm);
1236
1237 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1238 if (i < 0)
1239 goto alloc_fail8;
1240
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,
1247 cfd->bLength - 4);
1248 acm->country_rel_date = cfd->iCountryCodeRelDate;
1249
1250 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1251 if (i < 0) {
1252 kfree(acm->country_codes);
1253 goto skip_countries;
1254 }
1255
1256 i = device_create_file(&intf->dev,
1257 &dev_attr_iCountryCodeRelDate);
1258 if (i < 0) {
1259 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1260 kfree(acm->country_codes);
1261 goto skip_countries;
1262 }
1263 }
1264
1265 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;
1273
1274 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1275
1276 acm_set_control(acm, acm->ctrlout);
1277
1278 acm->line.dwDTERate = cpu_to_le32(9600);
1279 acm->line.bDataBits = 8;
1280 acm_set_line(acm, &acm->line);
1281
1282 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1283 usb_set_intfdata(data_interface, acm);
1284
1285 usb_get_intf(control_interface);
1286 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1287
1288 acm_table[minor] = acm;
1289
1290 return 0;
1291 alloc_fail8:
1292 for (i = 0; i < ACM_NW; i++)
1293 usb_free_urb(acm->wb[i].urb);
1294 alloc_fail7:
1295 acm_read_buffers_free(acm);
1296 alloc_fail6:
1297 for (i = 0; i < num_rx_buf; i++)
1298 usb_free_urb(acm->ru[i].urb);
1299 usb_free_urb(acm->ctrlurb);
1300 alloc_fail5:
1301 acm_write_buffers_free(acm);
1302 alloc_fail4:
1303 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1304 alloc_fail2:
1305 kfree(acm);
1306 alloc_fail:
1307 return -ENOMEM;
1308 }
1309
1310 static void stop_data_traffic(struct acm *acm)
1311 {
1312 int i;
1313 dbg("Entering stop_data_traffic");
1314
1315 tasklet_disable(&acm->urb_task);
1316
1317 usb_kill_urb(acm->ctrlurb);
1318 for (i = 0; i < ACM_NW; i++)
1319 usb_kill_urb(acm->wb[i].urb);
1320 for (i = 0; i < acm->rx_buflimit; i++)
1321 usb_kill_urb(acm->ru[i].urb);
1322
1323 tasklet_enable(&acm->urb_task);
1324
1325 cancel_work_sync(&acm->work);
1326 }
1327
1328 static void acm_disconnect(struct usb_interface *intf)
1329 {
1330 struct acm *acm = usb_get_intfdata(intf);
1331 struct usb_device *usb_dev = interface_to_usbdev(intf);
1332 struct tty_struct *tty;
1333
1334 /* sibling interface is already cleaning up */
1335 if (!acm)
1336 return;
1337
1338 mutex_lock(&open_mutex);
1339 if (acm->country_codes) {
1340 device_remove_file(&acm->control->dev,
1341 &dev_attr_wCountryCodes);
1342 device_remove_file(&acm->control->dev,
1343 &dev_attr_iCountryCodeRelDate);
1344 }
1345 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1346 acm->dev = NULL;
1347 usb_set_intfdata(acm->control, NULL);
1348 usb_set_intfdata(acm->data, NULL);
1349
1350 stop_data_traffic(acm);
1351
1352 acm_write_buffers_free(acm);
1353 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1354 acm->ctrl_dma);
1355 acm_read_buffers_free(acm);
1356
1357 if (!acm->combined_interfaces)
1358 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1359 acm->data : acm->control);
1360
1361 if (acm->port.count == 0) {
1362 acm_tty_unregister(acm);
1363 mutex_unlock(&open_mutex);
1364 return;
1365 }
1366
1367 mutex_unlock(&open_mutex);
1368 tty = tty_port_tty_get(&acm->port);
1369 if (tty) {
1370 tty_hangup(tty);
1371 tty_kref_put(tty);
1372 }
1373 }
1374
1375 #ifdef CONFIG_PM
1376 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1377 {
1378 struct acm *acm = usb_get_intfdata(intf);
1379 int cnt;
1380
1381 if (message.event & PM_EVENT_AUTO) {
1382 int b;
1383
1384 spin_lock_irq(&acm->read_lock);
1385 spin_lock(&acm->write_lock);
1386 b = acm->processing + acm->transmitting;
1387 spin_unlock(&acm->write_lock);
1388 spin_unlock_irq(&acm->read_lock);
1389 if (b)
1390 return -EBUSY;
1391 }
1392
1393 spin_lock_irq(&acm->read_lock);
1394 spin_lock(&acm->write_lock);
1395 cnt = acm->susp_count++;
1396 spin_unlock(&acm->write_lock);
1397 spin_unlock_irq(&acm->read_lock);
1398
1399 if (cnt)
1400 return 0;
1401 /*
1402 we treat opened interfaces differently,
1403 we must guard against open
1404 */
1405 mutex_lock(&acm->mutex);
1406
1407 if (acm->port.count)
1408 stop_data_traffic(acm);
1409
1410 mutex_unlock(&acm->mutex);
1411 return 0;
1412 }
1413
1414 static int acm_resume(struct usb_interface *intf)
1415 {
1416 struct acm *acm = usb_get_intfdata(intf);
1417 struct acm_wb *wb;
1418 int rv = 0;
1419 int cnt;
1420
1421 spin_lock_irq(&acm->read_lock);
1422 acm->susp_count -= 1;
1423 cnt = acm->susp_count;
1424 spin_unlock_irq(&acm->read_lock);
1425
1426 if (cnt)
1427 return 0;
1428
1429 mutex_lock(&acm->mutex);
1430 if (acm->port.count) {
1431 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1432
1433 spin_lock_irq(&acm->write_lock);
1434 if (acm->delayed_wb) {
1435 wb = acm->delayed_wb;
1436 acm->delayed_wb = NULL;
1437 spin_unlock_irq(&acm->write_lock);
1438 acm_start_wb(acm, wb);
1439 } else {
1440 spin_unlock_irq(&acm->write_lock);
1441 }
1442
1443 /*
1444 * delayed error checking because we must
1445 * do the write path at all cost
1446 */
1447 if (rv < 0)
1448 goto err_out;
1449
1450 tasklet_schedule(&acm->urb_task);
1451 }
1452
1453 err_out:
1454 mutex_unlock(&acm->mutex);
1455 return rv;
1456 }
1457
1458 static int acm_reset_resume(struct usb_interface *intf)
1459 {
1460 struct acm *acm = usb_get_intfdata(intf);
1461 struct tty_struct *tty;
1462
1463 mutex_lock(&acm->mutex);
1464 if (acm->port.count) {
1465 tty = tty_port_tty_get(&acm->port);
1466 if (tty) {
1467 tty_hangup(tty);
1468 tty_kref_put(tty);
1469 }
1470 }
1471 mutex_unlock(&acm->mutex);
1472 return acm_resume(intf);
1473 }
1474
1475 #endif /* CONFIG_PM */
1476
1477 #define NOKIA_PCSUITE_ACM_INFO(x) \
1478 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1479 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1480 USB_CDC_ACM_PROTO_VENDOR)
1481
1482 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1483 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1484 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1485 USB_CDC_ACM_PROTO_VENDOR)
1486
1487 /*
1488 * USB driver structure.
1489 */
1490
1491 static const struct usb_device_id acm_ids[] = {
1492 /* quirky and broken devices */
1493 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1494 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495 },
1496 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1497 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498 },
1499 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1500 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501 },
1502 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1503 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504 },
1505 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1506 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507 },
1508 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1509 .driver_info = SINGLE_RX_URB,
1510 },
1511 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1512 .driver_info = SINGLE_RX_URB, /* firmware bug */
1513 },
1514 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1515 .driver_info = SINGLE_RX_URB, /* firmware bug */
1516 },
1517 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1518 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519 },
1520 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1521 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522 },
1523 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1524 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525 },
1526 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1527 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528 },
1529 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1530 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531 },
1532 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1533 },
1534 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1535 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1536 data interface instead of
1537 communications interface.
1538 Maybe we should define a new
1539 quirk for this. */
1540 },
1541 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1542 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1543 },
1544 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1545 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1546 },
1547
1548 /* Nokia S60 phones expose two ACM channels. The first is
1549 * a modem and is picked up by the standard AT-command
1550 * information below. The second is 'vendor-specific' but
1551 * is treated as a serial device at the S60 end, so we want
1552 * to expose it on Linux too. */
1553 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1554 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1555 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1556 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1557 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1559 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1561 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1568 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1571 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1573 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1574 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1576 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1582 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1583 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1585 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1586 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1587 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1588 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1589 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1594 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1595 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1596 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1597 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1598 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1600 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1602 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1604 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1605 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1606 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1608 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1609
1610 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1611
1612 /* Support Lego NXT using pbLua firmware */
1613 { USB_DEVICE(0x0694, 0xff00),
1614 .driver_info = NOT_A_MODEM,
1615 },
1616
1617 /* control interfaces without any protocol set */
1618 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1619 USB_CDC_PROTO_NONE) },
1620
1621 /* control interfaces with various AT-command sets */
1622 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1623 USB_CDC_ACM_PROTO_AT_V25TER) },
1624 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1625 USB_CDC_ACM_PROTO_AT_PCCA101) },
1626 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1627 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1628 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1629 USB_CDC_ACM_PROTO_AT_GSM) },
1630 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1631 USB_CDC_ACM_PROTO_AT_3G) },
1632 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1633 USB_CDC_ACM_PROTO_AT_CDMA) },
1634
1635 { }
1636 };
1637
1638 MODULE_DEVICE_TABLE(usb, acm_ids);
1639
1640 static struct usb_driver acm_driver = {
1641 .name = "cdc_acm",
1642 .probe = acm_probe,
1643 .disconnect = acm_disconnect,
1644 #ifdef CONFIG_PM
1645 .suspend = acm_suspend,
1646 .resume = acm_resume,
1647 .reset_resume = acm_reset_resume,
1648 #endif
1649 .id_table = acm_ids,
1650 #ifdef CONFIG_PM
1651 .supports_autosuspend = 1,
1652 #endif
1653 };
1654
1655 /*
1656 * TTY driver structures.
1657 */
1658
1659 static const struct tty_operations acm_ops = {
1660 .open = acm_tty_open,
1661 .close = acm_tty_close,
1662 .hangup = acm_tty_hangup,
1663 .write = acm_tty_write,
1664 .write_room = acm_tty_write_room,
1665 .ioctl = acm_tty_ioctl,
1666 .throttle = acm_tty_throttle,
1667 .unthrottle = acm_tty_unthrottle,
1668 .chars_in_buffer = acm_tty_chars_in_buffer,
1669 .break_ctl = acm_tty_break_ctl,
1670 .set_termios = acm_tty_set_termios,
1671 .tiocmget = acm_tty_tiocmget,
1672 .tiocmset = acm_tty_tiocmset,
1673 };
1674
1675 /*
1676 * Init / exit.
1677 */
1678
1679 static int __init acm_init(void)
1680 {
1681 int retval;
1682 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1683 if (!acm_tty_driver)
1684 return -ENOMEM;
1685 acm_tty_driver->owner = THIS_MODULE,
1686 acm_tty_driver->driver_name = "acm",
1687 acm_tty_driver->name = "ttyACM",
1688 acm_tty_driver->major = ACM_TTY_MAJOR,
1689 acm_tty_driver->minor_start = 0,
1690 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1691 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1692 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1693 acm_tty_driver->init_termios = tty_std_termios;
1694 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1695 HUPCL | CLOCAL;
1696 tty_set_operations(acm_tty_driver, &acm_ops);
1697
1698 retval = tty_register_driver(acm_tty_driver);
1699 if (retval) {
1700 put_tty_driver(acm_tty_driver);
1701 return retval;
1702 }
1703
1704 retval = usb_register(&acm_driver);
1705 if (retval) {
1706 tty_unregister_driver(acm_tty_driver);
1707 put_tty_driver(acm_tty_driver);
1708 return retval;
1709 }
1710
1711 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1712 DRIVER_DESC "\n");
1713
1714 return 0;
1715 }
1716
1717 static void __exit acm_exit(void)
1718 {
1719 usb_deregister(&acm_driver);
1720 tty_unregister_driver(acm_tty_driver);
1721 put_tty_driver(acm_tty_driver);
1722 }
1723
1724 module_init(acm_init);
1725 module_exit(acm_exit);
1726
1727 MODULE_AUTHOR(DRIVER_AUTHOR);
1728 MODULE_DESCRIPTION(DRIVER_DESC);
1729 MODULE_LICENSE("GPL");
1730 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
Tomato firmware and modifications.