projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
USB: cxacru: Use a bulk/int URB to access the command endpoint
[deliverable/linux.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>
a2531293 5 * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
1da177e4
LT		 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
6e47e069
AC		 19 * v0.12 - added TIOCM ioctls, added break handling, made struct acm
20 * kmalloced
1da177e4
LT		 21 * v0.13 - added termios, added hangup
22 * v0.14 - sized down struct acm
23 * v0.15 - fixed flow control again - characters could be lost
24 * v0.16 - added code for modems with swapped data and control interfaces
25 * v0.17 - added new style probing
26 * v0.18 - fixed new style probing for devices with more configurations
27 * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
28 * v0.20 - switched to probing on interface (rather than device) class
29 * v0.21 - revert to probing on device for devices with multiple configs
30 * v0.22 - probe only the control interface. if usbcore doesn't choose the
31 * config we want, sysadmin changes bConfigurationValue in sysfs.
32 * v0.23 - use softirq for rx processing, as needed by tty layer
33 * v0.24 - change probe method to evaluate CDC union descriptor
61a87adf 34 * v0.25 - downstream tasks paralelized to maximize throughput
e4cf3aa8 35 * v0.26 - multiple write urbs, writesize increased
1da177e4
LT		 36 */
37
38/*
39 * This program is free software; you can redistribute it and/or modify
40 * it under the terms of the GNU General Public License as published by
41 * the Free Software Foundation; either version 2 of the License, or
42 * (at your option) any later version.
43 *
44 * This program is distributed in the hope that it will be useful,
45 * but WITHOUT ANY WARRANTY; without even the implied warranty of
46 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
47 * GNU General Public License for more details.
48 *
49 * You should have received a copy of the GNU General Public License
50 * along with this program; if not, write to the Free Software
51 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
52 */
53
54#undef DEBUG
e5fbab51 55#undef VERBOSE_DEBUG
1da177e4
LT		 56
57#include <linux/kernel.h>
58#include <linux/errno.h>
59#include <linux/init.h>
60#include <linux/slab.h>
61#include <linux/tty.h>
7af25b4b 62#include <linux/serial.h>
1da177e4
LT		 63#include <linux/tty_driver.h>
64#include <linux/tty_flip.h>
65#include <linux/module.h>
4186ecf8 66#include <linux/mutex.h>
10077d4a 67#include <linux/uaccess.h>
1da177e4 68#include <linux/usb.h>
a8c28f23 69#include <linux/usb/cdc.h>
1da177e4
LT		 70#include <asm/byteorder.h>
71#include <asm/unaligned.h>
61a87adf 72#include <linux/list.h>
1da177e4
LT		 73
74#include "cdc-acm.h"
75
e5fbab51
DB		 76
77#define ACM_CLOSE_TIMEOUT 15 /* seconds to let writes drain */
78
1da177e4
LT		 79/*
80 * Version Information
81 */
e4cf3aa8 82#define DRIVER_VERSION "v0.26"
61a87adf 83#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
1da177e4
LT		 84#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
85
86static struct usb_driver acm_driver;
87static struct tty_driver *acm_tty_driver;
88static struct acm *acm_table[ACM_TTY_MINORS];
89
4186ecf8 90static DEFINE_MUTEX(open_mutex);
1da177e4 91
10077d4a 92#define ACM_READY(acm) (acm && acm->dev && acm->port.count)
1da177e4 93
739e0285
AC		 94static const struct tty_port_operations acm_port_ops = {
95};
96
e5fbab51
DB		 97#ifdef VERBOSE_DEBUG
98#define verbose 1
99#else
100#define verbose 0
101#endif
102
1da177e4
LT		 103/*
104 * Functions for ACM control messages.
105 */
106
6e47e069
AC		 107static int acm_ctrl_msg(struct acm *acm, int request, int value,
108 void *buf, int len)
1da177e4
LT		 109{
110 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
111 request, USB_RT_ACM, value,
112 acm->control->altsetting[0].desc.bInterfaceNumber,
113 buf, len, 5000);
6e47e069
AC		 114 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
115 request, value, len, retval);
1da177e4
LT		 116 return retval < 0 ? retval : 0;
117}
118
119/* devices aren't required to support these requests.
120 * the cdc acm descriptor tells whether they do...
121 */
122#define acm_set_control(acm, control) \
123 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
124#define acm_set_line(acm, line) \
125 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
126#define acm_send_break(acm, ms) \
127 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
128
884b600f
ON		 129/*
130 * Write buffer management.
131 * All of these assume proper locks taken by the caller.
132 */
133
134static int acm_wb_alloc(struct acm *acm)
135{
136 int i, wbn;
137 struct acm_wb *wb;
138
e4cf3aa8 139 wbn = 0;
884b600f
ON		 140 i = 0;
141 for (;;) {
142 wb = &acm->wb[wbn];
143 if (!wb->use) {
144 wb->use = 1;
145 return wbn;
146 }
86478944
ON		 147 wbn = (wbn + 1) % ACM_NW;
148 if (++i >= ACM_NW)
884b600f
ON		 149 return -1;
150 }
151}
152
884b600f
ON		 153static int acm_wb_is_avail(struct acm *acm)
154{
155 int i, n;
e5fbab51 156 unsigned long flags;
884b600f 157
86478944 158 n = ACM_NW;
e5fbab51 159 spin_lock_irqsave(&acm->write_lock, flags);
6e47e069 160 for (i = 0; i < ACM_NW; i++)
86478944 161 n -= acm->wb[i].use;
e5fbab51 162 spin_unlock_irqrestore(&acm->write_lock, flags);
884b600f
ON		 163 return n;
164}
165
884b600f 166/*
ad0b65ef 167 * Finish write. Caller must hold acm->write_lock
884b600f 168 */
e4cf3aa8 169static void acm_write_done(struct acm *acm, struct acm_wb *wb)
884b600f 170{
e4cf3aa8 171 wb->use = 0;
11ea859d 172 acm->transmitting--;
97d35f95 173 usb_autopm_put_interface_async(acm->control);
884b600f
ON		 174}
175
176/*
177 * Poke write.
11ea859d
ON		 178 *
179 * the caller is responsible for locking
884b600f 180 */
11ea859d
ON		 181
182static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
183{
184 int rc;
185
186 acm->transmitting++;
187
188 wb->urb->transfer_buffer = wb->buf;
189 wb->urb->transfer_dma = wb->dmah;
190 wb->urb->transfer_buffer_length = wb->len;
191 wb->urb->dev = acm->dev;
192
6e47e069
AC		 193 rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
194 if (rc < 0) {
11ea859d
ON		 195 dbg("usb_submit_urb(write bulk) failed: %d", rc);
196 acm_write_done(acm, wb);
197 }
198 return rc;
199}
200
e4cf3aa8 201static int acm_write_start(struct acm *acm, int wbn)
884b600f
ON		 202{
203 unsigned long flags;
934da463 204 struct acm_wb *wb = &acm->wb[wbn];
884b600f
ON		 205 int rc;
206
207 spin_lock_irqsave(&acm->write_lock, flags);
208 if (!acm->dev) {
934da463 209 wb->use = 0;
884b600f
ON		 210 spin_unlock_irqrestore(&acm->write_lock, flags);
211 return -ENODEV;
212 }
213
11ea859d 214 dbg("%s susp_count: %d", __func__, acm->susp_count);
97d35f95 215 usb_autopm_get_interface_async(acm->control);
11ea859d 216 if (acm->susp_count) {
97d35f95
ON		 217 if (!acm->delayed_wb)
218 acm->delayed_wb = wb;
219 else
220 usb_autopm_put_interface_async(acm->control);
11ea859d
ON		 221 spin_unlock_irqrestore(&acm->write_lock, flags);
222 return 0; /* A white lie */
223 }
224 usb_mark_last_busy(acm->dev);
225
11ea859d 226 rc = acm_start_wb(acm, wb);
884b600f
ON		 227 spin_unlock_irqrestore(&acm->write_lock, flags);
228
884b600f 229 return rc;
11ea859d 230
884b600f 231}
c4cabd28
ON		 232/*
233 * attributes exported through sysfs
234 */
235static ssize_t show_caps
236(struct device *dev, struct device_attribute *attr, char *buf)
237{
238 struct usb_interface *intf = to_usb_interface(dev);
239 struct acm *acm = usb_get_intfdata(intf);
240
241 return sprintf(buf, "%d", acm->ctrl_caps);
242}
243static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
244
245static ssize_t show_country_codes
246(struct device *dev, struct device_attribute *attr, char *buf)
247{
248 struct usb_interface *intf = to_usb_interface(dev);
249 struct acm *acm = usb_get_intfdata(intf);
250
251 memcpy(buf, acm->country_codes, acm->country_code_size);
252 return acm->country_code_size;
253}
254
255static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
256
257static ssize_t show_country_rel_date
258(struct device *dev, struct device_attribute *attr, char *buf)
259{
260 struct usb_interface *intf = to_usb_interface(dev);
261 struct acm *acm = usb_get_intfdata(intf);
262
263 return sprintf(buf, "%d", acm->country_rel_date);
264}
884b600f 265
c4cabd28 266static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
1da177e4
LT		 267/*
268 * Interrupt handlers for various ACM device responses
269 */
270
271/* control interface reports status changes with "interrupt" transfers */
7d12e780 272static void acm_ctrl_irq(struct urb *urb)
1da177e4
LT		 273{
274 struct acm *acm = urb->context;
275 struct usb_cdc_notification *dr = urb->transfer_buffer;
10077d4a 276 struct tty_struct *tty;
1da177e4
LT		 277 unsigned char *data;
278 int newctrl;
185d4058
GKH		 279 int retval;
280 int status = urb->status;
1da177e4 281
185d4058 282 switch (status) {
1da177e4
LT		 283 case 0:
284 /* success */
285 break;
286 case -ECONNRESET:
287 case -ENOENT:
288 case -ESHUTDOWN:
289 /* this urb is terminated, clean up */
441b62c1 290 dbg("%s - urb shutting down with status: %d", __func__, status);
1da177e4
LT		 291 return;
292 default:
441b62c1 293 dbg("%s - nonzero urb status received: %d", __func__, status);
1da177e4
LT		 294 goto exit;
295 }
296
297 if (!ACM_READY(acm))
298 goto exit;
299
300 data = (unsigned char *)(dr + 1);
301 switch (dr->bNotificationType) {
6e47e069
AC		 302 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
303 dbg("%s network", dr->wValue ?
304 "connected to" : "disconnected from");
305 break;
1da177e4 306
6e47e069
AC		 307 case USB_CDC_NOTIFY_SERIAL_STATE:
308 tty = tty_port_tty_get(&acm->port);
309 newctrl = get_unaligned_le16(data);
1da177e4 310
6e47e069
AC		 311 if (tty) {
312 if (!acm->clocal &&
313 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
314 dbg("calling hangup");
315 tty_hangup(tty);
1da177e4 316 }
6e47e069
AC		 317 tty_kref_put(tty);
318 }
1da177e4 319
6e47e069 320 acm->ctrlin = newctrl;
1da177e4 321
6e47e069
AC		 322 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
323 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
324 acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
325 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
326 acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
327 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
328 acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
329 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
1da177e4
LT		 330 break;
331
6e47e069
AC		 332 default:
333 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
334 dr->bNotificationType, dr->wIndex,
335 dr->wLength, data[0], data[1]);
336 break;
1da177e4
LT		 337 }
338exit:
11ea859d 339 usb_mark_last_busy(acm->dev);
6e47e069 340 retval = usb_submit_urb(urb, GFP_ATOMIC);
185d4058 341 if (retval)
9908a32e
GKH		 342 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
343 "result %d", __func__, retval);
1da177e4
LT		 344}
345
346/* data interface returns incoming bytes, or we got unthrottled */
7d12e780 347static void acm_read_bulk(struct urb *urb)
1da177e4 348{
61a87adf
DK		 349 struct acm_rb *buf;
350 struct acm_ru *rcv = urb->context;
351 struct acm *acm = rcv->instance;
86478944 352 int status = urb->status;
185d4058
GKH		 353
354 dbg("Entering acm_read_bulk with status %d", status);
1da177e4 355
11ea859d
ON		 356 if (!ACM_READY(acm)) {
357 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
1da177e4 358 return;
11ea859d
ON		 359 }
360 usb_mark_last_busy(acm->dev);
1da177e4 361
86478944 362 if (status)
898eb71c 363 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
1da177e4 364
61a87adf
DK		 365 buf = rcv->buffer;
366 buf->size = urb->actual_length;
367
86478944
ON		 368 if (likely(status == 0)) {
369 spin_lock(&acm->read_lock);
11ea859d 370 acm->processing++;
86478944
ON		 371 list_add_tail(&rcv->list, &acm->spare_read_urbs);
372 list_add_tail(&buf->list, &acm->filled_read_bufs);
373 spin_unlock(&acm->read_lock);
374 } else {
375 /* we drop the buffer due to an error */
376 spin_lock(&acm->read_lock);
377 list_add_tail(&rcv->list, &acm->spare_read_urbs);
378 list_add(&buf->list, &acm->spare_read_bufs);
379 spin_unlock(&acm->read_lock);
380 /* nevertheless the tasklet must be kicked unconditionally
381 so the queue cannot dry up */
382 }
11ea859d
ON		 383 if (likely(!acm->susp_count))
384 tasklet_schedule(&acm->urb_task);
1da177e4
LT		 385}
386
387static void acm_rx_tasklet(unsigned long _acm)
388{
389 struct acm *acm = (void *)_acm;
61a87adf 390 struct acm_rb *buf;
10077d4a 391 struct tty_struct *tty;
61a87adf 392 struct acm_ru *rcv;
762f007b 393 unsigned long flags;
ca79b7b4 394 unsigned char throttled;
11ea859d 395
1da177e4
LT		 396 dbg("Entering acm_rx_tasklet");
397
10077d4a 398 if (!ACM_READY(acm)) {
11ea859d 399 dbg("acm_rx_tasklet: ACM not ready");
ca79b7b4 400 return;
11ea859d 401 }
ca79b7b4 402
834dbca5 403 spin_lock_irqsave(&acm->throttle_lock, flags);
ca79b7b4 404 throttled = acm->throttle;
834dbca5 405 spin_unlock_irqrestore(&acm->throttle_lock, flags);
10077d4a 406 if (throttled) {
11ea859d 407 dbg("acm_rx_tasklet: throttled");
61a87adf 408 return;
11ea859d 409 }
61a87adf 410
10077d4a
AC		 411 tty = tty_port_tty_get(&acm->port);
412
61a87adf 413next_buffer:
762f007b 414 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 415 if (list_empty(&acm->filled_read_bufs)) {
762f007b 416 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf 417 goto urbs;
1da177e4 418 }
61a87adf
DK		 419 buf = list_entry(acm->filled_read_bufs.next,
420 struct acm_rb, list);
421 list_del(&buf->list);
762f007b 422 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf 423
3dd2ae81 424 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
61a87adf 425
10077d4a
AC		 426 if (tty) {
427 spin_lock_irqsave(&acm->throttle_lock, flags);
428 throttled = acm->throttle;
429 spin_unlock_irqrestore(&acm->throttle_lock, flags);
430 if (!throttled) {
10077d4a
AC		 431 tty_insert_flip_string(tty, buf->base, buf->size);
432 tty_flip_buffer_push(tty);
433 } else {
434 tty_kref_put(tty);
435 dbg("Throttling noticed");
436 spin_lock_irqsave(&acm->read_lock, flags);
437 list_add(&buf->list, &acm->filled_read_bufs);
438 spin_unlock_irqrestore(&acm->read_lock, flags);
439 return;
440 }
1da177e4 441 }
1da177e4 442
762f007b 443 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 444 list_add(&buf->list, &acm->spare_read_bufs);
762f007b 445 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 446 goto next_buffer;
447
448urbs:
10077d4a
AC		 449 tty_kref_put(tty);
450
61a87adf 451 while (!list_empty(&acm->spare_read_bufs)) {
762f007b 452 spin_lock_irqsave(&acm->read_lock, flags);
61a87adf 453 if (list_empty(&acm->spare_read_urbs)) {
11ea859d 454 acm->processing = 0;
762f007b 455 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 456 return;
457 }
458 rcv = list_entry(acm->spare_read_urbs.next,
459 struct acm_ru, list);
460 list_del(&rcv->list);
762f007b 461 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf
DK		 462
463 buf = list_entry(acm->spare_read_bufs.next,
464 struct acm_rb, list);
465 list_del(&buf->list);
466
467 rcv->buffer = buf;
468
cf7fdd57 469 if (acm->is_int_ep)
5186ffee
AL		 470 usb_fill_int_urb(rcv->urb, acm->dev,
471 acm->rx_endpoint,
472 buf->base,
473 acm->readsize,
cf7fdd57 474 acm_read_bulk, rcv, acm->bInterval);
5186ffee
AL		 475 else
476 usb_fill_bulk_urb(rcv->urb, acm->dev,
477 acm->rx_endpoint,
478 buf->base,
479 acm->readsize,
480 acm_read_bulk, rcv);
61a87adf
DK		 481 rcv->urb->transfer_dma = buf->dma;
482 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
483
6e47e069
AC		 484 /* This shouldn't kill the driver as unsuccessful URBs are
485 returned to the free-urbs-pool and resubmited ASAP */
11ea859d 486 spin_lock_irqsave(&acm->read_lock, flags);
6e47e069
AC		 487 if (acm->susp_count ||
488 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
61a87adf 489 list_add(&buf->list, &acm->spare_read_bufs);
61a87adf 490 list_add(&rcv->list, &acm->spare_read_urbs);
11ea859d 491 acm->processing = 0;
762f007b 492 spin_unlock_irqrestore(&acm->read_lock, flags);
61a87adf 493 return;
11ea859d
ON		 494 } else {
495 spin_unlock_irqrestore(&acm->read_lock, flags);
496 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
61a87adf
DK		 497 }
498 }
11ea859d
ON		 499 spin_lock_irqsave(&acm->read_lock, flags);
500 acm->processing = 0;
501 spin_unlock_irqrestore(&acm->read_lock, flags);
1da177e4
LT		 502}
503
504/* data interface wrote those outgoing bytes */
7d12e780 505static void acm_write_bulk(struct urb *urb)
1da177e4 506{
cdc97792 507 struct acm_wb *wb = urb->context;
e5fbab51 508 struct acm *acm = wb->instance;
ad0b65ef 509 unsigned long flags;
1da177e4 510
e5fbab51
DB		 511 if (verbose || urb->status
512 || (urb->actual_length != urb->transfer_buffer_length))
513 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
514 urb->actual_length,
515 urb->transfer_buffer_length,
516 urb->status);
1da177e4 517
ad0b65ef 518 spin_lock_irqsave(&acm->write_lock, flags);
e4cf3aa8 519 acm_write_done(acm, wb);
ad0b65ef 520 spin_unlock_irqrestore(&acm->write_lock, flags);
884b600f
ON		 521 if (ACM_READY(acm))
522 schedule_work(&acm->work);
e5fbab51
DB		 523 else
524 wake_up_interruptible(&acm->drain_wait);
1da177e4
LT		 525}
526
c4028958 527static void acm_softint(struct work_struct *work)
1da177e4 528{
c4028958 529 struct acm *acm = container_of(work, struct acm, work);
10077d4a 530 struct tty_struct *tty;
e5fbab51
DB		 531
532 dev_vdbg(&acm->data->dev, "tx work\n");
1da177e4
LT		 533 if (!ACM_READY(acm))
534 return;
10077d4a
AC		 535 tty = tty_port_tty_get(&acm->port);
536 tty_wakeup(tty);
537 tty_kref_put(tty);
1da177e4
LT		 538}
539
540/*
541 * TTY handlers
542 */
543
544static int acm_tty_open(struct tty_struct *tty, struct file *filp)
545{
546 struct acm *acm;
42dd2aa6 547 int rv = -ENODEV;
61a87adf 548 int i;
3dd2ae81 549 dbg("Entering acm_tty_open.");
4186ecf8
AV		 550
551 mutex_lock(&open_mutex);
1da177e4
LT		 552
553 acm = acm_table[tty->index];
554 if (!acm || !acm->dev)
2b626dc1 555 goto out;
1da177e4
LT		 556 else
557 rv = 0;
558
28d1dfad 559 set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
10077d4a 560
1da177e4 561 tty->driver_data = acm;
10077d4a 562 tty_port_tty_set(&acm->port, tty);
1da177e4 563
94409cc1
ON		 564 if (usb_autopm_get_interface(acm->control) < 0)
565 goto early_bail;
11ea859d
ON		 566 else
567 acm->control->needs_remote_wakeup = 1;
1365baf7
ON		 568
569 mutex_lock(&acm->mutex);
10077d4a 570 if (acm->port.count++) {
2b626dc1 571 mutex_unlock(&acm->mutex);
1365baf7 572 usb_autopm_put_interface(acm->control);
2b626dc1 573 goto out;
10077d4a 574 }
1365baf7 575
1da177e4
LT		 576 acm->ctrlurb->dev = acm->dev;
577 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
578 dbg("usb_submit_urb(ctrl irq) failed");
579 goto bail_out;
580 }
581
ca79b7b4
ON		 582 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
583 (acm->ctrl_caps & USB_CDC_CAP_LINE))
1da177e4 584 goto full_bailout;
10077d4a 585
11ea859d 586 usb_autopm_put_interface(acm->control);
1da177e4 587
61a87adf
DK		 588 INIT_LIST_HEAD(&acm->spare_read_urbs);
589 INIT_LIST_HEAD(&acm->spare_read_bufs);
590 INIT_LIST_HEAD(&acm->filled_read_bufs);
6e47e069
AC		 591
592 for (i = 0; i < acm->rx_buflimit; i++)
61a87adf 593 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
6e47e069 594 for (i = 0; i < acm->rx_buflimit; i++)
61a87adf 595 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
61a87adf 596
ca79b7b4
ON		 597 acm->throttle = 0;
598
7af25b4b 599 set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
10077d4a 600 rv = tty_port_block_til_ready(&acm->port, tty, filp);
18a77b5d 601 tasklet_schedule(&acm->urb_task);
2b626dc1 602
1365baf7 603 mutex_unlock(&acm->mutex);
2b626dc1 604out:
94409cc1 605 mutex_unlock(&open_mutex);
1da177e4
LT		 606 return rv;
607
608full_bailout:
1da177e4
LT		 609 usb_kill_urb(acm->ctrlurb);
610bail_out:
10077d4a 611 acm->port.count--;
1365baf7 612 mutex_unlock(&acm->mutex);
2b626dc1 613 usb_autopm_put_interface(acm->control);
94409cc1
ON		 614early_bail:
615 mutex_unlock(&open_mutex);
10077d4a 616 tty_port_tty_set(&acm->port, NULL);
1da177e4
LT		 617 return -EIO;
618}
619
83ef344a 620static void acm_tty_unregister(struct acm *acm)
621{
10077d4a 622 int i, nr;
61a87adf 623
86478944 624 nr = acm->rx_buflimit;
83ef344a 625 tty_unregister_device(acm_tty_driver, acm->minor);
626 usb_put_intf(acm->control);
627 acm_table[acm->minor] = NULL;
628 usb_free_urb(acm->ctrlurb);
e4cf3aa8
DE		 629 for (i = 0; i < ACM_NW; i++)
630 usb_free_urb(acm->wb[i].urb);
86478944 631 for (i = 0; i < nr; i++)
61a87adf 632 usb_free_urb(acm->ru[i].urb);
c4cabd28 633 kfree(acm->country_codes);
83ef344a 634 kfree(acm);
635}
636
e5fbab51
DB		 637static int acm_tty_chars_in_buffer(struct tty_struct *tty);
638
4e608671 639static void acm_port_down(struct acm *acm)
10077d4a
AC		 640{
641 int i, nr = acm->rx_buflimit;
642 mutex_lock(&open_mutex);
643 if (acm->dev) {
644 usb_autopm_get_interface(acm->control);
645 acm_set_control(acm, acm->ctrlout = 0);
10077d4a
AC		 646 usb_kill_urb(acm->ctrlurb);
647 for (i = 0; i < ACM_NW; i++)
648 usb_kill_urb(acm->wb[i].urb);
649 for (i = 0; i < nr; i++)
650 usb_kill_urb(acm->ru[i].urb);
651 acm->control->needs_remote_wakeup = 0;
652 usb_autopm_put_interface(acm->control);
653 }
654 mutex_unlock(&open_mutex);
655}
656
657static void acm_tty_hangup(struct tty_struct *tty)
658{
659 struct acm *acm = tty->driver_data;
660 tty_port_hangup(&acm->port);
4e608671 661 acm_port_down(acm);
10077d4a
AC		 662}
663
1da177e4
LT		 664static void acm_tty_close(struct tty_struct *tty, struct file *filp)
665{
666 struct acm *acm = tty->driver_data;
667
10077d4a
AC		 668 /* Perform the closing process and see if we need to do the hardware
669 shutdown */
051522bb 670 if (!acm)
1da177e4 671 return;
051522bb
FL		 672 if (tty_port_close_start(&acm->port, tty, filp) == 0) {
673 mutex_lock(&open_mutex);
674 if (!acm->dev) {
675 tty_port_tty_set(&acm->port, NULL);
676 acm_tty_unregister(acm);
677 tty->driver_data = NULL;
678 }
679 mutex_unlock(&open_mutex);
680 return;
681 }
4e608671 682 acm_port_down(acm);
10077d4a 683 tty_port_close_end(&acm->port, tty);
10077d4a 684 tty_port_tty_set(&acm->port, NULL);
1da177e4
LT		 685}
686
6e47e069
AC		 687static int acm_tty_write(struct tty_struct *tty,
688 const unsigned char *buf, int count)
1da177e4
LT		 689{
690 struct acm *acm = tty->driver_data;
691 int stat;
884b600f
ON		 692 unsigned long flags;
693 int wbn;
694 struct acm_wb *wb;
695
3dd2ae81 696 dbg("Entering acm_tty_write to write %d bytes,", count);
1da177e4
LT		 697
698 if (!ACM_READY(acm))
699 return -EINVAL;
1da177e4
LT		 700 if (!count)
701 return 0;
702
884b600f 703 spin_lock_irqsave(&acm->write_lock, flags);
6e47e069
AC		 704 wbn = acm_wb_alloc(acm);
705 if (wbn < 0) {
884b600f 706 spin_unlock_irqrestore(&acm->write_lock, flags);
884b600f
ON		 707 return 0;
708 }
709 wb = &acm->wb[wbn];
1da177e4 710
884b600f 711 count = (count > acm->writesize) ? acm->writesize : count;
1da177e4 712 dbg("Get %d bytes...", count);
884b600f
ON		 713 memcpy(wb->buf, buf, count);
714 wb->len = count;
715 spin_unlock_irqrestore(&acm->write_lock, flags);
1da177e4 716
6e47e069
AC		 717 stat = acm_write_start(acm, wbn);
718 if (stat < 0)
1da177e4 719 return stat;
1da177e4
LT		 720 return count;
721}
722
723static int acm_tty_write_room(struct tty_struct *tty)
724{
725 struct acm *acm = tty->driver_data;
726 if (!ACM_READY(acm))
727 return -EINVAL;
884b600f
ON		 728 /*
729 * Do not let the line discipline to know that we have a reserve,
730 * or it might get too enthusiastic.
731 */
934da463 732 return acm_wb_is_avail(acm) ? acm->writesize : 0;
1da177e4
LT		 733}
734
735static int acm_tty_chars_in_buffer(struct tty_struct *tty)
736{
737 struct acm *acm = tty->driver_data;
738 if (!ACM_READY(acm))
23198fda 739 return 0;
884b600f
ON		 740 /*
741 * This is inaccurate (overcounts), but it works.
742 */
86478944 743 return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
1da177e4
LT		 744}
745
746static void acm_tty_throttle(struct tty_struct *tty)
747{
748 struct acm *acm = tty->driver_data;
749 if (!ACM_READY(acm))
750 return;
751 spin_lock_bh(&acm->throttle_lock);
752 acm->throttle = 1;
753 spin_unlock_bh(&acm->throttle_lock);
754}
755
756static void acm_tty_unthrottle(struct tty_struct *tty)
757{
758 struct acm *acm = tty->driver_data;
759 if (!ACM_READY(acm))
760 return;
761 spin_lock_bh(&acm->throttle_lock);
762 acm->throttle = 0;
763 spin_unlock_bh(&acm->throttle_lock);
61a87adf 764 tasklet_schedule(&acm->urb_task);
1da177e4
LT		 765}
766
9e98966c 767static int acm_tty_break_ctl(struct tty_struct *tty, int state)
1da177e4
LT		 768{
769 struct acm *acm = tty->driver_data;
9e98966c 770 int retval;
1da177e4 771 if (!ACM_READY(acm))
9e98966c
AC		 772 return -EINVAL;
773 retval = acm_send_break(acm, state ? 0xffff : 0);
774 if (retval < 0)
1da177e4 775 dbg("send break failed");
9e98966c 776 return retval;
1da177e4
LT		 777}
778
779static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
780{
781 struct acm *acm = tty->driver_data;
782
783 if (!ACM_READY(acm))
784 return -EINVAL;
785
786 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
787 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
788 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
789 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
790 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
791 TIOCM_CTS;
792}
793
794static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
795 unsigned int set, unsigned int clear)
796{
797 struct acm *acm = tty->driver_data;
798 unsigned int newctrl;
799
800 if (!ACM_READY(acm))
801 return -EINVAL;
802
803 newctrl = acm->ctrlout;
6e47e069
AC		 804 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
805 (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
806 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
807 (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
1da177e4
LT		 808
809 newctrl = (newctrl & ~clear) | set;
810
811 if (acm->ctrlout == newctrl)
812 return 0;
813 return acm_set_control(acm, acm->ctrlout = newctrl);
814}
815
6e47e069
AC		 816static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
817 unsigned int cmd, unsigned long arg)
1da177e4
LT		 818{
819 struct acm *acm = tty->driver_data;
820
821 if (!ACM_READY(acm))
822 return -EINVAL;
823
824 return -ENOIOCTLCMD;
825}
826
4c4c9432 827static const __u32 acm_tty_speed[] = {
1da177e4
LT		 828 0, 50, 75, 110, 134, 150, 200, 300, 600,
829 1200, 1800, 2400, 4800, 9600, 19200, 38400,
830 57600, 115200, 230400, 460800, 500000, 576000,
831 921600, 1000000, 1152000, 1500000, 2000000,
832 2500000, 3000000, 3500000, 4000000
833};
834
4c4c9432 835static const __u8 acm_tty_size[] = {
1da177e4
LT		 836 5, 6, 7, 8
837};
838
6e47e069
AC		 839static void acm_tty_set_termios(struct tty_struct *tty,
840 struct ktermios *termios_old)
1da177e4
LT		 841{
842 struct acm *acm = tty->driver_data;
606d099c 843 struct ktermios *termios = tty->termios;
1da177e4
LT		 844 struct usb_cdc_line_coding newline;
845 int newctrl = acm->ctrlout;
846
847 if (!ACM_READY(acm))
848 return;
849
9b80fee1 850 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
1da177e4
LT		 851 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
852 newline.bParityType = termios->c_cflag & PARENB ?
6e47e069
AC		 853 (termios->c_cflag & PARODD ? 1 : 2) +
854 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
1da177e4 855 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
6e47e069 856 /* FIXME: Needs to clear unsupported bits in the termios */
1da177e4
LT		 857 acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
858
859 if (!newline.dwDTERate) {
860 newline.dwDTERate = acm->line.dwDTERate;
861 newctrl &= ~ACM_CTRL_DTR;
6e47e069
AC		 862 } else
863 newctrl |= ACM_CTRL_DTR;
1da177e4
LT		 864
865 if (newctrl != acm->ctrlout)
866 acm_set_control(acm, acm->ctrlout = newctrl);
867
868 if (memcmp(&acm->line, &newline, sizeof newline)) {
869 memcpy(&acm->line, &newline, sizeof newline);
870 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
871 newline.bCharFormat, newline.bParityType,
872 newline.bDataBits);
873 acm_set_line(acm, &acm->line);
874 }
875}
876
877/*
878 * USB probe and disconnect routines.
879 */
880
830f4021 881/* Little helpers: write/read buffers free */
884b600f
ON		 882static void acm_write_buffers_free(struct acm *acm)
883{
884 int i;
885 struct acm_wb *wb;
a496c64f 886 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
884b600f 887
6e47e069 888 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
997ea58e 889 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
884b600f
ON		 890}
891
830f4021
ON		 892static void acm_read_buffers_free(struct acm *acm)
893{
894 struct usb_device *usb_dev = interface_to_usbdev(acm->control);
895 int i, n = acm->rx_buflimit;
896
897 for (i = 0; i < n; i++)
997ea58e
DM		 898 usb_free_coherent(usb_dev, acm->readsize,
899 acm->rb[i].base, acm->rb[i].dma);
830f4021
ON		 900}
901
884b600f
ON		 902/* Little helper: write buffers allocate */
903static int acm_write_buffers_alloc(struct acm *acm)
904{
905 int i;
906 struct acm_wb *wb;
907
86478944 908 for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
997ea58e 909 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
884b600f
ON		 910 &wb->dmah);
911 if (!wb->buf) {
912 while (i != 0) {
913 --i;
914 --wb;
997ea58e 915 usb_free_coherent(acm->dev, acm->writesize,
884b600f
ON		 916 wb->buf, wb->dmah);
917 }
918 return -ENOMEM;
919 }
920 }
921 return 0;
922}
923
10077d4a
AC		 924static int acm_probe(struct usb_interface *intf,
925 const struct usb_device_id *id)
1da177e4
LT		 926{
927 struct usb_cdc_union_desc *union_header = NULL;
c4cabd28 928 struct usb_cdc_country_functional_desc *cfd = NULL;
c6dbf554 929 unsigned char *buffer = intf->altsetting->extra;
1da177e4
LT		 930 int buflen = intf->altsetting->extralen;
931 struct usb_interface *control_interface;
932 struct usb_interface *data_interface;
a2bfb4a3
ON		 933 struct usb_endpoint_descriptor *epctrl = NULL;
934 struct usb_endpoint_descriptor *epread = NULL;
935 struct usb_endpoint_descriptor *epwrite = NULL;
1da177e4
LT		 936 struct usb_device *usb_dev = interface_to_usbdev(intf);
937 struct acm *acm;
938 int minor;
6e47e069 939 int ctrlsize, readsize;
1da177e4
LT		 940 u8 *buf;
941 u8 ac_management_function = 0;
942 u8 call_management_function = 0;
943 int call_interface_num = -1;
944 int data_interface_num;
945 unsigned long quirks;
86478944 946 int num_rx_buf;
61a87adf 947 int i;
a2bfb4a3 948 int combined_interfaces = 0;
1da177e4 949
86478944 950 /* normal quirks */
1da177e4 951 quirks = (unsigned long)id->driver_info;
86478944
ON		 952 num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
953
954 /* handle quirks deadly to normal probing*/
1da177e4
LT		 955 if (quirks == NO_UNION_NORMAL) {
956 data_interface = usb_ifnum_to_if(usb_dev, 1);
957 control_interface = usb_ifnum_to_if(usb_dev, 0);
958 goto skip_normal_probe;
959 }
6e47e069 960
1da177e4
LT		 961 /* normal probing*/
962 if (!buffer) {
9908a32e 963 dev_err(&intf->dev, "Weird descriptor references\n");
1da177e4
LT		 964 return -EINVAL;
965 }
966
967 if (!buflen) {
6e47e069
AC		 968 if (intf->cur_altsetting->endpoint->extralen &&
969 intf->cur_altsetting->endpoint->extra) {
970 dev_dbg(&intf->dev,
971 "Seeking extra descriptors on endpoint\n");
1da177e4
LT		 972 buflen = intf->cur_altsetting->endpoint->extralen;
973 buffer = intf->cur_altsetting->endpoint->extra;
974 } else {
9908a32e
GKH		 975 dev_err(&intf->dev,
976 "Zero length descriptor references\n");
1da177e4
LT		 977 return -EINVAL;
978 }
979 }
980
981 while (buflen > 0) {
6e47e069 982 if (buffer[1] != USB_DT_CS_INTERFACE) {
9908a32e 983 dev_err(&intf->dev, "skipping garbage\n");
1da177e4
LT		 984 goto next_desc;
985 }
986
6e47e069
AC		 987 switch (buffer[2]) {
988 case USB_CDC_UNION_TYPE: /* we've found it */
989 if (union_header) {
990 dev_err(&intf->dev, "More than one "
991 "union descriptor, skipping ...\n");
992 goto next_desc;
1da177e4 993 }
6e47e069
AC		 994 union_header = (struct usb_cdc_union_desc *)buffer;
995 break;
996 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
997 cfd = (struct usb_cdc_country_functional_desc *)buffer;
998 break;
999 case USB_CDC_HEADER_TYPE: /* maybe check version */
1000 break; /* for now we ignore it */
1001 case USB_CDC_ACM_TYPE:
1002 ac_management_function = buffer[3];
1003 break;
1004 case USB_CDC_CALL_MANAGEMENT_TYPE:
1005 call_management_function = buffer[3];
1006 call_interface_num = buffer[4];
ce126644 1007 if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
6e47e069
AC		 1008 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1009 break;
1010 default:
1011 /* there are LOTS more CDC descriptors that
1012 * could legitimately be found here.
1013 */
1014 dev_dbg(&intf->dev, "Ignoring descriptor: "
1015 "type %02x, length %d\n",
1016 buffer[2], buffer[0]);
1017 break;
1018 }
1da177e4
LT		 1019next_desc:
1020 buflen -= buffer[0];
1021 buffer += buffer[0];
1022 }
1023
1024 if (!union_header) {
1025 if (call_interface_num > 0) {
6e47e069 1026 dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1da177e4
LT		 1027 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1028 control_interface = intf;
1029 } else {
a2bfb4a3
ON		 1030 if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1031 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1032 return -ENODEV;
1033 } else {
1034 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1035 combined_interfaces = 1;
1036 control_interface = data_interface = intf;
1037 goto look_for_collapsed_interface;
1038 }
1da177e4
LT		 1039 }
1040 } else {
1041 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1042 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1043 if (!control_interface || !data_interface) {
6e47e069 1044 dev_dbg(&intf->dev, "no interfaces\n");
1da177e4
LT		 1045 return -ENODEV;
1046 }
1047 }
6e47e069 1048
1da177e4 1049 if (data_interface_num != call_interface_num)
6e47e069 1050 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1da177e4 1051
a2bfb4a3
ON		 1052 if (control_interface == data_interface) {
1053 /* some broken devices designed for windows work this way */
1054 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1055 combined_interfaces = 1;
1056 /* a popular other OS doesn't use it */
1057 quirks |= NO_CAP_LINE;
1058 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1059 dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1060 return -EINVAL;
1061 }
1062look_for_collapsed_interface:
1063 for (i = 0; i < 3; i++) {
1064 struct usb_endpoint_descriptor *ep;
1065 ep = &data_interface->cur_altsetting->endpoint[i].desc;
1066
1067 if (usb_endpoint_is_int_in(ep))
1068 epctrl = ep;
1069 else if (usb_endpoint_is_bulk_out(ep))
1070 epwrite = ep;
1071 else if (usb_endpoint_is_bulk_in(ep))
1072 epread = ep;
1073 else
1074 return -EINVAL;
1075 }
1076 if (!epctrl || !epread || !epwrite)
1077 return -ENODEV;
1078 else
1079 goto made_compressed_probe;
1080 }
1081
1da177e4
LT		 1082skip_normal_probe:
1083
1084 /*workaround for switched interfaces */
6e47e069
AC		 1085 if (data_interface->cur_altsetting->desc.bInterfaceClass
1086 != CDC_DATA_INTERFACE_TYPE) {
1087 if (control_interface->cur_altsetting->desc.bInterfaceClass
1088 == CDC_DATA_INTERFACE_TYPE) {
1da177e4 1089 struct usb_interface *t;
6e47e069
AC		 1090 dev_dbg(&intf->dev,
1091 "Your device has switched interfaces.\n");
1da177e4
LT		 1092 t = control_interface;
1093 control_interface = data_interface;
1094 data_interface = t;
1095 } else {
1096 return -EINVAL;
1097 }
1098 }
74da5d68
AS		 1099
1100 /* Accept probe requests only for the control interface */
a2bfb4a3 1101 if (!combined_interfaces && intf != control_interface)
74da5d68 1102 return -ENODEV;
6e47e069 1103
a2bfb4a3
ON		 1104 if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1105 /* valid in this context */
6e47e069 1106 dev_dbg(&intf->dev, "The data interface isn't available\n");
1da177e4
LT		 1107 return -EBUSY;
1108 }
1109
1110
1111 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1112 return -EINVAL;
1113
1114 epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1115 epread = &data_interface->cur_altsetting->endpoint[0].desc;
1116 epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1117
1118
1119 /* workaround for switched endpoints */
45aea704 1120 if (!usb_endpoint_dir_in(epread)) {
1da177e4
LT		 1121 /* descriptors are swapped */
1122 struct usb_endpoint_descriptor *t;
6e47e069
AC		 1123 dev_dbg(&intf->dev,
1124 "The data interface has switched endpoints\n");
1da177e4
LT		 1125 t = epread;
1126 epread = epwrite;
1127 epwrite = t;
1128 }
a2bfb4a3 1129made_compressed_probe:
1da177e4
LT		 1130 dbg("interfaces are valid");
1131 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1132
1133 if (minor == ACM_TTY_MINORS) {
9908a32e 1134 dev_err(&intf->dev, "no more free acm devices\n");
1da177e4
LT		 1135 return -ENODEV;
1136 }
1137
6e47e069
AC		 1138 acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1139 if (acm == NULL) {
898eb71c 1140 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1da177e4
LT		 1141 goto alloc_fail;
1142 }
1da177e4
LT		 1143
1144 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
6e47e069
AC		 1145 readsize = le16_to_cpu(epread->wMaxPacketSize) *
1146 (quirks == SINGLE_RX_URB ? 1 : 2);
a2bfb4a3 1147 acm->combined_interfaces = combined_interfaces;
e4cf3aa8 1148 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1da177e4
LT		 1149 acm->control = control_interface;
1150 acm->data = data_interface;
1151 acm->minor = minor;
1152 acm->dev = usb_dev;
1153 acm->ctrl_caps = ac_management_function;
a2bfb4a3
ON		 1154 if (quirks & NO_CAP_LINE)
1155 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1da177e4
LT		 1156 acm->ctrlsize = ctrlsize;
1157 acm->readsize = readsize;
86478944 1158 acm->rx_buflimit = num_rx_buf;
61a87adf
DK		 1159 acm->urb_task.func = acm_rx_tasklet;
1160 acm->urb_task.data = (unsigned long) acm;
c4028958 1161 INIT_WORK(&acm->work, acm_softint);
e5fbab51 1162 init_waitqueue_head(&acm->drain_wait);
1da177e4 1163 spin_lock_init(&acm->throttle_lock);
884b600f 1164 spin_lock_init(&acm->write_lock);
61a87adf 1165 spin_lock_init(&acm->read_lock);
1365baf7 1166 mutex_init(&acm->mutex);
61a87adf 1167 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
cf7fdd57
ON		 1168 acm->is_int_ep = usb_endpoint_xfer_int(epread);
1169 if (acm->is_int_ep)
1170 acm->bInterval = epread->bInterval;
739e0285
AC		 1171 tty_port_init(&acm->port);
1172 acm->port.ops = &acm_port_ops;
1da177e4 1173
997ea58e 1174 buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1da177e4 1175 if (!buf) {
898eb71c 1176 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1da177e4
LT		 1177 goto alloc_fail2;
1178 }
1179 acm->ctrl_buffer = buf;
1180
884b600f 1181 if (acm_write_buffers_alloc(acm) < 0) {
898eb71c 1182 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1da177e4
LT		 1183 goto alloc_fail4;
1184 }
1da177e4
LT		 1185
1186 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1187 if (!acm->ctrlurb) {
898eb71c 1188 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1da177e4
LT		 1189 goto alloc_fail5;
1190 }
86478944 1191 for (i = 0; i < num_rx_buf; i++) {
61a87adf
DK		 1192 struct acm_ru *rcv = &(acm->ru[i]);
1193
6e47e069
AC		 1194 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1195 if (rcv->urb == NULL) {
1196 dev_dbg(&intf->dev,
1197 "out of memory (read urbs usb_alloc_urb)\n");
c2572b78 1198 goto alloc_fail6;
61a87adf
DK		 1199 }
1200
1201 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1202 rcv->instance = acm;
1203 }
86478944 1204 for (i = 0; i < num_rx_buf; i++) {
672c4e18 1205 struct acm_rb *rb = &(acm->rb[i]);
61a87adf 1206
997ea58e 1207 rb->base = usb_alloc_coherent(acm->dev, readsize,
672c4e18
DB		 1208 GFP_KERNEL, &rb->dma);
1209 if (!rb->base) {
6e47e069 1210 dev_dbg(&intf->dev,
997ea58e 1211 "out of memory (read bufs usb_alloc_coherent)\n");
61a87adf
DK		 1212 goto alloc_fail7;
1213 }
1da177e4 1214 }
6e47e069 1215 for (i = 0; i < ACM_NW; i++) {
e4cf3aa8
DE		 1216 struct acm_wb *snd = &(acm->wb[i]);
1217
6e47e069
AC		 1218 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1219 if (snd->urb == NULL) {
1220 dev_dbg(&intf->dev,
1221 "out of memory (write urbs usb_alloc_urb)");
c2572b78 1222 goto alloc_fail8;
e4cf3aa8
DE		 1223 }
1224
5186ffee
AL		 1225 if (usb_endpoint_xfer_int(epwrite))
1226 usb_fill_int_urb(snd->urb, usb_dev,
1227 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1228 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1229 else
1230 usb_fill_bulk_urb(snd->urb, usb_dev,
1231 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1232 NULL, acm->writesize, acm_write_bulk, snd);
e4cf3aa8
DE		 1233 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1234 snd->instance = acm;
1da177e4
LT		 1235 }
1236
6e47e069 1237 usb_set_intfdata(intf, acm);
c4cabd28
ON		 1238
1239 i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1240 if (i < 0)
1241 goto alloc_fail8;
1242
1243 if (cfd) { /* export the country data */
1244 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1245 if (!acm->country_codes)
1246 goto skip_countries;
1247 acm->country_code_size = cfd->bLength - 4;
6e47e069
AC		 1248 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1249 cfd->bLength - 4);
c4cabd28
ON		 1250 acm->country_rel_date = cfd->iCountryCodeRelDate;
1251
1252 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1253 if (i < 0) {
1254 kfree(acm->country_codes);
1255 goto skip_countries;
1256 }
1257
6e47e069
AC		 1258 i = device_create_file(&intf->dev,
1259 &dev_attr_iCountryCodeRelDate);
c4cabd28 1260 if (i < 0) {
c2572b78 1261 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
c4cabd28
ON		 1262 kfree(acm->country_codes);
1263 goto skip_countries;
1264 }
1265 }
1266
1267skip_countries:
6e47e069 1268 usb_fill_int_urb(acm->ctrlurb, usb_dev,
a2bfb4a3
ON		 1269 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1270 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1271 /* works around buggy devices */
1272 epctrl->bInterval ? epctrl->bInterval : 0xff);
1da177e4
LT		 1273 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1274 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1275
1da177e4
LT		 1276 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1277
1278 acm_set_control(acm, acm->ctrlout);
1279
1280 acm->line.dwDTERate = cpu_to_le32(9600);
1281 acm->line.bDataBits = 8;
1282 acm_set_line(acm, &acm->line);
1283
1284 usb_driver_claim_interface(&acm_driver, data_interface, acm);
672c4e18 1285 usb_set_intfdata(data_interface, acm);
1da177e4 1286
83ef344a 1287 usb_get_intf(control_interface);
1288 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1da177e4
LT		 1289
1290 acm_table[minor] = acm;
1da177e4 1291
c4cabd28
ON		 1292 return 0;
1293alloc_fail8:
e4cf3aa8
DE		 1294 for (i = 0; i < ACM_NW; i++)
1295 usb_free_urb(acm->wb[i].urb);
1da177e4 1296alloc_fail7:
830f4021 1297 acm_read_buffers_free(acm);
c2572b78 1298alloc_fail6:
86478944 1299 for (i = 0; i < num_rx_buf; i++)
61a87adf 1300 usb_free_urb(acm->ru[i].urb);
1da177e4
LT		 1301 usb_free_urb(acm->ctrlurb);
1302alloc_fail5:
884b600f 1303 acm_write_buffers_free(acm);
1da177e4 1304alloc_fail4:
997ea58e 1305 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1da177e4
LT		 1306alloc_fail2:
1307 kfree(acm);
1308alloc_fail:
1309 return -ENOMEM;
1310}
1311
1365baf7
ON		 1312static void stop_data_traffic(struct acm *acm)
1313{
1314 int i;
11ea859d 1315 dbg("Entering stop_data_traffic");
1365baf7
ON		 1316
1317 tasklet_disable(&acm->urb_task);
1318
1319 usb_kill_urb(acm->ctrlurb);
6e47e069 1320 for (i = 0; i < ACM_NW; i++)
e4cf3aa8 1321 usb_kill_urb(acm->wb[i].urb);
1365baf7
ON		 1322 for (i = 0; i < acm->rx_buflimit; i++)
1323 usb_kill_urb(acm->ru[i].urb);
1324
1365baf7
ON		 1325 tasklet_enable(&acm->urb_task);
1326
1327 cancel_work_sync(&acm->work);
1328}
1329
1da177e4
LT		 1330static void acm_disconnect(struct usb_interface *intf)
1331{
c4cabd28 1332 struct acm *acm = usb_get_intfdata(intf);
1da177e4 1333 struct usb_device *usb_dev = interface_to_usbdev(intf);
10077d4a 1334 struct tty_struct *tty;
1da177e4 1335
672c4e18
DB		 1336 /* sibling interface is already cleaning up */
1337 if (!acm)
86067eea 1338 return;
672c4e18
DB		 1339
1340 mutex_lock(&open_mutex);
6e47e069 1341 if (acm->country_codes) {
74da5d68
AS		 1342 device_remove_file(&acm->control->dev,
1343 &dev_attr_wCountryCodes);
1344 device_remove_file(&acm->control->dev,
1345 &dev_attr_iCountryCodeRelDate);
c4cabd28 1346 }
74da5d68 1347 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1da177e4 1348 acm->dev = NULL;
86067eea
ON		 1349 usb_set_intfdata(acm->control, NULL);
1350 usb_set_intfdata(acm->data, NULL);
1da177e4 1351
1365baf7 1352 stop_data_traffic(acm);
1da177e4 1353
884b600f 1354 acm_write_buffers_free(acm);
997ea58e
DM		 1355 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1356 acm->ctrl_dma);
830f4021 1357 acm_read_buffers_free(acm);
1da177e4 1358
a2bfb4a3
ON		 1359 if (!acm->combined_interfaces)
1360 usb_driver_release_interface(&acm_driver, intf == acm->control ?
830f4021 1361 acm->data : acm->control);
1da177e4 1362
10077d4a 1363 if (acm->port.count == 0) {
83ef344a 1364 acm_tty_unregister(acm);
4186ecf8 1365 mutex_unlock(&open_mutex);
1da177e4
LT		 1366 return;
1367 }
1368
4186ecf8 1369 mutex_unlock(&open_mutex);
10077d4a
AC		 1370 tty = tty_port_tty_get(&acm->port);
1371 if (tty) {
1372 tty_hangup(tty);
1373 tty_kref_put(tty);
1374 }
1da177e4
LT		 1375}
1376
35758589 1377#ifdef CONFIG_PM
1365baf7
ON		 1378static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1379{
1380 struct acm *acm = usb_get_intfdata(intf);
11ea859d
ON		 1381 int cnt;
1382
65bfd296 1383 if (message.event & PM_EVENT_AUTO) {
11ea859d
ON		 1384 int b;
1385
1386 spin_lock_irq(&acm->read_lock);
1387 spin_lock(&acm->write_lock);
1388 b = acm->processing + acm->transmitting;
1389 spin_unlock(&acm->write_lock);
1390 spin_unlock_irq(&acm->read_lock);
1391 if (b)
1392 return -EBUSY;
1393 }
1394
1395 spin_lock_irq(&acm->read_lock);
1396 spin_lock(&acm->write_lock);
1397 cnt = acm->susp_count++;
1398 spin_unlock(&acm->write_lock);
1399 spin_unlock_irq(&acm->read_lock);
1365baf7 1400
11ea859d 1401 if (cnt)
1365baf7
ON		 1402 return 0;
1403 /*
1404 we treat opened interfaces differently,
1405 we must guard against open
1406 */
1407 mutex_lock(&acm->mutex);
1408
10077d4a 1409 if (acm->port.count)
1365baf7
ON		 1410 stop_data_traffic(acm);
1411
1412 mutex_unlock(&acm->mutex);
1413 return 0;
1414}
1415
1416static int acm_resume(struct usb_interface *intf)
1417{
1418 struct acm *acm = usb_get_intfdata(intf);
97d35f95 1419 struct acm_wb *wb;
1365baf7 1420 int rv = 0;
11ea859d 1421 int cnt;
1365baf7 1422
11ea859d
ON		 1423 spin_lock_irq(&acm->read_lock);
1424 acm->susp_count -= 1;
1425 cnt = acm->susp_count;
1426 spin_unlock_irq(&acm->read_lock);
1427
1428 if (cnt)
1365baf7
ON		 1429 return 0;
1430
1431 mutex_lock(&acm->mutex);
10077d4a 1432 if (acm->port.count) {
1365baf7 1433 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
97d35f95
ON		 1434
1435 spin_lock_irq(&acm->write_lock);
1436 if (acm->delayed_wb) {
1437 wb = acm->delayed_wb;
1438 acm->delayed_wb = NULL;
1439 spin_unlock_irq(&acm->write_lock);
f0730924 1440 acm_start_wb(acm, wb);
97d35f95
ON		 1441 } else {
1442 spin_unlock_irq(&acm->write_lock);
1443 }
1444
1445 /*
1446 * delayed error checking because we must
1447 * do the write path at all cost
1448 */
1365baf7 1449 if (rv < 0)
11ea859d 1450 goto err_out;
1365baf7
ON		 1451
1452 tasklet_schedule(&acm->urb_task);
1453 }
1454
1455err_out:
1456 mutex_unlock(&acm->mutex);
1457 return rv;
1458}
35758589 1459
a91b0c50
FL		 1460static int acm_reset_resume(struct usb_interface *intf)
1461{
1462 struct acm *acm = usb_get_intfdata(intf);
1463 struct tty_struct *tty;
1464
1465 mutex_lock(&acm->mutex);
1466 if (acm->port.count) {
1467 tty = tty_port_tty_get(&acm->port);
1468 if (tty) {
1469 tty_hangup(tty);
1470 tty_kref_put(tty);
1471 }
1472 }
1473 mutex_unlock(&acm->mutex);
1474 return acm_resume(intf);
1475}
1476
35758589 1477#endif /* CONFIG_PM */
c1479a92
AT		 1478
1479#define NOKIA_PCSUITE_ACM_INFO(x) \
1480 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1481 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1482 USB_CDC_ACM_PROTO_VENDOR)
1483
4035e456
TG		 1484#define SAMSUNG_PCSUITE_ACM_INFO(x) \
1485 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1486 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1487 USB_CDC_ACM_PROTO_VENDOR)
1488
1da177e4
LT		 1489/*
1490 * USB driver structure.
1491 */
1492
6ef4852b 1493static const struct usb_device_id acm_ids[] = {
1da177e4
LT		 1494 /* quirky and broken devices */
1495 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1496 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1497 },
b0e2a705
AA		 1498 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1499 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1500 },
0f9c7b4a
AL		 1501 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1502 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503 },
8753e65e
MO		 1504 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1505 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1506 },
91a9c921
CM		 1507 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1508 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1509 },
7abcf20b
AC		 1510 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1511 .driver_info = SINGLE_RX_URB,
1512 },
86478944
ON		 1513 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1514 .driver_info = SINGLE_RX_URB, /* firmware bug */
1515 },
3dd2ae81
ON		 1516 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1517 .driver_info = SINGLE_RX_URB, /* firmware bug */
1518 },
9be8456c
ON		 1519 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1520 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1521 },
6149ed5e
IM		 1522 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1523 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1524 },
c8fd2c37
ES		 1525 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1526 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1527 },
c89c60e9
AC		 1528 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1529 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1530 },
cab98a0a
XK		 1531 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1532 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1533 },
155df65a
DT		 1534 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1535 },
c332b4e1
AR		 1536 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1537 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1538 data interface instead of
1539 communications interface.
1540 Maybe we should define a new
1541 quirk for this. */
1542 },
1f17c502
KK		 1543 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1544 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1545 },
c3baa19b
RN		 1546 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1547 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1548 },
9be8456c 1549
c1479a92
AT		 1550 /* Nokia S60 phones expose two ACM channels. The first is
1551 * a modem and is picked up by the standard AT-command
1552 * information below. The second is 'vendor-specific' but
1553 * is treated as a serial device at the S60 end, so we want
1554 * to expose it on Linux too. */
1555 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1556 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1557 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1558 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1559 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1560 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1561 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1562 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1563 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1564 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1565 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1566 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1567 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1568 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1569 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1570 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1571 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1572 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1573 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1574 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1575 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1576 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1577 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1578 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1579 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1580 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1581 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1582 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1583 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1584 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1585 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1586 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1587 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1588 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1589 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1590 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1591 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1592 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1593 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1594 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1595 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1596 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1597 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
83a4eae9 1598 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
4035e456
TG		 1599 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1600 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1601 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1602 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1603 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1604 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1605 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1606 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1607 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1608 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1609 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
c1479a92
AT		 1610
1611 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1612
7c5d8c39 1613 /* Support Lego NXT using pbLua firmware */
ce126644
JC		 1614 { USB_DEVICE(0x0694, 0xff00),
1615 .driver_info = NOT_A_MODEM,
1616 },
7c5d8c39 1617
1da177e4
LT		 1618 /* control interfaces with various AT-command sets */
1619 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1620 USB_CDC_ACM_PROTO_AT_V25TER) },
1621 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1622 USB_CDC_ACM_PROTO_AT_PCCA101) },
1623 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1624 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1625 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1626 USB_CDC_ACM_PROTO_AT_GSM) },
1627 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
6e47e069 1628 USB_CDC_ACM_PROTO_AT_3G) },
1da177e4
LT		 1629 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1630 USB_CDC_ACM_PROTO_AT_CDMA) },
1631
1da177e4
LT		 1632 { }
1633};
1634
6e47e069 1635MODULE_DEVICE_TABLE(usb, acm_ids);
1da177e4
LT		 1636
1637static struct usb_driver acm_driver = {
1da177e4
LT		 1638 .name = "cdc_acm",
1639 .probe = acm_probe,
1640 .disconnect = acm_disconnect,
35758589 1641#ifdef CONFIG_PM
1365baf7
ON		 1642 .suspend = acm_suspend,
1643 .resume = acm_resume,
a91b0c50 1644 .reset_resume = acm_reset_resume,
35758589 1645#endif
1da177e4 1646 .id_table = acm_ids,
35758589 1647#ifdef CONFIG_PM
1365baf7 1648 .supports_autosuspend = 1,
35758589 1649#endif
1da177e4
LT		 1650};
1651
1652/*
1653 * TTY driver structures.
1654 */
1655
b68e31d0 1656static const struct tty_operations acm_ops = {
1da177e4
LT		 1657 .open = acm_tty_open,
1658 .close = acm_tty_close,
10077d4a 1659 .hangup = acm_tty_hangup,
1da177e4
LT		 1660 .write = acm_tty_write,
1661 .write_room = acm_tty_write_room,
1662 .ioctl = acm_tty_ioctl,
1663 .throttle = acm_tty_throttle,
1664 .unthrottle = acm_tty_unthrottle,
1665 .chars_in_buffer = acm_tty_chars_in_buffer,
1666 .break_ctl = acm_tty_break_ctl,
1667 .set_termios = acm_tty_set_termios,
1668 .tiocmget = acm_tty_tiocmget,
1669 .tiocmset = acm_tty_tiocmset,
1670};
1671
1672/*
1673 * Init / exit.
1674 */
1675
1676static int __init acm_init(void)
1677{
1678 int retval;
1679 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1680 if (!acm_tty_driver)
1681 return -ENOMEM;
1682 acm_tty_driver->owner = THIS_MODULE,
1683 acm_tty_driver->driver_name = "acm",
1684 acm_tty_driver->name = "ttyACM",
1da177e4
LT		 1685 acm_tty_driver->major = ACM_TTY_MAJOR,
1686 acm_tty_driver->minor_start = 0,
1687 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1688 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
331b8319 1689 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1da177e4 1690 acm_tty_driver->init_termios = tty_std_termios;
6e47e069
AC		 1691 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1692 HUPCL | CLOCAL;
1da177e4
LT		 1693 tty_set_operations(acm_tty_driver, &acm_ops);
1694
1695 retval = tty_register_driver(acm_tty_driver);
1696 if (retval) {
1697 put_tty_driver(acm_tty_driver);
1698 return retval;
1699 }
1700
1701 retval = usb_register(&acm_driver);
1702 if (retval) {
1703 tty_unregister_driver(acm_tty_driver);
1704 put_tty_driver(acm_tty_driver);
1705 return retval;
1706 }
1707
5909f6ea
GKH		 1708 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1709 DRIVER_DESC "\n");
1da177e4
LT		 1710
1711 return 0;
1712}
1713
1714static void __exit acm_exit(void)
1715{
1716 usb_deregister(&acm_driver);
1717 tty_unregister_driver(acm_tty_driver);
1718 put_tty_driver(acm_tty_driver);
1719}
1720
1721module_init(acm_init);
1722module_exit(acm_exit);
1723
6e47e069
AC		 1724MODULE_AUTHOR(DRIVER_AUTHOR);
1725MODULE_DESCRIPTION(DRIVER_DESC);
1da177e4 1726MODULE_LICENSE("GPL");
e766aeb8 1727MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
Linux kernel - Deliverables
This page took 0.759025 seconds and 5 git commands to generate.