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