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