]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/usb/class/cdc-acm.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: usb: yet another Dell wireless CDMA/EVDO modem
[net-next-2.6.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;
185d4058
GKH		 260 int retval;
261 int status = urb->status;
1da177e4 262
185d4058 263 switch (status) {
1da177e4
LT		 264 case 0:
265 /* success */
266 break;
267 case -ECONNRESET:
268 case -ENOENT:
269 case -ESHUTDOWN:
270 /* this urb is terminated, clean up */
185d4058 271 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
1da177e4
LT		 272 return;
273 default:
185d4058 274 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
1da177e4
LT		 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 }
314exit:
185d4058
GKH		 315 retval = usb_submit_urb (urb, GFP_ATOMIC);
316 if (retval)
1da177e4 317 err ("%s - usb_submit_urb failed with result %d",
185d4058 318 __FUNCTION__, retval);
1da177e4
LT		 319}
320
321/* data interface returns incoming bytes, or we got unthrottled */
7d12e780 322static void acm_read_bulk(struct urb *urb)
1da177e4 323{
61a87adf
DK		 324 struct acm_rb *buf;
325 struct acm_ru *rcv = urb->context;
326 struct acm *acm = rcv->instance;
86478944 327 int status = urb->status;
185d4058
GKH		 328
329 dbg("Entering acm_read_bulk with status %d", status);
1da177e4
LT		 330
331 if (!ACM_READY(acm))
332 return;
333
86478944 334 if (status)
898eb71c 335 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
1da177e4 336
61a87adf
DK		 337 buf = rcv->buffer;
338 buf->size = urb->actual_length;
339
86478944
ON		 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 }
61a87adf 354 tasklet_schedule(&acm->urb_task);
1da177e4
LT		 355}
356
357static void acm_rx_tasklet(unsigned long _acm)
358{
359 struct acm *acm = (void *)_acm;
61a87adf 360 struct acm_rb *buf;
1da177e4 361 struct tty_struct *tty = acm->tty;
61a87adf 362 struct acm_ru *rcv;
762f007b 363 unsigned long flags;
ca79b7b4 364 unsigned char throttled;
1da177e4
LT		 365 dbg("Entering acm_rx_tasklet");
366
ca79b7b4
ON		 367 if (!ACM_READY(acm))
368 return;
369
834dbca5 370 spin_lock_irqsave(&acm->throttle_lock, flags);
ca79b7b4 371 throttled = acm->throttle;
834dbca5 372 spin_unlock_irqrestore(&acm->throttle_lock, flags);
ca79b7b4 373 if (throttled)
61a87adf
DK		 374 return;
375
376next_buffer:
762f007b 377 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 378 if (list_empty(&acm->filled_read_bufs)) {
762f007b 379 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf 380 goto urbs;
1da177e4 381 }
61a87adf
DK		 382 buf = list_entry(acm->filled_read_bufs.next,
383 struct acm_rb, list);
384 list_del(&buf->list);
762f007b 385 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf 386
3dd2ae81 387 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
61a87adf 388
33f0f88f 389 tty_buffer_request_room(tty, buf->size);
834dbca5 390 spin_lock_irqsave(&acm->throttle_lock, flags);
ca79b7b4 391 throttled = acm->throttle;
834dbca5 392 spin_unlock_irqrestore(&acm->throttle_lock, flags);
ca79b7b4 393 if (!throttled)
33f0f88f 394 tty_insert_flip_string(tty, buf->base, buf->size);
61a87adf 395 tty_flip_buffer_push(tty);
1da177e4 396
ca79b7b4
ON		 397 if (throttled) {
398 dbg("Throttling noticed");
762f007b 399 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 400 list_add(&buf->list, &acm->filled_read_bufs);
762f007b 401 spin_unlock_irqrestore(&acm->read_lock, flags);
1da177e4
LT		 402 return;
403 }
1da177e4 404
762f007b 405 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 406 list_add(&buf->list, &acm->spare_read_bufs);
762f007b 407 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 408 goto next_buffer;
409
410urbs:
411 while (!list_empty(&acm->spare_read_bufs)) {
762f007b 412 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 413 if (list_empty(&acm->spare_read_urbs)) {
762f007b 414 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 415 return;
416 }
417 rcv = list_entry(acm->spare_read_urbs.next,
418 struct acm_ru, list);
419 list_del(&rcv->list);
762f007b 420 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 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
3dd2ae81 436 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
61a87adf
DK		 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);
762f007b 442 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 443 list_add(&rcv->list, &acm->spare_read_urbs);
762f007b 444 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 445 return;
446 }
447 }
1da177e4
LT		 448}
449
450/* data interface wrote those outgoing bytes */
7d12e780 451static void acm_write_bulk(struct urb *urb)
1da177e4
LT		 452{
453 struct acm *acm = (struct acm *)urb->context;
1da177e4 454
3dd2ae81 455 dbg("Entering acm_write_bulk with status %d", urb->status);
1da177e4 456
884b600f
ON		 457 acm_write_done(acm);
458 acm_write_start(acm);
459 if (ACM_READY(acm))
460 schedule_work(&acm->work);
1da177e4
LT		 461}
462
c4028958 463static void acm_softint(struct work_struct *work)
1da177e4 464{
c4028958 465 struct acm *acm = container_of(work, struct acm, work);
3dd2ae81 466 dbg("Entering acm_softint.");
1da177e4
LT		 467
468 if (!ACM_READY(acm))
469 return;
470 tty_wakeup(acm->tty);
471}
472
473/*
474 * TTY handlers
475 */
476
477static int acm_tty_open(struct tty_struct *tty, struct file *filp)
478{
479 struct acm *acm;
480 int rv = -EINVAL;
61a87adf 481 int i;
3dd2ae81 482 dbg("Entering acm_tty_open.");
4186ecf8
AV		 483
484 mutex_lock(&open_mutex);
1da177e4
LT		 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
61a87adf
DK		 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;
1da177e4 498
1365baf7
ON		 499 if (usb_autopm_get_interface(acm->control)) {
500 mutex_unlock(&open_mutex);
501 return -EIO;
502 }
503
504 mutex_lock(&acm->mutex);
505 mutex_unlock(&open_mutex);
1da177e4 506 if (acm->used++) {
1365baf7 507 usb_autopm_put_interface(acm->control);
1da177e4
LT		 508 goto done;
509 }
510
1365baf7 511
1da177e4
LT		 512 acm->ctrlurb->dev = acm->dev;
513 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
514 dbg("usb_submit_urb(ctrl irq) failed");
515 goto bail_out;
516 }
517
ca79b7b4
ON		 518 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
519 (acm->ctrl_caps & USB_CDC_CAP_LINE))
1da177e4
LT		 520 goto full_bailout;
521
61a87adf
DK		 522 INIT_LIST_HEAD(&acm->spare_read_urbs);
523 INIT_LIST_HEAD(&acm->spare_read_bufs);
524 INIT_LIST_HEAD(&acm->filled_read_bufs);
86478944 525 for (i = 0; i < acm->rx_buflimit; i++) {
61a87adf
DK		 526 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
527 }
86478944 528 for (i = 0; i < acm->rx_buflimit; i++) {
61a87adf
DK		 529 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
530 }
531
ca79b7b4
ON		 532 acm->throttle = 0;
533
61a87adf 534 tasklet_schedule(&acm->urb_task);
1da177e4
LT		 535
536done:
537err_out:
1365baf7 538 mutex_unlock(&acm->mutex);
1da177e4
LT		 539 return rv;
540
541full_bailout:
1da177e4
LT		 542 usb_kill_urb(acm->ctrlurb);
543bail_out:
1365baf7 544 usb_autopm_put_interface(acm->control);
1da177e4 545 acm->used--;
1365baf7 546 mutex_unlock(&acm->mutex);
1da177e4
LT		 547 return -EIO;
548}
549
83ef344a 550static void acm_tty_unregister(struct acm *acm)
551{
86478944 552 int i,nr;
61a87adf 553
86478944 554 nr = acm->rx_buflimit;
83ef344a 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);
83ef344a 559 usb_free_urb(acm->writeurb);
86478944 560 for (i = 0; i < nr; i++)
61a87adf 561 usb_free_urb(acm->ru[i].urb);
c4cabd28 562 kfree(acm->country_codes);
83ef344a 563 kfree(acm);
564}
565
1da177e4
LT		 566static void acm_tty_close(struct tty_struct *tty, struct file *filp)
567{
568 struct acm *acm = tty->driver_data;
86478944 569 int i,nr;
1da177e4
LT		 570
571 if (!acm || !acm->used)
572 return;
573
86478944 574 nr = acm->rx_buflimit;
4186ecf8 575 mutex_lock(&open_mutex);
1da177e4
LT		 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);
86478944 581 for (i = 0; i < nr; i++)
61a87adf 582 usb_kill_urb(acm->ru[i].urb);
1365baf7 583 usb_autopm_put_interface(acm->control);
83ef344a 584 } else
585 acm_tty_unregister(acm);
1da177e4 586 }
4186ecf8 587 mutex_unlock(&open_mutex);
1da177e4
LT		 588}
589
590static 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;
884b600f
ON		 594 unsigned long flags;
595 int wbn;
596 struct acm_wb *wb;
597
3dd2ae81 598 dbg("Entering acm_tty_write to write %d bytes,", count);
1da177e4
LT		 599
600 if (!ACM_READY(acm))
601 return -EINVAL;
1da177e4
LT		 602 if (!count)
603 return 0;
604
884b600f
ON		 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];
1da177e4 612
884b600f 613 count = (count > acm->writesize) ? acm->writesize : count;
1da177e4 614 dbg("Get %d bytes...", count);
884b600f
ON		 615 memcpy(wb->buf, buf, count);
616 wb->len = count;
617 spin_unlock_irqrestore(&acm->write_lock, flags);
1da177e4 618
884b600f 619 if ((stat = acm_write_start(acm)) < 0)
1da177e4 620 return stat;
1da177e4
LT		 621 return count;
622}
623
624static 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;
884b600f
ON		 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;
1da177e4
LT		 634}
635
636static 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;
884b600f
ON		 641 /*
642 * This is inaccurate (overcounts), but it works.
643 */
86478944 644 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
1da177e4
LT		 645}
646
647static 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
657static 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);
61a87adf 665 tasklet_schedule(&acm->urb_task);
1da177e4
LT		 666}
667
668static 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
677static 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
692static 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
712static 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
4c4c9432 722static const __u32 acm_tty_speed[] = {
1da177e4
LT		 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
4c4c9432 730static const __u8 acm_tty_size[] = {
1da177e4
LT		 731 5, 6, 7, 8
732};
733
606d099c 734static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
1da177e4
LT		 735{
736 struct acm *acm = tty->driver_data;
606d099c 737 struct ktermios *termios = tty->termios;
1da177e4
LT		 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
884b600f
ON		 774/* Little helper: write buffers free */
775static void acm_write_buffers_free(struct acm *acm)
776{
777 int i;
778 struct acm_wb *wb;
779
86478944 780 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
884b600f
ON		 781 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
782 }
783}
784
785/* Little helper: write buffers allocate */
786static int acm_write_buffers_alloc(struct acm *acm)
787{
788 int i;
789 struct acm_wb *wb;
790
86478944 791 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
884b600f
ON		 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
1da177e4
LT		 807static int acm_probe (struct usb_interface *intf,
808 const struct usb_device_id *id)
809{
810 struct usb_cdc_union_desc *union_header = NULL;
c4cabd28 811 struct usb_cdc_country_functional_desc *cfd = NULL;
1da177e4
LT		 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;
86478944 829 int num_rx_buf;
61a87adf 830 int i;
1da177e4 831
86478944 832 /* normal quirks */
1da177e4 833 quirks = (unsigned long)id->driver_info;
86478944
ON		 834 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
835
836 /* handle quirks deadly to normal probing*/
1da177e4
LT		 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) {
898eb71c 845 err("Weird descriptor references\n");
1da177e4
LT		 846 return -EINVAL;
847 }
848
849 if (!buflen) {
850 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
898eb71c 851 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
1da177e4
LT		 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;
c4cabd28
ON		 875 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
876 cfd = (struct usb_cdc_country_functional_desc *)buffer;
877 break;
1da177e4
LT		 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 }
894next_desc:
895 buflen -= buffer[0];
896 buffer += buffer[0];
897 }
898
899 if (!union_header) {
900 if (call_interface_num > 0) {
898eb71c 901 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
1da177e4
LT		 902 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
903 control_interface = intf;
904 } else {
898eb71c 905 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1da177e4
LT		 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) {
898eb71c 912 dev_dbg(&intf->dev,"no interfaces\n");
1da177e4
LT		 913 return -ENODEV;
914 }
915 }
916
917 if (data_interface_num != call_interface_num)
dc0d5c1e 918 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
1da177e4
LT		 919
920skip_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;
898eb71c 926 dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
1da177e4
LT		 927
928 t = control_interface;
929 control_interface = data_interface;
930 data_interface = t;
931 } else {
932 return -EINVAL;
933 }
934 }
74da5d68
AS		 935
936 /* Accept probe requests only for the control interface */
937 if (intf != control_interface)
938 return -ENODEV;
1da177e4
LT		 939
940 if (usb_interface_claimed(data_interface)) { /* valid in this context */
898eb71c 941 dev_dbg(&intf->dev,"The data interface isn't available\n");
1da177e4
LT		 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 */
45aea704 955 if (!usb_endpoint_dir_in(epread)) {
1da177e4
LT		 956 /* descriptors are swapped */
957 struct usb_endpoint_descriptor *t;
898eb71c 958 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
1da177e4
LT		 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
46f116ea 972 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
898eb71c 973 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1da177e4
LT		 974 goto alloc_fail;
975 }
1da177e4
LT		 976
977 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
86478944 978 readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
1da177e4
LT		 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;
86478944 987 acm->rx_buflimit = num_rx_buf;
61a87adf
DK		 988 acm->urb_task.func = acm_rx_tasklet;
989 acm->urb_task.data = (unsigned long) acm;
c4028958 990 INIT_WORK(&acm->work, acm_softint);
1da177e4 991 spin_lock_init(&acm->throttle_lock);
884b600f 992 spin_lock_init(&acm->write_lock);
61a87adf 993 spin_lock_init(&acm->read_lock);
1365baf7 994 mutex_init(&acm->mutex);
884b600f 995 acm->write_ready = 1;
61a87adf 996 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1da177e4
LT		 997
998 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
999 if (!buf) {
898eb71c 1000 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1da177e4
LT		 1001 goto alloc_fail2;
1002 }
1003 acm->ctrl_buffer = buf;
1004
884b600f 1005 if (acm_write_buffers_alloc(acm) < 0) {
898eb71c 1006 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1da177e4
LT		 1007 goto alloc_fail4;
1008 }
1da177e4
LT		 1009
1010 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1011 if (!acm->ctrlurb) {
898eb71c 1012 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1da177e4
LT		 1013 goto alloc_fail5;
1014 }
86478944 1015 for (i = 0; i < num_rx_buf; i++) {
61a87adf
DK		 1016 struct acm_ru *rcv = &(acm->ru[i]);
1017
1018 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
898eb71c 1019 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
61a87adf
DK		 1020 goto alloc_fail7;
1021 }
1022
1023 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1024 rcv->instance = acm;
1025 }
86478944 1026 for (i = 0; i < num_rx_buf; i++) {
61a87adf
DK		 1027 struct acm_rb *buf = &(acm->rb[i]);
1028
61a87adf 1029 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
898eb71c 1030 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
61a87adf
DK		 1031 goto alloc_fail7;
1032 }
1da177e4
LT		 1033 }
1034 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1035 if (!acm->writeurb) {
898eb71c 1036 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
1da177e4
LT		 1037 goto alloc_fail7;
1038 }
1039
c4cabd28
ON		 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
1067skip_countries:
1da177e4
LT		 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
1da177e4 1073 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
884b600f 1074 NULL, acm->writesize, acm_write_bulk, acm);
1da177e4 1075 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1da177e4
LT		 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
83ef344a 1087 usb_get_intf(control_interface);
1088 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1da177e4
LT		 1089
1090 acm_table[minor] = acm;
1da177e4 1091
c4cabd28
ON		 1092 return 0;
1093alloc_fail8:
1094 usb_free_urb(acm->writeurb);
1da177e4 1095alloc_fail7:
86478944 1096 for (i = 0; i < num_rx_buf; i++)
61a87adf 1097 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
86478944 1098 for (i = 0; i < num_rx_buf; i++)
61a87adf 1099 usb_free_urb(acm->ru[i].urb);
1da177e4
LT		 1100 usb_free_urb(acm->ctrlurb);
1101alloc_fail5:
884b600f 1102 acm_write_buffers_free(acm);
1da177e4 1103alloc_fail4:
1da177e4
LT		 1104 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1105alloc_fail2:
1106 kfree(acm);
1107alloc_fail:
1108 return -ENOMEM;
1109}
1110
1365baf7
ON		 1111static 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
1da177e4
LT		 1130static void acm_disconnect(struct usb_interface *intf)
1131{
c4cabd28 1132 struct acm *acm = usb_get_intfdata(intf);
1da177e4 1133 struct usb_device *usb_dev = interface_to_usbdev(intf);
61a87adf 1134 int i;
1da177e4
LT		 1135
1136 if (!acm || !acm->dev) {
1137 dbg("disconnect on nonexisting interface");
1138 return;
1139 }
1140
4186ecf8 1141 mutex_lock(&open_mutex);
86067eea 1142 if (!usb_get_intfdata(intf)) {
4186ecf8 1143 mutex_unlock(&open_mutex);
86067eea
ON		 1144 return;
1145 }
c4cabd28 1146 if (acm->country_codes){
74da5d68
AS		 1147 device_remove_file(&acm->control->dev,
1148 &dev_attr_wCountryCodes);
1149 device_remove_file(&acm->control->dev,
1150 &dev_attr_iCountryCodeRelDate);
c4cabd28 1151 }
74da5d68 1152 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1da177e4 1153 acm->dev = NULL;
86067eea
ON		 1154 usb_set_intfdata(acm->control, NULL);
1155 usb_set_intfdata(acm->data, NULL);
1da177e4 1156
1365baf7 1157 stop_data_traffic(acm);
1da177e4 1158
884b600f 1159 acm_write_buffers_free(acm);
1da177e4 1160 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
86478944 1161 for (i = 0; i < acm->rx_buflimit; i++)
61a87adf 1162 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1da177e4 1163
86067eea 1164 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1da177e4
LT		 1165
1166 if (!acm->used) {
83ef344a 1167 acm_tty_unregister(acm);
4186ecf8 1168 mutex_unlock(&open_mutex);
1da177e4
LT		 1169 return;
1170 }
1171
4186ecf8 1172 mutex_unlock(&open_mutex);
1da177e4
LT		 1173
1174 if (acm->tty)
1175 tty_hangup(acm->tty);
1176}
1177
1365baf7
ON		 1178static 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
1197static 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
1214err_out:
1215 mutex_unlock(&acm->mutex);
1216 return rv;
1217}
1da177e4
LT		 1218/*
1219 * USB driver structure.
1220 */
1221
1222static 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 },
b0e2a705
AA		 1227 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1228 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1229 },
8753e65e
MO		 1230 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1231 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1232 },
91a9c921
CM		 1233 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1234 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1235 },
86478944
ON		 1236 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1237 .driver_info = SINGLE_RX_URB, /* firmware bug */
1238 },
3dd2ae81
ON		 1239 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1240 .driver_info = SINGLE_RX_URB, /* firmware bug */
1241 },
9be8456c
ON		 1242 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1243 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1244 },
1245
1da177e4
LT		 1246 /* control interfaces with various AT-command sets */
1247 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1248 USB_CDC_ACM_PROTO_AT_V25TER) },
1249 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1250 USB_CDC_ACM_PROTO_AT_PCCA101) },
1251 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1252 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1253 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1254 USB_CDC_ACM_PROTO_AT_GSM) },
1255 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1256 USB_CDC_ACM_PROTO_AT_3G ) },
1257 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1258 USB_CDC_ACM_PROTO_AT_CDMA) },
1259
1260 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1261 { }
1262};
1263
1264MODULE_DEVICE_TABLE (usb, acm_ids);
1265
1266static struct usb_driver acm_driver = {
1da177e4
LT		 1267 .name = "cdc_acm",
1268 .probe = acm_probe,
1269 .disconnect = acm_disconnect,
1365baf7
ON		 1270 .suspend = acm_suspend,
1271 .resume = acm_resume,
1da177e4 1272 .id_table = acm_ids,
1365baf7 1273 .supports_autosuspend = 1,
1da177e4
LT		 1274};
1275
1276/*
1277 * TTY driver structures.
1278 */
1279
b68e31d0 1280static const struct tty_operations acm_ops = {
1da177e4
LT		 1281 .open = acm_tty_open,
1282 .close = acm_tty_close,
1283 .write = acm_tty_write,
1284 .write_room = acm_tty_write_room,
1285 .ioctl = acm_tty_ioctl,
1286 .throttle = acm_tty_throttle,
1287 .unthrottle = acm_tty_unthrottle,
1288 .chars_in_buffer = acm_tty_chars_in_buffer,
1289 .break_ctl = acm_tty_break_ctl,
1290 .set_termios = acm_tty_set_termios,
1291 .tiocmget = acm_tty_tiocmget,
1292 .tiocmset = acm_tty_tiocmset,
1293};
1294
1295/*
1296 * Init / exit.
1297 */
1298
1299static int __init acm_init(void)
1300{
1301 int retval;
1302 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1303 if (!acm_tty_driver)
1304 return -ENOMEM;
1305 acm_tty_driver->owner = THIS_MODULE,
1306 acm_tty_driver->driver_name = "acm",
1307 acm_tty_driver->name = "ttyACM",
1da177e4
LT		 1308 acm_tty_driver->major = ACM_TTY_MAJOR,
1309 acm_tty_driver->minor_start = 0,
1310 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1311 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
331b8319 1312 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1da177e4
LT		 1313 acm_tty_driver->init_termios = tty_std_termios;
1314 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1315 tty_set_operations(acm_tty_driver, &acm_ops);
1316
1317 retval = tty_register_driver(acm_tty_driver);
1318 if (retval) {
1319 put_tty_driver(acm_tty_driver);
1320 return retval;
1321 }
1322
1323 retval = usb_register(&acm_driver);
1324 if (retval) {
1325 tty_unregister_driver(acm_tty_driver);
1326 put_tty_driver(acm_tty_driver);
1327 return retval;
1328 }
1329
1330 info(DRIVER_VERSION ":" DRIVER_DESC);
1331
1332 return 0;
1333}
1334
1335static void __exit acm_exit(void)
1336{
1337 usb_deregister(&acm_driver);
1338 tty_unregister_driver(acm_tty_driver);
1339 put_tty_driver(acm_tty_driver);
1340}
1341
1342module_init(acm_init);
1343module_exit(acm_exit);
1344
1345MODULE_AUTHOR( DRIVER_AUTHOR );
1346MODULE_DESCRIPTION( DRIVER_DESC );
1347MODULE_LICENSE("GPL");
1348
Clone of davem's net-next-2.6 tree