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