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