?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drivers/usb/class/cdc-acm.c: clear dangling pointer
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / class / cdc-acm.c
blobea5e487448bf12fff367836d4db97c5b06c36e9a
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 = usb_endpoint_maxp(epctrl);
1064 readsize = usb_endpoint_maxp(epread) *
1065 (quirks == SINGLE_RX_URB ? 1 : 2);
1066 acm->combined_interfaces = combined_interfaces;
1067 acm->writesize = usb_endpoint_maxp(epwrite) * 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 acm->country_codes = NULL;
1187 acm->country_code_size = 0;
1188 goto skip_countries;
1189 }
1190
1191 i = device_create_file(&intf->dev,
1192 &dev_attr_iCountryCodeRelDate);
1193 if (i < 0) {
1194 device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1195 kfree(acm->country_codes);
1196 acm->country_codes = NULL;
1197 acm->country_code_size = 0;
1198 goto skip_countries;
1199 }
1200 }
1201
1202 skip_countries:
1203 usb_fill_int_urb(acm->ctrlurb, usb_dev,
1204 usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1205 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1206 /* works around buggy devices */
1207 epctrl->bInterval ? epctrl->bInterval : 0xff);
1208 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1209 acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1210
1211 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1212
1213 acm_set_control(acm, acm->ctrlout);
1214
1215 acm->line.dwDTERate = cpu_to_le32(9600);
1216 acm->line.bDataBits = 8;
1217 acm_set_line(acm, &acm->line);
1218
1219 usb_driver_claim_interface(&acm_driver, data_interface, acm);
1220 usb_set_intfdata(data_interface, acm);
1221
1222 usb_get_intf(control_interface);
1223 tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1224
1225 acm_table[minor] = acm;
1226
1227 return 0;
1228 alloc_fail7:
1229 for (i = 0; i < ACM_NW; i++)
1230 usb_free_urb(acm->wb[i].urb);
1231 alloc_fail6:
1232 for (i = 0; i < num_rx_buf; i++)
1233 usb_free_urb(acm->read_urbs[i]);
1234 acm_read_buffers_free(acm);
1235 usb_free_urb(acm->ctrlurb);
1236 alloc_fail5:
1237 acm_write_buffers_free(acm);
1238 alloc_fail4:
1239 usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1240 alloc_fail2:
1241 kfree(acm);
1242 alloc_fail:
1243 return -ENOMEM;
1244 }
1245
1246 static void stop_data_traffic(struct acm *acm)
1247 {
1248 int i;
1249
1250 dev_dbg(&acm->control->dev, "%s\n", __func__);
1251
1252 usb_kill_urb(acm->ctrlurb);
1253 for (i = 0; i < ACM_NW; i++)
1254 usb_kill_urb(acm->wb[i].urb);
1255 for (i = 0; i < acm->rx_buflimit; i++)
1256 usb_kill_urb(acm->read_urbs[i]);
1257
1258 cancel_work_sync(&acm->work);
1259 }
1260
1261 static void acm_disconnect(struct usb_interface *intf)
1262 {
1263 struct acm *acm = usb_get_intfdata(intf);
1264 struct usb_device *usb_dev = interface_to_usbdev(intf);
1265 struct tty_struct *tty;
1266
1267 /* sibling interface is already cleaning up */
1268 if (!acm)
1269 return;
1270
1271 mutex_lock(&open_mutex);
1272 if (acm->country_codes) {
1273 device_remove_file(&acm->control->dev,
1274 &dev_attr_wCountryCodes);
1275 device_remove_file(&acm->control->dev,
1276 &dev_attr_iCountryCodeRelDate);
1277 }
1278 device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1279 acm->dev = NULL;
1280 usb_set_intfdata(acm->control, NULL);
1281 usb_set_intfdata(acm->data, NULL);
1282
1283 stop_data_traffic(acm);
1284
1285 acm_write_buffers_free(acm);
1286 usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1287 acm->ctrl_dma);
1288 acm_read_buffers_free(acm);
1289
1290 if (!acm->combined_interfaces)
1291 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1292 acm->data : acm->control);
1293
1294 if (acm->port.count == 0) {
1295 acm_tty_unregister(acm);
1296 mutex_unlock(&open_mutex);
1297 return;
1298 }
1299
1300 mutex_unlock(&open_mutex);
1301 tty = tty_port_tty_get(&acm->port);
1302 if (tty) {
1303 tty_hangup(tty);
1304 tty_kref_put(tty);
1305 }
1306 }
1307
1308 #ifdef CONFIG_PM
1309 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1310 {
1311 struct acm *acm = usb_get_intfdata(intf);
1312 int cnt;
1313
1314 if (PMSG_IS_AUTO(message)) {
1315 int b;
1316
1317 spin_lock_irq(&acm->write_lock);
1318 b = acm->transmitting;
1319 spin_unlock_irq(&acm->write_lock);
1320 if (b)
1321 return -EBUSY;
1322 }
1323
1324 spin_lock_irq(&acm->read_lock);
1325 spin_lock(&acm->write_lock);
1326 cnt = acm->susp_count++;
1327 spin_unlock(&acm->write_lock);
1328 spin_unlock_irq(&acm->read_lock);
1329
1330 if (cnt)
1331 return 0;
1332 /*
1333 we treat opened interfaces differently,
1334 we must guard against open
1335 */
1336 mutex_lock(&acm->mutex);
1337
1338 if (acm->port.count)
1339 stop_data_traffic(acm);
1340
1341 mutex_unlock(&acm->mutex);
1342 return 0;
1343 }
1344
1345 static int acm_resume(struct usb_interface *intf)
1346 {
1347 struct acm *acm = usb_get_intfdata(intf);
1348 struct acm_wb *wb;
1349 int rv = 0;
1350 int cnt;
1351
1352 spin_lock_irq(&acm->read_lock);
1353 acm->susp_count -= 1;
1354 cnt = acm->susp_count;
1355 spin_unlock_irq(&acm->read_lock);
1356
1357 if (cnt)
1358 return 0;
1359
1360 mutex_lock(&acm->mutex);
1361 if (acm->port.count) {
1362 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1363
1364 spin_lock_irq(&acm->write_lock);
1365 if (acm->delayed_wb) {
1366 wb = acm->delayed_wb;
1367 acm->delayed_wb = NULL;
1368 spin_unlock_irq(&acm->write_lock);
1369 acm_start_wb(acm, wb);
1370 } else {
1371 spin_unlock_irq(&acm->write_lock);
1372 }
1373
1374 /*
1375 * delayed error checking because we must
1376 * do the write path at all cost
1377 */
1378 if (rv < 0)
1379 goto err_out;
1380
1381 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1382 }
1383
1384 err_out:
1385 mutex_unlock(&acm->mutex);
1386 return rv;
1387 }
1388
1389 static int acm_reset_resume(struct usb_interface *intf)
1390 {
1391 struct acm *acm = usb_get_intfdata(intf);
1392 struct tty_struct *tty;
1393
1394 mutex_lock(&acm->mutex);
1395 if (acm->port.count) {
1396 tty = tty_port_tty_get(&acm->port);
1397 if (tty) {
1398 tty_hangup(tty);
1399 tty_kref_put(tty);
1400 }
1401 }
1402 mutex_unlock(&acm->mutex);
1403 return acm_resume(intf);
1404 }
1405
1406 #endif /* CONFIG_PM */
1407
1408 #define NOKIA_PCSUITE_ACM_INFO(x) \
1409 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1410 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1411 USB_CDC_ACM_PROTO_VENDOR)
1412
1413 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1414 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1415 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1416 USB_CDC_ACM_PROTO_VENDOR)
1417
1418 /*
1419 * USB driver structure.
1420 */
1421
1422 static const struct usb_device_id acm_ids[] = {
1423 /* quirky and broken devices */
1424 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1425 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1426 },
1427 { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1428 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1429 },
1430 { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1431 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1432 },
1433 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1434 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1435 },
1436 { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1437 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1438 },
1439 { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1440 .driver_info = SINGLE_RX_URB,
1441 },
1442 { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1443 .driver_info = SINGLE_RX_URB, /* firmware bug */
1444 },
1445 { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1446 .driver_info = SINGLE_RX_URB, /* firmware bug */
1447 },
1448 { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1449 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1450 },
1451 { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1452 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1453 },
1454 { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1455 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1456 },
1457 { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1458 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1459 },
1460 { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1461 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1462 },
1463 { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1464 },
1465 /* Motorola H24 HSPA module: */
1466 { USB_DEVICE(0x22b8, 0x2d91) }, /* modem */
1467 { USB_DEVICE(0x22b8, 0x2d92) }, /* modem + diagnostics */
1468 { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port */
1469 { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics */
1470 { USB_DEVICE(0x22b8, 0x2d96) }, /* modem + NMEA */
1471 { USB_DEVICE(0x22b8, 0x2d97) }, /* modem + diagnostics + NMEA */
1472 { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port + NMEA */
1473 { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1474
1475 { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1476 .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1477 data interface instead of
1478 communications interface.
1479 Maybe we should define a new
1480 quirk for this. */
1481 },
1482 { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1483 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1484 },
1485 { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1486 .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1487 },
1488
1489 /* Nokia S60 phones expose two ACM channels. The first is
1490 * a modem and is picked up by the standard AT-command
1491 * information below. The second is 'vendor-specific' but
1492 * is treated as a serial device at the S60 end, so we want
1493 * to expose it on Linux too. */
1494 { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1495 { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1496 { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1497 { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1498 { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1499 { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1500 { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1501 { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1502 { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1503 { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1504 { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1505 { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1506 { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1507 { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1508 { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1509 { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1510 { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1511 { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i */
1512 { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1513 { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1514 { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1515 { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic & */
1516 { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1517 { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1518 { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1519 { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1520 { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1521 { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1522 { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1523 { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1524 { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1525 { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB */
1526 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1527 { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1528 { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1529 { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1530 { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1531 { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1532 { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1533 { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3 */
1534 { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1535 { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1536 { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1537 { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1538 { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1539 { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1540 { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1541 { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1542 { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1543 { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1544 { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1545 { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1546 { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1547 { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1548 { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1549 { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1550 { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1551 { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1552
1553 /* Support for Owen devices */
1554 { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1555
1556 /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1557
1558 /* Support Lego NXT using pbLua firmware */
1559 { USB_DEVICE(0x0694, 0xff00),
1560 .driver_info = NOT_A_MODEM,
1561 },
1562
1563 /* Support for Droids MuIn LCD */
1564 { USB_DEVICE(0x04d8, 0x000b),
1565 .driver_info = NO_DATA_INTERFACE,
1566 },
1567
1568 /* control interfaces without any protocol set */
1569 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1570 USB_CDC_PROTO_NONE) },
1571
1572 /* control interfaces with various AT-command sets */
1573 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1574 USB_CDC_ACM_PROTO_AT_V25TER) },
1575 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1576 USB_CDC_ACM_PROTO_AT_PCCA101) },
1577 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1578 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1579 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1580 USB_CDC_ACM_PROTO_AT_GSM) },
1581 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1582 USB_CDC_ACM_PROTO_AT_3G) },
1583 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1584 USB_CDC_ACM_PROTO_AT_CDMA) },
1585
1586 { }
1587 };
1588
1589 MODULE_DEVICE_TABLE(usb, acm_ids);
1590
1591 static struct usb_driver acm_driver = {
1592 .name = "cdc_acm",
1593 .probe = acm_probe,
1594 .disconnect = acm_disconnect,
1595 #ifdef CONFIG_PM
1596 .suspend = acm_suspend,
1597 .resume = acm_resume,
1598 .reset_resume = acm_reset_resume,
1599 #endif
1600 .id_table = acm_ids,
1601 #ifdef CONFIG_PM
1602 .supports_autosuspend = 1,
1603 #endif
1604 };
1605
1606 /*
1607 * TTY driver structures.
1608 */
1609
1610 static const struct tty_operations acm_ops = {
1611 .open = acm_tty_open,
1612 .close = acm_tty_close,
1613 .hangup = acm_tty_hangup,
1614 .write = acm_tty_write,
1615 .write_room = acm_tty_write_room,
1616 .ioctl = acm_tty_ioctl,
1617 .throttle = acm_tty_throttle,
1618 .unthrottle = acm_tty_unthrottle,
1619 .chars_in_buffer = acm_tty_chars_in_buffer,
1620 .break_ctl = acm_tty_break_ctl,
1621 .set_termios = acm_tty_set_termios,
1622 .tiocmget = acm_tty_tiocmget,
1623 .tiocmset = acm_tty_tiocmset,
1624 };
1625
1626 /*
1627 * Init / exit.
1628 */
1629
1630 static int __init acm_init(void)
1631 {
1632 int retval;
1633 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1634 if (!acm_tty_driver)
1635 return -ENOMEM;
1636 acm_tty_driver->owner = THIS_MODULE,
1637 acm_tty_driver->driver_name = "acm",
1638 acm_tty_driver->name = "ttyACM",
1639 acm_tty_driver->major = ACM_TTY_MAJOR,
1640 acm_tty_driver->minor_start = 0,
1641 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1642 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1643 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1644 acm_tty_driver->init_termios = tty_std_termios;
1645 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1646 HUPCL | CLOCAL;
1647 tty_set_operations(acm_tty_driver, &acm_ops);
1648
1649 retval = tty_register_driver(acm_tty_driver);
1650 if (retval) {
1651 put_tty_driver(acm_tty_driver);
1652 return retval;
1653 }
1654
1655 retval = usb_register(&acm_driver);
1656 if (retval) {
1657 tty_unregister_driver(acm_tty_driver);
1658 put_tty_driver(acm_tty_driver);
1659 return retval;
1660 }
1661
1662 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1663
1664 return 0;
1665 }
1666
1667 static void __exit acm_exit(void)
1668 {
1669 usb_deregister(&acm_driver);
1670 tty_unregister_driver(acm_tty_driver);
1671 put_tty_driver(acm_tty_driver);
1672 }
1673
1674 module_init(acm_init);
1675 module_exit(acm_exit);
1676
1677 MODULE_AUTHOR(DRIVER_AUTHOR);
1678 MODULE_DESCRIPTION(DRIVER_DESC);
1679 MODULE_LICENSE("GPL");
1680 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree