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 #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>
41 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
42 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
47 static int mct_u232_startup(struct usb_serial *serial);
48 static int mct_u232_port_probe(struct usb_serial_port *port);
49 static int mct_u232_port_remove(struct usb_serial_port *remove);
50 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
51 static void mct_u232_close(struct usb_serial_port *port);
52 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
53 static void mct_u232_read_int_callback(struct urb *urb);
54 static void mct_u232_set_termios(struct tty_struct *tty,
55 struct usb_serial_port *port, struct ktermios *old);
56 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
57 static int mct_u232_tiocmget(struct tty_struct *tty);
58 static int mct_u232_tiocmset(struct tty_struct *tty,
59 unsigned int set, unsigned int clear);
60 static int mct_u232_ioctl(struct tty_struct *tty,
61 unsigned int cmd, unsigned long arg);
62 static int mct_u232_get_icount(struct tty_struct *tty,
63 struct serial_icounter_struct *icount);
64 static void mct_u232_throttle(struct tty_struct *tty);
65 static void mct_u232_unthrottle(struct tty_struct *tty);
69 * All of the device info needed for the MCT USB-RS232 converter.
71 static const struct usb_device_id id_table[] = {
72 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
73 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
74 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
75 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
76 { } /* Terminating entry */
78 MODULE_DEVICE_TABLE(usb, id_table);
80 static struct usb_serial_driver mct_u232_device = {
85 .description = "MCT U232",
88 .open = mct_u232_open,
89 .close = mct_u232_close,
90 .dtr_rts = mct_u232_dtr_rts,
91 .throttle = mct_u232_throttle,
92 .unthrottle = mct_u232_unthrottle,
93 .read_int_callback = mct_u232_read_int_callback,
94 .set_termios = mct_u232_set_termios,
95 .break_ctl = mct_u232_break_ctl,
96 .tiocmget = mct_u232_tiocmget,
97 .tiocmset = mct_u232_tiocmset,
98 .attach = mct_u232_startup,
99 .port_probe = mct_u232_port_probe,
100 .port_remove = mct_u232_port_remove,
101 .ioctl = mct_u232_ioctl,
102 .get_icount = mct_u232_get_icount,
105 static struct usb_serial_driver * const serial_drivers[] = {
106 &mct_u232_device, NULL
109 struct mct_u232_private {
111 unsigned int control_state; /* Modem Line Setting (TIOCM) */
112 unsigned char last_lcr; /* Line Control Register */
113 unsigned char last_lsr; /* Line Status Register */
114 unsigned char last_msr; /* Modem Status Register */
115 unsigned int rx_flags; /* Throttling flags */
116 struct async_icount icount;
117 wait_queue_head_t msr_wait; /* for handling sleeping while waiting
118 for msr change to happen */
121 #define THROTTLED 0x01
124 * Handle vendor specific USB requests
127 #define WDR_TIMEOUT 5000 /* default urb timeout */
130 * Later day 2.6.0-test kernels have new baud rates like B230400 which
131 * we do not know how to support. We ignore them for the moment.
133 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
134 speed_t value, speed_t *result)
138 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
139 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
144 return 0x02; /* this one not tested */
166 /* FIXME: Can we use any divider - should we do
167 divider = 115200/value;
168 real baud = 115200/divider */
188 static int mct_u232_set_baud_rate(struct tty_struct *tty,
189 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
191 unsigned int divisor;
194 unsigned char cts_enable_byte = 0;
197 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
201 divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
202 put_unaligned_le32(cpu_to_le32(divisor), buf);
203 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
204 MCT_U232_SET_BAUD_RATE_REQUEST,
205 MCT_U232_SET_REQUEST_TYPE,
206 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
208 if (rc < 0) /*FIXME: What value speed results */
209 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
212 tty_encode_baud_rate(tty, speed, speed);
213 dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor);
215 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
216 always sends two extra USB 'device request' messages after the
217 'baud rate change' message. The actual functionality of the
218 request codes in these messages is not fully understood but these
219 particular codes are never seen in any operation besides a baud
220 rate change. Both of these messages send a single byte of data.
221 In the first message, the value of this byte is always zero.
223 The second message has been determined experimentally to control
224 whether data will be transmitted to a device which is not asserting
225 the 'CTS' signal. If the second message's data byte is zero, data
226 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
227 flow control). if the second message's data byte is nonzero (a
228 value of 1 is used by this driver), data will not be transmitted to
229 a device which is not asserting 'CTS'.
233 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
234 MCT_U232_SET_UNKNOWN1_REQUEST,
235 MCT_U232_SET_REQUEST_TYPE,
236 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
239 dev_err(&port->dev, "Sending USB device request code %d "
240 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
243 if (port && C_CRTSCTS(tty))
246 dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n",
248 buf[0] = cts_enable_byte;
249 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
250 MCT_U232_SET_CTS_REQUEST,
251 MCT_U232_SET_REQUEST_TYPE,
252 0, 0, buf, MCT_U232_SET_CTS_SIZE,
255 dev_err(&port->dev, "Sending USB device request code %d "
256 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
260 } /* mct_u232_set_baud_rate */
262 static int mct_u232_set_line_ctrl(struct usb_serial_port *port,
268 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
273 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
274 MCT_U232_SET_LINE_CTRL_REQUEST,
275 MCT_U232_SET_REQUEST_TYPE,
276 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
279 dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
280 dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr);
283 } /* mct_u232_set_line_ctrl */
285 static int mct_u232_set_modem_ctrl(struct usb_serial_port *port,
286 unsigned int control_state)
292 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
296 mcr = MCT_U232_MCR_NONE;
297 if (control_state & TIOCM_DTR)
298 mcr |= MCT_U232_MCR_DTR;
299 if (control_state & TIOCM_RTS)
300 mcr |= MCT_U232_MCR_RTS;
303 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
304 MCT_U232_SET_MODEM_CTRL_REQUEST,
305 MCT_U232_SET_REQUEST_TYPE,
306 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
310 dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr);
313 dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
317 } /* mct_u232_set_modem_ctrl */
319 static int mct_u232_get_modem_stat(struct usb_serial_port *port,
325 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
330 rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),
331 MCT_U232_GET_MODEM_STAT_REQUEST,
332 MCT_U232_GET_REQUEST_TYPE,
333 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
336 dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc);
341 dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr);
344 } /* mct_u232_get_modem_stat */
346 static void mct_u232_msr_to_icount(struct async_icount *icount,
349 /* Translate Control Line states */
350 if (msr & MCT_U232_MSR_DDSR)
352 if (msr & MCT_U232_MSR_DCTS)
354 if (msr & MCT_U232_MSR_DRI)
356 if (msr & MCT_U232_MSR_DCD)
358 } /* mct_u232_msr_to_icount */
360 static void mct_u232_msr_to_state(struct usb_serial_port *port,
361 unsigned int *control_state, unsigned char msr)
363 /* Translate Control Line states */
364 if (msr & MCT_U232_MSR_DSR)
365 *control_state |= TIOCM_DSR;
367 *control_state &= ~TIOCM_DSR;
368 if (msr & MCT_U232_MSR_CTS)
369 *control_state |= TIOCM_CTS;
371 *control_state &= ~TIOCM_CTS;
372 if (msr & MCT_U232_MSR_RI)
373 *control_state |= TIOCM_RI;
375 *control_state &= ~TIOCM_RI;
376 if (msr & MCT_U232_MSR_CD)
377 *control_state |= TIOCM_CD;
379 *control_state &= ~TIOCM_CD;
380 dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state);
381 } /* mct_u232_msr_to_state */
384 * Driver's tty interface functions
387 static int mct_u232_startup(struct usb_serial *serial)
389 struct usb_serial_port *port, *rport;
391 /* Puh, that's dirty */
392 port = serial->port[0];
393 rport = serial->port[1];
394 /* No unlinking, it wasn't submitted yet. */
395 usb_free_urb(port->read_urb);
396 port->read_urb = rport->interrupt_in_urb;
397 rport->interrupt_in_urb = NULL;
398 port->read_urb->context = port;
401 } /* mct_u232_startup */
403 static int mct_u232_port_probe(struct usb_serial_port *port)
405 struct mct_u232_private *priv;
407 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
411 spin_lock_init(&priv->lock);
412 init_waitqueue_head(&priv->msr_wait);
414 usb_set_serial_port_data(port, priv);
419 static int mct_u232_port_remove(struct usb_serial_port *port)
421 struct mct_u232_private *priv;
423 priv = usb_get_serial_port_data(port);
429 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
431 struct usb_serial *serial = port->serial;
432 struct mct_u232_private *priv = usb_get_serial_port_data(port);
434 unsigned int control_state;
436 unsigned char last_lcr;
437 unsigned char last_msr;
439 /* Compensate for a hardware bug: although the Sitecom U232-P25
440 * device reports a maximum output packet size of 32 bytes,
441 * it seems to be able to accept only 16 bytes (and that's what
442 * SniffUSB says too...)
444 if (le16_to_cpu(serial->dev->descriptor.idProduct)
445 == MCT_U232_SITECOM_PID)
446 port->bulk_out_size = 16;
448 /* Do a defined restart: the normal serial device seems to
449 * always turn on DTR and RTS here, so do the same. I'm not
450 * sure if this is really necessary. But it should not harm
453 spin_lock_irqsave(&priv->lock, flags);
454 if (tty && (tty->termios.c_cflag & CBAUD))
455 priv->control_state = TIOCM_DTR | TIOCM_RTS;
457 priv->control_state = 0;
459 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
460 MCT_U232_PARITY_NONE |
461 MCT_U232_STOP_BITS_1);
462 control_state = priv->control_state;
463 last_lcr = priv->last_lcr;
464 spin_unlock_irqrestore(&priv->lock, flags);
465 mct_u232_set_modem_ctrl(port, control_state);
466 mct_u232_set_line_ctrl(port, last_lcr);
468 /* Read modem status and update control state */
469 mct_u232_get_modem_stat(port, &last_msr);
470 spin_lock_irqsave(&priv->lock, flags);
471 priv->last_msr = last_msr;
472 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
473 spin_unlock_irqrestore(&priv->lock, flags);
475 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
478 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
479 port->read_urb->pipe, retval);
483 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
485 usb_kill_urb(port->read_urb);
487 "usb_submit_urb(read int) failed pipe 0x%x err %d",
488 port->interrupt_in_urb->pipe, retval);
495 } /* mct_u232_open */
497 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
499 unsigned int control_state;
500 struct mct_u232_private *priv = usb_get_serial_port_data(port);
502 spin_lock_irq(&priv->lock);
504 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
506 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
507 control_state = priv->control_state;
508 spin_unlock_irq(&priv->lock);
510 mct_u232_set_modem_ctrl(port, control_state);
513 static void mct_u232_close(struct usb_serial_port *port)
516 * Must kill the read urb as it is actually an interrupt urb, which
517 * generic close thus fails to kill.
519 usb_kill_urb(port->read_urb);
520 usb_kill_urb(port->interrupt_in_urb);
522 usb_serial_generic_close(port);
523 } /* mct_u232_close */
526 static void mct_u232_read_int_callback(struct urb *urb)
528 struct usb_serial_port *port = urb->context;
529 struct mct_u232_private *priv = usb_get_serial_port_data(port);
530 unsigned char *data = urb->transfer_buffer;
532 int status = urb->status;
542 /* this urb is terminated, clean up */
543 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
547 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
552 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
555 * Work-a-round: handle the 'usual' bulk-in pipe here
557 if (urb->transfer_buffer_length > 2) {
558 if (urb->actual_length) {
559 tty_insert_flip_string(&port->port, data,
561 tty_flip_buffer_push(&port->port);
567 * The interrupt-in pipe signals exceptional conditions (modem line
568 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
570 spin_lock_irqsave(&priv->lock, flags);
571 priv->last_msr = data[MCT_U232_MSR_INDEX];
573 /* Record Control Line states */
574 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
576 mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
579 /* Not yet handled. See belkin_sa.c for further information */
580 /* Now to report any errors */
581 priv->last_lsr = data[MCT_U232_LSR_INDEX];
583 * fill in the flip buffer here, but I do not know the relation
584 * to the current/next receive buffer or characters. I need
585 * to look in to this before committing any code.
587 if (priv->last_lsr & MCT_U232_LSR_ERR) {
588 tty = tty_port_tty_get(&port->port);
590 if (priv->last_lsr & MCT_U232_LSR_OE) {
593 if (priv->last_lsr & MCT_U232_LSR_PE) {
596 if (priv->last_lsr & MCT_U232_LSR_FE) {
598 /* Break Indicator */
599 if (priv->last_lsr & MCT_U232_LSR_BI) {
604 wake_up_interruptible(&priv->msr_wait);
605 spin_unlock_irqrestore(&priv->lock, flags);
607 retval = usb_submit_urb(urb, GFP_ATOMIC);
610 "%s - usb_submit_urb failed with result %d\n",
612 } /* mct_u232_read_int_callback */
614 static void mct_u232_set_termios(struct tty_struct *tty,
615 struct usb_serial_port *port,
616 struct ktermios *old_termios)
618 struct usb_serial *serial = port->serial;
619 struct mct_u232_private *priv = usb_get_serial_port_data(port);
620 struct ktermios *termios = &tty->termios;
621 unsigned int cflag = termios->c_cflag;
622 unsigned int old_cflag = old_termios->c_cflag;
624 unsigned int control_state;
625 unsigned char last_lcr;
627 /* get a local copy of the current port settings */
628 spin_lock_irqsave(&priv->lock, flags);
629 control_state = priv->control_state;
630 spin_unlock_irqrestore(&priv->lock, flags);
635 * Do not attempt to cache old rates and skip settings,
636 * disconnects screw such tricks up completely.
637 * Premature optimization is the root of all evil.
640 /* reassert DTR and RTS on transition from B0 */
641 if ((old_cflag & CBAUD) == B0) {
642 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
643 control_state |= TIOCM_DTR | TIOCM_RTS;
644 mct_u232_set_modem_ctrl(port, control_state);
647 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
649 if ((cflag & CBAUD) == B0) {
650 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
651 /* Drop RTS and DTR */
652 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
653 mct_u232_set_modem_ctrl(port, control_state);
657 * Update line control register (LCR)
662 last_lcr |= (cflag & PARODD) ?
663 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
665 last_lcr |= MCT_U232_PARITY_NONE;
667 /* set the number of data bits */
668 switch (cflag & CSIZE) {
670 last_lcr |= MCT_U232_DATA_BITS_5; break;
672 last_lcr |= MCT_U232_DATA_BITS_6; break;
674 last_lcr |= MCT_U232_DATA_BITS_7; break;
676 last_lcr |= MCT_U232_DATA_BITS_8; break;
679 "CSIZE was not CS5-CS8, using default of 8\n");
680 last_lcr |= MCT_U232_DATA_BITS_8;
684 termios->c_cflag &= ~CMSPAR;
686 /* set the number of stop bits */
687 last_lcr |= (cflag & CSTOPB) ?
688 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
690 mct_u232_set_line_ctrl(port, last_lcr);
692 /* save off the modified port settings */
693 spin_lock_irqsave(&priv->lock, flags);
694 priv->control_state = control_state;
695 priv->last_lcr = last_lcr;
696 spin_unlock_irqrestore(&priv->lock, flags);
697 } /* mct_u232_set_termios */
699 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
701 struct usb_serial_port *port = tty->driver_data;
702 struct mct_u232_private *priv = usb_get_serial_port_data(port);
706 spin_lock_irqsave(&priv->lock, flags);
707 lcr = priv->last_lcr;
710 lcr |= MCT_U232_SET_BREAK;
711 spin_unlock_irqrestore(&priv->lock, flags);
713 mct_u232_set_line_ctrl(port, lcr);
714 } /* mct_u232_break_ctl */
717 static int mct_u232_tiocmget(struct tty_struct *tty)
719 struct usb_serial_port *port = tty->driver_data;
720 struct mct_u232_private *priv = usb_get_serial_port_data(port);
721 unsigned int control_state;
724 spin_lock_irqsave(&priv->lock, flags);
725 control_state = priv->control_state;
726 spin_unlock_irqrestore(&priv->lock, flags);
728 return control_state;
731 static int mct_u232_tiocmset(struct tty_struct *tty,
732 unsigned int set, unsigned int clear)
734 struct usb_serial_port *port = tty->driver_data;
735 struct mct_u232_private *priv = usb_get_serial_port_data(port);
736 unsigned int control_state;
739 spin_lock_irqsave(&priv->lock, flags);
740 control_state = priv->control_state;
743 control_state |= TIOCM_RTS;
745 control_state |= TIOCM_DTR;
746 if (clear & TIOCM_RTS)
747 control_state &= ~TIOCM_RTS;
748 if (clear & TIOCM_DTR)
749 control_state &= ~TIOCM_DTR;
751 priv->control_state = control_state;
752 spin_unlock_irqrestore(&priv->lock, flags);
753 return mct_u232_set_modem_ctrl(port, control_state);
756 static void mct_u232_throttle(struct tty_struct *tty)
758 struct usb_serial_port *port = tty->driver_data;
759 struct mct_u232_private *priv = usb_get_serial_port_data(port);
760 unsigned int control_state;
762 spin_lock_irq(&priv->lock);
763 priv->rx_flags |= THROTTLED;
764 if (C_CRTSCTS(tty)) {
765 priv->control_state &= ~TIOCM_RTS;
766 control_state = priv->control_state;
767 spin_unlock_irq(&priv->lock);
768 mct_u232_set_modem_ctrl(port, control_state);
770 spin_unlock_irq(&priv->lock);
774 static void mct_u232_unthrottle(struct tty_struct *tty)
776 struct usb_serial_port *port = tty->driver_data;
777 struct mct_u232_private *priv = usb_get_serial_port_data(port);
778 unsigned int control_state;
780 spin_lock_irq(&priv->lock);
781 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
782 priv->rx_flags &= ~THROTTLED;
783 priv->control_state |= TIOCM_RTS;
784 control_state = priv->control_state;
785 spin_unlock_irq(&priv->lock);
786 mct_u232_set_modem_ctrl(port, control_state);
788 spin_unlock_irq(&priv->lock);
792 static int mct_u232_ioctl(struct tty_struct *tty,
793 unsigned int cmd, unsigned long arg)
796 struct usb_serial_port *port = tty->driver_data;
797 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
798 struct async_icount cnow, cprev;
801 dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
807 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
809 spin_lock_irqsave(&mct_u232_port->lock, flags);
810 cprev = mct_u232_port->icount;
811 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
813 prepare_to_wait(&mct_u232_port->msr_wait,
814 &wait, TASK_INTERRUPTIBLE);
816 finish_wait(&mct_u232_port->msr_wait, &wait);
817 /* see if a signal did it */
818 if (signal_pending(current))
820 spin_lock_irqsave(&mct_u232_port->lock, flags);
821 cnow = mct_u232_port->icount;
822 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
823 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
824 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
825 return -EIO; /* no change => error */
826 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
827 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
828 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
829 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
839 static int mct_u232_get_icount(struct tty_struct *tty,
840 struct serial_icounter_struct *icount)
842 struct usb_serial_port *port = tty->driver_data;
843 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
844 struct async_icount *ic = &mct_u232_port->icount;
847 spin_lock_irqsave(&mct_u232_port->lock, flags);
849 icount->cts = ic->cts;
850 icount->dsr = ic->dsr;
851 icount->rng = ic->rng;
852 icount->dcd = ic->dcd;
855 icount->frame = ic->frame;
856 icount->overrun = ic->overrun;
857 icount->parity = ic->parity;
858 icount->brk = ic->brk;
859 icount->buf_overrun = ic->buf_overrun;
861 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
863 dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
864 __func__, icount->rx, icount->tx);
868 module_usb_serial_driver(serial_drivers, id_table);
870 MODULE_AUTHOR(DRIVER_AUTHOR);
871 MODULE_DESCRIPTION(DRIVER_DESC);
872 MODULE_LICENSE("GPL");