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