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 kmalloced
20 * v0.13 - added termios, added hangup
21 * v0.14 - sized down struct acm
22 * v0.15 - fixed flow control again - characters could be lost
23 * v0.16 - added code for modems with swapped data and control interfaces
24 * v0.17 - added new style probing
25 * v0.18 - fixed new style probing for devices with more configurations
26 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
27 * v0.20 - switched to probing on interface (rather than device) class
28 * v0.21 - revert to probing on device for devices with multiple configs
29 * v0.22 - probe only the control interface. if usbcore doesn't choose the
30 * config we want, sysadmin changes bConfigurationValue in sysfs.
31 * v0.23 - use softirq for rx processing, as needed by tty layer
32 * v0.24 - change probe method to evaluate CDC union descriptor
33 * v0.25 - downstream tasks paralelized to maximize throughput
34 */
35
36 /*
37 * This program is free software; you can redistribute it and/or modify
38 * it under the terms of the GNU General Public License as published by
39 * the Free Software Foundation; either version 2 of the License, or
40 * (at your option) any later version.
41 *
42 * This program is distributed in the hope that it will be useful,
43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 * GNU General Public License for more details.
46 *
47 * You should have received a copy of the GNU General Public License
48 * along with this program; if not, write to the Free Software
49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
50 */
51
52 #undef DEBUG
53
54 #include <linux/kernel.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/tty.h>
59 #include <linux/tty_driver.h>
60 #include <linux/tty_flip.h>
61 #include <linux/module.h>
62 #include <linux/mutex.h>
63 #include <asm/uaccess.h>
64 #include <linux/usb.h>
65 #include <linux/usb/cdc.h>
66 #include <asm/byteorder.h>
67 #include <asm/unaligned.h>
68 #include <linux/list.h>
69
70 #include "cdc-acm.h"
71
72 /*
73 * Version Information
74 */
75 #define DRIVER_VERSION "v0.25"
76 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
77 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
78
79 static struct usb_driver acm_driver;
80 static struct tty_driver *acm_tty_driver;
81 static struct acm *acm_table[ACM_TTY_MINORS];
82
83 static DEFINE_MUTEX(open_mutex);
84
85 #define ACM_READY(acm) (acm && acm->dev && acm->used)
86
87 /*
88 * Functions for ACM control messages.
89 */
90
91 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
92 {
93 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
94 request, USB_RT_ACM, value,
95 acm->control->altsetting[0].desc.bInterfaceNumber,
96 buf, len, 5000);
97 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
98 return retval < 0 ? retval : 0;
99 }
100
101 /* devices aren't required to support these requests.
102 * the cdc acm descriptor tells whether they do...
103 */
104 #define acm_set_control(acm, control) \
105 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
106 #define acm_set_line(acm, line) \
107 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
108 #define acm_send_break(acm, ms) \
109 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
110
111 /*
112 * Write buffer management.
113 * All of these assume proper locks taken by the caller.
114 */
115
116 static int acm_wb_alloc(struct acm *acm)
117 {
118 int i, wbn;
119 struct acm_wb *wb;
120
121 wbn = acm->write_current;
122 i = 0;
123 for (;;) {
124 wb = &acm->wb[wbn];
125 if (!wb->use) {
126 wb->use = 1;
127 return wbn;
128 }
129 wbn = (wbn + 1) % ACM_NW;
130 if (++i >= ACM_NW)
131 return -1;
132 }
133 }
134
135 static void acm_wb_free(struct acm *acm, int wbn)
136 {
137 acm->wb[wbn].use = 0;
138 }
139
140 static int acm_wb_is_avail(struct acm *acm)
141 {
142 int i, n;
143
144 n = ACM_NW;
145 for (i = 0; i < ACM_NW; i++) {
146 n -= acm->wb[i].use;
147 }
148 return n;
149 }
150
151 static inline int acm_wb_is_used(struct acm *acm, int wbn)
152 {
153 return acm->wb[wbn].use;
154 }
155
156 /*
157 * Finish write.
158 */
159 static void acm_write_done(struct acm *acm)
160 {
161 unsigned long flags;
162 int wbn;
163
164 spin_lock_irqsave(&acm->write_lock, flags);
165 acm->write_ready = 1;
166 wbn = acm->write_current;
167 acm_wb_free(acm, wbn);
168 acm->write_current = (wbn + 1) % ACM_NW;
169 spin_unlock_irqrestore(&acm->write_lock, flags);
170 }
171
172 /*
173 * Poke write.
174 */
175 static int acm_write_start(struct acm *acm)
176 {
177 unsigned long flags;
178 int wbn;
179 struct acm_wb *wb;
180 int rc;
181
182 spin_lock_irqsave(&acm->write_lock, flags);
183 if (!acm->dev) {
184 spin_unlock_irqrestore(&acm->write_lock, flags);
185 return -ENODEV;
186 }
187
188 if (!acm->write_ready) {
189 spin_unlock_irqrestore(&acm->write_lock, flags);
190 return 0; /* A white lie */
191 }
192
193 wbn = acm->write_current;
194 if (!acm_wb_is_used(acm, wbn)) {
195 spin_unlock_irqrestore(&acm->write_lock, flags);
196 return 0;
197 }
198 wb = &acm->wb[wbn];
199
200 acm->write_ready = 0;
201 spin_unlock_irqrestore(&acm->write_lock, flags);
202
203 acm->writeurb->transfer_buffer = wb->buf;
204 acm->writeurb->transfer_dma = wb->dmah;
205 acm->writeurb->transfer_buffer_length = wb->len;
206 acm->writeurb->dev = acm->dev;
207
208 if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
209 dbg("usb_submit_urb(write bulk) failed: %d", rc);
210 acm_write_done(acm);
211 }
212 return rc;
213 }
214 /*
215 * attributes exported through sysfs
216 */
217 static ssize_t show_caps
218 (struct device *dev, struct device_attribute *attr, char *buf)
219 {
220 struct usb_interface *intf = to_usb_interface(dev);
221 struct acm *acm = usb_get_intfdata(intf);
222
223 return sprintf(buf, "%d", acm->ctrl_caps);
224 }
225 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
226
227 static ssize_t show_country_codes
228 (struct device *dev, struct device_attribute *attr, char *buf)
229 {
230 struct usb_interface *intf = to_usb_interface(dev);
231 struct acm *acm = usb_get_intfdata(intf);
232
233 memcpy(buf, acm->country_codes, acm->country_code_size);
234 return acm->country_code_size;
235 }
236
237 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
238
239 static ssize_t show_country_rel_date
240 (struct device *dev, struct device_attribute *attr, char *buf)
241 {
242 struct usb_interface *intf = to_usb_interface(dev);
243 struct acm *acm = usb_get_intfdata(intf);
244
245 return sprintf(buf, "%d", acm->country_rel_date);
246 }
247
248 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
249 /*
250 * Interrupt handlers for various ACM device responses
251 */
252
253 /* control interface reports status changes with "interrupt" transfers */
254 static void acm_ctrl_irq(struct urb *urb)
255 {
256 struct acm *acm = urb->context;
257 struct usb_cdc_notification *dr = urb->transfer_buffer;
258 unsigned char *data;
259 int newctrl;
260 int retval;
261 int status = urb->status;
262
263 switch (status) {
264 case 0:
265 /* success */
266 break;
267 case -ECONNRESET:
268 case -ENOENT:
269 case -ESHUTDOWN:
270 /* this urb is terminated, clean up */
271 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
272 return;
273 default:
274 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
275 goto exit;
276 }
277
278 if (!ACM_READY(acm))
279 goto exit;
280
281 data = (unsigned char *)(dr + 1);
282 switch (dr->bNotificationType) {
283
284 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
285
286 dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
287 break;
288
289 case USB_CDC_NOTIFY_SERIAL_STATE:
290
291 newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
292
293 if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
294 dbg("calling hangup");
295 tty_hangup(acm->tty);
296 }
297
298 acm->ctrlin = newctrl;
299
300 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
301 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
302 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
303 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
304 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
305
306 break;
307
308 default:
309 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
310 dr->bNotificationType, dr->wIndex,
311 dr->wLength, data[0], data[1]);
312 break;
313 }
314 exit:
315 retval = usb_submit_urb (urb, GFP_ATOMIC);
316 if (retval)
317 err ("%s - usb_submit_urb failed with result %d",
318 __FUNCTION__, retval);
319 }
320
321 /* data interface returns incoming bytes, or we got unthrottled */
322 static void acm_read_bulk(struct urb *urb)
323 {
324 struct acm_rb *buf;
325 struct acm_ru *rcv = urb->context;
326 struct acm *acm = rcv->instance;
327 int status = urb->status;
328
329 dbg("Entering acm_read_bulk with status %d", status);
330
331 if (!ACM_READY(acm))
332 return;
333
334 if (status)
335 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
336
337 buf = rcv->buffer;
338 buf->size = urb->actual_length;
339
340 if (likely(status == 0)) {
341 spin_lock(&acm->read_lock);
342 list_add_tail(&rcv->list, &acm->spare_read_urbs);
343 list_add_tail(&buf->list, &acm->filled_read_bufs);
344 spin_unlock(&acm->read_lock);
345 } else {
346 /* we drop the buffer due to an error */
347 spin_lock(&acm->read_lock);
348 list_add_tail(&rcv->list, &acm->spare_read_urbs);
349 list_add(&buf->list, &acm->spare_read_bufs);
350 spin_unlock(&acm->read_lock);
351 /* nevertheless the tasklet must be kicked unconditionally
352 so the queue cannot dry up */
353 }
354 tasklet_schedule(&acm->urb_task);
355 }
356
357 static void acm_rx_tasklet(unsigned long _acm)
358 {
359 struct acm *acm = (void *)_acm;
360 struct acm_rb *buf;
361 struct tty_struct *tty = acm->tty;
362 struct acm_ru *rcv;
363 unsigned long flags;
364 unsigned char throttled;
365 dbg("Entering acm_rx_tasklet");
366
367 if (!ACM_READY(acm))
368 return;
369
370 spin_lock_irqsave(&acm->throttle_lock, flags);
371 throttled = acm->throttle;
372 spin_unlock_irqrestore(&acm->throttle_lock, flags);
373 if (throttled)
374 return;
375
376 next_buffer:
377 spin_lock_irqsave(&acm->read_lock, flags);
378 if (list_empty(&acm->filled_read_bufs)) {
379 spin_unlock_irqrestore(&acm->read_lock, flags);
380 goto urbs;
381 }
382 buf = list_entry(acm->filled_read_bufs.next,
383 struct acm_rb, list);
384 list_del(&buf->list);
385 spin_unlock_irqrestore(&acm->read_lock, flags);
386
387 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
388
389 tty_buffer_request_room(tty, buf->size);
390 spin_lock_irqsave(&acm->throttle_lock, flags);
391 throttled = acm->throttle;
392 spin_unlock_irqrestore(&acm->throttle_lock, flags);
393 if (!throttled)
394 tty_insert_flip_string(tty, buf->base, buf->size);
395 tty_flip_buffer_push(tty);
396
397 if (throttled) {
398 dbg("Throttling noticed");
399 spin_lock_irqsave(&acm->read_lock, flags);
400 list_add(&buf->list, &acm->filled_read_bufs);
401 spin_unlock_irqrestore(&acm->read_lock, flags);
402 return;
403 }
404
405 spin_lock_irqsave(&acm->read_lock, flags);
406 list_add(&buf->list, &acm->spare_read_bufs);
407 spin_unlock_irqrestore(&acm->read_lock, flags);
408 goto next_buffer;
409
410 urbs:
411 while (!list_empty(&acm->spare_read_bufs)) {
412 spin_lock_irqsave(&acm->read_lock, flags);
413 if (list_empty(&acm->spare_read_urbs)) {
414 spin_unlock_irqrestore(&acm->read_lock, flags);
415 return;
416 }
417 rcv = list_entry(acm->spare_read_urbs.next,
418 struct acm_ru, list);
419 list_del(&rcv->list);
420 spin_unlock_irqrestore(&acm->read_lock, flags);
421
422 buf = list_entry(acm->spare_read_bufs.next,
423 struct acm_rb, list);
424 list_del(&buf->list);
425
426 rcv->buffer = buf;
427
428 usb_fill_bulk_urb(rcv->urb, acm->dev,
429 acm->rx_endpoint,
430 buf->base,
431 acm->readsize,
432 acm_read_bulk, rcv);
433 rcv->urb->transfer_dma = buf->dma;
434 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
435
436 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
437
438 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
439 free-urbs-pool and resubmited ASAP */
440 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
441 list_add(&buf->list, &acm->spare_read_bufs);
442 spin_lock_irqsave(&acm->read_lock, flags);
443 list_add(&rcv->list, &acm->spare_read_urbs);
444 spin_unlock_irqrestore(&acm->read_lock, flags);
445 return;
446 }
447 }
448 }
449
450 /* data interface wrote those outgoing bytes */
451 static void acm_write_bulk(struct urb *urb)
452 {
453 struct acm *acm = (struct acm *)urb->context;
454
455 dbg("Entering acm_write_bulk with status %d", urb->status);
456
457 acm_write_done(acm);
458 acm_write_start(acm);
459 if (ACM_READY(acm))
460 schedule_work(&acm->work);
461 }
462
463 static void acm_softint(struct work_struct *work)
464 {
465 struct acm *acm = container_of(work, struct acm, work);
466 dbg("Entering acm_softint.");
467
468 if (!ACM_READY(acm))
469 return;
470 tty_wakeup(acm->tty);
471 }
472
473 /*
474 * TTY handlers
475 */
476
477 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
478 {
479 struct acm *acm;
480 int rv = -EINVAL;
481 int i;
482 dbg("Entering acm_tty_open.");
483
484 mutex_lock(&open_mutex);
485
486 acm = acm_table[tty->index];
487 if (!acm || !acm->dev)
488 goto err_out;
489 else
490 rv = 0;
491
492 tty->driver_data = acm;
493 acm->tty = tty;
494
495 /* force low_latency on so that our tty_push actually forces the data through,
496 otherwise it is scheduled, and with high data rates data can get lost. */
497 tty->low_latency = 1;
498
499 if (usb_autopm_get_interface(acm->control) < 0)
500 goto early_bail;
501
502 mutex_lock(&acm->mutex);
503 if (acm->used++) {
504 usb_autopm_put_interface(acm->control);
505 goto done;
506 }
507
508
509 acm->ctrlurb->dev = acm->dev;
510 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
511 dbg("usb_submit_urb(ctrl irq) failed");
512 goto bail_out;
513 }
514
515 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
516 (acm->ctrl_caps & USB_CDC_CAP_LINE))
517 goto full_bailout;
518
519 INIT_LIST_HEAD(&acm->spare_read_urbs);
520 INIT_LIST_HEAD(&acm->spare_read_bufs);
521 INIT_LIST_HEAD(&acm->filled_read_bufs);
522 for (i = 0; i < acm->rx_buflimit; i++) {
523 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
524 }
525 for (i = 0; i < acm->rx_buflimit; i++) {
526 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
527 }
528
529 acm->throttle = 0;
530
531 tasklet_schedule(&acm->urb_task);
532
533 done:
534 err_out:
535 mutex_unlock(&acm->mutex);
536 mutex_unlock(&open_mutex);
537 return rv;
538
539 full_bailout:
540 usb_kill_urb(acm->ctrlurb);
541 bail_out:
542 usb_autopm_put_interface(acm->control);
543 acm->used--;
544 mutex_unlock(&acm->mutex);
545 early_bail:
546 mutex_unlock(&open_mutex);
547 return -EIO;
548 }
549
550 static void acm_tty_unregister(struct acm *acm)
551 {
552 int i,nr;
553
554 nr = acm->rx_buflimit;
555 tty_unregister_device(acm_tty_driver, acm->minor);
556 usb_put_intf(acm->control);
557 acm_table[acm->minor] = NULL;
558 usb_free_urb(acm->ctrlurb);
559 usb_free_urb(acm->writeurb);
560 for (i = 0; i < nr; i++)
561 usb_free_urb(acm->ru[i].urb);
562 kfree(acm->country_codes);
563 kfree(acm);
564 }
565
566 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
567 {
568 struct acm *acm = tty->driver_data;
569 int i,nr;
570
571 if (!acm || !acm->used)
572 return;
573
574 nr = acm->rx_buflimit;
575 mutex_lock(&open_mutex);
576 if (!--acm->used) {
577 if (acm->dev) {
578 acm_set_control(acm, acm->ctrlout = 0);
579 usb_kill_urb(acm->ctrlurb);
580 usb_kill_urb(acm->writeurb);
581 for (i = 0; i < nr; i++)
582 usb_kill_urb(acm->ru[i].urb);
583 usb_autopm_put_interface(acm->control);
584 } else
585 acm_tty_unregister(acm);
586 }
587 mutex_unlock(&open_mutex);
588 }
589
590 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
591 {
592 struct acm *acm = tty->driver_data;
593 int stat;
594 unsigned long flags;
595 int wbn;
596 struct acm_wb *wb;
597
598 dbg("Entering acm_tty_write to write %d bytes,", count);
599
600 if (!ACM_READY(acm))
601 return -EINVAL;
602 if (!count)
603 return 0;
604
605 spin_lock_irqsave(&acm->write_lock, flags);
606 if ((wbn = acm_wb_alloc(acm)) < 0) {
607 spin_unlock_irqrestore(&acm->write_lock, flags);
608 acm_write_start(acm);
609 return 0;
610 }
611 wb = &acm->wb[wbn];
612
613 count = (count > acm->writesize) ? acm->writesize : count;
614 dbg("Get %d bytes...", count);
615 memcpy(wb->buf, buf, count);
616 wb->len = count;
617 spin_unlock_irqrestore(&acm->write_lock, flags);
618
619 if ((stat = acm_write_start(acm)) < 0)
620 return stat;
621 return count;
622 }
623
624 static int acm_tty_write_room(struct tty_struct *tty)
625 {
626 struct acm *acm = tty->driver_data;
627 if (!ACM_READY(acm))
628 return -EINVAL;
629 /*
630 * Do not let the line discipline to know that we have a reserve,
631 * or it might get too enthusiastic.
632 */
633 return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
634 }
635
636 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
637 {
638 struct acm *acm = tty->driver_data;
639 if (!ACM_READY(acm))
640 return -EINVAL;
641 /*
642 * This is inaccurate (overcounts), but it works.
643 */
644 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
645 }
646
647 static void acm_tty_throttle(struct tty_struct *tty)
648 {
649 struct acm *acm = tty->driver_data;
650 if (!ACM_READY(acm))
651 return;
652 spin_lock_bh(&acm->throttle_lock);
653 acm->throttle = 1;
654 spin_unlock_bh(&acm->throttle_lock);
655 }
656
657 static void acm_tty_unthrottle(struct tty_struct *tty)
658 {
659 struct acm *acm = tty->driver_data;
660 if (!ACM_READY(acm))
661 return;
662 spin_lock_bh(&acm->throttle_lock);
663 acm->throttle = 0;
664 spin_unlock_bh(&acm->throttle_lock);
665 tasklet_schedule(&acm->urb_task);
666 }
667
668 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
669 {
670 struct acm *acm = tty->driver_data;
671 if (!ACM_READY(acm))
672 return;
673 if (acm_send_break(acm, state ? 0xffff : 0))
674 dbg("send break failed");
675 }
676
677 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
678 {
679 struct acm *acm = tty->driver_data;
680
681 if (!ACM_READY(acm))
682 return -EINVAL;
683
684 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
685 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
686 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
687 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
688 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
689 TIOCM_CTS;
690 }
691
692 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
693 unsigned int set, unsigned int clear)
694 {
695 struct acm *acm = tty->driver_data;
696 unsigned int newctrl;
697
698 if (!ACM_READY(acm))
699 return -EINVAL;
700
701 newctrl = acm->ctrlout;
702 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
703 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
704
705 newctrl = (newctrl & ~clear) | set;
706
707 if (acm->ctrlout == newctrl)
708 return 0;
709 return acm_set_control(acm, acm->ctrlout = newctrl);
710 }
711
712 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
713 {
714 struct acm *acm = tty->driver_data;
715
716 if (!ACM_READY(acm))
717 return -EINVAL;
718
719 return -ENOIOCTLCMD;
720 }
721
722 static const __u32 acm_tty_speed[] = {
723 0, 50, 75, 110, 134, 150, 200, 300, 600,
724 1200, 1800, 2400, 4800, 9600, 19200, 38400,
725 57600, 115200, 230400, 460800, 500000, 576000,
726 921600, 1000000, 1152000, 1500000, 2000000,
727 2500000, 3000000, 3500000, 4000000
728 };
729
730 static const __u8 acm_tty_size[] = {
731 5, 6, 7, 8
732 };
733
734 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
735 {
736 struct acm *acm = tty->driver_data;
737 struct ktermios *termios = tty->termios;
738 struct usb_cdc_line_coding newline;
739 int newctrl = acm->ctrlout;
740
741 if (!ACM_READY(acm))
742 return;
743
744 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
745 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
746 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
747 newline.bParityType = termios->c_cflag & PARENB ?
748 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
749 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
750
751 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
752
753 if (!newline.dwDTERate) {
754 newline.dwDTERate = acm->line.dwDTERate;
755 newctrl &= ~ACM_CTRL_DTR;
756 } else newctrl |= ACM_CTRL_DTR;
757
758 if (newctrl != acm->ctrlout)
759 acm_set_control(acm, acm->ctrlout = newctrl);
760
761 if (memcmp(&acm->line, &newline, sizeof newline)) {
762 memcpy(&acm->line, &newline, sizeof newline);
763 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
764 newline.bCharFormat, newline.bParityType,
765 newline.bDataBits);
766 acm_set_line(acm, &acm->line);
767 }
768 }
769
770 /*
771 * USB probe and disconnect routines.
772 */
773
774 /* Little helper: write buffers free */
775 static void acm_write_buffers_free(struct acm *acm)
776 {
777 int i;
778 struct acm_wb *wb;
779
780 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
781 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
782 }
783 }
784
785 /* Little helper: write buffers allocate */
786 static int acm_write_buffers_alloc(struct acm *acm)
787 {
788 int i;
789 struct acm_wb *wb;
790
791 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
792 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
793 &wb->dmah);
794 if (!wb->buf) {
795 while (i != 0) {
796 --i;
797 --wb;
798 usb_buffer_free(acm->dev, acm->writesize,
799 wb->buf, wb->dmah);
800 }
801 return -ENOMEM;
802 }
803 }
804 return 0;
805 }
806
807 static int acm_probe (struct usb_interface *intf,
808 const struct usb_device_id *id)
809 {
810 struct usb_cdc_union_desc *union_header = NULL;
811 struct usb_cdc_country_functional_desc *cfd = NULL;
812 char *buffer = intf->altsetting->extra;
813 int buflen = intf->altsetting->extralen;
814 struct usb_interface *control_interface;
815 struct usb_interface *data_interface;
816 struct usb_endpoint_descriptor *epctrl;
817 struct usb_endpoint_descriptor *epread;
818 struct usb_endpoint_descriptor *epwrite;
819 struct usb_device *usb_dev = interface_to_usbdev(intf);
820 struct acm *acm;
821 int minor;
822 int ctrlsize,readsize;
823 u8 *buf;
824 u8 ac_management_function = 0;
825 u8 call_management_function = 0;
826 int call_interface_num = -1;
827 int data_interface_num;
828 unsigned long quirks;
829 int num_rx_buf;
830 int i;
831
832 /* normal quirks */
833 quirks = (unsigned long)id->driver_info;
834 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
835
836 /* handle quirks deadly to normal probing*/
837 if (quirks == NO_UNION_NORMAL) {
838 data_interface = usb_ifnum_to_if(usb_dev, 1);
839 control_interface = usb_ifnum_to_if(usb_dev, 0);
840 goto skip_normal_probe;
841 }
842
843 /* normal probing*/
844 if (!buffer) {
845 err("Weird descriptor references\n");
846 return -EINVAL;
847 }
848
849 if (!buflen) {
850 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
851 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
852 buflen = intf->cur_altsetting->endpoint->extralen;
853 buffer = intf->cur_altsetting->endpoint->extra;
854 } else {
855 err("Zero length descriptor references\n");
856 return -EINVAL;
857 }
858 }
859
860 while (buflen > 0) {
861 if (buffer [1] != USB_DT_CS_INTERFACE) {
862 err("skipping garbage\n");
863 goto next_desc;
864 }
865
866 switch (buffer [2]) {
867 case USB_CDC_UNION_TYPE: /* we've found it */
868 if (union_header) {
869 err("More than one union descriptor, skipping ...");
870 goto next_desc;
871 }
872 union_header = (struct usb_cdc_union_desc *)
873 buffer;
874 break;
875 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
876 cfd = (struct usb_cdc_country_functional_desc *)buffer;
877 break;
878 case USB_CDC_HEADER_TYPE: /* maybe check version */
879 break; /* for now we ignore it */
880 case USB_CDC_ACM_TYPE:
881 ac_management_function = buffer[3];
882 break;
883 case USB_CDC_CALL_MANAGEMENT_TYPE:
884 call_management_function = buffer[3];
885 call_interface_num = buffer[4];
886 if ((call_management_function & 3) != 3)
887 err("This device cannot do calls on its own. It is no modem.");
888 break;
889
890 default:
891 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
892 break;
893 }
894 next_desc:
895 buflen -= buffer[0];
896 buffer += buffer[0];
897 }
898
899 if (!union_header) {
900 if (call_interface_num > 0) {
901 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
902 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
903 control_interface = intf;
904 } else {
905 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
906 return -ENODEV;
907 }
908 } else {
909 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
910 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
911 if (!control_interface || !data_interface) {
912 dev_dbg(&intf->dev,"no interfaces\n");
913 return -ENODEV;
914 }
915 }
916
917 if (data_interface_num != call_interface_num)
918 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
919
920 skip_normal_probe:
921
922 /*workaround for switched interfaces */
923 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
924 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
925 struct usb_interface *t;
926 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
927
928 t = control_interface;
929 control_interface = data_interface;
930 data_interface = t;
931 } else {
932 return -EINVAL;
933 }
934 }
935
936 /* Accept probe requests only for the control interface */
937 if (intf != control_interface)
938 return -ENODEV;
939
940 if (usb_interface_claimed(data_interface)) { /* valid in this context */
941 dev_dbg(&intf->dev,"The data interface isn't available\n");
942 return -EBUSY;
943 }
944
945
946 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
947 return -EINVAL;
948
949 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
950 epread = &data_interface->cur_altsetting->endpoint[0].desc;
951 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
952
953
954 /* workaround for switched endpoints */
955 if (!usb_endpoint_dir_in(epread)) {
956 /* descriptors are swapped */
957 struct usb_endpoint_descriptor *t;
958 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
959
960 t = epread;
961 epread = epwrite;
962 epwrite = t;
963 }
964 dbg("interfaces are valid");
965 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
966
967 if (minor == ACM_TTY_MINORS) {
968 err("no more free acm devices");
969 return -ENODEV;
970 }
971
972 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
973 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
974 goto alloc_fail;
975 }
976
977 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
978 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
979 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
980 acm->control = control_interface;
981 acm->data = data_interface;
982 acm->minor = minor;
983 acm->dev = usb_dev;
984 acm->ctrl_caps = ac_management_function;
985 acm->ctrlsize = ctrlsize;
986 acm->readsize = readsize;
987 acm->rx_buflimit = num_rx_buf;
988 acm->urb_task.func = acm_rx_tasklet;
989 acm->urb_task.data = (unsigned long) acm;
990 INIT_WORK(&acm->work, acm_softint);
991 spin_lock_init(&acm->throttle_lock);
992 spin_lock_init(&acm->write_lock);
993 spin_lock_init(&acm->read_lock);
994 mutex_init(&acm->mutex);
995 acm->write_ready = 1;
996 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
997
998 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
999 if (!buf) {
1000 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1001 goto alloc_fail2;
1002 }
1003 acm->ctrl_buffer = buf;
1004
1005 if (acm_write_buffers_alloc(acm) < 0) {
1006 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1007 goto alloc_fail4;
1008 }
1009
1010 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1011 if (!acm->ctrlurb) {
1012 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1013 goto alloc_fail5;
1014 }
1015 for (i = 0; i < num_rx_buf; i++) {
1016 struct acm_ru *rcv = &(acm->ru[i]);
1017
1018 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1019 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1020 goto alloc_fail7;
1021 }
1022
1023 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1024 rcv->instance = acm;
1025 }
1026 for (i = 0; i < num_rx_buf; i++) {
1027 struct acm_rb *buf = &(acm->rb[i]);
1028
1029 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
1030 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1031 goto alloc_fail7;
1032 }
1033 }
1034 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1035 if (!acm->writeurb) {
1036 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
1037 goto alloc_fail7;
1038 }
1039
1040 usb_set_intfdata (intf, acm);
1041
1042 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1043 if (i < 0)
1044 goto alloc_fail8;
1045
1046 if (cfd) { /* export the country data */
1047 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1048 if (!acm->country_codes)
1049 goto skip_countries;
1050 acm->country_code_size = cfd->bLength - 4;
1051 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1052 acm->country_rel_date = cfd->iCountryCodeRelDate;
1053
1054 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1055 if (i < 0) {
1056 kfree(acm->country_codes);
1057 goto skip_countries;
1058 }
1059
1060 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1061 if (i < 0) {
1062 kfree(acm->country_codes);
1063 goto skip_countries;
1064 }
1065 }
1066
1067 skip_countries:
1068 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1069 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1070 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1071 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1072
1073 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1074 NULL, acm->writesize, acm_write_bulk, acm);
1075 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1076
1077 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1078
1079 acm_set_control(acm, acm->ctrlout);
1080
1081 acm->line.dwDTERate = cpu_to_le32(9600);
1082 acm->line.bDataBits = 8;
1083 acm_set_line(acm, &acm->line);
1084
1085 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1086
1087 usb_get_intf(control_interface);
1088 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1089
1090 acm_table[minor] = acm;
1091
1092 return 0;
1093 alloc_fail8:
1094 usb_free_urb(acm->writeurb);
1095 alloc_fail7:
1096 for (i = 0; i < num_rx_buf; i++)
1097 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1098 for (i = 0; i < num_rx_buf; i++)
1099 usb_free_urb(acm->ru[i].urb);
1100 usb_free_urb(acm->ctrlurb);
1101 alloc_fail5:
1102 acm_write_buffers_free(acm);
1103 alloc_fail4:
1104 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1105 alloc_fail2:
1106 kfree(acm);
1107 alloc_fail:
1108 return -ENOMEM;
1109 }
1110
1111 static void stop_data_traffic(struct acm *acm)
1112 {
1113 int i;
1114
1115 tasklet_disable(&acm->urb_task);
1116
1117 usb_kill_urb(acm->ctrlurb);
1118 usb_kill_urb(acm->writeurb);
1119 for (i = 0; i < acm->rx_buflimit; i++)
1120 usb_kill_urb(acm->ru[i].urb);
1121
1122 INIT_LIST_HEAD(&acm->filled_read_bufs);
1123 INIT_LIST_HEAD(&acm->spare_read_bufs);
1124
1125 tasklet_enable(&acm->urb_task);
1126
1127 cancel_work_sync(&acm->work);
1128 }
1129
1130 static void acm_disconnect(struct usb_interface *intf)
1131 {
1132 struct acm *acm = usb_get_intfdata(intf);
1133 struct usb_device *usb_dev = interface_to_usbdev(intf);
1134 int i;
1135
1136 if (!acm || !acm->dev) {
1137 dbg("disconnect on nonexisting interface");
1138 return;
1139 }
1140
1141 mutex_lock(&open_mutex);
1142 if (!usb_get_intfdata(intf)) {
1143 mutex_unlock(&open_mutex);
1144 return;
1145 }
1146 if (acm->country_codes){
1147 device_remove_file(&acm->control->dev,
1148 &dev_attr_wCountryCodes);
1149 device_remove_file(&acm->control->dev,
1150 &dev_attr_iCountryCodeRelDate);
1151 }
1152 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1153 acm->dev = NULL;
1154 usb_set_intfdata(acm->control, NULL);
1155 usb_set_intfdata(acm->data, NULL);
1156
1157 stop_data_traffic(acm);
1158
1159 acm_write_buffers_free(acm);
1160 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1161 for (i = 0; i < acm->rx_buflimit; i++)
1162 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1163
1164 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1165
1166 if (!acm->used) {
1167 acm_tty_unregister(acm);
1168 mutex_unlock(&open_mutex);
1169 return;
1170 }
1171
1172 mutex_unlock(&open_mutex);
1173
1174 if (acm->tty)
1175 tty_hangup(acm->tty);
1176 }
1177
1178 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1179 {
1180 struct acm *acm = usb_get_intfdata(intf);
1181
1182 if (acm->susp_count++)
1183 return 0;
1184 /*
1185 we treat opened interfaces differently,
1186 we must guard against open
1187 */
1188 mutex_lock(&acm->mutex);
1189
1190 if (acm->used)
1191 stop_data_traffic(acm);
1192
1193 mutex_unlock(&acm->mutex);
1194 return 0;
1195 }
1196
1197 static int acm_resume(struct usb_interface *intf)
1198 {
1199 struct acm *acm = usb_get_intfdata(intf);
1200 int rv = 0;
1201
1202 if (--acm->susp_count)
1203 return 0;
1204
1205 mutex_lock(&acm->mutex);
1206 if (acm->used) {
1207 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1208 if (rv < 0)
1209 goto err_out;
1210
1211 tasklet_schedule(&acm->urb_task);
1212 }
1213
1214 err_out:
1215 mutex_unlock(&acm->mutex);
1216 return rv;
1217 }
1218 /*
1219 * USB driver structure.
1220 */
1221
1222 static struct usb_device_id acm_ids[] = {
1223 /* quirky and broken devices */
1224 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1225 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1226 },
1227 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1228 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1229 },
1230 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1231 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1232 },
1233 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1234 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1235 },
1236 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1237 .driver_info = SINGLE_RX_URB, /* firmware bug */
1238 },
1239 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1240 .driver_info = SINGLE_RX_URB, /* firmware bug */
1241 },
1242 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1243 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1244 },
1245 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1246 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1247 },
1248
1249 /* control interfaces with various AT-command sets */
1250 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1251 USB_CDC_ACM_PROTO_AT_V25TER) },
1252 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1253 USB_CDC_ACM_PROTO_AT_PCCA101) },
1254 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1255 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1256 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1257 USB_CDC_ACM_PROTO_AT_GSM) },
1258 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1259 USB_CDC_ACM_PROTO_AT_3G ) },
1260 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1261 USB_CDC_ACM_PROTO_AT_CDMA) },
1262
1263 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1264 { }
1265 };
1266
1267 MODULE_DEVICE_TABLE (usb, acm_ids);
1268
1269 static struct usb_driver acm_driver = {
1270 .name = "cdc_acm",
1271 .probe = acm_probe,
1272 .disconnect = acm_disconnect,
1273 .suspend = acm_suspend,
1274 .resume = acm_resume,
1275 .id_table = acm_ids,
1276 .supports_autosuspend = 1,
1277 };
1278
1279 /*
1280 * TTY driver structures.
1281 */
1282
1283 static const struct tty_operations acm_ops = {
1284 .open = acm_tty_open,
1285 .close = acm_tty_close,
1286 .write = acm_tty_write,
1287 .write_room = acm_tty_write_room,
1288 .ioctl = acm_tty_ioctl,
1289 .throttle = acm_tty_throttle,
1290 .unthrottle = acm_tty_unthrottle,
1291 .chars_in_buffer = acm_tty_chars_in_buffer,
1292 .break_ctl = acm_tty_break_ctl,
1293 .set_termios = acm_tty_set_termios,
1294 .tiocmget = acm_tty_tiocmget,
1295 .tiocmset = acm_tty_tiocmset,
1296 };
1297
1298 /*
1299 * Init / exit.
1300 */
1301
1302 static int __init acm_init(void)
1303 {
1304 int retval;
1305 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1306 if (!acm_tty_driver)
1307 return -ENOMEM;
1308 acm_tty_driver->owner = THIS_MODULE,
1309 acm_tty_driver->driver_name = "acm",
1310 acm_tty_driver->name = "ttyACM",
1311 acm_tty_driver->major = ACM_TTY_MAJOR,
1312 acm_tty_driver->minor_start = 0,
1313 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1314 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1315 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1316 acm_tty_driver->init_termios = tty_std_termios;
1317 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1318 tty_set_operations(acm_tty_driver, &acm_ops);
1319
1320 retval = tty_register_driver(acm_tty_driver);
1321 if (retval) {
1322 put_tty_driver(acm_tty_driver);
1323 return retval;
1324 }
1325
1326 retval = usb_register(&acm_driver);
1327 if (retval) {
1328 tty_unregister_driver(acm_tty_driver);
1329 put_tty_driver(acm_tty_driver);
1330 return retval;
1331 }
1332
1333 info(DRIVER_VERSION ":" DRIVER_DESC);
1334
1335 return 0;
1336 }
1337
1338 static void __exit acm_exit(void)
1339 {
1340 usb_deregister(&acm_driver);
1341 tty_unregister_driver(acm_tty_driver);
1342 put_tty_driver(acm_tty_driver);
1343 }
1344
1345 module_init(acm_init);
1346 module_exit(acm_exit);
1347
1348 MODULE_AUTHOR( DRIVER_AUTHOR );
1349 MODULE_DESCRIPTION( DRIVER_DESC );
1350 MODULE_LICENSE("GPL");
1351
1352
|
This page was automatically generated by the
LXR engine.
|