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/slab.h>
27 #include <linux/tty.h>
28 #include <linux/tty_driver.h>
29 #include <linux/tty_flip.h>
30 #include <linux/module.h>
31 #include <linux/spinlock.h>
32 #include <linux/uaccess.h>
33 #include <asm/unaligned.h>
34 #include <linux/usb.h>
35 #include <linux/usb/serial.h>
36 #include <linux/serial.h>
39 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
40 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
45 static int mct_u232_port_probe(struct usb_serial_port
*port
);
46 static int mct_u232_port_remove(struct usb_serial_port
*remove
);
47 static int mct_u232_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
48 static void mct_u232_close(struct usb_serial_port
*port
);
49 static void mct_u232_dtr_rts(struct usb_serial_port
*port
, int on
);
50 static void mct_u232_read_int_callback(struct urb
*urb
);
51 static void mct_u232_set_termios(struct tty_struct
*tty
,
52 struct usb_serial_port
*port
, struct ktermios
*old
);
53 static void mct_u232_break_ctl(struct tty_struct
*tty
, int break_state
);
54 static int mct_u232_tiocmget(struct tty_struct
*tty
);
55 static int mct_u232_tiocmset(struct tty_struct
*tty
,
56 unsigned int set
, unsigned int clear
);
57 static void mct_u232_throttle(struct tty_struct
*tty
);
58 static void mct_u232_unthrottle(struct tty_struct
*tty
);
62 * All of the device info needed for the MCT USB-RS232 converter.
64 static const struct usb_device_id id_table
[] = {
65 { USB_DEVICE(MCT_U232_VID
, MCT_U232_PID
) },
66 { USB_DEVICE(MCT_U232_VID
, MCT_U232_SITECOM_PID
) },
67 { USB_DEVICE(MCT_U232_VID
, MCT_U232_DU_H3SP_PID
) },
68 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID
, MCT_U232_BELKIN_F5U109_PID
) },
69 { } /* Terminating entry */
71 MODULE_DEVICE_TABLE(usb
, id_table
);
73 static struct usb_serial_driver mct_u232_device
= {
78 .description
= "MCT U232",
81 .open
= mct_u232_open
,
82 .close
= mct_u232_close
,
83 .dtr_rts
= mct_u232_dtr_rts
,
84 .throttle
= mct_u232_throttle
,
85 .unthrottle
= mct_u232_unthrottle
,
86 .read_int_callback
= mct_u232_read_int_callback
,
87 .set_termios
= mct_u232_set_termios
,
88 .break_ctl
= mct_u232_break_ctl
,
89 .tiocmget
= mct_u232_tiocmget
,
90 .tiocmset
= mct_u232_tiocmset
,
91 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
92 .port_probe
= mct_u232_port_probe
,
93 .port_remove
= mct_u232_port_remove
,
94 .get_icount
= usb_serial_generic_get_icount
,
97 static struct usb_serial_driver
* const serial_drivers
[] = {
98 &mct_u232_device
, NULL
101 struct mct_u232_private
{
102 struct urb
*read_urb
;
104 unsigned int control_state
; /* Modem Line Setting (TIOCM) */
105 unsigned char last_lcr
; /* Line Control Register */
106 unsigned char last_lsr
; /* Line Status Register */
107 unsigned char last_msr
; /* Modem Status Register */
108 unsigned int rx_flags
; /* Throttling flags */
111 #define THROTTLED 0x01
114 * Handle vendor specific USB requests
117 #define WDR_TIMEOUT 5000 /* default urb timeout */
120 * Later day 2.6.0-test kernels have new baud rates like B230400 which
121 * we do not know how to support. We ignore them for the moment.
123 static int mct_u232_calculate_baud_rate(struct usb_serial
*serial
,
124 speed_t value
, speed_t
*result
)
128 if (le16_to_cpu(serial
->dev
->descriptor
.idProduct
) == MCT_U232_SITECOM_PID
129 || le16_to_cpu(serial
->dev
->descriptor
.idProduct
) == MCT_U232_BELKIN_F5U109_PID
) {
134 return 0x02; /* this one not tested */
156 /* FIXME: Can we use any divider - should we do
157 divider = 115200/value;
158 real baud = 115200/divider */
178 static int mct_u232_set_baud_rate(struct tty_struct
*tty
,
179 struct usb_serial
*serial
, struct usb_serial_port
*port
, speed_t value
)
181 unsigned int divisor
;
184 unsigned char cts_enable_byte
= 0;
187 buf
= kmalloc(MCT_U232_MAX_SIZE
, GFP_KERNEL
);
191 divisor
= mct_u232_calculate_baud_rate(serial
, value
, &speed
);
192 put_unaligned_le32(divisor
, buf
);
193 rc
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
194 MCT_U232_SET_BAUD_RATE_REQUEST
,
195 MCT_U232_SET_REQUEST_TYPE
,
196 0, 0, buf
, MCT_U232_SET_BAUD_RATE_SIZE
,
198 if (rc
< 0) /*FIXME: What value speed results */
199 dev_err(&port
->dev
, "Set BAUD RATE %d failed (error = %d)\n",
202 tty_encode_baud_rate(tty
, speed
, speed
);
203 dev_dbg(&port
->dev
, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value
, divisor
);
205 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
206 always sends two extra USB 'device request' messages after the
207 'baud rate change' message. The actual functionality of the
208 request codes in these messages is not fully understood but these
209 particular codes are never seen in any operation besides a baud
210 rate change. Both of these messages send a single byte of data.
211 In the first message, the value of this byte is always zero.
213 The second message has been determined experimentally to control
214 whether data will be transmitted to a device which is not asserting
215 the 'CTS' signal. If the second message's data byte is zero, data
216 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
217 flow control). if the second message's data byte is nonzero (a
218 value of 1 is used by this driver), data will not be transmitted to
219 a device which is not asserting 'CTS'.
223 rc
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
224 MCT_U232_SET_UNKNOWN1_REQUEST
,
225 MCT_U232_SET_REQUEST_TYPE
,
226 0, 0, buf
, MCT_U232_SET_UNKNOWN1_SIZE
,
229 dev_err(&port
->dev
, "Sending USB device request code %d "
230 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST
,
233 if (port
&& C_CRTSCTS(tty
))
236 dev_dbg(&port
->dev
, "set_baud_rate: send second control message, data = %02X\n",
238 buf
[0] = cts_enable_byte
;
239 rc
= usb_control_msg(serial
->dev
, usb_sndctrlpipe(serial
->dev
, 0),
240 MCT_U232_SET_CTS_REQUEST
,
241 MCT_U232_SET_REQUEST_TYPE
,
242 0, 0, buf
, MCT_U232_SET_CTS_SIZE
,
245 dev_err(&port
->dev
, "Sending USB device request code %d "
246 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST
, rc
);
250 } /* mct_u232_set_baud_rate */
252 static int mct_u232_set_line_ctrl(struct usb_serial_port
*port
,
258 buf
= kmalloc(MCT_U232_MAX_SIZE
, GFP_KERNEL
);
263 rc
= usb_control_msg(port
->serial
->dev
, usb_sndctrlpipe(port
->serial
->dev
, 0),
264 MCT_U232_SET_LINE_CTRL_REQUEST
,
265 MCT_U232_SET_REQUEST_TYPE
,
266 0, 0, buf
, MCT_U232_SET_LINE_CTRL_SIZE
,
269 dev_err(&port
->dev
, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr
, rc
);
270 dev_dbg(&port
->dev
, "set_line_ctrl: 0x%x\n", lcr
);
273 } /* mct_u232_set_line_ctrl */
275 static int mct_u232_set_modem_ctrl(struct usb_serial_port
*port
,
276 unsigned int control_state
)
282 buf
= kmalloc(MCT_U232_MAX_SIZE
, GFP_KERNEL
);
286 mcr
= MCT_U232_MCR_NONE
;
287 if (control_state
& TIOCM_DTR
)
288 mcr
|= MCT_U232_MCR_DTR
;
289 if (control_state
& TIOCM_RTS
)
290 mcr
|= MCT_U232_MCR_RTS
;
293 rc
= usb_control_msg(port
->serial
->dev
, usb_sndctrlpipe(port
->serial
->dev
, 0),
294 MCT_U232_SET_MODEM_CTRL_REQUEST
,
295 MCT_U232_SET_REQUEST_TYPE
,
296 0, 0, buf
, MCT_U232_SET_MODEM_CTRL_SIZE
,
300 dev_dbg(&port
->dev
, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state
, mcr
);
303 dev_err(&port
->dev
, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr
, rc
);
307 } /* mct_u232_set_modem_ctrl */
309 static int mct_u232_get_modem_stat(struct usb_serial_port
*port
,
315 buf
= kmalloc(MCT_U232_MAX_SIZE
, GFP_KERNEL
);
320 rc
= usb_control_msg(port
->serial
->dev
, usb_rcvctrlpipe(port
->serial
->dev
, 0),
321 MCT_U232_GET_MODEM_STAT_REQUEST
,
322 MCT_U232_GET_REQUEST_TYPE
,
323 0, 0, buf
, MCT_U232_GET_MODEM_STAT_SIZE
,
325 if (rc
< MCT_U232_GET_MODEM_STAT_SIZE
) {
326 dev_err(&port
->dev
, "Get MODEM STATus failed (error = %d)\n", rc
);
335 dev_dbg(&port
->dev
, "get_modem_stat: 0x%x\n", *msr
);
338 } /* mct_u232_get_modem_stat */
340 static void mct_u232_msr_to_icount(struct async_icount
*icount
,
343 /* Translate Control Line states */
344 if (msr
& MCT_U232_MSR_DDSR
)
346 if (msr
& MCT_U232_MSR_DCTS
)
348 if (msr
& MCT_U232_MSR_DRI
)
350 if (msr
& MCT_U232_MSR_DCD
)
352 } /* mct_u232_msr_to_icount */
354 static void mct_u232_msr_to_state(struct usb_serial_port
*port
,
355 unsigned int *control_state
, unsigned char msr
)
357 /* Translate Control Line states */
358 if (msr
& MCT_U232_MSR_DSR
)
359 *control_state
|= TIOCM_DSR
;
361 *control_state
&= ~TIOCM_DSR
;
362 if (msr
& MCT_U232_MSR_CTS
)
363 *control_state
|= TIOCM_CTS
;
365 *control_state
&= ~TIOCM_CTS
;
366 if (msr
& MCT_U232_MSR_RI
)
367 *control_state
|= TIOCM_RI
;
369 *control_state
&= ~TIOCM_RI
;
370 if (msr
& MCT_U232_MSR_CD
)
371 *control_state
|= TIOCM_CD
;
373 *control_state
&= ~TIOCM_CD
;
374 dev_dbg(&port
->dev
, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr
, *control_state
);
375 } /* mct_u232_msr_to_state */
378 * Driver's tty interface functions
381 static int mct_u232_port_probe(struct usb_serial_port
*port
)
383 struct usb_serial
*serial
= port
->serial
;
384 struct mct_u232_private
*priv
;
386 /* check first to simplify error handling */
387 if (!serial
->port
[1] || !serial
->port
[1]->interrupt_in_urb
) {
388 dev_err(&port
->dev
, "expected endpoint missing\n");
392 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
396 /* Use second interrupt-in endpoint for reading. */
397 priv
->read_urb
= serial
->port
[1]->interrupt_in_urb
;
398 priv
->read_urb
->context
= port
;
400 spin_lock_init(&priv
->lock
);
402 usb_set_serial_port_data(port
, priv
);
407 static int mct_u232_port_remove(struct usb_serial_port
*port
)
409 struct mct_u232_private
*priv
;
411 priv
= usb_get_serial_port_data(port
);
417 static int mct_u232_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
419 struct usb_serial
*serial
= port
->serial
;
420 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
422 unsigned int control_state
;
424 unsigned char last_lcr
;
425 unsigned char last_msr
;
427 /* Compensate for a hardware bug: although the Sitecom U232-P25
428 * device reports a maximum output packet size of 32 bytes,
429 * it seems to be able to accept only 16 bytes (and that's what
430 * SniffUSB says too...)
432 if (le16_to_cpu(serial
->dev
->descriptor
.idProduct
)
433 == MCT_U232_SITECOM_PID
)
434 port
->bulk_out_size
= 16;
436 /* Do a defined restart: the normal serial device seems to
437 * always turn on DTR and RTS here, so do the same. I'm not
438 * sure if this is really necessary. But it should not harm
441 spin_lock_irqsave(&priv
->lock
, flags
);
442 if (tty
&& (tty
->termios
.c_cflag
& CBAUD
))
443 priv
->control_state
= TIOCM_DTR
| TIOCM_RTS
;
445 priv
->control_state
= 0;
447 priv
->last_lcr
= (MCT_U232_DATA_BITS_8
|
448 MCT_U232_PARITY_NONE
|
449 MCT_U232_STOP_BITS_1
);
450 control_state
= priv
->control_state
;
451 last_lcr
= priv
->last_lcr
;
452 spin_unlock_irqrestore(&priv
->lock
, flags
);
453 mct_u232_set_modem_ctrl(port
, control_state
);
454 mct_u232_set_line_ctrl(port
, last_lcr
);
456 /* Read modem status and update control state */
457 mct_u232_get_modem_stat(port
, &last_msr
);
458 spin_lock_irqsave(&priv
->lock
, flags
);
459 priv
->last_msr
= last_msr
;
460 mct_u232_msr_to_state(port
, &priv
->control_state
, priv
->last_msr
);
461 spin_unlock_irqrestore(&priv
->lock
, flags
);
463 retval
= usb_submit_urb(priv
->read_urb
, GFP_KERNEL
);
466 "usb_submit_urb(read) failed pipe 0x%x err %d\n",
467 port
->read_urb
->pipe
, retval
);
471 retval
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
473 usb_kill_urb(priv
->read_urb
);
475 "usb_submit_urb(read int) failed pipe 0x%x err %d",
476 port
->interrupt_in_urb
->pipe
, retval
);
483 } /* mct_u232_open */
485 static void mct_u232_dtr_rts(struct usb_serial_port
*port
, int on
)
487 unsigned int control_state
;
488 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
490 spin_lock_irq(&priv
->lock
);
492 priv
->control_state
|= TIOCM_DTR
| TIOCM_RTS
;
494 priv
->control_state
&= ~(TIOCM_DTR
| TIOCM_RTS
);
495 control_state
= priv
->control_state
;
496 spin_unlock_irq(&priv
->lock
);
498 mct_u232_set_modem_ctrl(port
, control_state
);
501 static void mct_u232_close(struct usb_serial_port
*port
)
503 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
505 usb_kill_urb(priv
->read_urb
);
506 usb_kill_urb(port
->interrupt_in_urb
);
508 usb_serial_generic_close(port
);
509 } /* mct_u232_close */
512 static void mct_u232_read_int_callback(struct urb
*urb
)
514 struct usb_serial_port
*port
= urb
->context
;
515 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
516 unsigned char *data
= urb
->transfer_buffer
;
518 int status
= urb
->status
;
528 /* this urb is terminated, clean up */
529 dev_dbg(&port
->dev
, "%s - urb shutting down with status: %d\n",
533 dev_dbg(&port
->dev
, "%s - nonzero urb status received: %d\n",
538 usb_serial_debug_data(&port
->dev
, __func__
, urb
->actual_length
, data
);
541 * Work-a-round: handle the 'usual' bulk-in pipe here
543 if (urb
->transfer_buffer_length
> 2) {
544 if (urb
->actual_length
) {
545 tty_insert_flip_string(&port
->port
, data
,
547 tty_flip_buffer_push(&port
->port
);
553 * The interrupt-in pipe signals exceptional conditions (modem line
554 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
556 spin_lock_irqsave(&priv
->lock
, flags
);
557 priv
->last_msr
= data
[MCT_U232_MSR_INDEX
];
559 /* Record Control Line states */
560 mct_u232_msr_to_state(port
, &priv
->control_state
, priv
->last_msr
);
562 mct_u232_msr_to_icount(&port
->icount
, priv
->last_msr
);
565 /* Not yet handled. See belkin_sa.c for further information */
566 /* Now to report any errors */
567 priv
->last_lsr
= data
[MCT_U232_LSR_INDEX
];
569 * fill in the flip buffer here, but I do not know the relation
570 * to the current/next receive buffer or characters. I need
571 * to look in to this before committing any code.
573 if (priv
->last_lsr
& MCT_U232_LSR_ERR
) {
574 tty
= tty_port_tty_get(&port
->port
);
576 if (priv
->last_lsr
& MCT_U232_LSR_OE
) {
579 if (priv
->last_lsr
& MCT_U232_LSR_PE
) {
582 if (priv
->last_lsr
& MCT_U232_LSR_FE
) {
584 /* Break Indicator */
585 if (priv
->last_lsr
& MCT_U232_LSR_BI
) {
590 wake_up_interruptible(&port
->port
.delta_msr_wait
);
591 spin_unlock_irqrestore(&priv
->lock
, flags
);
593 retval
= usb_submit_urb(urb
, GFP_ATOMIC
);
596 "%s - usb_submit_urb failed with result %d\n",
598 } /* mct_u232_read_int_callback */
600 static void mct_u232_set_termios(struct tty_struct
*tty
,
601 struct usb_serial_port
*port
,
602 struct ktermios
*old_termios
)
604 struct usb_serial
*serial
= port
->serial
;
605 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
606 struct ktermios
*termios
= &tty
->termios
;
607 unsigned int cflag
= termios
->c_cflag
;
608 unsigned int old_cflag
= old_termios
->c_cflag
;
610 unsigned int control_state
;
611 unsigned char last_lcr
;
613 /* get a local copy of the current port settings */
614 spin_lock_irqsave(&priv
->lock
, flags
);
615 control_state
= priv
->control_state
;
616 spin_unlock_irqrestore(&priv
->lock
, flags
);
621 * Do not attempt to cache old rates and skip settings,
622 * disconnects screw such tricks up completely.
623 * Premature optimization is the root of all evil.
626 /* reassert DTR and RTS on transition from B0 */
627 if ((old_cflag
& CBAUD
) == B0
) {
628 dev_dbg(&port
->dev
, "%s: baud was B0\n", __func__
);
629 control_state
|= TIOCM_DTR
| TIOCM_RTS
;
630 mct_u232_set_modem_ctrl(port
, control_state
);
633 mct_u232_set_baud_rate(tty
, serial
, port
, tty_get_baud_rate(tty
));
635 if ((cflag
& CBAUD
) == B0
) {
636 dev_dbg(&port
->dev
, "%s: baud is B0\n", __func__
);
637 /* Drop RTS and DTR */
638 control_state
&= ~(TIOCM_DTR
| TIOCM_RTS
);
639 mct_u232_set_modem_ctrl(port
, control_state
);
643 * Update line control register (LCR)
648 last_lcr
|= (cflag
& PARODD
) ?
649 MCT_U232_PARITY_ODD
: MCT_U232_PARITY_EVEN
;
651 last_lcr
|= MCT_U232_PARITY_NONE
;
653 /* set the number of data bits */
654 switch (cflag
& CSIZE
) {
656 last_lcr
|= MCT_U232_DATA_BITS_5
; break;
658 last_lcr
|= MCT_U232_DATA_BITS_6
; break;
660 last_lcr
|= MCT_U232_DATA_BITS_7
; break;
662 last_lcr
|= MCT_U232_DATA_BITS_8
; break;
665 "CSIZE was not CS5-CS8, using default of 8\n");
666 last_lcr
|= MCT_U232_DATA_BITS_8
;
670 termios
->c_cflag
&= ~CMSPAR
;
672 /* set the number of stop bits */
673 last_lcr
|= (cflag
& CSTOPB
) ?
674 MCT_U232_STOP_BITS_2
: MCT_U232_STOP_BITS_1
;
676 mct_u232_set_line_ctrl(port
, last_lcr
);
678 /* save off the modified port settings */
679 spin_lock_irqsave(&priv
->lock
, flags
);
680 priv
->control_state
= control_state
;
681 priv
->last_lcr
= last_lcr
;
682 spin_unlock_irqrestore(&priv
->lock
, flags
);
683 } /* mct_u232_set_termios */
685 static void mct_u232_break_ctl(struct tty_struct
*tty
, int break_state
)
687 struct usb_serial_port
*port
= tty
->driver_data
;
688 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
692 spin_lock_irqsave(&priv
->lock
, flags
);
693 lcr
= priv
->last_lcr
;
696 lcr
|= MCT_U232_SET_BREAK
;
697 spin_unlock_irqrestore(&priv
->lock
, flags
);
699 mct_u232_set_line_ctrl(port
, lcr
);
700 } /* mct_u232_break_ctl */
703 static int mct_u232_tiocmget(struct tty_struct
*tty
)
705 struct usb_serial_port
*port
= tty
->driver_data
;
706 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
707 unsigned int control_state
;
710 spin_lock_irqsave(&priv
->lock
, flags
);
711 control_state
= priv
->control_state
;
712 spin_unlock_irqrestore(&priv
->lock
, flags
);
714 return control_state
;
717 static int mct_u232_tiocmset(struct tty_struct
*tty
,
718 unsigned int set
, unsigned int clear
)
720 struct usb_serial_port
*port
= tty
->driver_data
;
721 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
722 unsigned int control_state
;
725 spin_lock_irqsave(&priv
->lock
, flags
);
726 control_state
= priv
->control_state
;
729 control_state
|= TIOCM_RTS
;
731 control_state
|= TIOCM_DTR
;
732 if (clear
& TIOCM_RTS
)
733 control_state
&= ~TIOCM_RTS
;
734 if (clear
& TIOCM_DTR
)
735 control_state
&= ~TIOCM_DTR
;
737 priv
->control_state
= control_state
;
738 spin_unlock_irqrestore(&priv
->lock
, flags
);
739 return mct_u232_set_modem_ctrl(port
, control_state
);
742 static void mct_u232_throttle(struct tty_struct
*tty
)
744 struct usb_serial_port
*port
= tty
->driver_data
;
745 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
746 unsigned int control_state
;
748 spin_lock_irq(&priv
->lock
);
749 priv
->rx_flags
|= THROTTLED
;
750 if (C_CRTSCTS(tty
)) {
751 priv
->control_state
&= ~TIOCM_RTS
;
752 control_state
= priv
->control_state
;
753 spin_unlock_irq(&priv
->lock
);
754 mct_u232_set_modem_ctrl(port
, control_state
);
756 spin_unlock_irq(&priv
->lock
);
760 static void mct_u232_unthrottle(struct tty_struct
*tty
)
762 struct usb_serial_port
*port
= tty
->driver_data
;
763 struct mct_u232_private
*priv
= usb_get_serial_port_data(port
);
764 unsigned int control_state
;
766 spin_lock_irq(&priv
->lock
);
767 if ((priv
->rx_flags
& THROTTLED
) && C_CRTSCTS(tty
)) {
768 priv
->rx_flags
&= ~THROTTLED
;
769 priv
->control_state
|= TIOCM_RTS
;
770 control_state
= priv
->control_state
;
771 spin_unlock_irq(&priv
->lock
);
772 mct_u232_set_modem_ctrl(port
, control_state
);
774 spin_unlock_irq(&priv
->lock
);
778 module_usb_serial_driver(serial_drivers
, id_table
);
780 MODULE_AUTHOR(DRIVER_AUTHOR
);
781 MODULE_DESCRIPTION(DRIVER_DESC
);
782 MODULE_LICENSE("GPL");