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