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