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