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