1 /*
2 * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
3 *
4 * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
5 *
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.
10 *
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.
14 *
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.
17 *
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.
22 *
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).
26 *
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.
31 *
32 * 10-Nov-2001 Wolfgang Grandegger
33 * - Fixed an endianess problem with the baudrate selection for PowerPC.
34 *
35 * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
36 * Added support for the Belkin F5U109 DB9 adaptor
37 *
38 * 30-May-2001 Greg Kroah-Hartman
39 * switched from using spinlock to a semaphore, which fixes lots of problems.
40 *
41 * 04-May-2001 Stelian Pop
42 * - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
43 * instead of the device reported 32 (using 32 bytes causes many data
44 * loss, Windows driver uses 16 too).
45 *
46 * 02-May-2001 Stelian Pop
47 * - Fixed the baud calculation for Sitecom U232-P25 model
48 *
49 * 08-Apr-2001 gb
50 * - Identify version on module load.
51 *
52 * 06-Jan-2001 Cornel Ciocirlan
53 * - Added support for Sitecom U232-P25 model (Product Id 0x0230)
54 * - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
55 *
56 * 29-Nov-2000 Greg Kroah-Hartman
57 * - Added device id table to fit with 2.4.0-test11 structure.
58 * - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
59 * (lots of things will change if/when the usb-serial core changes to
60 * handle these issues.
61 *
62 * 27-Nov-2000 Wolfgang Grandegger
63 * A version for kernel 2.4.0-test10 released to the Linux community
64 * (via linux-usb-devel).
65 */
66
67 #include <linux/kernel.h>
68 #include <linux/errno.h>
69 #include <linux/init.h>
70 #include <linux/slab.h>
71 #include <linux/tty.h>
72 #include <linux/tty_driver.h>
73 #include <linux/tty_flip.h>
74 #include <linux/module.h>
75 #include <linux/spinlock.h>
76 #include <asm/uaccess.h>
77 #include <linux/usb.h>
78 #include <linux/usb/serial.h>
79 #include "mct_u232.h"
80
81 /*
82 * Version Information
83 */
84 #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */
85 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
86 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
87
88 static int debug;
89
90 /*
91 * Function prototypes
92 */
93 static int mct_u232_startup (struct usb_serial *serial);
94 static void mct_u232_shutdown (struct usb_serial *serial);
95 static int mct_u232_open (struct usb_serial_port *port,
96 struct file *filp);
97 static void mct_u232_close (struct usb_serial_port *port,
98 struct file *filp);
99 static void mct_u232_read_int_callback (struct urb *urb);
100 static void mct_u232_set_termios (struct usb_serial_port *port,
101 struct ktermios * old);
102 static int mct_u232_ioctl (struct usb_serial_port *port,
103 struct file * file,
104 unsigned int cmd,
105 unsigned long arg);
106 static void mct_u232_break_ctl (struct usb_serial_port *port,
107 int break_state );
108 static int mct_u232_tiocmget (struct usb_serial_port *port,
109 struct file *file);
110 static int mct_u232_tiocmset (struct usb_serial_port *port,
111 struct file *file, unsigned int set,
112 unsigned int clear);
113 static void mct_u232_throttle (struct usb_serial_port *port);
114 static void mct_u232_unthrottle (struct usb_serial_port *port);
115
116
117 /*
118 * All of the device info needed for the MCT USB-RS232 converter.
119 */
120 static struct usb_device_id id_table_combined [] = {
121 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
122 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
123 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
124 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
125 { } /* Terminating entry */
126 };
127
128 MODULE_DEVICE_TABLE (usb, id_table_combined);
129
130 static struct usb_driver mct_u232_driver = {
131 .name = "mct_u232",
132 .probe = usb_serial_probe,
133 .disconnect = usb_serial_disconnect,
134 .id_table = id_table_combined,
135 .no_dynamic_id = 1,
136 };
137
138 static struct usb_serial_driver mct_u232_device = {
139 .driver = {
140 .owner = THIS_MODULE,
141 .name = "mct_u232",
142 },
143 .description = "MCT U232",
144 .usb_driver = &mct_u232_driver,
145 .id_table = id_table_combined,
146 .num_interrupt_in = 2,
147 .num_bulk_in = 0,
148 .num_bulk_out = 1,
149 .num_ports = 1,
150 .open = mct_u232_open,
151 .close = mct_u232_close,
152 .throttle = mct_u232_throttle,
153 .unthrottle = mct_u232_unthrottle,
154 .read_int_callback = mct_u232_read_int_callback,
155 .ioctl = mct_u232_ioctl,
156 .set_termios = mct_u232_set_termios,
157 .break_ctl = mct_u232_break_ctl,
158 .tiocmget = mct_u232_tiocmget,
159 .tiocmset = mct_u232_tiocmset,
160 .attach = mct_u232_startup,
161 .shutdown = mct_u232_shutdown,
162 };
163
164
165 struct mct_u232_private {
166 spinlock_t lock;
167 unsigned int control_state; /* Modem Line Setting (TIOCM) */
168 unsigned char last_lcr; /* Line Control Register */
169 unsigned char last_lsr; /* Line Status Register */
170 unsigned char last_msr; /* Modem Status Register */
171 unsigned int rx_flags; /* Throttling flags */
172 };
173
174 #define THROTTLED 0x01
175
176 /*
177 * Handle vendor specific USB requests
178 */
179
180 #define WDR_TIMEOUT 5000 /* default urb timeout */
181
182 /*
183 * Later day 2.6.0-test kernels have new baud rates like B230400 which
184 * we do not know how to support. We ignore them for the moment.
185 */
186 static int mct_u232_calculate_baud_rate(struct usb_serial *serial, speed_t value, speed_t *result)
187 {
188 *result = value;
189
190 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
191 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
192 switch (value) {
193 case 300: return 0x01;
194 case 600: return 0x02; /* this one not tested */
195 case 1200: return 0x03;
196 case 2400: return 0x04;
197 case 4800: return 0x06;
198 case 9600: return 0x08;
199 case 19200: return 0x09;
200 case 38400: return 0x0a;
201 case 57600: return 0x0b;
202 case 115200: return 0x0c;
203 default:
204 *result = 9600;
205 return 0x08;
206 }
207 } else {
208 /* FIXME: Can we use any divider - should we do
209 divider = 115200/value;
210 real baud = 115200/divider */
211 switch (value) {
212 case 300: break;
213 case 600: break;
214 case 1200: break;
215 case 2400: break;
216 case 4800: break;
217 case 9600: break;
218 case 19200: break;
219 case 38400: break;
220 case 57600: break;
221 case 115200: break;
222 default:
223 value = 9600;
224 *result = 9600;
225 }
226 return 115200/value;
227 }
228 }
229
230 static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_port *port,
231 speed_t value)
232 {
233 __le32 divisor;
234 int rc;
235 unsigned char zero_byte = 0;
236 unsigned char cts_enable_byte = 0;
237 speed_t speed;
238
239 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value, &speed));
240
241 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
242 MCT_U232_SET_BAUD_RATE_REQUEST,
243 MCT_U232_SET_REQUEST_TYPE,
244 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
245 WDR_TIMEOUT);
246 if (rc < 0) /*FIXME: What value speed results */
247 err("Set BAUD RATE %d failed (error = %d)", value, rc);
248 else
249 tty_encode_baud_rate(port->tty, speed, speed);
250 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
251
252 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
253 always sends two extra USB 'device request' messages after the
254 'baud rate change' message. The actual functionality of the
255 request codes in these messages is not fully understood but these
256 particular codes are never seen in any operation besides a baud
257 rate change. Both of these messages send a single byte of data.
258 In the first message, the value of this byte is always zero.
259
260 The second message has been determined experimentally to control
261 whether data will be transmitted to a device which is not asserting
262 the 'CTS' signal. If the second message's data byte is zero, data
263 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
264 flow control). if the second message's data byte is nonzero (a value
265 of 1 is used by this driver), data will not be transmitted to a device
266 which is not asserting 'CTS'.
267 */
268
269 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
270 MCT_U232_SET_UNKNOWN1_REQUEST,
271 MCT_U232_SET_REQUEST_TYPE,
272 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
273 WDR_TIMEOUT);
274 if (rc < 0)
275 err("Sending USB device request code %d failed (error = %d)",
276 MCT_U232_SET_UNKNOWN1_REQUEST, rc);
277
278 if (port && C_CRTSCTS(port->tty)) {
279 cts_enable_byte = 1;
280 }
281
282 dbg("set_baud_rate: send second control message, data = %02X", cts_enable_byte);
283 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
284 MCT_U232_SET_CTS_REQUEST,
285 MCT_U232_SET_REQUEST_TYPE,
286 0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
287 WDR_TIMEOUT);
288 if (rc < 0)
289 err("Sending USB device request code %d failed (error = %d)",
290 MCT_U232_SET_CTS_REQUEST, rc);
291
292 return rc;
293 } /* mct_u232_set_baud_rate */
294
295 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
296 {
297 int rc;
298 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
299 MCT_U232_SET_LINE_CTRL_REQUEST,
300 MCT_U232_SET_REQUEST_TYPE,
301 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
302 WDR_TIMEOUT);
303 if (rc < 0)
304 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
305 dbg("set_line_ctrl: 0x%x", lcr);
306 return rc;
307 } /* mct_u232_set_line_ctrl */
308
309 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
310 unsigned int control_state)
311 {
312 int rc;
313 unsigned char mcr = MCT_U232_MCR_NONE;
314
315 if (control_state & TIOCM_DTR)
316 mcr |= MCT_U232_MCR_DTR;
317 if (control_state & TIOCM_RTS)
318 mcr |= MCT_U232_MCR_RTS;
319
320 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
321 MCT_U232_SET_MODEM_CTRL_REQUEST,
322 MCT_U232_SET_REQUEST_TYPE,
323 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
324 WDR_TIMEOUT);
325 if (rc < 0)
326 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
327 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
328
329 return rc;
330 } /* mct_u232_set_modem_ctrl */
331
332 static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
333 {
334 int rc;
335 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
336 MCT_U232_GET_MODEM_STAT_REQUEST,
337 MCT_U232_GET_REQUEST_TYPE,
338 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
339 WDR_TIMEOUT);
340 if (rc < 0) {
341 err("Get MODEM STATus failed (error = %d)", rc);
342 *msr = 0;
343 }
344 dbg("get_modem_stat: 0x%x", *msr);
345 return rc;
346 } /* mct_u232_get_modem_stat */
347
348 static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr)
349 {
350 /* Translate Control Line states */
351 if (msr & MCT_U232_MSR_DSR)
352 *control_state |= TIOCM_DSR;
353 else
354 *control_state &= ~TIOCM_DSR;
355 if (msr & MCT_U232_MSR_CTS)
356 *control_state |= TIOCM_CTS;
357 else
358 *control_state &= ~TIOCM_CTS;
359 if (msr & MCT_U232_MSR_RI)
360 *control_state |= TIOCM_RI;
361 else
362 *control_state &= ~TIOCM_RI;
363 if (msr & MCT_U232_MSR_CD)
364 *control_state |= TIOCM_CD;
365 else
366 *control_state &= ~TIOCM_CD;
367 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
368 } /* mct_u232_msr_to_state */
369
370 /*
371 * Driver's tty interface functions
372 */
373
374 static int mct_u232_startup (struct usb_serial *serial)
375 {
376 struct mct_u232_private *priv;
377 struct usb_serial_port *port, *rport;
378
379 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
380 if (!priv)
381 return -ENOMEM;
382 spin_lock_init(&priv->lock);
383 usb_set_serial_port_data(serial->port[0], priv);
384
385 init_waitqueue_head(&serial->port[0]->write_wait);
386
387 /* Puh, that's dirty */
388 port = serial->port[0];
389 rport = serial->port[1];
390 /* No unlinking, it wasn't submitted yet. */
391 usb_free_urb(port->read_urb);
392 port->read_urb = rport->interrupt_in_urb;
393 rport->interrupt_in_urb = NULL;
394 port->read_urb->context = port;
395
396 return (0);
397 } /* mct_u232_startup */
398
399
400 static void mct_u232_shutdown (struct usb_serial *serial)
401 {
402 struct mct_u232_private *priv;
403 int i;
404
405 dbg("%s", __FUNCTION__);
406
407 for (i=0; i < serial->num_ports; ++i) {
408 /* My special items, the standard routines free my urbs */
409 priv = usb_get_serial_port_data(serial->port[i]);
410 if (priv) {
411 usb_set_serial_port_data(serial->port[i], NULL);
412 kfree(priv);
413 }
414 }
415 } /* mct_u232_shutdown */
416
417 static int mct_u232_open (struct usb_serial_port *port, struct file *filp)
418 {
419 struct usb_serial *serial = port->serial;
420 struct mct_u232_private *priv = usb_get_serial_port_data(port);
421 int retval = 0;
422 unsigned int control_state;
423 unsigned long flags;
424 unsigned char last_lcr;
425 unsigned char last_msr;
426
427 dbg("%s port %d", __FUNCTION__, port->number);
428
429 /* Compensate for a hardware bug: although the Sitecom U232-P25
430 * device reports a maximum output packet size of 32 bytes,
431 * it seems to be able to accept only 16 bytes (and that's what
432 * SniffUSB says too...)
433 */
434 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
435 port->bulk_out_size = 16;
436
437 /* Do a defined restart: the normal serial device seems to
438 * always turn on DTR and RTS here, so do the same. I'm not
439 * sure if this is really necessary. But it should not harm
440 * either.
441 */
442 spin_lock_irqsave(&priv->lock, flags);
443 if (port->tty->termios->c_cflag & CBAUD)
444 priv->control_state = TIOCM_DTR | TIOCM_RTS;
445 else
446 priv->control_state = 0;
447
448 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
449 MCT_U232_PARITY_NONE |
450 MCT_U232_STOP_BITS_1);
451 control_state = priv->control_state;
452 last_lcr = priv->last_lcr;
453 spin_unlock_irqrestore(&priv->lock, flags);
454 mct_u232_set_modem_ctrl(serial, control_state);
455 mct_u232_set_line_ctrl(serial, last_lcr);
456
457 /* Read modem status and update control state */
458 mct_u232_get_modem_stat(serial, &last_msr);
459 spin_lock_irqsave(&priv->lock, flags);
460 priv->last_msr = last_msr;
461 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
462 spin_unlock_irqrestore(&priv->lock, flags);
463
464 port->read_urb->dev = port->serial->dev;
465 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
466 if (retval) {
467 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
468 port->read_urb->pipe, retval);
469 goto error;
470 }
471
472 port->interrupt_in_urb->dev = port->serial->dev;
473 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
474 if (retval) {
475 usb_kill_urb(port->read_urb);
476 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
477 port->interrupt_in_urb->pipe, retval);
478 goto error;
479 }
480 return 0;
481
482 error:
483 return retval;
484 } /* mct_u232_open */
485
486
487 static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
488 {
489 unsigned int c_cflag;
490 unsigned int control_state;
491 struct mct_u232_private *priv = usb_get_serial_port_data(port);
492 dbg("%s port %d", __FUNCTION__, port->number);
493
494 if (port->tty) {
495 c_cflag = port->tty->termios->c_cflag;
496 mutex_lock(&port->serial->disc_mutex);
497 if (c_cflag & HUPCL && !port->serial->disconnected) {
498 /* drop DTR and RTS */
499 spin_lock_irq(&priv->lock);
500 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
501 control_state = priv->control_state;
502 spin_unlock_irq(&priv->lock);
503 mct_u232_set_modem_ctrl(port->serial, control_state);
504 }
505 mutex_unlock(&port->serial->disc_mutex);
506 }
507
508
509 if (port->serial->dev) {
510 /* shutdown our urbs */
511 usb_kill_urb(port->write_urb);
512 usb_kill_urb(port->read_urb);
513 usb_kill_urb(port->interrupt_in_urb);
514 }
515 } /* mct_u232_close */
516
517
518 static void mct_u232_read_int_callback (struct urb *urb)
519 {
520 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
521 struct mct_u232_private *priv = usb_get_serial_port_data(port);
522 struct usb_serial *serial = port->serial;
523 struct tty_struct *tty;
524 unsigned char *data = urb->transfer_buffer;
525 int retval;
526 int status = urb->status;
527 unsigned long flags;
528
529 switch (status) {
530 case 0:
531 /* success */
532 break;
533 case -ECONNRESET:
534 case -ENOENT:
535 case -ESHUTDOWN:
536 /* this urb is terminated, clean up */
537 dbg("%s - urb shutting down with status: %d",
538 __FUNCTION__, status);
539 return;
540 default:
541 dbg("%s - nonzero urb status received: %d",
542 __FUNCTION__, status);
543 goto exit;
544 }
545
546 if (!serial) {
547 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
548 return;
549 }
550
551 dbg("%s - port %d", __FUNCTION__, port->number);
552 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
553
554 /*
555 * Work-a-round: handle the 'usual' bulk-in pipe here
556 */
557 if (urb->transfer_buffer_length > 2) {
558 int i;
559 tty = port->tty;
560 if (urb->actual_length) {
561 for (i = 0; i < urb->actual_length ; ++i) {
562 tty_insert_flip_char(tty, data[i], 0);
563 }
564 tty_flip_buffer_push(tty);
565 }
566 goto exit;
567 }
568
569 /*
570 * The interrupt-in pipe signals exceptional conditions (modem line
571 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
572 */
573 spin_lock_irqsave(&priv->lock, flags);
574 priv->last_msr = data[MCT_U232_MSR_INDEX];
575
576 /* Record Control Line states */
577 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
578
579 #if 0
580 /* Not yet handled. See belin_sa.c for further information */
581 /* Now to report any errors */
582 priv->last_lsr = data[MCT_U232_LSR_INDEX];
583 /*
584 * fill in the flip buffer here, but I do not know the relation
585 * to the current/next receive buffer or characters. I need
586 * to look in to this before committing any code.
587 */
588 if (priv->last_lsr & MCT_U232_LSR_ERR) {
589 tty = port->tty;
590 /* Overrun Error */
591 if (priv->last_lsr & MCT_U232_LSR_OE) {
592 }
593 /* Parity Error */
594 if (priv->last_lsr & MCT_U232_LSR_PE) {
595 }
596 /* Framing Error */
597 if (priv->last_lsr & MCT_U232_LSR_FE) {
598 }
599 /* Break Indicator */
600 if (priv->last_lsr & MCT_U232_LSR_BI) {
601 }
602 }
603 #endif
604 spin_unlock_irqrestore(&priv->lock, flags);
605 exit:
606 retval = usb_submit_urb (urb, GFP_ATOMIC);
607 if (retval)
608 err ("%s - usb_submit_urb failed with result %d",
609 __FUNCTION__, retval);
610 } /* mct_u232_read_int_callback */
611
612 static void mct_u232_set_termios (struct usb_serial_port *port,
613 struct ktermios *old_termios)
614 {
615 struct usb_serial *serial = port->serial;
616 struct mct_u232_private *priv = usb_get_serial_port_data(port);
617 struct ktermios *termios = port->tty->termios;
618 unsigned int cflag = termios->c_cflag;
619 unsigned int old_cflag = old_termios->c_cflag;
620 unsigned long flags;
621 unsigned int control_state;
622 unsigned char last_lcr;
623
624 /* get a local copy of the current port settings */
625 spin_lock_irqsave(&priv->lock, flags);
626 control_state = priv->control_state;
627 spin_unlock_irqrestore(&priv->lock, flags);
628 last_lcr = 0;
629
630 /*
631 * Update baud rate.
632 * Do not attempt to cache old rates and skip settings,
633 * disconnects screw such tricks up completely.
634 * Premature optimization is the root of all evil.
635 */
636
637 /* reassert DTR and RTS on transition from B0 */
638 if ((old_cflag & CBAUD) == B0) {
639 dbg("%s: baud was B0", __FUNCTION__);
640 control_state |= TIOCM_DTR | TIOCM_RTS;
641 mct_u232_set_modem_ctrl(serial, control_state);
642 }
643
644 mct_u232_set_baud_rate(serial, port, tty_get_baud_rate(port->tty));
645
646 if ((cflag & CBAUD) == B0 ) {
647 dbg("%s: baud is B0", __FUNCTION__);
648 /* Drop RTS and DTR */
649 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
650 mct_u232_set_modem_ctrl(serial, control_state);
651 }
652
653 /*
654 * Update line control register (LCR)
655 */
656
657 /* set the parity */
658 if (cflag & PARENB)
659 last_lcr |= (cflag & PARODD) ?
660 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
661 else
662 last_lcr |= MCT_U232_PARITY_NONE;
663
664 /* set the number of data bits */
665 switch (cflag & CSIZE) {
666 case CS5:
667 last_lcr |= MCT_U232_DATA_BITS_5; break;
668 case CS6:
669 last_lcr |= MCT_U232_DATA_BITS_6; break;
670 case CS7:
671 last_lcr |= MCT_U232_DATA_BITS_7; break;
672 case CS8:
673 last_lcr |= MCT_U232_DATA_BITS_8; break;
674 default:
675 err("CSIZE was not CS5-CS8, using default of 8");
676 last_lcr |= MCT_U232_DATA_BITS_8;
677 break;
678 }
679
680 termios->c_cflag &= ~CMSPAR;
681
682 /* set the number of stop bits */
683 last_lcr |= (cflag & CSTOPB) ?
684 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
685
686 mct_u232_set_line_ctrl(serial, last_lcr);
687
688 /* save off the modified port settings */
689 spin_lock_irqsave(&priv->lock, flags);
690 priv->control_state = control_state;
691 priv->last_lcr = last_lcr;
692 spin_unlock_irqrestore(&priv->lock, flags);
693 } /* mct_u232_set_termios */
694
695 static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
696 {
697 struct usb_serial *serial = port->serial;
698 struct mct_u232_private *priv = usb_get_serial_port_data(port);
699 unsigned char lcr;
700 unsigned long flags;
701
702 dbg("%sstate=%d", __FUNCTION__, break_state);
703
704 spin_lock_irqsave(&priv->lock, flags);
705 lcr = priv->last_lcr;
706 spin_unlock_irqrestore(&priv->lock, flags);
707
708 if (break_state)
709 lcr |= MCT_U232_SET_BREAK;
710
711 mct_u232_set_line_ctrl(serial, lcr);
712 } /* mct_u232_break_ctl */
713
714
715 static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
716 {
717 struct mct_u232_private *priv = usb_get_serial_port_data(port);
718 unsigned int control_state;
719 unsigned long flags;
720
721 dbg("%s", __FUNCTION__);
722
723 spin_lock_irqsave(&priv->lock, flags);
724 control_state = priv->control_state;
725 spin_unlock_irqrestore(&priv->lock, flags);
726
727 return control_state;
728 }
729
730 static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
731 unsigned int set, unsigned int clear)
732 {
733 struct usb_serial *serial = port->serial;
734 struct mct_u232_private *priv = usb_get_serial_port_data(port);
735 unsigned int control_state;
736 unsigned long flags;
737
738 dbg("%s", __FUNCTION__);
739
740 spin_lock_irqsave(&priv->lock, flags);
741 control_state = priv->control_state;
742
743 if (set & TIOCM_RTS)
744 control_state |= TIOCM_RTS;
745 if (set & TIOCM_DTR)
746 control_state |= TIOCM_DTR;
747 if (clear & TIOCM_RTS)
748 control_state &= ~TIOCM_RTS;
749 if (clear & TIOCM_DTR)
750 control_state &= ~TIOCM_DTR;
751
752 priv->control_state = control_state;
753 spin_unlock_irqrestore(&priv->lock, flags);
754 return mct_u232_set_modem_ctrl(serial, control_state);
755 }
756
757 static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
758 unsigned int cmd, unsigned long arg)
759 {
760 dbg("%scmd=0x%x", __FUNCTION__, cmd);
761
762 /* Based on code from acm.c and others */
763 switch (cmd) {
764 case TIOCMIWAIT:
765 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
766 /* TODO */
767 return( 0 );
768
769 case TIOCGICOUNT:
770 /* return count of modemline transitions */
771 /* TODO */
772 return 0;
773
774 default:
775 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
776 return(-ENOIOCTLCMD);
777 break;
778 }
779 return 0;
780 } /* mct_u232_ioctl */
781
782 static void mct_u232_throttle (struct usb_serial_port *port)
783 {
784 struct mct_u232_private *priv = usb_get_serial_port_data(port);
785 unsigned long flags;
786 unsigned int control_state;
787 struct tty_struct *tty;
788
789 tty = port->tty;
790 dbg("%s - port %d", __FUNCTION__, port->number);
791
792 spin_lock_irqsave(&priv->lock, flags);
793 priv->rx_flags |= THROTTLED;
794 if (C_CRTSCTS(tty)) {
795 priv->control_state &= ~TIOCM_RTS;
796 control_state = priv->control_state;
797 spin_unlock_irqrestore(&priv->lock, flags);
798 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
799 } else {
800 spin_unlock_irqrestore(&priv->lock, flags);
801 }
802 }
803
804
805 static void mct_u232_unthrottle (struct usb_serial_port *port)
806 {
807 struct mct_u232_private *priv = usb_get_serial_port_data(port);
808 unsigned long flags;
809 unsigned int control_state;
810 struct tty_struct *tty;
811
812 dbg("%s - port %d", __FUNCTION__, port->number);
813
814 tty = port->tty;
815 spin_lock_irqsave(&priv->lock, flags);
816 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
817 priv->rx_flags &= ~THROTTLED;
818 priv->control_state |= TIOCM_RTS;
819 control_state = priv->control_state;
820 spin_unlock_irqrestore(&priv->lock, flags);
821 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
822 } else {
823 spin_unlock_irqrestore(&priv->lock, flags);
824 }
825 }
826
827 static int __init mct_u232_init (void)
828 {
829 int retval;
830 retval = usb_serial_register(&mct_u232_device);
831 if (retval)
832 goto failed_usb_serial_register;
833 retval = usb_register(&mct_u232_driver);
834 if (retval)
835 goto failed_usb_register;
836 info(DRIVER_DESC " " DRIVER_VERSION);
837 return 0;
838 failed_usb_register:
839 usb_serial_deregister(&mct_u232_device);
840 failed_usb_serial_register:
841 return retval;
842 }
843
844
845 static void __exit mct_u232_exit (void)
846 {
847 usb_deregister (&mct_u232_driver);
848 usb_serial_deregister (&mct_u232_device);
849 }
850
851
852 module_init (mct_u232_init);
853 module_exit(mct_u232_exit);
854
855 MODULE_AUTHOR( DRIVER_AUTHOR );
856 MODULE_DESCRIPTION( DRIVER_DESC );
857 MODULE_LICENSE("GPL");
858
859 module_param(debug, bool, S_IRUGO | S_IWUSR);
860 MODULE_PARM_DESC(debug, "Debug enabled or not");
861
|
This page was automatically generated by the
LXR engine.
|