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