320db2a585adf43044f0c593c9d3bc312f70de55
[pandora-kernel.git] / drivers / usb / class / cdc-acm.c
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         /*
502          * Unthrottle device in case the TTY was closed while throttled.
503          */
504         spin_lock_irq(&acm->read_lock);
505         acm->throttled = 0;
506         acm->throttle_req = 0;
507         spin_unlock_irq(&acm->read_lock);
508
509         if (acm_submit_read_urbs(acm, GFP_KERNEL))
510                 goto bail_out;
511
512         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
513         rv = tty_port_block_til_ready(&acm->port, tty, filp);
514
515         mutex_unlock(&acm->mutex);
516 out:
517         mutex_unlock(&open_mutex);
518         return rv;
519
520 bail_out:
521         acm->port.count--;
522         mutex_unlock(&acm->mutex);
523         usb_autopm_put_interface(acm->control);
524 early_bail:
525         mutex_unlock(&open_mutex);
526         tty_port_tty_set(&acm->port, NULL);
527         return -EIO;
528 }
529
530 static void acm_tty_unregister(struct acm *acm)
531 {
532         int i;
533
534         tty_unregister_device(acm_tty_driver, acm->minor);
535         usb_put_intf(acm->control);
536         acm_table[acm->minor] = NULL;
537         usb_free_urb(acm->ctrlurb);
538         for (i = 0; i < ACM_NW; i++)
539                 usb_free_urb(acm->wb[i].urb);
540         for (i = 0; i < acm->rx_buflimit; i++)
541                 usb_free_urb(acm->read_urbs[i]);
542         kfree(acm->country_codes);
543         kfree(acm);
544 }
545
546 static void acm_port_down(struct acm *acm)
547 {
548         int i;
549
550         if (acm->dev) {
551                 usb_autopm_get_interface(acm->control);
552                 acm_set_control(acm, acm->ctrlout = 0);
553                 usb_kill_urb(acm->ctrlurb);
554                 for (i = 0; i < ACM_NW; i++)
555                         usb_kill_urb(acm->wb[i].urb);
556                 for (i = 0; i < acm->rx_buflimit; i++)
557                         usb_kill_urb(acm->read_urbs[i]);
558                 acm->control->needs_remote_wakeup = 0;
559                 usb_autopm_put_interface(acm->control);
560         }
561 }
562
563 static void acm_tty_hangup(struct tty_struct *tty)
564 {
565         struct acm *acm;
566
567         mutex_lock(&open_mutex);
568         acm = tty->driver_data;
569
570         if (!acm)
571                 goto out;
572
573         tty_port_hangup(&acm->port);
574         acm_port_down(acm);
575
576 out:
577         mutex_unlock(&open_mutex);
578 }
579
580 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
581 {
582         struct acm *acm = tty->driver_data;
583
584         /* Perform the closing process and see if we need to do the hardware
585            shutdown */
586         if (!acm)
587                 return;
588
589         mutex_lock(&open_mutex);
590         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
591                 if (!acm->dev) {
592                         tty_port_tty_set(&acm->port, NULL);
593                         acm_tty_unregister(acm);
594                         tty->driver_data = NULL;
595                 }
596                 mutex_unlock(&open_mutex);
597                 return;
598         }
599         acm_port_down(acm);
600         tty_port_close_end(&acm->port, tty);
601         tty_port_tty_set(&acm->port, NULL);
602         mutex_unlock(&open_mutex);
603 }
604
605 static int acm_tty_write(struct tty_struct *tty,
606                                         const unsigned char *buf, int count)
607 {
608         struct acm *acm = tty->driver_data;
609         int stat;
610         unsigned long flags;
611         int wbn;
612         struct acm_wb *wb;
613
614         if (!ACM_READY(acm))
615                 return -EINVAL;
616         if (!count)
617                 return 0;
618
619         dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
620
621         spin_lock_irqsave(&acm->write_lock, flags);
622         wbn = acm_wb_alloc(acm);
623         if (wbn < 0) {
624                 spin_unlock_irqrestore(&acm->write_lock, flags);
625                 return 0;
626         }
627         wb = &acm->wb[wbn];
628
629         count = (count > acm->writesize) ? acm->writesize : count;
630         dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
631         memcpy(wb->buf, buf, count);
632         wb->len = count;
633         spin_unlock_irqrestore(&acm->write_lock, flags);
634
635         stat = acm_write_start(acm, wbn);
636         if (stat < 0)
637                 return stat;
638         return count;
639 }
640
641 static int acm_tty_write_room(struct tty_struct *tty)
642 {
643         struct acm *acm = tty->driver_data;
644         if (!ACM_READY(acm))
645                 return -EINVAL;
646         /*
647          * Do not let the line discipline to know that we have a reserve,
648          * or it might get too enthusiastic.
649          */
650         return acm_wb_is_avail(acm) ? acm->writesize : 0;
651 }
652
653 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
654 {
655         struct acm *acm = tty->driver_data;
656         if (!ACM_READY(acm))
657                 return 0;
658         /*
659          * This is inaccurate (overcounts), but it works.
660          */
661         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
662 }
663
664 static void acm_tty_throttle(struct tty_struct *tty)
665 {
666         struct acm *acm = tty->driver_data;
667
668         if (!ACM_READY(acm))
669                 return;
670
671         spin_lock_irq(&acm->read_lock);
672         acm->throttle_req = 1;
673         spin_unlock_irq(&acm->read_lock);
674 }
675
676 static void acm_tty_unthrottle(struct tty_struct *tty)
677 {
678         struct acm *acm = tty->driver_data;
679         unsigned int was_throttled;
680
681         if (!ACM_READY(acm))
682                 return;
683
684         spin_lock_irq(&acm->read_lock);
685         was_throttled = acm->throttled;
686         acm->throttled = 0;
687         acm->throttle_req = 0;
688         spin_unlock_irq(&acm->read_lock);
689
690         if (was_throttled)
691                 acm_submit_read_urbs(acm, GFP_KERNEL);
692 }
693
694 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
695 {
696         struct acm *acm = tty->driver_data;
697         int retval;
698         if (!ACM_READY(acm))
699                 return -EINVAL;
700         retval = acm_send_break(acm, state ? 0xffff : 0);
701         if (retval < 0)
702                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
703                                                                 __func__);
704         return retval;
705 }
706
707 static int acm_tty_tiocmget(struct tty_struct *tty)
708 {
709         struct acm *acm = tty->driver_data;
710
711         if (!ACM_READY(acm))
712                 return -EINVAL;
713
714         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
715                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
716                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
717                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
718                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
719                TIOCM_CTS;
720 }
721
722 static int acm_tty_tiocmset(struct tty_struct *tty,
723                             unsigned int set, unsigned int clear)
724 {
725         struct acm *acm = tty->driver_data;
726         unsigned int newctrl;
727
728         if (!ACM_READY(acm))
729                 return -EINVAL;
730
731         newctrl = acm->ctrlout;
732         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
733                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
734         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
735                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
736
737         newctrl = (newctrl & ~clear) | set;
738
739         if (acm->ctrlout == newctrl)
740                 return 0;
741         return acm_set_control(acm, acm->ctrlout = newctrl);
742 }
743
744 static int acm_tty_ioctl(struct tty_struct *tty,
745                                         unsigned int cmd, unsigned long arg)
746 {
747         struct acm *acm = tty->driver_data;
748
749         if (!ACM_READY(acm))
750                 return -EINVAL;
751
752         return -ENOIOCTLCMD;
753 }
754
755 static const __u32 acm_tty_speed[] = {
756         0, 50, 75, 110, 134, 150, 200, 300, 600,
757         1200, 1800, 2400, 4800, 9600, 19200, 38400,
758         57600, 115200, 230400, 460800, 500000, 576000,
759         921600, 1000000, 1152000, 1500000, 2000000,
760         2500000, 3000000, 3500000, 4000000
761 };
762
763 static void acm_tty_set_termios(struct tty_struct *tty,
764                                                 struct ktermios *termios_old)
765 {
766         struct acm *acm = tty->driver_data;
767         struct ktermios *termios = tty->termios;
768         struct usb_cdc_line_coding newline;
769         int newctrl = acm->ctrlout;
770
771         if (!ACM_READY(acm))
772                 return;
773
774         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
775         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
776         newline.bParityType = termios->c_cflag & PARENB ?
777                                 (termios->c_cflag & PARODD ? 1 : 2) +
778                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
779         switch (termios->c_cflag & CSIZE) {
780         case CS5:
781                 newline.bDataBits = 5;
782                 break;
783         case CS6:
784                 newline.bDataBits = 6;
785                 break;
786         case CS7:
787                 newline.bDataBits = 7;
788                 break;
789         case CS8:
790         default:
791                 newline.bDataBits = 8;
792                 break;
793         }
794         /* FIXME: Needs to clear unsupported bits in the termios */
795         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
796
797         if (!newline.dwDTERate) {
798                 newline.dwDTERate = acm->line.dwDTERate;
799                 newctrl &= ~ACM_CTRL_DTR;
800         } else
801                 newctrl |=  ACM_CTRL_DTR;
802
803         if (newctrl != acm->ctrlout)
804                 acm_set_control(acm, acm->ctrlout = newctrl);
805
806         if (memcmp(&acm->line, &newline, sizeof newline)) {
807                 memcpy(&acm->line, &newline, sizeof newline);
808                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
809                         __func__,
810                         le32_to_cpu(newline.dwDTERate),
811                         newline.bCharFormat, newline.bParityType,
812                         newline.bDataBits);
813                 acm_set_line(acm, &acm->line);
814         }
815 }
816
817 /*
818  * USB probe and disconnect routines.
819  */
820
821 /* Little helpers: write/read buffers free */
822 static void acm_write_buffers_free(struct acm *acm)
823 {
824         int i;
825         struct acm_wb *wb;
826         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
827
828         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
829                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
830 }
831
832 static void acm_read_buffers_free(struct acm *acm)
833 {
834         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
835         int i;
836
837         for (i = 0; i < acm->rx_buflimit; i++)
838                 usb_free_coherent(usb_dev, acm->readsize,
839                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
840 }
841
842 /* Little helper: write buffers allocate */
843 static int acm_write_buffers_alloc(struct acm *acm)
844 {
845         int i;
846         struct acm_wb *wb;
847
848         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
849                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
850                     &wb->dmah);
851                 if (!wb->buf) {
852                         while (i != 0) {
853                                 --i;
854                                 --wb;
855                                 usb_free_coherent(acm->dev, acm->writesize,
856                                     wb->buf, wb->dmah);
857                         }
858                         return -ENOMEM;
859                 }
860         }
861         return 0;
862 }
863
864 static int acm_probe(struct usb_interface *intf,
865                      const struct usb_device_id *id)
866 {
867         struct usb_cdc_union_desc *union_header = NULL;
868         struct usb_cdc_country_functional_desc *cfd = NULL;
869         unsigned char *buffer = intf->altsetting->extra;
870         int buflen = intf->altsetting->extralen;
871         struct usb_interface *control_interface;
872         struct usb_interface *data_interface;
873         struct usb_endpoint_descriptor *epctrl = NULL;
874         struct usb_endpoint_descriptor *epread = NULL;
875         struct usb_endpoint_descriptor *epwrite = NULL;
876         struct usb_device *usb_dev = interface_to_usbdev(intf);
877         struct acm *acm;
878         int minor;
879         int ctrlsize, readsize;
880         u8 *buf;
881         u8 ac_management_function = 0;
882         u8 call_management_function = 0;
883         int call_interface_num = -1;
884         int data_interface_num = -1;
885         unsigned long quirks;
886         int num_rx_buf;
887         int i;
888         int combined_interfaces = 0;
889
890         /* normal quirks */
891         quirks = (unsigned long)id->driver_info;
892         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
893
894         /* handle quirks deadly to normal probing*/
895         if (quirks == NO_UNION_NORMAL) {
896                 data_interface = usb_ifnum_to_if(usb_dev, 1);
897                 control_interface = usb_ifnum_to_if(usb_dev, 0);
898                 goto skip_normal_probe;
899         }
900
901         /* normal probing*/
902         if (!buffer) {
903                 dev_err(&intf->dev, "Weird descriptor references\n");
904                 return -EINVAL;
905         }
906
907         if (!buflen) {
908                 if (intf->cur_altsetting->endpoint &&
909                                 intf->cur_altsetting->endpoint->extralen &&
910                                 intf->cur_altsetting->endpoint->extra) {
911                         dev_dbg(&intf->dev,
912                                 "Seeking extra descriptors on endpoint\n");
913                         buflen = intf->cur_altsetting->endpoint->extralen;
914                         buffer = intf->cur_altsetting->endpoint->extra;
915                 } else {
916                         dev_err(&intf->dev,
917                                 "Zero length descriptor references\n");
918                         return -EINVAL;
919                 }
920         }
921
922         while (buflen > 0) {
923                 if (buffer[1] != USB_DT_CS_INTERFACE) {
924                         dev_err(&intf->dev, "skipping garbage\n");
925                         goto next_desc;
926                 }
927
928                 switch (buffer[2]) {
929                 case USB_CDC_UNION_TYPE: /* we've found it */
930                         if (union_header) {
931                                 dev_err(&intf->dev, "More than one "
932                                         "union descriptor, skipping ...\n");
933                                 goto next_desc;
934                         }
935                         union_header = (struct usb_cdc_union_desc *)buffer;
936                         break;
937                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
938                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
939                         break;
940                 case USB_CDC_HEADER_TYPE: /* maybe check version */
941                         break; /* for now we ignore it */
942                 case USB_CDC_ACM_TYPE:
943                         ac_management_function = buffer[3];
944                         break;
945                 case USB_CDC_CALL_MANAGEMENT_TYPE:
946                         call_management_function = buffer[3];
947                         call_interface_num = buffer[4];
948                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
949                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
950                         break;
951                 default:
952                         /* there are LOTS more CDC descriptors that
953                          * could legitimately be found here.
954                          */
955                         dev_dbg(&intf->dev, "Ignoring descriptor: "
956                                         "type %02x, length %d\n",
957                                         buffer[2], buffer[0]);
958                         break;
959                 }
960 next_desc:
961                 buflen -= buffer[0];
962                 buffer += buffer[0];
963         }
964
965         if (!union_header) {
966                 if (call_interface_num > 0) {
967                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
968                         /* quirks for Droids MuIn LCD */
969                         if (quirks & NO_DATA_INTERFACE)
970                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
971                         else
972                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
973                         control_interface = intf;
974                 } else {
975                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
976                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
977                                 return -ENODEV;
978                         } else {
979                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
980                                 combined_interfaces = 1;
981                                 control_interface = data_interface = intf;
982                                 goto look_for_collapsed_interface;
983                         }
984                 }
985         } else {
986                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
987                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
988                 if (!control_interface || !data_interface) {
989                         dev_dbg(&intf->dev, "no interfaces\n");
990                         return -ENODEV;
991                 }
992         }
993
994         if (data_interface_num != call_interface_num)
995                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
996
997         if (control_interface == data_interface) {
998                 /* some broken devices designed for windows work this way */
999                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1000                 combined_interfaces = 1;
1001                 /* a popular other OS doesn't use it */
1002                 quirks |= NO_CAP_LINE;
1003                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1004                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1005                         return -EINVAL;
1006                 }
1007 look_for_collapsed_interface:
1008                 for (i = 0; i < 3; i++) {
1009                         struct usb_endpoint_descriptor *ep;
1010                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1011
1012                         if (usb_endpoint_is_int_in(ep))
1013                                 epctrl = ep;
1014                         else if (usb_endpoint_is_bulk_out(ep))
1015                                 epwrite = ep;
1016                         else if (usb_endpoint_is_bulk_in(ep))
1017                                 epread = ep;
1018                         else
1019                                 return -EINVAL;
1020                 }
1021                 if (!epctrl || !epread || !epwrite)
1022                         return -ENODEV;
1023                 else
1024                         goto made_compressed_probe;
1025         }
1026
1027 skip_normal_probe:
1028
1029         /*workaround for switched interfaces */
1030         if (data_interface->cur_altsetting->desc.bInterfaceClass
1031                                                 != CDC_DATA_INTERFACE_TYPE) {
1032                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1033                                                 == CDC_DATA_INTERFACE_TYPE) {
1034                         struct usb_interface *t;
1035                         dev_dbg(&intf->dev,
1036                                 "Your device has switched interfaces.\n");
1037                         t = control_interface;
1038                         control_interface = data_interface;
1039                         data_interface = t;
1040                 } else {
1041                         return -EINVAL;
1042                 }
1043         }
1044
1045         /* Accept probe requests only for the control interface */
1046         if (!combined_interfaces && intf != control_interface)
1047                 return -ENODEV;
1048
1049         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1050                 /* valid in this context */
1051                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1052                 return -EBUSY;
1053         }
1054
1055
1056         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1057             control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1058                 return -EINVAL;
1059
1060         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1061         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1062         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1063
1064
1065         /* workaround for switched endpoints */
1066         if (!usb_endpoint_dir_in(epread)) {
1067                 /* descriptors are swapped */
1068                 struct usb_endpoint_descriptor *t;
1069                 dev_dbg(&intf->dev,
1070                         "The data interface has switched endpoints\n");
1071                 t = epread;
1072                 epread = epwrite;
1073                 epwrite = t;
1074         }
1075 made_compressed_probe:
1076         dev_dbg(&intf->dev, "interfaces are valid\n");
1077         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1078
1079         if (minor == ACM_TTY_MINORS) {
1080                 dev_err(&intf->dev, "no more free acm devices\n");
1081                 return -ENODEV;
1082         }
1083
1084         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1085         if (acm == NULL) {
1086                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1087                 goto alloc_fail;
1088         }
1089
1090         ctrlsize = usb_endpoint_maxp(epctrl);
1091         readsize = usb_endpoint_maxp(epread) *
1092                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1093         acm->combined_interfaces = combined_interfaces;
1094         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1095         acm->control = control_interface;
1096         acm->data = data_interface;
1097         acm->minor = minor;
1098         acm->dev = usb_dev;
1099         acm->ctrl_caps = ac_management_function;
1100         if (quirks & NO_CAP_LINE)
1101                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1102         acm->ctrlsize = ctrlsize;
1103         acm->readsize = readsize;
1104         acm->rx_buflimit = num_rx_buf;
1105         INIT_WORK(&acm->work, acm_softint);
1106         spin_lock_init(&acm->write_lock);
1107         spin_lock_init(&acm->read_lock);
1108         mutex_init(&acm->mutex);
1109         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1110         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1111         if (acm->is_int_ep)
1112                 acm->bInterval = epread->bInterval;
1113         tty_port_init(&acm->port);
1114         acm->port.ops = &acm_port_ops;
1115
1116         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1117         if (!buf) {
1118                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1119                 goto alloc_fail2;
1120         }
1121         acm->ctrl_buffer = buf;
1122
1123         if (acm_write_buffers_alloc(acm) < 0) {
1124                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1125                 goto alloc_fail4;
1126         }
1127
1128         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1129         if (!acm->ctrlurb) {
1130                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1131                 goto alloc_fail5;
1132         }
1133         for (i = 0; i < num_rx_buf; i++) {
1134                 struct acm_rb *rb = &(acm->read_buffers[i]);
1135                 struct urb *urb;
1136
1137                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1138                                                                 &rb->dma);
1139                 if (!rb->base) {
1140                         dev_err(&intf->dev, "out of memory "
1141                                         "(read bufs usb_alloc_coherent)\n");
1142                         goto alloc_fail6;
1143                 }
1144                 rb->index = i;
1145                 rb->instance = acm;
1146
1147                 urb = usb_alloc_urb(0, GFP_KERNEL);
1148                 if (!urb) {
1149                         dev_err(&intf->dev,
1150                                 "out of memory (read urbs usb_alloc_urb)\n");
1151                         goto alloc_fail6;
1152                 }
1153                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1154                 urb->transfer_dma = rb->dma;
1155                 if (acm->is_int_ep) {
1156                         usb_fill_int_urb(urb, acm->dev,
1157                                          acm->rx_endpoint,
1158                                          rb->base,
1159                                          acm->readsize,
1160                                          acm_read_bulk_callback, rb,
1161                                          acm->bInterval);
1162                 } else {
1163                         usb_fill_bulk_urb(urb, acm->dev,
1164                                           acm->rx_endpoint,
1165                                           rb->base,
1166                                           acm->readsize,
1167                                           acm_read_bulk_callback, rb);
1168                 }
1169
1170                 acm->read_urbs[i] = urb;
1171                 __set_bit(i, &acm->read_urbs_free);
1172         }
1173         for (i = 0; i < ACM_NW; i++) {
1174                 struct acm_wb *snd = &(acm->wb[i]);
1175
1176                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1177                 if (snd->urb == NULL) {
1178                         dev_err(&intf->dev,
1179                                 "out of memory (write urbs usb_alloc_urb)\n");
1180                         goto alloc_fail7;
1181                 }
1182
1183                 if (usb_endpoint_xfer_int(epwrite))
1184                         usb_fill_int_urb(snd->urb, usb_dev,
1185                                 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1186                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1187                 else
1188                         usb_fill_bulk_urb(snd->urb, usb_dev,
1189                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1190                                 NULL, acm->writesize, acm_write_bulk, snd);
1191                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1192                 snd->instance = acm;
1193         }
1194
1195         usb_set_intfdata(intf, acm);
1196
1197         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1198         if (i < 0)
1199                 goto alloc_fail7;
1200
1201         if (cfd) { /* export the country data */
1202                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1203                 if (!acm->country_codes)
1204                         goto skip_countries;
1205                 acm->country_code_size = cfd->bLength - 4;
1206                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1207                                                         cfd->bLength - 4);
1208                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1209
1210                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1211                 if (i < 0) {
1212                         kfree(acm->country_codes);
1213                         acm->country_codes = NULL;
1214                         acm->country_code_size = 0;
1215                         goto skip_countries;
1216                 }
1217
1218                 i = device_create_file(&intf->dev,
1219                                                 &dev_attr_iCountryCodeRelDate);
1220                 if (i < 0) {
1221                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1222                         kfree(acm->country_codes);
1223                         acm->country_codes = NULL;
1224                         acm->country_code_size = 0;
1225                         goto skip_countries;
1226                 }
1227         }
1228
1229 skip_countries:
1230         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1231                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1232                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1233                          /* works around buggy devices */
1234                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1235         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1236         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1237
1238         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1239
1240         acm_set_control(acm, acm->ctrlout);
1241
1242         acm->line.dwDTERate = cpu_to_le32(9600);
1243         acm->line.bDataBits = 8;
1244         acm_set_line(acm, &acm->line);
1245
1246         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1247         usb_set_intfdata(data_interface, acm);
1248
1249         usb_get_intf(control_interface);
1250         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1251
1252         acm_table[minor] = acm;
1253
1254         return 0;
1255 alloc_fail7:
1256         for (i = 0; i < ACM_NW; i++)
1257                 usb_free_urb(acm->wb[i].urb);
1258 alloc_fail6:
1259         for (i = 0; i < num_rx_buf; i++)
1260                 usb_free_urb(acm->read_urbs[i]);
1261         acm_read_buffers_free(acm);
1262         usb_free_urb(acm->ctrlurb);
1263 alloc_fail5:
1264         acm_write_buffers_free(acm);
1265 alloc_fail4:
1266         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1267 alloc_fail2:
1268         kfree(acm);
1269 alloc_fail:
1270         return -ENOMEM;
1271 }
1272
1273 static void stop_data_traffic(struct acm *acm)
1274 {
1275         int i;
1276
1277         dev_dbg(&acm->control->dev, "%s\n", __func__);
1278
1279         usb_kill_urb(acm->ctrlurb);
1280         for (i = 0; i < ACM_NW; i++)
1281                 usb_kill_urb(acm->wb[i].urb);
1282         for (i = 0; i < acm->rx_buflimit; i++)
1283                 usb_kill_urb(acm->read_urbs[i]);
1284
1285         cancel_work_sync(&acm->work);
1286 }
1287
1288 static void acm_disconnect(struct usb_interface *intf)
1289 {
1290         struct acm *acm = usb_get_intfdata(intf);
1291         struct usb_device *usb_dev = interface_to_usbdev(intf);
1292         struct tty_struct *tty;
1293
1294         /* sibling interface is already cleaning up */
1295         if (!acm)
1296                 return;
1297
1298         mutex_lock(&open_mutex);
1299         if (acm->country_codes) {
1300                 device_remove_file(&acm->control->dev,
1301                                 &dev_attr_wCountryCodes);
1302                 device_remove_file(&acm->control->dev,
1303                                 &dev_attr_iCountryCodeRelDate);
1304         }
1305         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1306         acm->dev = NULL;
1307         usb_set_intfdata(acm->control, NULL);
1308         usb_set_intfdata(acm->data, NULL);
1309
1310         stop_data_traffic(acm);
1311
1312         acm_write_buffers_free(acm);
1313         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1314                           acm->ctrl_dma);
1315         acm_read_buffers_free(acm);
1316
1317         if (!acm->combined_interfaces)
1318                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1319                                         acm->data : acm->control);
1320
1321         if (acm->port.count == 0) {
1322                 acm_tty_unregister(acm);
1323                 mutex_unlock(&open_mutex);
1324                 return;
1325         }
1326
1327         mutex_unlock(&open_mutex);
1328         tty = tty_port_tty_get(&acm->port);
1329         if (tty) {
1330                 tty_hangup(tty);
1331                 tty_kref_put(tty);
1332         }
1333 }
1334
1335 #ifdef CONFIG_PM
1336 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1337 {
1338         struct acm *acm = usb_get_intfdata(intf);
1339         int cnt;
1340
1341         if (PMSG_IS_AUTO(message)) {
1342                 int b;
1343
1344                 spin_lock_irq(&acm->write_lock);
1345                 b = acm->transmitting;
1346                 spin_unlock_irq(&acm->write_lock);
1347                 if (b)
1348                         return -EBUSY;
1349         }
1350
1351         spin_lock_irq(&acm->read_lock);
1352         spin_lock(&acm->write_lock);
1353         cnt = acm->susp_count++;
1354         spin_unlock(&acm->write_lock);
1355         spin_unlock_irq(&acm->read_lock);
1356
1357         if (cnt)
1358                 return 0;
1359         /*
1360         we treat opened interfaces differently,
1361         we must guard against open
1362         */
1363         mutex_lock(&acm->mutex);
1364
1365         if (acm->port.count)
1366                 stop_data_traffic(acm);
1367
1368         mutex_unlock(&acm->mutex);
1369         return 0;
1370 }
1371
1372 static int acm_resume(struct usb_interface *intf)
1373 {
1374         struct acm *acm = usb_get_intfdata(intf);
1375         struct acm_wb *wb;
1376         int rv = 0;
1377         int cnt;
1378
1379         spin_lock_irq(&acm->read_lock);
1380         acm->susp_count -= 1;
1381         cnt = acm->susp_count;
1382         spin_unlock_irq(&acm->read_lock);
1383
1384         if (cnt)
1385                 return 0;
1386
1387         mutex_lock(&acm->mutex);
1388         if (acm->port.count) {
1389                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1390
1391                 spin_lock_irq(&acm->write_lock);
1392                 if (acm->delayed_wb) {
1393                         wb = acm->delayed_wb;
1394                         acm->delayed_wb = NULL;
1395                         spin_unlock_irq(&acm->write_lock);
1396                         acm_start_wb(acm, wb);
1397                 } else {
1398                         spin_unlock_irq(&acm->write_lock);
1399                 }
1400
1401                 /*
1402                  * delayed error checking because we must
1403                  * do the write path at all cost
1404                  */
1405                 if (rv < 0)
1406                         goto err_out;
1407
1408                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1409         }
1410
1411 err_out:
1412         mutex_unlock(&acm->mutex);
1413         return rv;
1414 }
1415
1416 static int acm_reset_resume(struct usb_interface *intf)
1417 {
1418         struct acm *acm = usb_get_intfdata(intf);
1419         struct tty_struct *tty;
1420
1421         mutex_lock(&acm->mutex);
1422         if (acm->port.count) {
1423                 tty = tty_port_tty_get(&acm->port);
1424                 if (tty) {
1425                         tty_hangup(tty);
1426                         tty_kref_put(tty);
1427                 }
1428         }
1429         mutex_unlock(&acm->mutex);
1430         return acm_resume(intf);
1431 }
1432
1433 #endif /* CONFIG_PM */
1434
1435 #define NOKIA_PCSUITE_ACM_INFO(x) \
1436                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1437                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1438                 USB_CDC_ACM_PROTO_VENDOR)
1439
1440 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1441                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1442                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1443                 USB_CDC_ACM_PROTO_VENDOR)
1444
1445 /*
1446  * USB driver structure.
1447  */
1448
1449 static const struct usb_device_id acm_ids[] = {
1450         /* quirky and broken devices */
1451         { USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1452         .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1453         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1454         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1455         },
1456         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1457         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1458         },
1459         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1460         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1461         },
1462         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1463         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1464         },
1465         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1466         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1467         },
1468         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1469         .driver_info = SINGLE_RX_URB,
1470         },
1471         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1472         .driver_info = SINGLE_RX_URB, /* firmware bug */
1473         },
1474         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1475         .driver_info = SINGLE_RX_URB, /* firmware bug */
1476         },
1477         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1478         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1479         },
1480         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1481         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1482         },
1483         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1484         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1485         },
1486         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1487         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1488         },
1489         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1490         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1491         },
1492         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1493         },
1494         /* Motorola H24 HSPA module: */
1495         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1496         { USB_DEVICE(0x22b8, 0x2d92),   /* modem           + diagnostics        */
1497         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1498         },
1499         { USB_DEVICE(0x22b8, 0x2d93),   /* modem + AT port                      */
1500         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1501         },
1502         { USB_DEVICE(0x22b8, 0x2d95),   /* modem + AT port + diagnostics        */
1503         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1504         },
1505         { USB_DEVICE(0x22b8, 0x2d96),   /* modem                         + NMEA */
1506         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1507         },
1508         { USB_DEVICE(0x22b8, 0x2d97),   /* modem           + diagnostics + NMEA */
1509         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1510         },
1511         { USB_DEVICE(0x22b8, 0x2d99),   /* modem + AT port               + NMEA */
1512         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1513         },
1514         { USB_DEVICE(0x22b8, 0x2d9a),   /* modem + AT port + diagnostics + NMEA */
1515         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1516         },
1517
1518         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1519         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1520                                            data interface instead of
1521                                            communications interface.
1522                                            Maybe we should define a new
1523                                            quirk for this. */
1524         },
1525         { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1526         .driver_info = NO_UNION_NORMAL,
1527         },
1528         { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1529         .driver_info = NO_UNION_NORMAL,
1530         },
1531         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1532         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1533         },
1534         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1535         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1536         },
1537
1538         /* Nokia S60 phones expose two ACM channels. The first is
1539          * a modem and is picked up by the standard AT-command
1540          * information below. The second is 'vendor-specific' but
1541          * is treated as a serial device at the S60 end, so we want
1542          * to expose it on Linux too. */
1543         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1544         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1545         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1546         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1547         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1548         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1549         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1550         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1551         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1552         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1554         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1556         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1558         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1561         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1562         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1563         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1564         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1566         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1567         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1568         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1570         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1571         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1573         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1574         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1575         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1576         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1577         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1579         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1580         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1581         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1582         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1583         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1584         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1585         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1586         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1588         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1589         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1590         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1592         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1594         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1595         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1596         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1597         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1598         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1599         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1600         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1601
1602         /* Support for Owen devices */
1603         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1604
1605         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1606
1607         /* Support Lego NXT using pbLua firmware */
1608         { USB_DEVICE(0x0694, 0xff00),
1609         .driver_info = NOT_A_MODEM,
1610         },
1611
1612         /* Support for Droids MuIn LCD */
1613         { USB_DEVICE(0x04d8, 0x000b),
1614         .driver_info = NO_DATA_INTERFACE,
1615         },
1616
1617         /* control interfaces without any protocol set */
1618         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1619                 USB_CDC_PROTO_NONE) },
1620
1621         /* control interfaces with various AT-command sets */
1622         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1623                 USB_CDC_ACM_PROTO_AT_V25TER) },
1624         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1625                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1626         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1627                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1628         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1629                 USB_CDC_ACM_PROTO_AT_GSM) },
1630         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1631                 USB_CDC_ACM_PROTO_AT_3G) },
1632         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1633                 USB_CDC_ACM_PROTO_AT_CDMA) },
1634
1635         { }
1636 };
1637
1638 MODULE_DEVICE_TABLE(usb, acm_ids);
1639
1640 static struct usb_driver acm_driver = {
1641         .name =         "cdc_acm",
1642         .probe =        acm_probe,
1643         .disconnect =   acm_disconnect,
1644 #ifdef CONFIG_PM
1645         .suspend =      acm_suspend,
1646         .resume =       acm_resume,
1647         .reset_resume = acm_reset_resume,
1648 #endif
1649         .id_table =     acm_ids,
1650 #ifdef CONFIG_PM
1651         .supports_autosuspend = 1,
1652 #endif
1653 };
1654
1655 /*
1656  * TTY driver structures.
1657  */
1658
1659 static const struct tty_operations acm_ops = {
1660         .open =                 acm_tty_open,
1661         .close =                acm_tty_close,
1662         .hangup =               acm_tty_hangup,
1663         .write =                acm_tty_write,
1664         .write_room =           acm_tty_write_room,
1665         .ioctl =                acm_tty_ioctl,
1666         .throttle =             acm_tty_throttle,
1667         .unthrottle =           acm_tty_unthrottle,
1668         .chars_in_buffer =      acm_tty_chars_in_buffer,
1669         .break_ctl =            acm_tty_break_ctl,
1670         .set_termios =          acm_tty_set_termios,
1671         .tiocmget =             acm_tty_tiocmget,
1672         .tiocmset =             acm_tty_tiocmset,
1673 };
1674
1675 /*
1676  * Init / exit.
1677  */
1678
1679 static int __init acm_init(void)
1680 {
1681         int retval;
1682         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1683         if (!acm_tty_driver)
1684                 return -ENOMEM;
1685         acm_tty_driver->owner = THIS_MODULE,
1686         acm_tty_driver->driver_name = "acm",
1687         acm_tty_driver->name = "ttyACM",
1688         acm_tty_driver->major = ACM_TTY_MAJOR,
1689         acm_tty_driver->minor_start = 0,
1690         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1691         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1692         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1693         acm_tty_driver->init_termios = tty_std_termios;
1694         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1695                                                                 HUPCL | CLOCAL;
1696         tty_set_operations(acm_tty_driver, &acm_ops);
1697
1698         retval = tty_register_driver(acm_tty_driver);
1699         if (retval) {
1700                 put_tty_driver(acm_tty_driver);
1701                 return retval;
1702         }
1703
1704         retval = usb_register(&acm_driver);
1705         if (retval) {
1706                 tty_unregister_driver(acm_tty_driver);
1707                 put_tty_driver(acm_tty_driver);
1708                 return retval;
1709         }
1710
1711         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1712
1713         return 0;
1714 }
1715
1716 static void __exit acm_exit(void)
1717 {
1718         usb_deregister(&acm_driver);
1719         tty_unregister_driver(acm_tty_driver);
1720         put_tty_driver(acm_tty_driver);
1721 }
1722
1723 module_init(acm_init);
1724 module_exit(acm_exit);
1725
1726 MODULE_AUTHOR(DRIVER_AUTHOR);
1727 MODULE_DESCRIPTION(DRIVER_DESC);
1728 MODULE_LICENSE("GPL");
1729 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);