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