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