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