USB: mct_u232: fix broken close
[linux-2.6.git] / drivers / usb / serial / belkin_sa.c
1 /*
2  * Belkin USB Serial Adapter Driver
3  *
4  *  Copyright (C) 2000          William Greathouse (wgreathouse@smva.com)
5  *  Copyright (C) 2000-2001     Greg Kroah-Hartman (greg@kroah.com)
6  *  Copyright (C) 2010          Johan Hovold (jhovold@gmail.com)
7  *
8  *  This program is largely derived from work by the linux-usb group
9  *  and associated source files.  Please see the usb/serial files for
10  *  individual credits and copyrights.
11  *
12  *      This program is free software; you can redistribute it and/or modify
13  *      it under the terms of the GNU General Public License as published by
14  *      the Free Software Foundation; either version 2 of the License, or
15  *      (at your option) any later version.
16  *
17  * See Documentation/usb/usb-serial.txt for more information on using this
18  * driver
19  *
20  * TODO:
21  * -- Add true modem contol line query capability.  Currently we track the
22  *    states reported by the interrupt and the states we request.
23  * -- Add error reporting back to application for UART error conditions.
24  *    Just point me at how to implement this and I'll do it. I've put the
25  *    framework in, but haven't analyzed the "tty_flip" interface yet.
26  * -- Add support for flush commands
27  * -- Add everything that is missing :)
28  *
29  * 27-Nov-2001 gkh
30  *      compressed all the differnent device entries into 1.
31  *
32  * 30-May-2001 gkh
33  *      switched from using spinlock to a semaphore, which fixes lots of
34  *      problems.
35  *
36  * 08-Apr-2001 gb
37  *      - Identify version on module load.
38  *
39  * 12-Mar-2001 gkh
40  *      - Added support for the GoHubs GO-COM232 device which is the same as the
41  *        Peracom device.
42  *
43  * 06-Nov-2000 gkh
44  *      - Added support for the old Belkin and Peracom devices.
45  *      - Made the port able to be opened multiple times.
46  *      - Added some defaults incase the line settings are things these devices
47  *        can't support.
48  *
49  * 18-Oct-2000 William Greathouse
50  *    Released into the wild (linux-usb-devel)
51  *
52  * 17-Oct-2000 William Greathouse
53  *    Add code to recognize firmware version and set hardware flow control
54  *    appropriately.  Belkin states that firmware prior to 3.05 does not
55  *    operate correctly in hardware handshake mode.  I have verified this
56  *    on firmware 2.05 -- for both RTS and DTR input flow control, the control
57  *    line is not reset.  The test performed by the Belkin Win* driver is
58  *    to enable hardware flow control for firmware 2.06 or greater and
59  *    for 1.00 or prior.  I am only enabling for 2.06 or greater.
60  *
61  * 12-Oct-2000 William Greathouse
62  *    First cut at supporting Belkin USB Serial Adapter F5U103
63  *    I did not have a copy of the original work to support this
64  *    adapter, so pardon any stupid mistakes.  All of the information
65  *    I am using to write this driver was acquired by using a modified
66  *    UsbSnoop on Windows2000 and from examining the other USB drivers.
67  */
68
69 #include <linux/kernel.h>
70 #include <linux/errno.h>
71 #include <linux/init.h>
72 #include <linux/slab.h>
73 #include <linux/tty.h>
74 #include <linux/tty_driver.h>
75 #include <linux/tty_flip.h>
76 #include <linux/module.h>
77 #include <linux/spinlock.h>
78 #include <linux/uaccess.h>
79 #include <linux/usb.h>
80 #include <linux/usb/serial.h>
81 #include "belkin_sa.h"
82
83 static int debug;
84
85 /*
86  * Version Information
87  */
88 #define DRIVER_VERSION "v1.3"
89 #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
90 #define DRIVER_DESC "USB Belkin Serial converter driver"
91
92 /* function prototypes for a Belkin USB Serial Adapter F5U103 */
93 static int  belkin_sa_startup(struct usb_serial *serial);
94 static void belkin_sa_release(struct usb_serial *serial);
95 static int  belkin_sa_open(struct tty_struct *tty,
96                         struct usb_serial_port *port);
97 static void belkin_sa_close(struct usb_serial_port *port);
98 static void belkin_sa_read_int_callback(struct urb *urb);
99 static void belkin_sa_process_read_urb(struct urb *urb);
100 static void belkin_sa_set_termios(struct tty_struct *tty,
101                         struct usb_serial_port *port, struct ktermios * old);
102 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
103 static int  belkin_sa_tiocmget(struct tty_struct *tty, struct file *file);
104 static int  belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
105                                         unsigned int set, unsigned int clear);
106
107
108 static const struct usb_device_id id_table_combined[] = {
109         { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
110         { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
111         { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
112         { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
113         { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
114         { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
115         { }     /* Terminating entry */
116 };
117 MODULE_DEVICE_TABLE(usb, id_table_combined);
118
119 static struct usb_driver belkin_driver = {
120         .name =         "belkin",
121         .probe =        usb_serial_probe,
122         .disconnect =   usb_serial_disconnect,
123         .id_table =     id_table_combined,
124         .no_dynamic_id =        1,
125 };
126
127 /* All of the device info needed for the serial converters */
128 static struct usb_serial_driver belkin_device = {
129         .driver = {
130                 .owner =        THIS_MODULE,
131                 .name =         "belkin",
132         },
133         .description =          "Belkin / Peracom / GoHubs USB Serial Adapter",
134         .usb_driver =           &belkin_driver,
135         .id_table =             id_table_combined,
136         .num_ports =            1,
137         .open =                 belkin_sa_open,
138         .close =                belkin_sa_close,
139         .read_int_callback =    belkin_sa_read_int_callback,
140         .process_read_urb =     belkin_sa_process_read_urb,
141         .set_termios =          belkin_sa_set_termios,
142         .break_ctl =            belkin_sa_break_ctl,
143         .tiocmget =             belkin_sa_tiocmget,
144         .tiocmset =             belkin_sa_tiocmset,
145         .attach =               belkin_sa_startup,
146         .release =              belkin_sa_release,
147 };
148
149 struct belkin_sa_private {
150         spinlock_t              lock;
151         unsigned long           control_state;
152         unsigned char           last_lsr;
153         unsigned char           last_msr;
154         int                     bad_flow_control;
155 };
156
157
158 /*
159  * ***************************************************************************
160  * Belkin USB Serial Adapter F5U103 specific driver functions
161  * ***************************************************************************
162  */
163
164 #define WDR_TIMEOUT 5000 /* default urb timeout */
165
166 /* assumes that struct usb_serial *serial is available */
167 #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
168                                             (c), BELKIN_SA_SET_REQUEST_TYPE, \
169                                             (v), 0, NULL, 0, WDR_TIMEOUT)
170
171 /* do some startup allocations not currently performed by usb_serial_probe() */
172 static int belkin_sa_startup(struct usb_serial *serial)
173 {
174         struct usb_device *dev = serial->dev;
175         struct belkin_sa_private *priv;
176
177         /* allocate the private data structure */
178         priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
179         if (!priv)
180                 return -1; /* error */
181         /* set initial values for control structures */
182         spin_lock_init(&priv->lock);
183         priv->control_state = 0;
184         priv->last_lsr = 0;
185         priv->last_msr = 0;
186         /* see comments at top of file */
187         priv->bad_flow_control =
188                 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
189         dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
190                                         le16_to_cpu(dev->descriptor.bcdDevice),
191                                         priv->bad_flow_control);
192
193         init_waitqueue_head(&serial->port[0]->write_wait);
194         usb_set_serial_port_data(serial->port[0], priv);
195
196         return 0;
197 }
198
199 static void belkin_sa_release(struct usb_serial *serial)
200 {
201         int i;
202
203         dbg("%s", __func__);
204
205         for (i = 0; i < serial->num_ports; ++i)
206                 kfree(usb_get_serial_port_data(serial->port[i]));
207 }
208
209 static int belkin_sa_open(struct tty_struct *tty,
210                                         struct usb_serial_port *port)
211 {
212         int retval;
213
214         dbg("%s port %d", __func__, port->number);
215
216         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
217         if (retval) {
218                 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
219                 return retval;
220         }
221
222         retval = usb_serial_generic_open(tty, port);
223         if (retval)
224                 usb_kill_urb(port->interrupt_in_urb);
225
226         return retval;
227 }
228
229 static void belkin_sa_close(struct usb_serial_port *port)
230 {
231         dbg("%s port %d", __func__, port->number);
232
233         usb_serial_generic_close(port);
234         usb_kill_urb(port->interrupt_in_urb);
235 }
236
237 static void belkin_sa_read_int_callback(struct urb *urb)
238 {
239         struct usb_serial_port *port = urb->context;
240         struct belkin_sa_private *priv;
241         unsigned char *data = urb->transfer_buffer;
242         int retval;
243         int status = urb->status;
244         unsigned long flags;
245
246         switch (status) {
247         case 0:
248                 /* success */
249                 break;
250         case -ECONNRESET:
251         case -ENOENT:
252         case -ESHUTDOWN:
253                 /* this urb is terminated, clean up */
254                 dbg("%s - urb shutting down with status: %d",
255                     __func__, status);
256                 return;
257         default:
258                 dbg("%s - nonzero urb status received: %d",
259                     __func__, status);
260                 goto exit;
261         }
262
263         usb_serial_debug_data(debug, &port->dev, __func__,
264                                         urb->actual_length, data);
265
266         /* Handle known interrupt data */
267         /* ignore data[0] and data[1] */
268
269         priv = usb_get_serial_port_data(port);
270         spin_lock_irqsave(&priv->lock, flags);
271         priv->last_msr = data[BELKIN_SA_MSR_INDEX];
272
273         /* Record Control Line states */
274         if (priv->last_msr & BELKIN_SA_MSR_DSR)
275                 priv->control_state |= TIOCM_DSR;
276         else
277                 priv->control_state &= ~TIOCM_DSR;
278
279         if (priv->last_msr & BELKIN_SA_MSR_CTS)
280                 priv->control_state |= TIOCM_CTS;
281         else
282                 priv->control_state &= ~TIOCM_CTS;
283
284         if (priv->last_msr & BELKIN_SA_MSR_RI)
285                 priv->control_state |= TIOCM_RI;
286         else
287                 priv->control_state &= ~TIOCM_RI;
288
289         if (priv->last_msr & BELKIN_SA_MSR_CD)
290                 priv->control_state |= TIOCM_CD;
291         else
292                 priv->control_state &= ~TIOCM_CD;
293
294         priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
295         spin_unlock_irqrestore(&priv->lock, flags);
296 exit:
297         retval = usb_submit_urb(urb, GFP_ATOMIC);
298         if (retval)
299                 dev_err(&port->dev, "%s - usb_submit_urb failed with "
300                         "result %d\n", __func__, retval);
301 }
302
303 static void belkin_sa_process_read_urb(struct urb *urb)
304 {
305         struct usb_serial_port *port = urb->context;
306         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
307         struct tty_struct *tty;
308         unsigned char *data = urb->transfer_buffer;
309         unsigned long flags;
310         unsigned char status;
311         char tty_flag;
312
313         /* Update line status */
314         tty_flag = TTY_NORMAL;
315
316         spin_lock_irqsave(&priv->lock, flags);
317         status = priv->last_lsr;
318         priv->last_lsr &= ~BELKIN_SA_LSR_ERR;
319         spin_unlock_irqrestore(&priv->lock, flags);
320
321         if (!urb->actual_length)
322                 return;
323
324         tty = tty_port_tty_get(&port->port);
325         if (!tty)
326                 return;
327
328         if (status & BELKIN_SA_LSR_ERR) {
329                 /* Break takes precedence over parity, which takes precedence
330                  * over framing errors. */
331                 if (status & BELKIN_SA_LSR_BI)
332                         tty_flag = TTY_BREAK;
333                 else if (status & BELKIN_SA_LSR_PE)
334                         tty_flag = TTY_PARITY;
335                 else if (status & BELKIN_SA_LSR_FE)
336                         tty_flag = TTY_FRAME;
337                 dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag);
338
339                 /* Overrun is special, not associated with a char. */
340                 if (status & BELKIN_SA_LSR_OE)
341                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
342         }
343
344         tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
345                                                         urb->actual_length);
346         tty_flip_buffer_push(tty);
347         tty_kref_put(tty);
348 }
349
350 static void belkin_sa_set_termios(struct tty_struct *tty,
351                 struct usb_serial_port *port, struct ktermios *old_termios)
352 {
353         struct usb_serial *serial = port->serial;
354         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
355         unsigned int iflag;
356         unsigned int cflag;
357         unsigned int old_iflag = 0;
358         unsigned int old_cflag = 0;
359         __u16 urb_value = 0; /* Will hold the new flags */
360         unsigned long flags;
361         unsigned long control_state;
362         int bad_flow_control;
363         speed_t baud;
364         struct ktermios *termios = tty->termios;
365
366         iflag = termios->c_iflag;
367         cflag = termios->c_cflag;
368
369         termios->c_cflag &= ~CMSPAR;
370
371         /* get a local copy of the current port settings */
372         spin_lock_irqsave(&priv->lock, flags);
373         control_state = priv->control_state;
374         bad_flow_control = priv->bad_flow_control;
375         spin_unlock_irqrestore(&priv->lock, flags);
376
377         old_iflag = old_termios->c_iflag;
378         old_cflag = old_termios->c_cflag;
379
380         /* Set the baud rate */
381         if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
382                 /* reassert DTR and (maybe) RTS on transition from B0 */
383                 if ((old_cflag & CBAUD) == B0) {
384                         control_state |= (TIOCM_DTR|TIOCM_RTS);
385                         if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
386                                 dev_err(&port->dev, "Set DTR error\n");
387                         /* don't set RTS if using hardware flow control */
388                         if (!(old_cflag & CRTSCTS))
389                                 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
390                                                                 , 1) < 0)
391                                         dev_err(&port->dev, "Set RTS error\n");
392                 }
393         }
394
395         baud = tty_get_baud_rate(tty);
396         if (baud) {
397                 urb_value = BELKIN_SA_BAUD(baud);
398                 /* Clip to maximum speed */
399                 if (urb_value == 0)
400                         urb_value = 1;
401                 /* Turn it back into a resulting real baud rate */
402                 baud = BELKIN_SA_BAUD(urb_value);
403
404                 /* Report the actual baud rate back to the caller */
405                 tty_encode_baud_rate(tty, baud, baud);
406                 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
407                         dev_err(&port->dev, "Set baudrate error\n");
408         } else {
409                 /* Disable flow control */
410                 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
411                                                 BELKIN_SA_FLOW_NONE) < 0)
412                         dev_err(&port->dev, "Disable flowcontrol error\n");
413                 /* Drop RTS and DTR */
414                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
415                 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
416                         dev_err(&port->dev, "DTR LOW error\n");
417                 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
418                         dev_err(&port->dev, "RTS LOW error\n");
419         }
420
421         /* set the parity */
422         if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
423                 if (cflag & PARENB)
424                         urb_value = (cflag & PARODD) ?  BELKIN_SA_PARITY_ODD
425                                                 : BELKIN_SA_PARITY_EVEN;
426                 else
427                         urb_value = BELKIN_SA_PARITY_NONE;
428                 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
429                         dev_err(&port->dev, "Set parity error\n");
430         }
431
432         /* set the number of data bits */
433         if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
434                 switch (cflag & CSIZE) {
435                 case CS5:
436                         urb_value = BELKIN_SA_DATA_BITS(5);
437                         break;
438                 case CS6:
439                         urb_value = BELKIN_SA_DATA_BITS(6);
440                         break;
441                 case CS7:
442                         urb_value = BELKIN_SA_DATA_BITS(7);
443                         break;
444                 case CS8:
445                         urb_value = BELKIN_SA_DATA_BITS(8);
446                         break;
447                 default: dbg("CSIZE was not CS5-CS8, using default of 8");
448                         urb_value = BELKIN_SA_DATA_BITS(8);
449                         break;
450                 }
451                 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
452                         dev_err(&port->dev, "Set data bits error\n");
453         }
454
455         /* set the number of stop bits */
456         if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
457                 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
458                                                 : BELKIN_SA_STOP_BITS(1);
459                 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
460                                                         urb_value) < 0)
461                         dev_err(&port->dev, "Set stop bits error\n");
462         }
463
464         /* Set flow control */
465         if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
466                 ((cflag ^ old_cflag) & CRTSCTS)) {
467                 urb_value = 0;
468                 if ((iflag & IXOFF) || (iflag & IXON))
469                         urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
470                 else
471                         urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
472
473                 if (cflag & CRTSCTS)
474                         urb_value |=  (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
475                 else
476                         urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
477
478                 if (bad_flow_control)
479                         urb_value &= ~(BELKIN_SA_FLOW_IRTS);
480
481                 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
482                         dev_err(&port->dev, "Set flow control error\n");
483         }
484
485         /* save off the modified port settings */
486         spin_lock_irqsave(&priv->lock, flags);
487         priv->control_state = control_state;
488         spin_unlock_irqrestore(&priv->lock, flags);
489 }
490
491 static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
492 {
493         struct usb_serial_port *port = tty->driver_data;
494         struct usb_serial *serial = port->serial;
495
496         if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
497                 dev_err(&port->dev, "Set break_ctl %d\n", break_state);
498 }
499
500 static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
501 {
502         struct usb_serial_port *port = tty->driver_data;
503         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
504         unsigned long control_state;
505         unsigned long flags;
506
507         dbg("%s", __func__);
508
509         spin_lock_irqsave(&priv->lock, flags);
510         control_state = priv->control_state;
511         spin_unlock_irqrestore(&priv->lock, flags);
512
513         return control_state;
514 }
515
516 static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
517                                unsigned int set, unsigned int clear)
518 {
519         struct usb_serial_port *port = tty->driver_data;
520         struct usb_serial *serial = port->serial;
521         struct belkin_sa_private *priv = usb_get_serial_port_data(port);
522         unsigned long control_state;
523         unsigned long flags;
524         int retval;
525         int rts = 0;
526         int dtr = 0;
527
528         dbg("%s", __func__);
529
530         spin_lock_irqsave(&priv->lock, flags);
531         control_state = priv->control_state;
532
533         if (set & TIOCM_RTS) {
534                 control_state |= TIOCM_RTS;
535                 rts = 1;
536         }
537         if (set & TIOCM_DTR) {
538                 control_state |= TIOCM_DTR;
539                 dtr = 1;
540         }
541         if (clear & TIOCM_RTS) {
542                 control_state &= ~TIOCM_RTS;
543                 rts = 0;
544         }
545         if (clear & TIOCM_DTR) {
546                 control_state &= ~TIOCM_DTR;
547                 dtr = 0;
548         }
549
550         priv->control_state = control_state;
551         spin_unlock_irqrestore(&priv->lock, flags);
552
553         retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
554         if (retval < 0) {
555                 dev_err(&port->dev, "Set RTS error %d\n", retval);
556                 goto exit;
557         }
558
559         retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
560         if (retval < 0) {
561                 dev_err(&port->dev, "Set DTR error %d\n", retval);
562                 goto exit;
563         }
564 exit:
565         return retval;
566 }
567
568
569 static int __init belkin_sa_init(void)
570 {
571         int retval;
572         retval = usb_serial_register(&belkin_device);
573         if (retval)
574                 goto failed_usb_serial_register;
575         retval = usb_register(&belkin_driver);
576         if (retval)
577                 goto failed_usb_register;
578         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
579                DRIVER_DESC "\n");
580         return 0;
581 failed_usb_register:
582         usb_serial_deregister(&belkin_device);
583 failed_usb_serial_register:
584         return retval;
585 }
586
587 static void __exit belkin_sa_exit (void)
588 {
589         usb_deregister(&belkin_driver);
590         usb_serial_deregister(&belkin_device);
591 }
592
593
594 module_init(belkin_sa_init);
595 module_exit(belkin_sa_exit);
596
597 MODULE_AUTHOR(DRIVER_AUTHOR);
598 MODULE_DESCRIPTION(DRIVER_DESC);
599 MODULE_VERSION(DRIVER_VERSION);
600 MODULE_LICENSE("GPL");
601
602 module_param(debug, bool, S_IRUGO | S_IWUSR);
603 MODULE_PARM_DESC(debug, "Debug enabled or not");