blob: 88b2074867c5d187c5567bd4414fa6264436966e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver
3 *
4 * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch)
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is largely derived from the Belkin USB Serial Adapter Driver
12 * (see belkin_sa.[ch]). All of the information about the device was acquired
13 * by using SniffUSB on Windows98. For technical details see mct_u232.h.
14 *
15 * William G. Greathouse and Greg Kroah-Hartman provided great help on how to
16 * do the reverse engineering and how to write a USB serial device driver.
17 *
18 * TO BE DONE, TO BE CHECKED:
19 * DTR/RTS signal handling may be incomplete or incorrect. I have mainly
20 * implemented what I have seen with SniffUSB or found in belkin_sa.c.
21 * For further TODOs check also belkin_sa.c.
22 *
23 * TEST STATUS:
24 * Basic tests have been performed with minicom/zmodem transfers and
25 * modem dialing under Linux 2.4.0-test10 (for me it works fine).
26 *
27 * 04-Nov-2003 Bill Marr <marr at flex dot com>
28 * - Mimic Windows driver by sending 2 USB 'device request' messages
29 * following normal 'baud rate change' message. This allows data to be
30 * transmitted to RS-232 devices which don't assert the 'CTS' signal.
31 *
32 * 10-Nov-2001 Wolfgang Grandegger
33 * - Fixed an endianess problem with the baudrate selection for PowerPC.
34 *
35 * 06-Dec-2001 Martin Hamilton <martinh@gnu.org>
36 * Added support for the Belkin F5U109 DB9 adaptor
37 *
38 * 30-May-2001 Greg Kroah-Hartman
39 * switched from using spinlock to a semaphore, which fixes lots of problems.
40 *
41 * 04-May-2001 Stelian Pop
42 * - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes
43 * instead of the device reported 32 (using 32 bytes causes many data
44 * loss, Windows driver uses 16 too).
45 *
46 * 02-May-2001 Stelian Pop
47 * - Fixed the baud calculation for Sitecom U232-P25 model
48 *
49 * 08-Apr-2001 gb
50 * - Identify version on module load.
51 *
52 * 06-Jan-2001 Cornel Ciocirlan
53 * - Added support for Sitecom U232-P25 model (Product Id 0x0230)
54 * - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200)
55 *
56 * 29-Nov-2000 Greg Kroah-Hartman
57 * - Added device id table to fit with 2.4.0-test11 structure.
58 * - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed
59 * (lots of things will change if/when the usb-serial core changes to
60 * handle these issues.
61 *
62 * 27-Nov-2000 Wolfgang Grandegger
63 * A version for kernel 2.4.0-test10 released to the Linux community
64 * (via linux-usb-devel).
65 */
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/kernel.h>
68#include <linux/errno.h>
69#include <linux/init.h>
70#include <linux/slab.h>
71#include <linux/tty.h>
72#include <linux/tty_driver.h>
73#include <linux/tty_flip.h>
74#include <linux/module.h>
75#include <linux/spinlock.h>
76#include <asm/uaccess.h>
77#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070078#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include "mct_u232.h"
80
81/*
82 * Version Information
83 */
Dave Platt45b844d2007-05-08 11:00:12 -070084#define DRIVER_VERSION "z2.1" /* Linux in-kernel version */
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
86#define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
87
88static int debug;
89
90/*
91 * Function prototypes
92 */
93static int mct_u232_startup (struct usb_serial *serial);
94static void mct_u232_shutdown (struct usb_serial *serial);
95static int mct_u232_open (struct usb_serial_port *port,
96 struct file *filp);
97static void mct_u232_close (struct usb_serial_port *port,
98 struct file *filp);
David Howells7d12e782006-10-05 14:55:46 +010099static void mct_u232_read_int_callback (struct urb *urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static void mct_u232_set_termios (struct usb_serial_port *port,
Alan Cox606d0992006-12-08 02:38:45 -0800101 struct ktermios * old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102static int mct_u232_ioctl (struct usb_serial_port *port,
103 struct file * file,
104 unsigned int cmd,
105 unsigned long arg);
106static void mct_u232_break_ctl (struct usb_serial_port *port,
107 int break_state );
108static int mct_u232_tiocmget (struct usb_serial_port *port,
109 struct file *file);
110static int mct_u232_tiocmset (struct usb_serial_port *port,
111 struct file *file, unsigned int set,
112 unsigned int clear);
Dave Platt45b844d2007-05-08 11:00:12 -0700113static void mct_u232_throttle (struct usb_serial_port *port);
114static void mct_u232_unthrottle (struct usb_serial_port *port);
115
116
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117/*
118 * All of the device info needed for the MCT USB-RS232 converter.
119 */
120static struct usb_device_id id_table_combined [] = {
121 { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) },
122 { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) },
123 { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) },
124 { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) },
125 { } /* Terminating entry */
126};
127
128MODULE_DEVICE_TABLE (usb, id_table_combined);
129
130static struct usb_driver mct_u232_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 .name = "mct_u232",
132 .probe = usb_serial_probe,
133 .disconnect = usb_serial_disconnect,
134 .id_table = id_table_combined,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800135 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700138static struct usb_serial_driver mct_u232_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700139 .driver = {
140 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700141 .name = "mct_u232",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700142 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700143 .description = "MCT U232",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100144 .usb_driver = &mct_u232_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 .id_table = id_table_combined,
146 .num_interrupt_in = 2,
147 .num_bulk_in = 0,
148 .num_bulk_out = 1,
149 .num_ports = 1,
150 .open = mct_u232_open,
151 .close = mct_u232_close,
Dave Platt45b844d2007-05-08 11:00:12 -0700152 .throttle = mct_u232_throttle,
153 .unthrottle = mct_u232_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 .read_int_callback = mct_u232_read_int_callback,
155 .ioctl = mct_u232_ioctl,
156 .set_termios = mct_u232_set_termios,
157 .break_ctl = mct_u232_break_ctl,
158 .tiocmget = mct_u232_tiocmget,
159 .tiocmset = mct_u232_tiocmset,
160 .attach = mct_u232_startup,
161 .shutdown = mct_u232_shutdown,
162};
163
164
165struct mct_u232_private {
166 spinlock_t lock;
167 unsigned int control_state; /* Modem Line Setting (TIOCM) */
168 unsigned char last_lcr; /* Line Control Register */
169 unsigned char last_lsr; /* Line Status Register */
170 unsigned char last_msr; /* Modem Status Register */
Dave Platt45b844d2007-05-08 11:00:12 -0700171 unsigned int rx_flags; /* Throttling flags */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172};
173
Dave Platt45b844d2007-05-08 11:00:12 -0700174#define THROTTLED 0x01
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176/*
177 * Handle vendor specific USB requests
178 */
179
180#define WDR_TIMEOUT 5000 /* default urb timeout */
181
182/*
183 * Later day 2.6.0-test kernels have new baud rates like B230400 which
184 * we do not know how to support. We ignore them for the moment.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 */
Alan Coxd0fab0d2007-12-13 16:15:29 -0800186static int mct_u232_calculate_baud_rate(struct usb_serial *serial, speed_t value, speed_t *result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
Alan Coxd0fab0d2007-12-13 16:15:29 -0800188 *result = value;
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID
191 || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) {
192 switch (value) {
Alan Coxf4244902007-07-26 19:01:10 +0100193 case 300: return 0x01;
194 case 600: return 0x02; /* this one not tested */
195 case 1200: return 0x03;
196 case 2400: return 0x04;
197 case 4800: return 0x06;
198 case 9600: return 0x08;
199 case 19200: return 0x09;
200 case 38400: return 0x0a;
201 case 57600: return 0x0b;
202 case 115200: return 0x0c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 default:
Alan Coxd0fab0d2007-12-13 16:15:29 -0800204 *result = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return 0x08;
206 }
207 } else {
Alan Coxd0fab0d2007-12-13 16:15:29 -0800208 /* FIXME: Can we use any divider - should we do
209 divider = 115200/value;
210 real baud = 115200/divider */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 switch (value) {
Andrew Mortonb3aceb22007-08-10 14:53:35 -0700212 case 300: break;
213 case 600: break;
214 case 1200: break;
215 case 2400: break;
216 case 4800: break;
217 case 9600: break;
218 case 19200: break;
219 case 38400: break;
220 case 57600: break;
221 case 115200: break;
222 default:
Andrew Mortonb3aceb22007-08-10 14:53:35 -0700223 value = 9600;
Alan Coxd0fab0d2007-12-13 16:15:29 -0800224 *result = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226 return 115200/value;
227 }
228}
229
Dave Platt45b844d2007-05-08 11:00:12 -0700230static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_port *port,
Alan Coxf4244902007-07-26 19:01:10 +0100231 speed_t value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
233 __le32 divisor;
234 int rc;
235 unsigned char zero_byte = 0;
Dave Platt45b844d2007-05-08 11:00:12 -0700236 unsigned char cts_enable_byte = 0;
Alan Coxd0fab0d2007-12-13 16:15:29 -0800237 speed_t speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Alan Coxd0fab0d2007-12-13 16:15:29 -0800239 divisor = cpu_to_le32(mct_u232_calculate_baud_rate(serial, value, &speed));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
242 MCT_U232_SET_BAUD_RATE_REQUEST,
243 MCT_U232_SET_REQUEST_TYPE,
244 0, 0, &divisor, MCT_U232_SET_BAUD_RATE_SIZE,
245 WDR_TIMEOUT);
Alan Coxd0fab0d2007-12-13 16:15:29 -0800246 if (rc < 0) /*FIXME: What value speed results */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 err("Set BAUD RATE %d failed (error = %d)", value, rc);
Alan Coxd0fab0d2007-12-13 16:15:29 -0800248 else
249 tty_encode_baud_rate(port->tty, speed, speed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
251
252 /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
253 always sends two extra USB 'device request' messages after the
254 'baud rate change' message. The actual functionality of the
255 request codes in these messages is not fully understood but these
256 particular codes are never seen in any operation besides a baud
Dave Platt45b844d2007-05-08 11:00:12 -0700257 rate change. Both of these messages send a single byte of data.
258 In the first message, the value of this byte is always zero.
259
260 The second message has been determined experimentally to control
261 whether data will be transmitted to a device which is not asserting
262 the 'CTS' signal. If the second message's data byte is zero, data
263 will be transmitted even if 'CTS' is not asserted (i.e. no hardware
264 flow control). if the second message's data byte is nonzero (a value
265 of 1 is used by this driver), data will not be transmitted to a device
266 which is not asserting 'CTS'.
267 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
270 MCT_U232_SET_UNKNOWN1_REQUEST,
271 MCT_U232_SET_REQUEST_TYPE,
272 0, 0, &zero_byte, MCT_U232_SET_UNKNOWN1_SIZE,
273 WDR_TIMEOUT);
274 if (rc < 0)
275 err("Sending USB device request code %d failed (error = %d)",
276 MCT_U232_SET_UNKNOWN1_REQUEST, rc);
277
Dave Platt45b844d2007-05-08 11:00:12 -0700278 if (port && C_CRTSCTS(port->tty)) {
279 cts_enable_byte = 1;
280 }
281
282 dbg("set_baud_rate: send second control message, data = %02X", cts_enable_byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
Dave Platt45b844d2007-05-08 11:00:12 -0700284 MCT_U232_SET_CTS_REQUEST,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 MCT_U232_SET_REQUEST_TYPE,
Dave Platt45b844d2007-05-08 11:00:12 -0700286 0, 0, &cts_enable_byte, MCT_U232_SET_CTS_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 WDR_TIMEOUT);
288 if (rc < 0)
Dave Platt45b844d2007-05-08 11:00:12 -0700289 err("Sending USB device request code %d failed (error = %d)",
290 MCT_U232_SET_CTS_REQUEST, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 return rc;
293} /* mct_u232_set_baud_rate */
294
295static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
296{
297 int rc;
298 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
299 MCT_U232_SET_LINE_CTRL_REQUEST,
300 MCT_U232_SET_REQUEST_TYPE,
301 0, 0, &lcr, MCT_U232_SET_LINE_CTRL_SIZE,
302 WDR_TIMEOUT);
303 if (rc < 0)
304 err("Set LINE CTRL 0x%x failed (error = %d)", lcr, rc);
305 dbg("set_line_ctrl: 0x%x", lcr);
306 return rc;
307} /* mct_u232_set_line_ctrl */
308
309static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
310 unsigned int control_state)
311{
312 int rc;
313 unsigned char mcr = MCT_U232_MCR_NONE;
314
315 if (control_state & TIOCM_DTR)
316 mcr |= MCT_U232_MCR_DTR;
317 if (control_state & TIOCM_RTS)
318 mcr |= MCT_U232_MCR_RTS;
319
320 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
321 MCT_U232_SET_MODEM_CTRL_REQUEST,
322 MCT_U232_SET_REQUEST_TYPE,
323 0, 0, &mcr, MCT_U232_SET_MODEM_CTRL_SIZE,
324 WDR_TIMEOUT);
325 if (rc < 0)
326 err("Set MODEM CTRL 0x%x failed (error = %d)", mcr, rc);
327 dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
328
329 return rc;
330} /* mct_u232_set_modem_ctrl */
331
332static int mct_u232_get_modem_stat(struct usb_serial *serial, unsigned char *msr)
333{
334 int rc;
335 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
336 MCT_U232_GET_MODEM_STAT_REQUEST,
337 MCT_U232_GET_REQUEST_TYPE,
338 0, 0, msr, MCT_U232_GET_MODEM_STAT_SIZE,
339 WDR_TIMEOUT);
340 if (rc < 0) {
341 err("Get MODEM STATus failed (error = %d)", rc);
342 *msr = 0;
343 }
344 dbg("get_modem_stat: 0x%x", *msr);
345 return rc;
346} /* mct_u232_get_modem_stat */
347
348static void mct_u232_msr_to_state(unsigned int *control_state, unsigned char msr)
349{
350 /* Translate Control Line states */
351 if (msr & MCT_U232_MSR_DSR)
352 *control_state |= TIOCM_DSR;
353 else
354 *control_state &= ~TIOCM_DSR;
355 if (msr & MCT_U232_MSR_CTS)
356 *control_state |= TIOCM_CTS;
357 else
358 *control_state &= ~TIOCM_CTS;
359 if (msr & MCT_U232_MSR_RI)
360 *control_state |= TIOCM_RI;
361 else
362 *control_state &= ~TIOCM_RI;
363 if (msr & MCT_U232_MSR_CD)
364 *control_state |= TIOCM_CD;
365 else
366 *control_state &= ~TIOCM_CD;
367 dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
368} /* mct_u232_msr_to_state */
369
370/*
371 * Driver's tty interface functions
372 */
373
374static int mct_u232_startup (struct usb_serial *serial)
375{
376 struct mct_u232_private *priv;
377 struct usb_serial_port *port, *rport;
378
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100379 priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (!priv)
381 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 spin_lock_init(&priv->lock);
383 usb_set_serial_port_data(serial->port[0], priv);
384
385 init_waitqueue_head(&serial->port[0]->write_wait);
386
387 /* Puh, that's dirty */
388 port = serial->port[0];
389 rport = serial->port[1];
Mariusz Kozlowski73135bb2006-11-08 15:36:42 +0100390 /* No unlinking, it wasn't submitted yet. */
391 usb_free_urb(port->read_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 port->read_urb = rport->interrupt_in_urb;
393 rport->interrupt_in_urb = NULL;
394 port->read_urb->context = port;
395
396 return (0);
397} /* mct_u232_startup */
398
399
400static void mct_u232_shutdown (struct usb_serial *serial)
401{
402 struct mct_u232_private *priv;
403 int i;
404
405 dbg("%s", __FUNCTION__);
406
407 for (i=0; i < serial->num_ports; ++i) {
408 /* My special items, the standard routines free my urbs */
409 priv = usb_get_serial_port_data(serial->port[i]);
410 if (priv) {
411 usb_set_serial_port_data(serial->port[i], NULL);
412 kfree(priv);
413 }
414 }
415} /* mct_u232_shutdown */
416
417static int mct_u232_open (struct usb_serial_port *port, struct file *filp)
418{
419 struct usb_serial *serial = port->serial;
420 struct mct_u232_private *priv = usb_get_serial_port_data(port);
421 int retval = 0;
422 unsigned int control_state;
423 unsigned long flags;
424 unsigned char last_lcr;
425 unsigned char last_msr;
426
427 dbg("%s port %d", __FUNCTION__, port->number);
428
429 /* Compensate for a hardware bug: although the Sitecom U232-P25
430 * device reports a maximum output packet size of 32 bytes,
431 * it seems to be able to accept only 16 bytes (and that's what
432 * SniffUSB says too...)
433 */
434 if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)
435 port->bulk_out_size = 16;
436
437 /* Do a defined restart: the normal serial device seems to
438 * always turn on DTR and RTS here, so do the same. I'm not
439 * sure if this is really necessary. But it should not harm
440 * either.
441 */
442 spin_lock_irqsave(&priv->lock, flags);
443 if (port->tty->termios->c_cflag & CBAUD)
444 priv->control_state = TIOCM_DTR | TIOCM_RTS;
445 else
446 priv->control_state = 0;
447
448 priv->last_lcr = (MCT_U232_DATA_BITS_8 |
449 MCT_U232_PARITY_NONE |
450 MCT_U232_STOP_BITS_1);
451 control_state = priv->control_state;
452 last_lcr = priv->last_lcr;
453 spin_unlock_irqrestore(&priv->lock, flags);
454 mct_u232_set_modem_ctrl(serial, control_state);
455 mct_u232_set_line_ctrl(serial, last_lcr);
456
457 /* Read modem status and update control state */
458 mct_u232_get_modem_stat(serial, &last_msr);
459 spin_lock_irqsave(&priv->lock, flags);
460 priv->last_msr = last_msr;
461 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
462 spin_unlock_irqrestore(&priv->lock, flags);
463
464 port->read_urb->dev = port->serial->dev;
465 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
466 if (retval) {
467 err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",
468 port->read_urb->pipe, retval);
Oliver Neukum2f007de2007-03-29 10:45:17 +0200469 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471
472 port->interrupt_in_urb->dev = port->serial->dev;
473 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
Oliver Neukum2f007de2007-03-29 10:45:17 +0200474 if (retval) {
475 usb_kill_urb(port->read_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 err(" usb_submit_urb(read int) failed pipe 0x%x err %d",
477 port->interrupt_in_urb->pipe, retval);
Oliver Neukum2f007de2007-03-29 10:45:17 +0200478 goto error;
479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 return 0;
Oliver Neukum2f007de2007-03-29 10:45:17 +0200481
482error:
483 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484} /* mct_u232_open */
485
486
487static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
488{
Dave Platt45b844d2007-05-08 11:00:12 -0700489 unsigned int c_cflag;
490 unsigned long flags;
491 unsigned int control_state;
492 struct mct_u232_private *priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 dbg("%s port %d", __FUNCTION__, port->number);
494
Dave Platt45b844d2007-05-08 11:00:12 -0700495 if (port->tty) {
496 c_cflag = port->tty->termios->c_cflag;
497 if (c_cflag & HUPCL) {
498 /* drop DTR and RTS */
499 spin_lock_irqsave(&priv->lock, flags);
500 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
501 control_state = priv->control_state;
502 spin_unlock_irqrestore(&priv->lock, flags);
503 mct_u232_set_modem_ctrl(port->serial, control_state);
504 }
505 }
506
507
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 if (port->serial->dev) {
509 /* shutdown our urbs */
510 usb_kill_urb(port->write_urb);
511 usb_kill_urb(port->read_urb);
512 usb_kill_urb(port->interrupt_in_urb);
513 }
514} /* mct_u232_close */
515
516
David Howells7d12e782006-10-05 14:55:46 +0100517static void mct_u232_read_int_callback (struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518{
519 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
520 struct mct_u232_private *priv = usb_get_serial_port_data(port);
521 struct usb_serial *serial = port->serial;
522 struct tty_struct *tty;
523 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700524 int retval;
525 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 unsigned long flags;
527
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700528 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 case 0:
530 /* success */
531 break;
532 case -ECONNRESET:
533 case -ENOENT:
534 case -ESHUTDOWN:
535 /* this urb is terminated, clean up */
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700536 dbg("%s - urb shutting down with status: %d",
537 __FUNCTION__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 return;
539 default:
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700540 dbg("%s - nonzero urb status received: %d",
541 __FUNCTION__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 goto exit;
543 }
544
545 if (!serial) {
546 dbg("%s - bad serial pointer, exiting", __FUNCTION__);
547 return;
548 }
549
550 dbg("%s - port %d", __FUNCTION__, port->number);
551 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
552
553 /*
554 * Work-a-round: handle the 'usual' bulk-in pipe here
555 */
556 if (urb->transfer_buffer_length > 2) {
557 int i;
558 tty = port->tty;
559 if (urb->actual_length) {
560 for (i = 0; i < urb->actual_length ; ++i) {
561 tty_insert_flip_char(tty, data[i], 0);
562 }
563 tty_flip_buffer_push(tty);
564 }
565 goto exit;
566 }
567
568 /*
569 * The interrupt-in pipe signals exceptional conditions (modem line
570 * signal changes and errors). data[0] holds MSR, data[1] holds LSR.
571 */
572 spin_lock_irqsave(&priv->lock, flags);
573 priv->last_msr = data[MCT_U232_MSR_INDEX];
574
575 /* Record Control Line states */
576 mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
577
578#if 0
579 /* Not yet handled. See belin_sa.c for further information */
580 /* Now to report any errors */
581 priv->last_lsr = data[MCT_U232_LSR_INDEX];
582 /*
583 * fill in the flip buffer here, but I do not know the relation
584 * to the current/next receive buffer or characters. I need
585 * to look in to this before committing any code.
586 */
587 if (priv->last_lsr & MCT_U232_LSR_ERR) {
588 tty = port->tty;
589 /* Overrun Error */
590 if (priv->last_lsr & MCT_U232_LSR_OE) {
591 }
592 /* Parity Error */
593 if (priv->last_lsr & MCT_U232_LSR_PE) {
594 }
595 /* Framing Error */
596 if (priv->last_lsr & MCT_U232_LSR_FE) {
597 }
598 /* Break Indicator */
599 if (priv->last_lsr & MCT_U232_LSR_BI) {
600 }
601 }
602#endif
603 spin_unlock_irqrestore(&priv->lock, flags);
604exit:
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700605 retval = usb_submit_urb (urb, GFP_ATOMIC);
606 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 err ("%s - usb_submit_urb failed with result %d",
Greg Kroah-Hartmane96da392007-06-15 15:44:13 -0700608 __FUNCTION__, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609} /* mct_u232_read_int_callback */
610
611static void mct_u232_set_termios (struct usb_serial_port *port,
Alan Cox606d0992006-12-08 02:38:45 -0800612 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
614 struct usb_serial *serial = port->serial;
615 struct mct_u232_private *priv = usb_get_serial_port_data(port);
Alan Coxd0fab0d2007-12-13 16:15:29 -0800616 struct ktermios *termios = port->tty->termios;
617 unsigned int cflag = termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 unsigned int old_cflag = old_termios->c_cflag;
619 unsigned long flags;
Dave Platt45b844d2007-05-08 11:00:12 -0700620 unsigned int control_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 unsigned char last_lcr;
622
623 /* get a local copy of the current port settings */
624 spin_lock_irqsave(&priv->lock, flags);
625 control_state = priv->control_state;
626 spin_unlock_irqrestore(&priv->lock, flags);
627 last_lcr = 0;
628
629 /*
630 * Update baud rate.
631 * Do not attempt to cache old rates and skip settings,
632 * disconnects screw such tricks up completely.
633 * Premature optimization is the root of all evil.
634 */
635
Dave Platt45b844d2007-05-08 11:00:12 -0700636 /* reassert DTR and RTS on transition from B0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 if ((old_cflag & CBAUD) == B0) {
638 dbg("%s: baud was B0", __FUNCTION__);
Dave Platt45b844d2007-05-08 11:00:12 -0700639 control_state |= TIOCM_DTR | TIOCM_RTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 mct_u232_set_modem_ctrl(serial, control_state);
641 }
642
Alan Coxf4244902007-07-26 19:01:10 +0100643 mct_u232_set_baud_rate(serial, port, tty_get_baud_rate(port->tty));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
645 if ((cflag & CBAUD) == B0 ) {
646 dbg("%s: baud is B0", __FUNCTION__);
647 /* Drop RTS and DTR */
648 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
649 mct_u232_set_modem_ctrl(serial, control_state);
650 }
651
652 /*
653 * Update line control register (LCR)
654 */
655
656 /* set the parity */
657 if (cflag & PARENB)
658 last_lcr |= (cflag & PARODD) ?
659 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
660 else
661 last_lcr |= MCT_U232_PARITY_NONE;
662
663 /* set the number of data bits */
664 switch (cflag & CSIZE) {
665 case CS5:
666 last_lcr |= MCT_U232_DATA_BITS_5; break;
667 case CS6:
668 last_lcr |= MCT_U232_DATA_BITS_6; break;
669 case CS7:
670 last_lcr |= MCT_U232_DATA_BITS_7; break;
671 case CS8:
672 last_lcr |= MCT_U232_DATA_BITS_8; break;
673 default:
674 err("CSIZE was not CS5-CS8, using default of 8");
675 last_lcr |= MCT_U232_DATA_BITS_8;
676 break;
677 }
678
Alan Coxd0fab0d2007-12-13 16:15:29 -0800679 termios->c_cflag &= ~CMSPAR;
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 /* set the number of stop bits */
682 last_lcr |= (cflag & CSTOPB) ?
683 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
684
685 mct_u232_set_line_ctrl(serial, last_lcr);
686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 /* save off the modified port settings */
688 spin_lock_irqsave(&priv->lock, flags);
689 priv->control_state = control_state;
690 priv->last_lcr = last_lcr;
691 spin_unlock_irqrestore(&priv->lock, flags);
692} /* mct_u232_set_termios */
693
694static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
695{
696 struct usb_serial *serial = port->serial;
697 struct mct_u232_private *priv = usb_get_serial_port_data(port);
698 unsigned char lcr;
699 unsigned long flags;
700
701 dbg("%sstate=%d", __FUNCTION__, break_state);
702
703 spin_lock_irqsave(&priv->lock, flags);
704 lcr = priv->last_lcr;
705 spin_unlock_irqrestore(&priv->lock, flags);
706
707 if (break_state)
708 lcr |= MCT_U232_SET_BREAK;
709
710 mct_u232_set_line_ctrl(serial, lcr);
711} /* mct_u232_break_ctl */
712
713
714static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
715{
716 struct mct_u232_private *priv = usb_get_serial_port_data(port);
717 unsigned int control_state;
718 unsigned long flags;
719
720 dbg("%s", __FUNCTION__);
721
722 spin_lock_irqsave(&priv->lock, flags);
723 control_state = priv->control_state;
724 spin_unlock_irqrestore(&priv->lock, flags);
725
726 return control_state;
727}
728
729static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
730 unsigned int set, unsigned int clear)
731{
732 struct usb_serial *serial = port->serial;
733 struct mct_u232_private *priv = usb_get_serial_port_data(port);
734 unsigned int control_state;
735 unsigned long flags;
736
737 dbg("%s", __FUNCTION__);
738
739 spin_lock_irqsave(&priv->lock, flags);
740 control_state = priv->control_state;
741
742 if (set & TIOCM_RTS)
743 control_state |= TIOCM_RTS;
744 if (set & TIOCM_DTR)
745 control_state |= TIOCM_DTR;
746 if (clear & TIOCM_RTS)
747 control_state &= ~TIOCM_RTS;
748 if (clear & TIOCM_DTR)
749 control_state &= ~TIOCM_DTR;
750
751 priv->control_state = control_state;
752 spin_unlock_irqrestore(&priv->lock, flags);
753 return mct_u232_set_modem_ctrl(serial, control_state);
754}
755
756static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
757 unsigned int cmd, unsigned long arg)
758{
759 dbg("%scmd=0x%x", __FUNCTION__, cmd);
760
761 /* Based on code from acm.c and others */
762 switch (cmd) {
763 case TIOCMIWAIT:
764 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
765 /* TODO */
766 return( 0 );
767
768 case TIOCGICOUNT:
769 /* return count of modemline transitions */
770 /* TODO */
771 return 0;
772
773 default:
774 dbg("%s: arg not supported - 0x%04x", __FUNCTION__,cmd);
775 return(-ENOIOCTLCMD);
776 break;
777 }
778 return 0;
779} /* mct_u232_ioctl */
780
Dave Platt45b844d2007-05-08 11:00:12 -0700781static void mct_u232_throttle (struct usb_serial_port *port)
782{
783 struct mct_u232_private *priv = usb_get_serial_port_data(port);
784 unsigned long flags;
785 unsigned int control_state;
786 struct tty_struct *tty;
787
788 tty = port->tty;
789 dbg("%s - port %d", __FUNCTION__, port->number);
790
791 spin_lock_irqsave(&priv->lock, flags);
792 priv->rx_flags |= THROTTLED;
793 if (C_CRTSCTS(tty)) {
794 priv->control_state &= ~TIOCM_RTS;
795 control_state = priv->control_state;
796 spin_unlock_irqrestore(&priv->lock, flags);
797 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
798 } else {
799 spin_unlock_irqrestore(&priv->lock, flags);
800 }
801}
802
803
804static void mct_u232_unthrottle (struct usb_serial_port *port)
805{
806 struct mct_u232_private *priv = usb_get_serial_port_data(port);
807 unsigned long flags;
808 unsigned int control_state;
809 struct tty_struct *tty;
810
811 dbg("%s - port %d", __FUNCTION__, port->number);
812
813 tty = port->tty;
814 spin_lock_irqsave(&priv->lock, flags);
815 if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
816 priv->rx_flags &= ~THROTTLED;
817 priv->control_state |= TIOCM_RTS;
818 control_state = priv->control_state;
819 spin_unlock_irqrestore(&priv->lock, flags);
820 (void) mct_u232_set_modem_ctrl(port->serial, control_state);
821 } else {
822 spin_unlock_irqrestore(&priv->lock, flags);
823 }
824}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826static int __init mct_u232_init (void)
827{
828 int retval;
829 retval = usb_serial_register(&mct_u232_device);
830 if (retval)
831 goto failed_usb_serial_register;
832 retval = usb_register(&mct_u232_driver);
833 if (retval)
834 goto failed_usb_register;
835 info(DRIVER_DESC " " DRIVER_VERSION);
836 return 0;
837failed_usb_register:
838 usb_serial_deregister(&mct_u232_device);
839failed_usb_serial_register:
840 return retval;
841}
842
843
844static void __exit mct_u232_exit (void)
845{
846 usb_deregister (&mct_u232_driver);
847 usb_serial_deregister (&mct_u232_device);
848}
849
850
851module_init (mct_u232_init);
852module_exit(mct_u232_exit);
853
854MODULE_AUTHOR( DRIVER_AUTHOR );
855MODULE_DESCRIPTION( DRIVER_DESC );
856MODULE_LICENSE("GPL");
857
858module_param(debug, bool, S_IRUGO | S_IWUSR);
859MODULE_PARM_DESC(debug, "Debug enabled or not");