?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mac80211: use AES_BLOCK_SIZE
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / class / cdc-acm.c
blobe057e5381465b1a12c03e550f3ff6b2f9d4d24e0
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 *
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_insert_flip_string(tty, buf->base, buf->size);
433 tty_flip_buffer_push(tty);
434 } else {
435 tty_kref_put(tty);
436 dbg("Throttling noticed");
437 spin_lock_irqsave(&acm->read_lock, flags);
438 list_add(&buf->list, &acm->filled_read_bufs);
439 spin_unlock_irqrestore(&acm->read_lock, flags);
440 return;
441 }
442 }
443
444 spin_lock_irqsave(&acm->read_lock, flags);
445 list_add(&buf->list, &acm->spare_read_bufs);
446 spin_unlock_irqrestore(&acm->read_lock, flags);
447 goto next_buffer;
448
449 urbs:
450 tty_kref_put(tty);
451
452 while (!list_empty(&acm->spare_read_bufs)) {
453 spin_lock_irqsave(&acm->read_lock, flags);
454 if (list_empty(&acm->spare_read_urbs)) {
455 acm->processing = 0;
456 spin_unlock_irqrestore(&acm->read_lock, flags);
457 return;
458 }
459 rcv = list_entry(acm->spare_read_urbs.next,
460 struct acm_ru, list);
461 list_del(&rcv->list);
462 spin_unlock_irqrestore(&acm->read_lock, flags);
463
464 buf = list_entry(acm->spare_read_bufs.next,
465 struct acm_rb, list);
466 list_del(&buf->list);
467
468 rcv->buffer = buf;
469
470 if (acm->is_int_ep)
471 usb_fill_int_urb(rcv->urb, acm->dev,
472 acm->rx_endpoint,
473 buf->base,
474 acm->readsize,
475 acm_read_bulk, rcv, acm->bInterval);
476 else
477 usb_fill_bulk_urb(rcv->urb, acm->dev,
478 acm->rx_endpoint,
479 buf->base,
480 acm->readsize,
481 acm_read_bulk, rcv);
482 rcv->urb->transfer_dma = buf->dma;
483 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
484
485 /* This shouldn't kill the driver as unsuccessful URBs are
486 returned to the free-urbs-pool and resubmited ASAP */
487 spin_lock_irqsave(&acm->read_lock, flags);
488 if (acm->susp_count ||
489 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
490 list_add(&buf->list, &acm->spare_read_bufs);
491 list_add(&rcv->list, &acm->spare_read_urbs);
492 acm->processing = 0;
493 spin_unlock_irqrestore(&acm->read_lock, flags);
494 return;
495 } else {
496 spin_unlock_irqrestore(&acm->read_lock, flags);
497 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
498 }
499 }
500 spin_lock_irqsave(&acm->read_lock, flags);
501 acm->processing = 0;
502 spin_unlock_irqrestore(&acm->read_lock, flags);
503 }
504
505 /* data interface wrote those outgoing bytes */
506 static void acm_write_bulk(struct urb *urb)
507 {
508 struct acm_wb *wb = urb->context;
509 struct acm *acm = wb->instance;
510 unsigned long flags;
511
512 if (verbose || urb->status
513 || (urb->actual_length != urb->transfer_buffer_length))
514 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
515 urb->actual_length,
516 urb->transfer_buffer_length,
517 urb->status);
518
519 spin_lock_irqsave(&acm->write_lock, flags);
520 acm_write_done(acm, wb);
521 spin_unlock_irqrestore(&acm->write_lock, flags);
522 if (ACM_READY(acm))
523 schedule_work(&acm->work);
524 else
525 wake_up_interruptible(&acm->drain_wait);
526 }
527
528 static void acm_softint(struct work_struct *work)
529 {
530 struct acm *acm = container_of(work, struct acm, work);
531 struct tty_struct *tty;
532
533 dev_vdbg(&acm->data->dev, "tx work\n");
534 if (!ACM_READY(acm))
535 return;
536 tty = tty_port_tty_get(&acm->port);
537 if (!tty)
538 return;
539 tty_wakeup(tty);
540 tty_kref_put(tty);
541 }
542
543 /*
544 * TTY handlers
545 */
546
547 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
548 {
549 struct acm *acm;
550 int rv = -ENODEV;
551 int i;
552 dbg("Entering acm_tty_open.");
553
554 mutex_lock(&open_mutex);
555
556 acm = acm_table[tty->index];
557 if (!acm || !acm->dev)
558 goto out;
559 else
560 rv = 0;
561
562 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
563
564 tty->driver_data = acm;
565 tty_port_tty_set(&acm->port, tty);
566
567 if (usb_autopm_get_interface(acm->control) < 0)
568 goto early_bail;
569 else
570 acm->control->needs_remote_wakeup = 1;
571
572 mutex_lock(&acm->mutex);
573 if (acm->port.count++) {
574 mutex_unlock(&acm->mutex);
575 usb_autopm_put_interface(acm->control);
576 goto out;
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
606 mutex_unlock(&acm->mutex);
607 out:
608 mutex_unlock(&open_mutex);
609 return rv;
610
611 full_bailout:
612 usb_kill_urb(acm->ctrlurb);
613 bail_out:
614 acm->port.count--;
615 mutex_unlock(&acm->mutex);
616 usb_autopm_put_interface(acm->control);
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)
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 usb_kill_urb(acm->ctrlurb);
650 for (i = 0; i < ACM_NW; i++)
651 usb_kill_urb(acm->wb[i].urb);
652 tasklet_disable(&acm->urb_task);
653 for (i = 0; i < nr; i++)
654 usb_kill_urb(acm->ru[i].urb);
655 tasklet_enable(&acm->urb_task);
656 acm->control->needs_remote_wakeup = 0;
657 usb_autopm_put_interface(acm->control);
658 }
659 mutex_unlock(&open_mutex);
660 }
661
662 static void acm_tty_hangup(struct tty_struct *tty)
663 {
664 struct acm *acm = tty->driver_data;
665 tty_port_hangup(&acm->port);
666 acm_port_down(acm);
667 }
668
669 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
670 {
671 struct acm *acm = tty->driver_data;
672
673 /* Perform the closing process and see if we need to do the hardware
674 shutdown */
675 if (!acm)
676 return;
677 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
678 mutex_lock(&open_mutex);
679 if (!acm->dev) {
680 tty_port_tty_set(&acm->port, NULL);
681 acm_tty_unregister(acm);
682 tty->driver_data = NULL;
683 }
684 mutex_unlock(&open_mutex);
685 return;
686 }
687 acm_port_down(acm);
688 tty_port_close_end(&acm->port, tty);
689 tty_port_tty_set(&acm->port, NULL);
690 }
691
692 static int acm_tty_write(struct tty_struct *tty,
693 const unsigned char *buf, int count)
694 {
695 struct acm *acm = tty->driver_data;
696 int stat;
697 unsigned long flags;
698 int wbn;
699 struct acm_wb *wb;
700
701 dbg("Entering acm_tty_write to write %d bytes,", count);
702
703 if (!ACM_READY(acm))
704 return -EINVAL;
705 if (!count)
706 return 0;
707
708 spin_lock_irqsave(&acm->write_lock, flags);
709 wbn = acm_wb_alloc(acm);
710 if (wbn < 0) {
711 spin_unlock_irqrestore(&acm->write_lock, flags);
712 return 0;
713 }
714 wb = &acm->wb[wbn];
715
716 count = (count > acm->writesize) ? acm->writesize : count;
717 dbg("Get %d bytes...", count);
718 memcpy(wb->buf, buf, count);
719 wb->len = count;
720 spin_unlock_irqrestore(&acm->write_lock, flags);
721
722 stat = acm_write_start(acm, wbn);
723 if (stat < 0)
724 return stat;
725 return count;
726 }
727
728 static int acm_tty_write_room(struct tty_struct *tty)
729 {
730 struct acm *acm = tty->driver_data;
731 if (!ACM_READY(acm))
732 return -EINVAL;
733 /*
734 * Do not let the line discipline to know that we have a reserve,
735 * or it might get too enthusiastic.
736 */
737 return acm_wb_is_avail(acm) ? acm->writesize : 0;
738 }
739
740 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
741 {
742 struct acm *acm = tty->driver_data;
743 if (!ACM_READY(acm))
744 return 0;
745 /*
746 * This is inaccurate (overcounts), but it works.
747 */
748 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
749 }
750
751 static void acm_tty_throttle(struct tty_struct *tty)
752 {
753 struct acm *acm = tty->driver_data;
754 if (!ACM_READY(acm))
755 return;
756 spin_lock_bh(&acm->throttle_lock);
757 acm->throttle = 1;
758 spin_unlock_bh(&acm->throttle_lock);
759 }
760
761 static void acm_tty_unthrottle(struct tty_struct *tty)
762 {
763 struct acm *acm = tty->driver_data;
764 if (!ACM_READY(acm))
765 return;
766 spin_lock_bh(&acm->throttle_lock);
767 acm->throttle = 0;
768 spin_unlock_bh(&acm->throttle_lock);
769 tasklet_schedule(&acm->urb_task);
770 }
771
772 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
773 {
774 struct acm *acm = tty->driver_data;
775 int retval;
776 if (!ACM_READY(acm))
777 return -EINVAL;
778 retval = acm_send_break(acm, state ? 0xffff : 0);
779 if (retval < 0)
780 dbg("send break failed");
781 return retval;
782 }
783
784 static int acm_tty_tiocmget(struct tty_struct *tty)
785 {
786 struct acm *acm = tty->driver_data;
787
788 if (!ACM_READY(acm))
789 return -EINVAL;
790
791 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
792 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
793 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
794 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
795 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
796 TIOCM_CTS;
797 }
798
799 static int acm_tty_tiocmset(struct tty_struct *tty,
800 unsigned int set, unsigned int clear)
801 {
802 struct acm *acm = tty->driver_data;
803 unsigned int newctrl;
804
805 if (!ACM_READY(acm))
806 return -EINVAL;
807
808 newctrl = acm->ctrlout;
809 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
810 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
811 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
812 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
813
814 newctrl = (newctrl & ~clear) | set;
815
816 if (acm->ctrlout == newctrl)
817 return 0;
818 return acm_set_control(acm, acm->ctrlout = newctrl);
819 }
820
821 static int acm_tty_ioctl(struct tty_struct *tty,
822 unsigned int cmd, unsigned long arg)
823 {
824 struct acm *acm = tty->driver_data;
825
826 if (!ACM_READY(acm))
827 return -EINVAL;
828
829 return -ENOIOCTLCMD;
830 }
831
832 static const __u32 acm_tty_speed[] = {
833 0, 50, 75, 110, 134, 150, 200, 300, 600,
834 1200, 1800, 2400, 4800, 9600, 19200, 38400,
835 57600, 115200, 230400, 460800, 500000, 576000,
836 921600, 1000000, 1152000, 1500000, 2000000,
837 2500000, 3000000, 3500000, 4000000
838 };
839
840 static const __u8 acm_tty_size[] = {
841 5, 6, 7, 8
842 };
843
844 static void acm_tty_set_termios(struct tty_struct *tty,
845 struct ktermios *termios_old)
846 {
847 struct acm *acm = tty->driver_data;
848 struct ktermios *termios = tty->termios;
849 struct usb_cdc_line_coding newline;
850 int newctrl = acm->ctrlout;
851
852 if (!ACM_READY(acm))
853 return;
854
855 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
856 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
857 newline.bParityType = termios->c_cflag & PARENB ?
858 (termios->c_cflag & PARODD ? 1 : 2) +
859 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
860 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
861 /* FIXME: Needs to clear unsupported bits in the termios */
862 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
863
864 if (!newline.dwDTERate) {
865 newline.dwDTERate = acm->line.dwDTERate;
866 newctrl &= ~ACM_CTRL_DTR;
867 } else
868 newctrl |= ACM_CTRL_DTR;
869
870 if (newctrl != acm->ctrlout)
871 acm_set_control(acm, acm->ctrlout = newctrl);
872
873 if (memcmp(&acm->line, &newline, sizeof newline)) {
874 memcpy(&acm->line, &newline, sizeof newline);
875 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
876 newline.bCharFormat, newline.bParityType,
877 newline.bDataBits);
878 acm_set_line(acm, &acm->line);
879 }
880 }
881
882 /*
883 * USB probe and disconnect routines.
884 */
885
886 /* Little helpers: write/read buffers free */
887 static void acm_write_buffers_free(struct acm *acm)
888 {
889 int i;
890 struct acm_wb *wb;
891 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
892
893 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
894 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
895 }
896
897 static void acm_read_buffers_free(struct acm *acm)
898 {
899 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
900 int i, n = acm->rx_buflimit;
901
902 for (i = 0; i < n; i++)
903 usb_free_coherent(usb_dev, acm->readsize,
904 acm->rb[i].base, acm->rb[i].dma);
905 }
906
907 /* Little helper: write buffers allocate */
908 static int acm_write_buffers_alloc(struct acm *acm)
909 {
910 int i;
911 struct acm_wb *wb;
912
913 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
914 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
915 &wb->dmah);
916 if (!wb->buf) {
917 while (i != 0) {
918 --i;
919 --wb;
920 usb_free_coherent(acm->dev, acm->writesize,
921 wb->buf, wb->dmah);
922 }
923 return -ENOMEM;
924 }
925 }
926 return 0;
927 }
928
929 static int acm_probe(struct usb_interface *intf,
930 const struct usb_device_id *id)
931 {
932 struct usb_cdc_union_desc *union_header = NULL;
933 struct usb_cdc_country_functional_desc *cfd = NULL;
934 unsigned char *buffer = intf->altsetting->extra;
935 int buflen = intf->altsetting->extralen;
936 struct usb_interface *control_interface;
937 struct usb_interface *data_interface;
938 struct usb_endpoint_descriptor *epctrl = NULL;
939 struct usb_endpoint_descriptor *epread = NULL;
940 struct usb_endpoint_descriptor *epwrite = NULL;
941 struct usb_device *usb_dev = interface_to_usbdev(intf);
942 struct acm *acm;
943 int minor;
944 int ctrlsize, readsize;
945 u8 *buf;
946 u8 ac_management_function = 0;
947 u8 call_management_function = 0;
948 int call_interface_num = -1;
949 int data_interface_num;
950 unsigned long quirks;
951 int num_rx_buf;
952 int i;
953 int combined_interfaces = 0;
954
955 /* normal quirks */
956 quirks = (unsigned long)id->driver_info;
957 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
958
959 /* handle quirks deadly to normal probing*/
960 if (quirks == NO_UNION_NORMAL) {
961 data_interface = usb_ifnum_to_if(usb_dev, 1);
962 control_interface = usb_ifnum_to_if(usb_dev, 0);
963 goto skip_normal_probe;
964 }
965
966 /* normal probing*/
967 if (!buffer) {
968 dev_err(&intf->dev, "Weird descriptor references\n");
969 return -EINVAL;
970 }
971
972 if (!buflen) {
973 if (intf->cur_altsetting->endpoint &&
974 intf->cur_altsetting->endpoint->extralen &&
975 intf->cur_altsetting->endpoint->extra) {
976 dev_dbg(&intf->dev,
977 "Seeking extra descriptors on endpoint\n");
978 buflen = intf->cur_altsetting->endpoint->extralen;
979 buffer = intf->cur_altsetting->endpoint->extra;
980 } else {
981 dev_err(&intf->dev,
982 "Zero length descriptor references\n");
983 return -EINVAL;
984 }
985 }
986
987 while (buflen > 0) {
988 if (buffer[1] != USB_DT_CS_INTERFACE) {
989 dev_err(&intf->dev, "skipping garbage\n");
990 goto next_desc;
991 }
992
993 switch (buffer[2]) {
994 case USB_CDC_UNION_TYPE: /* we've found it */
995 if (union_header) {
996 dev_err(&intf->dev, "More than one "
997 "union descriptor, skipping ...\n");
998 goto next_desc;
999 }
1000 union_header = (struct usb_cdc_union_desc *)buffer;
1001 break;
1002 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1003 cfd = (struct usb_cdc_country_functional_desc *)buffer;
1004 break;
1005 case USB_CDC_HEADER_TYPE: /* maybe check version */
1006 break; /* for now we ignore it */
1007 case USB_CDC_ACM_TYPE:
1008 ac_management_function = buffer[3];
1009 break;
1010 case USB_CDC_CALL_MANAGEMENT_TYPE:
1011 call_management_function = buffer[3];
1012 call_interface_num = buffer[4];
1013 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1014 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1015 break;
1016 default:
1017 /* there are LOTS more CDC descriptors that
1018 * could legitimately be found here.
1019 */
1020 dev_dbg(&intf->dev, "Ignoring descriptor: "
1021 "type %02x, length %d\n",
1022 buffer[2], buffer[0]);
1023 break;
1024 }
1025 next_desc:
1026 buflen -= buffer[0];
1027 buffer += buffer[0];
1028 }
1029
1030 if (!union_header) {
1031 if (call_interface_num > 0) {
1032 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
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 return -EINVAL;
1119
1120 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1121 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1122 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1123
1124
1125 /* workaround for switched endpoints */
1126 if (!usb_endpoint_dir_in(epread)) {
1127 /* descriptors are swapped */
1128 struct usb_endpoint_descriptor *t;
1129 dev_dbg(&intf->dev,
1130 "The data interface has switched endpoints\n");
1131 t = epread;
1132 epread = epwrite;
1133 epwrite = t;
1134 }
1135 made_compressed_probe:
1136 dbg("interfaces are valid");
1137 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1138
1139 if (minor == ACM_TTY_MINORS) {
1140 dev_err(&intf->dev, "no more free acm devices\n");
1141 return -ENODEV;
1142 }
1143
1144 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1145 if (acm == NULL) {
1146 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1147 goto alloc_fail;
1148 }
1149
1150 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1151 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1152 (quirks == SINGLE_RX_URB ? 1 : 2);
1153 acm->combined_interfaces = combined_interfaces;
1154 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1155 acm->control = control_interface;
1156 acm->data = data_interface;
1157 acm->minor = minor;
1158 acm->dev = usb_dev;
1159 acm->ctrl_caps = ac_management_function;
1160 if (quirks & NO_CAP_LINE)
1161 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1162 acm->ctrlsize = ctrlsize;
1163 acm->readsize = readsize;
1164 acm->rx_buflimit = num_rx_buf;
1165 acm->urb_task.func = acm_rx_tasklet;
1166 acm->urb_task.data = (unsigned long) acm;
1167 INIT_WORK(&acm->work, acm_softint);
1168 init_waitqueue_head(&acm->drain_wait);
1169 spin_lock_init(&acm->throttle_lock);
1170 spin_lock_init(&acm->write_lock);
1171 spin_lock_init(&acm->read_lock);
1172 mutex_init(&acm->mutex);
1173 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1174 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1175 if (acm->is_int_ep)
1176 acm->bInterval = epread->bInterval;
1177 tty_port_init(&acm->port);
1178 acm->port.ops = &acm_port_ops;
1179
1180 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1181 if (!buf) {
1182 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1183 goto alloc_fail2;
1184 }
1185 acm->ctrl_buffer = buf;
1186
1187 if (acm_write_buffers_alloc(acm) < 0) {
1188 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1189 goto alloc_fail4;
1190 }
1191
1192 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1193 if (!acm->ctrlurb) {
1194 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1195 goto alloc_fail5;
1196 }
1197 for (i = 0; i < num_rx_buf; i++) {
1198 struct acm_ru *rcv = &(acm->ru[i]);
1199
1200 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1201 if (rcv->urb == NULL) {
1202 dev_dbg(&intf->dev,
1203 "out of memory (read urbs usb_alloc_urb)\n");
1204 goto alloc_fail6;
1205 }
1206
1207 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1208 rcv->instance = acm;
1209 }
1210 for (i = 0; i < num_rx_buf; i++) {
1211 struct acm_rb *rb = &(acm->rb[i]);
1212
1213 rb->base = usb_alloc_coherent(acm->dev, readsize,
1214 GFP_KERNEL, &rb->dma);
1215 if (!rb->base) {
1216 dev_dbg(&intf->dev,
1217 "out of memory (read bufs usb_alloc_coherent)\n");
1218 goto alloc_fail7;
1219 }
1220 }
1221 for (i = 0; i < ACM_NW; i++) {
1222 struct acm_wb *snd = &(acm->wb[i]);
1223
1224 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1225 if (snd->urb == NULL) {
1226 dev_dbg(&intf->dev,
1227 "out of memory (write urbs usb_alloc_urb)");
1228 goto alloc_fail8;
1229 }
1230
1231 if (usb_endpoint_xfer_int(epwrite))
1232 usb_fill_int_urb(snd->urb, usb_dev,
1233 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1234 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1235 else
1236 usb_fill_bulk_urb(snd->urb, usb_dev,
1237 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1238 NULL, acm->writesize, acm_write_bulk, snd);
1239 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1240 snd->instance = acm;
1241 }
1242
1243 usb_set_intfdata(intf, acm);
1244
1245 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1246 if (i < 0)
1247 goto alloc_fail8;
1248
1249 if (cfd) { /* export the country data */
1250 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1251 if (!acm->country_codes)
1252 goto skip_countries;
1253 acm->country_code_size = cfd->bLength - 4;
1254 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1255 cfd->bLength - 4);
1256 acm->country_rel_date = cfd->iCountryCodeRelDate;
1257
1258 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1259 if (i < 0) {
1260 kfree(acm->country_codes);
1261 goto skip_countries;
1262 }
1263
1264 i = device_create_file(&intf->dev,
1265 &dev_attr_iCountryCodeRelDate);
1266 if (i < 0) {
1267 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1268 kfree(acm->country_codes);
1269 goto skip_countries;
1270 }
1271 }
1272
1273 skip_countries:
1274 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1275 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1276 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1277 /* works around buggy devices */
1278 epctrl->bInterval ? epctrl->bInterval : 0xff);
1279 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1280 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1281
1282 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1283
1284 acm_set_control(acm, acm->ctrlout);
1285
1286 acm->line.dwDTERate = cpu_to_le32(9600);
1287 acm->line.bDataBits = 8;
1288 acm_set_line(acm, &acm->line);
1289
1290 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1291 usb_set_intfdata(data_interface, acm);
1292
1293 usb_get_intf(control_interface);
1294 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1295
1296 acm_table[minor] = acm;
1297
1298 return 0;
1299 alloc_fail8:
1300 for (i = 0; i < ACM_NW; i++)
1301 usb_free_urb(acm->wb[i].urb);
1302 alloc_fail7:
1303 acm_read_buffers_free(acm);
1304 alloc_fail6:
1305 for (i = 0; i < num_rx_buf; i++)
1306 usb_free_urb(acm->ru[i].urb);
1307 usb_free_urb(acm->ctrlurb);
1308 alloc_fail5:
1309 acm_write_buffers_free(acm);
1310 alloc_fail4:
1311 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1312 alloc_fail2:
1313 kfree(acm);
1314 alloc_fail:
1315 return -ENOMEM;
1316 }
1317
1318 static void stop_data_traffic(struct acm *acm)
1319 {
1320 int i;
1321 dbg("Entering stop_data_traffic");
1322
1323 tasklet_disable(&acm->urb_task);
1324
1325 usb_kill_urb(acm->ctrlurb);
1326 for (i = 0; i < ACM_NW; i++)
1327 usb_kill_urb(acm->wb[i].urb);
1328 for (i = 0; i < acm->rx_buflimit; i++)
1329 usb_kill_urb(acm->ru[i].urb);
1330
1331 tasklet_enable(&acm->urb_task);
1332
1333 cancel_work_sync(&acm->work);
1334 }
1335
1336 static void acm_disconnect(struct usb_interface *intf)
1337 {
1338 struct acm *acm = usb_get_intfdata(intf);
1339 struct usb_device *usb_dev = interface_to_usbdev(intf);
1340 struct tty_struct *tty;
1341
1342 /* sibling interface is already cleaning up */
1343 if (!acm)
1344 return;
1345
1346 mutex_lock(&open_mutex);
1347 if (acm->country_codes) {
1348 device_remove_file(&acm->control->dev,
1349 &dev_attr_wCountryCodes);
1350 device_remove_file(&acm->control->dev,
1351 &dev_attr_iCountryCodeRelDate);
1352 }
1353 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1354 acm->dev = NULL;
1355 usb_set_intfdata(acm->control, NULL);
1356 usb_set_intfdata(acm->data, NULL);
1357
1358 stop_data_traffic(acm);
1359
1360 acm_write_buffers_free(acm);
1361 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1362 acm->ctrl_dma);
1363 acm_read_buffers_free(acm);
1364
1365 if (!acm->combined_interfaces)
1366 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1367 acm->data : acm->control);
1368
1369 if (acm->port.count == 0) {
1370 acm_tty_unregister(acm);
1371 mutex_unlock(&open_mutex);
1372 return;
1373 }
1374
1375 mutex_unlock(&open_mutex);
1376 tty = tty_port_tty_get(&acm->port);
1377 if (tty) {
1378 tty_hangup(tty);
1379 tty_kref_put(tty);
1380 }
1381 }
1382
1383 #ifdef CONFIG_PM
1384 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1385 {
1386 struct acm *acm = usb_get_intfdata(intf);
1387 int cnt;
1388
1389 if (message.event & PM_EVENT_AUTO) {
1390 int b;
1391
1392 spin_lock_irq(&acm->read_lock);
1393 spin_lock(&acm->write_lock);
1394 b = acm->processing + acm->transmitting;
1395 spin_unlock(&acm->write_lock);
1396 spin_unlock_irq(&acm->read_lock);
1397 if (b)
1398 return -EBUSY;
1399 }
1400
1401 spin_lock_irq(&acm->read_lock);
1402 spin_lock(&acm->write_lock);
1403 cnt = acm->susp_count++;
1404 spin_unlock(&acm->write_lock);
1405 spin_unlock_irq(&acm->read_lock);
1406
1407 if (cnt)
1408 return 0;
1409 /*
1410 we treat opened interfaces differently,
1411 we must guard against open
1412 */
1413 mutex_lock(&acm->mutex);
1414
1415 if (acm->port.count)
1416 stop_data_traffic(acm);
1417
1418 mutex_unlock(&acm->mutex);
1419 return 0;
1420 }
1421
1422 static int acm_resume(struct usb_interface *intf)
1423 {
1424 struct acm *acm = usb_get_intfdata(intf);
1425 struct acm_wb *wb;
1426 int rv = 0;
1427 int cnt;
1428
1429 spin_lock_irq(&acm->read_lock);
1430 acm->susp_count -= 1;
1431 cnt = acm->susp_count;
1432 spin_unlock_irq(&acm->read_lock);
1433
1434 if (cnt)
1435 return 0;
1436
1437 mutex_lock(&acm->mutex);
1438 if (acm->port.count) {
1439 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1440
1441 spin_lock_irq(&acm->write_lock);
1442 if (acm->delayed_wb) {
1443 wb = acm->delayed_wb;
1444 acm->delayed_wb = NULL;
1445 spin_unlock_irq(&acm->write_lock);
1446 acm_start_wb(acm, wb);
1447 } else {
1448 spin_unlock_irq(&acm->write_lock);
1449 }
1450
1451 /*
1452 * delayed error checking because we must
1453 * do the write path at all cost
1454 */
1455 if (rv < 0)
1456 goto err_out;
1457
1458 tasklet_schedule(&acm->urb_task);
1459 }
1460
1461 err_out:
1462 mutex_unlock(&acm->mutex);
1463 return rv;
1464 }
1465
1466 static int acm_reset_resume(struct usb_interface *intf)
1467 {
1468 struct acm *acm = usb_get_intfdata(intf);
1469 struct tty_struct *tty;
1470
1471 mutex_lock(&acm->mutex);
1472 if (acm->port.count) {
1473 tty = tty_port_tty_get(&acm->port);
1474 if (tty) {
1475 tty_hangup(tty);
1476 tty_kref_put(tty);
1477 }
1478 }
1479 mutex_unlock(&acm->mutex);
1480 return acm_resume(intf);
1481 }
1482
1483 #endif /* CONFIG_PM */
1484
1485 #define NOKIA_PCSUITE_ACM_INFO(x) \
1486 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1487 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1488 USB_CDC_ACM_PROTO_VENDOR)
1489
1490 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1491 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1492 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1493 USB_CDC_ACM_PROTO_VENDOR)
1494
1495 /*
1496 * USB driver structure.
1497 */
1498
1499 static const struct usb_device_id acm_ids[] = {
1500 /* quirky and broken devices */
1501 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1502 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503 },
1504 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1505 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1506 },
1507 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1508 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1509 },
1510 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1511 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1512 },
1513 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1514 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1515 },
1516 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1517 .driver_info = SINGLE_RX_URB,
1518 },
1519 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1520 .driver_info = SINGLE_RX_URB, /* firmware bug */
1521 },
1522 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1523 .driver_info = SINGLE_RX_URB, /* firmware bug */
1524 },
1525 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1526 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1527 },
1528 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1529 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1530 },
1531 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1532 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1533 },
1534 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1535 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1536 },
1537 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1538 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1539 },
1540 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1541 },
1542 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1543 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1544 data interface instead of
1545 communications interface.
1546 Maybe we should define a new
1547 quirk for this. */
1548 },
1549 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1550 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1551 },
1552 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1553 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1554 },
1555
1556 /* Nokia S60 phones expose two ACM channels. The first is
1557 * a modem and is picked up by the standard AT-command
1558 * information below. The second is 'vendor-specific' but
1559 * is treated as a serial device at the S60 end, so we want
1560 * to expose it on Linux too. */
1561 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1563 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1567 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1570 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1573 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1575 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1576 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1578 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1579 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1580 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1581 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1582 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1583 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1584 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1585 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1586 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1587 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1590 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1591 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1592 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1593 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1594 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1595 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1596 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1597 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1598 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1599 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1602 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1603 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1606 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1607 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1608 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1609 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1610 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1611 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1612 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1613 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1614 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1615 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1616 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1617
1618 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1619
1620 /* Support Lego NXT using pbLua firmware */
1621 { USB_DEVICE(0x0694, 0xff00),
1622 .driver_info = NOT_A_MODEM,
1623 },
1624
1625 /* control interfaces without any protocol set */
1626 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1627 USB_CDC_PROTO_NONE) },
1628
1629 /* control interfaces with various AT-command sets */
1630 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1631 USB_CDC_ACM_PROTO_AT_V25TER) },
1632 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1633 USB_CDC_ACM_PROTO_AT_PCCA101) },
1634 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1635 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1636 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1637 USB_CDC_ACM_PROTO_AT_GSM) },
1638 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1639 USB_CDC_ACM_PROTO_AT_3G) },
1640 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1641 USB_CDC_ACM_PROTO_AT_CDMA) },
1642
1643 { }
1644 };
1645
1646 MODULE_DEVICE_TABLE(usb, acm_ids);
1647
1648 static struct usb_driver acm_driver = {
1649 .name = "cdc_acm",
1650 .probe = acm_probe,
1651 .disconnect = acm_disconnect,
1652 #ifdef CONFIG_PM
1653 .suspend = acm_suspend,
1654 .resume = acm_resume,
1655 .reset_resume = acm_reset_resume,
1656 #endif
1657 .id_table = acm_ids,
1658 #ifdef CONFIG_PM
1659 .supports_autosuspend = 1,
1660 #endif
1661 };
1662
1663 /*
1664 * TTY driver structures.
1665 */
1666
1667 static const struct tty_operations acm_ops = {
1668 .open = acm_tty_open,
1669 .close = acm_tty_close,
1670 .hangup = acm_tty_hangup,
1671 .write = acm_tty_write,
1672 .write_room = acm_tty_write_room,
1673 .ioctl = acm_tty_ioctl,
1674 .throttle = acm_tty_throttle,
1675 .unthrottle = acm_tty_unthrottle,
1676 .chars_in_buffer = acm_tty_chars_in_buffer,
1677 .break_ctl = acm_tty_break_ctl,
1678 .set_termios = acm_tty_set_termios,
1679 .tiocmget = acm_tty_tiocmget,
1680 .tiocmset = acm_tty_tiocmset,
1681 };
1682
1683 /*
1684 * Init / exit.
1685 */
1686
1687 static int __init acm_init(void)
1688 {
1689 int retval;
1690 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1691 if (!acm_tty_driver)
1692 return -ENOMEM;
1693 acm_tty_driver->owner = THIS_MODULE,
1694 acm_tty_driver->driver_name = "acm",
1695 acm_tty_driver->name = "ttyACM",
1696 acm_tty_driver->major = ACM_TTY_MAJOR,
1697 acm_tty_driver->minor_start = 0,
1698 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1699 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1700 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1701 acm_tty_driver->init_termios = tty_std_termios;
1702 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1703 HUPCL | CLOCAL;
1704 tty_set_operations(acm_tty_driver, &acm_ops);
1705
1706 retval = tty_register_driver(acm_tty_driver);
1707 if (retval) {
1708 put_tty_driver(acm_tty_driver);
1709 return retval;
1710 }
1711
1712 retval = usb_register(&acm_driver);
1713 if (retval) {
1714 tty_unregister_driver(acm_tty_driver);
1715 put_tty_driver(acm_tty_driver);
1716 return retval;
1717 }
1718
1719 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1720 DRIVER_DESC "\n");
1721
1722 return 0;
1723 }
1724
1725 static void __exit acm_exit(void)
1726 {
1727 usb_deregister(&acm_driver);
1728 tty_unregister_driver(acm_tty_driver);
1729 put_tty_driver(acm_tty_driver);
1730 }
1731
1732 module_init(acm_init);
1733 module_exit(acm_exit);
1734
1735 MODULE_AUTHOR(DRIVER_AUTHOR);
1736 MODULE_DESCRIPTION(DRIVER_DESC);
1737 MODULE_LICENSE("GPL");
1738 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree