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