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