?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'mini2440-dev-unlikely' into mini2440-dev
[linux-2.6/mini2440.git] / drivers / usb / class / cdc-acm.c
blobe4eca7810bcf1bed6821086e4bab6130525e3c17
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 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
613 rv = tty_port_block_til_ready(&acm->port, tty, filp);
614 tasklet_schedule(&acm->urb_task);
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)
690 return;
691 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
692 mutex_lock(&open_mutex);
693 if (!acm->dev) {
694 tty_port_tty_set(&acm->port, NULL);
695 acm_tty_unregister(acm);
696 tty->driver_data = NULL;
697 }
698 mutex_unlock(&open_mutex);
699 return;
700 }
701 acm_port_down(acm, 0);
702 tty_port_close_end(&acm->port, tty);
703 tty_port_tty_set(&acm->port, NULL);
704 }
705
706 static int acm_tty_write(struct tty_struct *tty,
707 const unsigned char *buf, int count)
708 {
709 struct acm *acm = tty->driver_data;
710 int stat;
711 unsigned long flags;
712 int wbn;
713 struct acm_wb *wb;
714
715 dbg("Entering acm_tty_write to write %d bytes,", count);
716
717 if (!ACM_READY(acm))
718 return -EINVAL;
719 if (!count)
720 return 0;
721
722 spin_lock_irqsave(&acm->write_lock, flags);
723 wbn = acm_wb_alloc(acm);
724 if (wbn < 0) {
725 spin_unlock_irqrestore(&acm->write_lock, flags);
726 return 0;
727 }
728 wb = &acm->wb[wbn];
729
730 count = (count > acm->writesize) ? acm->writesize : count;
731 dbg("Get %d bytes...", count);
732 memcpy(wb->buf, buf, count);
733 wb->len = count;
734 spin_unlock_irqrestore(&acm->write_lock, flags);
735
736 stat = acm_write_start(acm, wbn);
737 if (stat < 0)
738 return stat;
739 return count;
740 }
741
742 static int acm_tty_write_room(struct tty_struct *tty)
743 {
744 struct acm *acm = tty->driver_data;
745 if (!ACM_READY(acm))
746 return -EINVAL;
747 /*
748 * Do not let the line discipline to know that we have a reserve,
749 * or it might get too enthusiastic.
750 */
751 return acm_wb_is_avail(acm) ? acm->writesize : 0;
752 }
753
754 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
755 {
756 struct acm *acm = tty->driver_data;
757 if (!ACM_READY(acm))
758 return 0;
759 /*
760 * This is inaccurate (overcounts), but it works.
761 */
762 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
763 }
764
765 static void acm_tty_throttle(struct tty_struct *tty)
766 {
767 struct acm *acm = tty->driver_data;
768 if (!ACM_READY(acm))
769 return;
770 spin_lock_bh(&acm->throttle_lock);
771 acm->throttle = 1;
772 spin_unlock_bh(&acm->throttle_lock);
773 }
774
775 static void acm_tty_unthrottle(struct tty_struct *tty)
776 {
777 struct acm *acm = tty->driver_data;
778 if (!ACM_READY(acm))
779 return;
780 spin_lock_bh(&acm->throttle_lock);
781 acm->throttle = 0;
782 spin_unlock_bh(&acm->throttle_lock);
783 tasklet_schedule(&acm->urb_task);
784 }
785
786 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
787 {
788 struct acm *acm = tty->driver_data;
789 int retval;
790 if (!ACM_READY(acm))
791 return -EINVAL;
792 retval = acm_send_break(acm, state ? 0xffff : 0);
793 if (retval < 0)
794 dbg("send break failed");
795 return retval;
796 }
797
798 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
799 {
800 struct acm *acm = tty->driver_data;
801
802 if (!ACM_READY(acm))
803 return -EINVAL;
804
805 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
806 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
807 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
808 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
809 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
810 TIOCM_CTS;
811 }
812
813 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
814 unsigned int set, unsigned int clear)
815 {
816 struct acm *acm = tty->driver_data;
817 unsigned int newctrl;
818
819 if (!ACM_READY(acm))
820 return -EINVAL;
821
822 newctrl = acm->ctrlout;
823 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
824 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
825 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
826 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
827
828 newctrl = (newctrl & ~clear) | set;
829
830 if (acm->ctrlout == newctrl)
831 return 0;
832 return acm_set_control(acm, acm->ctrlout = newctrl);
833 }
834
835 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
836 unsigned int cmd, unsigned long arg)
837 {
838 struct acm *acm = tty->driver_data;
839
840 if (!ACM_READY(acm))
841 return -EINVAL;
842
843 return -ENOIOCTLCMD;
844 }
845
846 static const __u32 acm_tty_speed[] = {
847 0, 50, 75, 110, 134, 150, 200, 300, 600,
848 1200, 1800, 2400, 4800, 9600, 19200, 38400,
849 57600, 115200, 230400, 460800, 500000, 576000,
850 921600, 1000000, 1152000, 1500000, 2000000,
851 2500000, 3000000, 3500000, 4000000
852 };
853
854 static const __u8 acm_tty_size[] = {
855 5, 6, 7, 8
856 };
857
858 static void acm_tty_set_termios(struct tty_struct *tty,
859 struct ktermios *termios_old)
860 {
861 struct acm *acm = tty->driver_data;
862 struct ktermios *termios = tty->termios;
863 struct usb_cdc_line_coding newline;
864 int newctrl = acm->ctrlout;
865
866 if (!ACM_READY(acm))
867 return;
868
869 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
870 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
871 newline.bParityType = termios->c_cflag & PARENB ?
872 (termios->c_cflag & PARODD ? 1 : 2) +
873 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
874 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
875 /* FIXME: Needs to clear unsupported bits in the termios */
876 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
877
878 if (!newline.dwDTERate) {
879 newline.dwDTERate = acm->line.dwDTERate;
880 newctrl &= ~ACM_CTRL_DTR;
881 } else
882 newctrl |= ACM_CTRL_DTR;
883
884 if (newctrl != acm->ctrlout)
885 acm_set_control(acm, acm->ctrlout = newctrl);
886
887 if (memcmp(&acm->line, &newline, sizeof newline)) {
888 memcpy(&acm->line, &newline, sizeof newline);
889 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
890 newline.bCharFormat, newline.bParityType,
891 newline.bDataBits);
892 acm_set_line(acm, &acm->line);
893 }
894 }
895
896 /*
897 * USB probe and disconnect routines.
898 */
899
900 /* Little helpers: write/read buffers free */
901 static void acm_write_buffers_free(struct acm *acm)
902 {
903 int i;
904 struct acm_wb *wb;
905 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
906
907 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
908 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
909 }
910
911 static void acm_read_buffers_free(struct acm *acm)
912 {
913 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
914 int i, n = acm->rx_buflimit;
915
916 for (i = 0; i < n; i++)
917 usb_buffer_free(usb_dev, acm->readsize,
918 acm->rb[i].base, acm->rb[i].dma);
919 }
920
921 /* Little helper: write buffers allocate */
922 static int acm_write_buffers_alloc(struct acm *acm)
923 {
924 int i;
925 struct acm_wb *wb;
926
927 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
928 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
929 &wb->dmah);
930 if (!wb->buf) {
931 while (i != 0) {
932 --i;
933 --wb;
934 usb_buffer_free(acm->dev, acm->writesize,
935 wb->buf, wb->dmah);
936 }
937 return -ENOMEM;
938 }
939 }
940 return 0;
941 }
942
943 static int acm_probe(struct usb_interface *intf,
944 const struct usb_device_id *id)
945 {
946 struct usb_cdc_union_desc *union_header = NULL;
947 struct usb_cdc_country_functional_desc *cfd = NULL;
948 unsigned char *buffer = intf->altsetting->extra;
949 int buflen = intf->altsetting->extralen;
950 struct usb_interface *control_interface;
951 struct usb_interface *data_interface;
952 struct usb_endpoint_descriptor *epctrl = NULL;
953 struct usb_endpoint_descriptor *epread = NULL;
954 struct usb_endpoint_descriptor *epwrite = NULL;
955 struct usb_device *usb_dev = interface_to_usbdev(intf);
956 struct acm *acm;
957 int minor;
958 int ctrlsize, readsize;
959 u8 *buf;
960 u8 ac_management_function = 0;
961 u8 call_management_function = 0;
962 int call_interface_num = -1;
963 int data_interface_num;
964 unsigned long quirks;
965 int num_rx_buf;
966 int i;
967 int combined_interfaces = 0;
968
969 /* normal quirks */
970 quirks = (unsigned long)id->driver_info;
971 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
972
973 /* handle quirks deadly to normal probing*/
974 if (quirks == NO_UNION_NORMAL) {
975 data_interface = usb_ifnum_to_if(usb_dev, 1);
976 control_interface = usb_ifnum_to_if(usb_dev, 0);
977 goto skip_normal_probe;
978 }
979
980 /* normal probing*/
981 if (!buffer) {
982 dev_err(&intf->dev, "Weird descriptor references\n");
983 return -EINVAL;
984 }
985
986 if (!buflen) {
987 if (intf->cur_altsetting->endpoint->extralen &&
988 intf->cur_altsetting->endpoint->extra) {
989 dev_dbg(&intf->dev,
990 "Seeking extra descriptors on endpoint\n");
991 buflen = intf->cur_altsetting->endpoint->extralen;
992 buffer = intf->cur_altsetting->endpoint->extra;
993 } else {
994 dev_err(&intf->dev,
995 "Zero length descriptor references\n");
996 return -EINVAL;
997 }
998 }
999
1000 while (buflen > 0) {
1001 if (buffer[1] != USB_DT_CS_INTERFACE) {
1002 dev_err(&intf->dev, "skipping garbage\n");
1003 goto next_desc;
1004 }
1005
1006 switch (buffer[2]) {
1007 case USB_CDC_UNION_TYPE: /* we've found it */
1008 if (union_header) {
1009 dev_err(&intf->dev, "More than one "
1010 "union descriptor, skipping ...\n");
1011 goto next_desc;
1012 }
1013 union_header = (struct usb_cdc_union_desc *)buffer;
1014 break;
1015 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1016 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1017 break;
1018 case USB_CDC_HEADER_TYPE: /* maybe check version */
1019 break; /* for now we ignore it */
1020 case USB_CDC_ACM_TYPE:
1021 ac_management_function = buffer[3];
1022 break;
1023 case USB_CDC_CALL_MANAGEMENT_TYPE:
1024 call_management_function = buffer[3];
1025 call_interface_num = buffer[4];
1026 if ((call_management_function & 3) != 3)
1027 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1028 break;
1029 default:
1030 /* there are LOTS more CDC descriptors that
1031 * could legitimately be found here.
1032 */
1033 dev_dbg(&intf->dev, "Ignoring descriptor: "
1034 "type %02x, length %d\n",
1035 buffer[2], buffer[0]);
1036 break;
1037 }
1038 next_desc:
1039 buflen -= buffer[0];
1040 buffer += buffer[0];
1041 }
1042
1043 if (!union_header) {
1044 if (call_interface_num > 0) {
1045 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1046 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1047 control_interface = intf;
1048 } else {
1049 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1050 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1051 return -ENODEV;
1052 } else {
1053 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1054 combined_interfaces = 1;
1055 control_interface = data_interface = intf;
1056 goto look_for_collapsed_interface;
1057 }
1058 }
1059 } else {
1060 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1061 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1062 if (!control_interface || !data_interface) {
1063 dev_dbg(&intf->dev, "no interfaces\n");
1064 return -ENODEV;
1065 }
1066 }
1067
1068 if (data_interface_num != call_interface_num)
1069 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1070
1071 if (control_interface == data_interface) {
1072 /* some broken devices designed for windows work this way */
1073 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1074 combined_interfaces = 1;
1075 /* a popular other OS doesn't use it */
1076 quirks |= NO_CAP_LINE;
1077 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1078 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1079 return -EINVAL;
1080 }
1081 look_for_collapsed_interface:
1082 for (i = 0; i < 3; i++) {
1083 struct usb_endpoint_descriptor *ep;
1084 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1085
1086 if (usb_endpoint_is_int_in(ep))
1087 epctrl = ep;
1088 else if (usb_endpoint_is_bulk_out(ep))
1089 epwrite = ep;
1090 else if (usb_endpoint_is_bulk_in(ep))
1091 epread = ep;
1092 else
1093 return -EINVAL;
1094 }
1095 if (!epctrl || !epread || !epwrite)
1096 return -ENODEV;
1097 else
1098 goto made_compressed_probe;
1099 }
1100
1101 skip_normal_probe:
1102
1103 /*workaround for switched interfaces */
1104 if (data_interface->cur_altsetting->desc.bInterfaceClass
1105 != CDC_DATA_INTERFACE_TYPE) {
1106 if (control_interface->cur_altsetting->desc.bInterfaceClass
1107 == CDC_DATA_INTERFACE_TYPE) {
1108 struct usb_interface *t;
1109 dev_dbg(&intf->dev,
1110 "Your device has switched interfaces.\n");
1111 t = control_interface;
1112 control_interface = data_interface;
1113 data_interface = t;
1114 } else {
1115 return -EINVAL;
1116 }
1117 }
1118
1119 /* Accept probe requests only for the control interface */
1120 if (!combined_interfaces && intf != control_interface)
1121 return -ENODEV;
1122
1123 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1124 /* valid in this context */
1125 dev_dbg(&intf->dev, "The data interface isn't available\n");
1126 return -EBUSY;
1127 }
1128
1129
1130 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1131 return -EINVAL;
1132
1133 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1134 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1135 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1136
1137
1138 /* workaround for switched endpoints */
1139 if (!usb_endpoint_dir_in(epread)) {
1140 /* descriptors are swapped */
1141 struct usb_endpoint_descriptor *t;
1142 dev_dbg(&intf->dev,
1143 "The data interface has switched endpoints\n");
1144 t = epread;
1145 epread = epwrite;
1146 epwrite = t;
1147 }
1148 made_compressed_probe:
1149 dbg("interfaces are valid");
1150 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1151
1152 if (minor == ACM_TTY_MINORS) {
1153 dev_err(&intf->dev, "no more free acm devices\n");
1154 return -ENODEV;
1155 }
1156
1157 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1158 if (acm == NULL) {
1159 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1160 goto alloc_fail;
1161 }
1162
1163 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1164 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1165 (quirks == SINGLE_RX_URB ? 1 : 2);
1166 acm->combined_interfaces = combined_interfaces;
1167 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1168 acm->control = control_interface;
1169 acm->data = data_interface;
1170 acm->minor = minor;
1171 acm->dev = usb_dev;
1172 acm->ctrl_caps = ac_management_function;
1173 if (quirks & NO_CAP_LINE)
1174 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1175 acm->ctrlsize = ctrlsize;
1176 acm->readsize = readsize;
1177 acm->rx_buflimit = num_rx_buf;
1178 acm->urb_task.func = acm_rx_tasklet;
1179 acm->urb_task.data = (unsigned long) acm;
1180 INIT_WORK(&acm->work, acm_softint);
1181 INIT_WORK(&acm->waker, acm_waker);
1182 init_waitqueue_head(&acm->drain_wait);
1183 spin_lock_init(&acm->throttle_lock);
1184 spin_lock_init(&acm->write_lock);
1185 spin_lock_init(&acm->read_lock);
1186 mutex_init(&acm->mutex);
1187 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1188 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1189 if (acm->is_int_ep)
1190 acm->bInterval = epread->bInterval;
1191 tty_port_init(&acm->port);
1192 acm->port.ops = &acm_port_ops;
1193
1194 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1195 if (!buf) {
1196 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1197 goto alloc_fail2;
1198 }
1199 acm->ctrl_buffer = buf;
1200
1201 if (acm_write_buffers_alloc(acm) < 0) {
1202 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1203 goto alloc_fail4;
1204 }
1205
1206 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1207 if (!acm->ctrlurb) {
1208 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1209 goto alloc_fail5;
1210 }
1211 for (i = 0; i < num_rx_buf; i++) {
1212 struct acm_ru *rcv = &(acm->ru[i]);
1213
1214 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1215 if (rcv->urb == NULL) {
1216 dev_dbg(&intf->dev,
1217 "out of memory (read urbs usb_alloc_urb)\n");
1218 goto alloc_fail7;
1219 }
1220
1221 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1222 rcv->instance = acm;
1223 }
1224 for (i = 0; i < num_rx_buf; i++) {
1225 struct acm_rb *rb = &(acm->rb[i]);
1226
1227 rb->base = usb_buffer_alloc(acm->dev, readsize,
1228 GFP_KERNEL, &rb->dma);
1229 if (!rb->base) {
1230 dev_dbg(&intf->dev,
1231 "out of memory (read bufs usb_buffer_alloc)\n");
1232 goto alloc_fail7;
1233 }
1234 }
1235 for (i = 0; i < ACM_NW; i++) {
1236 struct acm_wb *snd = &(acm->wb[i]);
1237
1238 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1239 if (snd->urb == NULL) {
1240 dev_dbg(&intf->dev,
1241 "out of memory (write urbs usb_alloc_urb)");
1242 goto alloc_fail7;
1243 }
1244
1245 if (usb_endpoint_xfer_int(epwrite))
1246 usb_fill_int_urb(snd->urb, usb_dev,
1247 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1248 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1249 else
1250 usb_fill_bulk_urb(snd->urb, usb_dev,
1251 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1252 NULL, acm->writesize, acm_write_bulk, snd);
1253 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1254 snd->instance = acm;
1255 }
1256
1257 usb_set_intfdata(intf, acm);
1258
1259 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1260 if (i < 0)
1261 goto alloc_fail8;
1262
1263 if (cfd) { /* export the country data */
1264 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1265 if (!acm->country_codes)
1266 goto skip_countries;
1267 acm->country_code_size = cfd->bLength - 4;
1268 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1269 cfd->bLength - 4);
1270 acm->country_rel_date = cfd->iCountryCodeRelDate;
1271
1272 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1273 if (i < 0) {
1274 kfree(acm->country_codes);
1275 goto skip_countries;
1276 }
1277
1278 i = device_create_file(&intf->dev,
1279 &dev_attr_iCountryCodeRelDate);
1280 if (i < 0) {
1281 kfree(acm->country_codes);
1282 goto skip_countries;
1283 }
1284 }
1285
1286 skip_countries:
1287 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1288 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1289 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1290 /* works around buggy devices */
1291 epctrl->bInterval ? epctrl->bInterval : 0xff);
1292 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1293 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1294
1295 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1296
1297 acm_set_control(acm, acm->ctrlout);
1298
1299 acm->line.dwDTERate = cpu_to_le32(9600);
1300 acm->line.bDataBits = 8;
1301 acm_set_line(acm, &acm->line);
1302
1303 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1304 usb_set_intfdata(data_interface, acm);
1305
1306 usb_get_intf(control_interface);
1307 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1308
1309 acm_table[minor] = acm;
1310
1311 return 0;
1312 alloc_fail8:
1313 for (i = 0; i < ACM_NW; i++)
1314 usb_free_urb(acm->wb[i].urb);
1315 alloc_fail7:
1316 acm_read_buffers_free(acm);
1317 for (i = 0; i < num_rx_buf; i++)
1318 usb_free_urb(acm->ru[i].urb);
1319 usb_free_urb(acm->ctrlurb);
1320 alloc_fail5:
1321 acm_write_buffers_free(acm);
1322 alloc_fail4:
1323 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1324 alloc_fail2:
1325 kfree(acm);
1326 alloc_fail:
1327 return -ENOMEM;
1328 }
1329
1330 static void stop_data_traffic(struct acm *acm)
1331 {
1332 int i;
1333 dbg("Entering stop_data_traffic");
1334
1335 tasklet_disable(&acm->urb_task);
1336
1337 usb_kill_urb(acm->ctrlurb);
1338 for (i = 0; i < ACM_NW; i++)
1339 usb_kill_urb(acm->wb[i].urb);
1340 for (i = 0; i < acm->rx_buflimit; i++)
1341 usb_kill_urb(acm->ru[i].urb);
1342
1343 tasklet_enable(&acm->urb_task);
1344
1345 cancel_work_sync(&acm->work);
1346 cancel_work_sync(&acm->waker);
1347 }
1348
1349 static void acm_disconnect(struct usb_interface *intf)
1350 {
1351 struct acm *acm = usb_get_intfdata(intf);
1352 struct usb_device *usb_dev = interface_to_usbdev(intf);
1353 struct tty_struct *tty;
1354
1355 /* sibling interface is already cleaning up */
1356 if (!acm)
1357 return;
1358
1359 mutex_lock(&open_mutex);
1360 if (acm->country_codes) {
1361 device_remove_file(&acm->control->dev,
1362 &dev_attr_wCountryCodes);
1363 device_remove_file(&acm->control->dev,
1364 &dev_attr_iCountryCodeRelDate);
1365 }
1366 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1367 acm->dev = NULL;
1368 usb_set_intfdata(acm->control, NULL);
1369 usb_set_intfdata(acm->data, NULL);
1370
1371 stop_data_traffic(acm);
1372
1373 acm_write_buffers_free(acm);
1374 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1375 acm->ctrl_dma);
1376 acm_read_buffers_free(acm);
1377
1378 if (!acm->combined_interfaces)
1379 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1380 acm->data : acm->control);
1381
1382 if (acm->port.count == 0) {
1383 acm_tty_unregister(acm);
1384 mutex_unlock(&open_mutex);
1385 return;
1386 }
1387
1388 mutex_unlock(&open_mutex);
1389 tty = tty_port_tty_get(&acm->port);
1390 if (tty) {
1391 tty_hangup(tty);
1392 tty_kref_put(tty);
1393 }
1394 }
1395
1396 #ifdef CONFIG_PM
1397 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1398 {
1399 struct acm *acm = usb_get_intfdata(intf);
1400 int cnt;
1401
1402 if (message.event & PM_EVENT_AUTO) {
1403 int b;
1404
1405 spin_lock_irq(&acm->read_lock);
1406 spin_lock(&acm->write_lock);
1407 b = acm->processing + acm->transmitting;
1408 spin_unlock(&acm->write_lock);
1409 spin_unlock_irq(&acm->read_lock);
1410 if (b)
1411 return -EBUSY;
1412 }
1413
1414 spin_lock_irq(&acm->read_lock);
1415 spin_lock(&acm->write_lock);
1416 cnt = acm->susp_count++;
1417 spin_unlock(&acm->write_lock);
1418 spin_unlock_irq(&acm->read_lock);
1419
1420 if (cnt)
1421 return 0;
1422 /*
1423 we treat opened interfaces differently,
1424 we must guard against open
1425 */
1426 mutex_lock(&acm->mutex);
1427
1428 if (acm->port.count)
1429 stop_data_traffic(acm);
1430
1431 mutex_unlock(&acm->mutex);
1432 return 0;
1433 }
1434
1435 static int acm_resume(struct usb_interface *intf)
1436 {
1437 struct acm *acm = usb_get_intfdata(intf);
1438 int rv = 0;
1439 int cnt;
1440
1441 spin_lock_irq(&acm->read_lock);
1442 acm->susp_count -= 1;
1443 cnt = acm->susp_count;
1444 spin_unlock_irq(&acm->read_lock);
1445
1446 if (cnt)
1447 return 0;
1448
1449 mutex_lock(&acm->mutex);
1450 if (acm->port.count) {
1451 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1452 if (rv < 0)
1453 goto err_out;
1454
1455 tasklet_schedule(&acm->urb_task);
1456 }
1457
1458 err_out:
1459 mutex_unlock(&acm->mutex);
1460 return rv;
1461 }
1462
1463 #endif /* CONFIG_PM */
1464 /*
1465 * USB driver structure.
1466 */
1467
1468 static struct usb_device_id acm_ids[] = {
1469 /* quirky and broken devices */
1470 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1471 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1472 },
1473 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1474 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1475 },
1476 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1477 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1478 },
1479 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1480 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1481 },
1482 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1483 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1484 },
1485 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1486 .driver_info = SINGLE_RX_URB,
1487 },
1488 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1489 .driver_info = SINGLE_RX_URB, /* firmware bug */
1490 },
1491 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1492 .driver_info = SINGLE_RX_URB, /* firmware bug */
1493 },
1494 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1495 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1496 },
1497 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1498 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1499 },
1500 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1501 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1502 },
1503 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1504 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1505 },
1506 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1507 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1508 },
1509 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1510 },
1511 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1512 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1513 data interface instead of
1514 communications interface.
1515 Maybe we should define a new
1516 quirk for this. */
1517 },
1518 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1519 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1520 },
1521
1522 /* control interfaces with various AT-command sets */
1523 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1524 USB_CDC_ACM_PROTO_AT_V25TER) },
1525 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1526 USB_CDC_ACM_PROTO_AT_PCCA101) },
1527 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1528 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1529 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1530 USB_CDC_ACM_PROTO_AT_GSM) },
1531 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1532 USB_CDC_ACM_PROTO_AT_3G) },
1533 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1534 USB_CDC_ACM_PROTO_AT_CDMA) },
1535
1536 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1537 { }
1538 };
1539
1540 MODULE_DEVICE_TABLE(usb, acm_ids);
1541
1542 static struct usb_driver acm_driver = {
1543 .name = "cdc_acm",
1544 .probe = acm_probe,
1545 .disconnect = acm_disconnect,
1546 #ifdef CONFIG_PM
1547 .suspend = acm_suspend,
1548 .resume = acm_resume,
1549 #endif
1550 .id_table = acm_ids,
1551 #ifdef CONFIG_PM
1552 .supports_autosuspend = 1,
1553 #endif
1554 };
1555
1556 /*
1557 * TTY driver structures.
1558 */
1559
1560 static const struct tty_operations acm_ops = {
1561 .open = acm_tty_open,
1562 .close = acm_tty_close,
1563 .hangup = acm_tty_hangup,
1564 .write = acm_tty_write,
1565 .write_room = acm_tty_write_room,
1566 .ioctl = acm_tty_ioctl,
1567 .throttle = acm_tty_throttle,
1568 .unthrottle = acm_tty_unthrottle,
1569 .chars_in_buffer = acm_tty_chars_in_buffer,
1570 .break_ctl = acm_tty_break_ctl,
1571 .set_termios = acm_tty_set_termios,
1572 .tiocmget = acm_tty_tiocmget,
1573 .tiocmset = acm_tty_tiocmset,
1574 };
1575
1576 /*
1577 * Init / exit.
1578 */
1579
1580 static int __init acm_init(void)
1581 {
1582 int retval;
1583 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1584 if (!acm_tty_driver)
1585 return -ENOMEM;
1586 acm_tty_driver->owner = THIS_MODULE,
1587 acm_tty_driver->driver_name = "acm",
1588 acm_tty_driver->name = "ttyACM",
1589 acm_tty_driver->major = ACM_TTY_MAJOR,
1590 acm_tty_driver->minor_start = 0,
1591 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1592 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1593 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1594 acm_tty_driver->init_termios = tty_std_termios;
1595 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1596 HUPCL | CLOCAL;
1597 tty_set_operations(acm_tty_driver, &acm_ops);
1598
1599 retval = tty_register_driver(acm_tty_driver);
1600 if (retval) {
1601 put_tty_driver(acm_tty_driver);
1602 return retval;
1603 }
1604
1605 retval = usb_register(&acm_driver);
1606 if (retval) {
1607 tty_unregister_driver(acm_tty_driver);
1608 put_tty_driver(acm_tty_driver);
1609 return retval;
1610 }
1611
1612 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1613 DRIVER_DESC "\n");
1614
1615 return 0;
1616 }
1617
1618 static void __exit acm_exit(void)
1619 {
1620 usb_deregister(&acm_driver);
1621 tty_unregister_driver(acm_tty_driver);
1622 put_tty_driver(acm_tty_driver);
1623 }
1624
1625 module_init(acm_init);
1626 module_exit(acm_exit);
1627
1628 MODULE_AUTHOR(DRIVER_AUTHOR);
1629 MODULE_DESCRIPTION(DRIVER_DESC);
1630 MODULE_LICENSE("GPL");
1631 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
Support for the Chinese Samsung S3C2440 based development boards