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 mutex_lock(&port->serial->disc_mutex);
503 if (!port->serial->disconnected) {
504 /* drop DTR and RTS */
505 spin_lock_irq(&priv->lock);
507 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
509 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
510 control_state = priv->control_state;
511 spin_unlock_irq(&priv->lock);
512 mct_u232_set_modem_ctrl(port, control_state);
514 mutex_unlock(&port->serial->disc_mutex);
517 static void mct_u232_close(struct usb_serial_port *port)
520 * Must kill the read urb as it is actually an interrupt urb, which
521 * generic close thus fails to kill.
523 usb_kill_urb(port->read_urb);
524 usb_kill_urb(port->interrupt_in_urb);
526 usb_serial_generic_close(port);
527 } /* mct_u232_close */
530 static void mct_u232_read_int_callback(struct urb *urb)
532 struct usb_serial_port *port = urb->context;
533 struct mct_u232_private *priv = usb_get_serial_port_data(port);
534 struct tty_struct *tty;
535 unsigned char *data = urb->transfer_buffer;
537 int status = urb->status;
547 /* this urb is terminated, clean up */
548 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
552 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
557 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
560 * Work-a-round: handle the 'usual' bulk-in pipe here
562 if (urb->transfer_buffer_length > 2) {
563 if (urb->actual_length) {
564 tty = tty_port_tty_get(&port->port);
566 tty_insert_flip_string(tty, data,
568 tty_flip_buffer_push(tty);
576 * The interrupt-in pipe signals exceptional conditions (modem line
577 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
579 spin_lock_irqsave(&priv->lock, flags);
580 priv->last_msr = data[MCT_U232_MSR_INDEX];
582 /* Record Control Line states */
583 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
585 mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
588 /* Not yet handled. See belkin_sa.c for further information */
589 /* Now to report any errors */
590 priv->last_lsr = data[MCT_U232_LSR_INDEX];
592 * fill in the flip buffer here, but I do not know the relation
593 * to the current/next receive buffer or characters. I need
594 * to look in to this before committing any code.
596 if (priv->last_lsr & MCT_U232_LSR_ERR) {
597 tty = tty_port_tty_get(&port->port);
599 if (priv->last_lsr & MCT_U232_LSR_OE) {
602 if (priv->last_lsr & MCT_U232_LSR_PE) {
605 if (priv->last_lsr & MCT_U232_LSR_FE) {
607 /* Break Indicator */
608 if (priv->last_lsr & MCT_U232_LSR_BI) {
613 wake_up_interruptible(&priv->msr_wait);
614 spin_unlock_irqrestore(&priv->lock, flags);
616 retval = usb_submit_urb(urb, GFP_ATOMIC);
619 "%s - usb_submit_urb failed with result %d\n",
621 } /* mct_u232_read_int_callback */
623 static void mct_u232_set_termios(struct tty_struct *tty,
624 struct usb_serial_port *port,
625 struct ktermios *old_termios)
627 struct usb_serial *serial = port->serial;
628 struct mct_u232_private *priv = usb_get_serial_port_data(port);
629 struct ktermios *termios = &tty->termios;
630 unsigned int cflag = termios->c_cflag;
631 unsigned int old_cflag = old_termios->c_cflag;
633 unsigned int control_state;
634 unsigned char last_lcr;
636 /* get a local copy of the current port settings */
637 spin_lock_irqsave(&priv->lock, flags);
638 control_state = priv->control_state;
639 spin_unlock_irqrestore(&priv->lock, flags);
644 * Do not attempt to cache old rates and skip settings,
645 * disconnects screw such tricks up completely.
646 * Premature optimization is the root of all evil.
649 /* reassert DTR and RTS on transition from B0 */
650 if ((old_cflag & CBAUD) == B0) {
651 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
652 control_state |= TIOCM_DTR | TIOCM_RTS;
653 mct_u232_set_modem_ctrl(port, control_state);
656 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
658 if ((cflag & CBAUD) == B0) {
659 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
660 /* Drop RTS and DTR */
661 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
662 mct_u232_set_modem_ctrl(port, control_state);
666 * Update line control register (LCR)
671 last_lcr |= (cflag & PARODD) ?
672 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
674 last_lcr |= MCT_U232_PARITY_NONE;
676 /* set the number of data bits */
677 switch (cflag & CSIZE) {
679 last_lcr |= MCT_U232_DATA_BITS_5; break;
681 last_lcr |= MCT_U232_DATA_BITS_6; break;
683 last_lcr |= MCT_U232_DATA_BITS_7; break;
685 last_lcr |= MCT_U232_DATA_BITS_8; break;
688 "CSIZE was not CS5-CS8, using default of 8\n");
689 last_lcr |= MCT_U232_DATA_BITS_8;
693 termios->c_cflag &= ~CMSPAR;
695 /* set the number of stop bits */
696 last_lcr |= (cflag & CSTOPB) ?
697 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
699 mct_u232_set_line_ctrl(port, last_lcr);
701 /* save off the modified port settings */
702 spin_lock_irqsave(&priv->lock, flags);
703 priv->control_state = control_state;
704 priv->last_lcr = last_lcr;
705 spin_unlock_irqrestore(&priv->lock, flags);
706 } /* mct_u232_set_termios */
708 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
710 struct usb_serial_port *port = tty->driver_data;
711 struct mct_u232_private *priv = usb_get_serial_port_data(port);
715 spin_lock_irqsave(&priv->lock, flags);
716 lcr = priv->last_lcr;
719 lcr |= MCT_U232_SET_BREAK;
720 spin_unlock_irqrestore(&priv->lock, flags);
722 mct_u232_set_line_ctrl(port, lcr);
723 } /* mct_u232_break_ctl */
726 static int mct_u232_tiocmget(struct tty_struct *tty)
728 struct usb_serial_port *port = tty->driver_data;
729 struct mct_u232_private *priv = usb_get_serial_port_data(port);
730 unsigned int control_state;
733 spin_lock_irqsave(&priv->lock, flags);
734 control_state = priv->control_state;
735 spin_unlock_irqrestore(&priv->lock, flags);
737 return control_state;
740 static int mct_u232_tiocmset(struct tty_struct *tty,
741 unsigned int set, unsigned int clear)
743 struct usb_serial_port *port = tty->driver_data;
744 struct mct_u232_private *priv = usb_get_serial_port_data(port);
745 unsigned int control_state;
748 spin_lock_irqsave(&priv->lock, flags);
749 control_state = priv->control_state;
752 control_state |= TIOCM_RTS;
754 control_state |= TIOCM_DTR;
755 if (clear & TIOCM_RTS)
756 control_state &= ~TIOCM_RTS;
757 if (clear & TIOCM_DTR)
758 control_state &= ~TIOCM_DTR;
760 priv->control_state = control_state;
761 spin_unlock_irqrestore(&priv->lock, flags);
762 return mct_u232_set_modem_ctrl(port, control_state);
765 static void mct_u232_throttle(struct tty_struct *tty)
767 struct usb_serial_port *port = tty->driver_data;
768 struct mct_u232_private *priv = usb_get_serial_port_data(port);
769 unsigned int control_state;
771 spin_lock_irq(&priv->lock);
772 priv->rx_flags |= THROTTLED;
773 if (C_CRTSCTS(tty)) {
774 priv->control_state &= ~TIOCM_RTS;
775 control_state = priv->control_state;
776 spin_unlock_irq(&priv->lock);
777 mct_u232_set_modem_ctrl(port, control_state);
779 spin_unlock_irq(&priv->lock);
783 static void mct_u232_unthrottle(struct tty_struct *tty)
785 struct usb_serial_port *port = tty->driver_data;
786 struct mct_u232_private *priv = usb_get_serial_port_data(port);
787 unsigned int control_state;
789 spin_lock_irq(&priv->lock);
790 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
791 priv->rx_flags &= ~THROTTLED;
792 priv->control_state |= TIOCM_RTS;
793 control_state = priv->control_state;
794 spin_unlock_irq(&priv->lock);
795 mct_u232_set_modem_ctrl(port, control_state);
797 spin_unlock_irq(&priv->lock);
801 static int mct_u232_ioctl(struct tty_struct *tty,
802 unsigned int cmd, unsigned long arg)
805 struct usb_serial_port *port = tty->driver_data;
806 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
807 struct async_icount cnow, cprev;
810 dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
816 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
818 spin_lock_irqsave(&mct_u232_port->lock, flags);
819 cprev = mct_u232_port->icount;
820 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
822 prepare_to_wait(&mct_u232_port->msr_wait,
823 &wait, TASK_INTERRUPTIBLE);
825 finish_wait(&mct_u232_port->msr_wait, &wait);
826 /* see if a signal did it */
827 if (signal_pending(current))
829 spin_lock_irqsave(&mct_u232_port->lock, flags);
830 cnow = mct_u232_port->icount;
831 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
832 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
833 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
834 return -EIO; /* no change => error */
835 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
836 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
837 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
838 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
848 static int mct_u232_get_icount(struct tty_struct *tty,
849 struct serial_icounter_struct *icount)
851 struct usb_serial_port *port = tty->driver_data;
852 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
853 struct async_icount *ic = &mct_u232_port->icount;
856 spin_lock_irqsave(&mct_u232_port->lock, flags);
858 icount->cts = ic->cts;
859 icount->dsr = ic->dsr;
860 icount->rng = ic->rng;
861 icount->dcd = ic->dcd;
864 icount->frame = ic->frame;
865 icount->overrun = ic->overrun;
866 icount->parity = ic->parity;
867 icount->brk = ic->brk;
868 icount->buf_overrun = ic->buf_overrun;
870 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
872 dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
873 __func__, icount->rx, icount->tx);
877 module_usb_serial_driver(serial_drivers, id_table);
879 MODULE_AUTHOR(DRIVER_AUTHOR);
880 MODULE_DESCRIPTION(DRIVER_DESC);
881 MODULE_LICENSE("GPL");