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