Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / usb / serial / mct_u232.c
blob27fa9c8a77b0745b7ccae628778d1b44ba9f41a7
1 /*
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>
39 #include "mct_u232.h"
42 * Version Information
44 #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */
45 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
46 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
48 static bool debug;
51 * Function prototypes
53 static int mct_u232_startup(struct usb_serial *serial);
54 static void mct_u232_release(struct usb_serial *serial);
55 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
56 static void mct_u232_close(struct usb_serial_port *port);
57 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
58 static void mct_u232_read_int_callback(struct urb *urb);
59 static void mct_u232_set_termios(struct tty_struct *tty,
60 struct usb_serial_port *port, struct ktermios *old);
61 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
62 static int mct_u232_tiocmget(struct tty_struct *tty);
63 static int mct_u232_tiocmset(struct tty_struct *tty,
64 unsigned int set, unsigned int clear);
65 static int mct_u232_ioctl(struct tty_struct *tty,
66 unsigned int cmd, unsigned long arg);
67 static int mct_u232_get_icount(struct tty_struct *tty,
68 struct serial_icounter_struct *icount);
69 static void mct_u232_throttle(struct tty_struct *tty);
70 static void mct_u232_unthrottle(struct tty_struct *tty);
74 * All of the device info needed for the MCT USB-RS232 converter.
76 static const struct usb_device_id id_table_combined[] = {
77 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
78 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
79 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
80 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
81 { } /* Terminating entry */
84 MODULE_DEVICE_TABLE(usb, id_table_combined);
86 static struct usb_driver mct_u232_driver = {
87 .name = "mct_u232",
88 .probe = usb_serial_probe,
89 .disconnect = usb_serial_disconnect,
90 .id_table = id_table_combined,
91 .no_dynamic_id = 1,
94 static struct usb_serial_driver mct_u232_device = {
95 .driver = {
96 .owner = THIS_MODULE,
97 .name = "mct_u232",
99 .description = "MCT U232",
100 .usb_driver = &mct_u232_driver,
101 .id_table = id_table_combined,
102 .num_ports = 1,
103 .open = mct_u232_open,
104 .close = mct_u232_close,
105 .dtr_rts = mct_u232_dtr_rts,
106 .throttle = mct_u232_throttle,
107 .unthrottle = mct_u232_unthrottle,
108 .read_int_callback = mct_u232_read_int_callback,
109 .set_termios = mct_u232_set_termios,
110 .break_ctl = mct_u232_break_ctl,
111 .tiocmget = mct_u232_tiocmget,
112 .tiocmset = mct_u232_tiocmset,
113 .attach = mct_u232_startup,
114 .release = mct_u232_release,
115 .ioctl = mct_u232_ioctl,
116 .get_icount = mct_u232_get_icount,
119 struct mct_u232_private {
120 spinlock_t lock;
121 unsigned int control_state; /* Modem Line Setting (TIOCM) */
122 unsigned char last_lcr; /* Line Control Register */
123 unsigned char last_lsr; /* Line Status Register */
124 unsigned char last_msr; /* Modem Status Register */
125 unsigned int rx_flags; /* Throttling flags */
126 struct async_icount icount;
127 wait_queue_head_t msr_wait; /* for handling sleeping while waiting
128 for msr change to happen */
131 #define THROTTLED 0x01
134 * Handle vendor specific USB requests
137 #define WDR_TIMEOUT 5000 /* default urb timeout */
140 * Later day 2.6.0-test kernels have new baud rates like B230400 which
141 * we do not know how to support. We ignore them for the moment.
143 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
144 speed_t value, speed_t *result)
146 *result = value;
148 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
149 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
150 switch (value) {
151 case 300:
152 return 0x01;
153 case 600:
154 return 0x02; /* this one not tested */
155 case 1200:
156 return 0x03;
157 case 2400:
158 return 0x04;
159 case 4800:
160 return 0x06;
161 case 9600:
162 return 0x08;
163 case 19200:
164 return 0x09;
165 case 38400:
166 return 0x0a;
167 case 57600:
168 return 0x0b;
169 case 115200:
170 return 0x0c;
171 default:
172 *result = 9600;
173 return 0x08;
175 } else {
176 /* FIXME: Can we use any divider - should we do
177 divider = 115200/value;
178 real baud = 115200/divider */
179 switch (value) {
180 case 300: break;
181 case 600: break;
182 case 1200: break;
183 case 2400: break;
184 case 4800: break;
185 case 9600: break;
186 case 19200: break;
187 case 38400: break;
188 case 57600: break;
189 case 115200: break;
190 default:
191 value = 9600;
192 *result = 9600;
194 return 115200/value;
198 static int mct_u232_set_baud_rate(struct tty_struct *tty,
199 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
201 unsigned int divisor;
202 int rc;
203 unsigned char *buf;
204 unsigned char cts_enable_byte = 0;
205 speed_t speed;
207 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
208 if (buf == NULL)
209 return -ENOMEM;
211 divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
212 put_unaligned_le32(cpu_to_le32(divisor), buf);
213 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
214 MCT_U232_SET_BAUD_RATE_REQUEST,
215 MCT_U232_SET_REQUEST_TYPE,
216 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
217 WDR_TIMEOUT);
218 if (rc < 0) /*FIXME: What value speed results */
219 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
220 value, rc);
221 else
222 tty_encode_baud_rate(tty, speed, speed);
223 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
225 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
226 always sends two extra USB 'device request' messages after the
227 'baud rate change' message. The actual functionality of the
228 request codes in these messages is not fully understood but these
229 particular codes are never seen in any operation besides a baud
230 rate change. Both of these messages send a single byte of data.
231 In the first message, the value of this byte is always zero.
233 The second message has been determined experimentally to control
234 whether data will be transmitted to a device which is not asserting
235 the 'CTS' signal. If the second message's data byte is zero, data
236 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
237 flow control). if the second message's data byte is nonzero (a
238 value of 1 is used by this driver), data will not be transmitted to
239 a device which is not asserting 'CTS'.
242 buf[0] = 0;
243 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
244 MCT_U232_SET_UNKNOWN1_REQUEST,
245 MCT_U232_SET_REQUEST_TYPE,
246 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
247 WDR_TIMEOUT);
248 if (rc < 0)
249 dev_err(&port->dev, "Sending USB device request code %d "
250 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
251 rc);
253 if (port && C_CRTSCTS(tty))
254 cts_enable_byte = 1;
256 dbg("set_baud_rate: send second control message, data = %02X",
257 cts_enable_byte);
258 buf[0] = cts_enable_byte;
259 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
260 MCT_U232_SET_CTS_REQUEST,
261 MCT_U232_SET_REQUEST_TYPE,
262 0, 0, buf, MCT_U232_SET_CTS_SIZE,
263 WDR_TIMEOUT);
264 if (rc < 0)
265 dev_err(&port->dev, "Sending USB device request code %d "
266 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
268 kfree(buf);
269 return rc;
270 } /* mct_u232_set_baud_rate */
272 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
274 int rc;
275 unsigned char *buf;
277 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
278 if (buf == NULL)
279 return -ENOMEM;
281 buf[0] = lcr;
282 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
283 MCT_U232_SET_LINE_CTRL_REQUEST,
284 MCT_U232_SET_REQUEST_TYPE,
285 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
286 WDR_TIMEOUT);
287 if (rc < 0)
288 dev_err(&serial->dev->dev,
289 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
290 dbg("set_line_ctrl: 0x%x", lcr);
291 kfree(buf);
292 return rc;
293 } /* mct_u232_set_line_ctrl */
295 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
296 unsigned int control_state)
298 int rc;
299 unsigned char mcr;
300 unsigned char *buf;
302 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
303 if (buf == NULL)
304 return -ENOMEM;
306 mcr = MCT_U232_MCR_NONE;
307 if (control_state & TIOCM_DTR)
308 mcr |= MCT_U232_MCR_DTR;
309 if (control_state & TIOCM_RTS)
310 mcr |= MCT_U232_MCR_RTS;
312 buf[0] = mcr;
313 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
314 MCT_U232_SET_MODEM_CTRL_REQUEST,
315 MCT_U232_SET_REQUEST_TYPE,
316 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
317 WDR_TIMEOUT);
318 if (rc < 0)
319 dev_err(&serial->dev->dev,
320 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
321 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
323 kfree(buf);
324 return rc;
325 } /* mct_u232_set_modem_ctrl */
327 static int mct_u232_get_modem_stat(struct usb_serial *serial,
328 unsigned char *msr)
330 int rc;
331 unsigned char *buf;
333 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
334 if (buf == NULL) {
335 *msr = 0;
336 return -ENOMEM;
338 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
339 MCT_U232_GET_MODEM_STAT_REQUEST,
340 MCT_U232_GET_REQUEST_TYPE,
341 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
342 WDR_TIMEOUT);
343 if (rc < 0) {
344 dev_err(&serial->dev->dev,
345 "Get MODEM STATus failed (error = %d)\n", rc);
346 *msr = 0;
347 } else {
348 *msr = buf[0];
350 dbg("get_modem_stat: 0x%x", *msr);
351 kfree(buf);
352 return rc;
353 } /* mct_u232_get_modem_stat */
355 static void mct_u232_msr_to_icount(struct async_icount *icount,
356 unsigned char msr)
358 /* Translate Control Line states */
359 if (msr & MCT_U232_MSR_DDSR)
360 icount->dsr++;
361 if (msr & MCT_U232_MSR_DCTS)
362 icount->cts++;
363 if (msr & MCT_U232_MSR_DRI)
364 icount->rng++;
365 if (msr & MCT_U232_MSR_DCD)
366 icount->dcd++;
367 } /* mct_u232_msr_to_icount */
369 static void mct_u232_msr_to_state(unsigned int *control_state,
370 unsigned char msr)
372 /* Translate Control Line states */
373 if (msr & MCT_U232_MSR_DSR)
374 *control_state |= TIOCM_DSR;
375 else
376 *control_state &= ~TIOCM_DSR;
377 if (msr & MCT_U232_MSR_CTS)
378 *control_state |= TIOCM_CTS;
379 else
380 *control_state &= ~TIOCM_CTS;
381 if (msr & MCT_U232_MSR_RI)
382 *control_state |= TIOCM_RI;
383 else
384 *control_state &= ~TIOCM_RI;
385 if (msr & MCT_U232_MSR_CD)
386 *control_state |= TIOCM_CD;
387 else
388 *control_state &= ~TIOCM_CD;
389 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
390 } /* mct_u232_msr_to_state */
393 * Driver's tty interface functions
396 static int mct_u232_startup(struct usb_serial *serial)
398 struct mct_u232_private *priv;
399 struct usb_serial_port *port, *rport;
401 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
402 if (!priv)
403 return -ENOMEM;
404 spin_lock_init(&priv->lock);
405 init_waitqueue_head(&priv->msr_wait);
406 usb_set_serial_port_data(serial->port[0], priv);
408 init_waitqueue_head(&serial->port[0]->write_wait);
410 /* Puh, that's dirty */
411 port = serial->port[0];
412 rport = serial->port[1];
413 /* No unlinking, it wasn't submitted yet. */
414 usb_free_urb(port->read_urb);
415 port->read_urb = rport->interrupt_in_urb;
416 rport->interrupt_in_urb = NULL;
417 port->read_urb->context = port;
419 return 0;
420 } /* mct_u232_startup */
423 static void mct_u232_release(struct usb_serial *serial)
425 struct mct_u232_private *priv;
426 int i;
428 dbg("%s", __func__);
430 for (i = 0; i < serial->num_ports; ++i) {
431 /* My special items, the standard routines free my urbs */
432 priv = usb_get_serial_port_data(serial->port[i]);
433 kfree(priv);
435 } /* mct_u232_release */
437 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
439 struct usb_serial *serial = port->serial;
440 struct mct_u232_private *priv = usb_get_serial_port_data(port);
441 int retval = 0;
442 unsigned int control_state;
443 unsigned long flags;
444 unsigned char last_lcr;
445 unsigned char last_msr;
447 dbg("%s port %d", __func__, port->number);
449 /* Compensate for a hardware bug: although the Sitecom U232-P25
450 * device reports a maximum output packet size of 32 bytes,
451 * it seems to be able to accept only 16 bytes (and that's what
452 * SniffUSB says too...)
454 if (le16_to_cpu(serial->dev->descriptor.idProduct)
455 == MCT_U232_SITECOM_PID)
456 port->bulk_out_size = 16;
458 /* Do a defined restart: the normal serial device seems to
459 * always turn on DTR and RTS here, so do the same. I'm not
460 * sure if this is really necessary. But it should not harm
461 * either.
463 spin_lock_irqsave(&priv->lock, flags);
464 if (tty && (tty->termios->c_cflag & CBAUD))
465 priv->control_state = TIOCM_DTR | TIOCM_RTS;
466 else
467 priv->control_state = 0;
469 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
470 MCT_U232_PARITY_NONE |
471 MCT_U232_STOP_BITS_1);
472 control_state = priv->control_state;
473 last_lcr = priv->last_lcr;
474 spin_unlock_irqrestore(&priv->lock, flags);
475 mct_u232_set_modem_ctrl(serial, control_state);
476 mct_u232_set_line_ctrl(serial, last_lcr);
478 /* Read modem status and update control state */
479 mct_u232_get_modem_stat(serial, &last_msr);
480 spin_lock_irqsave(&priv->lock, flags);
481 priv->last_msr = last_msr;
482 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
483 spin_unlock_irqrestore(&priv->lock, flags);
485 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
486 if (retval) {
487 dev_err(&port->dev,
488 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
489 port->read_urb->pipe, retval);
490 goto error;
493 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
494 if (retval) {
495 usb_kill_urb(port->read_urb);
496 dev_err(&port->dev,
497 "usb_submit_urb(read int) failed pipe 0x%x err %d",
498 port->interrupt_in_urb->pipe, retval);
499 goto error;
501 return 0;
503 error:
504 return retval;
505 } /* mct_u232_open */
507 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
509 unsigned int control_state;
510 struct mct_u232_private *priv = usb_get_serial_port_data(port);
512 mutex_lock(&port->serial->disc_mutex);
513 if (!port->serial->disconnected) {
514 /* drop DTR and RTS */
515 spin_lock_irq(&priv->lock);
516 if (on)
517 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
518 else
519 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
520 control_state = priv->control_state;
521 spin_unlock_irq(&priv->lock);
522 mct_u232_set_modem_ctrl(port->serial, control_state);
524 mutex_unlock(&port->serial->disc_mutex);
527 static void mct_u232_close(struct usb_serial_port *port)
529 dbg("%s port %d", __func__, port->number);
531 if (port->serial->dev) {
532 /* shutdown our urbs */
533 usb_kill_urb(port->write_urb);
534 usb_kill_urb(port->read_urb);
535 usb_kill_urb(port->interrupt_in_urb);
537 } /* mct_u232_close */
540 static void mct_u232_read_int_callback(struct urb *urb)
542 struct usb_serial_port *port = urb->context;
543 struct mct_u232_private *priv = usb_get_serial_port_data(port);
544 struct usb_serial *serial = port->serial;
545 struct tty_struct *tty;
546 unsigned char *data = urb->transfer_buffer;
547 int retval;
548 int status = urb->status;
549 unsigned long flags;
551 switch (status) {
552 case 0:
553 /* success */
554 break;
555 case -ECONNRESET:
556 case -ENOENT:
557 case -ESHUTDOWN:
558 /* this urb is terminated, clean up */
559 dbg("%s - urb shutting down with status: %d",
560 __func__, status);
561 return;
562 default:
563 dbg("%s - nonzero urb status received: %d",
564 __func__, status);
565 goto exit;
568 if (!serial) {
569 dbg("%s - bad serial pointer, exiting", __func__);
570 return;
573 dbg("%s - port %d", __func__, port->number);
574 usb_serial_debug_data(debug, &port->dev, __func__,
575 urb->actual_length, data);
578 * Work-a-round: handle the 'usual' bulk-in pipe here
580 if (urb->transfer_buffer_length > 2) {
581 if (urb->actual_length) {
582 tty = tty_port_tty_get(&port->port);
583 if (tty) {
584 tty_insert_flip_string(tty, data,
585 urb->actual_length);
586 tty_flip_buffer_push(tty);
588 tty_kref_put(tty);
590 goto exit;
594 * The interrupt-in pipe signals exceptional conditions (modem line
595 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
597 spin_lock_irqsave(&priv->lock, flags);
598 priv->last_msr = data[MCT_U232_MSR_INDEX];
600 /* Record Control Line states */
601 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
603 mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
605 #if 0
606 /* Not yet handled. See belkin_sa.c for further information */
607 /* Now to report any errors */
608 priv->last_lsr = data[MCT_U232_LSR_INDEX];
610 * fill in the flip buffer here, but I do not know the relation
611 * to the current/next receive buffer or characters. I need
612 * to look in to this before committing any code.
614 if (priv->last_lsr & MCT_U232_LSR_ERR) {
615 tty = tty_port_tty_get(&port->port);
616 /* Overrun Error */
617 if (priv->last_lsr & MCT_U232_LSR_OE) {
619 /* Parity Error */
620 if (priv->last_lsr & MCT_U232_LSR_PE) {
622 /* Framing Error */
623 if (priv->last_lsr & MCT_U232_LSR_FE) {
625 /* Break Indicator */
626 if (priv->last_lsr & MCT_U232_LSR_BI) {
628 tty_kref_put(tty);
630 #endif
631 wake_up_interruptible(&priv->msr_wait);
632 spin_unlock_irqrestore(&priv->lock, flags);
633 exit:
634 retval = usb_submit_urb(urb, GFP_ATOMIC);
635 if (retval)
636 dev_err(&port->dev,
637 "%s - usb_submit_urb failed with result %d\n",
638 __func__, retval);
639 } /* mct_u232_read_int_callback */
641 static void mct_u232_set_termios(struct tty_struct *tty,
642 struct usb_serial_port *port,
643 struct ktermios *old_termios)
645 struct usb_serial *serial = port->serial;
646 struct mct_u232_private *priv = usb_get_serial_port_data(port);
647 struct ktermios *termios = tty->termios;
648 unsigned int cflag = termios->c_cflag;
649 unsigned int old_cflag = old_termios->c_cflag;
650 unsigned long flags;
651 unsigned int control_state;
652 unsigned char last_lcr;
654 /* get a local copy of the current port settings */
655 spin_lock_irqsave(&priv->lock, flags);
656 control_state = priv->control_state;
657 spin_unlock_irqrestore(&priv->lock, flags);
658 last_lcr = 0;
661 * Update baud rate.
662 * Do not attempt to cache old rates and skip settings,
663 * disconnects screw such tricks up completely.
664 * Premature optimization is the root of all evil.
667 /* reassert DTR and RTS on transition from B0 */
668 if ((old_cflag & CBAUD) == B0) {
669 dbg("%s: baud was B0", __func__);
670 control_state |= TIOCM_DTR | TIOCM_RTS;
671 mct_u232_set_modem_ctrl(serial, control_state);
674 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
676 if ((cflag & CBAUD) == B0) {
677 dbg("%s: baud is B0", __func__);
678 /* Drop RTS and DTR */
679 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
680 mct_u232_set_modem_ctrl(serial, control_state);
684 * Update line control register (LCR)
687 /* set the parity */
688 if (cflag & PARENB)
689 last_lcr |= (cflag & PARODD) ?
690 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
691 else
692 last_lcr |= MCT_U232_PARITY_NONE;
694 /* set the number of data bits */
695 switch (cflag & CSIZE) {
696 case CS5:
697 last_lcr |= MCT_U232_DATA_BITS_5; break;
698 case CS6:
699 last_lcr |= MCT_U232_DATA_BITS_6; break;
700 case CS7:
701 last_lcr |= MCT_U232_DATA_BITS_7; break;
702 case CS8:
703 last_lcr |= MCT_U232_DATA_BITS_8; break;
704 default:
705 dev_err(&port->dev,
706 "CSIZE was not CS5-CS8, using default of 8\n");
707 last_lcr |= MCT_U232_DATA_BITS_8;
708 break;
711 termios->c_cflag &= ~CMSPAR;
713 /* set the number of stop bits */
714 last_lcr |= (cflag & CSTOPB) ?
715 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
717 mct_u232_set_line_ctrl(serial, last_lcr);
719 /* save off the modified port settings */
720 spin_lock_irqsave(&priv->lock, flags);
721 priv->control_state = control_state;
722 priv->last_lcr = last_lcr;
723 spin_unlock_irqrestore(&priv->lock, flags);
724 } /* mct_u232_set_termios */
726 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
728 struct usb_serial_port *port = tty->driver_data;
729 struct usb_serial *serial = port->serial;
730 struct mct_u232_private *priv = usb_get_serial_port_data(port);
731 unsigned char lcr;
732 unsigned long flags;
734 dbg("%sstate=%d", __func__, break_state);
736 spin_lock_irqsave(&priv->lock, flags);
737 lcr = priv->last_lcr;
739 if (break_state)
740 lcr |= MCT_U232_SET_BREAK;
741 spin_unlock_irqrestore(&priv->lock, flags);
743 mct_u232_set_line_ctrl(serial, lcr);
744 } /* mct_u232_break_ctl */
747 static int mct_u232_tiocmget(struct tty_struct *tty)
749 struct usb_serial_port *port = tty->driver_data;
750 struct mct_u232_private *priv = usb_get_serial_port_data(port);
751 unsigned int control_state;
752 unsigned long flags;
754 dbg("%s", __func__);
756 spin_lock_irqsave(&priv->lock, flags);
757 control_state = priv->control_state;
758 spin_unlock_irqrestore(&priv->lock, flags);
760 return control_state;
763 static int mct_u232_tiocmset(struct tty_struct *tty,
764 unsigned int set, unsigned int clear)
766 struct usb_serial_port *port = tty->driver_data;
767 struct usb_serial *serial = port->serial;
768 struct mct_u232_private *priv = usb_get_serial_port_data(port);
769 unsigned int control_state;
770 unsigned long flags;
772 dbg("%s", __func__);
774 spin_lock_irqsave(&priv->lock, flags);
775 control_state = priv->control_state;
777 if (set & TIOCM_RTS)
778 control_state |= TIOCM_RTS;
779 if (set & TIOCM_DTR)
780 control_state |= TIOCM_DTR;
781 if (clear & TIOCM_RTS)
782 control_state &= ~TIOCM_RTS;
783 if (clear & TIOCM_DTR)
784 control_state &= ~TIOCM_DTR;
786 priv->control_state = control_state;
787 spin_unlock_irqrestore(&priv->lock, flags);
788 return mct_u232_set_modem_ctrl(serial, control_state);
791 static void mct_u232_throttle(struct tty_struct *tty)
793 struct usb_serial_port *port = tty->driver_data;
794 struct mct_u232_private *priv = usb_get_serial_port_data(port);
795 unsigned int control_state;
797 dbg("%s - port %d", __func__, port->number);
799 spin_lock_irq(&priv->lock);
800 priv->rx_flags |= THROTTLED;
801 if (C_CRTSCTS(tty)) {
802 priv->control_state &= ~TIOCM_RTS;
803 control_state = priv->control_state;
804 spin_unlock_irq(&priv->lock);
805 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
806 } else {
807 spin_unlock_irq(&priv->lock);
811 static void mct_u232_unthrottle(struct tty_struct *tty)
813 struct usb_serial_port *port = tty->driver_data;
814 struct mct_u232_private *priv = usb_get_serial_port_data(port);
815 unsigned int control_state;
817 dbg("%s - port %d", __func__, port->number);
819 spin_lock_irq(&priv->lock);
820 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
821 priv->rx_flags &= ~THROTTLED;
822 priv->control_state |= TIOCM_RTS;
823 control_state = priv->control_state;
824 spin_unlock_irq(&priv->lock);
825 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
826 } else {
827 spin_unlock_irq(&priv->lock);
831 static int mct_u232_ioctl(struct tty_struct *tty,
832 unsigned int cmd, unsigned long arg)
834 DEFINE_WAIT(wait);
835 struct usb_serial_port *port = tty->driver_data;
836 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
837 struct async_icount cnow, cprev;
838 unsigned long flags;
840 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
842 switch (cmd) {
844 case TIOCMIWAIT:
846 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
848 spin_lock_irqsave(&mct_u232_port->lock, flags);
849 cprev = mct_u232_port->icount;
850 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
851 for ( ; ; ) {
852 prepare_to_wait(&mct_u232_port->msr_wait,
853 &wait, TASK_INTERRUPTIBLE);
854 schedule();
855 finish_wait(&mct_u232_port->msr_wait, &wait);
856 /* see if a signal did it */
857 if (signal_pending(current))
858 return -ERESTARTSYS;
859 spin_lock_irqsave(&mct_u232_port->lock, flags);
860 cnow = mct_u232_port->icount;
861 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
862 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
863 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
864 return -EIO; /* no change => error */
865 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
866 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
867 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
868 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
869 return 0;
871 cprev = cnow;
875 return -ENOIOCTLCMD;
878 static int mct_u232_get_icount(struct tty_struct *tty,
879 struct serial_icounter_struct *icount)
881 struct usb_serial_port *port = tty->driver_data;
882 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
883 struct async_icount *ic = &mct_u232_port->icount;
884 unsigned long flags;
886 spin_lock_irqsave(&mct_u232_port->lock, flags);
888 icount->cts = ic->cts;
889 icount->dsr = ic->dsr;
890 icount->rng = ic->rng;
891 icount->dcd = ic->dcd;
892 icount->rx = ic->rx;
893 icount->tx = ic->tx;
894 icount->frame = ic->frame;
895 icount->overrun = ic->overrun;
896 icount->parity = ic->parity;
897 icount->brk = ic->brk;
898 icount->buf_overrun = ic->buf_overrun;
900 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
902 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
903 __func__, port->number, icount->rx, icount->tx);
904 return 0;
907 static int __init mct_u232_init(void)
909 int retval;
910 retval = usb_serial_register(&mct_u232_device);
911 if (retval)
912 goto failed_usb_serial_register;
913 retval = usb_register(&mct_u232_driver);
914 if (retval)
915 goto failed_usb_register;
916 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
917 DRIVER_DESC "\n");
918 return 0;
919 failed_usb_register:
920 usb_serial_deregister(&mct_u232_device);
921 failed_usb_serial_register:
922 return retval;
926 static void __exit mct_u232_exit(void)
928 usb_deregister(&mct_u232_driver);
929 usb_serial_deregister(&mct_u232_device);
932 module_init(mct_u232_init);
933 module_exit(mct_u232_exit);
935 MODULE_AUTHOR(DRIVER_AUTHOR);
936 MODULE_DESCRIPTION(DRIVER_DESC);
937 MODULE_LICENSE("GPL");
939 module_param(debug, bool, S_IRUGO | S_IWUSR);
940 MODULE_PARM_DESC(debug, "Debug enabled or not");