USB: omninet: fix write_room
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / mct_u232.c
blobcd009cb280a50b29d80a50610f8303a4badbd9af
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.
23 * TEST STATUS:
24 * Basic tests have been performed with minicom/zmodem transfers and
25 * modem dialing under Linux 2.4.0-test10 (for me it works fine).
27 * 04-Nov-2003 Bill Marr <marr at flex dot com>
28 * - Mimic Windows driver by sending 2 USB 'device request' messages
29 * following normal 'baud rate change' message. This allows data to be
30 * transmitted to RS-232 devices which don't assert the 'CTS' signal.
32 * 10-Nov-2001 Wolfgang Grandegger
33 * - Fixed an endianess problem with the baudrate selection for PowerPC.
35 * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
36 * - Added support for the Belkin F5U109 DB9 adaptor
38 * 30-May-2001 Greg Kroah-Hartman
39 * - switched from using spinlock to a semaphore, which fixes lots of
40 * problems.
42 * 04-May-2001 Stelian Pop
43 * - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
44 * instead of the device reported 32 (using 32 bytes causes many data
45 * loss, Windows driver uses 16 too).
47 * 02-May-2001 Stelian Pop
48 * - Fixed the baud calculation for Sitecom U232-P25 model
50 * 08-Apr-2001 gb
51 * - Identify version on module load.
53 * 06-Jan-2001 Cornel Ciocirlan
54 * - Added support for Sitecom U232-P25 model (Product Id 0x0230)
55 * - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
57 * 29-Nov-2000 Greg Kroah-Hartman
58 * - Added device id table to fit with 2.4.0-test11 structure.
59 * - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
60 * (lots of things will change if/when the usb-serial core changes to
61 * handle these issues.
63 * 27-Nov-2000 Wolfgang Grandegge
64 * A version for kernel 2.4.0-test10 released to the Linux community
65 * (via linux-usb-devel).
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 <linux/usb.h>
79 #include <linux/usb/serial.h>
80 #include "mct_u232.h"
83 * Version Information
85 #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */
86 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
87 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
89 static int debug;
92 * Function prototypes
94 static int mct_u232_startup(struct usb_serial *serial);
95 static void mct_u232_release(struct usb_serial *serial);
96 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
97 static void mct_u232_close(struct usb_serial_port *port);
98 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
99 static void mct_u232_read_int_callback(struct urb *urb);
100 static void mct_u232_set_termios(struct tty_struct *tty,
101 struct usb_serial_port *port, struct ktermios *old);
102 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
103 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file);
104 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
105 unsigned int set, unsigned int clear);
106 static void mct_u232_throttle(struct tty_struct *tty);
107 static void mct_u232_unthrottle(struct tty_struct *tty);
111 * All of the device info needed for the MCT USB-RS232 converter.
113 static struct usb_device_id id_table_combined [] = {
114 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
115 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
116 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
117 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
118 { } /* Terminating entry */
121 MODULE_DEVICE_TABLE(usb, id_table_combined);
123 static struct usb_driver mct_u232_driver = {
124 .name = "mct_u232",
125 .probe = usb_serial_probe,
126 .disconnect = usb_serial_disconnect,
127 .id_table = id_table_combined,
128 .no_dynamic_id = 1,
131 static struct usb_serial_driver mct_u232_device = {
132 .driver = {
133 .owner = THIS_MODULE,
134 .name = "mct_u232",
136 .description = "MCT U232",
137 .usb_driver = &mct_u232_driver,
138 .id_table = id_table_combined,
139 .num_ports = 1,
140 .open = mct_u232_open,
141 .close = mct_u232_close,
142 .dtr_rts = mct_u232_dtr_rts,
143 .throttle = mct_u232_throttle,
144 .unthrottle = mct_u232_unthrottle,
145 .read_int_callback = mct_u232_read_int_callback,
146 .set_termios = mct_u232_set_termios,
147 .break_ctl = mct_u232_break_ctl,
148 .tiocmget = mct_u232_tiocmget,
149 .tiocmset = mct_u232_tiocmset,
150 .attach = mct_u232_startup,
151 .release = mct_u232_release,
155 struct mct_u232_private {
156 spinlock_t lock;
157 unsigned int control_state; /* Modem Line Setting (TIOCM) */
158 unsigned char last_lcr; /* Line Control Register */
159 unsigned char last_lsr; /* Line Status Register */
160 unsigned char last_msr; /* Modem Status Register */
161 unsigned int rx_flags; /* Throttling flags */
164 #define THROTTLED 0x01
167 * Handle vendor specific USB requests
170 #define WDR_TIMEOUT 5000 /* default urb timeout */
173 * Later day 2.6.0-test kernels have new baud rates like B230400 which
174 * we do not know how to support. We ignore them for the moment.
176 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
177 speed_t value, speed_t *result)
179 *result = value;
181 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
182 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
183 switch (value) {
184 case 300:
185 return 0x01;
186 case 600:
187 return 0x02; /* this one not tested */
188 case 1200:
189 return 0x03;
190 case 2400:
191 return 0x04;
192 case 4800:
193 return 0x06;
194 case 9600:
195 return 0x08;
196 case 19200:
197 return 0x09;
198 case 38400:
199 return 0x0a;
200 case 57600:
201 return 0x0b;
202 case 115200:
203 return 0x0c;
204 default:
205 *result = 9600;
206 return 0x08;
208 } else {
209 /* FIXME: Can we use any divider - should we do
210 divider = 115200/value;
211 real baud = 115200/divider */
212 switch (value) {
213 case 300: break;
214 case 600: break;
215 case 1200: break;
216 case 2400: break;
217 case 4800: break;
218 case 9600: break;
219 case 19200: break;
220 case 38400: break;
221 case 57600: break;
222 case 115200: break;
223 default:
224 value = 9600;
225 *result = 9600;
227 return 115200/value;
231 static int mct_u232_set_baud_rate(struct tty_struct *tty,
232 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
234 __le32 divisor;
235 int rc;
236 unsigned char zero_byte = 0;
237 unsigned char cts_enable_byte = 0;
238 speed_t speed;
240 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value,
241 &speed));
243 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
244 MCT_U232_SET_BAUD_RATE_REQUEST,
245 MCT_U232_SET_REQUEST_TYPE,
246 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
247 WDR_TIMEOUT);
248 if (rc < 0) /*FIXME: What value speed results */
249 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
250 value, rc);
251 else
252 tty_encode_baud_rate(tty, speed, speed);
253 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
255 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
256 always sends two extra USB 'device request' messages after the
257 'baud rate change' message. The actual functionality of the
258 request codes in these messages is not fully understood but these
259 particular codes are never seen in any operation besides a baud
260 rate change. Both of these messages send a single byte of data.
261 In the first message, the value of this byte is always zero.
263 The second message has been determined experimentally to control
264 whether data will be transmitted to a device which is not asserting
265 the 'CTS' signal. If the second message's data byte is zero, data
266 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
267 flow control). if the second message's data byte is nonzero (a
268 value of 1 is used by this driver), data will not be transmitted to
269 a device which is not asserting 'CTS'.
272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273 MCT_U232_SET_UNKNOWN1_REQUEST,
274 MCT_U232_SET_REQUEST_TYPE,
275 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
276 WDR_TIMEOUT);
277 if (rc < 0)
278 dev_err(&port->dev, "Sending USB device request code %d "
279 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
280 rc);
282 if (port && C_CRTSCTS(tty))
283 cts_enable_byte = 1;
285 dbg("set_baud_rate: send second control message, data = %02X",
286 cts_enable_byte);
287 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
288 MCT_U232_SET_CTS_REQUEST,
289 MCT_U232_SET_REQUEST_TYPE,
290 0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
291 WDR_TIMEOUT);
292 if (rc < 0)
293 dev_err(&port->dev, "Sending USB device request code %d "
294 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
296 return rc;
297 } /* mct_u232_set_baud_rate */
299 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
301 int rc;
302 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
303 MCT_U232_SET_LINE_CTRL_REQUEST,
304 MCT_U232_SET_REQUEST_TYPE,
305 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
306 WDR_TIMEOUT);
307 if (rc < 0)
308 dev_err(&serial->dev->dev,
309 "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
310 dbg("set_line_ctrl: 0x%x", lcr);
311 return rc;
312 } /* mct_u232_set_line_ctrl */
314 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
315 unsigned int control_state)
317 int rc;
318 unsigned char mcr = MCT_U232_MCR_NONE;
320 if (control_state & TIOCM_DTR)
321 mcr |= MCT_U232_MCR_DTR;
322 if (control_state & TIOCM_RTS)
323 mcr |= MCT_U232_MCR_RTS;
325 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
326 MCT_U232_SET_MODEM_CTRL_REQUEST,
327 MCT_U232_SET_REQUEST_TYPE,
328 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
329 WDR_TIMEOUT);
330 if (rc < 0)
331 dev_err(&serial->dev->dev,
332 "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
333 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
335 return rc;
336 } /* mct_u232_set_modem_ctrl */
338 static int mct_u232_get_modem_stat(struct usb_serial *serial,
339 unsigned char *msr)
341 int rc;
342 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
343 MCT_U232_GET_MODEM_STAT_REQUEST,
344 MCT_U232_GET_REQUEST_TYPE,
345 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
346 WDR_TIMEOUT);
347 if (rc < 0) {
348 dev_err(&serial->dev->dev,
349 "Get MODEM STATus failed (error = %d)\n", rc);
350 *msr = 0;
352 dbg("get_modem_stat: 0x%x", *msr);
353 return rc;
354 } /* mct_u232_get_modem_stat */
356 static void mct_u232_msr_to_state(unsigned int *control_state,
357 unsigned char msr)
359 /* Translate Control Line states */
360 if (msr & MCT_U232_MSR_DSR)
361 *control_state |= TIOCM_DSR;
362 else
363 *control_state &= ~TIOCM_DSR;
364 if (msr & MCT_U232_MSR_CTS)
365 *control_state |= TIOCM_CTS;
366 else
367 *control_state &= ~TIOCM_CTS;
368 if (msr & MCT_U232_MSR_RI)
369 *control_state |= TIOCM_RI;
370 else
371 *control_state &= ~TIOCM_RI;
372 if (msr & MCT_U232_MSR_CD)
373 *control_state |= TIOCM_CD;
374 else
375 *control_state &= ~TIOCM_CD;
376 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
377 } /* mct_u232_msr_to_state */
380 * Driver's tty interface functions
383 static int mct_u232_startup(struct usb_serial *serial)
385 struct mct_u232_private *priv;
386 struct usb_serial_port *port, *rport;
388 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
389 if (!priv)
390 return -ENOMEM;
391 spin_lock_init(&priv->lock);
392 usb_set_serial_port_data(serial->port[0], priv);
394 init_waitqueue_head(&serial->port[0]->write_wait);
396 /* Puh, that's dirty */
397 port = serial->port[0];
398 rport = serial->port[1];
399 /* No unlinking, it wasn't submitted yet. */
400 usb_free_urb(port->read_urb);
401 port->read_urb = rport->interrupt_in_urb;
402 rport->interrupt_in_urb = NULL;
403 port->read_urb->context = port;
405 return 0;
406 } /* mct_u232_startup */
409 static void mct_u232_release(struct usb_serial *serial)
411 struct mct_u232_private *priv;
412 int i;
414 dbg("%s", __func__);
416 for (i = 0; i < serial->num_ports; ++i) {
417 /* My special items, the standard routines free my urbs */
418 priv = usb_get_serial_port_data(serial->port[i]);
419 kfree(priv);
421 } /* mct_u232_release */
423 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
425 struct usb_serial *serial = port->serial;
426 struct mct_u232_private *priv = usb_get_serial_port_data(port);
427 int retval = 0;
428 unsigned int control_state;
429 unsigned long flags;
430 unsigned char last_lcr;
431 unsigned char last_msr;
433 dbg("%s port %d", __func__, port->number);
435 /* Compensate for a hardware bug: although the Sitecom U232-P25
436 * device reports a maximum output packet size of 32 bytes,
437 * it seems to be able to accept only 16 bytes (and that's what
438 * SniffUSB says too...)
440 if (le16_to_cpu(serial->dev->descriptor.idProduct)
441 == MCT_U232_SITECOM_PID)
442 port->bulk_out_size = 16;
444 /* Do a defined restart: the normal serial device seems to
445 * always turn on DTR and RTS here, so do the same. I'm not
446 * sure if this is really necessary. But it should not harm
447 * either.
449 spin_lock_irqsave(&priv->lock, flags);
450 if (tty && (tty->termios->c_cflag & CBAUD))
451 priv->control_state = TIOCM_DTR | TIOCM_RTS;
452 else
453 priv->control_state = 0;
455 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
456 MCT_U232_PARITY_NONE |
457 MCT_U232_STOP_BITS_1);
458 control_state = priv->control_state;
459 last_lcr = priv->last_lcr;
460 spin_unlock_irqrestore(&priv->lock, flags);
461 mct_u232_set_modem_ctrl(serial, control_state);
462 mct_u232_set_line_ctrl(serial, last_lcr);
464 /* Read modem status and update control state */
465 mct_u232_get_modem_stat(serial, &last_msr);
466 spin_lock_irqsave(&priv->lock, flags);
467 priv->last_msr = last_msr;
468 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
469 spin_unlock_irqrestore(&priv->lock, flags);
471 port->read_urb->dev = port->serial->dev;
472 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
473 if (retval) {
474 dev_err(&port->dev,
475 "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n",
476 port->read_urb->pipe, retval);
477 goto error;
480 port->interrupt_in_urb->dev = port->serial->dev;
481 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
482 if (retval) {
483 usb_kill_urb(port->read_urb);
484 dev_err(&port->dev,
485 "usb_submit_urb(read int) failed pipe 0x%x err %d",
486 port->interrupt_in_urb->pipe, retval);
487 goto error;
489 return 0;
491 error:
492 return retval;
493 } /* mct_u232_open */
495 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
497 unsigned int control_state;
498 struct mct_u232_private *priv = usb_get_serial_port_data(port);
500 mutex_lock(&port->serial->disc_mutex);
501 if (!port->serial->disconnected) {
502 /* drop DTR and RTS */
503 spin_lock_irq(&priv->lock);
504 if (on)
505 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
506 else
507 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
508 control_state = priv->control_state;
509 spin_unlock_irq(&priv->lock);
510 mct_u232_set_modem_ctrl(port->serial, control_state);
512 mutex_unlock(&port->serial->disc_mutex);
515 static void mct_u232_close(struct usb_serial_port *port)
517 dbg("%s port %d", __func__, port->number);
519 if (port->serial->dev) {
520 /* shutdown our urbs */
521 usb_kill_urb(port->write_urb);
522 usb_kill_urb(port->read_urb);
523 usb_kill_urb(port->interrupt_in_urb);
525 } /* mct_u232_close */
528 static void mct_u232_read_int_callback(struct urb *urb)
530 struct usb_serial_port *port = urb->context;
531 struct mct_u232_private *priv = usb_get_serial_port_data(port);
532 struct usb_serial *serial = port->serial;
533 struct tty_struct *tty;
534 unsigned char *data = urb->transfer_buffer;
535 int retval;
536 int status = urb->status;
537 unsigned long flags;
539 switch (status) {
540 case 0:
541 /* success */
542 break;
543 case -ECONNRESET:
544 case -ENOENT:
545 case -ESHUTDOWN:
546 /* this urb is terminated, clean up */
547 dbg("%s - urb shutting down with status: %d",
548 __func__, status);
549 return;
550 default:
551 dbg("%s - nonzero urb status received: %d",
552 __func__, status);
553 goto exit;
556 if (!serial) {
557 dbg("%s - bad serial pointer, exiting", __func__);
558 return;
561 dbg("%s - port %d", __func__, port->number);
562 usb_serial_debug_data(debug, &port->dev, __func__,
563 urb->actual_length, data);
566 * Work-a-round: handle the 'usual' bulk-in pipe here
568 if (urb->transfer_buffer_length > 2) {
569 if (urb->actual_length) {
570 tty = tty_port_tty_get(&port->port);
571 if (tty) {
572 tty_insert_flip_string(tty, data,
573 urb->actual_length);
574 tty_flip_buffer_push(tty);
576 tty_kref_put(tty);
578 goto exit;
582 * The interrupt-in pipe signals exceptional conditions (modem line
583 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
585 spin_lock_irqsave(&priv->lock, flags);
586 priv->last_msr = data[MCT_U232_MSR_INDEX];
588 /* Record Control Line states */
589 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
591 #if 0
592 /* Not yet handled. See belkin_sa.c for further information */
593 /* Now to report any errors */
594 priv->last_lsr = data[MCT_U232_LSR_INDEX];
596 * fill in the flip buffer here, but I do not know the relation
597 * to the current/next receive buffer or characters. I need
598 * to look in to this before committing any code.
600 if (priv->last_lsr & MCT_U232_LSR_ERR) {
601 tty = tty_port_tty_get(&port->port);
602 /* Overrun Error */
603 if (priv->last_lsr & MCT_U232_LSR_OE) {
605 /* Parity Error */
606 if (priv->last_lsr & MCT_U232_LSR_PE) {
608 /* Framing Error */
609 if (priv->last_lsr & MCT_U232_LSR_FE) {
611 /* Break Indicator */
612 if (priv->last_lsr & MCT_U232_LSR_BI) {
614 tty_kref_put(tty);
616 #endif
617 spin_unlock_irqrestore(&priv->lock, flags);
618 exit:
619 retval = usb_submit_urb(urb, GFP_ATOMIC);
620 if (retval)
621 dev_err(&port->dev,
622 "%s - usb_submit_urb failed with result %d\n",
623 __func__, retval);
624 } /* mct_u232_read_int_callback */
626 static void mct_u232_set_termios(struct tty_struct *tty,
627 struct usb_serial_port *port,
628 struct ktermios *old_termios)
630 struct usb_serial *serial = port->serial;
631 struct mct_u232_private *priv = usb_get_serial_port_data(port);
632 struct ktermios *termios = tty->termios;
633 unsigned int cflag = termios->c_cflag;
634 unsigned int old_cflag = old_termios->c_cflag;
635 unsigned long flags;
636 unsigned int control_state;
637 unsigned char last_lcr;
639 /* get a local copy of the current port settings */
640 spin_lock_irqsave(&priv->lock, flags);
641 control_state = priv->control_state;
642 spin_unlock_irqrestore(&priv->lock, flags);
643 last_lcr = 0;
646 * Update baud rate.
647 * Do not attempt to cache old rates and skip settings,
648 * disconnects screw such tricks up completely.
649 * Premature optimization is the root of all evil.
652 /* reassert DTR and RTS on transition from B0 */
653 if ((old_cflag & CBAUD) == B0) {
654 dbg("%s: baud was B0", __func__);
655 control_state |= TIOCM_DTR | TIOCM_RTS;
656 mct_u232_set_modem_ctrl(serial, control_state);
659 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
661 if ((cflag & CBAUD) == B0) {
662 dbg("%s: baud is B0", __func__);
663 /* Drop RTS and DTR */
664 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
665 mct_u232_set_modem_ctrl(serial, control_state);
669 * Update line control register (LCR)
672 /* set the parity */
673 if (cflag & PARENB)
674 last_lcr |= (cflag & PARODD) ?
675 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
676 else
677 last_lcr |= MCT_U232_PARITY_NONE;
679 /* set the number of data bits */
680 switch (cflag & CSIZE) {
681 case CS5:
682 last_lcr |= MCT_U232_DATA_BITS_5; break;
683 case CS6:
684 last_lcr |= MCT_U232_DATA_BITS_6; break;
685 case CS7:
686 last_lcr |= MCT_U232_DATA_BITS_7; break;
687 case CS8:
688 last_lcr |= MCT_U232_DATA_BITS_8; break;
689 default:
690 dev_err(&port->dev,
691 "CSIZE was not CS5-CS8, using default of 8\n");
692 last_lcr |= MCT_U232_DATA_BITS_8;
693 break;
696 termios->c_cflag &= ~CMSPAR;
698 /* set the number of stop bits */
699 last_lcr |= (cflag & CSTOPB) ?
700 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
702 mct_u232_set_line_ctrl(serial, last_lcr);
704 /* save off the modified port settings */
705 spin_lock_irqsave(&priv->lock, flags);
706 priv->control_state = control_state;
707 priv->last_lcr = last_lcr;
708 spin_unlock_irqrestore(&priv->lock, flags);
709 } /* mct_u232_set_termios */
711 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
713 struct usb_serial_port *port = tty->driver_data;
714 struct usb_serial *serial = port->serial;
715 struct mct_u232_private *priv = usb_get_serial_port_data(port);
716 unsigned char lcr;
717 unsigned long flags;
719 dbg("%sstate=%d", __func__, break_state);
721 spin_lock_irqsave(&priv->lock, flags);
722 lcr = priv->last_lcr;
724 if (break_state)
725 lcr |= MCT_U232_SET_BREAK;
726 spin_unlock_irqrestore(&priv->lock, flags);
728 mct_u232_set_line_ctrl(serial, lcr);
729 } /* mct_u232_break_ctl */
732 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
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;
737 unsigned long flags;
739 dbg("%s", __func__);
741 spin_lock_irqsave(&priv->lock, flags);
742 control_state = priv->control_state;
743 spin_unlock_irqrestore(&priv->lock, flags);
745 return control_state;
748 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
749 unsigned int set, unsigned int clear)
751 struct usb_serial_port *port = tty->driver_data;
752 struct usb_serial *serial = port->serial;
753 struct mct_u232_private *priv = usb_get_serial_port_data(port);
754 unsigned int control_state;
755 unsigned long flags;
757 dbg("%s", __func__);
759 spin_lock_irqsave(&priv->lock, flags);
760 control_state = priv->control_state;
762 if (set & TIOCM_RTS)
763 control_state |= TIOCM_RTS;
764 if (set & TIOCM_DTR)
765 control_state |= TIOCM_DTR;
766 if (clear & TIOCM_RTS)
767 control_state &= ~TIOCM_RTS;
768 if (clear & TIOCM_DTR)
769 control_state &= ~TIOCM_DTR;
771 priv->control_state = control_state;
772 spin_unlock_irqrestore(&priv->lock, flags);
773 return mct_u232_set_modem_ctrl(serial, control_state);
776 static void mct_u232_throttle(struct tty_struct *tty)
778 struct usb_serial_port *port = tty->driver_data;
779 struct mct_u232_private *priv = usb_get_serial_port_data(port);
780 unsigned int control_state;
782 dbg("%s - port %d", __func__, port->number);
784 spin_lock_irq(&priv->lock);
785 priv->rx_flags |= THROTTLED;
786 if (C_CRTSCTS(tty)) {
787 priv->control_state &= ~TIOCM_RTS;
788 control_state = priv->control_state;
789 spin_unlock_irq(&priv->lock);
790 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
791 } else {
792 spin_unlock_irq(&priv->lock);
797 static void mct_u232_unthrottle(struct tty_struct *tty)
799 struct usb_serial_port *port = tty->driver_data;
800 struct mct_u232_private *priv = usb_get_serial_port_data(port);
801 unsigned int control_state;
803 dbg("%s - port %d", __func__, port->number);
805 spin_lock_irq(&priv->lock);
806 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
807 priv->rx_flags &= ~THROTTLED;
808 priv->control_state |= TIOCM_RTS;
809 control_state = priv->control_state;
810 spin_unlock_irq(&priv->lock);
811 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
812 } else {
813 spin_unlock_irq(&priv->lock);
817 static int __init mct_u232_init(void)
819 int retval;
820 retval = usb_serial_register(&mct_u232_device);
821 if (retval)
822 goto failed_usb_serial_register;
823 retval = usb_register(&mct_u232_driver);
824 if (retval)
825 goto failed_usb_register;
826 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
827 DRIVER_DESC "\n");
828 return 0;
829 failed_usb_register:
830 usb_serial_deregister(&mct_u232_device);
831 failed_usb_serial_register:
832 return retval;
836 static void __exit mct_u232_exit(void)
838 usb_deregister(&mct_u232_driver);
839 usb_serial_deregister(&mct_u232_device);
842 module_init(mct_u232_init);
843 module_exit(mct_u232_exit);
845 MODULE_AUTHOR(DRIVER_AUTHOR);
846 MODULE_DESCRIPTION(DRIVER_DESC);
847 MODULE_LICENSE("GPL");
849 module_param(debug, bool, S_IRUGO | S_IWUSR);
850 MODULE_PARM_DESC(debug, "Debug enabled or not");