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