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