projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'next' into for-linus
[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 tty_unregister_device(acm_tty_driver, acm->minor);
597 acm_release_minor(acm);
598 usb_put_intf(acm->control);
599 kfree(acm->country_codes);
600 kfree(acm);
601 }
602
603 static void acm_port_shutdown(struct tty_port *port)
604 {
605 struct acm *acm = container_of(port, struct acm, port);
606 int i;
607
608 dev_dbg(&acm->control->dev, "%s\n", __func__);
609
610 mutex_lock(&acm->mutex);
611 if (!acm->disconnected) {
612 usb_autopm_get_interface(acm->control);
613 acm_set_control(acm, acm->ctrlout = 0);
614 usb_kill_urb(acm->ctrlurb);
615 for (i = 0; i < ACM_NW; i++)
616 usb_kill_urb(acm->wb[i].urb);
617 for (i = 0; i < acm->rx_buflimit; i++)
618 usb_kill_urb(acm->read_urbs[i]);
619 acm->control->needs_remote_wakeup = 0;
620 usb_autopm_put_interface(acm->control);
621 }
622 mutex_unlock(&acm->mutex);
623 }
624
625 static void acm_tty_cleanup(struct tty_struct *tty)
626 {
627 struct acm *acm = tty->driver_data;
628 dev_dbg(&acm->control->dev, "%s\n", __func__);
629 tty_port_put(&acm->port);
630 }
631
632 static void acm_tty_hangup(struct tty_struct *tty)
633 {
634 struct acm *acm = tty->driver_data;
635 dev_dbg(&acm->control->dev, "%s\n", __func__);
636 tty_port_hangup(&acm->port);
637 }
638
639 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
640 {
641 struct acm *acm = tty->driver_data;
642 dev_dbg(&acm->control->dev, "%s\n", __func__);
643 tty_port_close(&acm->port, tty, filp);
644 }
645
646 static int acm_tty_write(struct tty_struct *tty,
647 const unsigned char *buf, int count)
648 {
649 struct acm *acm = tty->driver_data;
650 int stat;
651 unsigned long flags;
652 int wbn;
653 struct acm_wb *wb;
654
655 if (!count)
656 return 0;
657
658 dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
659
660 spin_lock_irqsave(&acm->write_lock, flags);
661 wbn = acm_wb_alloc(acm);
662 if (wbn < 0) {
663 spin_unlock_irqrestore(&acm->write_lock, flags);
664 return 0;
665 }
666 wb = &acm->wb[wbn];
667
668 count = (count > acm->writesize) ? acm->writesize : count;
669 dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
670 memcpy(wb->buf, buf, count);
671 wb->len = count;
672 spin_unlock_irqrestore(&acm->write_lock, flags);
673
674 stat = acm_write_start(acm, wbn);
675 if (stat < 0)
676 return stat;
677 return count;
678 }
679
680 static int acm_tty_write_room(struct tty_struct *tty)
681 {
682 struct acm *acm = tty->driver_data;
683 /*
684 * Do not let the line discipline to know that we have a reserve,
685 * or it might get too enthusiastic.
686 */
687 return acm_wb_is_avail(acm) ? acm->writesize : 0;
688 }
689
690 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
691 {
692 struct acm *acm = tty->driver_data;
693 /*
694 * if the device was unplugged then any remaining characters fell out
695 * of the connector ;)
696 */
697 if (acm->disconnected)
698 return 0;
699 /*
700 * This is inaccurate (overcounts), but it works.
701 */
702 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
703 }
704
705 static void acm_tty_throttle(struct tty_struct *tty)
706 {
707 struct acm *acm = tty->driver_data;
708
709 spin_lock_irq(&acm->read_lock);
710 acm->throttle_req = 1;
711 spin_unlock_irq(&acm->read_lock);
712 }
713
714 static void acm_tty_unthrottle(struct tty_struct *tty)
715 {
716 struct acm *acm = tty->driver_data;
717 unsigned int was_throttled;
718
719 spin_lock_irq(&acm->read_lock);
720 was_throttled = acm->throttled;
721 acm->throttled = 0;
722 acm->throttle_req = 0;
723 spin_unlock_irq(&acm->read_lock);
724
725 if (was_throttled)
726 acm_submit_read_urbs(acm, GFP_KERNEL);
727 }
728
729 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
730 {
731 struct acm *acm = tty->driver_data;
732 int retval;
733
734 retval = acm_send_break(acm, state ? 0xffff : 0);
735 if (retval < 0)
736 dev_dbg(&acm->control->dev, "%s - send break failed\n",
737 __func__);
738 return retval;
739 }
740
741 static int acm_tty_tiocmget(struct tty_struct *tty)
742 {
743 struct acm *acm = tty->driver_data;
744
745 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
746 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
747 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
748 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
749 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
750 TIOCM_CTS;
751 }
752
753 static int acm_tty_tiocmset(struct tty_struct *tty,
754 unsigned int set, unsigned int clear)
755 {
756 struct acm *acm = tty->driver_data;
757 unsigned int newctrl;
758
759 newctrl = acm->ctrlout;
760 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
761 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
762 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
763 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
764
765 newctrl = (newctrl & ~clear) | set;
766
767 if (acm->ctrlout == newctrl)
768 return 0;
769 return acm_set_control(acm, acm->ctrlout = newctrl);
770 }
771
772 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
773 {
774 struct serial_struct tmp;
775
776 if (!info)
777 return -EINVAL;
778
779 memset(&tmp, 0, sizeof(tmp));
780 tmp.flags = ASYNC_LOW_LATENCY;
781 tmp.xmit_fifo_size = acm->writesize;
782 tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
783 tmp.close_delay = acm->port.close_delay / 10;
784 tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
785 ASYNC_CLOSING_WAIT_NONE :
786 acm->port.closing_wait / 10;
787
788 if (copy_to_user(info, &tmp, sizeof(tmp)))
789 return -EFAULT;
790 else
791 return 0;
792 }
793
794 static int set_serial_info(struct acm *acm,
795 struct serial_struct __user *newinfo)
796 {
797 struct serial_struct new_serial;
798 unsigned int closing_wait, close_delay;
799 int retval = 0;
800
801 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
802 return -EFAULT;
803
804 close_delay = new_serial.close_delay * 10;
805 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
806 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
807
808 mutex_lock(&acm->port.mutex);
809
810 if (!capable(CAP_SYS_ADMIN)) {
811 if ((close_delay != acm->port.close_delay) ||
812 (closing_wait != acm->port.closing_wait))
813 retval = -EPERM;
814 else
815 retval = -EOPNOTSUPP;
816 } else {
817 acm->port.close_delay = close_delay;
818 acm->port.closing_wait = closing_wait;
819 }
820
821 mutex_unlock(&acm->port.mutex);
822 return retval;
823 }
824
825 static int acm_tty_ioctl(struct tty_struct *tty,
826 unsigned int cmd, unsigned long arg)
827 {
828 struct acm *acm = tty->driver_data;
829 int rv = -ENOIOCTLCMD;
830
831 switch (cmd) {
832 case TIOCGSERIAL: /* gets serial port data */
833 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
834 break;
835 case TIOCSSERIAL:
836 rv = set_serial_info(acm, (struct serial_struct __user *) arg);
837 break;
838 }
839
840 return rv;
841 }
842
843 static const __u32 acm_tty_speed[] = {
844 0, 50, 75, 110, 134, 150, 200, 300, 600,
845 1200, 1800, 2400, 4800, 9600, 19200, 38400,
846 57600, 115200, 230400, 460800, 500000, 576000,
847 921600, 1000000, 1152000, 1500000, 2000000,
848 2500000, 3000000, 3500000, 4000000
849 };
850
851 static void acm_tty_set_termios(struct tty_struct *tty,
852 struct ktermios *termios_old)
853 {
854 struct acm *acm = tty->driver_data;
855 struct ktermios *termios = &tty->termios;
856 struct usb_cdc_line_coding newline;
857 int newctrl = acm->ctrlout;
858
859 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
860 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
861 newline.bParityType = termios->c_cflag & PARENB ?
862 (termios->c_cflag & PARODD ? 1 : 2) +
863 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
864 switch (termios->c_cflag & CSIZE) {
865 case CS5:
866 newline.bDataBits = 5;
867 break;
868 case CS6:
869 newline.bDataBits = 6;
870 break;
871 case CS7:
872 newline.bDataBits = 7;
873 break;
874 case CS8:
875 default:
876 newline.bDataBits = 8;
877 break;
878 }
879 /* FIXME: Needs to clear unsupported bits in the termios */
880 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
881
882 if (!newline.dwDTERate) {
883 newline.dwDTERate = acm->line.dwDTERate;
884 newctrl &= ~ACM_CTRL_DTR;
885 } else
886 newctrl |= ACM_CTRL_DTR;
887
888 if (newctrl != acm->ctrlout)
889 acm_set_control(acm, acm->ctrlout = newctrl);
890
891 if (memcmp(&acm->line, &newline, sizeof newline)) {
892 memcpy(&acm->line, &newline, sizeof newline);
893 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
894 __func__,
895 le32_to_cpu(newline.dwDTERate),
896 newline.bCharFormat, newline.bParityType,
897 newline.bDataBits);
898 acm_set_line(acm, &acm->line);
899 }
900 }
901
902 static const struct tty_port_operations acm_port_ops = {
903 .shutdown = acm_port_shutdown,
904 .activate = acm_port_activate,
905 .destruct = acm_port_destruct,
906 };
907
908 /*
909 * USB probe and disconnect routines.
910 */
911
912 /* Little helpers: write/read buffers free */
913 static void acm_write_buffers_free(struct acm *acm)
914 {
915 int i;
916 struct acm_wb *wb;
917 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
918
919 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
920 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
921 }
922
923 static void acm_read_buffers_free(struct acm *acm)
924 {
925 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
926 int i;
927
928 for (i = 0; i < acm->rx_buflimit; i++)
929 usb_free_coherent(usb_dev, acm->readsize,
930 acm->read_buffers[i].base, acm->read_buffers[i].dma);
931 }
932
933 /* Little helper: write buffers allocate */
934 static int acm_write_buffers_alloc(struct acm *acm)
935 {
936 int i;
937 struct acm_wb *wb;
938
939 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
940 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
941 &wb->dmah);
942 if (!wb->buf) {
943 while (i != 0) {
944 --i;
945 --wb;
946 usb_free_coherent(acm->dev, acm->writesize,
947 wb->buf, wb->dmah);
948 }
949 return -ENOMEM;
950 }
951 }
952 return 0;
953 }
954
955 static int acm_probe(struct usb_interface *intf,
956 const struct usb_device_id *id)
957 {
958 struct usb_cdc_union_desc *union_header = NULL;
959 struct usb_cdc_country_functional_desc *cfd = NULL;
960 unsigned char *buffer = intf->altsetting->extra;
961 int buflen = intf->altsetting->extralen;
962 struct usb_interface *control_interface;
963 struct usb_interface *data_interface;
964 struct usb_endpoint_descriptor *epctrl = NULL;
965 struct usb_endpoint_descriptor *epread = NULL;
966 struct usb_endpoint_descriptor *epwrite = NULL;
967 struct usb_device *usb_dev = interface_to_usbdev(intf);
968 struct acm *acm;
969 int minor;
970 int ctrlsize, readsize;
971 u8 *buf;
972 u8 ac_management_function = 0;
973 u8 call_management_function = 0;
974 int call_interface_num = -1;
975 int data_interface_num = -1;
976 unsigned long quirks;
977 int num_rx_buf;
978 int i;
979 int combined_interfaces = 0;
980
981 /* normal quirks */
982 quirks = (unsigned long)id->driver_info;
983
984 if (quirks == IGNORE_DEVICE)
985 return -ENODEV;
986
987 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
988
989 /* handle quirks deadly to normal probing*/
990 if (quirks == NO_UNION_NORMAL) {
991 data_interface = usb_ifnum_to_if(usb_dev, 1);
992 control_interface = usb_ifnum_to_if(usb_dev, 0);
993 goto skip_normal_probe;
994 }
995
996 /* normal probing*/
997 if (!buffer) {
998 dev_err(&intf->dev, "Weird descriptor references\n");
999 return -EINVAL;
1000 }
1001
1002 if (!buflen) {
1003 if (intf->cur_altsetting->endpoint &&
1004 intf->cur_altsetting->endpoint->extralen &&
1005 intf->cur_altsetting->endpoint->extra) {
1006 dev_dbg(&intf->dev,
1007 "Seeking extra descriptors on endpoint\n");
1008 buflen = intf->cur_altsetting->endpoint->extralen;
1009 buffer = intf->cur_altsetting->endpoint->extra;
1010 } else {
1011 dev_err(&intf->dev,
1012 "Zero length descriptor references\n");
1013 return -EINVAL;
1014 }
1015 }
1016
1017 while (buflen > 0) {
1018 if (buffer[1] != USB_DT_CS_INTERFACE) {
1019 dev_err(&intf->dev, "skipping garbage\n");
1020 goto next_desc;
1021 }
1022
1023 switch (buffer[2]) {
1024 case USB_CDC_UNION_TYPE: /* we've found it */
1025 if (union_header) {
1026 dev_err(&intf->dev, "More than one "
1027 "union descriptor, skipping ...\n");
1028 goto next_desc;
1029 }
1030 union_header = (struct usb_cdc_union_desc *)buffer;
1031 break;
1032 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1033 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1034 break;
1035 case USB_CDC_HEADER_TYPE: /* maybe check version */
1036 break; /* for now we ignore it */
1037 case USB_CDC_ACM_TYPE:
1038 ac_management_function = buffer[3];
1039 break;
1040 case USB_CDC_CALL_MANAGEMENT_TYPE:
1041 call_management_function = buffer[3];
1042 call_interface_num = buffer[4];
1043 if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1044 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1045 break;
1046 default:
1047 /* there are LOTS more CDC descriptors that
1048 * could legitimately be found here.
1049 */
1050 dev_dbg(&intf->dev, "Ignoring descriptor: "
1051 "type %02x, length %d\n",
1052 buffer[2], buffer[0]);
1053 break;
1054 }
1055 next_desc:
1056 buflen -= buffer[0];
1057 buffer += buffer[0];
1058 }
1059
1060 if (!union_header) {
1061 if (call_interface_num > 0) {
1062 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1063 /* quirks for Droids MuIn LCD */
1064 if (quirks & NO_DATA_INTERFACE)
1065 data_interface = usb_ifnum_to_if(usb_dev, 0);
1066 else
1067 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1068 control_interface = intf;
1069 } else {
1070 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1071 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1072 return -ENODEV;
1073 } else {
1074 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1075 combined_interfaces = 1;
1076 control_interface = data_interface = intf;
1077 goto look_for_collapsed_interface;
1078 }
1079 }
1080 } else {
1081 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1082 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1083 if (!control_interface || !data_interface) {
1084 dev_dbg(&intf->dev, "no interfaces\n");
1085 return -ENODEV;
1086 }
1087 }
1088
1089 if (data_interface_num != call_interface_num)
1090 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1091
1092 if (control_interface == data_interface) {
1093 /* some broken devices designed for windows work this way */
1094 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1095 combined_interfaces = 1;
1096 /* a popular other OS doesn't use it */
1097 quirks |= NO_CAP_LINE;
1098 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1099 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1100 return -EINVAL;
1101 }
1102 look_for_collapsed_interface:
1103 for (i = 0; i < 3; i++) {
1104 struct usb_endpoint_descriptor *ep;
1105 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1106
1107 if (usb_endpoint_is_int_in(ep))
1108 epctrl = ep;
1109 else if (usb_endpoint_is_bulk_out(ep))
1110 epwrite = ep;
1111 else if (usb_endpoint_is_bulk_in(ep))
1112 epread = ep;
1113 else
1114 return -EINVAL;
1115 }
1116 if (!epctrl || !epread || !epwrite)
1117 return -ENODEV;
1118 else
1119 goto made_compressed_probe;
1120 }
1121
1122 skip_normal_probe:
1123
1124 /*workaround for switched interfaces */
1125 if (data_interface->cur_altsetting->desc.bInterfaceClass
1126 != CDC_DATA_INTERFACE_TYPE) {
1127 if (control_interface->cur_altsetting->desc.bInterfaceClass
1128 == CDC_DATA_INTERFACE_TYPE) {
1129 struct usb_interface *t;
1130 dev_dbg(&intf->dev,
1131 "Your device has switched interfaces.\n");
1132 t = control_interface;
1133 control_interface = data_interface;
1134 data_interface = t;
1135 } else {
1136 return -EINVAL;
1137 }
1138 }
1139
1140 /* Accept probe requests only for the control interface */
1141 if (!combined_interfaces && intf != control_interface)
1142 return -ENODEV;
1143
1144 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1145 /* valid in this context */
1146 dev_dbg(&intf->dev, "The data interface isn't available\n");
1147 return -EBUSY;
1148 }
1149
1150
1151 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1152 control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1153 return -EINVAL;
1154
1155 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1156 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1157 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1158
1159
1160 /* workaround for switched endpoints */
1161 if (!usb_endpoint_dir_in(epread)) {
1162 /* descriptors are swapped */
1163 struct usb_endpoint_descriptor *t;
1164 dev_dbg(&intf->dev,
1165 "The data interface has switched endpoints\n");
1166 t = epread;
1167 epread = epwrite;
1168 epwrite = t;
1169 }
1170 made_compressed_probe:
1171 dev_dbg(&intf->dev, "interfaces are valid\n");
1172
1173 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1174 if (acm == NULL) {
1175 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1176 goto alloc_fail;
1177 }
1178
1179 minor = acm_alloc_minor(acm);
1180 if (minor == ACM_TTY_MINORS) {
1181 dev_err(&intf->dev, "no more free acm devices\n");
1182 kfree(acm);
1183 return -ENODEV;
1184 }
1185
1186 ctrlsize = usb_endpoint_maxp(epctrl);
1187 readsize = usb_endpoint_maxp(epread) *
1188 (quirks == SINGLE_RX_URB ? 1 : 2);
1189 acm->combined_interfaces = combined_interfaces;
1190 acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1191 acm->control = control_interface;
1192 acm->data = data_interface;
1193 acm->minor = minor;
1194 acm->dev = usb_dev;
1195 acm->ctrl_caps = ac_management_function;
1196 if (quirks & NO_CAP_LINE)
1197 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1198 acm->ctrlsize = ctrlsize;
1199 acm->readsize = readsize;
1200 acm->rx_buflimit = num_rx_buf;
1201 INIT_WORK(&acm->work, acm_softint);
1202 spin_lock_init(&acm->write_lock);
1203 spin_lock_init(&acm->read_lock);
1204 mutex_init(&acm->mutex);
1205 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1206 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1207 if (acm->is_int_ep)
1208 acm->bInterval = epread->bInterval;
1209 tty_port_init(&acm->port);
1210 acm->port.ops = &acm_port_ops;
1211
1212 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1213 if (!buf) {
1214 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1215 goto alloc_fail2;
1216 }
1217 acm->ctrl_buffer = buf;
1218
1219 if (acm_write_buffers_alloc(acm) < 0) {
1220 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1221 goto alloc_fail4;
1222 }
1223
1224 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1225 if (!acm->ctrlurb) {
1226 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1227 goto alloc_fail5;
1228 }
1229 for (i = 0; i < num_rx_buf; i++) {
1230 struct acm_rb *rb = &(acm->read_buffers[i]);
1231 struct urb *urb;
1232
1233 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1234 &rb->dma);
1235 if (!rb->base) {
1236 dev_err(&intf->dev, "out of memory "
1237 "(read bufs usb_alloc_coherent)\n");
1238 goto alloc_fail6;
1239 }
1240 rb->index = i;
1241 rb->instance = acm;
1242
1243 urb = usb_alloc_urb(0, GFP_KERNEL);
1244 if (!urb) {
1245 dev_err(&intf->dev,
1246 "out of memory (read urbs usb_alloc_urb)\n");
1247 goto alloc_fail6;
1248 }
1249 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1250 urb->transfer_dma = rb->dma;
1251 if (acm->is_int_ep) {
1252 usb_fill_int_urb(urb, acm->dev,
1253 acm->rx_endpoint,
1254 rb->base,
1255 acm->readsize,
1256 acm_read_bulk_callback, rb,
1257 acm->bInterval);
1258 } else {
1259 usb_fill_bulk_urb(urb, acm->dev,
1260 acm->rx_endpoint,
1261 rb->base,
1262 acm->readsize,
1263 acm_read_bulk_callback, rb);
1264 }
1265
1266 acm->read_urbs[i] = urb;
1267 __set_bit(i, &acm->read_urbs_free);
1268 }
1269 for (i = 0; i < ACM_NW; i++) {
1270 struct acm_wb *snd = &(acm->wb[i]);
1271
1272 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1273 if (snd->urb == NULL) {
1274 dev_err(&intf->dev,
1275 "out of memory (write urbs usb_alloc_urb)\n");
1276 goto alloc_fail7;
1277 }
1278
1279 if (usb_endpoint_xfer_int(epwrite))
1280 usb_fill_int_urb(snd->urb, usb_dev,
1281 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1282 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1283 else
1284 usb_fill_bulk_urb(snd->urb, usb_dev,
1285 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1286 NULL, acm->writesize, acm_write_bulk, snd);
1287 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288 snd->instance = acm;
1289 }
1290
1291 usb_set_intfdata(intf, acm);
1292
1293 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1294 if (i < 0)
1295 goto alloc_fail7;
1296
1297 if (cfd) { /* export the country data */
1298 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1299 if (!acm->country_codes)
1300 goto skip_countries;
1301 acm->country_code_size = cfd->bLength - 4;
1302 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1303 cfd->bLength - 4);
1304 acm->country_rel_date = cfd->iCountryCodeRelDate;
1305
1306 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1307 if (i < 0) {
1308 kfree(acm->country_codes);
1309 acm->country_codes = NULL;
1310 acm->country_code_size = 0;
1311 goto skip_countries;
1312 }
1313
1314 i = device_create_file(&intf->dev,
1315 &dev_attr_iCountryCodeRelDate);
1316 if (i < 0) {
1317 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1318 kfree(acm->country_codes);
1319 acm->country_codes = NULL;
1320 acm->country_code_size = 0;
1321 goto skip_countries;
1322 }
1323 }
1324
1325 skip_countries:
1326 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1327 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1328 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1329 /* works around buggy devices */
1330 epctrl->bInterval ? epctrl->bInterval : 0xff);
1331 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1332 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1333
1334 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1335
1336 acm_set_control(acm, acm->ctrlout);
1337
1338 acm->line.dwDTERate = cpu_to_le32(9600);
1339 acm->line.bDataBits = 8;
1340 acm_set_line(acm, &acm->line);
1341
1342 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1343 usb_set_intfdata(data_interface, acm);
1344
1345 usb_get_intf(control_interface);
1346 tty_port_register_device(&acm->port, acm_tty_driver, minor,
1347 &control_interface->dev);
1348
1349 return 0;
1350 alloc_fail7:
1351 for (i = 0; i < ACM_NW; i++)
1352 usb_free_urb(acm->wb[i].urb);
1353 alloc_fail6:
1354 for (i = 0; i < num_rx_buf; i++)
1355 usb_free_urb(acm->read_urbs[i]);
1356 acm_read_buffers_free(acm);
1357 usb_free_urb(acm->ctrlurb);
1358 alloc_fail5:
1359 acm_write_buffers_free(acm);
1360 alloc_fail4:
1361 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1362 alloc_fail2:
1363 acm_release_minor(acm);
1364 kfree(acm);
1365 alloc_fail:
1366 return -ENOMEM;
1367 }
1368
1369 static void stop_data_traffic(struct acm *acm)
1370 {
1371 int i;
1372
1373 dev_dbg(&acm->control->dev, "%s\n", __func__);
1374
1375 usb_kill_urb(acm->ctrlurb);
1376 for (i = 0; i < ACM_NW; i++)
1377 usb_kill_urb(acm->wb[i].urb);
1378 for (i = 0; i < acm->rx_buflimit; i++)
1379 usb_kill_urb(acm->read_urbs[i]);
1380
1381 cancel_work_sync(&acm->work);
1382 }
1383
1384 static void acm_disconnect(struct usb_interface *intf)
1385 {
1386 struct acm *acm = usb_get_intfdata(intf);
1387 struct usb_device *usb_dev = interface_to_usbdev(intf);
1388 struct tty_struct *tty;
1389 int i;
1390
1391 dev_dbg(&intf->dev, "%s\n", __func__);
1392
1393 /* sibling interface is already cleaning up */
1394 if (!acm)
1395 return;
1396
1397 mutex_lock(&acm->mutex);
1398 acm->disconnected = true;
1399 if (acm->country_codes) {
1400 device_remove_file(&acm->control->dev,
1401 &dev_attr_wCountryCodes);
1402 device_remove_file(&acm->control->dev,
1403 &dev_attr_iCountryCodeRelDate);
1404 }
1405 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1406 usb_set_intfdata(acm->control, NULL);
1407 usb_set_intfdata(acm->data, NULL);
1408 mutex_unlock(&acm->mutex);
1409
1410 tty = tty_port_tty_get(&acm->port);
1411 if (tty) {
1412 tty_vhangup(tty);
1413 tty_kref_put(tty);
1414 }
1415
1416 stop_data_traffic(acm);
1417
1418 usb_free_urb(acm->ctrlurb);
1419 for (i = 0; i < ACM_NW; i++)
1420 usb_free_urb(acm->wb[i].urb);
1421 for (i = 0; i < acm->rx_buflimit; i++)
1422 usb_free_urb(acm->read_urbs[i]);
1423 acm_write_buffers_free(acm);
1424 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1425 acm_read_buffers_free(acm);
1426
1427 if (!acm->combined_interfaces)
1428 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1429 acm->data : acm->control);
1430
1431 tty_port_put(&acm->port);
1432 }
1433
1434 #ifdef CONFIG_PM
1435 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1436 {
1437 struct acm *acm = usb_get_intfdata(intf);
1438 int cnt;
1439
1440 if (PMSG_IS_AUTO(message)) {
1441 int b;
1442
1443 spin_lock_irq(&acm->write_lock);
1444 b = acm->transmitting;
1445 spin_unlock_irq(&acm->write_lock);
1446 if (b)
1447 return -EBUSY;
1448 }
1449
1450 spin_lock_irq(&acm->read_lock);
1451 spin_lock(&acm->write_lock);
1452 cnt = acm->susp_count++;
1453 spin_unlock(&acm->write_lock);
1454 spin_unlock_irq(&acm->read_lock);
1455
1456 if (cnt)
1457 return 0;
1458
1459 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
1460 stop_data_traffic(acm);
1461
1462 return 0;
1463 }
1464
1465 static int acm_resume(struct usb_interface *intf)
1466 {
1467 struct acm *acm = usb_get_intfdata(intf);
1468 struct acm_wb *wb;
1469 int rv = 0;
1470 int cnt;
1471
1472 spin_lock_irq(&acm->read_lock);
1473 acm->susp_count -= 1;
1474 cnt = acm->susp_count;
1475 spin_unlock_irq(&acm->read_lock);
1476
1477 if (cnt)
1478 return 0;
1479
1480 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1481 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1482
1483 spin_lock_irq(&acm->write_lock);
1484 if (acm->delayed_wb) {
1485 wb = acm->delayed_wb;
1486 acm->delayed_wb = NULL;
1487 spin_unlock_irq(&acm->write_lock);
1488 acm_start_wb(acm, wb);
1489 } else {
1490 spin_unlock_irq(&acm->write_lock);
1491 }
1492
1493 /*
1494 * delayed error checking because we must
1495 * do the write path at all cost
1496 */
1497 if (rv < 0)
1498 goto err_out;
1499
1500 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1501 }
1502
1503 err_out:
1504 return rv;
1505 }
1506
1507 static int acm_reset_resume(struct usb_interface *intf)
1508 {
1509 struct acm *acm = usb_get_intfdata(intf);
1510 struct tty_struct *tty;
1511
1512 if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
1513 tty = tty_port_tty_get(&acm->port);
1514 if (tty) {
1515 tty_hangup(tty);
1516 tty_kref_put(tty);
1517 }
1518 }
1519
1520 return acm_resume(intf);
1521 }
1522
1523 #endif /* CONFIG_PM */
1524
1525 #define NOKIA_PCSUITE_ACM_INFO(x) \
1526 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1527 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1528 USB_CDC_ACM_PROTO_VENDOR)
1529
1530 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1531 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1532 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1533 USB_CDC_ACM_PROTO_VENDOR)
1534
1535 /*
1536 * USB driver structure.
1537 */
1538
1539 static const struct usb_device_id acm_ids[] = {
1540 /* quirky and broken devices */
1541 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1542 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1543 },
1544 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1545 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1546 },
1547 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1548 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1549 },
1550 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1551 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1552 },
1553 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1554 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1555 },
1556 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1557 .driver_info = SINGLE_RX_URB,
1558 },
1559 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1560 .driver_info = SINGLE_RX_URB, /* firmware bug */
1561 },
1562 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1563 .driver_info = SINGLE_RX_URB, /* firmware bug */
1564 },
1565 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1566 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1567 },
1568 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1569 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1570 },
1571 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1572 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1573 },
1574 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1575 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1576 },
1577 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1578 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1579 },
1580 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1581 },
1582 /* Motorola H24 HSPA module: */
1583 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1584 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1585 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1586 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1587 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1588 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1589 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1590 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1591
1592 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1593 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1594 data interface instead of
1595 communications interface.
1596 Maybe we should define a new
1597 quirk for this. */
1598 },
1599 { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1600 .driver_info = NO_UNION_NORMAL,
1601 },
1602 { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1603 .driver_info = NO_UNION_NORMAL,
1604 },
1605 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1606 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1607 },
1608 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1609 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1610 },
1611
1612 /* Nokia S60 phones expose two ACM channels. The first is
1613 * a modem and is picked up by the standard AT-command
1614 * information below. The second is 'vendor-specific' but
1615 * is treated as a serial device at the S60 end, so we want
1616 * to expose it on Linux too. */
1617 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1618 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1619 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1620 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1621 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1622 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1623 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1624 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1625 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1626 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1627 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1628 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1629 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1630 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1631 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1632 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1633 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1634 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1635 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1636 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1637 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1638 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1639 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1640 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1641 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1642 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1643 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1644 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1645 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1646 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1647 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1648 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1649 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1650 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1651 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1652 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1653 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1654 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1655 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1656 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1657 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1658 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1659 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1660 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1661 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1662 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1663 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1664 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1665 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1666 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1667 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1668 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1669 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1670 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1671 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1672 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1673 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1674 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1675
1676 /* Support for Owen devices */
1677 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1678
1679 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1680
1681 /* Support Lego NXT using pbLua firmware */
1682 { USB_DEVICE(0x0694, 0xff00),
1683 .driver_info = NOT_A_MODEM,
1684 },
1685
1686 /* Support for Droids MuIn LCD */
1687 { USB_DEVICE(0x04d8, 0x000b),
1688 .driver_info = NO_DATA_INTERFACE,
1689 },
1690
1691 #if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1692 { USB_DEVICE(0x04d8, 0x0082), /* Application mode */
1693 .driver_info = IGNORE_DEVICE,
1694 },
1695 { USB_DEVICE(0x04d8, 0x0083), /* Bootloader mode */
1696 .driver_info = IGNORE_DEVICE,
1697 },
1698 #endif
1699
1700 /* control interfaces without any protocol set */
1701 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1702 USB_CDC_PROTO_NONE) },
1703
1704 /* control interfaces with various AT-command sets */
1705 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1706 USB_CDC_ACM_PROTO_AT_V25TER) },
1707 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1708 USB_CDC_ACM_PROTO_AT_PCCA101) },
1709 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1710 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1711 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1712 USB_CDC_ACM_PROTO_AT_GSM) },
1713 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1714 USB_CDC_ACM_PROTO_AT_3G) },
1715 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1716 USB_CDC_ACM_PROTO_AT_CDMA) },
1717
1718 { }
1719 };
1720
1721 MODULE_DEVICE_TABLE(usb, acm_ids);
1722
1723 static struct usb_driver acm_driver = {
1724 .name = "cdc_acm",
1725 .probe = acm_probe,
1726 .disconnect = acm_disconnect,
1727 #ifdef CONFIG_PM
1728 .suspend = acm_suspend,
1729 .resume = acm_resume,
1730 .reset_resume = acm_reset_resume,
1731 #endif
1732 .id_table = acm_ids,
1733 #ifdef CONFIG_PM
1734 .supports_autosuspend = 1,
1735 #endif
1736 .disable_hub_initiated_lpm = 1,
1737 };
1738
1739 /*
1740 * TTY driver structures.
1741 */
1742
1743 static const struct tty_operations acm_ops = {
1744 .install = acm_tty_install,
1745 .open = acm_tty_open,
1746 .close = acm_tty_close,
1747 .cleanup = acm_tty_cleanup,
1748 .hangup = acm_tty_hangup,
1749 .write = acm_tty_write,
1750 .write_room = acm_tty_write_room,
1751 .ioctl = acm_tty_ioctl,
1752 .throttle = acm_tty_throttle,
1753 .unthrottle = acm_tty_unthrottle,
1754 .chars_in_buffer = acm_tty_chars_in_buffer,
1755 .break_ctl = acm_tty_break_ctl,
1756 .set_termios = acm_tty_set_termios,
1757 .tiocmget = acm_tty_tiocmget,
1758 .tiocmset = acm_tty_tiocmset,
1759 };
1760
1761 /*
1762 * Init / exit.
1763 */
1764
1765 static int __init acm_init(void)
1766 {
1767 int retval;
1768 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1769 if (!acm_tty_driver)
1770 return -ENOMEM;
1771 acm_tty_driver->driver_name = "acm",
1772 acm_tty_driver->name = "ttyACM",
1773 acm_tty_driver->major = ACM_TTY_MAJOR,
1774 acm_tty_driver->minor_start = 0,
1775 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1776 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1777 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1778 acm_tty_driver->init_termios = tty_std_termios;
1779 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1780 HUPCL | CLOCAL;
1781 tty_set_operations(acm_tty_driver, &acm_ops);
1782
1783 retval = tty_register_driver(acm_tty_driver);
1784 if (retval) {
1785 put_tty_driver(acm_tty_driver);
1786 return retval;
1787 }
1788
1789 retval = usb_register(&acm_driver);
1790 if (retval) {
1791 tty_unregister_driver(acm_tty_driver);
1792 put_tty_driver(acm_tty_driver);
1793 return retval;
1794 }
1795
1796 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1797
1798 return 0;
1799 }
1800
1801 static void __exit acm_exit(void)
1802 {
1803 usb_deregister(&acm_driver);
1804 tty_unregister_driver(acm_tty_driver);
1805 put_tty_driver(acm_tty_driver);
1806 }
1807
1808 module_init(acm_init);
1809 module_exit(acm_exit);
1810
1811 MODULE_AUTHOR(DRIVER_AUTHOR);
1812 MODULE_DESCRIPTION(DRIVER_DESC);
1813 MODULE_LICENSE("GPL");
1814 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
kernel source for telekom puls (alcatel/mediatek)