?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.9-rc4
[linux-2.6/cjktty.git] / drivers / usb / serial / mct_u232.c
blob06d5a60be2c4cb87279744372edef4a41864b74b
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
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"
40
41 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
42 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
43
44 /*
45 * Function prototypes
46 */
47 static int mct_u232_startup(struct usb_serial *serial);
48 static int mct_u232_port_probe(struct usb_serial_port *port);
49 static int mct_u232_port_remove(struct usb_serial_port *remove);
50 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
51 static void mct_u232_close(struct usb_serial_port *port);
52 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
53 static void mct_u232_read_int_callback(struct urb *urb);
54 static void mct_u232_set_termios(struct tty_struct *tty,
55 struct usb_serial_port *port, struct ktermios *old);
56 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state);
57 static int mct_u232_tiocmget(struct tty_struct *tty);
58 static int mct_u232_tiocmset(struct tty_struct *tty,
59 unsigned int set, unsigned int clear);
60 static int mct_u232_ioctl(struct tty_struct *tty,
61 unsigned int cmd, unsigned long arg);
62 static int mct_u232_get_icount(struct tty_struct *tty,
63 struct serial_icounter_struct *icount);
64 static void mct_u232_throttle(struct tty_struct *tty);
65 static void mct_u232_unthrottle(struct tty_struct *tty);
66
67
68 /*
69 * All of the device info needed for the MCT USB-RS232 converter.
70 */
71 static const struct usb_device_id id_table[] = {
72 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
73 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
74 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
75 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
76 { } /* Terminating entry */
77 };
78 MODULE_DEVICE_TABLE(usb, id_table);
79
80 static struct usb_serial_driver mct_u232_device = {
81 .driver = {
82 .owner = THIS_MODULE,
83 .name = "mct_u232",
84 },
85 .description = "MCT U232",
86 .id_table = id_table,
87 .num_ports = 1,
88 .open = mct_u232_open,
89 .close = mct_u232_close,
90 .dtr_rts = mct_u232_dtr_rts,
91 .throttle = mct_u232_throttle,
92 .unthrottle = mct_u232_unthrottle,
93 .read_int_callback = mct_u232_read_int_callback,
94 .set_termios = mct_u232_set_termios,
95 .break_ctl = mct_u232_break_ctl,
96 .tiocmget = mct_u232_tiocmget,
97 .tiocmset = mct_u232_tiocmset,
98 .attach = mct_u232_startup,
99 .port_probe = mct_u232_port_probe,
100 .port_remove = mct_u232_port_remove,
101 .ioctl = mct_u232_ioctl,
102 .get_icount = mct_u232_get_icount,
103 };
104
105 static struct usb_serial_driver * const serial_drivers[] = {
106 &mct_u232_device, NULL
107 };
108
109 struct mct_u232_private {
110 spinlock_t lock;
111 unsigned int control_state; /* Modem Line Setting (TIOCM) */
112 unsigned char last_lcr; /* Line Control Register */
113 unsigned char last_lsr; /* Line Status Register */
114 unsigned char last_msr; /* Modem Status Register */
115 unsigned int rx_flags; /* Throttling flags */
116 struct async_icount icount;
117 };
118
119 #define THROTTLED 0x01
120
121 /*
122 * Handle vendor specific USB requests
123 */
124
125 #define WDR_TIMEOUT 5000 /* default urb timeout */
126
127 /*
128 * Later day 2.6.0-test kernels have new baud rates like B230400 which
129 * we do not know how to support. We ignore them for the moment.
130 */
131 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
132 speed_t value, speed_t *result)
133 {
134 *result = value;
135
136 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
137 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
138 switch (value) {
139 case 300:
140 return 0x01;
141 case 600:
142 return 0x02; /* this one not tested */
143 case 1200:
144 return 0x03;
145 case 2400:
146 return 0x04;
147 case 4800:
148 return 0x06;
149 case 9600:
150 return 0x08;
151 case 19200:
152 return 0x09;
153 case 38400:
154 return 0x0a;
155 case 57600:
156 return 0x0b;
157 case 115200:
158 return 0x0c;
159 default:
160 *result = 9600;
161 return 0x08;
162 }
163 } else {
164 /* FIXME: Can we use any divider - should we do
165 divider = 115200/value;
166 real baud = 115200/divider */
167 switch (value) {
168 case 300: break;
169 case 600: break;
170 case 1200: break;
171 case 2400: break;
172 case 4800: break;
173 case 9600: break;
174 case 19200: break;
175 case 38400: break;
176 case 57600: break;
177 case 115200: break;
178 default:
179 value = 9600;
180 *result = 9600;
181 }
182 return 115200/value;
183 }
184 }
185
186 static int mct_u232_set_baud_rate(struct tty_struct *tty,
187 struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
188 {
189 unsigned int divisor;
190 int rc;
191 unsigned char *buf;
192 unsigned char cts_enable_byte = 0;
193 speed_t speed;
194
195 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
196 if (buf == NULL)
197 return -ENOMEM;
198
199 divisor = mct_u232_calculate_baud_rate(serial, value, &speed);
200 put_unaligned_le32(cpu_to_le32(divisor), buf);
201 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
202 MCT_U232_SET_BAUD_RATE_REQUEST,
203 MCT_U232_SET_REQUEST_TYPE,
204 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE,
205 WDR_TIMEOUT);
206 if (rc < 0) /*FIXME: What value speed results */
207 dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n",
208 value, rc);
209 else
210 tty_encode_baud_rate(tty, speed, speed);
211 dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor);
212
213 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
214 always sends two extra USB 'device request' messages after the
215 'baud rate change' message. The actual functionality of the
216 request codes in these messages is not fully understood but these
217 particular codes are never seen in any operation besides a baud
218 rate change. Both of these messages send a single byte of data.
219 In the first message, the value of this byte is always zero.
220
221 The second message has been determined experimentally to control
222 whether data will be transmitted to a device which is not asserting
223 the 'CTS' signal. If the second message's data byte is zero, data
224 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
225 flow control). if the second message's data byte is nonzero (a
226 value of 1 is used by this driver), data will not be transmitted to
227 a device which is not asserting 'CTS'.
228 */
229
230 buf[0] = 0;
231 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
232 MCT_U232_SET_UNKNOWN1_REQUEST,
233 MCT_U232_SET_REQUEST_TYPE,
234 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE,
235 WDR_TIMEOUT);
236 if (rc < 0)
237 dev_err(&port->dev, "Sending USB device request code %d "
238 "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST,
239 rc);
240
241 if (port && C_CRTSCTS(tty))
242 cts_enable_byte = 1;
243
244 dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n",
245 cts_enable_byte);
246 buf[0] = cts_enable_byte;
247 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
248 MCT_U232_SET_CTS_REQUEST,
249 MCT_U232_SET_REQUEST_TYPE,
250 0, 0, buf, MCT_U232_SET_CTS_SIZE,
251 WDR_TIMEOUT);
252 if (rc < 0)
253 dev_err(&port->dev, "Sending USB device request code %d "
254 "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc);
255
256 kfree(buf);
257 return rc;
258 } /* mct_u232_set_baud_rate */
259
260 static int mct_u232_set_line_ctrl(struct usb_serial_port *port,
261 unsigned char lcr)
262 {
263 int rc;
264 unsigned char *buf;
265
266 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
267 if (buf == NULL)
268 return -ENOMEM;
269
270 buf[0] = lcr;
271 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
272 MCT_U232_SET_LINE_CTRL_REQUEST,
273 MCT_U232_SET_REQUEST_TYPE,
274 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
275 WDR_TIMEOUT);
276 if (rc < 0)
277 dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
278 dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr);
279 kfree(buf);
280 return rc;
281 } /* mct_u232_set_line_ctrl */
282
283 static int mct_u232_set_modem_ctrl(struct usb_serial_port *port,
284 unsigned int control_state)
285 {
286 int rc;
287 unsigned char mcr;
288 unsigned char *buf;
289
290 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
291 if (buf == NULL)
292 return -ENOMEM;
293
294 mcr = MCT_U232_MCR_NONE;
295 if (control_state & TIOCM_DTR)
296 mcr |= MCT_U232_MCR_DTR;
297 if (control_state & TIOCM_RTS)
298 mcr |= MCT_U232_MCR_RTS;
299
300 buf[0] = mcr;
301 rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
302 MCT_U232_SET_MODEM_CTRL_REQUEST,
303 MCT_U232_SET_REQUEST_TYPE,
304 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
305 WDR_TIMEOUT);
306 kfree(buf);
307
308 dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr);
309
310 if (rc < 0) {
311 dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
312 return rc;
313 }
314 return 0;
315 } /* mct_u232_set_modem_ctrl */
316
317 static int mct_u232_get_modem_stat(struct usb_serial_port *port,
318 unsigned char *msr)
319 {
320 int rc;
321 unsigned char *buf;
322
323 buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL);
324 if (buf == NULL) {
325 *msr = 0;
326 return -ENOMEM;
327 }
328 rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),
329 MCT_U232_GET_MODEM_STAT_REQUEST,
330 MCT_U232_GET_REQUEST_TYPE,
331 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
332 WDR_TIMEOUT);
333 if (rc < 0) {
334 dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc);
335 *msr = 0;
336 } else {
337 *msr = buf[0];
338 }
339 dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr);
340 kfree(buf);
341 return rc;
342 } /* mct_u232_get_modem_stat */
343
344 static void mct_u232_msr_to_icount(struct async_icount *icount,
345 unsigned char msr)
346 {
347 /* Translate Control Line states */
348 if (msr & MCT_U232_MSR_DDSR)
349 icount->dsr++;
350 if (msr & MCT_U232_MSR_DCTS)
351 icount->cts++;
352 if (msr & MCT_U232_MSR_DRI)
353 icount->rng++;
354 if (msr & MCT_U232_MSR_DCD)
355 icount->dcd++;
356 } /* mct_u232_msr_to_icount */
357
358 static void mct_u232_msr_to_state(struct usb_serial_port *port,
359 unsigned int *control_state, unsigned char msr)
360 {
361 /* Translate Control Line states */
362 if (msr & MCT_U232_MSR_DSR)
363 *control_state |= TIOCM_DSR;
364 else
365 *control_state &= ~TIOCM_DSR;
366 if (msr & MCT_U232_MSR_CTS)
367 *control_state |= TIOCM_CTS;
368 else
369 *control_state &= ~TIOCM_CTS;
370 if (msr & MCT_U232_MSR_RI)
371 *control_state |= TIOCM_RI;
372 else
373 *control_state &= ~TIOCM_RI;
374 if (msr & MCT_U232_MSR_CD)
375 *control_state |= TIOCM_CD;
376 else
377 *control_state &= ~TIOCM_CD;
378 dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state);
379 } /* mct_u232_msr_to_state */
380
381 /*
382 * Driver's tty interface functions
383 */
384
385 static int mct_u232_startup(struct usb_serial *serial)
386 {
387 struct usb_serial_port *port, *rport;
388
389 /* Puh, that's dirty */
390 port = serial->port[0];
391 rport = serial->port[1];
392 /* No unlinking, it wasn't submitted yet. */
393 usb_free_urb(port->read_urb);
394 port->read_urb = rport->interrupt_in_urb;
395 rport->interrupt_in_urb = NULL;
396 port->read_urb->context = port;
397
398 return 0;
399 } /* mct_u232_startup */
400
401 static int mct_u232_port_probe(struct usb_serial_port *port)
402 {
403 struct mct_u232_private *priv;
404
405 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
406 if (!priv)
407 return -ENOMEM;
408
409 spin_lock_init(&priv->lock);
410
411 usb_set_serial_port_data(port, priv);
412
413 return 0;
414 }
415
416 static int mct_u232_port_remove(struct usb_serial_port *port)
417 {
418 struct mct_u232_private *priv;
419
420 priv = usb_get_serial_port_data(port);
421 kfree(priv);
422
423 return 0;
424 }
425
426 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
427 {
428 struct usb_serial *serial = port->serial;
429 struct mct_u232_private *priv = usb_get_serial_port_data(port);
430 int retval = 0;
431 unsigned int control_state;
432 unsigned long flags;
433 unsigned char last_lcr;
434 unsigned char last_msr;
435
436 /* Compensate for a hardware bug: although the Sitecom U232-P25
437 * device reports a maximum output packet size of 32 bytes,
438 * it seems to be able to accept only 16 bytes (and that's what
439 * SniffUSB says too...)
440 */
441 if (le16_to_cpu(serial->dev->descriptor.idProduct)
442 == MCT_U232_SITECOM_PID)
443 port->bulk_out_size = 16;
444
445 /* Do a defined restart: the normal serial device seems to
446 * always turn on DTR and RTS here, so do the same. I'm not
447 * sure if this is really necessary. But it should not harm
448 * either.
449 */
450 spin_lock_irqsave(&priv->lock, flags);
451 if (tty && (tty->termios.c_cflag & CBAUD))
452 priv->control_state = TIOCM_DTR | TIOCM_RTS;
453 else
454 priv->control_state = 0;
455
456 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
457 MCT_U232_PARITY_NONE |
458 MCT_U232_STOP_BITS_1);
459 control_state = priv->control_state;
460 last_lcr = priv->last_lcr;
461 spin_unlock_irqrestore(&priv->lock, flags);
462 mct_u232_set_modem_ctrl(port, control_state);
463 mct_u232_set_line_ctrl(port, last_lcr);
464
465 /* Read modem status and update control state */
466 mct_u232_get_modem_stat(port, &last_msr);
467 spin_lock_irqsave(&priv->lock, flags);
468 priv->last_msr = last_msr;
469 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
470 spin_unlock_irqrestore(&priv->lock, flags);
471
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;
478 }
479
480 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
481 if (retval) {
482 usb_kill_urb(port->read_urb);
483 dev_err(&port->dev,
484 "usb_submit_urb(read int) failed pipe 0x%x err %d",
485 port->interrupt_in_urb->pipe, retval);
486 goto error;
487 }
488 return 0;
489
490 error:
491 return retval;
492 } /* mct_u232_open */
493
494 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
495 {
496 unsigned int control_state;
497 struct mct_u232_private *priv = usb_get_serial_port_data(port);
498
499 spin_lock_irq(&priv->lock);
500 if (on)
501 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
502 else
503 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
504 control_state = priv->control_state;
505 spin_unlock_irq(&priv->lock);
506
507 mct_u232_set_modem_ctrl(port, control_state);
508 }
509
510 static void mct_u232_close(struct usb_serial_port *port)
511 {
512 /*
513 * Must kill the read urb as it is actually an interrupt urb, which
514 * generic close thus fails to kill.
515 */
516 usb_kill_urb(port->read_urb);
517 usb_kill_urb(port->interrupt_in_urb);
518
519 usb_serial_generic_close(port);
520 } /* mct_u232_close */
521
522
523 static void mct_u232_read_int_callback(struct urb *urb)
524 {
525 struct usb_serial_port *port = urb->context;
526 struct mct_u232_private *priv = usb_get_serial_port_data(port);
527 unsigned char *data = urb->transfer_buffer;
528 int retval;
529 int status = urb->status;
530 unsigned long flags;
531
532 switch (status) {
533 case 0:
534 /* success */
535 break;
536 case -ECONNRESET:
537 case -ENOENT:
538 case -ESHUTDOWN:
539 /* this urb is terminated, clean up */
540 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
541 __func__, status);
542 return;
543 default:
544 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
545 __func__, status);
546 goto exit;
547 }
548
549 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
550
551 /*
552 * Work-a-round: handle the 'usual' bulk-in pipe here
553 */
554 if (urb->transfer_buffer_length > 2) {
555 if (urb->actual_length) {
556 tty_insert_flip_string(&port->port, data,
557 urb->actual_length);
558 tty_flip_buffer_push(&port->port);
559 }
560 goto exit;
561 }
562
563 /*
564 * The interrupt-in pipe signals exceptional conditions (modem line
565 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
566 */
567 spin_lock_irqsave(&priv->lock, flags);
568 priv->last_msr = data[MCT_U232_MSR_INDEX];
569
570 /* Record Control Line states */
571 mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
572
573 mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
574
575 #if 0
576 /* Not yet handled. See belkin_sa.c for further information */
577 /* Now to report any errors */
578 priv->last_lsr = data[MCT_U232_LSR_INDEX];
579 /*
580 * fill in the flip buffer here, but I do not know the relation
581 * to the current/next receive buffer or characters. I need
582 * to look in to this before committing any code.
583 */
584 if (priv->last_lsr & MCT_U232_LSR_ERR) {
585 tty = tty_port_tty_get(&port->port);
586 /* Overrun Error */
587 if (priv->last_lsr & MCT_U232_LSR_OE) {
588 }
589 /* Parity Error */
590 if (priv->last_lsr & MCT_U232_LSR_PE) {
591 }
592 /* Framing Error */
593 if (priv->last_lsr & MCT_U232_LSR_FE) {
594 }
595 /* Break Indicator */
596 if (priv->last_lsr & MCT_U232_LSR_BI) {
597 }
598 tty_kref_put(tty);
599 }
600 #endif
601 wake_up_interruptible(&port->delta_msr_wait);
602 spin_unlock_irqrestore(&priv->lock, flags);
603 exit:
604 retval = usb_submit_urb(urb, GFP_ATOMIC);
605 if (retval)
606 dev_err(&port->dev,
607 "%s - usb_submit_urb failed with result %d\n",
608 __func__, retval);
609 } /* mct_u232_read_int_callback */
610
611 static void mct_u232_set_termios(struct tty_struct *tty,
612 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 = &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 dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
640 control_state |= TIOCM_DTR | TIOCM_RTS;
641 mct_u232_set_modem_ctrl(port, control_state);
642 }
643
644 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
645
646 if ((cflag & CBAUD) == B0) {
647 dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
648 /* Drop RTS and DTR */
649 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
650 mct_u232_set_modem_ctrl(port, 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 dev_err(&port->dev,
676 "CSIZE was not CS5-CS8, using default of 8\n");
677 last_lcr |= MCT_U232_DATA_BITS_8;
678 break;
679 }
680
681 termios->c_cflag &= ~CMSPAR;
682
683 /* set the number of stop bits */
684 last_lcr |= (cflag & CSTOPB) ?
685 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
686
687 mct_u232_set_line_ctrl(port, last_lcr);
688
689 /* save off the modified port settings */
690 spin_lock_irqsave(&priv->lock, flags);
691 priv->control_state = control_state;
692 priv->last_lcr = last_lcr;
693 spin_unlock_irqrestore(&priv->lock, flags);
694 } /* mct_u232_set_termios */
695
696 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
697 {
698 struct usb_serial_port *port = tty->driver_data;
699 struct mct_u232_private *priv = usb_get_serial_port_data(port);
700 unsigned char lcr;
701 unsigned long flags;
702
703 spin_lock_irqsave(&priv->lock, flags);
704 lcr = priv->last_lcr;
705
706 if (break_state)
707 lcr |= MCT_U232_SET_BREAK;
708 spin_unlock_irqrestore(&priv->lock, flags);
709
710 mct_u232_set_line_ctrl(port, lcr);
711 } /* mct_u232_break_ctl */
712
713
714 static int mct_u232_tiocmget(struct tty_struct *tty)
715 {
716 struct usb_serial_port *port = tty->driver_data;
717 struct mct_u232_private *priv = usb_get_serial_port_data(port);
718 unsigned int control_state;
719 unsigned long flags;
720
721 spin_lock_irqsave(&priv->lock, flags);
722 control_state = priv->control_state;
723 spin_unlock_irqrestore(&priv->lock, flags);
724
725 return control_state;
726 }
727
728 static int mct_u232_tiocmset(struct tty_struct *tty,
729 unsigned int set, unsigned int clear)
730 {
731 struct usb_serial_port *port = tty->driver_data;
732 struct mct_u232_private *priv = usb_get_serial_port_data(port);
733 unsigned int control_state;
734 unsigned long flags;
735
736 spin_lock_irqsave(&priv->lock, flags);
737 control_state = priv->control_state;
738
739 if (set & TIOCM_RTS)
740 control_state |= TIOCM_RTS;
741 if (set & TIOCM_DTR)
742 control_state |= TIOCM_DTR;
743 if (clear & TIOCM_RTS)
744 control_state &= ~TIOCM_RTS;
745 if (clear & TIOCM_DTR)
746 control_state &= ~TIOCM_DTR;
747
748 priv->control_state = control_state;
749 spin_unlock_irqrestore(&priv->lock, flags);
750 return mct_u232_set_modem_ctrl(port, control_state);
751 }
752
753 static void mct_u232_throttle(struct tty_struct *tty)
754 {
755 struct usb_serial_port *port = tty->driver_data;
756 struct mct_u232_private *priv = usb_get_serial_port_data(port);
757 unsigned int control_state;
758
759 spin_lock_irq(&priv->lock);
760 priv->rx_flags |= THROTTLED;
761 if (C_CRTSCTS(tty)) {
762 priv->control_state &= ~TIOCM_RTS;
763 control_state = priv->control_state;
764 spin_unlock_irq(&priv->lock);
765 mct_u232_set_modem_ctrl(port, control_state);
766 } else {
767 spin_unlock_irq(&priv->lock);
768 }
769 }
770
771 static void mct_u232_unthrottle(struct tty_struct *tty)
772 {
773 struct usb_serial_port *port = tty->driver_data;
774 struct mct_u232_private *priv = usb_get_serial_port_data(port);
775 unsigned int control_state;
776
777 spin_lock_irq(&priv->lock);
778 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
779 priv->rx_flags &= ~THROTTLED;
780 priv->control_state |= TIOCM_RTS;
781 control_state = priv->control_state;
782 spin_unlock_irq(&priv->lock);
783 mct_u232_set_modem_ctrl(port, control_state);
784 } else {
785 spin_unlock_irq(&priv->lock);
786 }
787 }
788
789 static int mct_u232_ioctl(struct tty_struct *tty,
790 unsigned int cmd, unsigned long arg)
791 {
792 DEFINE_WAIT(wait);
793 struct usb_serial_port *port = tty->driver_data;
794 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
795 struct async_icount cnow, cprev;
796 unsigned long flags;
797
798 dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
799
800 switch (cmd) {
801
802 case TIOCMIWAIT:
803
804 dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
805
806 spin_lock_irqsave(&mct_u232_port->lock, flags);
807 cprev = mct_u232_port->icount;
808 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
809 for ( ; ; ) {
810 prepare_to_wait(&port->delta_msr_wait,
811 &wait, TASK_INTERRUPTIBLE);
812 schedule();
813 finish_wait(&port->delta_msr_wait, &wait);
814 /* see if a signal did it */
815 if (signal_pending(current))
816 return -ERESTARTSYS;
817
818 if (port->serial->disconnected)
819 return -EIO;
820
821 spin_lock_irqsave(&mct_u232_port->lock, flags);
822 cnow = mct_u232_port->icount;
823 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
824 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
825 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
826 return -EIO; /* no change => error */
827 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
828 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
829 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
830 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
831 return 0;
832 }
833 cprev = cnow;
834 }
835
836 }
837 return -ENOIOCTLCMD;
838 }
839
840 static int mct_u232_get_icount(struct tty_struct *tty,
841 struct serial_icounter_struct *icount)
842 {
843 struct usb_serial_port *port = tty->driver_data;
844 struct mct_u232_private *mct_u232_port = usb_get_serial_port_data(port);
845 struct async_icount *ic = &mct_u232_port->icount;
846 unsigned long flags;
847
848 spin_lock_irqsave(&mct_u232_port->lock, flags);
849
850 icount->cts = ic->cts;
851 icount->dsr = ic->dsr;
852 icount->rng = ic->rng;
853 icount->dcd = ic->dcd;
854 icount->rx = ic->rx;
855 icount->tx = ic->tx;
856 icount->frame = ic->frame;
857 icount->overrun = ic->overrun;
858 icount->parity = ic->parity;
859 icount->brk = ic->brk;
860 icount->buf_overrun = ic->buf_overrun;
861
862 spin_unlock_irqrestore(&mct_u232_port->lock, flags);
863
864 dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
865 __func__, icount->rx, icount->tx);
866 return 0;
867 }
868
869 module_usb_serial_driver(serial_drivers, id_table);
870
871 MODULE_AUTHOR(DRIVER_AUTHOR);
872 MODULE_DESCRIPTION(DRIVER_DESC);
873 MODULE_LICENSE("GPL");
CJK support for tty framebuffer vt