blob: b7eacad4d48cb4ae34097c8d2ebbe7cb0ad0a363 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Belkin USB Serial Adapter Driver
3 *
4 * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com)
5 * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com)
6 *
7 * This program is largely derived from work by the linux-usb group
8 * and associated source files. Please see the usb/serial files for
9 * individual credits and copyrights.
Alan Coxb69c1492008-07-22 11:09:39 +010010 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
Alan Coxb69c1492008-07-22 11:09:39 +010016 * See Documentation/usb/usb-serial.txt for more information on using this
17 * driver
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 *
19 * TODO:
20 * -- Add true modem contol line query capability. Currently we track the
21 * states reported by the interrupt and the states we request.
22 * -- Add error reporting back to application for UART error conditions.
23 * Just point me at how to implement this and I'll do it. I've put the
24 * framework in, but haven't analyzed the "tty_flip" interface yet.
25 * -- Add support for flush commands
26 * -- Add everything that is missing :)
27 *
28 * 27-Nov-2001 gkh
29 * compressed all the differnent device entries into 1.
30 *
31 * 30-May-2001 gkh
Alan Coxb69c1492008-07-22 11:09:39 +010032 * switched from using spinlock to a semaphore, which fixes lots of
33 * problems.
Linus Torvalds1da177e2005-04-16 15:20:36 -070034 *
35 * 08-Apr-2001 gb
36 * - Identify version on module load.
37 *
38 * 12-Mar-2001 gkh
39 * - Added support for the GoHubs GO-COM232 device which is the same as the
40 * Peracom device.
41 *
42 * 06-Nov-2000 gkh
43 * - Added support for the old Belkin and Peracom devices.
44 * - Made the port able to be opened multiple times.
45 * - Added some defaults incase the line settings are things these devices
Alan Coxb69c1492008-07-22 11:09:39 +010046 * can't support.
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 *
48 * 18-Oct-2000 William Greathouse
49 * Released into the wild (linux-usb-devel)
50 *
51 * 17-Oct-2000 William Greathouse
52 * Add code to recognize firmware version and set hardware flow control
53 * appropriately. Belkin states that firmware prior to 3.05 does not
54 * operate correctly in hardware handshake mode. I have verified this
55 * on firmware 2.05 -- for both RTS and DTR input flow control, the control
56 * line is not reset. The test performed by the Belkin Win* driver is
57 * to enable hardware flow control for firmware 2.06 or greater and
58 * for 1.00 or prior. I am only enabling for 2.06 or greater.
59 *
60 * 12-Oct-2000 William Greathouse
61 * First cut at supporting Belkin USB Serial Adapter F5U103
62 * I did not have a copy of the original work to support this
63 * adapter, so pardon any stupid mistakes. All of the information
64 * I am using to write this driver was acquired by using a modified
65 * UsbSnoop on Windows2000 and from examining the other USB drivers.
66 */
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#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>
Alan Coxb69c1492008-07-22 11:09:39 +010077#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070078#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070079#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070080#include "belkin_sa.h"
81
82static int debug;
83
84/*
85 * Version Information
86 */
87#define DRIVER_VERSION "v1.2"
88#define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
89#define DRIVER_DESC "USB Belkin Serial converter driver"
90
91/* function prototypes for a Belkin USB Serial Adapter F5U103 */
Alan Coxb69c1492008-07-22 11:09:39 +010092static int belkin_sa_startup(struct usb_serial *serial);
93static void belkin_sa_shutdown(struct usb_serial *serial);
94static int belkin_sa_open(struct tty_struct *tty,
95 struct usb_serial_port *port, struct file *filp);
96static void belkin_sa_close(struct tty_struct *tty,
97 struct usb_serial_port *port, struct file *filp);
98static void belkin_sa_read_int_callback(struct urb *urb);
99static void belkin_sa_set_termios(struct tty_struct *tty,
100 struct usb_serial_port *port, struct ktermios * old);
101static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
102static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file);
103static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
104 unsigned int set, unsigned int clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
106
107static struct usb_device_id id_table_combined [] = {
108 { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
109 { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
110 { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
111 { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
112 { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
113 { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
Alan Coxb69c1492008-07-22 11:09:39 +0100114 { } /* Terminating entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
Alan Coxb69c1492008-07-22 11:09:39 +0100117MODULE_DEVICE_TABLE(usb, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119static struct usb_driver belkin_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 .name = "belkin",
121 .probe = usb_serial_probe,
122 .disconnect = usb_serial_disconnect,
123 .id_table = id_table_combined,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800124 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125};
126
127/* All of the device info needed for the serial converters */
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700128static struct usb_serial_driver belkin_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700129 .driver = {
130 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700131 .name = "belkin",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700132 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700133 .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100134 .usb_driver = &belkin_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 .id_table = id_table_combined,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 .num_ports = 1,
137 .open = belkin_sa_open,
138 .close = belkin_sa_close,
Alan Coxb69c1492008-07-22 11:09:39 +0100139 .read_int_callback = belkin_sa_read_int_callback,
140 /* How we get the status info */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 .set_termios = belkin_sa_set_termios,
142 .break_ctl = belkin_sa_break_ctl,
143 .tiocmget = belkin_sa_tiocmget,
144 .tiocmset = belkin_sa_tiocmset,
145 .attach = belkin_sa_startup,
146 .shutdown = belkin_sa_shutdown,
147};
148
149
150struct belkin_sa_private {
151 spinlock_t lock;
152 unsigned long control_state;
153 unsigned char last_lsr;
154 unsigned char last_msr;
155 int bad_flow_control;
156};
157
158
159/*
160 * ***************************************************************************
161 * Belkin USB Serial Adapter F5U103 specific driver functions
162 * ***************************************************************************
163 */
164
165#define WDR_TIMEOUT 5000 /* default urb timeout */
166
167/* assumes that struct usb_serial *serial is available */
Alan Coxb69c1492008-07-22 11:09:39 +0100168#define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 (c), BELKIN_SA_SET_REQUEST_TYPE, \
170 (v), 0, NULL, 0, WDR_TIMEOUT)
171
172/* do some startup allocations not currently performed by usb_serial_probe() */
Alan Coxb69c1492008-07-22 11:09:39 +0100173static int belkin_sa_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
175 struct usb_device *dev = serial->dev;
176 struct belkin_sa_private *priv;
177
178 /* allocate the private data structure */
179 priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
180 if (!priv)
Alan Coxb69c1492008-07-22 11:09:39 +0100181 return -1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 /* set initial values for control structures */
183 spin_lock_init(&priv->lock);
184 priv->control_state = 0;
185 priv->last_lsr = 0;
186 priv->last_msr = 0;
187 /* see comments at top of file */
Alan Coxb69c1492008-07-22 11:09:39 +0100188 priv->bad_flow_control =
189 (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700190 dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
Alan Coxb69c1492008-07-22 11:09:39 +0100191 le16_to_cpu(dev->descriptor.bcdDevice),
192 priv->bad_flow_control);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194 init_waitqueue_head(&serial->port[0]->write_wait);
195 usb_set_serial_port_data(serial->port[0], priv);
Alan Coxb69c1492008-07-22 11:09:39 +0100196
197 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198}
199
200
Alan Cox95da3102008-07-22 11:09:07 +0100201static void belkin_sa_shutdown(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
203 struct belkin_sa_private *priv;
204 int i;
Alan Coxb69c1492008-07-22 11:09:39 +0100205
206 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 /* stop reads and writes on all ports */
Alan Coxb69c1492008-07-22 11:09:39 +0100209 for (i = 0; i < serial->num_ports; ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 /* My special items, the standard routines free my urbs */
211 priv = usb_get_serial_port_data(serial->port[i]);
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -0700212 kfree(priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 }
214}
215
216
Alan Coxb69c1492008-07-22 11:09:39 +0100217static int belkin_sa_open(struct tty_struct *tty,
218 struct usb_serial_port *port, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 int retval = 0;
221
Harvey Harrison441b62c2008-03-03 16:08:34 -0800222 dbg("%s port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 /*Start reading from the device*/
225 /* TODO: Look at possibility of submitting multiple URBs to device to
226 * enhance buffering. Win trace shows 16 initial read URBs.
227 */
228 port->read_urb->dev = port->serial->dev;
229 retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
230 if (retval) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700231 dev_err(&port->dev, "usb_submit_urb(read bulk) failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 goto exit;
233 }
234
235 port->interrupt_in_urb->dev = port->serial->dev;
236 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
237 if (retval) {
238 usb_kill_urb(port->read_urb);
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700239 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
241
242exit:
243 return retval;
244} /* belkin_sa_open */
245
246
Alan Coxb69c1492008-07-22 11:09:39 +0100247static void belkin_sa_close(struct tty_struct *tty,
Alan Cox95da3102008-07-22 11:09:07 +0100248 struct usb_serial_port *port, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800250 dbg("%s port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
252 /* shutdown our bulk reads and writes */
253 usb_kill_urb(port->write_urb);
254 usb_kill_urb(port->read_urb);
255 usb_kill_urb(port->interrupt_in_urb);
256} /* belkin_sa_close */
257
258
Alan Cox95da3102008-07-22 11:09:07 +0100259static void belkin_sa_read_int_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
Ming Leicdc97792008-02-24 18:41:47 +0800261 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 struct belkin_sa_private *priv;
263 unsigned char *data = urb->transfer_buffer;
264 int retval;
Greg Kroah-Hartmanf26aad22007-06-15 15:44:13 -0700265 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 unsigned long flags;
267
Greg Kroah-Hartmanf26aad22007-06-15 15:44:13 -0700268 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 case 0:
270 /* success */
271 break;
272 case -ECONNRESET:
273 case -ENOENT:
274 case -ESHUTDOWN:
275 /* this urb is terminated, clean up */
Greg Kroah-Hartmanf26aad22007-06-15 15:44:13 -0700276 dbg("%s - urb shutting down with status: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800277 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 return;
279 default:
Greg Kroah-Hartmanf26aad22007-06-15 15:44:13 -0700280 dbg("%s - nonzero urb status received: %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800281 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 goto exit;
283 }
284
Alan Coxb69c1492008-07-22 11:09:39 +0100285 usb_serial_debug_data(debug, &port->dev, __func__,
286 urb->actual_length, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 /* Handle known interrupt data */
289 /* ignore data[0] and data[1] */
290
291 priv = usb_get_serial_port_data(port);
292 spin_lock_irqsave(&priv->lock, flags);
293 priv->last_msr = data[BELKIN_SA_MSR_INDEX];
Alan Coxb69c1492008-07-22 11:09:39 +0100294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 /* Record Control Line states */
296 if (priv->last_msr & BELKIN_SA_MSR_DSR)
297 priv->control_state |= TIOCM_DSR;
298 else
299 priv->control_state &= ~TIOCM_DSR;
300
301 if (priv->last_msr & BELKIN_SA_MSR_CTS)
302 priv->control_state |= TIOCM_CTS;
303 else
304 priv->control_state &= ~TIOCM_CTS;
305
306 if (priv->last_msr & BELKIN_SA_MSR_RI)
307 priv->control_state |= TIOCM_RI;
308 else
309 priv->control_state &= ~TIOCM_RI;
310
311 if (priv->last_msr & BELKIN_SA_MSR_CD)
312 priv->control_state |= TIOCM_CD;
313 else
314 priv->control_state &= ~TIOCM_CD;
315
316 /* Now to report any errors */
317 priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
318#if 0
319 /*
320 * fill in the flip buffer here, but I do not know the relation
321 * to the current/next receive buffer or characters. I need
322 * to look in to this before committing any code.
323 */
324 if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
Alan Cox4a90f092008-10-13 10:39:46 +0100325 tty = tty_port_tty_get(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 /* Overrun Error */
327 if (priv->last_lsr & BELKIN_SA_LSR_OE) {
328 }
329 /* Parity Error */
330 if (priv->last_lsr & BELKIN_SA_LSR_PE) {
331 }
332 /* Framing Error */
333 if (priv->last_lsr & BELKIN_SA_LSR_FE) {
334 }
335 /* Break Indicator */
336 if (priv->last_lsr & BELKIN_SA_LSR_BI) {
337 }
Alan Cox4a90f092008-10-13 10:39:46 +0100338 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
340#endif
341 spin_unlock_irqrestore(&priv->lock, flags);
342exit:
Alan Coxb69c1492008-07-22 11:09:39 +0100343 retval = usb_submit_urb(urb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (retval)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700345 dev_err(&port->dev, "%s - usb_submit_urb failed with "
346 "result %d\n", __func__, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347}
348
Alan Cox95da3102008-07-22 11:09:07 +0100349static void belkin_sa_set_termios(struct tty_struct *tty,
350 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
352 struct usb_serial *serial = port->serial;
353 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
354 unsigned int iflag;
355 unsigned int cflag;
356 unsigned int old_iflag = 0;
357 unsigned int old_cflag = 0;
358 __u16 urb_value = 0; /* Will hold the new flags */
359 unsigned long flags;
360 unsigned long control_state;
361 int bad_flow_control;
Alan Cox9a8baec2007-06-22 14:40:18 +0100362 speed_t baud;
Alan Cox95da3102008-07-22 11:09:07 +0100363 struct ktermios *termios = tty->termios;
Alan Coxb69c1492008-07-22 11:09:39 +0100364
Alan Cox3ec466b2007-12-13 16:15:26 -0800365 iflag = termios->c_iflag;
366 cflag = termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Alan Cox3ec466b2007-12-13 16:15:26 -0800368 termios->c_cflag &= ~CMSPAR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 /* get a local copy of the current port settings */
371 spin_lock_irqsave(&priv->lock, flags);
372 control_state = priv->control_state;
373 bad_flow_control = priv->bad_flow_control;
374 spin_unlock_irqrestore(&priv->lock, flags);
Alan Coxb69c1492008-07-22 11:09:39 +0100375
Alan Cox9a8baec2007-06-22 14:40:18 +0100376 old_iflag = old_termios->c_iflag;
377 old_cflag = old_termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 /* Set the baud rate */
Alan Cox3ec466b2007-12-13 16:15:26 -0800380 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 /* reassert DTR and (maybe) RTS on transition from B0 */
Alan Coxb69c1492008-07-22 11:09:39 +0100382 if ((old_cflag & CBAUD) == B0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 control_state |= (TIOCM_DTR|TIOCM_RTS);
384 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700385 dev_err(&port->dev, "Set DTR error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 /* don't set RTS if using hardware flow control */
Alan Cox3ec466b2007-12-13 16:15:26 -0800387 if (!(old_cflag & CRTSCTS))
Alan Coxb69c1492008-07-22 11:09:39 +0100388 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
389 , 1) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700390 dev_err(&port->dev, "Set RTS error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 }
Alan Cox9a8baec2007-06-22 14:40:18 +0100392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Alan Cox95da3102008-07-22 11:09:07 +0100394 baud = tty_get_baud_rate(tty);
Alan Cox3ec466b2007-12-13 16:15:26 -0800395 if (baud) {
396 urb_value = BELKIN_SA_BAUD(baud);
397 /* Clip to maximum speed */
398 if (urb_value == 0)
399 urb_value = 1;
400 /* Turn it back into a resulting real baud rate */
401 baud = BELKIN_SA_BAUD(urb_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Alan Cox3ec466b2007-12-13 16:15:26 -0800403 /* Report the actual baud rate back to the caller */
Alan Cox95da3102008-07-22 11:09:07 +0100404 tty_encode_baud_rate(tty, baud, baud);
Alan Cox9a8baec2007-06-22 14:40:18 +0100405 if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700406 dev_err(&port->dev, "Set baudrate error\n");
Alan Cox9a8baec2007-06-22 14:40:18 +0100407 } else {
408 /* Disable flow control */
Alan Coxb69c1492008-07-22 11:09:39 +0100409 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
410 BELKIN_SA_FLOW_NONE) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700411 dev_err(&port->dev, "Disable flowcontrol error\n");
Alan Cox9a8baec2007-06-22 14:40:18 +0100412 /* Drop RTS and DTR */
413 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
414 if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700415 dev_err(&port->dev, "DTR LOW error\n");
Alan Cox9a8baec2007-06-22 14:40:18 +0100416 if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700417 dev_err(&port->dev, "RTS LOW error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419
420 /* set the parity */
Alan Coxb69c1492008-07-22 11:09:39 +0100421 if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 if (cflag & PARENB)
Alan Coxb69c1492008-07-22 11:09:39 +0100423 urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD
424 : BELKIN_SA_PARITY_EVEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 else
426 urb_value = BELKIN_SA_PARITY_NONE;
427 if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700428 dev_err(&port->dev, "Set parity error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 }
430
431 /* set the number of data bits */
Alan Coxb69c1492008-07-22 11:09:39 +0100432 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 switch (cflag & CSIZE) {
Alan Coxb69c1492008-07-22 11:09:39 +0100434 case CS5:
435 urb_value = BELKIN_SA_DATA_BITS(5);
436 break;
437 case CS6:
438 urb_value = BELKIN_SA_DATA_BITS(6);
439 break;
440 case CS7:
441 urb_value = BELKIN_SA_DATA_BITS(7);
442 break;
443 case CS8:
444 urb_value = BELKIN_SA_DATA_BITS(8);
445 break;
446 default: dbg("CSIZE was not CS5-CS8, using default of 8");
447 urb_value = BELKIN_SA_DATA_BITS(8);
448 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
450 if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700451 dev_err(&port->dev, "Set data bits error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453
454 /* set the number of stop bits */
Alan Coxb69c1492008-07-22 11:09:39 +0100455 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
456 urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
457 : BELKIN_SA_STOP_BITS(1);
458 if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
459 urb_value) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700460 dev_err(&port->dev, "Set stop bits error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 }
462
463 /* Set flow control */
Alan Coxb69c1492008-07-22 11:09:39 +0100464 if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
465 ((cflag ^ old_cflag) & CRTSCTS)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 urb_value = 0;
467 if ((iflag & IXOFF) || (iflag & IXON))
468 urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
469 else
470 urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
471
472 if (cflag & CRTSCTS)
473 urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
474 else
475 urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
476
477 if (bad_flow_control)
478 urb_value &= ~(BELKIN_SA_FLOW_IRTS);
479
480 if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700481 dev_err(&port->dev, "Set flow control error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
483
484 /* save off the modified port settings */
485 spin_lock_irqsave(&priv->lock, flags);
486 priv->control_state = control_state;
487 spin_unlock_irqrestore(&priv->lock, flags);
488} /* belkin_sa_set_termios */
489
490
Alan Cox95da3102008-07-22 11:09:07 +0100491static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
Alan Cox95da3102008-07-22 11:09:07 +0100493 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 struct usb_serial *serial = port->serial;
495
496 if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700497 dev_err(&port->dev, "Set break_ctl %d\n", break_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498}
499
500
Alan Cox95da3102008-07-22 11:09:07 +0100501static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Alan Cox95da3102008-07-22 11:09:07 +0100503 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
505 unsigned long control_state;
506 unsigned long flags;
Alan Coxb69c1492008-07-22 11:09:39 +0100507
Harvey Harrison441b62c2008-03-03 16:08:34 -0800508 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 spin_lock_irqsave(&priv->lock, flags);
511 control_state = priv->control_state;
512 spin_unlock_irqrestore(&priv->lock, flags);
513
514 return control_state;
515}
516
517
Alan Cox95da3102008-07-22 11:09:07 +0100518static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 unsigned int set, unsigned int clear)
520{
Alan Cox95da3102008-07-22 11:09:07 +0100521 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 struct usb_serial *serial = port->serial;
523 struct belkin_sa_private *priv = usb_get_serial_port_data(port);
524 unsigned long control_state;
525 unsigned long flags;
526 int retval;
527 int rts = 0;
528 int dtr = 0;
Alan Coxb69c1492008-07-22 11:09:39 +0100529
Harvey Harrison441b62c2008-03-03 16:08:34 -0800530 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 spin_lock_irqsave(&priv->lock, flags);
533 control_state = priv->control_state;
534
535 if (set & TIOCM_RTS) {
536 control_state |= TIOCM_RTS;
537 rts = 1;
538 }
539 if (set & TIOCM_DTR) {
540 control_state |= TIOCM_DTR;
541 dtr = 1;
542 }
543 if (clear & TIOCM_RTS) {
544 control_state &= ~TIOCM_RTS;
545 rts = 0;
546 }
547 if (clear & TIOCM_DTR) {
548 control_state &= ~TIOCM_DTR;
549 dtr = 0;
550 }
551
552 priv->control_state = control_state;
553 spin_unlock_irqrestore(&priv->lock, flags);
554
555 retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
556 if (retval < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700557 dev_err(&port->dev, "Set RTS error %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 goto exit;
559 }
560
561 retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
562 if (retval < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700563 dev_err(&port->dev, "Set DTR error %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 goto exit;
565 }
566exit:
567 return retval;
568}
569
570
Alan Cox95da3102008-07-22 11:09:07 +0100571static int __init belkin_sa_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
573 int retval;
574 retval = usb_serial_register(&belkin_device);
575 if (retval)
576 goto failed_usb_serial_register;
577 retval = usb_register(&belkin_driver);
578 if (retval)
579 goto failed_usb_register;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700580 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
581 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return 0;
583failed_usb_register:
584 usb_serial_deregister(&belkin_device);
585failed_usb_serial_register:
586 return retval;
587}
588
589
590static void __exit belkin_sa_exit (void)
591{
Alan Coxb69c1492008-07-22 11:09:39 +0100592 usb_deregister(&belkin_driver);
Alan Cox95da3102008-07-22 11:09:07 +0100593 usb_serial_deregister(&belkin_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
595
596
Alan Coxb69c1492008-07-22 11:09:39 +0100597module_init(belkin_sa_init);
598module_exit(belkin_sa_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Alan Coxb69c1492008-07-22 11:09:39 +0100600MODULE_AUTHOR(DRIVER_AUTHOR);
601MODULE_DESCRIPTION(DRIVER_DESC);
602MODULE_VERSION(DRIVER_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603MODULE_LICENSE("GPL");
604
605module_param(debug, bool, S_IRUGO | S_IWUSR);
606MODULE_PARM_DESC(debug, "Debug enabled or not");