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