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