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