?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OMAP3: PM: decouple PER and CORE context save and restore
[linux-ginger.git] / drivers / usb / serial / mct_u232.c
blobcd009cb280a50b29d80a50610f8303a4badbd9af
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
40 * problems.
41 *
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).
46 *
47 * 02-May-2001 Stelian Pop
48 * - Fixed the baud calculation for Sitecom U232-P25 model
49 *
50 * 08-Apr-2001 gb
51 * - Identify version on module load.
52 *
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)
56 *
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.
62 *
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).
66 */
67
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"
81
82 /*
83 * Version Information
84 */
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"
88
89 static int debug;
90
91 /*
92 * Function prototypes
93 */
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);
108
109
110 /*
111 * All of the device info needed for the MCT USB-RS232 converter.
112 */
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 */
119 };
120
121 MODULE_DEVICE_TABLE(usb, id_table_combined);
122
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,
129 };
130
131 static struct usb_serial_driver mct_u232_device = {
132 .driver = {
133 .owner = THIS_MODULE,
134 .name = "mct_u232",
135 },
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,
152 };
153
154
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 */
162 };
163
164 #define THROTTLED 0x01
165
166 /*
167 * Handle vendor specific USB requests
168 */
169
170 #define WDR_TIMEOUT 5000 /* default urb timeout */
171
172 /*
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.
175 */
176 static int mct_u232_calculate_baud_rate(struct usb_serial *serial,
177 speed_t value, speed_t *result)
178 {
179 *result = value;
180
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;
207 }
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;
226 }
227 return 115200/value;
228 }
229 }
230
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)
233 {
234 __le32 divisor;
235 int rc;
236 unsigned char zero_byte = 0;
237 unsigned char cts_enable_byte = 0;
238 speed_t speed;
239
240 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value,
241 &speed));
242
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);
254
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.
262
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'.
270 */
271
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);
281
282 if (port && C_CRTSCTS(tty))
283 cts_enable_byte = 1;
284
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);
295
296 return rc;
297 } /* mct_u232_set_baud_rate */
298
299 static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
300 {
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 */
313
314 static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
315 unsigned int control_state)
316 {
317 int rc;
318 unsigned char mcr = MCT_U232_MCR_NONE;
319
320 if (control_state & TIOCM_DTR)
321 mcr |= MCT_U232_MCR_DTR;
322 if (control_state & TIOCM_RTS)
323 mcr |= MCT_U232_MCR_RTS;
324
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);
334
335 return rc;
336 } /* mct_u232_set_modem_ctrl */
337
338 static int mct_u232_get_modem_stat(struct usb_serial *serial,
339 unsigned char *msr)
340 {
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;
351 }
352 dbg("get_modem_stat: 0x%x", *msr);
353 return rc;
354 } /* mct_u232_get_modem_stat */
355
356 static void mct_u232_msr_to_state(unsigned int *control_state,
357 unsigned char msr)
358 {
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 */
378
379 /*
380 * Driver's tty interface functions
381 */
382
383 static int mct_u232_startup(struct usb_serial *serial)
384 {
385 struct mct_u232_private *priv;
386 struct usb_serial_port *port, *rport;
387
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);
393
394 init_waitqueue_head(&serial->port[0]->write_wait);
395
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;
404
405 return 0;
406 } /* mct_u232_startup */
407
408
409 static void mct_u232_release(struct usb_serial *serial)
410 {
411 struct mct_u232_private *priv;
412 int i;
413
414 dbg("%s", __func__);
415
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);
420 }
421 } /* mct_u232_release */
422
423 static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
424 {
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;
432
433 dbg("%s port %d", __func__, port->number);
434
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...)
439 */
440 if (le16_to_cpu(serial->dev->descriptor.idProduct)
441 == MCT_U232_SITECOM_PID)
442 port->bulk_out_size = 16;
443
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.
448 */
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;
454
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);
463
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);
470
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;
478 }
479
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;
488 }
489 return 0;
490
491 error:
492 return retval;
493 } /* mct_u232_open */
494
495 static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
496 {
497 unsigned int control_state;
498 struct mct_u232_private *priv = usb_get_serial_port_data(port);
499
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);
511 }
512 mutex_unlock(&port->serial->disc_mutex);
513 }
514
515 static void mct_u232_close(struct usb_serial_port *port)
516 {
517 dbg("%s port %d", __func__, port->number);
518
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);
524 }
525 } /* mct_u232_close */
526
527
528 static void mct_u232_read_int_callback(struct urb *urb)
529 {
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;
538
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;
554 }
555
556 if (!serial) {
557 dbg("%s - bad serial pointer, exiting", __func__);
558 return;
559 }
560
561 dbg("%s - port %d", __func__, port->number);
562 usb_serial_debug_data(debug, &port->dev, __func__,
563 urb->actual_length, data);
564
565 /*
566 * Work-a-round: handle the 'usual' bulk-in pipe here
567 */
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);
575 }
576 tty_kref_put(tty);
577 }
578 goto exit;
579 }
580
581 /*
582 * The interrupt-in pipe signals exceptional conditions (modem line
583 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
584 */
585 spin_lock_irqsave(&priv->lock, flags);
586 priv->last_msr = data[MCT_U232_MSR_INDEX];
587
588 /* Record Control Line states */
589 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
590
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];
595 /*
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.
599 */
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) {
604 }
605 /* Parity Error */
606 if (priv->last_lsr & MCT_U232_LSR_PE) {
607 }
608 /* Framing Error */
609 if (priv->last_lsr & MCT_U232_LSR_FE) {
610 }
611 /* Break Indicator */
612 if (priv->last_lsr & MCT_U232_LSR_BI) {
613 }
614 tty_kref_put(tty);
615 }
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 */
625
626 static void mct_u232_set_termios(struct tty_struct *tty,
627 struct usb_serial_port *port,
628 struct ktermios *old_termios)
629 {
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;
638
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;
644
645 /*
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.
650 */
651
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);
657 }
658
659 mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
660
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);
666 }
667
668 /*
669 * Update line control register (LCR)
670 */
671
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;
678
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;
694 }
695
696 termios->c_cflag &= ~CMSPAR;
697
698 /* set the number of stop bits */
699 last_lcr |= (cflag & CSTOPB) ?
700 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
701
702 mct_u232_set_line_ctrl(serial, last_lcr);
703
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 */
710
711 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
712 {
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;
718
719 dbg("%sstate=%d", __func__, break_state);
720
721 spin_lock_irqsave(&priv->lock, flags);
722 lcr = priv->last_lcr;
723
724 if (break_state)
725 lcr |= MCT_U232_SET_BREAK;
726 spin_unlock_irqrestore(&priv->lock, flags);
727
728 mct_u232_set_line_ctrl(serial, lcr);
729 } /* mct_u232_break_ctl */
730
731
732 static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
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 unsigned long flags;
738
739 dbg("%s", __func__);
740
741 spin_lock_irqsave(&priv->lock, flags);
742 control_state = priv->control_state;
743 spin_unlock_irqrestore(&priv->lock, flags);
744
745 return control_state;
746 }
747
748 static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
749 unsigned int set, unsigned int clear)
750 {
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;
756
757 dbg("%s", __func__);
758
759 spin_lock_irqsave(&priv->lock, flags);
760 control_state = priv->control_state;
761
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;
770
771 priv->control_state = control_state;
772 spin_unlock_irqrestore(&priv->lock, flags);
773 return mct_u232_set_modem_ctrl(serial, control_state);
774 }
775
776 static void mct_u232_throttle(struct tty_struct *tty)
777 {
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;
781
782 dbg("%s - port %d", __func__, port->number);
783
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);
793 }
794 }
795
796
797 static void mct_u232_unthrottle(struct tty_struct *tty)
798 {
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;
802
803 dbg("%s - port %d", __func__, port->number);
804
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);
814 }
815 }
816
817 static int __init mct_u232_init(void)
818 {
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;
833 }
834
835
836 static void __exit mct_u232_exit(void)
837 {
838 usb_deregister(&mct_u232_driver);
839 usb_serial_deregister(&mct_u232_device);
840 }
841
842 module_init(mct_u232_init);
843 module_exit(mct_u232_exit);
844
845 MODULE_AUTHOR(DRIVER_AUTHOR);
846 MODULE_DESCRIPTION(DRIVER_DESC);
847 MODULE_LICENSE("GPL");
848
849 module_param(debug, bool, S_IRUGO | S_IWUSR);
850 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux for Ginger Game Console