1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
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 <linux/uaccess.h>
78#include <asm/unaligned.h>
79#include <linux/usb.h>
80#include <linux/usb/serial.h>
81#include "mct_u232.h"
82
83
84
85
86#define DRIVER_VERSION "z2.1"
87#define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
88#define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
89
90static int debug;
91
92
93
94
95static int mct_u232_startup(struct usb_serial *serial);
96static void mct_u232_release(struct usb_serial *serial);
97static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
98static void mct_u232_close(struct usb_serial_port *port);
99static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
100static void mct_u232_read_int_callback(struct urb *urb);
101static void mct_u232_set_termios(struct tty_struct *tty,
102 struct usb_serial_port *port, struct ktermios *old);
103static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
104static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file);
105static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
106 unsigned int set, unsigned int clear);
107static void mct_u232_throttle(struct tty_struct *tty);
108static void mct_u232_unthrottle(struct tty_struct *tty);
109
110
111
112
113
114static const struct usb_device_id id_table_combined[] = {
115 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
116 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
117 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
118 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
119 { }
120};
121
122MODULE_DEVICE_TABLE(usb, id_table_combined);
123
124static struct usb_driver mct_u232_driver = {
125 .name = "mct_u232",
126 .probe = usb_serial_probe,
127 .disconnect = usb_serial_disconnect,
128 .id_table = id_table_combined,
129 .no_dynamic_id = 1,
130};
131
132static struct usb_serial_driver mct_u232_device = {
133 .driver = {
134 .owner = THIS_MODULE,
135 .name = "mct_u232",
136 },
137 .description = "MCT U232",
138 .usb_driver = &mct_u232_driver,
139 .id_table = id_table_combined,
140 .num_ports = 1,
141 .open = mct_u232_open,
142 .close = mct_u232_close,
143 .dtr_rts = mct_u232_dtr_rts,
144 .throttle = mct_u232_throttle,
145 .unthrottle = mct_u232_unthrottle,
146 .read_int_callback = mct_u232_read_int_callback,
147 .set_termios = mct_u232_set_termios,
148 .break_ctl = mct_u232_break_ctl,
149 .tiocmget = mct_u232_tiocmget,
150 .tiocmset = mct_u232_tiocmset,
151 .attach = mct_u232_startup,
152 .release = mct_u232_release,
153};
154
155
156struct mct_u232_private {
157 spinlock_t lock;
158 unsigned int control_state;
159 unsigned char last_lcr;
160 unsigned char last_lsr;
161 unsigned char last_msr;
162 unsigned int rx_flags;
163};
164
165#define THROTTLED 0x01
166
167
168
169
170
171#define WDR_TIMEOUT 5000
172
173
174
175
176
177static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
178 speed_t value, speed_t *result)
179{
180 *result = value;
181
182 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
183 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
184 switch (value) {
185 case 300:
186 return 0x01;
187 case 600:
188 return 0x02;
189 case 1200:
190 return 0x03;
191 case 2400:
192 return 0x04;
193 case 4800:
194 return 0x06;
195 case 9600:
196 return 0x08;
197 case 19200:
198 return 0x09;
199 case 38400:
200 return 0x0a;
201 case 57600:
202 return 0x0b;
203 case 115200:
204 return 0x0c;
205 default:
206 *result = 9600;
207 return 0x08;
208 }
209 } else {
210
211
212
213 switch (value) {
214 case 300: break;
215 case 600: break;
216 case 1200: break;
217 case 2400: break;
218 case 4800: break;
219 case 9600: break;
220 case 19200: break;
221 case 38400: break;
222 case 57600: break;
223 case 115200: break;
224 default:
225 value = 9600;
226 *result = 9600;
227 }
228 return 115200/value;
229 }
230}
231
232static int mct_u232_set_baud_rate(struct tty_struct *tty,
233 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
234{
235 unsigned int divisor;
236 int rc;
237 unsigned char *buf;
238 unsigned char cts_enable_byte = 0;
239 speed_t speed;
240
241 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
242 if (buf == NULL)
243 return -ENOMEM;
244
245 divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
246 put_unaligned_le32(cpu_to_le32(divisor), buf);
247 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
248 MCT_U232_SET_BAUD_RATE_REQUEST,
249 MCT_U232_SET_REQUEST_TYPE,
250 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
251 WDR_TIMEOUT);
252 if (rc < 0)
253 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
254 value, rc);
255 else
256 tty_encode_baud_rate(tty, speed, speed);
257 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276 buf[0] = 0;
277 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
278 MCT_U232_SET_UNKNOWN1_REQUEST,
279 MCT_U232_SET_REQUEST_TYPE,
280 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
281 WDR_TIMEOUT);
282 if (rc < 0)
283 dev_err(&port->dev, "Sending USB device request code %d "
284 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
285 rc);
286
287 if (port && C_CRTSCTS(tty))
288 cts_enable_byte = 1;
289
290 dbg("set_baud_rate: send second control message, data = %02X",
291 cts_enable_byte);
292 buf[0] = cts_enable_byte;
293 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
294 MCT_U232_SET_CTS_REQUEST,
295 MCT_U232_SET_REQUEST_TYPE,
296 0, 0, buf, MCT_U232_SET_CTS_SIZE,
297 WDR_TIMEOUT);
298 if (rc < 0)
299 dev_err(&port->dev, "Sending USB device request code %d "
300 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
301
302 kfree(buf);
303 return rc;
304}
305
306static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
307{
308 int rc;
309 unsigned char *buf;
310
311 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
312 if (buf == NULL)
313 return -ENOMEM;
314
315 buf[0] = lcr;
316 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
317 MCT_U232_SET_LINE_CTRL_REQUEST,
318 MCT_U232_SET_REQUEST_TYPE,
319 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
320 WDR_TIMEOUT);
321 if (rc < 0)
322 dev_err(&serial->dev->dev,
323 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
324 dbg("set_line_ctrl: 0x%x", lcr);
325 kfree(buf);
326 return rc;
327}
328
329static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
330 unsigned int control_state)
331{
332 int rc;
333 unsigned char mcr;
334 unsigned char *buf;
335
336 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
337 if (buf == NULL)
338 return -ENOMEM;
339
340 mcr = MCT_U232_MCR_NONE;
341 if (control_state & TIOCM_DTR)
342 mcr |= MCT_U232_MCR_DTR;
343 if (control_state & TIOCM_RTS)
344 mcr |= MCT_U232_MCR_RTS;
345
346 buf[0] = mcr;
347 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
348 MCT_U232_SET_MODEM_CTRL_REQUEST,
349 MCT_U232_SET_REQUEST_TYPE,
350 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
351 WDR_TIMEOUT);
352 if (rc < 0)
353 dev_err(&serial->dev->dev,
354 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
355 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
356
357 kfree(buf);
358 return rc;
359}
360
361static int mct_u232_get_modem_stat(struct usb_serial *serial,
362 unsigned char *msr)
363{
364 int rc;
365 unsigned char *buf;
366
367 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
368 if (buf == NULL) {
369 *msr = 0;
370 return -ENOMEM;
371 }
372 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
373 MCT_U232_GET_MODEM_STAT_REQUEST,
374 MCT_U232_GET_REQUEST_TYPE,
375 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
376 WDR_TIMEOUT);
377 if (rc < 0) {
378 dev_err(&serial->dev->dev,
379 "Get MODEM STATus failed (error = %d)\n", rc);
380 *msr = 0;
381 } else {
382 *msr = buf[0];
383 }
384 dbg("get_modem_stat: 0x%x", *msr);
385 kfree(buf);
386 return rc;
387}
388
389static void mct_u232_msr_to_state(unsigned int *control_state,
390 unsigned char msr)
391{
392
393 if (msr & MCT_U232_MSR_DSR)
394 *control_state |= TIOCM_DSR;
395 else
396 *control_state &= ~TIOCM_DSR;
397 if (msr & MCT_U232_MSR_CTS)
398 *control_state |= TIOCM_CTS;
399 else
400 *control_state &= ~TIOCM_CTS;
401 if (msr & MCT_U232_MSR_RI)
402 *control_state |= TIOCM_RI;
403 else
404 *control_state &= ~TIOCM_RI;
405 if (msr & MCT_U232_MSR_CD)
406 *control_state |= TIOCM_CD;
407 else
408 *control_state &= ~TIOCM_CD;
409 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
410}
411
412
413
414
415
416static int mct_u232_startup(struct usb_serial *serial)
417{
418 struct mct_u232_private *priv;
419 struct usb_serial_port *port, *rport;
420
421 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
422 if (!priv)
423 return -ENOMEM;
424 spin_lock_init(&priv->lock);
425 usb_set_serial_port_data(serial->port[0], priv);
426
427 init_waitqueue_head(&serial->port[0]->write_wait);
428
429
430 port = serial->port[0];
431 rport = serial->port[1];
432
433 usb_free_urb(port->read_urb);
434 port->read_urb = rport->interrupt_in_urb;
435 rport->interrupt_in_urb = NULL;
436 port->read_urb->context = port;
437
438 return 0;
439}
440
441
442static void mct_u232_release(struct usb_serial *serial)
443{
444 struct mct_u232_private *priv;
445 int i;
446
447 dbg("%s", __func__);
448
449 for (i = 0; i < serial->num_ports; ++i) {
450
451 priv = usb_get_serial_port_data(serial->port[i]);
452 kfree(priv);
453 }
454}
455
456static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
457{
458 struct usb_serial *serial = port->serial;
459 struct mct_u232_private *priv = usb_get_serial_port_data(port);
460 int retval = 0;
461 unsigned int control_state;
462 unsigned long flags;
463 unsigned char last_lcr;
464 unsigned char last_msr;
465
466 dbg("%s port %d", __func__, port->number);
467
468
469
470
471
472
473 if (le16_to_cpu(serial->dev->descriptor.idProduct)
474 == MCT_U232_SITECOM_PID)
475 port->bulk_out_size = 16;
476
477
478
479
480
481
482 spin_lock_irqsave(&priv->lock, flags);
483 if (tty && (tty->termios->c_cflag & CBAUD))
484 priv->control_state = TIOCM_DTR | TIOCM_RTS;
485 else
486 priv->control_state = 0;
487
488 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
489 MCT_U232_PARITY_NONE |
490 MCT_U232_STOP_BITS_1);
491 control_state = priv->control_state;
492 last_lcr = priv->last_lcr;
493 spin_unlock_irqrestore(&priv->lock, flags);
494 mct_u232_set_modem_ctrl(serial, control_state);
495 mct_u232_set_line_ctrl(serial, last_lcr);
496
497
498 mct_u232_get_modem_stat(serial, &last_msr);
499 spin_lock_irqsave(&priv->lock, flags);
500 priv->last_msr = last_msr;
501 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
502 spin_unlock_irqrestore(&priv->lock, flags);
503
504 port->read_urb->dev = port->serial->dev;
505 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
506 if (retval) {
507 dev_err(&port->dev,
508 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
509 port->read_urb->pipe, retval);
510 goto error;
511 }
512
513 port->interrupt_in_urb->dev = port->serial->dev;
514 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
515 if (retval) {
516 usb_kill_urb(port->read_urb);
517 dev_err(&port->dev,
518 "usb_submit_urb(read int) failed pipe 0x%x err %d",
519 port->interrupt_in_urb->pipe, retval);
520 goto error;
521 }
522 return 0;
523
524error:
525 return retval;
526}
527
528static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
529{
530 unsigned int control_state;
531 struct mct_u232_private *priv = usb_get_serial_port_data(port);
532
533 mutex_lock(&port->serial->disc_mutex);
534 if (!port->serial->disconnected) {
535
536 spin_lock_irq(&priv->lock);
537 if (on)
538 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
539 else
540 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
541 control_state = priv->control_state;
542 spin_unlock_irq(&priv->lock);
543 mct_u232_set_modem_ctrl(port->serial, control_state);
544 }
545 mutex_unlock(&port->serial->disc_mutex);
546}
547
548static void mct_u232_close(struct usb_serial_port *port)
549{
550 dbg("%s port %d", __func__, port->number);
551
552 if (port->serial->dev) {
553
554 usb_kill_urb(port->write_urb);
555 usb_kill_urb(port->read_urb);
556 usb_kill_urb(port->interrupt_in_urb);
557 }
558}
559
560
561static void mct_u232_read_int_callback(struct urb *urb)
562{
563 struct usb_serial_port *port = urb->context;
564 struct mct_u232_private *priv = usb_get_serial_port_data(port);
565 struct usb_serial *serial = port->serial;
566 struct tty_struct *tty;
567 unsigned char *data = urb->transfer_buffer;
568 int retval;
569 int status = urb->status;
570 unsigned long flags;
571
572 switch (status) {
573 case 0:
574
575 break;
576 case -ECONNRESET:
577 case -ENOENT:
578 case -ESHUTDOWN:
579
580 dbg("%s - urb shutting down with status: %d",
581 __func__, status);
582 return;
583 default:
584 dbg("%s - nonzero urb status received: %d",
585 __func__, status);
586 goto exit;
587 }
588
589 if (!serial) {
590 dbg("%s - bad serial pointer, exiting", __func__);
591 return;
592 }
593
594 dbg("%s - port %d", __func__, port->number);
595 usb_serial_debug_data(debug, &port->dev, __func__,
596 urb->actual_length, data);
597
598
599
600
601 if (urb->transfer_buffer_length > 2) {
602 if (urb->actual_length) {
603 tty = tty_port_tty_get(&port->port);
604 if (tty) {
605 tty_insert_flip_string(tty, data,
606 urb->actual_length);
607 tty_flip_buffer_push(tty);
608 }
609 tty_kref_put(tty);
610 }
611 goto exit;
612 }
613
614
615
616
617
618 spin_lock_irqsave(&priv->lock, flags);
619 priv->last_msr = data[MCT_U232_MSR_INDEX];
620
621
622 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
623
624#if 0
625
626
627 priv->last_lsr = data[MCT_U232_LSR_INDEX];
628
629
630
631
632
633 if (priv->last_lsr & MCT_U232_LSR_ERR) {
634 tty = tty_port_tty_get(&port->port);
635
636 if (priv->last_lsr & MCT_U232_LSR_OE) {
637 }
638
639 if (priv->last_lsr & MCT_U232_LSR_PE) {
640 }
641
642 if (priv->last_lsr & MCT_U232_LSR_FE) {
643 }
644
645 if (priv->last_lsr & MCT_U232_LSR_BI) {
646 }
647 tty_kref_put(tty);
648 }
649#endif
650 spin_unlock_irqrestore(&priv->lock, flags);
651exit:
652 retval = usb_submit_urb(urb, GFP_ATOMIC);
653 if (retval)
654 dev_err(&port->dev,
655 "%s - usb_submit_urb failed with result %d\n",
656 __func__, retval);
657}
658
659static void mct_u232_set_termios(struct tty_struct *tty,
660 struct usb_serial_port *port,
661 struct ktermios *old_termios)
662{
663 struct usb_serial *serial = port->serial;
664 struct mct_u232_private *priv = usb_get_serial_port_data(port);
665 struct ktermios *termios = tty->termios;
666 unsigned int cflag = termios->c_cflag;
667 unsigned int old_cflag = old_termios->c_cflag;
668 unsigned long flags;
669 unsigned int control_state;
670 unsigned char last_lcr;
671
672
673 spin_lock_irqsave(&priv->lock, flags);
674 control_state = priv->control_state;
675 spin_unlock_irqrestore(&priv->lock, flags);
676 last_lcr = 0;
677
678
679
680
681
682
683
684
685
686 if ((old_cflag & CBAUD) == B0) {
687 dbg("%s: baud was B0", __func__);
688 control_state |= TIOCM_DTR | TIOCM_RTS;
689 mct_u232_set_modem_ctrl(serial, control_state);
690 }
691
692 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
693
694 if ((cflag & CBAUD) == B0) {
695 dbg("%s: baud is B0", __func__);
696
697 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
698 mct_u232_set_modem_ctrl(serial, control_state);
699 }
700
701
702
703
704
705
706 if (cflag & PARENB)
707 last_lcr |= (cflag & PARODD) ?
708 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
709 else
710 last_lcr |= MCT_U232_PARITY_NONE;
711
712
713 switch (cflag & CSIZE) {
714 case CS5:
715 last_lcr |= MCT_U232_DATA_BITS_5; break;
716 case CS6:
717 last_lcr |= MCT_U232_DATA_BITS_6; break;
718 case CS7:
719 last_lcr |= MCT_U232_DATA_BITS_7; break;
720 case CS8:
721 last_lcr |= MCT_U232_DATA_BITS_8; break;
722 default:
723 dev_err(&port->dev,
724 "CSIZE was not CS5-CS8, using default of 8\n");
725 last_lcr |= MCT_U232_DATA_BITS_8;
726 break;
727 }
728
729 termios->c_cflag &= ~CMSPAR;
730
731
732 last_lcr |= (cflag & CSTOPB) ?
733 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
734
735 mct_u232_set_line_ctrl(serial, last_lcr);
736
737
738 spin_lock_irqsave(&priv->lock, flags);
739 priv->control_state = control_state;
740 priv->last_lcr = last_lcr;
741 spin_unlock_irqrestore(&priv->lock, flags);
742}
743
744static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
745{
746 struct usb_serial_port *port = tty->driver_data;
747 struct usb_serial *serial = port->serial;
748 struct mct_u232_private *priv = usb_get_serial_port_data(port);
749 unsigned char lcr;
750 unsigned long flags;
751
752 dbg("%sstate=%d", __func__, break_state);
753
754 spin_lock_irqsave(&priv->lock, flags);
755 lcr = priv->last_lcr;
756
757 if (break_state)
758 lcr |= MCT_U232_SET_BREAK;
759 spin_unlock_irqrestore(&priv->lock, flags);
760
761 mct_u232_set_line_ctrl(serial, lcr);
762}
763
764
765static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
766{
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;
770 unsigned long flags;
771
772 dbg("%s", __func__);
773
774 spin_lock_irqsave(&priv->lock, flags);
775 control_state = priv->control_state;
776 spin_unlock_irqrestore(&priv->lock, flags);
777
778 return control_state;
779}
780
781static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
782 unsigned int set, unsigned int clear)
783{
784 struct usb_serial_port *port = tty->driver_data;
785 struct usb_serial *serial = port->serial;
786 struct mct_u232_private *priv = usb_get_serial_port_data(port);
787 unsigned int control_state;
788 unsigned long flags;
789
790 dbg("%s", __func__);
791
792 spin_lock_irqsave(&priv->lock, flags);
793 control_state = priv->control_state;
794
795 if (set & TIOCM_RTS)
796 control_state |= TIOCM_RTS;
797 if (set & TIOCM_DTR)
798 control_state |= TIOCM_DTR;
799 if (clear & TIOCM_RTS)
800 control_state &= ~TIOCM_RTS;
801 if (clear & TIOCM_DTR)
802 control_state &= ~TIOCM_DTR;
803
804 priv->control_state = control_state;
805 spin_unlock_irqrestore(&priv->lock, flags);
806 return mct_u232_set_modem_ctrl(serial, control_state);
807}
808
809static void mct_u232_throttle(struct tty_struct *tty)
810{
811 struct usb_serial_port *port = tty->driver_data;
812 struct mct_u232_private *priv = usb_get_serial_port_data(port);
813 unsigned int control_state;
814
815 dbg("%s - port %d", __func__, port->number);
816
817 spin_lock_irq(&priv->lock);
818 priv->rx_flags |= THROTTLED;
819 if (C_CRTSCTS(tty)) {
820 priv->control_state &= ~TIOCM_RTS;
821 control_state = priv->control_state;
822 spin_unlock_irq(&priv->lock);
823 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
824 } else {
825 spin_unlock_irq(&priv->lock);
826 }
827}
828
829
830static void mct_u232_unthrottle(struct tty_struct *tty)
831{
832 struct usb_serial_port *port = tty->driver_data;
833 struct mct_u232_private *priv = usb_get_serial_port_data(port);
834 unsigned int control_state;
835
836 dbg("%s - port %d", __func__, port->number);
837
838 spin_lock_irq(&priv->lock);
839 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
840 priv->rx_flags &= ~THROTTLED;
841 priv->control_state |= TIOCM_RTS;
842 control_state = priv->control_state;
843 spin_unlock_irq(&priv->lock);
844 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
845 } else {
846 spin_unlock_irq(&priv->lock);
847 }
848}
849
850static int __init mct_u232_init(void)
851{
852 int retval;
853 retval = usb_serial_register(&mct_u232_device);
854 if (retval)
855 goto failed_usb_serial_register;
856 retval = usb_register(&mct_u232_driver);
857 if (retval)
858 goto failed_usb_register;
859 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
860 DRIVER_DESC "\n");
861 return 0;
862failed_usb_register:
863 usb_serial_deregister(&mct_u232_device);
864failed_usb_serial_register:
865 return retval;
866}
867
868
869static void __exit mct_u232_exit(void)
870{
871 usb_deregister(&mct_u232_driver);
872 usb_serial_deregister(&mct_u232_device);
873}
874
875module_init(mct_u232_init);
876module_exit(mct_u232_exit);
877
878MODULE_AUTHOR(DRIVER_AUTHOR);
879MODULE_DESCRIPTION(DRIVER_DESC);
880MODULE_LICENSE("GPL");
881
882module_param(debug, bool, S_IRUGO | S_IWUSR);
883MODULE_PARM_DESC(debug, "Debug enabled or not");
884