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