2 * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
4 * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
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.
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.
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.
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.
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).
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.
32 * 10-Nov-2001 Wolfgang Grandegger
33 * - Fixed an endianess problem with the baudrate selection for PowerPC.
35 * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
36 * Added support for the Belkin F5U109 DB9 adaptor
38 * 30-May-2001 Greg Kroah-Hartman
39 * switched from using spinlock to a semaphore, which fixes lots of problems.
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).
46 * 02-May-2001 Stelian Pop
47 * - Fixed the baud calculation for Sitecom U232-P25 model
50 * - Identify version on module load.
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)
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.
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).
67 #include <linux/config.h>
68 #include <linux/kernel.h>
69 #include <linux/errno.h>
70 #include <linux/init.h>
71 #include <linux/slab.h>
72 #include <linux/tty.h>
73 #include <linux/tty_driver.h>
74 #include <linux/tty_flip.h>
75 #include <linux/module.h>
76 #include <linux/spinlock.h>
77 #include <asm/uaccess.h>
78 #include <linux/usb.h>
79 #include "usb-serial.h"
85 #define DRIVER_VERSION "z2.0" /* Linux in-kernel version */
86 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
87 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
94 static int mct_u232_startup (struct usb_serial *serial);
95 static void mct_u232_shutdown (struct usb_serial *serial);
96 static int mct_u232_open (struct usb_serial_port *port,
98 static void mct_u232_close (struct usb_serial_port *port,
100 static void mct_u232_read_int_callback (struct urb *urb, struct pt_regs *regs);
101 static void mct_u232_set_termios (struct usb_serial_port *port,
102 struct termios * old);
103 static int mct_u232_ioctl (struct usb_serial_port *port,
107 static void mct_u232_break_ctl (struct usb_serial_port *port,
109 static int mct_u232_tiocmget (struct usb_serial_port *port,
111 static int mct_u232_tiocmset (struct usb_serial_port *port,
112 struct file *file, unsigned int set,
115 * All of the device info needed for the MCT USB-RS232 converter.
117 static struct usb_device_id id_table_combined [] = {
118 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
119 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
120 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
121 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
122 { } /* Terminating entry */
125 MODULE_DEVICE_TABLE (usb, id_table_combined);
127 static struct usb_driver mct_u232_driver = {
128 .owner = THIS_MODULE,
130 .probe = usb_serial_probe,
131 .disconnect = usb_serial_disconnect,
132 .id_table = id_table_combined,
136 static struct usb_serial_driver mct_u232_device = {
138 .owner = THIS_MODULE,
141 .description = "MCT U232",
142 .id_table = id_table_combined,
143 .num_interrupt_in = 2,
147 .open = mct_u232_open,
148 .close = mct_u232_close,
149 .read_int_callback = mct_u232_read_int_callback,
150 .ioctl = mct_u232_ioctl,
151 .set_termios = mct_u232_set_termios,
152 .break_ctl = mct_u232_break_ctl,
153 .tiocmget = mct_u232_tiocmget,
154 .tiocmset = mct_u232_tiocmset,
155 .attach = mct_u232_startup,
156 .shutdown = mct_u232_shutdown,
160 struct mct_u232_private {
162 unsigned int control_state; /* Modem Line Setting (TIOCM) */
163 unsigned char last_lcr; /* Line Control Register */
164 unsigned char last_lsr; /* Line Status Register */
165 unsigned char last_msr; /* Modem Status Register */
169 * Handle vendor specific USB requests
172 #define WDR_TIMEOUT 5000 /* default urb timeout */
175 * Later day 2.6.0-test kernels have new baud rates like B230400 which
176 * we do not know how to support. We ignore them for the moment.
177 * XXX Rate-limit the error message, it's user triggerable.
179 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, int value)
181 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
182 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
184 case B300: return 0x01;
185 case B600: return 0x02; /* this one not tested */
186 case B1200: return 0x03;
187 case B2400: return 0x04;
188 case B4800: return 0x06;
189 case B9600: return 0x08;
190 case B19200: return 0x09;
191 case B38400: return 0x0a;
192 case B57600: return 0x0b;
193 case B115200: return 0x0c;
195 err("MCT USB-RS232: unsupported baudrate request 0x%x,"
196 " using default of B9600", value);
201 case B300: value = 300; break;
202 case B600: value = 600; break;
203 case B1200: value = 1200; break;
204 case B2400: value = 2400; break;
205 case B4800: value = 4800; break;
206 case B9600: value = 9600; break;
207 case B19200: value = 19200; break;
208 case B38400: value = 38400; break;
209 case B57600: value = 57600; break;
210 case B115200: value = 115200; break;
212 err("MCT USB-RS232: unsupported baudrate request 0x%x,"
213 " using default of B9600", value);
220 static int mct_u232_set_baud_rate(struct usb_serial *serial, int value)
224 unsigned char zero_byte = 0;
226 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value));
228 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
229 MCT_U232_SET_BAUD_RATE_REQUEST,
230 MCT_U232_SET_REQUEST_TYPE,
231 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
234 err("Set BAUD RATE %d failed (error = %d)", value, rc);
235 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
237 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
238 always sends two extra USB 'device request' messages after the
239 'baud rate change' message. The actual functionality of the
240 request codes in these messages is not fully understood but these
241 particular codes are never seen in any operation besides a baud
242 rate change. Both of these messages send a single byte of data
243 whose value is always zero. The second of these two extra messages
244 is required in order for data to be properly written to an RS-232
245 device which does not assert the 'CTS' signal. */
247 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
248 MCT_U232_SET_UNKNOWN1_REQUEST,
249 MCT_U232_SET_REQUEST_TYPE,
250 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
253 err("Sending USB device request code %d failed (error = %d)",
254 MCT_U232_SET_UNKNOWN1_REQUEST, rc);
256 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
257 MCT_U232_SET_UNKNOWN2_REQUEST,
258 MCT_U232_SET_REQUEST_TYPE,
259 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN2_SIZE,
262 err("Sending USB device request code %d failed (error = %d)",
263 MCT_U232_SET_UNKNOWN2_REQUEST, rc);
266 } /* mct_u232_set_baud_rate */
268 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
271 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
272 MCT_U232_SET_LINE_CTRL_REQUEST,
273 MCT_U232_SET_REQUEST_TYPE,
274 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
277 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
278 dbg("set_line_ctrl: 0x%x", lcr);
280 } /* mct_u232_set_line_ctrl */
282 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
283 unsigned int control_state)
286 unsigned char mcr = MCT_U232_MCR_NONE;
288 if (control_state & TIOCM_DTR)
289 mcr |= MCT_U232_MCR_DTR;
290 if (control_state & TIOCM_RTS)
291 mcr |= MCT_U232_MCR_RTS;
293 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
294 MCT_U232_SET_MODEM_CTRL_REQUEST,
295 MCT_U232_SET_REQUEST_TYPE,
296 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
299 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
300 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
303 } /* mct_u232_set_modem_ctrl */
305 static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
308 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
309 MCT_U232_GET_MODEM_STAT_REQUEST,
310 MCT_U232_GET_REQUEST_TYPE,
311 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
314 err("Get MODEM STATus failed (error = %d)", rc);
317 dbg("get_modem_stat: 0x%x", *msr);
319 } /* mct_u232_get_modem_stat */
321 static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr)
323 /* Translate Control Line states */
324 if (msr & MCT_U232_MSR_DSR)
325 *control_state |= TIOCM_DSR;
327 *control_state &= ~TIOCM_DSR;
328 if (msr & MCT_U232_MSR_CTS)
329 *control_state |= TIOCM_CTS;
331 *control_state &= ~TIOCM_CTS;
332 if (msr & MCT_U232_MSR_RI)
333 *control_state |= TIOCM_RI;
335 *control_state &= ~TIOCM_RI;
336 if (msr & MCT_U232_MSR_CD)
337 *control_state |= TIOCM_CD;
339 *control_state &= ~TIOCM_CD;
340 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
341 } /* mct_u232_msr_to_state */
344 * Driver's tty interface functions
347 static int mct_u232_startup (struct usb_serial *serial)
349 struct mct_u232_private *priv;
350 struct usb_serial_port *port, *rport;
352 priv = kmalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
355 memset(priv, 0, sizeof(struct mct_u232_private));
356 spin_lock_init(&priv->lock);
357 usb_set_serial_port_data(serial->port[0], priv);
359 init_waitqueue_head(&serial->port[0]->write_wait);
361 /* Puh, that's dirty */
362 port = serial->port[0];
363 rport = serial->port[1];
364 if (port->read_urb) {
365 /* No unlinking, it wasn't submitted yet. */
366 usb_free_urb(port->read_urb);
368 port->read_urb = rport->interrupt_in_urb;
369 rport->interrupt_in_urb = NULL;
370 port->read_urb->context = port;
373 } /* mct_u232_startup */
376 static void mct_u232_shutdown (struct usb_serial *serial)
378 struct mct_u232_private *priv;
381 dbg("%s", __FUNCTION__);
383 for (i=0; i < serial->num_ports; ++i) {
384 /* My special items, the standard routines free my urbs */
385 priv = usb_get_serial_port_data(serial->port[i]);
387 usb_set_serial_port_data(serial->port[i], NULL);
391 } /* mct_u232_shutdown */
393 static int mct_u232_open (struct usb_serial_port *port, struct file *filp)
395 struct usb_serial *serial = port->serial;
396 struct mct_u232_private *priv = usb_get_serial_port_data(port);
398 unsigned int control_state;
400 unsigned char last_lcr;
401 unsigned char last_msr;
403 dbg("%s port %d", __FUNCTION__, port->number);
405 /* Compensate for a hardware bug: although the Sitecom U232-P25
406 * device reports a maximum output packet size of 32 bytes,
407 * it seems to be able to accept only 16 bytes (and that's what
408 * SniffUSB says too...)
410 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
411 port->bulk_out_size = 16;
413 /* Do a defined restart: the normal serial device seems to
414 * always turn on DTR and RTS here, so do the same. I'm not
415 * sure if this is really necessary. But it should not harm
418 spin_lock_irqsave(&priv->lock, flags);
419 if (port->tty->termios->c_cflag & CBAUD)
420 priv->control_state = TIOCM_DTR | TIOCM_RTS;
422 priv->control_state = 0;
424 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
425 MCT_U232_PARITY_NONE |
426 MCT_U232_STOP_BITS_1);
427 control_state = priv->control_state;
428 last_lcr = priv->last_lcr;
429 spin_unlock_irqrestore(&priv->lock, flags);
430 mct_u232_set_modem_ctrl(serial, control_state);
431 mct_u232_set_line_ctrl(serial, last_lcr);
433 /* Read modem status and update control state */
434 mct_u232_get_modem_stat(serial, &last_msr);
435 spin_lock_irqsave(&priv->lock, flags);
436 priv->last_msr = last_msr;
437 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
438 spin_unlock_irqrestore(&priv->lock, flags);
440 port->read_urb->dev = port->serial->dev;
441 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
443 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
444 port->read_urb->pipe, retval);
448 port->interrupt_in_urb->dev = port->serial->dev;
449 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
451 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
452 port->interrupt_in_urb->pipe, retval);
456 } /* mct_u232_open */
459 static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
461 dbg("%s port %d", __FUNCTION__, port->number);
463 if (port->serial->dev) {
464 /* shutdown our urbs */
465 usb_kill_urb(port->write_urb);
466 usb_kill_urb(port->read_urb);
467 usb_kill_urb(port->interrupt_in_urb);
469 } /* mct_u232_close */
472 static void mct_u232_read_int_callback (struct urb *urb, struct pt_regs *regs)
474 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
475 struct mct_u232_private *priv = usb_get_serial_port_data(port);
476 struct usb_serial *serial = port->serial;
477 struct tty_struct *tty;
478 unsigned char *data = urb->transfer_buffer;
482 switch (urb->status) {
489 /* this urb is terminated, clean up */
490 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
493 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
498 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
502 dbg("%s - port %d", __FUNCTION__, port->number);
503 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
506 * Work-a-round: handle the 'usual' bulk-in pipe here
508 if (urb->transfer_buffer_length > 2) {
511 if (urb->actual_length) {
512 for (i = 0; i < urb->actual_length ; ++i) {
513 tty_insert_flip_char(tty, data[i], 0);
515 tty_flip_buffer_push(tty);
521 * The interrupt-in pipe signals exceptional conditions (modem line
522 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
524 spin_lock_irqsave(&priv->lock, flags);
525 priv->last_msr = data[MCT_U232_MSR_INDEX];
527 /* Record Control Line states */
528 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
531 /* Not yet handled. See belin_sa.c for further information */
532 /* Now to report any errors */
533 priv->last_lsr = data[MCT_U232_LSR_INDEX];
535 * fill in the flip buffer here, but I do not know the relation
536 * to the current/next receive buffer or characters. I need
537 * to look in to this before committing any code.
539 if (priv->last_lsr & MCT_U232_LSR_ERR) {
542 if (priv->last_lsr & MCT_U232_LSR_OE) {
545 if (priv->last_lsr & MCT_U232_LSR_PE) {
548 if (priv->last_lsr & MCT_U232_LSR_FE) {
550 /* Break Indicator */
551 if (priv->last_lsr & MCT_U232_LSR_BI) {
555 spin_unlock_irqrestore(&priv->lock, flags);
557 status = usb_submit_urb (urb, GFP_ATOMIC);
559 err ("%s - usb_submit_urb failed with result %d",
560 __FUNCTION__, status);
561 } /* mct_u232_read_int_callback */
563 static void mct_u232_set_termios (struct usb_serial_port *port,
564 struct termios *old_termios)
566 struct usb_serial *serial = port->serial;
567 struct mct_u232_private *priv = usb_get_serial_port_data(port);
568 unsigned int iflag = port->tty->termios->c_iflag;
569 unsigned int cflag = port->tty->termios->c_cflag;
570 unsigned int old_cflag = old_termios->c_cflag;
572 unsigned int control_state, new_state;
573 unsigned char last_lcr;
575 /* get a local copy of the current port settings */
576 spin_lock_irqsave(&priv->lock, flags);
577 control_state = priv->control_state;
578 spin_unlock_irqrestore(&priv->lock, flags);
583 * Do not attempt to cache old rates and skip settings,
584 * disconnects screw such tricks up completely.
585 * Premature optimization is the root of all evil.
588 /* reassert DTR and (maybe) RTS on transition from B0 */
589 if ((old_cflag & CBAUD) == B0) {
590 dbg("%s: baud was B0", __FUNCTION__);
591 control_state |= TIOCM_DTR;
592 /* don't set RTS if using hardware flow control */
593 if (!(old_cflag & CRTSCTS)) {
594 control_state |= TIOCM_RTS;
596 mct_u232_set_modem_ctrl(serial, control_state);
599 mct_u232_set_baud_rate(serial, cflag & CBAUD);
601 if ((cflag & CBAUD) == B0 ) {
602 dbg("%s: baud is B0", __FUNCTION__);
603 /* Drop RTS and DTR */
604 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
605 mct_u232_set_modem_ctrl(serial, control_state);
609 * Update line control register (LCR)
614 last_lcr |= (cflag & PARODD) ?
615 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
617 last_lcr |= MCT_U232_PARITY_NONE;
619 /* set the number of data bits */
620 switch (cflag & CSIZE) {
622 last_lcr |= MCT_U232_DATA_BITS_5; break;
624 last_lcr |= MCT_U232_DATA_BITS_6; break;
626 last_lcr |= MCT_U232_DATA_BITS_7; break;
628 last_lcr |= MCT_U232_DATA_BITS_8; break;
630 err("CSIZE was not CS5-CS8, using default of 8");
631 last_lcr |= MCT_U232_DATA_BITS_8;
635 /* set the number of stop bits */
636 last_lcr |= (cflag & CSTOPB) ?
637 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
639 mct_u232_set_line_ctrl(serial, last_lcr);
642 * Set flow control: well, I do not really now how to handle DTR/RTS.
643 * Just do what we have seen with SniffUSB on Win98.
645 /* Drop DTR/RTS if no flow control otherwise assert */
646 new_state = control_state;
647 if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
648 new_state |= TIOCM_DTR | TIOCM_RTS;
650 new_state &= ~(TIOCM_DTR | TIOCM_RTS);
651 if (new_state != control_state) {
652 mct_u232_set_modem_ctrl(serial, new_state);
653 control_state = new_state;
656 /* save off the modified port settings */
657 spin_lock_irqsave(&priv->lock, flags);
658 priv->control_state = control_state;
659 priv->last_lcr = last_lcr;
660 spin_unlock_irqrestore(&priv->lock, flags);
661 } /* mct_u232_set_termios */
663 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
665 struct usb_serial *serial = port->serial;
666 struct mct_u232_private *priv = usb_get_serial_port_data(port);
670 dbg("%sstate=%d", __FUNCTION__, break_state);
672 spin_lock_irqsave(&priv->lock, flags);
673 lcr = priv->last_lcr;
674 spin_unlock_irqrestore(&priv->lock, flags);
677 lcr |= MCT_U232_SET_BREAK;
679 mct_u232_set_line_ctrl(serial, lcr);
680 } /* mct_u232_break_ctl */
683 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
685 struct mct_u232_private *priv = usb_get_serial_port_data(port);
686 unsigned int control_state;
689 dbg("%s", __FUNCTION__);
691 spin_lock_irqsave(&priv->lock, flags);
692 control_state = priv->control_state;
693 spin_unlock_irqrestore(&priv->lock, flags);
695 return control_state;
698 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
699 unsigned int set, unsigned int clear)
701 struct usb_serial *serial = port->serial;
702 struct mct_u232_private *priv = usb_get_serial_port_data(port);
703 unsigned int control_state;
706 dbg("%s", __FUNCTION__);
708 spin_lock_irqsave(&priv->lock, flags);
709 control_state = priv->control_state;
712 control_state |= TIOCM_RTS;
714 control_state |= TIOCM_DTR;
715 if (clear & TIOCM_RTS)
716 control_state &= ~TIOCM_RTS;
717 if (clear & TIOCM_DTR)
718 control_state &= ~TIOCM_DTR;
720 priv->control_state = control_state;
721 spin_unlock_irqrestore(&priv->lock, flags);
722 return mct_u232_set_modem_ctrl(serial, control_state);
725 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
726 unsigned int cmd, unsigned long arg)
728 dbg("%scmd=0x%x", __FUNCTION__, cmd);
730 /* Based on code from acm.c and others */
733 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
738 /* return count of modemline transitions */
743 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
744 return(-ENOIOCTLCMD);
748 } /* mct_u232_ioctl */
751 static int __init mct_u232_init (void)
754 retval = usb_serial_register(&mct_u232_device);
756 goto failed_usb_serial_register;
757 retval = usb_register(&mct_u232_driver);
759 goto failed_usb_register;
760 info(DRIVER_DESC " " DRIVER_VERSION);
763 usb_serial_deregister(&mct_u232_device);
764 failed_usb_serial_register:
769 static void __exit mct_u232_exit (void)
771 usb_deregister (&mct_u232_driver);
772 usb_serial_deregister (&mct_u232_device);
776 module_init (mct_u232_init);
777 module_exit(mct_u232_exit);
779 MODULE_AUTHOR( DRIVER_AUTHOR );
780 MODULE_DESCRIPTION( DRIVER_DESC );
781 MODULE_LICENSE("GPL");
783 module_param(debug, bool, S_IRUGO | S_IWUSR);
784 MODULE_PARM_DESC(debug, "Debug enabled or not");