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