[PATCH] const struct tty_operations
[linux-3.10.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@suse.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  *
11  * USB Abstract Control Model driver for USB modems and ISDN adapters
12  *
13  * Sponsored by SuSE
14  *
15  * ChangeLog:
16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
17  *      v0.10 - some more cleanups
18  *      v0.11 - fixed flow control, read error doesn't stop reads
19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
20  *      v0.13 - added termios, added hangup
21  *      v0.14 - sized down struct acm
22  *      v0.15 - fixed flow control again - characters could be lost
23  *      v0.16 - added code for modems with swapped data and control interfaces
24  *      v0.17 - added new style probing
25  *      v0.18 - fixed new style probing for devices with more configurations
26  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
27  *      v0.20 - switched to probing on interface (rather than device) class
28  *      v0.21 - revert to probing on device for devices with multiple configs
29  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
30  *              config we want, sysadmin changes bConfigurationValue in sysfs.
31  *      v0.23 - use softirq for rx processing, as needed by tty layer
32  *      v0.24 - change probe method to evaluate CDC union descriptor
33  *      v0.25 - downstream tasks paralelized to maximize throughput
34  */
35
36 /*
37  * This program is free software; you can redistribute it and/or modify
38  * it under the terms of the GNU General Public License as published by
39  * the Free Software Foundation; either version 2 of the License, or
40  * (at your option) any later version.
41  *
42  * This program is distributed in the hope that it will be useful,
43  * but WITHOUT ANY WARRANTY; without even the implied warranty of
44  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
45  * GNU General Public License for more details.
46  *
47  * You should have received a copy of the GNU General Public License
48  * along with this program; if not, write to the Free Software
49  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
50  */
51
52 #undef DEBUG
53
54 #include <linux/kernel.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/tty.h>
59 #include <linux/tty_driver.h>
60 #include <linux/tty_flip.h>
61 #include <linux/module.h>
62 #include <linux/smp_lock.h>
63 #include <linux/mutex.h>
64 #include <asm/uaccess.h>
65 #include <linux/usb.h>
66 #include <linux/usb/cdc.h>
67 #include <asm/byteorder.h>
68 #include <asm/unaligned.h>
69 #include <linux/list.h>
70
71 #include "cdc-acm.h"
72
73 /*
74  * Version Information
75  */
76 #define DRIVER_VERSION "v0.25"
77 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
78 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
79
80 static struct usb_driver acm_driver;
81 static struct tty_driver *acm_tty_driver;
82 static struct acm *acm_table[ACM_TTY_MINORS];
83
84 static DEFINE_MUTEX(open_mutex);
85
86 #define ACM_READY(acm)  (acm && acm->dev && acm->used)
87
88 /*
89  * Functions for ACM control messages.
90  */
91
92 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
93 {
94         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
95                 request, USB_RT_ACM, value,
96                 acm->control->altsetting[0].desc.bInterfaceNumber,
97                 buf, len, 5000);
98         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
99         return retval < 0 ? retval : 0;
100 }
101
102 /* devices aren't required to support these requests.
103  * the cdc acm descriptor tells whether they do...
104  */
105 #define acm_set_control(acm, control) \
106         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
107 #define acm_set_line(acm, line) \
108         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
109 #define acm_send_break(acm, ms) \
110         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
111
112 /*
113  * Write buffer management.
114  * All of these assume proper locks taken by the caller.
115  */
116
117 static int acm_wb_alloc(struct acm *acm)
118 {
119         int i, wbn;
120         struct acm_wb *wb;
121
122         wbn = acm->write_current;
123         i = 0;
124         for (;;) {
125                 wb = &acm->wb[wbn];
126                 if (!wb->use) {
127                         wb->use = 1;
128                         return wbn;
129                 }
130                 wbn = (wbn + 1) % ACM_NW;
131                 if (++i >= ACM_NW)
132                         return -1;
133         }
134 }
135
136 static void acm_wb_free(struct acm *acm, int wbn)
137 {
138         acm->wb[wbn].use = 0;
139 }
140
141 static int acm_wb_is_avail(struct acm *acm)
142 {
143         int i, n;
144
145         n = ACM_NW;
146         for (i = 0; i < ACM_NW; i++) {
147                 n -= acm->wb[i].use;
148         }
149         return n;
150 }
151
152 static inline int acm_wb_is_used(struct acm *acm, int wbn)
153 {
154         return acm->wb[wbn].use;
155 }
156
157 /*
158  * Finish write.
159  */
160 static void acm_write_done(struct acm *acm)
161 {
162         unsigned long flags;
163         int wbn;
164
165         spin_lock_irqsave(&acm->write_lock, flags);
166         acm->write_ready = 1;
167         wbn = acm->write_current;
168         acm_wb_free(acm, wbn);
169         acm->write_current = (wbn + 1) % ACM_NW;
170         spin_unlock_irqrestore(&acm->write_lock, flags);
171 }
172
173 /*
174  * Poke write.
175  */
176 static int acm_write_start(struct acm *acm)
177 {
178         unsigned long flags;
179         int wbn;
180         struct acm_wb *wb;
181         int rc;
182
183         spin_lock_irqsave(&acm->write_lock, flags);
184         if (!acm->dev) {
185                 spin_unlock_irqrestore(&acm->write_lock, flags);
186                 return -ENODEV;
187         }
188
189         if (!acm->write_ready) {
190                 spin_unlock_irqrestore(&acm->write_lock, flags);
191                 return 0;       /* A white lie */
192         }
193
194         wbn = acm->write_current;
195         if (!acm_wb_is_used(acm, wbn)) {
196                 spin_unlock_irqrestore(&acm->write_lock, flags);
197                 return 0;
198         }
199         wb = &acm->wb[wbn];
200
201         acm->write_ready = 0;
202         spin_unlock_irqrestore(&acm->write_lock, flags);
203
204         acm->writeurb->transfer_buffer = wb->buf;
205         acm->writeurb->transfer_dma = wb->dmah;
206         acm->writeurb->transfer_buffer_length = wb->len;
207         acm->writeurb->dev = acm->dev;
208
209         if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
210                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
211                 acm_write_done(acm);
212         }
213         return rc;
214 }
215
216 /*
217  * Interrupt handlers for various ACM device responses
218  */
219
220 /* control interface reports status changes with "interrupt" transfers */
221 static void acm_ctrl_irq(struct urb *urb, struct pt_regs *regs)
222 {
223         struct acm *acm = urb->context;
224         struct usb_cdc_notification *dr = urb->transfer_buffer;
225         unsigned char *data;
226         int newctrl;
227         int status;
228
229         switch (urb->status) {
230         case 0:
231                 /* success */
232                 break;
233         case -ECONNRESET:
234         case -ENOENT:
235         case -ESHUTDOWN:
236                 /* this urb is terminated, clean up */
237                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
238                 return;
239         default:
240                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
241                 goto exit;
242         }
243
244         if (!ACM_READY(acm))
245                 goto exit;
246
247         data = (unsigned char *)(dr + 1);
248         switch (dr->bNotificationType) {
249
250                 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
251
252                         dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
253                         break;
254
255                 case USB_CDC_NOTIFY_SERIAL_STATE:
256
257                         newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
258
259                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
260                                 dbg("calling hangup");
261                                 tty_hangup(acm->tty);
262                         }
263
264                         acm->ctrlin = newctrl;
265
266                         dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
267                                 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
268                                 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
269                                 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
270                                 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
271
272                         break;
273
274                 default:
275                         dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
276                                 dr->bNotificationType, dr->wIndex,
277                                 dr->wLength, data[0], data[1]);
278                         break;
279         }
280 exit:
281         status = usb_submit_urb (urb, GFP_ATOMIC);
282         if (status)
283                 err ("%s - usb_submit_urb failed with result %d",
284                      __FUNCTION__, status);
285 }
286
287 /* data interface returns incoming bytes, or we got unthrottled */
288 static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
289 {
290         struct acm_rb *buf;
291         struct acm_ru *rcv = urb->context;
292         struct acm *acm = rcv->instance;
293         int status = urb->status;
294         dbg("Entering acm_read_bulk with status %d", urb->status);
295
296         if (!ACM_READY(acm))
297                 return;
298
299         if (status)
300                 dev_dbg(&acm->data->dev, "bulk rx status %d", status);
301
302         buf = rcv->buffer;
303         buf->size = urb->actual_length;
304
305         if (likely(status == 0)) {
306                 spin_lock(&acm->read_lock);
307                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
308                 list_add_tail(&buf->list, &acm->filled_read_bufs);
309                 spin_unlock(&acm->read_lock);
310         } else {
311                 /* we drop the buffer due to an error */
312                 spin_lock(&acm->read_lock);
313                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
314                 list_add(&buf->list, &acm->spare_read_bufs);
315                 spin_unlock(&acm->read_lock);
316                 /* nevertheless the tasklet must be kicked unconditionally
317                 so the queue cannot dry up */
318         }
319         tasklet_schedule(&acm->urb_task);
320 }
321
322 static void acm_rx_tasklet(unsigned long _acm)
323 {
324         struct acm *acm = (void *)_acm;
325         struct acm_rb *buf;
326         struct tty_struct *tty = acm->tty;
327         struct acm_ru *rcv;
328         //unsigned long flags;
329         int i = 0;
330         dbg("Entering acm_rx_tasklet");
331
332         if (!ACM_READY(acm) || acm->throttle)
333                 return;
334
335 next_buffer:
336         spin_lock(&acm->read_lock);
337         if (list_empty(&acm->filled_read_bufs)) {
338                 spin_unlock(&acm->read_lock);
339                 goto urbs;
340         }
341         buf = list_entry(acm->filled_read_bufs.next,
342                          struct acm_rb, list);
343         list_del(&buf->list);
344         spin_unlock(&acm->read_lock);
345
346         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
347
348         tty_buffer_request_room(tty, buf->size);
349         if (!acm->throttle)
350                 tty_insert_flip_string(tty, buf->base, buf->size);
351         tty_flip_buffer_push(tty);
352
353         spin_lock(&acm->throttle_lock);
354         if (acm->throttle) {
355                 dbg("Throtteling noticed");
356                 memmove(buf->base, buf->base + i, buf->size - i);
357                 buf->size -= i;
358                 spin_unlock(&acm->throttle_lock);
359                 spin_lock(&acm->read_lock);
360                 list_add(&buf->list, &acm->filled_read_bufs);
361                 spin_unlock(&acm->read_lock);
362                 return;
363         }
364         spin_unlock(&acm->throttle_lock);
365
366         spin_lock(&acm->read_lock);
367         list_add(&buf->list, &acm->spare_read_bufs);
368         spin_unlock(&acm->read_lock);
369         goto next_buffer;
370
371 urbs:
372         while (!list_empty(&acm->spare_read_bufs)) {
373                 spin_lock(&acm->read_lock);
374                 if (list_empty(&acm->spare_read_urbs)) {
375                         spin_unlock(&acm->read_lock);
376                         return;
377                 }
378                 rcv = list_entry(acm->spare_read_urbs.next,
379                                  struct acm_ru, list);
380                 list_del(&rcv->list);
381                 spin_unlock(&acm->read_lock);
382
383                 buf = list_entry(acm->spare_read_bufs.next,
384                                  struct acm_rb, list);
385                 list_del(&buf->list);
386
387                 rcv->buffer = buf;
388
389                 usb_fill_bulk_urb(rcv->urb, acm->dev,
390                                   acm->rx_endpoint,
391                                   buf->base,
392                                   acm->readsize,
393                                   acm_read_bulk, rcv);
394                 rcv->urb->transfer_dma = buf->dma;
395                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
396
397                 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
398
399                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
400                    free-urbs-pool and resubmited ASAP */
401                 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
402                         list_add(&buf->list, &acm->spare_read_bufs);
403                         spin_lock(&acm->read_lock);
404                         list_add(&rcv->list, &acm->spare_read_urbs);
405                         spin_unlock(&acm->read_lock);
406                         return;
407                 }
408         }
409 }
410
411 /* data interface wrote those outgoing bytes */
412 static void acm_write_bulk(struct urb *urb, struct pt_regs *regs)
413 {
414         struct acm *acm = (struct acm *)urb->context;
415
416         dbg("Entering acm_write_bulk with status %d", urb->status);
417
418         acm_write_done(acm);
419         acm_write_start(acm);
420         if (ACM_READY(acm))
421                 schedule_work(&acm->work);
422 }
423
424 static void acm_softint(void *private)
425 {
426         struct acm *acm = private;
427         dbg("Entering acm_softint.");
428         
429         if (!ACM_READY(acm))
430                 return;
431         tty_wakeup(acm->tty);
432 }
433
434 /*
435  * TTY handlers
436  */
437
438 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
439 {
440         struct acm *acm;
441         int rv = -EINVAL;
442         int i;
443         dbg("Entering acm_tty_open.");
444
445         mutex_lock(&open_mutex);
446
447         acm = acm_table[tty->index];
448         if (!acm || !acm->dev)
449                 goto err_out;
450         else
451                 rv = 0;
452
453         tty->driver_data = acm;
454         acm->tty = tty;
455
456         /* force low_latency on so that our tty_push actually forces the data through,
457            otherwise it is scheduled, and with high data rates data can get lost. */
458         tty->low_latency = 1;
459
460         if (acm->used++) {
461                 goto done;
462         }
463
464         acm->ctrlurb->dev = acm->dev;
465         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
466                 dbg("usb_submit_urb(ctrl irq) failed");
467                 goto bail_out;
468         }
469
470         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
471                 goto full_bailout;
472
473         INIT_LIST_HEAD(&acm->spare_read_urbs);
474         INIT_LIST_HEAD(&acm->spare_read_bufs);
475         INIT_LIST_HEAD(&acm->filled_read_bufs);
476         for (i = 0; i < acm->rx_buflimit; i++) {
477                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
478         }
479         for (i = 0; i < acm->rx_buflimit; i++) {
480                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
481         }
482
483         tasklet_schedule(&acm->urb_task);
484
485 done:
486 err_out:
487         mutex_unlock(&open_mutex);
488         return rv;
489
490 full_bailout:
491         usb_kill_urb(acm->ctrlurb);
492 bail_out:
493         acm->used--;
494         mutex_unlock(&open_mutex);
495         return -EIO;
496 }
497
498 static void acm_tty_unregister(struct acm *acm)
499 {
500         int i,nr;
501
502         nr = acm->rx_buflimit;
503         tty_unregister_device(acm_tty_driver, acm->minor);
504         usb_put_intf(acm->control);
505         acm_table[acm->minor] = NULL;
506         usb_free_urb(acm->ctrlurb);
507         usb_free_urb(acm->writeurb);
508         for (i = 0; i < nr; i++)
509                 usb_free_urb(acm->ru[i].urb);
510         kfree(acm);
511 }
512
513 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
514 {
515         struct acm *acm = tty->driver_data;
516         int i,nr;
517
518         if (!acm || !acm->used)
519                 return;
520
521         nr = acm->rx_buflimit;
522         mutex_lock(&open_mutex);
523         if (!--acm->used) {
524                 if (acm->dev) {
525                         acm_set_control(acm, acm->ctrlout = 0);
526                         usb_kill_urb(acm->ctrlurb);
527                         usb_kill_urb(acm->writeurb);
528                         for (i = 0; i < nr; i++)
529                                 usb_kill_urb(acm->ru[i].urb);
530                 } else
531                         acm_tty_unregister(acm);
532         }
533         mutex_unlock(&open_mutex);
534 }
535
536 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
537 {
538         struct acm *acm = tty->driver_data;
539         int stat;
540         unsigned long flags;
541         int wbn;
542         struct acm_wb *wb;
543
544         dbg("Entering acm_tty_write to write %d bytes,", count);
545
546         if (!ACM_READY(acm))
547                 return -EINVAL;
548         if (!count)
549                 return 0;
550
551         spin_lock_irqsave(&acm->write_lock, flags);
552         if ((wbn = acm_wb_alloc(acm)) < 0) {
553                 spin_unlock_irqrestore(&acm->write_lock, flags);
554                 acm_write_start(acm);
555                 return 0;
556         }
557         wb = &acm->wb[wbn];
558
559         count = (count > acm->writesize) ? acm->writesize : count;
560         dbg("Get %d bytes...", count);
561         memcpy(wb->buf, buf, count);
562         wb->len = count;
563         spin_unlock_irqrestore(&acm->write_lock, flags);
564
565         if ((stat = acm_write_start(acm)) < 0)
566                 return stat;
567         return count;
568 }
569
570 static int acm_tty_write_room(struct tty_struct *tty)
571 {
572         struct acm *acm = tty->driver_data;
573         if (!ACM_READY(acm))
574                 return -EINVAL;
575         /*
576          * Do not let the line discipline to know that we have a reserve,
577          * or it might get too enthusiastic.
578          */
579         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
580 }
581
582 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
583 {
584         struct acm *acm = tty->driver_data;
585         if (!ACM_READY(acm))
586                 return -EINVAL;
587         /*
588          * This is inaccurate (overcounts), but it works.
589          */
590         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
591 }
592
593 static void acm_tty_throttle(struct tty_struct *tty)
594 {
595         struct acm *acm = tty->driver_data;
596         if (!ACM_READY(acm))
597                 return;
598         spin_lock_bh(&acm->throttle_lock);
599         acm->throttle = 1;
600         spin_unlock_bh(&acm->throttle_lock);
601 }
602
603 static void acm_tty_unthrottle(struct tty_struct *tty)
604 {
605         struct acm *acm = tty->driver_data;
606         if (!ACM_READY(acm))
607                 return;
608         spin_lock_bh(&acm->throttle_lock);
609         acm->throttle = 0;
610         spin_unlock_bh(&acm->throttle_lock);
611         tasklet_schedule(&acm->urb_task);
612 }
613
614 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
615 {
616         struct acm *acm = tty->driver_data;
617         if (!ACM_READY(acm))
618                 return;
619         if (acm_send_break(acm, state ? 0xffff : 0))
620                 dbg("send break failed");
621 }
622
623 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
624 {
625         struct acm *acm = tty->driver_data;
626
627         if (!ACM_READY(acm))
628                 return -EINVAL;
629
630         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
631                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
632                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
633                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
634                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
635                TIOCM_CTS;
636 }
637
638 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
639                             unsigned int set, unsigned int clear)
640 {
641         struct acm *acm = tty->driver_data;
642         unsigned int newctrl;
643
644         if (!ACM_READY(acm))
645                 return -EINVAL;
646
647         newctrl = acm->ctrlout;
648         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
649         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
650
651         newctrl = (newctrl & ~clear) | set;
652
653         if (acm->ctrlout == newctrl)
654                 return 0;
655         return acm_set_control(acm, acm->ctrlout = newctrl);
656 }
657
658 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
659 {
660         struct acm *acm = tty->driver_data;
661
662         if (!ACM_READY(acm))
663                 return -EINVAL;
664
665         return -ENOIOCTLCMD;
666 }
667
668 static const __u32 acm_tty_speed[] = {
669         0, 50, 75, 110, 134, 150, 200, 300, 600,
670         1200, 1800, 2400, 4800, 9600, 19200, 38400,
671         57600, 115200, 230400, 460800, 500000, 576000,
672         921600, 1000000, 1152000, 1500000, 2000000,
673         2500000, 3000000, 3500000, 4000000
674 };
675
676 static const __u8 acm_tty_size[] = {
677         5, 6, 7, 8
678 };
679
680 static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
681 {
682         struct acm *acm = tty->driver_data;
683         struct termios *termios = tty->termios;
684         struct usb_cdc_line_coding newline;
685         int newctrl = acm->ctrlout;
686
687         if (!ACM_READY(acm))
688                 return;
689
690         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
691                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
692         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
693         newline.bParityType = termios->c_cflag & PARENB ?
694                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
695         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
696
697         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
698
699         if (!newline.dwDTERate) {
700                 newline.dwDTERate = acm->line.dwDTERate;
701                 newctrl &= ~ACM_CTRL_DTR;
702         } else  newctrl |=  ACM_CTRL_DTR;
703
704         if (newctrl != acm->ctrlout)
705                 acm_set_control(acm, acm->ctrlout = newctrl);
706
707         if (memcmp(&acm->line, &newline, sizeof newline)) {
708                 memcpy(&acm->line, &newline, sizeof newline);
709                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
710                         newline.bCharFormat, newline.bParityType,
711                         newline.bDataBits);
712                 acm_set_line(acm, &acm->line);
713         }
714 }
715
716 /*
717  * USB probe and disconnect routines.
718  */
719
720 /* Little helper: write buffers free */
721 static void acm_write_buffers_free(struct acm *acm)
722 {
723         int i;
724         struct acm_wb *wb;
725
726         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
727                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
728         }
729 }
730
731 /* Little helper: write buffers allocate */
732 static int acm_write_buffers_alloc(struct acm *acm)
733 {
734         int i;
735         struct acm_wb *wb;
736
737         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
738                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
739                     &wb->dmah);
740                 if (!wb->buf) {
741                         while (i != 0) {
742                                 --i;
743                                 --wb;
744                                 usb_buffer_free(acm->dev, acm->writesize,
745                                     wb->buf, wb->dmah);
746                         }
747                         return -ENOMEM;
748                 }
749         }
750         return 0;
751 }
752
753 static int acm_probe (struct usb_interface *intf,
754                       const struct usb_device_id *id)
755 {
756         struct usb_cdc_union_desc *union_header = NULL;
757         char *buffer = intf->altsetting->extra;
758         int buflen = intf->altsetting->extralen;
759         struct usb_interface *control_interface;
760         struct usb_interface *data_interface;
761         struct usb_endpoint_descriptor *epctrl;
762         struct usb_endpoint_descriptor *epread;
763         struct usb_endpoint_descriptor *epwrite;
764         struct usb_device *usb_dev = interface_to_usbdev(intf);
765         struct acm *acm;
766         int minor;
767         int ctrlsize,readsize;
768         u8 *buf;
769         u8 ac_management_function = 0;
770         u8 call_management_function = 0;
771         int call_interface_num = -1;
772         int data_interface_num;
773         unsigned long quirks;
774         int num_rx_buf;
775         int i;
776
777         /* normal quirks */
778         quirks = (unsigned long)id->driver_info;
779         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
780
781         /* handle quirks deadly to normal probing*/
782         if (quirks == NO_UNION_NORMAL) {
783                 data_interface = usb_ifnum_to_if(usb_dev, 1);
784                 control_interface = usb_ifnum_to_if(usb_dev, 0);
785                 goto skip_normal_probe;
786         }
787         
788         /* normal probing*/
789         if (!buffer) {
790                 err("Wierd descriptor references\n");
791                 return -EINVAL;
792         }
793
794         if (!buflen) {
795                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
796                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
797                         buflen = intf->cur_altsetting->endpoint->extralen;
798                         buffer = intf->cur_altsetting->endpoint->extra;
799                 } else {
800                         err("Zero length descriptor references\n");
801                         return -EINVAL;
802                 }
803         }
804
805         while (buflen > 0) {
806                 if (buffer [1] != USB_DT_CS_INTERFACE) {
807                         err("skipping garbage\n");
808                         goto next_desc;
809                 }
810
811                 switch (buffer [2]) {
812                         case USB_CDC_UNION_TYPE: /* we've found it */
813                                 if (union_header) {
814                                         err("More than one union descriptor, skipping ...");
815                                         goto next_desc;
816                                 }
817                                 union_header = (struct usb_cdc_union_desc *)
818                                                         buffer;
819                                 break;
820                         case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */
821                                 break; /* for now we ignore it */
822                         case USB_CDC_HEADER_TYPE: /* maybe check version */ 
823                                 break; /* for now we ignore it */ 
824                         case USB_CDC_ACM_TYPE:
825                                 ac_management_function = buffer[3];
826                                 break;
827                         case USB_CDC_CALL_MANAGEMENT_TYPE:
828                                 call_management_function = buffer[3];
829                                 call_interface_num = buffer[4];
830                                 if ((call_management_function & 3) != 3)
831                                         err("This device cannot do calls on its own. It is no modem.");
832                                 break;
833                                 
834                         default:
835                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
836                                 break;
837                         }
838 next_desc:
839                 buflen -= buffer[0];
840                 buffer += buffer[0];
841         }
842
843         if (!union_header) {
844                 if (call_interface_num > 0) {
845                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
846                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
847                         control_interface = intf;
848                 } else {
849                         dev_dbg(&intf->dev,"No union descriptor, giving up");
850                         return -ENODEV;
851                 }
852         } else {
853                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
854                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
855                 if (!control_interface || !data_interface) {
856                         dev_dbg(&intf->dev,"no interfaces");
857                         return -ENODEV;
858                 }
859         }
860         
861         if (data_interface_num != call_interface_num)
862                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
863
864 skip_normal_probe:
865
866         /*workaround for switched interfaces */
867         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
868                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
869                         struct usb_interface *t;
870                         dev_dbg(&intf->dev,"Your device has switched interfaces.");
871
872                         t = control_interface;
873                         control_interface = data_interface;
874                         data_interface = t;
875                 } else {
876                         return -EINVAL;
877                 }
878         }
879         
880         if (usb_interface_claimed(data_interface)) { /* valid in this context */
881                 dev_dbg(&intf->dev,"The data interface isn't available");
882                 return -EBUSY;
883         }
884
885
886         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
887                 return -EINVAL;
888
889         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
890         epread = &data_interface->cur_altsetting->endpoint[0].desc;
891         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
892
893
894         /* workaround for switched endpoints */
895         if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
896                 /* descriptors are swapped */
897                 struct usb_endpoint_descriptor *t;
898                 dev_dbg(&intf->dev,"The data interface has switched endpoints");
899                 
900                 t = epread;
901                 epread = epwrite;
902                 epwrite = t;
903         }
904         dbg("interfaces are valid");
905         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
906
907         if (minor == ACM_TTY_MINORS) {
908                 err("no more free acm devices");
909                 return -ENODEV;
910         }
911
912         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
913                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
914                 goto alloc_fail;
915         }
916
917         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
918         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
919         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
920         acm->control = control_interface;
921         acm->data = data_interface;
922         acm->minor = minor;
923         acm->dev = usb_dev;
924         acm->ctrl_caps = ac_management_function;
925         acm->ctrlsize = ctrlsize;
926         acm->readsize = readsize;
927         acm->rx_buflimit = num_rx_buf;
928         acm->urb_task.func = acm_rx_tasklet;
929         acm->urb_task.data = (unsigned long) acm;
930         INIT_WORK(&acm->work, acm_softint, acm);
931         spin_lock_init(&acm->throttle_lock);
932         spin_lock_init(&acm->write_lock);
933         spin_lock_init(&acm->read_lock);
934         acm->write_ready = 1;
935         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
936
937         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
938         if (!buf) {
939                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
940                 goto alloc_fail2;
941         }
942         acm->ctrl_buffer = buf;
943
944         if (acm_write_buffers_alloc(acm) < 0) {
945                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
946                 goto alloc_fail4;
947         }
948
949         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
950         if (!acm->ctrlurb) {
951                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
952                 goto alloc_fail5;
953         }
954         for (i = 0; i < num_rx_buf; i++) {
955                 struct acm_ru *rcv = &(acm->ru[i]);
956
957                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
958                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
959                         goto alloc_fail7;
960                 }
961
962                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
963                 rcv->instance = acm;
964         }
965         for (i = 0; i < num_rx_buf; i++) {
966                 struct acm_rb *buf = &(acm->rb[i]);
967
968                 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
969                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
970                         goto alloc_fail7;
971                 }
972         }
973         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
974         if (!acm->writeurb) {
975                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
976                 goto alloc_fail7;
977         }
978
979         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
980                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
981         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
982         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
983
984         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
985                           NULL, acm->writesize, acm_write_bulk, acm);
986         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
987
988         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
989
990         acm_set_control(acm, acm->ctrlout);
991
992         acm->line.dwDTERate = cpu_to_le32(9600);
993         acm->line.bDataBits = 8;
994         acm_set_line(acm, &acm->line);
995
996         usb_driver_claim_interface(&acm_driver, data_interface, acm);
997
998         usb_get_intf(control_interface);
999         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1000
1001         acm_table[minor] = acm;
1002         usb_set_intfdata (intf, acm);
1003         return 0;
1004
1005 alloc_fail7:
1006         for (i = 0; i < num_rx_buf; i++)
1007                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1008         for (i = 0; i < num_rx_buf; i++)
1009                 usb_free_urb(acm->ru[i].urb);
1010         usb_free_urb(acm->ctrlurb);
1011 alloc_fail5:
1012         acm_write_buffers_free(acm);
1013 alloc_fail4:
1014         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1015 alloc_fail2:
1016         kfree(acm);
1017 alloc_fail:
1018         return -ENOMEM;
1019 }
1020
1021 static void acm_disconnect(struct usb_interface *intf)
1022 {
1023         struct acm *acm = usb_get_intfdata (intf);
1024         struct usb_device *usb_dev = interface_to_usbdev(intf);
1025         int i;
1026
1027         if (!acm || !acm->dev) {
1028                 dbg("disconnect on nonexisting interface");
1029                 return;
1030         }
1031
1032         mutex_lock(&open_mutex);
1033         if (!usb_get_intfdata(intf)) {
1034                 mutex_unlock(&open_mutex);
1035                 return;
1036         }
1037         acm->dev = NULL;
1038         usb_set_intfdata(acm->control, NULL);
1039         usb_set_intfdata(acm->data, NULL);
1040
1041         tasklet_disable(&acm->urb_task);
1042
1043         usb_kill_urb(acm->ctrlurb);
1044         usb_kill_urb(acm->writeurb);
1045         for (i = 0; i < acm->rx_buflimit; i++)
1046                 usb_kill_urb(acm->ru[i].urb);
1047
1048         INIT_LIST_HEAD(&acm->filled_read_bufs);
1049         INIT_LIST_HEAD(&acm->spare_read_bufs);
1050
1051         tasklet_enable(&acm->urb_task);
1052
1053         flush_scheduled_work(); /* wait for acm_softint */
1054
1055         acm_write_buffers_free(acm);
1056         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1057         for (i = 0; i < acm->rx_buflimit; i++)
1058                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1059
1060         usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1061
1062         if (!acm->used) {
1063                 acm_tty_unregister(acm);
1064                 mutex_unlock(&open_mutex);
1065                 return;
1066         }
1067
1068         mutex_unlock(&open_mutex);
1069
1070         if (acm->tty)
1071                 tty_hangup(acm->tty);
1072 }
1073
1074 /*
1075  * USB driver structure.
1076  */
1077
1078 static struct usb_device_id acm_ids[] = {
1079         /* quirky and broken devices */
1080         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1081         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1082         },
1083         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1084         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1085         },
1086         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1087         .driver_info = SINGLE_RX_URB, /* firmware bug */
1088         },
1089         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1090         .driver_info = SINGLE_RX_URB, /* firmware bug */
1091         },
1092         /* control interfaces with various AT-command sets */
1093         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1094                 USB_CDC_ACM_PROTO_AT_V25TER) },
1095         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1096                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1097         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1098                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1099         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1100                 USB_CDC_ACM_PROTO_AT_GSM) },
1101         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1102                 USB_CDC_ACM_PROTO_AT_3G ) },
1103         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1104                 USB_CDC_ACM_PROTO_AT_CDMA) },
1105
1106         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1107         { }
1108 };
1109
1110 MODULE_DEVICE_TABLE (usb, acm_ids);
1111
1112 static struct usb_driver acm_driver = {
1113         .name =         "cdc_acm",
1114         .probe =        acm_probe,
1115         .disconnect =   acm_disconnect,
1116         .id_table =     acm_ids,
1117 };
1118
1119 /*
1120  * TTY driver structures.
1121  */
1122
1123 static const struct tty_operations acm_ops = {
1124         .open =                 acm_tty_open,
1125         .close =                acm_tty_close,
1126         .write =                acm_tty_write,
1127         .write_room =           acm_tty_write_room,
1128         .ioctl =                acm_tty_ioctl,
1129         .throttle =             acm_tty_throttle,
1130         .unthrottle =           acm_tty_unthrottle,
1131         .chars_in_buffer =      acm_tty_chars_in_buffer,
1132         .break_ctl =            acm_tty_break_ctl,
1133         .set_termios =          acm_tty_set_termios,
1134         .tiocmget =             acm_tty_tiocmget,
1135         .tiocmset =             acm_tty_tiocmset,
1136 };
1137
1138 /*
1139  * Init / exit.
1140  */
1141
1142 static int __init acm_init(void)
1143 {
1144         int retval;
1145         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1146         if (!acm_tty_driver)
1147                 return -ENOMEM;
1148         acm_tty_driver->owner = THIS_MODULE,
1149         acm_tty_driver->driver_name = "acm",
1150         acm_tty_driver->name = "ttyACM",
1151         acm_tty_driver->major = ACM_TTY_MAJOR,
1152         acm_tty_driver->minor_start = 0,
1153         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1154         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1155         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1156         acm_tty_driver->init_termios = tty_std_termios;
1157         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1158         tty_set_operations(acm_tty_driver, &acm_ops);
1159
1160         retval = tty_register_driver(acm_tty_driver);
1161         if (retval) {
1162                 put_tty_driver(acm_tty_driver);
1163                 return retval;
1164         }
1165
1166         retval = usb_register(&acm_driver);
1167         if (retval) {
1168                 tty_unregister_driver(acm_tty_driver);
1169                 put_tty_driver(acm_tty_driver);
1170                 return retval;
1171         }
1172
1173         info(DRIVER_VERSION ":" DRIVER_DESC);
1174
1175         return 0;
1176 }
1177
1178 static void __exit acm_exit(void)
1179 {
1180         usb_deregister(&acm_driver);
1181         tty_unregister_driver(acm_tty_driver);
1182         put_tty_driver(acm_tty_driver);
1183 }
1184
1185 module_init(acm_init);
1186 module_exit(acm_exit);
1187
1188 MODULE_AUTHOR( DRIVER_AUTHOR );
1189 MODULE_DESCRIPTION( DRIVER_DESC );
1190 MODULE_LICENSE("GPL");
1191