ef4d7adfbd9d40a0d40665cb1116875eff21c5cd
[linux-2.6.git] / 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
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/tty.h>
29 #include <linux/tty_driver.h>
30 #include <linux/tty_flip.h>
31 #include <linux/module.h>
32 #include <linux/spinlock.h>
33 #include <linux/uaccess.h>
34 #include <asm/unaligned.h>
35 #include <linux/usb.h>
36 #include <linux/usb/serial.h>
37 #include <linux/serial.h>
38 #include <linux/ioctl.h>
39 #include "mct_u232.h"
40
41 /*
42  * Version Information
43  */
44 #define DRIVER_VERSION "z2.1"           /* Linux in-kernel version */
45 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
46 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
47
48 static bool debug;
49
50 /*
51  * Function prototypes
52  */
53 static int  mct_u232_startup(struct usb_serial *serial);
54 static void mct_u232_release(struct usb_serial *serial);
55 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
56 static void mct_u232_close(struct usb_serial_port *port);
57 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
58 static void mct_u232_read_int_callback(struct urb *urb);
59 static void mct_u232_set_termios(struct tty_struct *tty,
60                         struct usb_serial_port *port, struct ktermios *old);
61 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
62 static int  mct_u232_tiocmget(struct tty_struct *tty);
63 static int  mct_u232_tiocmset(struct tty_struct *tty,
64                         unsigned int set, unsigned int clear);
65 static int  mct_u232_ioctl(struct tty_struct *tty,
66                         unsigned int cmd, unsigned long arg);
67 static int  mct_u232_get_icount(struct tty_struct *tty,
68                         struct serial_icounter_struct *icount);
69 static void mct_u232_throttle(struct tty_struct *tty);
70 static void mct_u232_unthrottle(struct tty_struct *tty);
71
72
73 /*
74  * All of the device info needed for the MCT USB-RS232 converter.
75  */
76 static const struct usb_device_id id_table_combined[] = {
77         { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
78         { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
79         { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
80         { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
81         { }             /* Terminating entry */
82 };
83
84 MODULE_DEVICE_TABLE(usb, id_table_combined);
85
86 static struct usb_driver mct_u232_driver = {
87         .name =         "mct_u232",
88         .probe =        usb_serial_probe,
89         .disconnect =   usb_serial_disconnect,
90         .id_table =     id_table_combined,
91 };
92
93 static struct usb_serial_driver mct_u232_device = {
94         .driver = {
95                 .owner =        THIS_MODULE,
96                 .name =         "mct_u232",
97         },
98         .description =       "MCT U232",
99         .id_table =          id_table_combined,
100         .num_ports =         1,
101         .open =              mct_u232_open,
102         .close =             mct_u232_close,
103         .dtr_rts =           mct_u232_dtr_rts,
104         .throttle =          mct_u232_throttle,
105         .unthrottle =        mct_u232_unthrottle,
106         .read_int_callback = mct_u232_read_int_callback,
107         .set_termios =       mct_u232_set_termios,
108         .break_ctl =         mct_u232_break_ctl,
109         .tiocmget =          mct_u232_tiocmget,
110         .tiocmset =          mct_u232_tiocmset,
111         .attach =            mct_u232_startup,
112         .release =           mct_u232_release,
113         .ioctl =             mct_u232_ioctl,
114         .get_icount =        mct_u232_get_icount,
115 };
116
117 static struct usb_serial_driver * const serial_drivers[] = {
118         &mct_u232_device, NULL
119 };
120
121 struct mct_u232_private {
122         spinlock_t lock;
123         unsigned int         control_state; /* Modem Line Setting (TIOCM) */
124         unsigned char        last_lcr;      /* Line Control Register */
125         unsigned char        last_lsr;      /* Line Status Register */
126         unsigned char        last_msr;      /* Modem Status Register */
127         unsigned int         rx_flags;      /* Throttling flags */
128         struct async_icount  icount;
129         wait_queue_head_t    msr_wait;  /* for handling sleeping while waiting
130                                                 for msr change to happen */
131 };
132
133 #define THROTTLED               0x01
134
135 /*
136  * Handle vendor specific USB requests
137  */
138
139 #define WDR_TIMEOUT 5000 /* default urb timeout */
140
141 /*
142  * Later day 2.6.0-test kernels have new baud rates like B230400 which
143  * we do not know how to support. We ignore them for the moment.
144  */
145 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
146                                         speed_t value, speed_t *result)
147 {
148         *result = value;
149
150         if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
151                 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
152                 switch (value) {
153                 case 300:
154                         return 0x01;
155                 case 600:
156                         return 0x02; /* this one not tested */
157                 case 1200:
158                         return 0x03;
159                 case 2400:
160                         return 0x04;
161                 case 4800:
162                         return 0x06;
163                 case 9600:
164                         return 0x08;
165                 case 19200:
166                         return 0x09;
167                 case 38400:
168                         return 0x0a;
169                 case 57600:
170                         return 0x0b;
171                 case 115200:
172                         return 0x0c;
173                 default:
174                         *result = 9600;
175                         return 0x08;
176                 }
177         } else {
178                 /* FIXME: Can we use any divider - should we do
179                    divider = 115200/value;
180                    real baud = 115200/divider */
181                 switch (value) {
182                 case 300: break;
183                 case 600: break;
184                 case 1200: break;
185                 case 2400: break;
186                 case 4800: break;
187                 case 9600: break;
188                 case 19200: break;
189                 case 38400: break;
190                 case 57600: break;
191                 case 115200: break;
192                 default:
193                         value = 9600;
194                         *result = 9600;
195                 }
196                 return 115200/value;
197         }
198 }
199
200 static int mct_u232_set_baud_rate(struct tty_struct *tty,
201         struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
202 {
203         unsigned int divisor;
204         int rc;
205         unsigned char *buf;
206         unsigned char cts_enable_byte = 0;
207         speed_t speed;
208
209         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
210         if (buf == NULL)
211                 return -ENOMEM;
212
213         divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
214         put_unaligned_le32(cpu_to_le32(divisor), buf);
215         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
216                                 MCT_U232_SET_BAUD_RATE_REQUEST,
217                                 MCT_U232_SET_REQUEST_TYPE,
218                                 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
219                                 WDR_TIMEOUT);
220         if (rc < 0)     /*FIXME: What value speed results */
221                 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
222                         value, rc);
223         else
224                 tty_encode_baud_rate(tty, speed, speed);
225         dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
226
227         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
228            always sends two extra USB 'device request' messages after the
229            'baud rate change' message.  The actual functionality of the
230            request codes in these messages is not fully understood but these
231            particular codes are never seen in any operation besides a baud
232            rate change.  Both of these messages send a single byte of data.
233            In the first message, the value of this byte is always zero.
234
235            The second message has been determined experimentally to control
236            whether data will be transmitted to a device which is not asserting
237            the 'CTS' signal.  If the second message's data byte is zero, data
238            will be transmitted even if 'CTS' is not asserted (i.e. no hardware
239            flow control).  if the second message's data byte is nonzero (a
240            value of 1 is used by this driver), data will not be transmitted to
241            a device which is not asserting 'CTS'.
242         */
243
244         buf[0] = 0;
245         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
246                                 MCT_U232_SET_UNKNOWN1_REQUEST,
247                                 MCT_U232_SET_REQUEST_TYPE,
248                                 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
249                                 WDR_TIMEOUT);
250         if (rc < 0)
251                 dev_err(&port->dev, "Sending USB device request code %d "
252                         "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
253                         rc);
254
255         if (port && C_CRTSCTS(tty))
256            cts_enable_byte = 1;
257
258         dbg("set_baud_rate: send second control message, data = %02X",
259                                                         cts_enable_byte);
260         buf[0] = cts_enable_byte;
261         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
262                         MCT_U232_SET_CTS_REQUEST,
263                         MCT_U232_SET_REQUEST_TYPE,
264                         0, 0, buf, MCT_U232_SET_CTS_SIZE,
265                         WDR_TIMEOUT);
266         if (rc < 0)
267                 dev_err(&port->dev, "Sending USB device request code %d "
268                         "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
269
270         kfree(buf);
271         return rc;
272 } /* mct_u232_set_baud_rate */
273
274 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
275 {
276         int rc;
277         unsigned char *buf;
278
279         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
280         if (buf == NULL)
281                 return -ENOMEM;
282
283         buf[0] = lcr;
284         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
285                         MCT_U232_SET_LINE_CTRL_REQUEST,
286                         MCT_U232_SET_REQUEST_TYPE,
287                         0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
288                         WDR_TIMEOUT);
289         if (rc < 0)
290                 dev_err(&serial->dev->dev,
291                         "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
292         dbg("set_line_ctrl: 0x%x", lcr);
293         kfree(buf);
294         return rc;
295 } /* mct_u232_set_line_ctrl */
296
297 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
298                                    unsigned int control_state)
299 {
300         int rc;
301         unsigned char mcr;
302         unsigned char *buf;
303
304         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
305         if (buf == NULL)
306                 return -ENOMEM;
307
308         mcr = MCT_U232_MCR_NONE;
309         if (control_state & TIOCM_DTR)
310                 mcr |= MCT_U232_MCR_DTR;
311         if (control_state & TIOCM_RTS)
312                 mcr |= MCT_U232_MCR_RTS;
313
314         buf[0] = mcr;
315         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
316                         MCT_U232_SET_MODEM_CTRL_REQUEST,
317                         MCT_U232_SET_REQUEST_TYPE,
318                         0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
319                         WDR_TIMEOUT);
320         kfree(buf);
321
322         dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
323
324         if (rc < 0) {
325                 dev_err(&serial->dev->dev,
326                         "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
327                 return rc;
328         }
329         return 0;
330 } /* mct_u232_set_modem_ctrl */
331
332 static int mct_u232_get_modem_stat(struct usb_serial *serial,
333                                                 unsigned char *msr)
334 {
335         int rc;
336         unsigned char *buf;
337
338         buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
339         if (buf == NULL) {
340                 *msr = 0;
341                 return -ENOMEM;
342         }
343         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
344                         MCT_U232_GET_MODEM_STAT_REQUEST,
345                         MCT_U232_GET_REQUEST_TYPE,
346                         0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
347                         WDR_TIMEOUT);
348         if (rc < 0) {
349                 dev_err(&serial->dev->dev,
350                         "Get MODEM STATus failed (error = %d)\n", rc);
351                 *msr = 0;
352         } else {
353                 *msr = buf[0];
354         }
355         dbg("get_modem_stat: 0x%x", *msr);
356         kfree(buf);
357         return rc;
358 } /* mct_u232_get_modem_stat */
359
360 static void mct_u232_msr_to_icount(struct async_icount *icount,
361                                                 unsigned char msr)
362 {
363         /* Translate Control Line states */
364         if (msr & MCT_U232_MSR_DDSR)
365                 icount->dsr++;
366         if (msr & MCT_U232_MSR_DCTS)
367                 icount->cts++;
368         if (msr & MCT_U232_MSR_DRI)
369                 icount->rng++;
370         if (msr & MCT_U232_MSR_DCD)
371                 icount->dcd++;
372 } /* mct_u232_msr_to_icount */
373
374 static void mct_u232_msr_to_state(unsigned int *control_state,
375                                                 unsigned char msr)
376 {
377         /* Translate Control Line states */
378         if (msr & MCT_U232_MSR_DSR)
379                 *control_state |=  TIOCM_DSR;
380         else
381                 *control_state &= ~TIOCM_DSR;
382         if (msr & MCT_U232_MSR_CTS)
383                 *control_state |=  TIOCM_CTS;
384         else
385                 *control_state &= ~TIOCM_CTS;
386         if (msr & MCT_U232_MSR_RI)
387                 *control_state |=  TIOCM_RI;
388         else
389                 *control_state &= ~TIOCM_RI;
390         if (msr & MCT_U232_MSR_CD)
391                 *control_state |=  TIOCM_CD;
392         else
393                 *control_state &= ~TIOCM_CD;
394         dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
395 } /* mct_u232_msr_to_state */
396
397 /*
398  * Driver's tty interface functions
399  */
400
401 static int mct_u232_startup(struct usb_serial *serial)
402 {
403         struct mct_u232_private *priv;
404         struct usb_serial_port *port, *rport;
405
406         priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
407         if (!priv)
408                 return -ENOMEM;
409         spin_lock_init(&priv->lock);
410         init_waitqueue_head(&priv->msr_wait);
411         usb_set_serial_port_data(serial->port[0], priv);
412
413         init_waitqueue_head(&serial->port[0]->write_wait);
414
415         /* Puh, that's dirty */
416         port = serial->port[0];
417         rport = serial->port[1];
418         /* No unlinking, it wasn't submitted yet. */
419         usb_free_urb(port->read_urb);
420         port->read_urb = rport->interrupt_in_urb;
421         rport->interrupt_in_urb = NULL;
422         port->read_urb->context = port;
423
424         return 0;
425 } /* mct_u232_startup */
426
427
428 static void mct_u232_release(struct usb_serial *serial)
429 {
430         struct mct_u232_private *priv;
431         int i;
432
433         dbg("%s", __func__);
434
435         for (i = 0; i < serial->num_ports; ++i) {
436                 /* My special items, the standard routines free my urbs */
437                 priv = usb_get_serial_port_data(serial->port[i]);
438                 kfree(priv);
439         }
440 } /* mct_u232_release */
441
442 static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
443 {
444         struct usb_serial *serial = port->serial;
445         struct mct_u232_private *priv = usb_get_serial_port_data(port);
446         int retval = 0;
447         unsigned int control_state;
448         unsigned long flags;
449         unsigned char last_lcr;
450         unsigned char last_msr;
451
452         dbg("%s port %d", __func__, port->number);
453
454         /* Compensate for a hardware bug: although the Sitecom U232-P25
455          * device reports a maximum output packet size of 32 bytes,
456          * it seems to be able to accept only 16 bytes (and that's what
457          * SniffUSB says too...)
458          */
459         if (le16_to_cpu(serial->dev->descriptor.idProduct)
460                                                 == MCT_U232_SITECOM_PID)
461                 port->bulk_out_size = 16;
462
463         /* Do a defined restart: the normal serial device seems to
464          * always turn on DTR and RTS here, so do the same. I'm not
465          * sure if this is really necessary. But it should not harm
466          * either.
467          */
468         spin_lock_irqsave(&priv->lock, flags);
469         if (tty && (tty->termios->c_cflag & CBAUD))
470                 priv->control_state = TIOCM_DTR | TIOCM_RTS;
471         else
472                 priv->control_state = 0;
473
474         priv->last_lcr = (MCT_U232_DATA_BITS_8 |
475                           MCT_U232_PARITY_NONE |
476                           MCT_U232_STOP_BITS_1);
477         control_state = priv->control_state;
478         last_lcr = priv->last_lcr;
479         spin_unlock_irqrestore(&priv->lock, flags);
480         mct_u232_set_modem_ctrl(serial, control_state);
481         mct_u232_set_line_ctrl(serial, last_lcr);
482
483         /* Read modem status and update control state */
484         mct_u232_get_modem_stat(serial, &last_msr);
485         spin_lock_irqsave(&priv->lock, flags);
486         priv->last_msr = last_msr;
487         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
488         spin_unlock_irqrestore(&priv->lock, flags);
489
490         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
491         if (retval) {
492                 dev_err(&port->dev,
493                         "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
494                         port->read_urb->pipe, retval);
495                 goto error;
496         }
497
498         retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
499         if (retval) {
500                 usb_kill_urb(port->read_urb);
501                 dev_err(&port->dev,
502                         "usb_submit_urb(read int) failed pipe 0x%x err %d",
503                         port->interrupt_in_urb->pipe, retval);
504                 goto error;
505         }
506         return 0;
507
508 error:
509         return retval;
510 } /* mct_u232_open */
511
512 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
513 {
514         unsigned int control_state;
515         struct mct_u232_private *priv = usb_get_serial_port_data(port);
516
517         mutex_lock(&port->serial->disc_mutex);
518         if (!port->serial->disconnected) {
519                 /* drop DTR and RTS */
520                 spin_lock_irq(&priv->lock);
521                 if (on)
522                         priv->control_state |= TIOCM_DTR | TIOCM_RTS;
523                 else
524                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
525                 control_state = priv->control_state;
526                 spin_unlock_irq(&priv->lock);
527                 mct_u232_set_modem_ctrl(port->serial, control_state);
528         }
529         mutex_unlock(&port->serial->disc_mutex);
530 }
531
532 static void mct_u232_close(struct usb_serial_port *port)
533 {
534         dbg("%s port %d", __func__, port->number);
535
536         if (port->serial->dev) {
537                 /* shutdown our urbs */
538                 usb_kill_urb(port->write_urb);
539                 usb_kill_urb(port->read_urb);
540                 usb_kill_urb(port->interrupt_in_urb);
541         }
542 } /* mct_u232_close */
543
544
545 static void mct_u232_read_int_callback(struct urb *urb)
546 {
547         struct usb_serial_port *port = urb->context;
548         struct mct_u232_private *priv = usb_get_serial_port_data(port);
549         struct usb_serial *serial = port->serial;
550         struct tty_struct *tty;
551         unsigned char *data = urb->transfer_buffer;
552         int retval;
553         int status = urb->status;
554         unsigned long flags;
555
556         switch (status) {
557         case 0:
558                 /* success */
559                 break;
560         case -ECONNRESET:
561         case -ENOENT:
562         case -ESHUTDOWN:
563                 /* this urb is terminated, clean up */
564                 dbg("%s - urb shutting down with status: %d",
565                     __func__, status);
566                 return;
567         default:
568                 dbg("%s - nonzero urb status received: %d",
569                     __func__, status);
570                 goto exit;
571         }
572
573         if (!serial) {
574                 dbg("%s - bad serial pointer, exiting", __func__);
575                 return;
576         }
577
578         dbg("%s - port %d", __func__, port->number);
579         usb_serial_debug_data(debug, &port->dev, __func__,
580                                         urb->actual_length, data);
581
582         /*
583          * Work-a-round: handle the 'usual' bulk-in pipe here
584          */
585         if (urb->transfer_buffer_length > 2) {
586                 if (urb->actual_length) {
587                         tty = tty_port_tty_get(&port->port);
588                         if (tty) {
589                                 tty_insert_flip_string(tty, data,
590                                                 urb->actual_length);
591                                 tty_flip_buffer_push(tty);
592                         }
593                         tty_kref_put(tty);
594                 }
595                 goto exit;
596         }
597
598         /*
599          * The interrupt-in pipe signals exceptional conditions (modem line
600          * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
601          */
602         spin_lock_irqsave(&priv->lock, flags);
603         priv->last_msr = data[MCT_U232_MSR_INDEX];
604
605         /* Record Control Line states */
606         mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
607
608         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
609
610 #if 0
611         /* Not yet handled. See belkin_sa.c for further information */
612         /* Now to report any errors */
613         priv->last_lsr = data[MCT_U232_LSR_INDEX];
614         /*
615          * fill in the flip buffer here, but I do not know the relation
616          * to the current/next receive buffer or characters.  I need
617          * to look in to this before committing any code.
618          */
619         if (priv->last_lsr & MCT_U232_LSR_ERR) {
620                 tty = tty_port_tty_get(&port->port);
621                 /* Overrun Error */
622                 if (priv->last_lsr & MCT_U232_LSR_OE) {
623                 }
624                 /* Parity Error */
625                 if (priv->last_lsr & MCT_U232_LSR_PE) {
626                 }
627                 /* Framing Error */
628                 if (priv->last_lsr & MCT_U232_LSR_FE) {
629                 }
630                 /* Break Indicator */
631                 if (priv->last_lsr & MCT_U232_LSR_BI) {
632                 }
633                 tty_kref_put(tty);
634         }
635 #endif
636         wake_up_interruptible(&priv->msr_wait);
637         spin_unlock_irqrestore(&priv->lock, flags);
638 exit:
639         retval = usb_submit_urb(urb, GFP_ATOMIC);
640         if (retval)
641                 dev_err(&port->dev,
642                         "%s - usb_submit_urb failed with result %d\n",
643                         __func__, retval);
644 } /* mct_u232_read_int_callback */
645
646 static void mct_u232_set_termios(struct tty_struct *tty,
647                                  struct usb_serial_port *port,
648                                  struct ktermios *old_termios)
649 {
650         struct usb_serial *serial = port->serial;
651         struct mct_u232_private *priv = usb_get_serial_port_data(port);
652         struct ktermios *termios = tty->termios;
653         unsigned int cflag = termios->c_cflag;
654         unsigned int old_cflag = old_termios->c_cflag;
655         unsigned long flags;
656         unsigned int control_state;
657         unsigned char last_lcr;
658
659         /* get a local copy of the current port settings */
660         spin_lock_irqsave(&priv->lock, flags);
661         control_state = priv->control_state;
662         spin_unlock_irqrestore(&priv->lock, flags);
663         last_lcr = 0;
664
665         /*
666          * Update baud rate.
667          * Do not attempt to cache old rates and skip settings,
668          * disconnects screw such tricks up completely.
669          * Premature optimization is the root of all evil.
670          */
671
672         /* reassert DTR and RTS on transition from B0 */
673         if ((old_cflag & CBAUD) == B0) {
674                 dbg("%s: baud was B0", __func__);
675                 control_state |= TIOCM_DTR | TIOCM_RTS;
676                 mct_u232_set_modem_ctrl(serial, control_state);
677         }
678
679         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
680
681         if ((cflag & CBAUD) == B0) {
682                 dbg("%s: baud is B0", __func__);
683                 /* Drop RTS and DTR */
684                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
685                 mct_u232_set_modem_ctrl(serial, control_state);
686         }
687
688         /*
689          * Update line control register (LCR)
690          */
691
692         /* set the parity */
693         if (cflag & PARENB)
694                 last_lcr |= (cflag & PARODD) ?
695                         MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
696         else
697                 last_lcr |= MCT_U232_PARITY_NONE;
698
699         /* set the number of data bits */
700         switch (cflag & CSIZE) {
701         case CS5:
702                 last_lcr |= MCT_U232_DATA_BITS_5; break;
703         case CS6:
704                 last_lcr |= MCT_U232_DATA_BITS_6; break;
705         case CS7:
706                 last_lcr |= MCT_U232_DATA_BITS_7; break;
707         case CS8:
708                 last_lcr |= MCT_U232_DATA_BITS_8; break;
709         default:
710                 dev_err(&port->dev,
711                         "CSIZE was not CS5-CS8, using default of 8\n");
712                 last_lcr |= MCT_U232_DATA_BITS_8;
713                 break;
714         }
715
716         termios->c_cflag &= ~CMSPAR;
717
718         /* set the number of stop bits */
719         last_lcr |= (cflag & CSTOPB) ?
720                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
721
722         mct_u232_set_line_ctrl(serial, last_lcr);
723
724         /* save off the modified port settings */
725         spin_lock_irqsave(&priv->lock, flags);
726         priv->control_state = control_state;
727         priv->last_lcr = last_lcr;
728         spin_unlock_irqrestore(&priv->lock, flags);
729 } /* mct_u232_set_termios */
730
731 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
732 {
733         struct usb_serial_port *port = tty->driver_data;
734         struct usb_serial *serial = port->serial;
735         struct mct_u232_private *priv = usb_get_serial_port_data(port);
736         unsigned char lcr;
737         unsigned long flags;
738
739         dbg("%sstate=%d", __func__, break_state);
740
741         spin_lock_irqsave(&priv->lock, flags);
742         lcr = priv->last_lcr;
743
744         if (break_state)
745                 lcr |= MCT_U232_SET_BREAK;
746         spin_unlock_irqrestore(&priv->lock, flags);
747
748         mct_u232_set_line_ctrl(serial, lcr);
749 } /* mct_u232_break_ctl */
750
751
752 static int mct_u232_tiocmget(struct tty_struct *tty)
753 {
754         struct usb_serial_port *port = tty->driver_data;
755         struct mct_u232_private *priv = usb_get_serial_port_data(port);
756         unsigned int control_state;
757         unsigned long flags;
758
759         dbg("%s", __func__);
760
761         spin_lock_irqsave(&priv->lock, flags);
762         control_state = priv->control_state;
763         spin_unlock_irqrestore(&priv->lock, flags);
764
765         return control_state;
766 }
767
768 static int mct_u232_tiocmset(struct tty_struct *tty,
769                               unsigned int set, unsigned int clear)
770 {
771         struct usb_serial_port *port = tty->driver_data;
772         struct usb_serial *serial = port->serial;
773         struct mct_u232_private *priv = usb_get_serial_port_data(port);
774         unsigned int control_state;
775         unsigned long flags;
776
777         dbg("%s", __func__);
778
779         spin_lock_irqsave(&priv->lock, flags);
780         control_state = priv->control_state;
781
782         if (set & TIOCM_RTS)
783                 control_state |= TIOCM_RTS;
784         if (set & TIOCM_DTR)
785                 control_state |= TIOCM_DTR;
786         if (clear & TIOCM_RTS)
787                 control_state &= ~TIOCM_RTS;
788         if (clear & TIOCM_DTR)
789                 control_state &= ~TIOCM_DTR;
790
791         priv->control_state = control_state;
792         spin_unlock_irqrestore(&priv->lock, flags);
793         return mct_u232_set_modem_ctrl(serial, control_state);
794 }
795
796 static void mct_u232_throttle(struct tty_struct *tty)
797 {
798         struct usb_serial_port *port = tty->driver_data;
799         struct mct_u232_private *priv = usb_get_serial_port_data(port);
800         unsigned int control_state;
801
802         dbg("%s - port %d", __func__, port->number);
803
804         spin_lock_irq(&priv->lock);
805         priv->rx_flags |= THROTTLED;
806         if (C_CRTSCTS(tty)) {
807                 priv->control_state &= ~TIOCM_RTS;
808                 control_state = priv->control_state;
809                 spin_unlock_irq(&priv->lock);
810                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
811         } else {
812                 spin_unlock_irq(&priv->lock);
813         }
814 }
815
816 static void mct_u232_unthrottle(struct tty_struct *tty)
817 {
818         struct usb_serial_port *port = tty->driver_data;
819         struct mct_u232_private *priv = usb_get_serial_port_data(port);
820         unsigned int control_state;
821
822         dbg("%s - port %d", __func__, port->number);
823
824         spin_lock_irq(&priv->lock);
825         if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
826                 priv->rx_flags &= ~THROTTLED;
827                 priv->control_state |= TIOCM_RTS;
828                 control_state = priv->control_state;
829                 spin_unlock_irq(&priv->lock);
830                 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
831         } else {
832                 spin_unlock_irq(&priv->lock);
833         }
834 }
835
836 static int  mct_u232_ioctl(struct tty_struct *tty,
837                         unsigned int cmd, unsigned long arg)
838 {
839         DEFINE_WAIT(wait);
840         struct usb_serial_port *port = tty->driver_data;
841         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
842         struct async_icount cnow, cprev;
843         unsigned long flags;
844
845         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
846
847         switch (cmd) {
848
849         case TIOCMIWAIT:
850
851                 dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
852
853                 spin_lock_irqsave(&mct_u232_port->lock, flags);
854                 cprev = mct_u232_port->icount;
855                 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
856                 for ( ; ; ) {
857                         prepare_to_wait(&mct_u232_port->msr_wait,
858                                         &wait, TASK_INTERRUPTIBLE);
859                         schedule();
860                         finish_wait(&mct_u232_port->msr_wait, &wait);
861                         /* see if a signal did it */
862                         if (signal_pending(current))
863                                 return -ERESTARTSYS;
864                         spin_lock_irqsave(&mct_u232_port->lock, flags);
865                         cnow = mct_u232_port->icount;
866                         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
867                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
868                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
869                                 return -EIO; /* no change => error */
870                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
871                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
872                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
873                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
874                                 return 0;
875                         }
876                         cprev = cnow;
877                 }
878
879         }
880         return -ENOIOCTLCMD;
881 }
882
883 static int  mct_u232_get_icount(struct tty_struct *tty,
884                         struct serial_icounter_struct *icount)
885 {
886         struct usb_serial_port *port = tty->driver_data;
887         struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
888         struct async_icount *ic = &mct_u232_port->icount;
889         unsigned long flags;
890
891         spin_lock_irqsave(&mct_u232_port->lock, flags);
892
893         icount->cts = ic->cts;
894         icount->dsr = ic->dsr;
895         icount->rng = ic->rng;
896         icount->dcd = ic->dcd;
897         icount->rx = ic->rx;
898         icount->tx = ic->tx;
899         icount->frame = ic->frame;
900         icount->overrun = ic->overrun;
901         icount->parity = ic->parity;
902         icount->brk = ic->brk;
903         icount->buf_overrun = ic->buf_overrun;
904
905         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
906
907         dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
908                 __func__,  port->number, icount->rx, icount->tx);
909         return 0;
910 }
911
912 module_usb_serial_driver(mct_u232_driver, serial_drivers);
913
914 MODULE_AUTHOR(DRIVER_AUTHOR);
915 MODULE_DESCRIPTION(DRIVER_DESC);
916 MODULE_LICENSE("GPL");
917
918 module_param(debug, bool, S_IRUGO | S_IWUSR);
919 MODULE_PARM_DESC(debug, "Debug enabled or not");