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