Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
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) | |
2afd8287 | 6 | * Copyright (C) 2010 Johan Hovold (jhovold@gmail.com) |
1da177e4 LT |
7 | * |
8 | * This program is largely derived from work by the linux-usb group | |
9 | * and associated source files. Please see the usb/serial files for | |
10 | * individual credits and copyrights. | |
b69c1499 | 11 | * |
1da177e4 LT |
12 | * This program is free software; you can redistribute it and/or modify |
13 | * it under the terms of the GNU General Public License as published by | |
14 | * the Free Software Foundation; either version 2 of the License, or | |
15 | * (at your option) any later version. | |
16 | * | |
b69c1499 AC |
17 | * See Documentation/usb/usb-serial.txt for more information on using this |
18 | * driver | |
1da177e4 LT |
19 | * |
20 | * TODO: | |
21 | * -- Add true modem contol line query capability. Currently we track the | |
22 | * states reported by the interrupt and the states we request. | |
23 | * -- Add error reporting back to application for UART error conditions. | |
24 | * Just point me at how to implement this and I'll do it. I've put the | |
25 | * framework in, but haven't analyzed the "tty_flip" interface yet. | |
26 | * -- Add support for flush commands | |
27 | * -- Add everything that is missing :) | |
28 | * | |
29 | * 27-Nov-2001 gkh | |
30 | * compressed all the differnent device entries into 1. | |
31 | * | |
32 | * 30-May-2001 gkh | |
b69c1499 AC |
33 | * switched from using spinlock to a semaphore, which fixes lots of |
34 | * problems. | |
1da177e4 LT |
35 | * |
36 | * 08-Apr-2001 gb | |
37 | * - Identify version on module load. | |
38 | * | |
39 | * 12-Mar-2001 gkh | |
40 | * - Added support for the GoHubs GO-COM232 device which is the same as the | |
41 | * Peracom device. | |
42 | * | |
43 | * 06-Nov-2000 gkh | |
44 | * - Added support for the old Belkin and Peracom devices. | |
45 | * - Made the port able to be opened multiple times. | |
46 | * - Added some defaults incase the line settings are things these devices | |
b69c1499 | 47 | * can't support. |
1da177e4 LT |
48 | * |
49 | * 18-Oct-2000 William Greathouse | |
50 | * Released into the wild (linux-usb-devel) | |
51 | * | |
52 | * 17-Oct-2000 William Greathouse | |
53 | * Add code to recognize firmware version and set hardware flow control | |
54 | * appropriately. Belkin states that firmware prior to 3.05 does not | |
55 | * operate correctly in hardware handshake mode. I have verified this | |
56 | * on firmware 2.05 -- for both RTS and DTR input flow control, the control | |
57 | * line is not reset. The test performed by the Belkin Win* driver is | |
58 | * to enable hardware flow control for firmware 2.06 or greater and | |
59 | * for 1.00 or prior. I am only enabling for 2.06 or greater. | |
60 | * | |
61 | * 12-Oct-2000 William Greathouse | |
62 | * First cut at supporting Belkin USB Serial Adapter F5U103 | |
63 | * I did not have a copy of the original work to support this | |
64 | * adapter, so pardon any stupid mistakes. All of the information | |
65 | * I am using to write this driver was acquired by using a modified | |
66 | * UsbSnoop on Windows2000 and from examining the other USB drivers. | |
67 | */ | |
68 | ||
1da177e4 LT |
69 | #include <linux/kernel.h> |
70 | #include <linux/errno.h> | |
71 | #include <linux/init.h> | |
72 | #include <linux/slab.h> | |
73 | #include <linux/tty.h> | |
74 | #include <linux/tty_driver.h> | |
75 | #include <linux/tty_flip.h> | |
76 | #include <linux/module.h> | |
77 | #include <linux/spinlock.h> | |
b69c1499 | 78 | #include <linux/uaccess.h> |
1da177e4 | 79 | #include <linux/usb.h> |
a969888c | 80 | #include <linux/usb/serial.h> |
1da177e4 LT |
81 | #include "belkin_sa.h" |
82 | ||
83 | static int debug; | |
84 | ||
85 | /* | |
86 | * Version Information | |
87 | */ | |
2afd8287 | 88 | #define DRIVER_VERSION "v1.3" |
1da177e4 LT |
89 | #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" |
90 | #define DRIVER_DESC "USB Belkin Serial converter driver" | |
91 | ||
92 | /* function prototypes for a Belkin USB Serial Adapter F5U103 */ | |
b69c1499 | 93 | static int belkin_sa_startup(struct usb_serial *serial); |
f9c99bb8 | 94 | static void belkin_sa_release(struct usb_serial *serial); |
b69c1499 | 95 | static int belkin_sa_open(struct tty_struct *tty, |
a509a7e4 | 96 | struct usb_serial_port *port); |
335f8514 | 97 | static void belkin_sa_close(struct usb_serial_port *port); |
b69c1499 | 98 | static void belkin_sa_read_int_callback(struct urb *urb); |
2afd8287 | 99 | static void belkin_sa_process_read_urb(struct urb *urb); |
b69c1499 AC |
100 | static void belkin_sa_set_termios(struct tty_struct *tty, |
101 | struct usb_serial_port *port, struct ktermios * old); | |
102 | static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state); | |
103 | static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file); | |
104 | static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file, | |
105 | unsigned int set, unsigned int clear); | |
1da177e4 LT |
106 | |
107 | ||
7d40d7e8 | 108 | static const struct usb_device_id id_table_combined[] = { |
1da177e4 LT |
109 | { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) }, |
110 | { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) }, | |
111 | { USB_DEVICE(PERACOM_VID, PERACOM_PID) }, | |
112 | { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) }, | |
113 | { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) }, | |
114 | { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) }, | |
b69c1499 | 115 | { } /* Terminating entry */ |
1da177e4 | 116 | }; |
b69c1499 | 117 | MODULE_DEVICE_TABLE(usb, id_table_combined); |
1da177e4 LT |
118 | |
119 | static struct usb_driver belkin_driver = { | |
1da177e4 LT |
120 | .name = "belkin", |
121 | .probe = usb_serial_probe, | |
122 | .disconnect = usb_serial_disconnect, | |
123 | .id_table = id_table_combined, | |
726ef428 | 124 | .no_dynamic_id = 1, |
1da177e4 LT |
125 | }; |
126 | ||
127 | /* All of the device info needed for the serial converters */ | |
ea65370d | 128 | static struct usb_serial_driver belkin_device = { |
18fcac35 GKH |
129 | .driver = { |
130 | .owner = THIS_MODULE, | |
269bda1c | 131 | .name = "belkin", |
18fcac35 | 132 | }, |
269bda1c | 133 | .description = "Belkin / Peracom / GoHubs USB Serial Adapter", |
d9b1b787 | 134 | .usb_driver = &belkin_driver, |
1da177e4 | 135 | .id_table = id_table_combined, |
1da177e4 LT |
136 | .num_ports = 1, |
137 | .open = belkin_sa_open, | |
138 | .close = belkin_sa_close, | |
b69c1499 | 139 | .read_int_callback = belkin_sa_read_int_callback, |
2afd8287 | 140 | .process_read_urb = belkin_sa_process_read_urb, |
1da177e4 LT |
141 | .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, | |
f9c99bb8 | 146 | .release = belkin_sa_release, |
1da177e4 LT |
147 | }; |
148 | ||
1da177e4 LT |
149 | struct belkin_sa_private { |
150 | spinlock_t lock; | |
151 | unsigned long control_state; | |
152 | unsigned char last_lsr; | |
153 | unsigned char last_msr; | |
154 | int bad_flow_control; | |
155 | }; | |
156 | ||
157 | ||
158 | /* | |
159 | * *************************************************************************** | |
160 | * Belkin USB Serial Adapter F5U103 specific driver functions | |
161 | * *************************************************************************** | |
162 | */ | |
163 | ||
164 | #define WDR_TIMEOUT 5000 /* default urb timeout */ | |
165 | ||
166 | /* assumes that struct usb_serial *serial is available */ | |
b69c1499 | 167 | #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \ |
1da177e4 LT |
168 | (c), BELKIN_SA_SET_REQUEST_TYPE, \ |
169 | (v), 0, NULL, 0, WDR_TIMEOUT) | |
170 | ||
171 | /* do some startup allocations not currently performed by usb_serial_probe() */ | |
b69c1499 | 172 | static int belkin_sa_startup(struct usb_serial *serial) |
1da177e4 LT |
173 | { |
174 | struct usb_device *dev = serial->dev; | |
175 | struct belkin_sa_private *priv; | |
176 | ||
177 | /* allocate the private data structure */ | |
178 | priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL); | |
179 | if (!priv) | |
b69c1499 | 180 | return -1; /* error */ |
1da177e4 LT |
181 | /* set initial values for control structures */ |
182 | spin_lock_init(&priv->lock); | |
183 | priv->control_state = 0; | |
184 | priv->last_lsr = 0; | |
185 | priv->last_msr = 0; | |
186 | /* see comments at top of file */ | |
b69c1499 AC |
187 | priv->bad_flow_control = |
188 | (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0; | |
c197a8db | 189 | dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n", |
b69c1499 AC |
190 | le16_to_cpu(dev->descriptor.bcdDevice), |
191 | priv->bad_flow_control); | |
1da177e4 LT |
192 | |
193 | init_waitqueue_head(&serial->port[0]->write_wait); | |
194 | usb_set_serial_port_data(serial->port[0], priv); | |
b69c1499 AC |
195 | |
196 | return 0; | |
1da177e4 LT |
197 | } |
198 | ||
f9c99bb8 | 199 | static void belkin_sa_release(struct usb_serial *serial) |
1da177e4 | 200 | { |
1da177e4 | 201 | int i; |
b69c1499 AC |
202 | |
203 | dbg("%s", __func__); | |
1da177e4 | 204 | |
726ef428 JH |
205 | for (i = 0; i < serial->num_ports; ++i) |
206 | kfree(usb_get_serial_port_data(serial->port[i])); | |
1da177e4 LT |
207 | } |
208 | ||
726ef428 | 209 | static int belkin_sa_open(struct tty_struct *tty, |
a509a7e4 | 210 | struct usb_serial_port *port) |
1da177e4 | 211 | { |
f2f8b7fe | 212 | int retval; |
1da177e4 | 213 | |
441b62c1 | 214 | dbg("%s port %d", __func__, port->number); |
1da177e4 | 215 | |
1da177e4 LT |
216 | retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); |
217 | if (retval) { | |
194343d9 | 218 | dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); |
f2f8b7fe | 219 | return retval; |
1da177e4 LT |
220 | } |
221 | ||
f2f8b7fe JH |
222 | retval = usb_serial_generic_open(tty, port); |
223 | if (retval) | |
224 | usb_kill_urb(port->interrupt_in_urb); | |
225 | ||
1da177e4 | 226 | return retval; |
726ef428 | 227 | } |
1da177e4 | 228 | |
335f8514 | 229 | static void belkin_sa_close(struct usb_serial_port *port) |
1da177e4 | 230 | { |
441b62c1 | 231 | dbg("%s port %d", __func__, port->number); |
1da177e4 | 232 | |
f26788da | 233 | usb_serial_generic_close(port); |
1da177e4 | 234 | usb_kill_urb(port->interrupt_in_urb); |
726ef428 | 235 | } |
1da177e4 | 236 | |
95da310e | 237 | static void belkin_sa_read_int_callback(struct urb *urb) |
1da177e4 | 238 | { |
cdc97792 | 239 | struct usb_serial_port *port = urb->context; |
1da177e4 LT |
240 | struct belkin_sa_private *priv; |
241 | unsigned char *data = urb->transfer_buffer; | |
242 | int retval; | |
f26aad25 | 243 | int status = urb->status; |
1da177e4 LT |
244 | unsigned long flags; |
245 | ||
f26aad25 | 246 | switch (status) { |
1da177e4 LT |
247 | case 0: |
248 | /* success */ | |
249 | break; | |
250 | case -ECONNRESET: | |
251 | case -ENOENT: | |
252 | case -ESHUTDOWN: | |
253 | /* this urb is terminated, clean up */ | |
f26aad25 | 254 | dbg("%s - urb shutting down with status: %d", |
441b62c1 | 255 | __func__, status); |
1da177e4 LT |
256 | return; |
257 | default: | |
f26aad25 | 258 | dbg("%s - nonzero urb status received: %d", |
441b62c1 | 259 | __func__, status); |
1da177e4 LT |
260 | goto exit; |
261 | } | |
262 | ||
b69c1499 AC |
263 | usb_serial_debug_data(debug, &port->dev, __func__, |
264 | urb->actual_length, data); | |
1da177e4 LT |
265 | |
266 | /* Handle known interrupt data */ | |
267 | /* ignore data[0] and data[1] */ | |
268 | ||
269 | priv = usb_get_serial_port_data(port); | |
270 | spin_lock_irqsave(&priv->lock, flags); | |
271 | priv->last_msr = data[BELKIN_SA_MSR_INDEX]; | |
b69c1499 | 272 | |
1da177e4 LT |
273 | /* Record Control Line states */ |
274 | if (priv->last_msr & BELKIN_SA_MSR_DSR) | |
275 | priv->control_state |= TIOCM_DSR; | |
276 | else | |
277 | priv->control_state &= ~TIOCM_DSR; | |
278 | ||
279 | if (priv->last_msr & BELKIN_SA_MSR_CTS) | |
280 | priv->control_state |= TIOCM_CTS; | |
281 | else | |
282 | priv->control_state &= ~TIOCM_CTS; | |
283 | ||
284 | if (priv->last_msr & BELKIN_SA_MSR_RI) | |
285 | priv->control_state |= TIOCM_RI; | |
286 | else | |
287 | priv->control_state &= ~TIOCM_RI; | |
288 | ||
289 | if (priv->last_msr & BELKIN_SA_MSR_CD) | |
290 | priv->control_state |= TIOCM_CD; | |
291 | else | |
292 | priv->control_state &= ~TIOCM_CD; | |
293 | ||
1da177e4 | 294 | priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; |
1da177e4 LT |
295 | spin_unlock_irqrestore(&priv->lock, flags); |
296 | exit: | |
b69c1499 | 297 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
1da177e4 | 298 | if (retval) |
194343d9 GKH |
299 | dev_err(&port->dev, "%s - usb_submit_urb failed with " |
300 | "result %d\n", __func__, retval); | |
1da177e4 LT |
301 | } |
302 | ||
2afd8287 JH |
303 | static void belkin_sa_process_read_urb(struct urb *urb) |
304 | { | |
305 | struct usb_serial_port *port = urb->context; | |
306 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
307 | struct tty_struct *tty; | |
308 | unsigned char *data = urb->transfer_buffer; | |
309 | unsigned long flags; | |
310 | unsigned char status; | |
311 | char tty_flag; | |
312 | ||
313 | /* Update line status */ | |
314 | tty_flag = TTY_NORMAL; | |
315 | ||
316 | spin_lock_irqsave(&priv->lock, flags); | |
317 | status = priv->last_lsr; | |
318 | priv->last_lsr &= ~BELKIN_SA_LSR_ERR; | |
319 | spin_unlock_irqrestore(&priv->lock, flags); | |
320 | ||
321 | if (!urb->actual_length) | |
322 | return; | |
323 | ||
324 | tty = tty_port_tty_get(&port->port); | |
325 | if (!tty) | |
326 | return; | |
327 | ||
328 | if (status & BELKIN_SA_LSR_ERR) { | |
329 | /* Break takes precedence over parity, which takes precedence | |
330 | * over framing errors. */ | |
331 | if (status & BELKIN_SA_LSR_BI) | |
332 | tty_flag = TTY_BREAK; | |
333 | else if (status & BELKIN_SA_LSR_PE) | |
334 | tty_flag = TTY_PARITY; | |
335 | else if (status & BELKIN_SA_LSR_FE) | |
336 | tty_flag = TTY_FRAME; | |
337 | dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); | |
338 | ||
339 | /* Overrun is special, not associated with a char. */ | |
340 | if (status & BELKIN_SA_LSR_OE) | |
341 | tty_insert_flip_char(tty, 0, TTY_OVERRUN); | |
342 | } | |
343 | ||
344 | tty_insert_flip_string_fixed_flag(tty, data, tty_flag, | |
345 | urb->actual_length); | |
346 | tty_flip_buffer_push(tty); | |
347 | tty_kref_put(tty); | |
348 | } | |
349 | ||
95da310e AC |
350 | static void belkin_sa_set_termios(struct tty_struct *tty, |
351 | struct usb_serial_port *port, struct ktermios *old_termios) | |
1da177e4 LT |
352 | { |
353 | struct usb_serial *serial = port->serial; | |
354 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
355 | unsigned int iflag; | |
356 | unsigned int cflag; | |
357 | unsigned int old_iflag = 0; | |
358 | unsigned int old_cflag = 0; | |
359 | __u16 urb_value = 0; /* Will hold the new flags */ | |
360 | unsigned long flags; | |
361 | unsigned long control_state; | |
362 | int bad_flow_control; | |
9a8baec7 | 363 | speed_t baud; |
95da310e | 364 | struct ktermios *termios = tty->termios; |
b69c1499 | 365 | |
3ec466b4 AC |
366 | iflag = termios->c_iflag; |
367 | cflag = termios->c_cflag; | |
1da177e4 | 368 | |
3ec466b4 | 369 | termios->c_cflag &= ~CMSPAR; |
1da177e4 LT |
370 | |
371 | /* get a local copy of the current port settings */ | |
372 | spin_lock_irqsave(&priv->lock, flags); | |
373 | control_state = priv->control_state; | |
374 | bad_flow_control = priv->bad_flow_control; | |
375 | spin_unlock_irqrestore(&priv->lock, flags); | |
b69c1499 | 376 | |
9a8baec7 AC |
377 | old_iflag = old_termios->c_iflag; |
378 | old_cflag = old_termios->c_cflag; | |
1da177e4 LT |
379 | |
380 | /* Set the baud rate */ | |
3ec466b4 | 381 | if ((cflag & CBAUD) != (old_cflag & CBAUD)) { |
1da177e4 | 382 | /* reassert DTR and (maybe) RTS on transition from B0 */ |
b69c1499 | 383 | if ((old_cflag & CBAUD) == B0) { |
1da177e4 LT |
384 | control_state |= (TIOCM_DTR|TIOCM_RTS); |
385 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) | |
194343d9 | 386 | dev_err(&port->dev, "Set DTR error\n"); |
1da177e4 | 387 | /* don't set RTS if using hardware flow control */ |
3ec466b4 | 388 | if (!(old_cflag & CRTSCTS)) |
b69c1499 AC |
389 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST |
390 | , 1) < 0) | |
194343d9 | 391 | dev_err(&port->dev, "Set RTS error\n"); |
1da177e4 | 392 | } |
9a8baec7 | 393 | } |
1da177e4 | 394 | |
95da310e | 395 | baud = tty_get_baud_rate(tty); |
3ec466b4 AC |
396 | if (baud) { |
397 | urb_value = BELKIN_SA_BAUD(baud); | |
398 | /* Clip to maximum speed */ | |
399 | if (urb_value == 0) | |
400 | urb_value = 1; | |
401 | /* Turn it back into a resulting real baud rate */ | |
402 | baud = BELKIN_SA_BAUD(urb_value); | |
403 | ||
404 | /* Report the actual baud rate back to the caller */ | |
95da310e | 405 | tty_encode_baud_rate(tty, baud, baud); |
9a8baec7 | 406 | if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) |
194343d9 | 407 | dev_err(&port->dev, "Set baudrate error\n"); |
9a8baec7 AC |
408 | } else { |
409 | /* Disable flow control */ | |
b69c1499 AC |
410 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, |
411 | BELKIN_SA_FLOW_NONE) < 0) | |
194343d9 | 412 | dev_err(&port->dev, "Disable flowcontrol error\n"); |
9a8baec7 AC |
413 | /* Drop RTS and DTR */ |
414 | control_state &= ~(TIOCM_DTR | TIOCM_RTS); | |
415 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) | |
194343d9 | 416 | dev_err(&port->dev, "DTR LOW error\n"); |
9a8baec7 | 417 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) |
194343d9 | 418 | dev_err(&port->dev, "RTS LOW error\n"); |
1da177e4 LT |
419 | } |
420 | ||
421 | /* set the parity */ | |
b69c1499 | 422 | if ((cflag ^ old_cflag) & (PARENB | PARODD)) { |
1da177e4 | 423 | if (cflag & PARENB) |
b69c1499 AC |
424 | urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD |
425 | : BELKIN_SA_PARITY_EVEN; | |
1da177e4 LT |
426 | else |
427 | urb_value = BELKIN_SA_PARITY_NONE; | |
428 | if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) | |
194343d9 | 429 | dev_err(&port->dev, "Set parity error\n"); |
1da177e4 LT |
430 | } |
431 | ||
432 | /* set the number of data bits */ | |
b69c1499 | 433 | if ((cflag & CSIZE) != (old_cflag & CSIZE)) { |
1da177e4 | 434 | switch (cflag & CSIZE) { |
b69c1499 AC |
435 | case CS5: |
436 | urb_value = BELKIN_SA_DATA_BITS(5); | |
437 | break; | |
438 | case CS6: | |
439 | urb_value = BELKIN_SA_DATA_BITS(6); | |
440 | break; | |
441 | case CS7: | |
442 | urb_value = BELKIN_SA_DATA_BITS(7); | |
443 | break; | |
444 | case CS8: | |
445 | urb_value = BELKIN_SA_DATA_BITS(8); | |
446 | break; | |
447 | default: dbg("CSIZE was not CS5-CS8, using default of 8"); | |
448 | urb_value = BELKIN_SA_DATA_BITS(8); | |
449 | break; | |
1da177e4 LT |
450 | } |
451 | if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) | |
194343d9 | 452 | dev_err(&port->dev, "Set data bits error\n"); |
1da177e4 LT |
453 | } |
454 | ||
455 | /* set the number of stop bits */ | |
b69c1499 AC |
456 | if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { |
457 | urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) | |
458 | : BELKIN_SA_STOP_BITS(1); | |
459 | if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, | |
460 | urb_value) < 0) | |
194343d9 | 461 | dev_err(&port->dev, "Set stop bits error\n"); |
1da177e4 LT |
462 | } |
463 | ||
464 | /* Set flow control */ | |
b69c1499 AC |
465 | if (((iflag ^ old_iflag) & (IXOFF | IXON)) || |
466 | ((cflag ^ old_cflag) & CRTSCTS)) { | |
1da177e4 LT |
467 | urb_value = 0; |
468 | if ((iflag & IXOFF) || (iflag & IXON)) | |
469 | urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); | |
470 | else | |
471 | urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); | |
472 | ||
473 | if (cflag & CRTSCTS) | |
474 | urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); | |
475 | else | |
476 | urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); | |
477 | ||
478 | if (bad_flow_control) | |
479 | urb_value &= ~(BELKIN_SA_FLOW_IRTS); | |
480 | ||
481 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) | |
194343d9 | 482 | dev_err(&port->dev, "Set flow control error\n"); |
1da177e4 LT |
483 | } |
484 | ||
485 | /* save off the modified port settings */ | |
486 | spin_lock_irqsave(&priv->lock, flags); | |
487 | priv->control_state = control_state; | |
488 | spin_unlock_irqrestore(&priv->lock, flags); | |
726ef428 | 489 | } |
1da177e4 | 490 | |
95da310e | 491 | static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) |
1da177e4 | 492 | { |
95da310e | 493 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
494 | struct usb_serial *serial = port->serial; |
495 | ||
496 | if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) | |
194343d9 | 497 | dev_err(&port->dev, "Set break_ctl %d\n", break_state); |
1da177e4 LT |
498 | } |
499 | ||
95da310e | 500 | static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file) |
1da177e4 | 501 | { |
95da310e | 502 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
503 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
504 | unsigned long control_state; | |
505 | unsigned long flags; | |
b69c1499 | 506 | |
441b62c1 | 507 | dbg("%s", __func__); |
1da177e4 LT |
508 | |
509 | spin_lock_irqsave(&priv->lock, flags); | |
510 | control_state = priv->control_state; | |
511 | spin_unlock_irqrestore(&priv->lock, flags); | |
512 | ||
513 | return control_state; | |
514 | } | |
515 | ||
95da310e | 516 | static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file, |
1da177e4 LT |
517 | unsigned int set, unsigned int clear) |
518 | { | |
95da310e | 519 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
520 | struct usb_serial *serial = port->serial; |
521 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
522 | unsigned long control_state; | |
523 | unsigned long flags; | |
524 | int retval; | |
525 | int rts = 0; | |
526 | int dtr = 0; | |
b69c1499 | 527 | |
441b62c1 | 528 | dbg("%s", __func__); |
1da177e4 LT |
529 | |
530 | spin_lock_irqsave(&priv->lock, flags); | |
531 | control_state = priv->control_state; | |
532 | ||
533 | if (set & TIOCM_RTS) { | |
534 | control_state |= TIOCM_RTS; | |
535 | rts = 1; | |
536 | } | |
537 | if (set & TIOCM_DTR) { | |
538 | control_state |= TIOCM_DTR; | |
539 | dtr = 1; | |
540 | } | |
541 | if (clear & TIOCM_RTS) { | |
542 | control_state &= ~TIOCM_RTS; | |
543 | rts = 0; | |
544 | } | |
545 | if (clear & TIOCM_DTR) { | |
546 | control_state &= ~TIOCM_DTR; | |
547 | dtr = 0; | |
548 | } | |
549 | ||
550 | priv->control_state = control_state; | |
551 | spin_unlock_irqrestore(&priv->lock, flags); | |
552 | ||
553 | retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); | |
554 | if (retval < 0) { | |
194343d9 | 555 | dev_err(&port->dev, "Set RTS error %d\n", retval); |
1da177e4 LT |
556 | goto exit; |
557 | } | |
558 | ||
559 | retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); | |
560 | if (retval < 0) { | |
194343d9 | 561 | dev_err(&port->dev, "Set DTR error %d\n", retval); |
1da177e4 LT |
562 | goto exit; |
563 | } | |
564 | exit: | |
565 | return retval; | |
566 | } | |
567 | ||
568 | ||
95da310e | 569 | static int __init belkin_sa_init(void) |
1da177e4 LT |
570 | { |
571 | int retval; | |
572 | retval = usb_serial_register(&belkin_device); | |
573 | if (retval) | |
574 | goto failed_usb_serial_register; | |
575 | retval = usb_register(&belkin_driver); | |
576 | if (retval) | |
577 | goto failed_usb_register; | |
c197a8db GKH |
578 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" |
579 | DRIVER_DESC "\n"); | |
1da177e4 LT |
580 | return 0; |
581 | failed_usb_register: | |
582 | usb_serial_deregister(&belkin_device); | |
583 | failed_usb_serial_register: | |
584 | return retval; | |
585 | } | |
586 | ||
1da177e4 LT |
587 | static void __exit belkin_sa_exit (void) |
588 | { | |
b69c1499 | 589 | usb_deregister(&belkin_driver); |
95da310e | 590 | usb_serial_deregister(&belkin_device); |
1da177e4 LT |
591 | } |
592 | ||
593 | ||
b69c1499 AC |
594 | module_init(belkin_sa_init); |
595 | module_exit(belkin_sa_exit); | |
1da177e4 | 596 | |
b69c1499 AC |
597 | MODULE_AUTHOR(DRIVER_AUTHOR); |
598 | MODULE_DESCRIPTION(DRIVER_DESC); | |
599 | MODULE_VERSION(DRIVER_VERSION); | |
1da177e4 LT |
600 | MODULE_LICENSE("GPL"); |
601 | ||
602 | module_param(debug, bool, S_IRUGO | S_IWUSR); | |
603 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |