Loading...
1/*
2 * cdc-acm.c
3 *
4 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
6 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
7 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
9 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
10 * Copyright (c) 2011 Johan Hovold <jhovold@gmail.com>
11 *
12 * USB Abstract Control Model driver for USB modems and ISDN adapters
13 *
14 * Sponsored by SuSE
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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/serial.h>
43#include <linux/module.h>
44#include <linux/mutex.h>
45#include <linux/uaccess.h>
46#include <linux/usb.h>
47#include <linux/usb/cdc.h>
48#include <asm/byteorder.h>
49#include <asm/unaligned.h>
50#include <linux/list.h>
51
52#include "cdc-acm.h"
53
54
55#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
56#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
57
58static struct usb_driver acm_driver;
59static struct tty_driver *acm_tty_driver;
60static struct acm *acm_table[ACM_TTY_MINORS];
61
62static DEFINE_MUTEX(acm_table_lock);
63
64/*
65 * acm_table accessors
66 */
67
68/*
69 * Look up an ACM structure by index. If found and not disconnected, increment
70 * its refcount and return it with its mutex held.
71 */
72static struct acm *acm_get_by_index(unsigned index)
73{
74 struct acm *acm;
75
76 mutex_lock(&acm_table_lock);
77 acm = acm_table[index];
78 if (acm) {
79 mutex_lock(&acm->mutex);
80 if (acm->disconnected) {
81 mutex_unlock(&acm->mutex);
82 acm = NULL;
83 } else {
84 tty_port_get(&acm->port);
85 mutex_unlock(&acm->mutex);
86 }
87 }
88 mutex_unlock(&acm_table_lock);
89 return acm;
90}
91
92/*
93 * Try to find an available minor number and if found, associate it with 'acm'.
94 */
95static int acm_alloc_minor(struct acm *acm)
96{
97 int minor;
98
99 mutex_lock(&acm_table_lock);
100 for (minor = 0; minor < ACM_TTY_MINORS; minor++) {
101 if (!acm_table[minor]) {
102 acm_table[minor] = acm;
103 break;
104 }
105 }
106 mutex_unlock(&acm_table_lock);
107
108 return minor;
109}
110
111/* Release the minor number associated with 'acm'. */
112static void acm_release_minor(struct acm *acm)
113{
114 mutex_lock(&acm_table_lock);
115 acm_table[acm->minor] = NULL;
116 mutex_unlock(&acm_table_lock);
117}
118
119/*
120 * Functions for ACM control messages.
121 */
122
123static int acm_ctrl_msg(struct acm *acm, int request, int value,
124 void *buf, int len)
125{
126 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
127 request, USB_RT_ACM, value,
128 acm->control->altsetting[0].desc.bInterfaceNumber,
129 buf, len, 5000);
130 dev_dbg(&acm->control->dev,
131 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
132 __func__, request, value, len, retval);
133 return retval < 0 ? retval : 0;
134}
135
136/* devices aren't required to support these requests.
137 * the cdc acm descriptor tells whether they do...
138 */
139#define acm_set_control(acm, control) \
140 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
141#define acm_set_line(acm, line) \
142 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
143#define acm_send_break(acm, ms) \
144 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
145
146/*
147 * Write buffer management.
148 * All of these assume proper locks taken by the caller.
149 */
150
151static int acm_wb_alloc(struct acm *acm)
152{
153 int i, wbn;
154 struct acm_wb *wb;
155
156 wbn = 0;
157 i = 0;
158 for (;;) {
159 wb = &acm->wb[wbn];
160 if (!wb->use) {
161 wb->use = 1;
162 return wbn;
163 }
164 wbn = (wbn + 1) % ACM_NW;
165 if (++i >= ACM_NW)
166 return -1;
167 }
168}
169
170static int acm_wb_is_avail(struct acm *acm)
171{
172 int i, n;
173 unsigned long flags;
174
175 n = ACM_NW;
176 spin_lock_irqsave(&acm->write_lock, flags);
177 for (i = 0; i < ACM_NW; i++)
178 n -= acm->wb[i].use;
179 spin_unlock_irqrestore(&acm->write_lock, flags);
180 return n;
181}
182
183/*
184 * Finish write. Caller must hold acm->write_lock
185 */
186static void acm_write_done(struct acm *acm, struct acm_wb *wb)
187{
188 wb->use = 0;
189 acm->transmitting--;
190 usb_autopm_put_interface_async(acm->control);
191}
192
193/*
194 * Poke write.
195 *
196 * the caller is responsible for locking
197 */
198
199static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
200{
201 int rc;
202
203 acm->transmitting++;
204
205 wb->urb->transfer_buffer = wb->buf;
206 wb->urb->transfer_dma = wb->dmah;
207 wb->urb->transfer_buffer_length = wb->len;
208 wb->urb->dev = acm->dev;
209
210 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
211 if (rc < 0) {
212 dev_err(&acm->data->dev,
213 "%s - usb_submit_urb(write bulk) failed: %d\n",
214 __func__, rc);
215 acm_write_done(acm, wb);
216 }
217 return rc;
218}
219
220static int acm_write_start(struct acm *acm, int wbn)
221{
222 unsigned long flags;
223 struct acm_wb *wb = &acm->wb[wbn];
224 int rc;
225
226 spin_lock_irqsave(&acm->write_lock, flags);
227 if (!acm->dev) {
228 wb->use = 0;
229 spin_unlock_irqrestore(&acm->write_lock, flags);
230 return -ENODEV;
231 }
232
233 dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
234 acm->susp_count);
235 usb_autopm_get_interface_async(acm->control);
236 if (acm->susp_count) {
237 if (!acm->delayed_wb)
238 acm->delayed_wb = wb;
239 else
240 usb_autopm_put_interface_async(acm->control);
241 spin_unlock_irqrestore(&acm->write_lock, flags);
242 return 0; /* A white lie */
243 }
244 usb_mark_last_busy(acm->dev);
245
246 rc = acm_start_wb(acm, wb);
247 spin_unlock_irqrestore(&acm->write_lock, flags);
248
249 return rc;
250
251}
252/*
253 * attributes exported through sysfs
254 */
255static ssize_t show_caps
256(struct device *dev, struct device_attribute *attr, char *buf)
257{
258 struct usb_interface *intf = to_usb_interface(dev);
259 struct acm *acm = usb_get_intfdata(intf);
260
261 return sprintf(buf, "%d", acm->ctrl_caps);
262}
263static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
264
265static ssize_t show_country_codes
266(struct device *dev, struct device_attribute *attr, char *buf)
267{
268 struct usb_interface *intf = to_usb_interface(dev);
269 struct acm *acm = usb_get_intfdata(intf);
270
271 memcpy(buf, acm->country_codes, acm->country_code_size);
272 return acm->country_code_size;
273}
274
275static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
276
277static ssize_t show_country_rel_date
278(struct device *dev, struct device_attribute *attr, char *buf)
279{
280 struct usb_interface *intf = to_usb_interface(dev);
281 struct acm *acm = usb_get_intfdata(intf);
282
283 return sprintf(buf, "%d", acm->country_rel_date);
284}
285
286static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
287/*
288 * Interrupt handlers for various ACM device responses
289 */
290
291/* control interface reports status changes with "interrupt" transfers */
292static void acm_ctrl_irq(struct urb *urb)
293{
294 struct acm *acm = urb->context;
295 struct usb_cdc_notification *dr = urb->transfer_buffer;
296 struct tty_struct *tty;
297 unsigned char *data;
298 int newctrl;
299 int retval;
300 int status = urb->status;
301
302 switch (status) {
303 case 0:
304 /* success */
305 break;
306 case -ECONNRESET:
307 case -ENOENT:
308 case -ESHUTDOWN:
309 /* this urb is terminated, clean up */
310 dev_dbg(&acm->control->dev,
311 "%s - urb shutting down with status: %d\n",
312 __func__, status);
313 return;
314 default:
315 dev_dbg(&acm->control->dev,
316 "%s - nonzero urb status received: %d\n",
317 __func__, status);
318 goto exit;
319 }
320
321 usb_mark_last_busy(acm->dev);
322
323 data = (unsigned char *)(dr + 1);
324 switch (dr->bNotificationType) {
325 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
326 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
327 __func__, dr->wValue);
328 break;
329
330 case USB_CDC_NOTIFY_SERIAL_STATE:
331 tty = tty_port_tty_get(&acm->port);
332 newctrl = get_unaligned_le16(data);
333
334 if (tty) {
335 if (!acm->clocal &&
336 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
337 dev_dbg(&acm->control->dev,
338 "%s - calling hangup\n", __func__);
339 tty_hangup(tty);
340 }
341 tty_kref_put(tty);
342 }
343
344 acm->ctrlin = newctrl;
345
346 dev_dbg(&acm->control->dev,
347 "%s - input control lines: dcd%c dsr%c break%c "
348 "ring%c framing%c parity%c overrun%c\n",
349 __func__,
350 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
351 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
352 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
353 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
354 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
355 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
356 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
357 break;
358
359 default:
360 dev_dbg(&acm->control->dev,
361 "%s - unknown notification %d received: index %d "
362 "len %d data0 %d data1 %d\n",
363 __func__,
364 dr->bNotificationType, dr->wIndex,
365 dr->wLength, data[0], data[1]);
366 break;
367 }
368exit:
369 retval = usb_submit_urb(urb, GFP_ATOMIC);
370 if (retval)
371 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
372 __func__, retval);
373}
374
375static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
376{
377 int res;
378
379 if (!test_and_clear_bit(index, &acm->read_urbs_free))
380 return 0;
381
382 dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
383
384 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
385 if (res) {
386 if (res != -EPERM) {
387 dev_err(&acm->data->dev,
388 "%s - usb_submit_urb failed: %d\n",
389 __func__, res);
390 }
391 set_bit(index, &acm->read_urbs_free);
392 return res;
393 }
394
395 return 0;
396}
397
398static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
399{
400 int res;
401 int i;
402
403 for (i = 0; i < acm->rx_buflimit; ++i) {
404 res = acm_submit_read_urb(acm, i, mem_flags);
405 if (res)
406 return res;
407 }
408
409 return 0;
410}
411
412static void acm_process_read_urb(struct acm *acm, struct urb *urb)
413{
414 struct tty_struct *tty;
415
416 if (!urb->actual_length)
417 return;
418
419 tty = tty_port_tty_get(&acm->port);
420 if (!tty)
421 return;
422
423 tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
424 tty_flip_buffer_push(tty);
425
426 tty_kref_put(tty);
427}
428
429static void acm_read_bulk_callback(struct urb *urb)
430{
431 struct acm_rb *rb = urb->context;
432 struct acm *acm = rb->instance;
433 unsigned long flags;
434
435 dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
436 rb->index, urb->actual_length);
437 set_bit(rb->index, &acm->read_urbs_free);
438
439 if (!acm->dev) {
440 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
441 return;
442 }
443 usb_mark_last_busy(acm->dev);
444
445 if (urb->status) {
446 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
447 __func__, urb->status);
448 return;
449 }
450 acm_process_read_urb(acm, urb);
451
452 /* throttle device if requested by tty */
453 spin_lock_irqsave(&acm->read_lock, flags);
454 acm->throttled = acm->throttle_req;
455 if (!acm->throttled && !acm->susp_count) {
456 spin_unlock_irqrestore(&acm->read_lock, flags);
457 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
458 } else {
459 spin_unlock_irqrestore(&acm->read_lock, flags);
460 }
461}
462
463/* data interface wrote those outgoing bytes */
464static void acm_write_bulk(struct urb *urb)
465{
466 struct acm_wb *wb = urb->context;
467 struct acm *acm = wb->instance;
468 unsigned long flags;
469
470 if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
471 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
472 __func__,
473 urb->actual_length,
474 urb->transfer_buffer_length,
475 urb->status);
476
477 spin_lock_irqsave(&acm->write_lock, flags);
478 acm_write_done(acm, wb);
479 spin_unlock_irqrestore(&acm->write_lock, flags);
480 schedule_work(&acm->work);
481}
482
483static void acm_softint(struct work_struct *work)
484{
485 struct acm *acm = container_of(work, struct acm, work);
486 struct tty_struct *tty;
487
488 dev_vdbg(&acm->data->dev, "%s\n", __func__);
489
490 tty = tty_port_tty_get(&acm->port);
491 if (!tty)
492 return;
493 tty_wakeup(tty);
494 tty_kref_put(tty);
495}
496
497/*
498 * TTY handlers
499 */
500
501static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
502{
503 struct acm *acm;
504 int retval;
505
506 dev_dbg(tty->dev, "%s\n", __func__);
507
508 acm = acm_get_by_index(tty->index);
509 if (!acm)
510 return -ENODEV;
511
512 retval = tty_standard_install(driver, tty);
513 if (retval)
514 goto error_init_termios;
515
516 tty->driver_data = acm;
517
518 return 0;
519
520error_init_termios:
521 tty_port_put(&acm->port);
522 return retval;
523}
524
525static int acm_tty_open(struct tty_struct *tty, struct file *filp)
526{
527 struct acm *acm = tty->driver_data;
528
529 dev_dbg(tty->dev, "%s\n", __func__);
530
531 return tty_port_open(&acm->port, tty, filp);
532}
533
534static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
535{
536 struct acm *acm = container_of(port, struct acm, port);
537 int retval = -ENODEV;
538
539 dev_dbg(&acm->control->dev, "%s\n", __func__);
540
541 mutex_lock(&acm->mutex);
542 if (acm->disconnected)
543 goto disconnected;
544
545 retval = usb_autopm_get_interface(acm->control);
546 if (retval)
547 goto error_get_interface;
548
549 /*
550 * FIXME: Why do we need this? Allocating 64K of physically contiguous
551 * memory is really nasty...
552 */
553 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
554 acm->control->needs_remote_wakeup = 1;
555
556 acm->ctrlurb->dev = acm->dev;
557 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
558 dev_err(&acm->control->dev,
559 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
560 goto error_submit_urb;
561 }
562
563 acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
564 if (acm_set_control(acm, acm->ctrlout) < 0 &&
565 (acm->ctrl_caps & USB_CDC_CAP_LINE))
566 goto error_set_control;
567
568 usb_autopm_put_interface(acm->control);
569
570 /*
571 * Unthrottle device in case the TTY was closed while throttled.
572 */
573 spin_lock_irq(&acm->read_lock);
574 acm->throttled = 0;
575 acm->throttle_req = 0;
576 spin_unlock_irq(&acm->read_lock);
577
578 if (acm_submit_read_urbs(acm, GFP_KERNEL))
579 goto error_submit_read_urbs;
580
581 mutex_unlock(&acm->mutex);
582
583 return 0;
584
585error_submit_read_urbs:
586 acm->ctrlout = 0;
587 acm_set_control(acm, acm->ctrlout);
588error_set_control:
589 usb_kill_urb(acm->ctrlurb);
590error_submit_urb:
591 usb_autopm_put_interface(acm->control);
592error_get_interface:
593disconnected:
594 mutex_unlock(&acm->mutex);
595 return retval;
596}
597
598static void acm_port_destruct(struct tty_port *port)
599{
600 struct acm *acm = container_of(port, struct acm, port);
601
602 dev_dbg(&acm->control->dev, "%s\n", __func__);
603
604 tty_unregister_device(acm_tty_driver, acm->minor);
605 acm_release_minor(acm);
606 usb_put_intf(acm->control);
607 kfree(acm->country_codes);
608 kfree(acm);
609}
610
611static void acm_port_shutdown(struct tty_port *port)
612{
613 struct acm *acm = container_of(port, struct acm, port);
614 int i;
615
616 dev_dbg(&acm->control->dev, "%s\n", __func__);
617
618 mutex_lock(&acm->mutex);
619 if (!acm->disconnected) {
620 usb_autopm_get_interface(acm->control);
621 acm_set_control(acm, acm->ctrlout = 0);
622 usb_kill_urb(acm->ctrlurb);
623 for (i = 0; i < ACM_NW; i++)
624 usb_kill_urb(acm->wb[i].urb);
625 for (i = 0; i < acm->rx_buflimit; i++)
626 usb_kill_urb(acm->read_urbs[i]);
627 acm->control->needs_remote_wakeup = 0;
628 usb_autopm_put_interface(acm->control);
629 }
630 mutex_unlock(&acm->mutex);
631}
632
633static void acm_tty_cleanup(struct tty_struct *tty)
634{
635 struct acm *acm = tty->driver_data;
636 dev_dbg(&acm->control->dev, "%s\n", __func__);
637 tty_port_put(&acm->port);
638}
639
640static void acm_tty_hangup(struct tty_struct *tty)
641{
642 struct acm *acm = tty->driver_data;
643 dev_dbg(&acm->control->dev, "%s\n", __func__);
644 tty_port_hangup(&acm->port);
645}
646
647static void acm_tty_close(struct tty_struct *tty, struct file *filp)
648{
649 struct acm *acm = tty->driver_data;
650 dev_dbg(&acm->control->dev, "%s\n", __func__);
651 tty_port_close(&acm->port, tty, filp);
652}
653
654static int acm_tty_write(struct tty_struct *tty,
655 const unsigned char *buf, int count)
656{
657 struct acm *acm = tty->driver_data;
658 int stat;
659 unsigned long flags;
660 int wbn;
661 struct acm_wb *wb;
662
663 if (!count)
664 return 0;
665
666 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
667
668 spin_lock_irqsave(&acm->write_lock, flags);
669 wbn = acm_wb_alloc(acm);
670 if (wbn < 0) {
671 spin_unlock_irqrestore(&acm->write_lock, flags);
672 return 0;
673 }
674 wb = &acm->wb[wbn];
675
676 count = (count > acm->writesize) ? acm->writesize : count;
677 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
678 memcpy(wb->buf, buf, count);
679 wb->len = count;
680 spin_unlock_irqrestore(&acm->write_lock, flags);
681
682 stat = acm_write_start(acm, wbn);
683 if (stat < 0)
684 return stat;
685 return count;
686}
687
688static int acm_tty_write_room(struct tty_struct *tty)
689{
690 struct acm *acm = tty->driver_data;
691 /*
692 * Do not let the line discipline to know that we have a reserve,
693 * or it might get too enthusiastic.
694 */
695 return acm_wb_is_avail(acm) ? acm->writesize : 0;
696}
697
698static int acm_tty_chars_in_buffer(struct tty_struct *tty)
699{
700 struct acm *acm = tty->driver_data;
701 /*
702 * if the device was unplugged then any remaining characters fell out
703 * of the connector ;)
704 */
705 if (acm->disconnected)
706 return 0;
707 /*
708 * This is inaccurate (overcounts), but it works.
709 */
710 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
711}
712
713static void acm_tty_throttle(struct tty_struct *tty)
714{
715 struct acm *acm = tty->driver_data;
716
717 spin_lock_irq(&acm->read_lock);
718 acm->throttle_req = 1;
719 spin_unlock_irq(&acm->read_lock);
720}
721
722static void acm_tty_unthrottle(struct tty_struct *tty)
723{
724 struct acm *acm = tty->driver_data;
725 unsigned int was_throttled;
726
727 spin_lock_irq(&acm->read_lock);
728 was_throttled = acm->throttled;
729 acm->throttled = 0;
730 acm->throttle_req = 0;
731 spin_unlock_irq(&acm->read_lock);
732
733 if (was_throttled)
734 acm_submit_read_urbs(acm, GFP_KERNEL);
735}
736
737static int acm_tty_break_ctl(struct tty_struct *tty, int state)
738{
739 struct acm *acm = tty->driver_data;
740 int retval;
741
742 retval = acm_send_break(acm, state ? 0xffff : 0);
743 if (retval < 0)
744 dev_dbg(&acm->control->dev, "%s - send break failed\n",
745 __func__);
746 return retval;
747}
748
749static int acm_tty_tiocmget(struct tty_struct *tty)
750{
751 struct acm *acm = tty->driver_data;
752
753 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
754 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
755 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
756 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
757 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
758 TIOCM_CTS;
759}
760
761static int acm_tty_tiocmset(struct tty_struct *tty,
762 unsigned int set, unsigned int clear)
763{
764 struct acm *acm = tty->driver_data;
765 unsigned int newctrl;
766
767 newctrl = acm->ctrlout;
768 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
769 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
770 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
771 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
772
773 newctrl = (newctrl & ~clear) | set;
774
775 if (acm->ctrlout == newctrl)
776 return 0;
777 return acm_set_control(acm, acm->ctrlout = newctrl);
778}
779
780static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
781{
782 struct serial_struct tmp;
783
784 if (!info)
785 return -EINVAL;
786
787 memset(&tmp, 0, sizeof(tmp));
788 tmp.flags = ASYNC_LOW_LATENCY;
789 tmp.xmit_fifo_size = acm->writesize;
790 tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
791
792 if (copy_to_user(info, &tmp, sizeof(tmp)))
793 return -EFAULT;
794 else
795 return 0;
796}
797
798static int acm_tty_ioctl(struct tty_struct *tty,
799 unsigned int cmd, unsigned long arg)
800{
801 struct acm *acm = tty->driver_data;
802 int rv = -ENOIOCTLCMD;
803
804 switch (cmd) {
805 case TIOCGSERIAL: /* gets serial port data */
806 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
807 break;
808 }
809
810 return rv;
811}
812
813static const __u32 acm_tty_speed[] = {
814 0, 50, 75, 110, 134, 150, 200, 300, 600,
815 1200, 1800, 2400, 4800, 9600, 19200, 38400,
816 57600, 115200, 230400, 460800, 500000, 576000,
817 921600, 1000000, 1152000, 1500000, 2000000,
818 2500000, 3000000, 3500000, 4000000
819};
820
821static const __u8 acm_tty_size[] = {
822 5, 6, 7, 8
823};
824
825static void acm_tty_set_termios(struct tty_struct *tty,
826 struct ktermios *termios_old)
827{
828 struct acm *acm = tty->driver_data;
829 struct ktermios *termios = tty->termios;
830 struct usb_cdc_line_coding newline;
831 int newctrl = acm->ctrlout;
832
833 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
834 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
835 newline.bParityType = termios->c_cflag & PARENB ?
836 (termios->c_cflag & PARODD ? 1 : 2) +
837 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
838 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
839 /* FIXME: Needs to clear unsupported bits in the termios */
840 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
841
842 if (!newline.dwDTERate) {
843 newline.dwDTERate = acm->line.dwDTERate;
844 newctrl &= ~ACM_CTRL_DTR;
845 } else
846 newctrl |= ACM_CTRL_DTR;
847
848 if (newctrl != acm->ctrlout)
849 acm_set_control(acm, acm->ctrlout = newctrl);
850
851 if (memcmp(&acm->line, &newline, sizeof newline)) {
852 memcpy(&acm->line, &newline, sizeof newline);
853 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
854 __func__,
855 le32_to_cpu(newline.dwDTERate),
856 newline.bCharFormat, newline.bParityType,
857 newline.bDataBits);
858 acm_set_line(acm, &acm->line);
859 }
860}
861
862static const struct tty_port_operations acm_port_ops = {
863 .shutdown = acm_port_shutdown,
864 .activate = acm_port_activate,
865 .destruct = acm_port_destruct,
866};
867
868/*
869 * USB probe and disconnect routines.
870 */
871
872/* Little helpers: write/read buffers free */
873static void acm_write_buffers_free(struct acm *acm)
874{
875 int i;
876 struct acm_wb *wb;
877 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
878
879 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
880 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
881}
882
883static void acm_read_buffers_free(struct acm *acm)
884{
885 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
886 int i;
887
888 for (i = 0; i < acm->rx_buflimit; i++)
889 usb_free_coherent(usb_dev, acm->readsize,
890 acm->read_buffers[i].base, acm->read_buffers[i].dma);
891}
892
893/* Little helper: write buffers allocate */
894static int acm_write_buffers_alloc(struct acm *acm)
895{
896 int i;
897 struct acm_wb *wb;
898
899 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
900 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
901 &wb->dmah);
902 if (!wb->buf) {
903 while (i != 0) {
904 --i;
905 --wb;
906 usb_free_coherent(acm->dev, acm->writesize,
907 wb->buf, wb->dmah);
908 }
909 return -ENOMEM;
910 }
911 }
912 return 0;
913}
914
915static int acm_probe(struct usb_interface *intf,
916 const struct usb_device_id *id)
917{
918 struct usb_cdc_union_desc *union_header = NULL;
919 struct usb_cdc_country_functional_desc *cfd = NULL;
920 unsigned char *buffer = intf->altsetting->extra;
921 int buflen = intf->altsetting->extralen;
922 struct usb_interface *control_interface;
923 struct usb_interface *data_interface;
924 struct usb_endpoint_descriptor *epctrl = NULL;
925 struct usb_endpoint_descriptor *epread = NULL;
926 struct usb_endpoint_descriptor *epwrite = NULL;
927 struct usb_device *usb_dev = interface_to_usbdev(intf);
928 struct acm *acm;
929 int minor;
930 int ctrlsize, readsize;
931 u8 *buf;
932 u8 ac_management_function = 0;
933 u8 call_management_function = 0;
934 int call_interface_num = -1;
935 int data_interface_num = -1;
936 unsigned long quirks;
937 int num_rx_buf;
938 int i;
939 int combined_interfaces = 0;
940
941 /* normal quirks */
942 quirks = (unsigned long)id->driver_info;
943 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
944
945 /* handle quirks deadly to normal probing*/
946 if (quirks == NO_UNION_NORMAL) {
947 data_interface = usb_ifnum_to_if(usb_dev, 1);
948 control_interface = usb_ifnum_to_if(usb_dev, 0);
949 goto skip_normal_probe;
950 }
951
952 /* normal probing*/
953 if (!buffer) {
954 dev_err(&intf->dev, "Weird descriptor references\n");
955 return -EINVAL;
956 }
957
958 if (!buflen) {
959 if (intf->cur_altsetting->endpoint &&
960 intf->cur_altsetting->endpoint->extralen &&
961 intf->cur_altsetting->endpoint->extra) {
962 dev_dbg(&intf->dev,
963 "Seeking extra descriptors on endpoint\n");
964 buflen = intf->cur_altsetting->endpoint->extralen;
965 buffer = intf->cur_altsetting->endpoint->extra;
966 } else {
967 dev_err(&intf->dev,
968 "Zero length descriptor references\n");
969 return -EINVAL;
970 }
971 }
972
973 while (buflen > 0) {
974 if (buffer[1] != USB_DT_CS_INTERFACE) {
975 dev_err(&intf->dev, "skipping garbage\n");
976 goto next_desc;
977 }
978
979 switch (buffer[2]) {
980 case USB_CDC_UNION_TYPE: /* we've found it */
981 if (union_header) {
982 dev_err(&intf->dev, "More than one "
983 "union descriptor, skipping ...\n");
984 goto next_desc;
985 }
986 union_header = (struct usb_cdc_union_desc *)buffer;
987 break;
988 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
989 cfd = (struct usb_cdc_country_functional_desc *)buffer;
990 break;
991 case USB_CDC_HEADER_TYPE: /* maybe check version */
992 break; /* for now we ignore it */
993 case USB_CDC_ACM_TYPE:
994 ac_management_function = buffer[3];
995 break;
996 case USB_CDC_CALL_MANAGEMENT_TYPE:
997 call_management_function = buffer[3];
998 call_interface_num = buffer[4];
999 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1000 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1001 break;
1002 default:
1003 /* there are LOTS more CDC descriptors that
1004 * could legitimately be found here.
1005 */
1006 dev_dbg(&intf->dev, "Ignoring descriptor: "
1007 "type %02x, length %d\n",
1008 buffer[2], buffer[0]);
1009 break;
1010 }
1011next_desc:
1012 buflen -= buffer[0];
1013 buffer += buffer[0];
1014 }
1015
1016 if (!union_header) {
1017 if (call_interface_num > 0) {
1018 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1019 /* quirks for Droids MuIn LCD */
1020 if (quirks & NO_DATA_INTERFACE)
1021 data_interface = usb_ifnum_to_if(usb_dev, 0);
1022 else
1023 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1024 control_interface = intf;
1025 } else {
1026 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1027 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1028 return -ENODEV;
1029 } else {
1030 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1031 combined_interfaces = 1;
1032 control_interface = data_interface = intf;
1033 goto look_for_collapsed_interface;
1034 }
1035 }
1036 } else {
1037 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1038 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1039 if (!control_interface || !data_interface) {
1040 dev_dbg(&intf->dev, "no interfaces\n");
1041 return -ENODEV;
1042 }
1043 }
1044
1045 if (data_interface_num != call_interface_num)
1046 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1047
1048 if (control_interface == data_interface) {
1049 /* some broken devices designed for windows work this way */
1050 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1051 combined_interfaces = 1;
1052 /* a popular other OS doesn't use it */
1053 quirks |= NO_CAP_LINE;
1054 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1055 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1056 return -EINVAL;
1057 }
1058look_for_collapsed_interface:
1059 for (i = 0; i < 3; i++) {
1060 struct usb_endpoint_descriptor *ep;
1061 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1062
1063 if (usb_endpoint_is_int_in(ep))
1064 epctrl = ep;
1065 else if (usb_endpoint_is_bulk_out(ep))
1066 epwrite = ep;
1067 else if (usb_endpoint_is_bulk_in(ep))
1068 epread = ep;
1069 else
1070 return -EINVAL;
1071 }
1072 if (!epctrl || !epread || !epwrite)
1073 return -ENODEV;
1074 else
1075 goto made_compressed_probe;
1076 }
1077
1078skip_normal_probe:
1079
1080 /*workaround for switched interfaces */
1081 if (data_interface->cur_altsetting->desc.bInterfaceClass
1082 != CDC_DATA_INTERFACE_TYPE) {
1083 if (control_interface->cur_altsetting->desc.bInterfaceClass
1084 == CDC_DATA_INTERFACE_TYPE) {
1085 struct usb_interface *t;
1086 dev_dbg(&intf->dev,
1087 "Your device has switched interfaces.\n");
1088 t = control_interface;
1089 control_interface = data_interface;
1090 data_interface = t;
1091 } else {
1092 return -EINVAL;
1093 }
1094 }
1095
1096 /* Accept probe requests only for the control interface */
1097 if (!combined_interfaces && intf != control_interface)
1098 return -ENODEV;
1099
1100 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1101 /* valid in this context */
1102 dev_dbg(&intf->dev, "The data interface isn't available\n");
1103 return -EBUSY;
1104 }
1105
1106
1107 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1108 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1109 return -EINVAL;
1110
1111 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1112 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1113 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1114
1115
1116 /* workaround for switched endpoints */
1117 if (!usb_endpoint_dir_in(epread)) {
1118 /* descriptors are swapped */
1119 struct usb_endpoint_descriptor *t;
1120 dev_dbg(&intf->dev,
1121 "The data interface has switched endpoints\n");
1122 t = epread;
1123 epread = epwrite;
1124 epwrite = t;
1125 }
1126made_compressed_probe:
1127 dev_dbg(&intf->dev, "interfaces are valid\n");
1128
1129 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1130 if (acm == NULL) {
1131 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1132 goto alloc_fail;
1133 }
1134
1135 minor = acm_alloc_minor(acm);
1136 if (minor == ACM_TTY_MINORS) {
1137 dev_err(&intf->dev, "no more free acm devices\n");
1138 kfree(acm);
1139 return -ENODEV;
1140 }
1141
1142 ctrlsize = usb_endpoint_maxp(epctrl);
1143 readsize = usb_endpoint_maxp(epread) *
1144 (quirks == SINGLE_RX_URB ? 1 : 2);
1145 acm->combined_interfaces = combined_interfaces;
1146 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1147 acm->control = control_interface;
1148 acm->data = data_interface;
1149 acm->minor = minor;
1150 acm->dev = usb_dev;
1151 acm->ctrl_caps = ac_management_function;
1152 if (quirks & NO_CAP_LINE)
1153 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1154 acm->ctrlsize = ctrlsize;
1155 acm->readsize = readsize;
1156 acm->rx_buflimit = num_rx_buf;
1157 INIT_WORK(&acm->work, acm_softint);
1158 spin_lock_init(&acm->write_lock);
1159 spin_lock_init(&acm->read_lock);
1160 mutex_init(&acm->mutex);
1161 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1162 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1163 if (acm->is_int_ep)
1164 acm->bInterval = epread->bInterval;
1165 tty_port_init(&acm->port);
1166 acm->port.ops = &acm_port_ops;
1167
1168 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1169 if (!buf) {
1170 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1171 goto alloc_fail2;
1172 }
1173 acm->ctrl_buffer = buf;
1174
1175 if (acm_write_buffers_alloc(acm) < 0) {
1176 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1177 goto alloc_fail4;
1178 }
1179
1180 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1181 if (!acm->ctrlurb) {
1182 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1183 goto alloc_fail5;
1184 }
1185 for (i = 0; i < num_rx_buf; i++) {
1186 struct acm_rb *rb = &(acm->read_buffers[i]);
1187 struct urb *urb;
1188
1189 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1190 &rb->dma);
1191 if (!rb->base) {
1192 dev_err(&intf->dev, "out of memory "
1193 "(read bufs usb_alloc_coherent)\n");
1194 goto alloc_fail6;
1195 }
1196 rb->index = i;
1197 rb->instance = acm;
1198
1199 urb = usb_alloc_urb(0, GFP_KERNEL);
1200 if (!urb) {
1201 dev_err(&intf->dev,
1202 "out of memory (read urbs usb_alloc_urb)\n");
1203 goto alloc_fail6;
1204 }
1205 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1206 urb->transfer_dma = rb->dma;
1207 if (acm->is_int_ep) {
1208 usb_fill_int_urb(urb, acm->dev,
1209 acm->rx_endpoint,
1210 rb->base,
1211 acm->readsize,
1212 acm_read_bulk_callback, rb,
1213 acm->bInterval);
1214 } else {
1215 usb_fill_bulk_urb(urb, acm->dev,
1216 acm->rx_endpoint,
1217 rb->base,
1218 acm->readsize,
1219 acm_read_bulk_callback, rb);
1220 }
1221
1222 acm->read_urbs[i] = urb;
1223 __set_bit(i, &acm->read_urbs_free);
1224 }
1225 for (i = 0; i < ACM_NW; i++) {
1226 struct acm_wb *snd = &(acm->wb[i]);
1227
1228 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1229 if (snd->urb == NULL) {
1230 dev_err(&intf->dev,
1231 "out of memory (write urbs usb_alloc_urb)\n");
1232 goto alloc_fail7;
1233 }
1234
1235 if (usb_endpoint_xfer_int(epwrite))
1236 usb_fill_int_urb(snd->urb, usb_dev,
1237 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1238 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1239 else
1240 usb_fill_bulk_urb(snd->urb, usb_dev,
1241 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1242 NULL, acm->writesize, acm_write_bulk, snd);
1243 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1244 snd->instance = acm;
1245 }
1246
1247 usb_set_intfdata(intf, acm);
1248
1249 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1250 if (i < 0)
1251 goto alloc_fail7;
1252
1253 if (cfd) { /* export the country data */
1254 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1255 if (!acm->country_codes)
1256 goto skip_countries;
1257 acm->country_code_size = cfd->bLength - 4;
1258 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1259 cfd->bLength - 4);
1260 acm->country_rel_date = cfd->iCountryCodeRelDate;
1261
1262 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1263 if (i < 0) {
1264 kfree(acm->country_codes);
1265 acm->country_codes = NULL;
1266 acm->country_code_size = 0;
1267 goto skip_countries;
1268 }
1269
1270 i = device_create_file(&intf->dev,
1271 &dev_attr_iCountryCodeRelDate);
1272 if (i < 0) {
1273 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1274 kfree(acm->country_codes);
1275 acm->country_codes = NULL;
1276 acm->country_code_size = 0;
1277 goto skip_countries;
1278 }
1279 }
1280
1281skip_countries:
1282 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1283 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1284 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1285 /* works around buggy devices */
1286 epctrl->bInterval ? epctrl->bInterval : 0xff);
1287 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1289
1290 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1291
1292 acm_set_control(acm, acm->ctrlout);
1293
1294 acm->line.dwDTERate = cpu_to_le32(9600);
1295 acm->line.bDataBits = 8;
1296 acm_set_line(acm, &acm->line);
1297
1298 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1299 usb_set_intfdata(data_interface, acm);
1300
1301 usb_get_intf(control_interface);
1302 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1303
1304 return 0;
1305alloc_fail7:
1306 for (i = 0; i < ACM_NW; i++)
1307 usb_free_urb(acm->wb[i].urb);
1308alloc_fail6:
1309 for (i = 0; i < num_rx_buf; i++)
1310 usb_free_urb(acm->read_urbs[i]);
1311 acm_read_buffers_free(acm);
1312 usb_free_urb(acm->ctrlurb);
1313alloc_fail5:
1314 acm_write_buffers_free(acm);
1315alloc_fail4:
1316 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1317alloc_fail2:
1318 acm_release_minor(acm);
1319 kfree(acm);
1320alloc_fail:
1321 return -ENOMEM;
1322}
1323
1324static void stop_data_traffic(struct acm *acm)
1325{
1326 int i;
1327
1328 dev_dbg(&acm->control->dev, "%s\n", __func__);
1329
1330 usb_kill_urb(acm->ctrlurb);
1331 for (i = 0; i < ACM_NW; i++)
1332 usb_kill_urb(acm->wb[i].urb);
1333 for (i = 0; i < acm->rx_buflimit; i++)
1334 usb_kill_urb(acm->read_urbs[i]);
1335
1336 cancel_work_sync(&acm->work);
1337}
1338
1339static void acm_disconnect(struct usb_interface *intf)
1340{
1341 struct acm *acm = usb_get_intfdata(intf);
1342 struct usb_device *usb_dev = interface_to_usbdev(intf);
1343 struct tty_struct *tty;
1344 int i;
1345
1346 dev_dbg(&intf->dev, "%s\n", __func__);
1347
1348 /* sibling interface is already cleaning up */
1349 if (!acm)
1350 return;
1351
1352 mutex_lock(&acm->mutex);
1353 acm->disconnected = true;
1354 if (acm->country_codes) {
1355 device_remove_file(&acm->control->dev,
1356 &dev_attr_wCountryCodes);
1357 device_remove_file(&acm->control->dev,
1358 &dev_attr_iCountryCodeRelDate);
1359 }
1360 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1361 usb_set_intfdata(acm->control, NULL);
1362 usb_set_intfdata(acm->data, NULL);
1363 mutex_unlock(&acm->mutex);
1364
1365 tty = tty_port_tty_get(&acm->port);
1366 if (tty) {
1367 tty_vhangup(tty);
1368 tty_kref_put(tty);
1369 }
1370
1371 stop_data_traffic(acm);
1372
1373 usb_free_urb(acm->ctrlurb);
1374 for (i = 0; i < ACM_NW; i++)
1375 usb_free_urb(acm->wb[i].urb);
1376 for (i = 0; i < acm->rx_buflimit; i++)
1377 usb_free_urb(acm->read_urbs[i]);
1378 acm_write_buffers_free(acm);
1379 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1380 acm_read_buffers_free(acm);
1381
1382 if (!acm->combined_interfaces)
1383 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1384 acm->data : acm->control);
1385
1386 tty_port_put(&acm->port);
1387}
1388
1389#ifdef CONFIG_PM
1390static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1391{
1392 struct acm *acm = usb_get_intfdata(intf);
1393 int cnt;
1394
1395 if (PMSG_IS_AUTO(message)) {
1396 int b;
1397
1398 spin_lock_irq(&acm->write_lock);
1399 b = acm->transmitting;
1400 spin_unlock_irq(&acm->write_lock);
1401 if (b)
1402 return -EBUSY;
1403 }
1404
1405 spin_lock_irq(&acm->read_lock);
1406 spin_lock(&acm->write_lock);
1407 cnt = acm->susp_count++;
1408 spin_unlock(&acm->write_lock);
1409 spin_unlock_irq(&acm->read_lock);
1410
1411 if (cnt)
1412 return 0;
1413
1414 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1415 stop_data_traffic(acm);
1416
1417 return 0;
1418}
1419
1420static int acm_resume(struct usb_interface *intf)
1421{
1422 struct acm *acm = usb_get_intfdata(intf);
1423 struct acm_wb *wb;
1424 int rv = 0;
1425 int cnt;
1426
1427 spin_lock_irq(&acm->read_lock);
1428 acm->susp_count -= 1;
1429 cnt = acm->susp_count;
1430 spin_unlock_irq(&acm->read_lock);
1431
1432 if (cnt)
1433 return 0;
1434
1435 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1436 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1437
1438 spin_lock_irq(&acm->write_lock);
1439 if (acm->delayed_wb) {
1440 wb = acm->delayed_wb;
1441 acm->delayed_wb = NULL;
1442 spin_unlock_irq(&acm->write_lock);
1443 acm_start_wb(acm, wb);
1444 } else {
1445 spin_unlock_irq(&acm->write_lock);
1446 }
1447
1448 /*
1449 * delayed error checking because we must
1450 * do the write path at all cost
1451 */
1452 if (rv < 0)
1453 goto err_out;
1454
1455 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1456 }
1457
1458err_out:
1459 return rv;
1460}
1461
1462static int acm_reset_resume(struct usb_interface *intf)
1463{
1464 struct acm *acm = usb_get_intfdata(intf);
1465 struct tty_struct *tty;
1466
1467 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1468 tty = tty_port_tty_get(&acm->port);
1469 if (tty) {
1470 tty_hangup(tty);
1471 tty_kref_put(tty);
1472 }
1473 }
1474
1475 return acm_resume(intf);
1476}
1477
1478#endif /* CONFIG_PM */
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 * USB driver structure.
1492 */
1493
1494static const struct usb_device_id acm_ids[] = {
1495 /* quirky and broken devices */
1496 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1497 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498 },
1499 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1500 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501 },
1502 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1503 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504 },
1505 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1506 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1507 },
1508 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1509 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1510 },
1511 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1512 .driver_info = SINGLE_RX_URB,
1513 },
1514 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1515 .driver_info = SINGLE_RX_URB, /* firmware bug */
1516 },
1517 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1518 .driver_info = SINGLE_RX_URB, /* firmware bug */
1519 },
1520 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1521 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522 },
1523 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1524 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525 },
1526 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1527 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528 },
1529 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1530 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1531 },
1532 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1533 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1534 },
1535 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1536 },
1537 /* Motorola H24 HSPA module: */
1538 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1539 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1540 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1541 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1542 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1543 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1544 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1545 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1546
1547 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1548 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1549 data interface instead of
1550 communications interface.
1551 Maybe we should define a new
1552 quirk for this. */
1553 },
1554 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1555 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1556 },
1557 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1558 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1559 },
1560
1561 /* Nokia S60 phones expose two ACM channels. The first is
1562 * a modem and is picked up by the standard AT-command
1563 * information below. The second is 'vendor-specific' but
1564 * is treated as a serial device at the S60 end, so we want
1565 * to expose it on Linux too. */
1566 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1568 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1572 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1576 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1577 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1579 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1581 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1582 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1583 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1584 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1585 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1586 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1587 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1589 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1590 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1594 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1596 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1597 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1598 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1599 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1602 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1606 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1607 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1608 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1609 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1611 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1612 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1613 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1615 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1616 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1617 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1618 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1619 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1620 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1621 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1622 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1623 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1624
1625 /* Support for Owen devices */
1626 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1627
1628 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1629
1630 /* Support Lego NXT using pbLua firmware */
1631 { USB_DEVICE(0x0694, 0xff00),
1632 .driver_info = NOT_A_MODEM,
1633 },
1634
1635 /* Support for Droids MuIn LCD */
1636 { USB_DEVICE(0x04d8, 0x000b),
1637 .driver_info = NO_DATA_INTERFACE,
1638 },
1639
1640 /* control interfaces without any protocol set */
1641 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1642 USB_CDC_PROTO_NONE) },
1643
1644 /* control interfaces with various AT-command sets */
1645 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1646 USB_CDC_ACM_PROTO_AT_V25TER) },
1647 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1648 USB_CDC_ACM_PROTO_AT_PCCA101) },
1649 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1650 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1651 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1652 USB_CDC_ACM_PROTO_AT_GSM) },
1653 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1654 USB_CDC_ACM_PROTO_AT_3G) },
1655 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1656 USB_CDC_ACM_PROTO_AT_CDMA) },
1657
1658 { }
1659};
1660
1661MODULE_DEVICE_TABLE(usb, acm_ids);
1662
1663static struct usb_driver acm_driver = {
1664 .name = "cdc_acm",
1665 .probe = acm_probe,
1666 .disconnect = acm_disconnect,
1667#ifdef CONFIG_PM
1668 .suspend = acm_suspend,
1669 .resume = acm_resume,
1670 .reset_resume = acm_reset_resume,
1671#endif
1672 .id_table = acm_ids,
1673#ifdef CONFIG_PM
1674 .supports_autosuspend = 1,
1675#endif
1676 .disable_hub_initiated_lpm = 1,
1677};
1678
1679/*
1680 * TTY driver structures.
1681 */
1682
1683static const struct tty_operations acm_ops = {
1684 .install = acm_tty_install,
1685 .open = acm_tty_open,
1686 .close = acm_tty_close,
1687 .cleanup = acm_tty_cleanup,
1688 .hangup = acm_tty_hangup,
1689 .write = acm_tty_write,
1690 .write_room = acm_tty_write_room,
1691 .ioctl = acm_tty_ioctl,
1692 .throttle = acm_tty_throttle,
1693 .unthrottle = acm_tty_unthrottle,
1694 .chars_in_buffer = acm_tty_chars_in_buffer,
1695 .break_ctl = acm_tty_break_ctl,
1696 .set_termios = acm_tty_set_termios,
1697 .tiocmget = acm_tty_tiocmget,
1698 .tiocmset = acm_tty_tiocmset,
1699};
1700
1701/*
1702 * Init / exit.
1703 */
1704
1705static int __init acm_init(void)
1706{
1707 int retval;
1708 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1709 if (!acm_tty_driver)
1710 return -ENOMEM;
1711 acm_tty_driver->driver_name = "acm",
1712 acm_tty_driver->name = "ttyACM",
1713 acm_tty_driver->major = ACM_TTY_MAJOR,
1714 acm_tty_driver->minor_start = 0,
1715 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1716 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1717 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1718 acm_tty_driver->init_termios = tty_std_termios;
1719 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1720 HUPCL | CLOCAL;
1721 tty_set_operations(acm_tty_driver, &acm_ops);
1722
1723 retval = tty_register_driver(acm_tty_driver);
1724 if (retval) {
1725 put_tty_driver(acm_tty_driver);
1726 return retval;
1727 }
1728
1729 retval = usb_register(&acm_driver);
1730 if (retval) {
1731 tty_unregister_driver(acm_tty_driver);
1732 put_tty_driver(acm_tty_driver);
1733 return retval;
1734 }
1735
1736 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1737
1738 return 0;
1739}
1740
1741static void __exit acm_exit(void)
1742{
1743 usb_deregister(&acm_driver);
1744 tty_unregister_driver(acm_tty_driver);
1745 put_tty_driver(acm_tty_driver);
1746}
1747
1748module_init(acm_init);
1749module_exit(acm_exit);
1750
1751MODULE_AUTHOR(DRIVER_AUTHOR);
1752MODULE_DESCRIPTION(DRIVER_DESC);
1753MODULE_LICENSE("GPL");
1754MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * cdc-acm.c
4 *
5 * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
6 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
7 * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
8 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
9 * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
10 * Copyright (c) 2005 David Kubicek <dave@awk.cz>
11 * Copyright (c) 2011 Johan Hovold <jhovold@gmail.com>
12 *
13 * USB Abstract Control Model driver for USB modems and ISDN adapters
14 *
15 * Sponsored by SuSE
16 */
17
18#undef DEBUG
19#undef VERBOSE_DEBUG
20
21#include <linux/kernel.h>
22#include <linux/sched/signal.h>
23#include <linux/errno.h>
24#include <linux/init.h>
25#include <linux/slab.h>
26#include <linux/log2.h>
27#include <linux/tty.h>
28#include <linux/serial.h>
29#include <linux/tty_driver.h>
30#include <linux/tty_flip.h>
31#include <linux/module.h>
32#include <linux/mutex.h>
33#include <linux/uaccess.h>
34#include <linux/usb.h>
35#include <linux/usb/cdc.h>
36#include <asm/byteorder.h>
37#include <asm/unaligned.h>
38#include <linux/idr.h>
39#include <linux/list.h>
40
41#include "cdc-acm.h"
42
43
44#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
45#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
46
47static struct usb_driver acm_driver;
48static struct tty_driver *acm_tty_driver;
49
50static DEFINE_IDR(acm_minors);
51static DEFINE_MUTEX(acm_minors_lock);
52
53static void acm_tty_set_termios(struct tty_struct *tty,
54 const struct ktermios *termios_old);
55
56/*
57 * acm_minors accessors
58 */
59
60/*
61 * Look up an ACM structure by minor. If found and not disconnected, increment
62 * its refcount and return it with its mutex held.
63 */
64static struct acm *acm_get_by_minor(unsigned int minor)
65{
66 struct acm *acm;
67
68 mutex_lock(&acm_minors_lock);
69 acm = idr_find(&acm_minors, minor);
70 if (acm) {
71 mutex_lock(&acm->mutex);
72 if (acm->disconnected) {
73 mutex_unlock(&acm->mutex);
74 acm = NULL;
75 } else {
76 tty_port_get(&acm->port);
77 mutex_unlock(&acm->mutex);
78 }
79 }
80 mutex_unlock(&acm_minors_lock);
81 return acm;
82}
83
84/*
85 * Try to find an available minor number and if found, associate it with 'acm'.
86 */
87static int acm_alloc_minor(struct acm *acm)
88{
89 int minor;
90
91 mutex_lock(&acm_minors_lock);
92 minor = idr_alloc(&acm_minors, acm, 0, ACM_TTY_MINORS, GFP_KERNEL);
93 mutex_unlock(&acm_minors_lock);
94
95 return minor;
96}
97
98/* Release the minor number associated with 'acm'. */
99static void acm_release_minor(struct acm *acm)
100{
101 mutex_lock(&acm_minors_lock);
102 idr_remove(&acm_minors, acm->minor);
103 mutex_unlock(&acm_minors_lock);
104}
105
106/*
107 * Functions for ACM control messages.
108 */
109
110static int acm_ctrl_msg(struct acm *acm, int request, int value,
111 void *buf, int len)
112{
113 int retval;
114
115 retval = usb_autopm_get_interface(acm->control);
116 if (retval)
117 return retval;
118
119 retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
120 request, USB_RT_ACM, value,
121 acm->control->altsetting[0].desc.bInterfaceNumber,
122 buf, len, USB_CTRL_SET_TIMEOUT);
123
124 dev_dbg(&acm->control->dev,
125 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
126 __func__, request, value, len, retval);
127
128 usb_autopm_put_interface(acm->control);
129
130 return retval < 0 ? retval : 0;
131}
132
133/* devices aren't required to support these requests.
134 * the cdc acm descriptor tells whether they do...
135 */
136static inline int acm_set_control(struct acm *acm, int control)
137{
138 if (acm->quirks & QUIRK_CONTROL_LINE_STATE)
139 return -EOPNOTSUPP;
140
141 return acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE,
142 control, NULL, 0);
143}
144
145#define acm_set_line(acm, line) \
146 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
147#define acm_send_break(acm, ms) \
148 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
149
150static void acm_poison_urbs(struct acm *acm)
151{
152 int i;
153
154 usb_poison_urb(acm->ctrlurb);
155 for (i = 0; i < ACM_NW; i++)
156 usb_poison_urb(acm->wb[i].urb);
157 for (i = 0; i < acm->rx_buflimit; i++)
158 usb_poison_urb(acm->read_urbs[i]);
159}
160
161static void acm_unpoison_urbs(struct acm *acm)
162{
163 int i;
164
165 for (i = 0; i < acm->rx_buflimit; i++)
166 usb_unpoison_urb(acm->read_urbs[i]);
167 for (i = 0; i < ACM_NW; i++)
168 usb_unpoison_urb(acm->wb[i].urb);
169 usb_unpoison_urb(acm->ctrlurb);
170}
171
172
173/*
174 * Write buffer management.
175 * All of these assume proper locks taken by the caller.
176 */
177
178static int acm_wb_alloc(struct acm *acm)
179{
180 int i, wbn;
181 struct acm_wb *wb;
182
183 wbn = 0;
184 i = 0;
185 for (;;) {
186 wb = &acm->wb[wbn];
187 if (!wb->use) {
188 wb->use = true;
189 wb->len = 0;
190 return wbn;
191 }
192 wbn = (wbn + 1) % ACM_NW;
193 if (++i >= ACM_NW)
194 return -1;
195 }
196}
197
198static int acm_wb_is_avail(struct acm *acm)
199{
200 int i, n;
201 unsigned long flags;
202
203 n = ACM_NW;
204 spin_lock_irqsave(&acm->write_lock, flags);
205 for (i = 0; i < ACM_NW; i++)
206 if(acm->wb[i].use)
207 n--;
208 spin_unlock_irqrestore(&acm->write_lock, flags);
209 return n;
210}
211
212/*
213 * Finish write. Caller must hold acm->write_lock
214 */
215static void acm_write_done(struct acm *acm, struct acm_wb *wb)
216{
217 wb->use = false;
218 acm->transmitting--;
219 usb_autopm_put_interface_async(acm->control);
220}
221
222/*
223 * Poke write.
224 *
225 * the caller is responsible for locking
226 */
227
228static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
229{
230 int rc;
231
232 acm->transmitting++;
233
234 wb->urb->transfer_buffer = wb->buf;
235 wb->urb->transfer_dma = wb->dmah;
236 wb->urb->transfer_buffer_length = wb->len;
237 wb->urb->dev = acm->dev;
238
239 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
240 if (rc < 0) {
241 if (rc != -EPERM)
242 dev_err(&acm->data->dev,
243 "%s - usb_submit_urb(write bulk) failed: %d\n",
244 __func__, rc);
245 acm_write_done(acm, wb);
246 }
247 return rc;
248}
249
250/*
251 * attributes exported through sysfs
252 */
253static ssize_t bmCapabilities_show
254(struct device *dev, struct device_attribute *attr, char *buf)
255{
256 struct usb_interface *intf = to_usb_interface(dev);
257 struct acm *acm = usb_get_intfdata(intf);
258
259 return sprintf(buf, "%d", acm->ctrl_caps);
260}
261static DEVICE_ATTR_RO(bmCapabilities);
262
263static ssize_t wCountryCodes_show
264(struct device *dev, struct device_attribute *attr, char *buf)
265{
266 struct usb_interface *intf = to_usb_interface(dev);
267 struct acm *acm = usb_get_intfdata(intf);
268
269 memcpy(buf, acm->country_codes, acm->country_code_size);
270 return acm->country_code_size;
271}
272
273static DEVICE_ATTR_RO(wCountryCodes);
274
275static ssize_t iCountryCodeRelDate_show
276(struct device *dev, struct device_attribute *attr, char *buf)
277{
278 struct usb_interface *intf = to_usb_interface(dev);
279 struct acm *acm = usb_get_intfdata(intf);
280
281 return sprintf(buf, "%d", acm->country_rel_date);
282}
283
284static DEVICE_ATTR_RO(iCountryCodeRelDate);
285/*
286 * Interrupt handlers for various ACM device responses
287 */
288
289static void acm_process_notification(struct acm *acm, unsigned char *buf)
290{
291 int newctrl;
292 int difference;
293 unsigned long flags;
294 struct usb_cdc_notification *dr = (struct usb_cdc_notification *)buf;
295 unsigned char *data = buf + sizeof(struct usb_cdc_notification);
296
297 switch (dr->bNotificationType) {
298 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
299 dev_dbg(&acm->control->dev,
300 "%s - network connection: %d\n", __func__, dr->wValue);
301 break;
302
303 case USB_CDC_NOTIFY_SERIAL_STATE:
304 if (le16_to_cpu(dr->wLength) != 2) {
305 dev_dbg(&acm->control->dev,
306 "%s - malformed serial state\n", __func__);
307 break;
308 }
309
310 newctrl = get_unaligned_le16(data);
311 dev_dbg(&acm->control->dev,
312 "%s - serial state: 0x%x\n", __func__, newctrl);
313
314 if (!acm->clocal && (acm->ctrlin & ~newctrl & USB_CDC_SERIAL_STATE_DCD)) {
315 dev_dbg(&acm->control->dev,
316 "%s - calling hangup\n", __func__);
317 tty_port_tty_hangup(&acm->port, false);
318 }
319
320 difference = acm->ctrlin ^ newctrl;
321 spin_lock_irqsave(&acm->read_lock, flags);
322 acm->ctrlin = newctrl;
323 acm->oldcount = acm->iocount;
324
325 if (difference & USB_CDC_SERIAL_STATE_DSR)
326 acm->iocount.dsr++;
327 if (difference & USB_CDC_SERIAL_STATE_DCD)
328 acm->iocount.dcd++;
329 if (newctrl & USB_CDC_SERIAL_STATE_BREAK) {
330 acm->iocount.brk++;
331 tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
332 }
333 if (newctrl & USB_CDC_SERIAL_STATE_RING_SIGNAL)
334 acm->iocount.rng++;
335 if (newctrl & USB_CDC_SERIAL_STATE_FRAMING)
336 acm->iocount.frame++;
337 if (newctrl & USB_CDC_SERIAL_STATE_PARITY)
338 acm->iocount.parity++;
339 if (newctrl & USB_CDC_SERIAL_STATE_OVERRUN)
340 acm->iocount.overrun++;
341 spin_unlock_irqrestore(&acm->read_lock, flags);
342
343 if (newctrl & USB_CDC_SERIAL_STATE_BREAK)
344 tty_flip_buffer_push(&acm->port);
345
346 if (difference)
347 wake_up_all(&acm->wioctl);
348
349 break;
350
351 default:
352 dev_dbg(&acm->control->dev,
353 "%s - unknown notification %d received: index %d len %d\n",
354 __func__,
355 dr->bNotificationType, dr->wIndex, dr->wLength);
356 }
357}
358
359/* control interface reports status changes with "interrupt" transfers */
360static void acm_ctrl_irq(struct urb *urb)
361{
362 struct acm *acm = urb->context;
363 struct usb_cdc_notification *dr = urb->transfer_buffer;
364 unsigned int current_size = urb->actual_length;
365 unsigned int expected_size, copy_size, alloc_size;
366 int retval;
367 int status = urb->status;
368
369 switch (status) {
370 case 0:
371 /* success */
372 break;
373 case -ECONNRESET:
374 case -ENOENT:
375 case -ESHUTDOWN:
376 /* this urb is terminated, clean up */
377 dev_dbg(&acm->control->dev,
378 "%s - urb shutting down with status: %d\n",
379 __func__, status);
380 return;
381 default:
382 dev_dbg(&acm->control->dev,
383 "%s - nonzero urb status received: %d\n",
384 __func__, status);
385 goto exit;
386 }
387
388 usb_mark_last_busy(acm->dev);
389
390 if (acm->nb_index)
391 dr = (struct usb_cdc_notification *)acm->notification_buffer;
392
393 /* size = notification-header + (optional) data */
394 expected_size = sizeof(struct usb_cdc_notification) +
395 le16_to_cpu(dr->wLength);
396
397 if (current_size < expected_size) {
398 /* notification is transmitted fragmented, reassemble */
399 if (acm->nb_size < expected_size) {
400 u8 *new_buffer;
401 alloc_size = roundup_pow_of_two(expected_size);
402 /* Final freeing is done on disconnect. */
403 new_buffer = krealloc(acm->notification_buffer,
404 alloc_size, GFP_ATOMIC);
405 if (!new_buffer) {
406 acm->nb_index = 0;
407 goto exit;
408 }
409
410 acm->notification_buffer = new_buffer;
411 acm->nb_size = alloc_size;
412 dr = (struct usb_cdc_notification *)acm->notification_buffer;
413 }
414
415 copy_size = min(current_size,
416 expected_size - acm->nb_index);
417
418 memcpy(&acm->notification_buffer[acm->nb_index],
419 urb->transfer_buffer, copy_size);
420 acm->nb_index += copy_size;
421 current_size = acm->nb_index;
422 }
423
424 if (current_size >= expected_size) {
425 /* notification complete */
426 acm_process_notification(acm, (unsigned char *)dr);
427 acm->nb_index = 0;
428 }
429
430exit:
431 retval = usb_submit_urb(urb, GFP_ATOMIC);
432 if (retval && retval != -EPERM && retval != -ENODEV)
433 dev_err(&acm->control->dev,
434 "%s - usb_submit_urb failed: %d\n", __func__, retval);
435 else
436 dev_vdbg(&acm->control->dev,
437 "control resubmission terminated %d\n", retval);
438}
439
440static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
441{
442 int res;
443
444 if (!test_and_clear_bit(index, &acm->read_urbs_free))
445 return 0;
446
447 res = usb_submit_urb(acm->read_urbs[index], mem_flags);
448 if (res) {
449 if (res != -EPERM && res != -ENODEV) {
450 dev_err(&acm->data->dev,
451 "urb %d failed submission with %d\n",
452 index, res);
453 } else {
454 dev_vdbg(&acm->data->dev, "intended failure %d\n", res);
455 }
456 set_bit(index, &acm->read_urbs_free);
457 return res;
458 } else {
459 dev_vdbg(&acm->data->dev, "submitted urb %d\n", index);
460 }
461
462 return 0;
463}
464
465static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
466{
467 int res;
468 int i;
469
470 for (i = 0; i < acm->rx_buflimit; ++i) {
471 res = acm_submit_read_urb(acm, i, mem_flags);
472 if (res)
473 return res;
474 }
475
476 return 0;
477}
478
479static void acm_process_read_urb(struct acm *acm, struct urb *urb)
480{
481 unsigned long flags;
482
483 if (!urb->actual_length)
484 return;
485
486 spin_lock_irqsave(&acm->read_lock, flags);
487 tty_insert_flip_string(&acm->port, urb->transfer_buffer,
488 urb->actual_length);
489 spin_unlock_irqrestore(&acm->read_lock, flags);
490
491 tty_flip_buffer_push(&acm->port);
492}
493
494static void acm_read_bulk_callback(struct urb *urb)
495{
496 struct acm_rb *rb = urb->context;
497 struct acm *acm = rb->instance;
498 int status = urb->status;
499 bool stopped = false;
500 bool stalled = false;
501 bool cooldown = false;
502
503 dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
504 rb->index, urb->actual_length, status);
505
506 switch (status) {
507 case 0:
508 usb_mark_last_busy(acm->dev);
509 acm_process_read_urb(acm, urb);
510 break;
511 case -EPIPE:
512 set_bit(EVENT_RX_STALL, &acm->flags);
513 stalled = true;
514 break;
515 case -ENOENT:
516 case -ECONNRESET:
517 case -ESHUTDOWN:
518 dev_dbg(&acm->data->dev,
519 "%s - urb shutting down with status: %d\n",
520 __func__, status);
521 stopped = true;
522 break;
523 case -EOVERFLOW:
524 case -EPROTO:
525 dev_dbg(&acm->data->dev,
526 "%s - cooling babbling device\n", __func__);
527 usb_mark_last_busy(acm->dev);
528 set_bit(rb->index, &acm->urbs_in_error_delay);
529 set_bit(ACM_ERROR_DELAY, &acm->flags);
530 cooldown = true;
531 break;
532 default:
533 dev_dbg(&acm->data->dev,
534 "%s - nonzero urb status received: %d\n",
535 __func__, status);
536 break;
537 }
538
539 /*
540 * Make sure URB processing is done before marking as free to avoid
541 * racing with unthrottle() on another CPU. Matches the barriers
542 * implied by the test_and_clear_bit() in acm_submit_read_urb().
543 */
544 smp_mb__before_atomic();
545 set_bit(rb->index, &acm->read_urbs_free);
546 /*
547 * Make sure URB is marked as free before checking the throttled flag
548 * to avoid racing with unthrottle() on another CPU. Matches the
549 * smp_mb() in unthrottle().
550 */
551 smp_mb__after_atomic();
552
553 if (stopped || stalled || cooldown) {
554 if (stalled)
555 schedule_delayed_work(&acm->dwork, 0);
556 else if (cooldown)
557 schedule_delayed_work(&acm->dwork, HZ / 2);
558 return;
559 }
560
561 if (test_bit(ACM_THROTTLED, &acm->flags))
562 return;
563
564 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
565}
566
567/* data interface wrote those outgoing bytes */
568static void acm_write_bulk(struct urb *urb)
569{
570 struct acm_wb *wb = urb->context;
571 struct acm *acm = wb->instance;
572 unsigned long flags;
573 int status = urb->status;
574
575 if (status || (urb->actual_length != urb->transfer_buffer_length))
576 dev_vdbg(&acm->data->dev, "wrote len %d/%d, status %d\n",
577 urb->actual_length,
578 urb->transfer_buffer_length,
579 status);
580
581 spin_lock_irqsave(&acm->write_lock, flags);
582 acm_write_done(acm, wb);
583 spin_unlock_irqrestore(&acm->write_lock, flags);
584 set_bit(EVENT_TTY_WAKEUP, &acm->flags);
585 schedule_delayed_work(&acm->dwork, 0);
586}
587
588static void acm_softint(struct work_struct *work)
589{
590 int i;
591 struct acm *acm = container_of(work, struct acm, dwork.work);
592
593 if (test_bit(EVENT_RX_STALL, &acm->flags)) {
594 smp_mb(); /* against acm_suspend() */
595 if (!acm->susp_count) {
596 for (i = 0; i < acm->rx_buflimit; i++)
597 usb_kill_urb(acm->read_urbs[i]);
598 usb_clear_halt(acm->dev, acm->in);
599 acm_submit_read_urbs(acm, GFP_KERNEL);
600 clear_bit(EVENT_RX_STALL, &acm->flags);
601 }
602 }
603
604 if (test_and_clear_bit(ACM_ERROR_DELAY, &acm->flags)) {
605 for (i = 0; i < acm->rx_buflimit; i++)
606 if (test_and_clear_bit(i, &acm->urbs_in_error_delay))
607 acm_submit_read_urb(acm, i, GFP_KERNEL);
608 }
609
610 if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
611 tty_port_tty_wakeup(&acm->port);
612}
613
614/*
615 * TTY handlers
616 */
617
618static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
619{
620 struct acm *acm;
621 int retval;
622
623 acm = acm_get_by_minor(tty->index);
624 if (!acm)
625 return -ENODEV;
626
627 retval = tty_standard_install(driver, tty);
628 if (retval)
629 goto error_init_termios;
630
631 /*
632 * Suppress initial echoing for some devices which might send data
633 * immediately after acm driver has been installed.
634 */
635 if (acm->quirks & DISABLE_ECHO)
636 tty->termios.c_lflag &= ~ECHO;
637
638 tty->driver_data = acm;
639
640 return 0;
641
642error_init_termios:
643 tty_port_put(&acm->port);
644 return retval;
645}
646
647static int acm_tty_open(struct tty_struct *tty, struct file *filp)
648{
649 struct acm *acm = tty->driver_data;
650
651 return tty_port_open(&acm->port, tty, filp);
652}
653
654static void acm_port_dtr_rts(struct tty_port *port, int raise)
655{
656 struct acm *acm = container_of(port, struct acm, port);
657 int val;
658 int res;
659
660 if (raise)
661 val = USB_CDC_CTRL_DTR | USB_CDC_CTRL_RTS;
662 else
663 val = 0;
664
665 /* FIXME: add missing ctrlout locking throughout driver */
666 acm->ctrlout = val;
667
668 res = acm_set_control(acm, val);
669 if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
670 /* This is broken in too many devices to spam the logs */
671 dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
672}
673
674static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
675{
676 struct acm *acm = container_of(port, struct acm, port);
677 int retval = -ENODEV;
678 int i;
679
680 mutex_lock(&acm->mutex);
681 if (acm->disconnected)
682 goto disconnected;
683
684 retval = usb_autopm_get_interface(acm->control);
685 if (retval)
686 goto error_get_interface;
687
688 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
689 acm->control->needs_remote_wakeup = 1;
690
691 acm->ctrlurb->dev = acm->dev;
692 retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
693 if (retval) {
694 dev_err(&acm->control->dev,
695 "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
696 goto error_submit_urb;
697 }
698
699 acm_tty_set_termios(tty, NULL);
700
701 /*
702 * Unthrottle device in case the TTY was closed while throttled.
703 */
704 clear_bit(ACM_THROTTLED, &acm->flags);
705
706 retval = acm_submit_read_urbs(acm, GFP_KERNEL);
707 if (retval)
708 goto error_submit_read_urbs;
709
710 usb_autopm_put_interface(acm->control);
711
712 mutex_unlock(&acm->mutex);
713
714 return 0;
715
716error_submit_read_urbs:
717 for (i = 0; i < acm->rx_buflimit; i++)
718 usb_kill_urb(acm->read_urbs[i]);
719 usb_kill_urb(acm->ctrlurb);
720error_submit_urb:
721 usb_autopm_put_interface(acm->control);
722error_get_interface:
723disconnected:
724 mutex_unlock(&acm->mutex);
725
726 return usb_translate_errors(retval);
727}
728
729static void acm_port_destruct(struct tty_port *port)
730{
731 struct acm *acm = container_of(port, struct acm, port);
732
733 if (acm->minor != ACM_MINOR_INVALID)
734 acm_release_minor(acm);
735 usb_put_intf(acm->control);
736 kfree(acm->country_codes);
737 kfree(acm);
738}
739
740static void acm_port_shutdown(struct tty_port *port)
741{
742 struct acm *acm = container_of(port, struct acm, port);
743 struct urb *urb;
744 struct acm_wb *wb;
745
746 /*
747 * Need to grab write_lock to prevent race with resume, but no need to
748 * hold it due to the tty-port initialised flag.
749 */
750 acm_poison_urbs(acm);
751 spin_lock_irq(&acm->write_lock);
752 spin_unlock_irq(&acm->write_lock);
753
754 usb_autopm_get_interface_no_resume(acm->control);
755 acm->control->needs_remote_wakeup = 0;
756 usb_autopm_put_interface(acm->control);
757
758 for (;;) {
759 urb = usb_get_from_anchor(&acm->delayed);
760 if (!urb)
761 break;
762 wb = urb->context;
763 wb->use = false;
764 usb_autopm_put_interface_async(acm->control);
765 }
766
767 acm_unpoison_urbs(acm);
768
769}
770
771static void acm_tty_cleanup(struct tty_struct *tty)
772{
773 struct acm *acm = tty->driver_data;
774
775 tty_port_put(&acm->port);
776}
777
778static void acm_tty_hangup(struct tty_struct *tty)
779{
780 struct acm *acm = tty->driver_data;
781
782 tty_port_hangup(&acm->port);
783}
784
785static void acm_tty_close(struct tty_struct *tty, struct file *filp)
786{
787 struct acm *acm = tty->driver_data;
788
789 tty_port_close(&acm->port, tty, filp);
790}
791
792static int acm_tty_write(struct tty_struct *tty,
793 const unsigned char *buf, int count)
794{
795 struct acm *acm = tty->driver_data;
796 int stat;
797 unsigned long flags;
798 int wbn;
799 struct acm_wb *wb;
800
801 if (!count)
802 return 0;
803
804 dev_vdbg(&acm->data->dev, "%d bytes from tty layer\n", count);
805
806 spin_lock_irqsave(&acm->write_lock, flags);
807 wbn = acm_wb_alloc(acm);
808 if (wbn < 0) {
809 spin_unlock_irqrestore(&acm->write_lock, flags);
810 return 0;
811 }
812 wb = &acm->wb[wbn];
813
814 if (!acm->dev) {
815 wb->use = false;
816 spin_unlock_irqrestore(&acm->write_lock, flags);
817 return -ENODEV;
818 }
819
820 count = (count > acm->writesize) ? acm->writesize : count;
821 dev_vdbg(&acm->data->dev, "writing %d bytes\n", count);
822 memcpy(wb->buf, buf, count);
823 wb->len = count;
824
825 stat = usb_autopm_get_interface_async(acm->control);
826 if (stat) {
827 wb->use = false;
828 spin_unlock_irqrestore(&acm->write_lock, flags);
829 return stat;
830 }
831
832 if (acm->susp_count) {
833 usb_anchor_urb(wb->urb, &acm->delayed);
834 spin_unlock_irqrestore(&acm->write_lock, flags);
835 return count;
836 }
837
838 stat = acm_start_wb(acm, wb);
839 spin_unlock_irqrestore(&acm->write_lock, flags);
840
841 if (stat < 0)
842 return stat;
843 return count;
844}
845
846static unsigned int acm_tty_write_room(struct tty_struct *tty)
847{
848 struct acm *acm = tty->driver_data;
849 /*
850 * Do not let the line discipline to know that we have a reserve,
851 * or it might get too enthusiastic.
852 */
853 return acm_wb_is_avail(acm) ? acm->writesize : 0;
854}
855
856static unsigned int acm_tty_chars_in_buffer(struct tty_struct *tty)
857{
858 struct acm *acm = tty->driver_data;
859 /*
860 * if the device was unplugged then any remaining characters fell out
861 * of the connector ;)
862 */
863 if (acm->disconnected)
864 return 0;
865 /*
866 * This is inaccurate (overcounts), but it works.
867 */
868 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
869}
870
871static void acm_tty_throttle(struct tty_struct *tty)
872{
873 struct acm *acm = tty->driver_data;
874
875 set_bit(ACM_THROTTLED, &acm->flags);
876}
877
878static void acm_tty_unthrottle(struct tty_struct *tty)
879{
880 struct acm *acm = tty->driver_data;
881
882 clear_bit(ACM_THROTTLED, &acm->flags);
883
884 /* Matches the smp_mb__after_atomic() in acm_read_bulk_callback(). */
885 smp_mb();
886
887 acm_submit_read_urbs(acm, GFP_KERNEL);
888}
889
890static int acm_tty_break_ctl(struct tty_struct *tty, int state)
891{
892 struct acm *acm = tty->driver_data;
893 int retval;
894
895 retval = acm_send_break(acm, state ? 0xffff : 0);
896 if (retval < 0)
897 dev_dbg(&acm->control->dev,
898 "%s - send break failed\n", __func__);
899 return retval;
900}
901
902static int acm_tty_tiocmget(struct tty_struct *tty)
903{
904 struct acm *acm = tty->driver_data;
905
906 return (acm->ctrlout & USB_CDC_CTRL_DTR ? TIOCM_DTR : 0) |
907 (acm->ctrlout & USB_CDC_CTRL_RTS ? TIOCM_RTS : 0) |
908 (acm->ctrlin & USB_CDC_SERIAL_STATE_DSR ? TIOCM_DSR : 0) |
909 (acm->ctrlin & USB_CDC_SERIAL_STATE_RING_SIGNAL ? TIOCM_RI : 0) |
910 (acm->ctrlin & USB_CDC_SERIAL_STATE_DCD ? TIOCM_CD : 0) |
911 TIOCM_CTS;
912}
913
914static int acm_tty_tiocmset(struct tty_struct *tty,
915 unsigned int set, unsigned int clear)
916{
917 struct acm *acm = tty->driver_data;
918 unsigned int newctrl;
919
920 newctrl = acm->ctrlout;
921 set = (set & TIOCM_DTR ? USB_CDC_CTRL_DTR : 0) |
922 (set & TIOCM_RTS ? USB_CDC_CTRL_RTS : 0);
923 clear = (clear & TIOCM_DTR ? USB_CDC_CTRL_DTR : 0) |
924 (clear & TIOCM_RTS ? USB_CDC_CTRL_RTS : 0);
925
926 newctrl = (newctrl & ~clear) | set;
927
928 if (acm->ctrlout == newctrl)
929 return 0;
930 return acm_set_control(acm, acm->ctrlout = newctrl);
931}
932
933static int get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
934{
935 struct acm *acm = tty->driver_data;
936
937 ss->line = acm->minor;
938 ss->close_delay = jiffies_to_msecs(acm->port.close_delay) / 10;
939 ss->closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
940 ASYNC_CLOSING_WAIT_NONE :
941 jiffies_to_msecs(acm->port.closing_wait) / 10;
942 return 0;
943}
944
945static int set_serial_info(struct tty_struct *tty, struct serial_struct *ss)
946{
947 struct acm *acm = tty->driver_data;
948 unsigned int closing_wait, close_delay;
949 int retval = 0;
950
951 close_delay = msecs_to_jiffies(ss->close_delay * 10);
952 closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
953 ASYNC_CLOSING_WAIT_NONE :
954 msecs_to_jiffies(ss->closing_wait * 10);
955
956 mutex_lock(&acm->port.mutex);
957
958 if (!capable(CAP_SYS_ADMIN)) {
959 if ((close_delay != acm->port.close_delay) ||
960 (closing_wait != acm->port.closing_wait))
961 retval = -EPERM;
962 } else {
963 acm->port.close_delay = close_delay;
964 acm->port.closing_wait = closing_wait;
965 }
966
967 mutex_unlock(&acm->port.mutex);
968 return retval;
969}
970
971static int wait_serial_change(struct acm *acm, unsigned long arg)
972{
973 int rv = 0;
974 DECLARE_WAITQUEUE(wait, current);
975 struct async_icount old, new;
976
977 do {
978 spin_lock_irq(&acm->read_lock);
979 old = acm->oldcount;
980 new = acm->iocount;
981 acm->oldcount = new;
982 spin_unlock_irq(&acm->read_lock);
983
984 if ((arg & TIOCM_DSR) &&
985 old.dsr != new.dsr)
986 break;
987 if ((arg & TIOCM_CD) &&
988 old.dcd != new.dcd)
989 break;
990 if ((arg & TIOCM_RI) &&
991 old.rng != new.rng)
992 break;
993
994 add_wait_queue(&acm->wioctl, &wait);
995 set_current_state(TASK_INTERRUPTIBLE);
996 schedule();
997 remove_wait_queue(&acm->wioctl, &wait);
998 if (acm->disconnected) {
999 if (arg & TIOCM_CD)
1000 break;
1001 else
1002 rv = -ENODEV;
1003 } else {
1004 if (signal_pending(current))
1005 rv = -ERESTARTSYS;
1006 }
1007 } while (!rv);
1008
1009
1010
1011 return rv;
1012}
1013
1014static int acm_tty_get_icount(struct tty_struct *tty,
1015 struct serial_icounter_struct *icount)
1016{
1017 struct acm *acm = tty->driver_data;
1018
1019 icount->dsr = acm->iocount.dsr;
1020 icount->rng = acm->iocount.rng;
1021 icount->dcd = acm->iocount.dcd;
1022 icount->frame = acm->iocount.frame;
1023 icount->overrun = acm->iocount.overrun;
1024 icount->parity = acm->iocount.parity;
1025 icount->brk = acm->iocount.brk;
1026
1027 return 0;
1028}
1029
1030static int acm_tty_ioctl(struct tty_struct *tty,
1031 unsigned int cmd, unsigned long arg)
1032{
1033 struct acm *acm = tty->driver_data;
1034 int rv = -ENOIOCTLCMD;
1035
1036 switch (cmd) {
1037 case TIOCMIWAIT:
1038 rv = usb_autopm_get_interface(acm->control);
1039 if (rv < 0) {
1040 rv = -EIO;
1041 break;
1042 }
1043 rv = wait_serial_change(acm, arg);
1044 usb_autopm_put_interface(acm->control);
1045 break;
1046 }
1047
1048 return rv;
1049}
1050
1051static void acm_tty_set_termios(struct tty_struct *tty,
1052 const struct ktermios *termios_old)
1053{
1054 struct acm *acm = tty->driver_data;
1055 struct ktermios *termios = &tty->termios;
1056 struct usb_cdc_line_coding newline;
1057 int newctrl = acm->ctrlout;
1058
1059 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
1060 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
1061 newline.bParityType = termios->c_cflag & PARENB ?
1062 (termios->c_cflag & PARODD ? 1 : 2) +
1063 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
1064 newline.bDataBits = tty_get_char_size(termios->c_cflag);
1065
1066 /* FIXME: Needs to clear unsupported bits in the termios */
1067 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
1068
1069 if (C_BAUD(tty) == B0) {
1070 newline.dwDTERate = acm->line.dwDTERate;
1071 newctrl &= ~USB_CDC_CTRL_DTR;
1072 } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
1073 newctrl |= USB_CDC_CTRL_DTR;
1074 }
1075
1076 if (newctrl != acm->ctrlout)
1077 acm_set_control(acm, acm->ctrlout = newctrl);
1078
1079 if (memcmp(&acm->line, &newline, sizeof newline)) {
1080 memcpy(&acm->line, &newline, sizeof newline);
1081 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
1082 __func__,
1083 le32_to_cpu(newline.dwDTERate),
1084 newline.bCharFormat, newline.bParityType,
1085 newline.bDataBits);
1086 acm_set_line(acm, &acm->line);
1087 }
1088}
1089
1090static const struct tty_port_operations acm_port_ops = {
1091 .dtr_rts = acm_port_dtr_rts,
1092 .shutdown = acm_port_shutdown,
1093 .activate = acm_port_activate,
1094 .destruct = acm_port_destruct,
1095};
1096
1097/*
1098 * USB probe and disconnect routines.
1099 */
1100
1101/* Little helpers: write/read buffers free */
1102static void acm_write_buffers_free(struct acm *acm)
1103{
1104 int i;
1105 struct acm_wb *wb;
1106
1107 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
1108 usb_free_coherent(acm->dev, acm->writesize, wb->buf, wb->dmah);
1109}
1110
1111static void acm_read_buffers_free(struct acm *acm)
1112{
1113 int i;
1114
1115 for (i = 0; i < acm->rx_buflimit; i++)
1116 usb_free_coherent(acm->dev, acm->readsize,
1117 acm->read_buffers[i].base, acm->read_buffers[i].dma);
1118}
1119
1120/* Little helper: write buffers allocate */
1121static int acm_write_buffers_alloc(struct acm *acm)
1122{
1123 int i;
1124 struct acm_wb *wb;
1125
1126 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
1127 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
1128 &wb->dmah);
1129 if (!wb->buf) {
1130 while (i != 0) {
1131 --i;
1132 --wb;
1133 usb_free_coherent(acm->dev, acm->writesize,
1134 wb->buf, wb->dmah);
1135 }
1136 return -ENOMEM;
1137 }
1138 }
1139 return 0;
1140}
1141
1142static int acm_probe(struct usb_interface *intf,
1143 const struct usb_device_id *id)
1144{
1145 struct usb_cdc_union_desc *union_header = NULL;
1146 struct usb_cdc_call_mgmt_descriptor *cmgmd = NULL;
1147 unsigned char *buffer = intf->altsetting->extra;
1148 int buflen = intf->altsetting->extralen;
1149 struct usb_interface *control_interface;
1150 struct usb_interface *data_interface;
1151 struct usb_endpoint_descriptor *epctrl = NULL;
1152 struct usb_endpoint_descriptor *epread = NULL;
1153 struct usb_endpoint_descriptor *epwrite = NULL;
1154 struct usb_device *usb_dev = interface_to_usbdev(intf);
1155 struct usb_cdc_parsed_header h;
1156 struct acm *acm;
1157 int minor;
1158 int ctrlsize, readsize;
1159 u8 *buf;
1160 int call_intf_num = -1;
1161 int data_intf_num = -1;
1162 unsigned long quirks;
1163 int num_rx_buf;
1164 int i;
1165 int combined_interfaces = 0;
1166 struct device *tty_dev;
1167 int rv = -ENOMEM;
1168 int res;
1169
1170 /* normal quirks */
1171 quirks = (unsigned long)id->driver_info;
1172
1173 if (quirks == IGNORE_DEVICE)
1174 return -ENODEV;
1175
1176 memset(&h, 0x00, sizeof(struct usb_cdc_parsed_header));
1177
1178 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
1179
1180 /* handle quirks deadly to normal probing*/
1181 if (quirks == NO_UNION_NORMAL) {
1182 data_interface = usb_ifnum_to_if(usb_dev, 1);
1183 control_interface = usb_ifnum_to_if(usb_dev, 0);
1184 /* we would crash */
1185 if (!data_interface || !control_interface)
1186 return -ENODEV;
1187 goto skip_normal_probe;
1188 }
1189
1190 /* normal probing*/
1191 if (!buffer) {
1192 dev_err(&intf->dev, "Weird descriptor references\n");
1193 return -EINVAL;
1194 }
1195
1196 if (!buflen) {
1197 if (intf->cur_altsetting->endpoint &&
1198 intf->cur_altsetting->endpoint->extralen &&
1199 intf->cur_altsetting->endpoint->extra) {
1200 dev_dbg(&intf->dev,
1201 "Seeking extra descriptors on endpoint\n");
1202 buflen = intf->cur_altsetting->endpoint->extralen;
1203 buffer = intf->cur_altsetting->endpoint->extra;
1204 } else {
1205 dev_err(&intf->dev,
1206 "Zero length descriptor references\n");
1207 return -EINVAL;
1208 }
1209 }
1210
1211 cdc_parse_cdc_header(&h, intf, buffer, buflen);
1212 union_header = h.usb_cdc_union_desc;
1213 cmgmd = h.usb_cdc_call_mgmt_descriptor;
1214 if (cmgmd)
1215 call_intf_num = cmgmd->bDataInterface;
1216
1217 if (!union_header) {
1218 if (intf->cur_altsetting->desc.bNumEndpoints == 3) {
1219 dev_dbg(&intf->dev, "No union descriptor, assuming single interface\n");
1220 combined_interfaces = 1;
1221 control_interface = data_interface = intf;
1222 goto look_for_collapsed_interface;
1223 } else if (call_intf_num > 0) {
1224 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1225 data_intf_num = call_intf_num;
1226 data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
1227 control_interface = intf;
1228 } else {
1229 dev_dbg(&intf->dev, "No union descriptor, giving up\n");
1230 return -ENODEV;
1231 }
1232 } else {
1233 int class = -1;
1234
1235 data_intf_num = union_header->bSlaveInterface0;
1236 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1237 data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
1238
1239 if (control_interface)
1240 class = control_interface->cur_altsetting->desc.bInterfaceClass;
1241
1242 if (class != USB_CLASS_COMM && class != USB_CLASS_CDC_DATA) {
1243 dev_dbg(&intf->dev, "Broken union descriptor, assuming single interface\n");
1244 combined_interfaces = 1;
1245 control_interface = data_interface = intf;
1246 goto look_for_collapsed_interface;
1247 }
1248 }
1249
1250 if (!control_interface || !data_interface) {
1251 dev_dbg(&intf->dev, "no interfaces\n");
1252 return -ENODEV;
1253 }
1254
1255 if (data_intf_num != call_intf_num)
1256 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1257
1258 if (control_interface == data_interface) {
1259 /* some broken devices designed for windows work this way */
1260 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1261 combined_interfaces = 1;
1262 /* a popular other OS doesn't use it */
1263 quirks |= NO_CAP_LINE;
1264 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1265 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1266 return -EINVAL;
1267 }
1268look_for_collapsed_interface:
1269 res = usb_find_common_endpoints(data_interface->cur_altsetting,
1270 &epread, &epwrite, &epctrl, NULL);
1271 if (res)
1272 return res;
1273
1274 goto made_compressed_probe;
1275 }
1276
1277skip_normal_probe:
1278
1279 /*workaround for switched interfaces */
1280 if (data_interface->cur_altsetting->desc.bInterfaceClass != USB_CLASS_CDC_DATA) {
1281 if (control_interface->cur_altsetting->desc.bInterfaceClass == USB_CLASS_CDC_DATA) {
1282 dev_dbg(&intf->dev,
1283 "Your device has switched interfaces.\n");
1284 swap(control_interface, data_interface);
1285 } else {
1286 return -EINVAL;
1287 }
1288 }
1289
1290 /* Accept probe requests only for the control interface */
1291 if (!combined_interfaces && intf != control_interface)
1292 return -ENODEV;
1293
1294 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1295 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1296 return -EINVAL;
1297
1298 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1299 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1300 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1301
1302
1303 /* workaround for switched endpoints */
1304 if (!usb_endpoint_dir_in(epread)) {
1305 /* descriptors are swapped */
1306 dev_dbg(&intf->dev,
1307 "The data interface has switched endpoints\n");
1308 swap(epread, epwrite);
1309 }
1310made_compressed_probe:
1311 dev_dbg(&intf->dev, "interfaces are valid\n");
1312
1313 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1314 if (!acm)
1315 return -ENOMEM;
1316
1317 tty_port_init(&acm->port);
1318 acm->port.ops = &acm_port_ops;
1319
1320 ctrlsize = usb_endpoint_maxp(epctrl);
1321 readsize = usb_endpoint_maxp(epread) *
1322 (quirks == SINGLE_RX_URB ? 1 : 2);
1323 acm->combined_interfaces = combined_interfaces;
1324 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1325 acm->control = control_interface;
1326 acm->data = data_interface;
1327
1328 usb_get_intf(acm->control); /* undone in destruct() */
1329
1330 minor = acm_alloc_minor(acm);
1331 if (minor < 0) {
1332 acm->minor = ACM_MINOR_INVALID;
1333 goto err_put_port;
1334 }
1335
1336 acm->minor = minor;
1337 acm->dev = usb_dev;
1338 if (h.usb_cdc_acm_descriptor)
1339 acm->ctrl_caps = h.usb_cdc_acm_descriptor->bmCapabilities;
1340 if (quirks & NO_CAP_LINE)
1341 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1342 acm->ctrlsize = ctrlsize;
1343 acm->readsize = readsize;
1344 acm->rx_buflimit = num_rx_buf;
1345 INIT_DELAYED_WORK(&acm->dwork, acm_softint);
1346 init_waitqueue_head(&acm->wioctl);
1347 spin_lock_init(&acm->write_lock);
1348 spin_lock_init(&acm->read_lock);
1349 mutex_init(&acm->mutex);
1350 if (usb_endpoint_xfer_int(epread)) {
1351 acm->bInterval = epread->bInterval;
1352 acm->in = usb_rcvintpipe(usb_dev, epread->bEndpointAddress);
1353 } else {
1354 acm->in = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1355 }
1356 if (usb_endpoint_xfer_int(epwrite))
1357 acm->out = usb_sndintpipe(usb_dev, epwrite->bEndpointAddress);
1358 else
1359 acm->out = usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress);
1360 init_usb_anchor(&acm->delayed);
1361 acm->quirks = quirks;
1362
1363 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1364 if (!buf)
1365 goto err_put_port;
1366 acm->ctrl_buffer = buf;
1367
1368 if (acm_write_buffers_alloc(acm) < 0)
1369 goto err_free_ctrl_buffer;
1370
1371 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1372 if (!acm->ctrlurb)
1373 goto err_free_write_buffers;
1374
1375 for (i = 0; i < num_rx_buf; i++) {
1376 struct acm_rb *rb = &(acm->read_buffers[i]);
1377 struct urb *urb;
1378
1379 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1380 &rb->dma);
1381 if (!rb->base)
1382 goto err_free_read_urbs;
1383 rb->index = i;
1384 rb->instance = acm;
1385
1386 urb = usb_alloc_urb(0, GFP_KERNEL);
1387 if (!urb)
1388 goto err_free_read_urbs;
1389
1390 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1391 urb->transfer_dma = rb->dma;
1392 if (usb_endpoint_xfer_int(epread))
1393 usb_fill_int_urb(urb, acm->dev, acm->in, rb->base,
1394 acm->readsize,
1395 acm_read_bulk_callback, rb,
1396 acm->bInterval);
1397 else
1398 usb_fill_bulk_urb(urb, acm->dev, acm->in, rb->base,
1399 acm->readsize,
1400 acm_read_bulk_callback, rb);
1401
1402 acm->read_urbs[i] = urb;
1403 __set_bit(i, &acm->read_urbs_free);
1404 }
1405 for (i = 0; i < ACM_NW; i++) {
1406 struct acm_wb *snd = &(acm->wb[i]);
1407
1408 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1409 if (!snd->urb)
1410 goto err_free_write_urbs;
1411
1412 if (usb_endpoint_xfer_int(epwrite))
1413 usb_fill_int_urb(snd->urb, usb_dev, acm->out,
1414 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1415 else
1416 usb_fill_bulk_urb(snd->urb, usb_dev, acm->out,
1417 NULL, acm->writesize, acm_write_bulk, snd);
1418 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1419 if (quirks & SEND_ZERO_PACKET)
1420 snd->urb->transfer_flags |= URB_ZERO_PACKET;
1421 snd->instance = acm;
1422 }
1423
1424 usb_set_intfdata(intf, acm);
1425
1426 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1427 if (i < 0)
1428 goto err_free_write_urbs;
1429
1430 if (h.usb_cdc_country_functional_desc) { /* export the country data */
1431 struct usb_cdc_country_functional_desc * cfd =
1432 h.usb_cdc_country_functional_desc;
1433
1434 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1435 if (!acm->country_codes)
1436 goto skip_countries;
1437 acm->country_code_size = cfd->bLength - 4;
1438 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1439 cfd->bLength - 4);
1440 acm->country_rel_date = cfd->iCountryCodeRelDate;
1441
1442 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1443 if (i < 0) {
1444 kfree(acm->country_codes);
1445 acm->country_codes = NULL;
1446 acm->country_code_size = 0;
1447 goto skip_countries;
1448 }
1449
1450 i = device_create_file(&intf->dev,
1451 &dev_attr_iCountryCodeRelDate);
1452 if (i < 0) {
1453 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1454 kfree(acm->country_codes);
1455 acm->country_codes = NULL;
1456 acm->country_code_size = 0;
1457 goto skip_countries;
1458 }
1459 }
1460
1461skip_countries:
1462 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1463 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1464 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1465 /* works around buggy devices */
1466 epctrl->bInterval ? epctrl->bInterval : 16);
1467 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1468 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1469 acm->notification_buffer = NULL;
1470 acm->nb_index = 0;
1471 acm->nb_size = 0;
1472
1473 acm->line.dwDTERate = cpu_to_le32(9600);
1474 acm->line.bDataBits = 8;
1475 acm_set_line(acm, &acm->line);
1476
1477 if (!acm->combined_interfaces) {
1478 rv = usb_driver_claim_interface(&acm_driver, data_interface, acm);
1479 if (rv)
1480 goto err_remove_files;
1481 }
1482
1483 tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1484 &control_interface->dev);
1485 if (IS_ERR(tty_dev)) {
1486 rv = PTR_ERR(tty_dev);
1487 goto err_release_data_interface;
1488 }
1489
1490 if (quirks & CLEAR_HALT_CONDITIONS) {
1491 usb_clear_halt(usb_dev, acm->in);
1492 usb_clear_halt(usb_dev, acm->out);
1493 }
1494
1495 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1496
1497 return 0;
1498
1499err_release_data_interface:
1500 if (!acm->combined_interfaces) {
1501 /* Clear driver data so that disconnect() returns early. */
1502 usb_set_intfdata(data_interface, NULL);
1503 usb_driver_release_interface(&acm_driver, data_interface);
1504 }
1505err_remove_files:
1506 if (acm->country_codes) {
1507 device_remove_file(&acm->control->dev,
1508 &dev_attr_wCountryCodes);
1509 device_remove_file(&acm->control->dev,
1510 &dev_attr_iCountryCodeRelDate);
1511 }
1512 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1513err_free_write_urbs:
1514 for (i = 0; i < ACM_NW; i++)
1515 usb_free_urb(acm->wb[i].urb);
1516err_free_read_urbs:
1517 for (i = 0; i < num_rx_buf; i++)
1518 usb_free_urb(acm->read_urbs[i]);
1519 acm_read_buffers_free(acm);
1520 usb_free_urb(acm->ctrlurb);
1521err_free_write_buffers:
1522 acm_write_buffers_free(acm);
1523err_free_ctrl_buffer:
1524 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1525err_put_port:
1526 tty_port_put(&acm->port);
1527
1528 return rv;
1529}
1530
1531static void acm_disconnect(struct usb_interface *intf)
1532{
1533 struct acm *acm = usb_get_intfdata(intf);
1534 struct tty_struct *tty;
1535 int i;
1536
1537 /* sibling interface is already cleaning up */
1538 if (!acm)
1539 return;
1540
1541 acm->disconnected = true;
1542 /*
1543 * there is a circular dependency. acm_softint() can resubmit
1544 * the URBs in error handling so we need to block any
1545 * submission right away
1546 */
1547 acm_poison_urbs(acm);
1548 mutex_lock(&acm->mutex);
1549 if (acm->country_codes) {
1550 device_remove_file(&acm->control->dev,
1551 &dev_attr_wCountryCodes);
1552 device_remove_file(&acm->control->dev,
1553 &dev_attr_iCountryCodeRelDate);
1554 }
1555 wake_up_all(&acm->wioctl);
1556 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1557 usb_set_intfdata(acm->control, NULL);
1558 usb_set_intfdata(acm->data, NULL);
1559 mutex_unlock(&acm->mutex);
1560
1561 tty = tty_port_tty_get(&acm->port);
1562 if (tty) {
1563 tty_vhangup(tty);
1564 tty_kref_put(tty);
1565 }
1566
1567 cancel_delayed_work_sync(&acm->dwork);
1568
1569 tty_unregister_device(acm_tty_driver, acm->minor);
1570
1571 usb_free_urb(acm->ctrlurb);
1572 for (i = 0; i < ACM_NW; i++)
1573 usb_free_urb(acm->wb[i].urb);
1574 for (i = 0; i < acm->rx_buflimit; i++)
1575 usb_free_urb(acm->read_urbs[i]);
1576 acm_write_buffers_free(acm);
1577 usb_free_coherent(acm->dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1578 acm_read_buffers_free(acm);
1579
1580 kfree(acm->notification_buffer);
1581
1582 if (!acm->combined_interfaces)
1583 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1584 acm->data : acm->control);
1585
1586 tty_port_put(&acm->port);
1587}
1588
1589#ifdef CONFIG_PM
1590static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1591{
1592 struct acm *acm = usb_get_intfdata(intf);
1593 int cnt;
1594
1595 spin_lock_irq(&acm->write_lock);
1596 if (PMSG_IS_AUTO(message)) {
1597 if (acm->transmitting) {
1598 spin_unlock_irq(&acm->write_lock);
1599 return -EBUSY;
1600 }
1601 }
1602 cnt = acm->susp_count++;
1603 spin_unlock_irq(&acm->write_lock);
1604
1605 if (cnt)
1606 return 0;
1607
1608 acm_poison_urbs(acm);
1609 cancel_delayed_work_sync(&acm->dwork);
1610 acm->urbs_in_error_delay = 0;
1611
1612 return 0;
1613}
1614
1615static int acm_resume(struct usb_interface *intf)
1616{
1617 struct acm *acm = usb_get_intfdata(intf);
1618 struct urb *urb;
1619 int rv = 0;
1620
1621 spin_lock_irq(&acm->write_lock);
1622
1623 if (--acm->susp_count)
1624 goto out;
1625
1626 acm_unpoison_urbs(acm);
1627
1628 if (tty_port_initialized(&acm->port)) {
1629 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1630
1631 for (;;) {
1632 urb = usb_get_from_anchor(&acm->delayed);
1633 if (!urb)
1634 break;
1635
1636 acm_start_wb(acm, urb->context);
1637 }
1638
1639 /*
1640 * delayed error checking because we must
1641 * do the write path at all cost
1642 */
1643 if (rv < 0)
1644 goto out;
1645
1646 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1647 }
1648out:
1649 spin_unlock_irq(&acm->write_lock);
1650
1651 return rv;
1652}
1653
1654static int acm_reset_resume(struct usb_interface *intf)
1655{
1656 struct acm *acm = usb_get_intfdata(intf);
1657
1658 if (tty_port_initialized(&acm->port))
1659 tty_port_tty_hangup(&acm->port, false);
1660
1661 return acm_resume(intf);
1662}
1663
1664#endif /* CONFIG_PM */
1665
1666static int acm_pre_reset(struct usb_interface *intf)
1667{
1668 struct acm *acm = usb_get_intfdata(intf);
1669
1670 clear_bit(EVENT_RX_STALL, &acm->flags);
1671 acm->nb_index = 0; /* pending control transfers are lost */
1672
1673 return 0;
1674}
1675
1676#define NOKIA_PCSUITE_ACM_INFO(x) \
1677 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1678 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1679 USB_CDC_ACM_PROTO_VENDOR)
1680
1681#define SAMSUNG_PCSUITE_ACM_INFO(x) \
1682 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1683 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1684 USB_CDC_ACM_PROTO_VENDOR)
1685
1686/*
1687 * USB driver structure.
1688 */
1689
1690static const struct usb_device_id acm_ids[] = {
1691 /* quirky and broken devices */
1692 { USB_DEVICE(0x0424, 0x274e), /* Microchip Technology, Inc. (formerly SMSC) */
1693 .driver_info = DISABLE_ECHO, }, /* DISABLE ECHO in termios flag */
1694 { USB_DEVICE(0x076d, 0x0006), /* Denso Cradle CU-321 */
1695 .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1696 { USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1697 .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1698 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1699 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1700 },
1701 { USB_DEVICE(0x045b, 0x023c), /* Renesas USB Download mode */
1702 .driver_info = DISABLE_ECHO, /* Don't echo banner */
1703 },
1704 { USB_DEVICE(0x045b, 0x0248), /* Renesas USB Download mode */
1705 .driver_info = DISABLE_ECHO, /* Don't echo banner */
1706 },
1707 { USB_DEVICE(0x045b, 0x024D), /* Renesas USB Download mode */
1708 .driver_info = DISABLE_ECHO, /* Don't echo banner */
1709 },
1710 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1711 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1712 },
1713 { USB_DEVICE(0x0e8d, 0x2000), /* MediaTek Inc Preloader */
1714 .driver_info = DISABLE_ECHO, /* DISABLE ECHO in termios flag */
1715 },
1716 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1717 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1718 },
1719 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1720 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1721 },
1722 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1723 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1724 },
1725 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1726 .driver_info = SINGLE_RX_URB,
1727 },
1728 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1729 .driver_info = SINGLE_RX_URB, /* firmware bug */
1730 },
1731 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1732 .driver_info = SINGLE_RX_URB, /* firmware bug */
1733 },
1734 { USB_DEVICE(0x11ca, 0x0201), /* VeriFone Mx870 Gadget Serial */
1735 .driver_info = SINGLE_RX_URB,
1736 },
1737 { USB_DEVICE(0x1965, 0x0018), /* Uniden UBC125XLT */
1738 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1739 },
1740 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1741 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1742 },
1743 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1744 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1745 },
1746 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1747 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1748 },
1749 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1750 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1751 },
1752 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1753 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1754 },
1755 { USB_DEVICE(0x0572, 0x1349), /* Hiro (Conexant) USB MODEM H50228 */
1756 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1757 },
1758 { USB_DEVICE(0x20df, 0x0001), /* Simtec Electronics Entropy Key */
1759 .driver_info = QUIRK_CONTROL_LINE_STATE, },
1760 { USB_DEVICE(0x2184, 0x001c) }, /* GW Instek AFG-2225 */
1761 { USB_DEVICE(0x2184, 0x0036) }, /* GW Instek AFG-125 */
1762 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1763 },
1764 /* Motorola H24 HSPA module: */
1765 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1766 { USB_DEVICE(0x22b8, 0x2d92), /* modem + diagnostics */
1767 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1768 },
1769 { USB_DEVICE(0x22b8, 0x2d93), /* modem + AT port */
1770 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1771 },
1772 { USB_DEVICE(0x22b8, 0x2d95), /* modem + AT port + diagnostics */
1773 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1774 },
1775 { USB_DEVICE(0x22b8, 0x2d96), /* modem + NMEA */
1776 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1777 },
1778 { USB_DEVICE(0x22b8, 0x2d97), /* modem + diagnostics + NMEA */
1779 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1780 },
1781 { USB_DEVICE(0x22b8, 0x2d99), /* modem + AT port + NMEA */
1782 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1783 },
1784 { USB_DEVICE(0x22b8, 0x2d9a), /* modem + AT port + diagnostics + NMEA */
1785 .driver_info = NO_UNION_NORMAL, /* handle only modem interface */
1786 },
1787
1788 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1789 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1790 data interface instead of
1791 communications interface.
1792 Maybe we should define a new
1793 quirk for this. */
1794 },
1795 { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1796 .driver_info = NO_UNION_NORMAL,
1797 },
1798 { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1799 .driver_info = NO_UNION_NORMAL,
1800 },
1801 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1802 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1803 },
1804 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1805 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1806 },
1807 { USB_DEVICE(0xfff0, 0x0100), /* DATECS FP-2000 */
1808 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1809 },
1810 { USB_DEVICE(0x09d8, 0x0320), /* Elatec GmbH TWN3 */
1811 .driver_info = NO_UNION_NORMAL, /* has misplaced union descriptor */
1812 },
1813 { USB_DEVICE(0x0c26, 0x0020), /* Icom ICF3400 Serie */
1814 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1815 },
1816 { USB_DEVICE(0x0ca6, 0xa050), /* Castles VEGA3000 */
1817 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1818 },
1819
1820 { USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */
1821 .driver_info = CLEAR_HALT_CONDITIONS,
1822 },
1823
1824 /* Nokia S60 phones expose two ACM channels. The first is
1825 * a modem and is picked up by the standard AT-command
1826 * information below. The second is 'vendor-specific' but
1827 * is treated as a serial device at the S60 end, so we want
1828 * to expose it on Linux too. */
1829 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1830 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1831 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1832 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1833 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1834 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1835 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1836 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1837 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1838 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1839 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1840 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1841 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1842 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1843 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1844 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1845 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1846 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1847 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1848 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1849 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1850 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1851 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1852 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1853 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1854 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1855 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1856 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1857 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1858 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1859 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1860 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1861 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1862 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1863 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1864 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1865 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1866 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1867 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1868 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1869 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1870 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1871 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1872 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1873 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1874 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1875 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1876 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1877 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1878 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1879 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1880 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1881 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1882 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1883 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1884 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1885 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1886
1887 /* Support for Owen devices */
1888 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1889
1890 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1891
1892#if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1893 { USB_DEVICE(0x04d8, 0x0082), /* Application mode */
1894 .driver_info = IGNORE_DEVICE,
1895 },
1896 { USB_DEVICE(0x04d8, 0x0083), /* Bootloader mode */
1897 .driver_info = IGNORE_DEVICE,
1898 },
1899#endif
1900
1901#if IS_ENABLED(CONFIG_IR_TOY)
1902 { USB_DEVICE(0x04d8, 0xfd08),
1903 .driver_info = IGNORE_DEVICE,
1904 },
1905
1906 { USB_DEVICE(0x04d8, 0xf58b),
1907 .driver_info = IGNORE_DEVICE,
1908 },
1909#endif
1910
1911#if IS_ENABLED(CONFIG_USB_SERIAL_XR)
1912 { USB_DEVICE(0x04e2, 0x1400), .driver_info = IGNORE_DEVICE },
1913 { USB_DEVICE(0x04e2, 0x1401), .driver_info = IGNORE_DEVICE },
1914 { USB_DEVICE(0x04e2, 0x1402), .driver_info = IGNORE_DEVICE },
1915 { USB_DEVICE(0x04e2, 0x1403), .driver_info = IGNORE_DEVICE },
1916 { USB_DEVICE(0x04e2, 0x1410), .driver_info = IGNORE_DEVICE },
1917 { USB_DEVICE(0x04e2, 0x1411), .driver_info = IGNORE_DEVICE },
1918 { USB_DEVICE(0x04e2, 0x1412), .driver_info = IGNORE_DEVICE },
1919 { USB_DEVICE(0x04e2, 0x1414), .driver_info = IGNORE_DEVICE },
1920 { USB_DEVICE(0x04e2, 0x1420), .driver_info = IGNORE_DEVICE },
1921 { USB_DEVICE(0x04e2, 0x1422), .driver_info = IGNORE_DEVICE },
1922 { USB_DEVICE(0x04e2, 0x1424), .driver_info = IGNORE_DEVICE },
1923#endif
1924
1925 /*Samsung phone in firmware update mode */
1926 { USB_DEVICE(0x04e8, 0x685d),
1927 .driver_info = IGNORE_DEVICE,
1928 },
1929
1930 /* Exclude Infineon Flash Loader utility */
1931 { USB_DEVICE(0x058b, 0x0041),
1932 .driver_info = IGNORE_DEVICE,
1933 },
1934
1935 /* Exclude ETAS ES58x */
1936 { USB_DEVICE(0x108c, 0x0159), /* ES581.4 */
1937 .driver_info = IGNORE_DEVICE,
1938 },
1939 { USB_DEVICE(0x108c, 0x0168), /* ES582.1 */
1940 .driver_info = IGNORE_DEVICE,
1941 },
1942 { USB_DEVICE(0x108c, 0x0169), /* ES584.1 */
1943 .driver_info = IGNORE_DEVICE,
1944 },
1945
1946 { USB_DEVICE(0x1bc7, 0x0021), /* Telit 3G ACM only composition */
1947 .driver_info = SEND_ZERO_PACKET,
1948 },
1949 { USB_DEVICE(0x1bc7, 0x0023), /* Telit 3G ACM + ECM composition */
1950 .driver_info = SEND_ZERO_PACKET,
1951 },
1952
1953 /* Exclude Goodix Fingerprint Reader */
1954 { USB_DEVICE(0x27c6, 0x5395),
1955 .driver_info = IGNORE_DEVICE,
1956 },
1957
1958 /* Exclude Heimann Sensor GmbH USB appset demo */
1959 { USB_DEVICE(0x32a7, 0x0000),
1960 .driver_info = IGNORE_DEVICE,
1961 },
1962
1963 /* control interfaces without any protocol set */
1964 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1965 USB_CDC_PROTO_NONE) },
1966
1967 /* control interfaces with various AT-command sets */
1968 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1969 USB_CDC_ACM_PROTO_AT_V25TER) },
1970 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1971 USB_CDC_ACM_PROTO_AT_PCCA101) },
1972 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1973 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1974 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1975 USB_CDC_ACM_PROTO_AT_GSM) },
1976 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1977 USB_CDC_ACM_PROTO_AT_3G) },
1978 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1979 USB_CDC_ACM_PROTO_AT_CDMA) },
1980
1981 { USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */
1982 .driver_info = SEND_ZERO_PACKET,
1983 },
1984
1985 { }
1986};
1987
1988MODULE_DEVICE_TABLE(usb, acm_ids);
1989
1990static struct usb_driver acm_driver = {
1991 .name = "cdc_acm",
1992 .probe = acm_probe,
1993 .disconnect = acm_disconnect,
1994#ifdef CONFIG_PM
1995 .suspend = acm_suspend,
1996 .resume = acm_resume,
1997 .reset_resume = acm_reset_resume,
1998#endif
1999 .pre_reset = acm_pre_reset,
2000 .id_table = acm_ids,
2001#ifdef CONFIG_PM
2002 .supports_autosuspend = 1,
2003#endif
2004 .disable_hub_initiated_lpm = 1,
2005};
2006
2007/*
2008 * TTY driver structures.
2009 */
2010
2011static const struct tty_operations acm_ops = {
2012 .install = acm_tty_install,
2013 .open = acm_tty_open,
2014 .close = acm_tty_close,
2015 .cleanup = acm_tty_cleanup,
2016 .hangup = acm_tty_hangup,
2017 .write = acm_tty_write,
2018 .write_room = acm_tty_write_room,
2019 .ioctl = acm_tty_ioctl,
2020 .throttle = acm_tty_throttle,
2021 .unthrottle = acm_tty_unthrottle,
2022 .chars_in_buffer = acm_tty_chars_in_buffer,
2023 .break_ctl = acm_tty_break_ctl,
2024 .set_termios = acm_tty_set_termios,
2025 .tiocmget = acm_tty_tiocmget,
2026 .tiocmset = acm_tty_tiocmset,
2027 .get_serial = get_serial_info,
2028 .set_serial = set_serial_info,
2029 .get_icount = acm_tty_get_icount,
2030};
2031
2032/*
2033 * Init / exit.
2034 */
2035
2036static int __init acm_init(void)
2037{
2038 int retval;
2039 acm_tty_driver = tty_alloc_driver(ACM_TTY_MINORS, TTY_DRIVER_REAL_RAW |
2040 TTY_DRIVER_DYNAMIC_DEV);
2041 if (IS_ERR(acm_tty_driver))
2042 return PTR_ERR(acm_tty_driver);
2043 acm_tty_driver->driver_name = "acm",
2044 acm_tty_driver->name = "ttyACM",
2045 acm_tty_driver->major = ACM_TTY_MAJOR,
2046 acm_tty_driver->minor_start = 0,
2047 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
2048 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
2049 acm_tty_driver->init_termios = tty_std_termios;
2050 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
2051 HUPCL | CLOCAL;
2052 tty_set_operations(acm_tty_driver, &acm_ops);
2053
2054 retval = tty_register_driver(acm_tty_driver);
2055 if (retval) {
2056 tty_driver_kref_put(acm_tty_driver);
2057 return retval;
2058 }
2059
2060 retval = usb_register(&acm_driver);
2061 if (retval) {
2062 tty_unregister_driver(acm_tty_driver);
2063 tty_driver_kref_put(acm_tty_driver);
2064 return retval;
2065 }
2066
2067 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
2068
2069 return 0;
2070}
2071
2072static void __exit acm_exit(void)
2073{
2074 usb_deregister(&acm_driver);
2075 tty_unregister_driver(acm_tty_driver);
2076 tty_driver_kref_put(acm_tty_driver);
2077 idr_destroy(&acm_minors);
2078}
2079
2080module_init(acm_init);
2081module_exit(acm_exit);
2082
2083MODULE_AUTHOR(DRIVER_AUTHOR);
2084MODULE_DESCRIPTION(DRIVER_DESC);
2085MODULE_LICENSE("GPL");
2086MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);