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