USB: gadgetfs race fix
[linux-2.6] / drivers / usb / serial / mct_u232.c
1 /*
2  * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
3  *
4  *   Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
5  *
6  *   This program is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU General Public License as published by
8  *   the Free Software Foundation; either version 2 of the License, or
9  *   (at your option) any later version.
10  *
11  * This program is largely derived from the Belkin USB Serial Adapter Driver
12  * (see belkin_sa.[ch]). All of the information about the device was acquired
13  * by using SniffUSB on Windows98. For technical details see mct_u232.h.
14  *
15  * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
16  * do the reverse engineering and how to write a USB serial device driver.
17  *
18  * TO BE DONE, TO BE CHECKED:
19  *   DTR/RTS signal handling may be incomplete or incorrect. I have mainly
20  *   implemented what I have seen with SniffUSB or found in belkin_sa.c.
21  *   For further TODOs check also belkin_sa.c.
22  *
23  * TEST STATUS:
24  *   Basic tests have been performed with minicom/zmodem transfers and
25  *   modem dialing under Linux 2.4.0-test10 (for me it works fine).
26  *
27  * 04-Nov-2003 Bill Marr <marr at flex dot com>
28  *   - Mimic Windows driver by sending 2 USB 'device request' messages
29  *     following normal 'baud rate change' message.  This allows data to be
30  *     transmitted to RS-232 devices which don't assert the 'CTS' signal.
31  *
32  * 10-Nov-2001 Wolfgang Grandegger
33  *   - Fixed an endianess problem with the baudrate selection for PowerPC.
34  *
35  * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
36  *      Added support for the Belkin F5U109 DB9 adaptor
37  *
38  * 30-May-2001 Greg Kroah-Hartman
39  *      switched from using spinlock to a semaphore, which fixes lots of problems.
40  *
41  * 04-May-2001 Stelian Pop
42  *   - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
43  *     instead of the device reported 32 (using 32 bytes causes many data
44  *     loss, Windows driver uses 16 too).
45  *
46  * 02-May-2001 Stelian Pop
47  *   - Fixed the baud calculation for Sitecom U232-P25 model
48  *
49  * 08-Apr-2001 gb
50  *   - Identify version on module load.
51  *
52  * 06-Jan-2001 Cornel Ciocirlan 
53  *   - Added support for Sitecom U232-P25 model (Product Id 0x0230)
54  *   - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
55  *
56  * 29-Nov-2000 Greg Kroah-Hartman
57  *   - Added device id table to fit with 2.4.0-test11 structure.
58  *   - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
59  *     (lots of things will change if/when the usb-serial core changes to
60  *     handle these issues.
61  *
62  * 27-Nov-2000 Wolfgang Grandegger
63  *   A version for kernel 2.4.0-test10 released to the Linux community 
64  *   (via linux-usb-devel).
65  */
66
67 #include <linux/kernel.h>
68 #include <linux/errno.h>
69 #include <linux/init.h>
70 #include <linux/slab.h>
71 #include <linux/tty.h>
72 #include <linux/tty_driver.h>
73 #include <linux/tty_flip.h>
74 #include <linux/module.h>
75 #include <linux/spinlock.h>
76 #include <asm/uaccess.h>
77 #include <linux/usb.h>
78 #include <linux/usb/serial.h>
79 #include "mct_u232.h"
80
81 /*
82  * Version Information
83  */
84 #define DRIVER_VERSION "z2.0"           /* Linux in-kernel version */
85 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
86 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
87
88 static int debug;
89
90 /*
91  * Function prototypes
92  */
93 static int  mct_u232_startup             (struct usb_serial *serial);
94 static void mct_u232_shutdown            (struct usb_serial *serial);
95 static int  mct_u232_open                (struct usb_serial_port *port,
96                                           struct file *filp);
97 static void mct_u232_close               (struct usb_serial_port *port,
98                                           struct file *filp);
99 static void mct_u232_read_int_callback   (struct urb *urb);
100 static void mct_u232_set_termios         (struct usb_serial_port *port,
101                                           struct ktermios * old);
102 static int  mct_u232_ioctl               (struct usb_serial_port *port,
103                                           struct file * file,
104                                           unsigned int cmd,
105                                           unsigned long arg);
106 static void mct_u232_break_ctl           (struct usb_serial_port *port,
107                                           int break_state );
108 static int  mct_u232_tiocmget            (struct usb_serial_port *port,
109                                           struct file *file);
110 static int  mct_u232_tiocmset            (struct usb_serial_port *port,
111                                           struct file *file, unsigned int set,
112                                           unsigned int clear);
113 /*
114  * All of the device info needed for the MCT USB-RS232 converter.
115  */
116 static struct usb_device_id id_table_combined [] = {
117         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
118         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
119         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
120         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
121         { }             /* Terminating entry */
122 };
123
124 MODULE_DEVICE_TABLE (usb, id_table_combined);
125
126 static struct usb_driver mct_u232_driver = {
127         .name =         "mct_u232",
128         .probe =        usb_serial_probe,
129         .disconnect =   usb_serial_disconnect,
130         .id_table =     id_table_combined,
131         .no_dynamic_id =        1,
132 };
133
134 static struct usb_serial_driver mct_u232_device = {
135         .driver = {
136                 .owner =        THIS_MODULE,
137                 .name =         "mct_u232",
138         },
139         .description =       "MCT U232",
140         .usb_driver =        &mct_u232_driver,
141         .id_table =          id_table_combined,
142         .num_interrupt_in =  2,
143         .num_bulk_in =       0,
144         .num_bulk_out =      1,
145         .num_ports =         1,
146         .open =              mct_u232_open,
147         .close =             mct_u232_close,
148         .read_int_callback = mct_u232_read_int_callback,
149         .ioctl =             mct_u232_ioctl,
150         .set_termios =       mct_u232_set_termios,
151         .break_ctl =         mct_u232_break_ctl,
152         .tiocmget =          mct_u232_tiocmget,
153         .tiocmset =          mct_u232_tiocmset,
154         .attach =            mct_u232_startup,
155         .shutdown =          mct_u232_shutdown,
156 };
157
158
159 struct mct_u232_private {
160         spinlock_t lock;
161         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
162         unsigned char        last_lcr;      /* Line Control Register */
163         unsigned char        last_lsr;      /* Line Status Register */
164         unsigned char        last_msr;      /* Modem Status Register */
165 };
166
167 /*
168  * Handle vendor specific USB requests
169  */
170
171 #define WDR_TIMEOUT 5000 /* default urb timeout */
172
173 /*
174  * Later day 2.6.0-test kernels have new baud rates like B230400 which
175  * we do not know how to support. We ignore them for the moment.
176  * XXX Rate-limit the error message, it's user triggerable.
177  */
178 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value)
179 {
180         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
181           || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
182                 switch (value) {
183                 case    B300: return 0x01;
184                 case    B600: return 0x02; /* this one not tested */
185                 case   B1200: return 0x03;
186                 case   B2400: return 0x04;
187                 case   B4800: return 0x06;
188                 case   B9600: return 0x08;
189                 case  B19200: return 0x09;
190                 case  B38400: return 0x0a;
191                 case  B57600: return 0x0b;
192                 case B115200: return 0x0c;
193                 default:
194                         err("MCT USB-RS232: unsupported baudrate request 0x%x,"
195                             " using default of B9600", value);
196                         return 0x08;
197                 }
198         } else {
199                 switch (value) {
200                 case    B300: value =     300; break;
201                 case    B600: value =     600; break;
202                 case   B1200: value =    1200; break;
203                 case   B2400: value =    2400; break;
204                 case   B4800: value =    4800; break;
205                 case   B9600: value =    9600; break;
206                 case  B19200: value =   19200; break;
207                 case  B38400: value =   38400; break;
208                 case  B57600: value =   57600; break;
209                 case B115200: value =  115200; break;
210                 default:
211                         err("MCT USB-RS232: unsupported baudrate request 0x%x,"
212                             " using default of B9600", value);
213                         value = 9600;
214                 }
215                 return 115200/value;
216         }
217 }
218
219 static int mct_u232_set_baud_rate(struct usb_serial *serial, int value)
220 {
221         __le32 divisor;
222         int rc;
223         unsigned char zero_byte = 0;
224
225         divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value));
226
227         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
228                              MCT_U232_SET_BAUD_RATE_REQUEST,
229                              MCT_U232_SET_REQUEST_TYPE,
230                              0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
231                              WDR_TIMEOUT);
232         if (rc < 0)
233                 err("Set BAUD RATE %d failed (error = %d)", value, rc);
234         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
235
236         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
237            always sends two extra USB 'device request' messages after the
238            'baud rate change' message.  The actual functionality of the
239            request codes in these messages is not fully understood but these
240            particular codes are never seen in any operation besides a baud
241            rate change.  Both of these messages send a single byte of data
242            whose value is always zero.  The second of these two extra messages
243            is required in order for data to be properly written to an RS-232
244            device which does not assert the 'CTS' signal. */
245
246         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
247                              MCT_U232_SET_UNKNOWN1_REQUEST, 
248                              MCT_U232_SET_REQUEST_TYPE,
249                              0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE, 
250                              WDR_TIMEOUT);
251         if (rc < 0)
252                 err("Sending USB device request code %d failed (error = %d)", 
253                     MCT_U232_SET_UNKNOWN1_REQUEST, rc);
254
255         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
256                              MCT_U232_SET_UNKNOWN2_REQUEST, 
257                              MCT_U232_SET_REQUEST_TYPE,
258                              0, 0, &zero_byte, MCT_U232_SET_UNKNOWN2_SIZE, 
259                              WDR_TIMEOUT);
260         if (rc < 0)
261                 err("Sending USB device request code %d failed (error = %d)", 
262                     MCT_U232_SET_UNKNOWN2_REQUEST, rc);
263
264         return rc;
265 } /* mct_u232_set_baud_rate */
266
267 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
268 {
269         int rc;
270         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
271                              MCT_U232_SET_LINE_CTRL_REQUEST,
272                              MCT_U232_SET_REQUEST_TYPE,
273                              0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
274                              WDR_TIMEOUT);
275         if (rc < 0)
276                 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
277         dbg("set_line_ctrl: 0x%x", lcr);
278         return rc;
279 } /* mct_u232_set_line_ctrl */
280
281 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
282                                    unsigned int control_state)
283 {
284         int rc;
285         unsigned char mcr = MCT_U232_MCR_NONE;
286
287         if (control_state & TIOCM_DTR)
288                 mcr |= MCT_U232_MCR_DTR;
289         if (control_state & TIOCM_RTS)
290                 mcr |= MCT_U232_MCR_RTS;
291
292         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
293                              MCT_U232_SET_MODEM_CTRL_REQUEST,
294                              MCT_U232_SET_REQUEST_TYPE,
295                              0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
296                              WDR_TIMEOUT);
297         if (rc < 0)
298                 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
299         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
300
301         return rc;
302 } /* mct_u232_set_modem_ctrl */
303
304 static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
305 {
306         int rc;
307         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
308                              MCT_U232_GET_MODEM_STAT_REQUEST,
309                              MCT_U232_GET_REQUEST_TYPE,
310                              0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
311                              WDR_TIMEOUT);
312         if (rc < 0) {
313                 err("Get MODEM STATus failed (error = %d)", rc);
314                 *msr = 0;
315         }
316         dbg("get_modem_stat: 0x%x", *msr);
317         return rc;
318 } /* mct_u232_get_modem_stat */
319
320 static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr)
321 {
322         /* Translate Control Line states */
323         if (msr & MCT_U232_MSR_DSR)
324                 *control_state |=  TIOCM_DSR;
325         else
326                 *control_state &= ~TIOCM_DSR;
327         if (msr & MCT_U232_MSR_CTS)
328                 *control_state |=  TIOCM_CTS;
329         else
330                 *control_state &= ~TIOCM_CTS;
331         if (msr & MCT_U232_MSR_RI)
332                 *control_state |=  TIOCM_RI;
333         else
334                 *control_state &= ~TIOCM_RI;
335         if (msr & MCT_U232_MSR_CD)
336                 *control_state |=  TIOCM_CD;
337         else
338                 *control_state &= ~TIOCM_CD;
339         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
340 } /* mct_u232_msr_to_state */
341
342 /*
343  * Driver's tty interface functions
344  */
345
346 static int mct_u232_startup (struct usb_serial *serial)
347 {
348         struct mct_u232_private *priv;
349         struct usb_serial_port *port, *rport;
350
351         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
352         if (!priv)
353                 return -ENOMEM;
354         spin_lock_init(&priv->lock);
355         usb_set_serial_port_data(serial->port[0], priv);
356
357         init_waitqueue_head(&serial->port[0]->write_wait);
358
359         /* Puh, that's dirty */
360         port = serial->port[0];
361         rport = serial->port[1];
362         /* No unlinking, it wasn't submitted yet. */
363         usb_free_urb(port->read_urb);
364         port->read_urb = rport->interrupt_in_urb;
365         rport->interrupt_in_urb = NULL;
366         port->read_urb->context = port;
367
368         return (0);
369 } /* mct_u232_startup */
370
371
372 static void mct_u232_shutdown (struct usb_serial *serial)
373 {
374         struct mct_u232_private *priv;
375         int i;
376         
377         dbg("%s", __FUNCTION__);
378
379         for (i=0; i < serial->num_ports; ++i) {
380                 /* My special items, the standard routines free my urbs */
381                 priv = usb_get_serial_port_data(serial->port[i]);
382                 if (priv) {
383                         usb_set_serial_port_data(serial->port[i], NULL);
384                         kfree(priv);
385                 }
386         }
387 } /* mct_u232_shutdown */
388
389 static int  mct_u232_open (struct usb_serial_port *port, struct file *filp)
390 {
391         struct usb_serial *serial = port->serial;
392         struct mct_u232_private *priv = usb_get_serial_port_data(port);
393         int retval = 0;
394         unsigned int control_state;
395         unsigned long flags;
396         unsigned char last_lcr;
397         unsigned char last_msr;
398
399         dbg("%s port %d", __FUNCTION__, port->number);
400
401         /* Compensate for a hardware bug: although the Sitecom U232-P25
402          * device reports a maximum output packet size of 32 bytes,
403          * it seems to be able to accept only 16 bytes (and that's what
404          * SniffUSB says too...)
405          */
406         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
407                 port->bulk_out_size = 16;
408
409         /* Do a defined restart: the normal serial device seems to 
410          * always turn on DTR and RTS here, so do the same. I'm not
411          * sure if this is really necessary. But it should not harm
412          * either.
413          */
414         spin_lock_irqsave(&priv->lock, flags);
415         if (port->tty->termios->c_cflag & CBAUD)
416                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
417         else
418                 priv->control_state = 0;
419         
420         priv->last_lcr = (MCT_U232_DATA_BITS_8 | 
421                           MCT_U232_PARITY_NONE |
422                           MCT_U232_STOP_BITS_1);
423         control_state = priv->control_state;
424         last_lcr = priv->last_lcr;
425         spin_unlock_irqrestore(&priv->lock, flags);
426         mct_u232_set_modem_ctrl(serial, control_state);
427         mct_u232_set_line_ctrl(serial, last_lcr);
428
429         /* Read modem status and update control state */
430         mct_u232_get_modem_stat(serial, &last_msr);
431         spin_lock_irqsave(&priv->lock, flags);
432         priv->last_msr = last_msr;
433         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
434         spin_unlock_irqrestore(&priv->lock, flags);
435
436         port->read_urb->dev = port->serial->dev;
437         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
438         if (retval) {
439                 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
440                     port->read_urb->pipe, retval);
441                 goto exit;
442         }
443
444         port->interrupt_in_urb->dev = port->serial->dev;
445         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
446         if (retval)
447                 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
448                     port->interrupt_in_urb->pipe, retval);
449
450 exit:
451         return 0;
452 } /* mct_u232_open */
453
454
455 static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
456 {
457         dbg("%s port %d", __FUNCTION__, port->number);
458
459         if (port->serial->dev) {
460                 /* shutdown our urbs */
461                 usb_kill_urb(port->write_urb);
462                 usb_kill_urb(port->read_urb);
463                 usb_kill_urb(port->interrupt_in_urb);
464         }
465 } /* mct_u232_close */
466
467
468 static void mct_u232_read_int_callback (struct urb *urb)
469 {
470         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
471         struct mct_u232_private *priv = usb_get_serial_port_data(port);
472         struct usb_serial *serial = port->serial;
473         struct tty_struct *tty;
474         unsigned char *data = urb->transfer_buffer;
475         int status;
476         unsigned long flags;
477
478         switch (urb->status) {
479         case 0:
480                 /* success */
481                 break;
482         case -ECONNRESET:
483         case -ENOENT:
484         case -ESHUTDOWN:
485                 /* this urb is terminated, clean up */
486                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
487                 return;
488         default:
489                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
490                 goto exit;
491         }
492
493         if (!serial) {
494                 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
495                 return;
496         }
497
498         dbg("%s - port %d", __FUNCTION__, port->number);
499         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
500
501         /*
502          * Work-a-round: handle the 'usual' bulk-in pipe here
503          */
504         if (urb->transfer_buffer_length > 2) {
505                 int i;
506                 tty = port->tty;
507                 if (urb->actual_length) {
508                         for (i = 0; i < urb->actual_length ; ++i) {
509                                 tty_insert_flip_char(tty, data[i], 0);
510                         }
511                         tty_flip_buffer_push(tty);
512                 }
513                 goto exit;
514         }
515         
516         /*
517          * The interrupt-in pipe signals exceptional conditions (modem line
518          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
519          */
520         spin_lock_irqsave(&priv->lock, flags);
521         priv->last_msr = data[MCT_U232_MSR_INDEX];
522         
523         /* Record Control Line states */
524         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
525
526 #if 0
527         /* Not yet handled. See belin_sa.c for further information */
528         /* Now to report any errors */
529         priv->last_lsr = data[MCT_U232_LSR_INDEX];
530         /*
531          * fill in the flip buffer here, but I do not know the relation
532          * to the current/next receive buffer or characters.  I need
533          * to look in to this before committing any code.
534          */
535         if (priv->last_lsr & MCT_U232_LSR_ERR) {
536                 tty = port->tty;
537                 /* Overrun Error */
538                 if (priv->last_lsr & MCT_U232_LSR_OE) {
539                 }
540                 /* Parity Error */
541                 if (priv->last_lsr & MCT_U232_LSR_PE) {
542                 }
543                 /* Framing Error */
544                 if (priv->last_lsr & MCT_U232_LSR_FE) {
545                 }
546                 /* Break Indicator */
547                 if (priv->last_lsr & MCT_U232_LSR_BI) {
548                 }
549         }
550 #endif
551         spin_unlock_irqrestore(&priv->lock, flags);
552 exit:
553         status = usb_submit_urb (urb, GFP_ATOMIC);
554         if (status)
555                 err ("%s - usb_submit_urb failed with result %d",
556                      __FUNCTION__, status);
557 } /* mct_u232_read_int_callback */
558
559 static void mct_u232_set_termios (struct usb_serial_port *port,
560                                   struct ktermios *old_termios)
561 {
562         struct usb_serial *serial = port->serial;
563         struct mct_u232_private *priv = usb_get_serial_port_data(port);
564         unsigned int iflag = port->tty->termios->c_iflag;
565         unsigned int cflag = port->tty->termios->c_cflag;
566         unsigned int old_cflag = old_termios->c_cflag;
567         unsigned long flags;
568         unsigned int control_state, new_state;
569         unsigned char last_lcr;
570
571         /* get a local copy of the current port settings */
572         spin_lock_irqsave(&priv->lock, flags);
573         control_state = priv->control_state;
574         spin_unlock_irqrestore(&priv->lock, flags);
575         last_lcr = 0;
576
577         /*
578          * Update baud rate.
579          * Do not attempt to cache old rates and skip settings,
580          * disconnects screw such tricks up completely.
581          * Premature optimization is the root of all evil.
582          */
583
584         /* reassert DTR and (maybe) RTS on transition from B0 */
585         if ((old_cflag & CBAUD) == B0) {
586                 dbg("%s: baud was B0", __FUNCTION__);
587                 control_state |= TIOCM_DTR;
588                 /* don't set RTS if using hardware flow control */
589                 if (!(old_cflag & CRTSCTS)) {
590                         control_state |= TIOCM_RTS;
591                 }
592                 mct_u232_set_modem_ctrl(serial, control_state);
593         }
594
595         mct_u232_set_baud_rate(serial, cflag & CBAUD);
596
597         if ((cflag & CBAUD) == B0 ) {
598                 dbg("%s: baud is B0", __FUNCTION__);
599                 /* Drop RTS and DTR */
600                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
601                 mct_u232_set_modem_ctrl(serial, control_state);
602         }
603
604         /*
605          * Update line control register (LCR)
606          */
607
608         /* set the parity */
609         if (cflag & PARENB)
610                 last_lcr |= (cflag & PARODD) ?
611                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
612         else
613                 last_lcr |= MCT_U232_PARITY_NONE;
614
615         /* set the number of data bits */
616         switch (cflag & CSIZE) {
617         case CS5:
618                 last_lcr |= MCT_U232_DATA_BITS_5; break;
619         case CS6:
620                 last_lcr |= MCT_U232_DATA_BITS_6; break;
621         case CS7:
622                 last_lcr |= MCT_U232_DATA_BITS_7; break;
623         case CS8:
624                 last_lcr |= MCT_U232_DATA_BITS_8; break;
625         default:
626                 err("CSIZE was not CS5-CS8, using default of 8");
627                 last_lcr |= MCT_U232_DATA_BITS_8;
628                 break;
629         }
630
631         /* set the number of stop bits */
632         last_lcr |= (cflag & CSTOPB) ?
633                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
634
635         mct_u232_set_line_ctrl(serial, last_lcr);
636
637         /*
638          * Set flow control: well, I do not really now how to handle DTR/RTS.
639          * Just do what we have seen with SniffUSB on Win98.
640          */
641         /* Drop DTR/RTS if no flow control otherwise assert */
642         new_state = control_state;
643         if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
644                 new_state |= TIOCM_DTR | TIOCM_RTS;
645         else
646                 new_state &= ~(TIOCM_DTR | TIOCM_RTS);
647         if (new_state != control_state) {
648                 mct_u232_set_modem_ctrl(serial, new_state);
649                 control_state = new_state;
650         }
651
652         /* save off the modified port settings */
653         spin_lock_irqsave(&priv->lock, flags);
654         priv->control_state = control_state;
655         priv->last_lcr = last_lcr;
656         spin_unlock_irqrestore(&priv->lock, flags);
657 } /* mct_u232_set_termios */
658
659 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
660 {
661         struct usb_serial *serial = port->serial;
662         struct mct_u232_private *priv = usb_get_serial_port_data(port);
663         unsigned char lcr;
664         unsigned long flags;
665
666         dbg("%sstate=%d", __FUNCTION__, break_state);
667
668         spin_lock_irqsave(&priv->lock, flags);
669         lcr = priv->last_lcr;
670         spin_unlock_irqrestore(&priv->lock, flags);
671
672         if (break_state)
673                 lcr |= MCT_U232_SET_BREAK;
674
675         mct_u232_set_line_ctrl(serial, lcr);
676 } /* mct_u232_break_ctl */
677
678
679 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
680 {
681         struct mct_u232_private *priv = usb_get_serial_port_data(port);
682         unsigned int control_state;
683         unsigned long flags;
684         
685         dbg("%s", __FUNCTION__);
686
687         spin_lock_irqsave(&priv->lock, flags);
688         control_state = priv->control_state;
689         spin_unlock_irqrestore(&priv->lock, flags);
690
691         return control_state;
692 }
693
694 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
695                               unsigned int set, unsigned int clear)
696 {
697         struct usb_serial *serial = port->serial;
698         struct mct_u232_private *priv = usb_get_serial_port_data(port);
699         unsigned int control_state;
700         unsigned long flags;
701         
702         dbg("%s", __FUNCTION__);
703
704         spin_lock_irqsave(&priv->lock, flags);
705         control_state = priv->control_state;
706
707         if (set & TIOCM_RTS)
708                 control_state |= TIOCM_RTS;
709         if (set & TIOCM_DTR)
710                 control_state |= TIOCM_DTR;
711         if (clear & TIOCM_RTS)
712                 control_state &= ~TIOCM_RTS;
713         if (clear & TIOCM_DTR)
714                 control_state &= ~TIOCM_DTR;
715
716         priv->control_state = control_state;
717         spin_unlock_irqrestore(&priv->lock, flags);
718         return mct_u232_set_modem_ctrl(serial, control_state);
719 }
720
721 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
722                            unsigned int cmd, unsigned long arg)
723 {
724         dbg("%scmd=0x%x", __FUNCTION__, cmd);
725
726         /* Based on code from acm.c and others */
727         switch (cmd) {
728         case TIOCMIWAIT:
729                 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
730                 /* TODO */
731                 return( 0 );
732
733         case TIOCGICOUNT:
734                 /* return count of modemline transitions */
735                 /* TODO */
736                 return 0;
737
738         default:
739                 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
740                 return(-ENOIOCTLCMD);
741                 break;
742         }
743         return 0;
744 } /* mct_u232_ioctl */
745
746
747 static int __init mct_u232_init (void)
748 {
749         int retval;
750         retval = usb_serial_register(&mct_u232_device);
751         if (retval)
752                 goto failed_usb_serial_register;
753         retval = usb_register(&mct_u232_driver);
754         if (retval)
755                 goto failed_usb_register;
756         info(DRIVER_DESC " " DRIVER_VERSION);
757         return 0;
758 failed_usb_register:
759         usb_serial_deregister(&mct_u232_device);
760 failed_usb_serial_register:
761         return retval;
762 }
763
764
765 static void __exit mct_u232_exit (void)
766 {
767         usb_deregister (&mct_u232_driver);
768         usb_serial_deregister (&mct_u232_device);
769 }
770
771
772 module_init (mct_u232_init);
773 module_exit(mct_u232_exit);
774
775 MODULE_AUTHOR( DRIVER_AUTHOR );
776 MODULE_DESCRIPTION( DRIVER_DESC );
777 MODULE_LICENSE("GPL");
778
779 module_param(debug, bool, S_IRUGO | S_IWUSR);
780 MODULE_PARM_DESC(debug, "Debug enabled or not");