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