Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Belkin USB Serial Adapter Driver | |
3 | * | |
4 | * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com) | |
70f3c758 | 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 | * |
70f3c758 BM |
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. | |
1da177e4 | 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. | |
1da177e4 | 23 | * -- Add support for flush commands |
1da177e4 LT |
24 | */ |
25 | ||
1da177e4 LT |
26 | #include <linux/kernel.h> |
27 | #include <linux/errno.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/slab.h> | |
30 | #include <linux/tty.h> | |
31 | #include <linux/tty_driver.h> | |
32 | #include <linux/tty_flip.h> | |
33 | #include <linux/module.h> | |
34 | #include <linux/spinlock.h> | |
b69c1499 | 35 | #include <linux/uaccess.h> |
1da177e4 | 36 | #include <linux/usb.h> |
a969888c | 37 | #include <linux/usb/serial.h> |
1da177e4 LT |
38 | #include "belkin_sa.h" |
39 | ||
90ab5ee9 | 40 | static bool debug; |
1da177e4 LT |
41 | |
42 | /* | |
43 | * Version Information | |
44 | */ | |
2afd8287 | 45 | #define DRIVER_VERSION "v1.3" |
1da177e4 LT |
46 | #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>" |
47 | #define DRIVER_DESC "USB Belkin Serial converter driver" | |
48 | ||
49 | /* function prototypes for a Belkin USB Serial Adapter F5U103 */ | |
b69c1499 | 50 | static int belkin_sa_startup(struct usb_serial *serial); |
f9c99bb8 | 51 | static void belkin_sa_release(struct usb_serial *serial); |
b69c1499 | 52 | static int belkin_sa_open(struct tty_struct *tty, |
a509a7e4 | 53 | struct usb_serial_port *port); |
335f8514 | 54 | static void belkin_sa_close(struct usb_serial_port *port); |
b69c1499 | 55 | static void belkin_sa_read_int_callback(struct urb *urb); |
2afd8287 | 56 | static void belkin_sa_process_read_urb(struct urb *urb); |
b69c1499 AC |
57 | static void belkin_sa_set_termios(struct tty_struct *tty, |
58 | struct usb_serial_port *port, struct ktermios * old); | |
59 | static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state); | |
60b33c13 | 60 | static int belkin_sa_tiocmget(struct tty_struct *tty); |
20b9d177 | 61 | static int belkin_sa_tiocmset(struct tty_struct *tty, |
b69c1499 | 62 | unsigned int set, unsigned int clear); |
1da177e4 LT |
63 | |
64 | ||
68e24113 | 65 | static const struct usb_device_id id_table[] = { |
1da177e4 LT |
66 | { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) }, |
67 | { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) }, | |
68 | { USB_DEVICE(PERACOM_VID, PERACOM_PID) }, | |
69 | { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) }, | |
70 | { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) }, | |
71 | { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) }, | |
b69c1499 | 72 | { } /* Terminating entry */ |
1da177e4 | 73 | }; |
68e24113 | 74 | MODULE_DEVICE_TABLE(usb, id_table); |
1da177e4 LT |
75 | |
76 | /* All of the device info needed for the serial converters */ | |
ea65370d | 77 | static struct usb_serial_driver belkin_device = { |
18fcac35 GKH |
78 | .driver = { |
79 | .owner = THIS_MODULE, | |
269bda1c | 80 | .name = "belkin", |
18fcac35 | 81 | }, |
269bda1c | 82 | .description = "Belkin / Peracom / GoHubs USB Serial Adapter", |
68e24113 | 83 | .id_table = id_table, |
1da177e4 LT |
84 | .num_ports = 1, |
85 | .open = belkin_sa_open, | |
86 | .close = belkin_sa_close, | |
b69c1499 | 87 | .read_int_callback = belkin_sa_read_int_callback, |
2afd8287 | 88 | .process_read_urb = belkin_sa_process_read_urb, |
1da177e4 LT |
89 | .set_termios = belkin_sa_set_termios, |
90 | .break_ctl = belkin_sa_break_ctl, | |
91 | .tiocmget = belkin_sa_tiocmget, | |
92 | .tiocmset = belkin_sa_tiocmset, | |
93 | .attach = belkin_sa_startup, | |
f9c99bb8 | 94 | .release = belkin_sa_release, |
1da177e4 LT |
95 | }; |
96 | ||
08a4f6bc AS |
97 | static struct usb_serial_driver * const serial_drivers[] = { |
98 | &belkin_device, NULL | |
99 | }; | |
100 | ||
1da177e4 LT |
101 | struct belkin_sa_private { |
102 | spinlock_t lock; | |
103 | unsigned long control_state; | |
104 | unsigned char last_lsr; | |
105 | unsigned char last_msr; | |
106 | int bad_flow_control; | |
107 | }; | |
108 | ||
109 | ||
110 | /* | |
111 | * *************************************************************************** | |
112 | * Belkin USB Serial Adapter F5U103 specific driver functions | |
113 | * *************************************************************************** | |
114 | */ | |
115 | ||
116 | #define WDR_TIMEOUT 5000 /* default urb timeout */ | |
117 | ||
118 | /* assumes that struct usb_serial *serial is available */ | |
b69c1499 | 119 | #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \ |
1da177e4 LT |
120 | (c), BELKIN_SA_SET_REQUEST_TYPE, \ |
121 | (v), 0, NULL, 0, WDR_TIMEOUT) | |
122 | ||
123 | /* do some startup allocations not currently performed by usb_serial_probe() */ | |
b69c1499 | 124 | static int belkin_sa_startup(struct usb_serial *serial) |
1da177e4 LT |
125 | { |
126 | struct usb_device *dev = serial->dev; | |
127 | struct belkin_sa_private *priv; | |
128 | ||
129 | /* allocate the private data structure */ | |
130 | priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL); | |
131 | if (!priv) | |
b69c1499 | 132 | return -1; /* error */ |
1da177e4 LT |
133 | /* set initial values for control structures */ |
134 | spin_lock_init(&priv->lock); | |
135 | priv->control_state = 0; | |
136 | priv->last_lsr = 0; | |
137 | priv->last_msr = 0; | |
138 | /* see comments at top of file */ | |
b69c1499 AC |
139 | priv->bad_flow_control = |
140 | (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0; | |
c197a8db | 141 | dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n", |
b69c1499 AC |
142 | le16_to_cpu(dev->descriptor.bcdDevice), |
143 | priv->bad_flow_control); | |
1da177e4 LT |
144 | |
145 | init_waitqueue_head(&serial->port[0]->write_wait); | |
146 | usb_set_serial_port_data(serial->port[0], priv); | |
b69c1499 AC |
147 | |
148 | return 0; | |
1da177e4 LT |
149 | } |
150 | ||
f9c99bb8 | 151 | static void belkin_sa_release(struct usb_serial *serial) |
1da177e4 | 152 | { |
1da177e4 | 153 | int i; |
b69c1499 | 154 | |
726ef428 JH |
155 | for (i = 0; i < serial->num_ports; ++i) |
156 | kfree(usb_get_serial_port_data(serial->port[i])); | |
1da177e4 LT |
157 | } |
158 | ||
726ef428 | 159 | static int belkin_sa_open(struct tty_struct *tty, |
a509a7e4 | 160 | struct usb_serial_port *port) |
1da177e4 | 161 | { |
f2f8b7fe | 162 | int retval; |
1da177e4 | 163 | |
1da177e4 LT |
164 | retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); |
165 | if (retval) { | |
194343d9 | 166 | dev_err(&port->dev, "usb_submit_urb(read int) failed\n"); |
f2f8b7fe | 167 | return retval; |
1da177e4 LT |
168 | } |
169 | ||
f2f8b7fe JH |
170 | retval = usb_serial_generic_open(tty, port); |
171 | if (retval) | |
172 | usb_kill_urb(port->interrupt_in_urb); | |
173 | ||
1da177e4 | 174 | return retval; |
726ef428 | 175 | } |
1da177e4 | 176 | |
335f8514 | 177 | static void belkin_sa_close(struct usb_serial_port *port) |
1da177e4 | 178 | { |
f26788da | 179 | usb_serial_generic_close(port); |
1da177e4 | 180 | usb_kill_urb(port->interrupt_in_urb); |
726ef428 | 181 | } |
1da177e4 | 182 | |
95da310e | 183 | static void belkin_sa_read_int_callback(struct urb *urb) |
1da177e4 | 184 | { |
cdc97792 | 185 | struct usb_serial_port *port = urb->context; |
1da177e4 LT |
186 | struct belkin_sa_private *priv; |
187 | unsigned char *data = urb->transfer_buffer; | |
188 | int retval; | |
f26aad25 | 189 | int status = urb->status; |
1da177e4 LT |
190 | unsigned long flags; |
191 | ||
f26aad25 | 192 | switch (status) { |
1da177e4 LT |
193 | case 0: |
194 | /* success */ | |
195 | break; | |
196 | case -ECONNRESET: | |
197 | case -ENOENT: | |
198 | case -ESHUTDOWN: | |
199 | /* this urb is terminated, clean up */ | |
c89aa638 GKH |
200 | dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", |
201 | __func__, status); | |
1da177e4 LT |
202 | return; |
203 | default: | |
c89aa638 GKH |
204 | dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", |
205 | __func__, status); | |
1da177e4 LT |
206 | goto exit; |
207 | } | |
208 | ||
b69c1499 AC |
209 | usb_serial_debug_data(debug, &port->dev, __func__, |
210 | urb->actual_length, data); | |
1da177e4 LT |
211 | |
212 | /* Handle known interrupt data */ | |
213 | /* ignore data[0] and data[1] */ | |
214 | ||
215 | priv = usb_get_serial_port_data(port); | |
216 | spin_lock_irqsave(&priv->lock, flags); | |
217 | priv->last_msr = data[BELKIN_SA_MSR_INDEX]; | |
b69c1499 | 218 | |
1da177e4 LT |
219 | /* Record Control Line states */ |
220 | if (priv->last_msr & BELKIN_SA_MSR_DSR) | |
221 | priv->control_state |= TIOCM_DSR; | |
222 | else | |
223 | priv->control_state &= ~TIOCM_DSR; | |
224 | ||
225 | if (priv->last_msr & BELKIN_SA_MSR_CTS) | |
226 | priv->control_state |= TIOCM_CTS; | |
227 | else | |
228 | priv->control_state &= ~TIOCM_CTS; | |
229 | ||
230 | if (priv->last_msr & BELKIN_SA_MSR_RI) | |
231 | priv->control_state |= TIOCM_RI; | |
232 | else | |
233 | priv->control_state &= ~TIOCM_RI; | |
234 | ||
235 | if (priv->last_msr & BELKIN_SA_MSR_CD) | |
236 | priv->control_state |= TIOCM_CD; | |
237 | else | |
238 | priv->control_state &= ~TIOCM_CD; | |
239 | ||
1da177e4 | 240 | priv->last_lsr = data[BELKIN_SA_LSR_INDEX]; |
1da177e4 LT |
241 | spin_unlock_irqrestore(&priv->lock, flags); |
242 | exit: | |
b69c1499 | 243 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
1da177e4 | 244 | if (retval) |
194343d9 GKH |
245 | dev_err(&port->dev, "%s - usb_submit_urb failed with " |
246 | "result %d\n", __func__, retval); | |
1da177e4 LT |
247 | } |
248 | ||
2afd8287 JH |
249 | static void belkin_sa_process_read_urb(struct urb *urb) |
250 | { | |
251 | struct usb_serial_port *port = urb->context; | |
252 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
253 | struct tty_struct *tty; | |
254 | unsigned char *data = urb->transfer_buffer; | |
255 | unsigned long flags; | |
256 | unsigned char status; | |
257 | char tty_flag; | |
258 | ||
259 | /* Update line status */ | |
260 | tty_flag = TTY_NORMAL; | |
261 | ||
262 | spin_lock_irqsave(&priv->lock, flags); | |
263 | status = priv->last_lsr; | |
264 | priv->last_lsr &= ~BELKIN_SA_LSR_ERR; | |
265 | spin_unlock_irqrestore(&priv->lock, flags); | |
266 | ||
267 | if (!urb->actual_length) | |
268 | return; | |
269 | ||
270 | tty = tty_port_tty_get(&port->port); | |
271 | if (!tty) | |
272 | return; | |
273 | ||
274 | if (status & BELKIN_SA_LSR_ERR) { | |
275 | /* Break takes precedence over parity, which takes precedence | |
276 | * over framing errors. */ | |
277 | if (status & BELKIN_SA_LSR_BI) | |
278 | tty_flag = TTY_BREAK; | |
279 | else if (status & BELKIN_SA_LSR_PE) | |
280 | tty_flag = TTY_PARITY; | |
281 | else if (status & BELKIN_SA_LSR_FE) | |
282 | tty_flag = TTY_FRAME; | |
283 | dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag); | |
284 | ||
285 | /* Overrun is special, not associated with a char. */ | |
286 | if (status & BELKIN_SA_LSR_OE) | |
287 | tty_insert_flip_char(tty, 0, TTY_OVERRUN); | |
288 | } | |
289 | ||
290 | tty_insert_flip_string_fixed_flag(tty, data, tty_flag, | |
291 | urb->actual_length); | |
292 | tty_flip_buffer_push(tty); | |
293 | tty_kref_put(tty); | |
294 | } | |
295 | ||
95da310e AC |
296 | static void belkin_sa_set_termios(struct tty_struct *tty, |
297 | struct usb_serial_port *port, struct ktermios *old_termios) | |
1da177e4 LT |
298 | { |
299 | struct usb_serial *serial = port->serial; | |
300 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
301 | unsigned int iflag; | |
302 | unsigned int cflag; | |
303 | unsigned int old_iflag = 0; | |
304 | unsigned int old_cflag = 0; | |
305 | __u16 urb_value = 0; /* Will hold the new flags */ | |
306 | unsigned long flags; | |
307 | unsigned long control_state; | |
308 | int bad_flow_control; | |
9a8baec7 | 309 | speed_t baud; |
adc8d746 | 310 | struct ktermios *termios = &tty->termios; |
b69c1499 | 311 | |
3ec466b4 AC |
312 | iflag = termios->c_iflag; |
313 | cflag = termios->c_cflag; | |
1da177e4 | 314 | |
3ec466b4 | 315 | termios->c_cflag &= ~CMSPAR; |
1da177e4 LT |
316 | |
317 | /* get a local copy of the current port settings */ | |
318 | spin_lock_irqsave(&priv->lock, flags); | |
319 | control_state = priv->control_state; | |
320 | bad_flow_control = priv->bad_flow_control; | |
321 | spin_unlock_irqrestore(&priv->lock, flags); | |
b69c1499 | 322 | |
9a8baec7 AC |
323 | old_iflag = old_termios->c_iflag; |
324 | old_cflag = old_termios->c_cflag; | |
1da177e4 LT |
325 | |
326 | /* Set the baud rate */ | |
3ec466b4 | 327 | if ((cflag & CBAUD) != (old_cflag & CBAUD)) { |
1da177e4 | 328 | /* reassert DTR and (maybe) RTS on transition from B0 */ |
b69c1499 | 329 | if ((old_cflag & CBAUD) == B0) { |
1da177e4 LT |
330 | control_state |= (TIOCM_DTR|TIOCM_RTS); |
331 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0) | |
194343d9 | 332 | dev_err(&port->dev, "Set DTR error\n"); |
1da177e4 | 333 | /* don't set RTS if using hardware flow control */ |
3ec466b4 | 334 | if (!(old_cflag & CRTSCTS)) |
b69c1499 AC |
335 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST |
336 | , 1) < 0) | |
194343d9 | 337 | dev_err(&port->dev, "Set RTS error\n"); |
1da177e4 | 338 | } |
9a8baec7 | 339 | } |
1da177e4 | 340 | |
95da310e | 341 | baud = tty_get_baud_rate(tty); |
3ec466b4 AC |
342 | if (baud) { |
343 | urb_value = BELKIN_SA_BAUD(baud); | |
344 | /* Clip to maximum speed */ | |
345 | if (urb_value == 0) | |
346 | urb_value = 1; | |
347 | /* Turn it back into a resulting real baud rate */ | |
348 | baud = BELKIN_SA_BAUD(urb_value); | |
349 | ||
350 | /* Report the actual baud rate back to the caller */ | |
95da310e | 351 | tty_encode_baud_rate(tty, baud, baud); |
9a8baec7 | 352 | if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0) |
194343d9 | 353 | dev_err(&port->dev, "Set baudrate error\n"); |
9a8baec7 AC |
354 | } else { |
355 | /* Disable flow control */ | |
b69c1499 AC |
356 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, |
357 | BELKIN_SA_FLOW_NONE) < 0) | |
194343d9 | 358 | dev_err(&port->dev, "Disable flowcontrol error\n"); |
9a8baec7 AC |
359 | /* Drop RTS and DTR */ |
360 | control_state &= ~(TIOCM_DTR | TIOCM_RTS); | |
361 | if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0) | |
194343d9 | 362 | dev_err(&port->dev, "DTR LOW error\n"); |
9a8baec7 | 363 | if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0) |
194343d9 | 364 | dev_err(&port->dev, "RTS LOW error\n"); |
1da177e4 LT |
365 | } |
366 | ||
367 | /* set the parity */ | |
b69c1499 | 368 | if ((cflag ^ old_cflag) & (PARENB | PARODD)) { |
1da177e4 | 369 | if (cflag & PARENB) |
b69c1499 AC |
370 | urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD |
371 | : BELKIN_SA_PARITY_EVEN; | |
1da177e4 LT |
372 | else |
373 | urb_value = BELKIN_SA_PARITY_NONE; | |
374 | if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0) | |
194343d9 | 375 | dev_err(&port->dev, "Set parity error\n"); |
1da177e4 LT |
376 | } |
377 | ||
378 | /* set the number of data bits */ | |
b69c1499 | 379 | if ((cflag & CSIZE) != (old_cflag & CSIZE)) { |
1da177e4 | 380 | switch (cflag & CSIZE) { |
b69c1499 AC |
381 | case CS5: |
382 | urb_value = BELKIN_SA_DATA_BITS(5); | |
383 | break; | |
384 | case CS6: | |
385 | urb_value = BELKIN_SA_DATA_BITS(6); | |
386 | break; | |
387 | case CS7: | |
388 | urb_value = BELKIN_SA_DATA_BITS(7); | |
389 | break; | |
390 | case CS8: | |
391 | urb_value = BELKIN_SA_DATA_BITS(8); | |
392 | break; | |
70f3c758 | 393 | default: |
c89aa638 GKH |
394 | dev_dbg(&port->dev, |
395 | "CSIZE was not CS5-CS8, using default of 8\n"); | |
b69c1499 AC |
396 | urb_value = BELKIN_SA_DATA_BITS(8); |
397 | break; | |
1da177e4 LT |
398 | } |
399 | if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0) | |
194343d9 | 400 | dev_err(&port->dev, "Set data bits error\n"); |
1da177e4 LT |
401 | } |
402 | ||
403 | /* set the number of stop bits */ | |
b69c1499 AC |
404 | if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { |
405 | urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2) | |
406 | : BELKIN_SA_STOP_BITS(1); | |
407 | if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST, | |
408 | urb_value) < 0) | |
194343d9 | 409 | dev_err(&port->dev, "Set stop bits error\n"); |
1da177e4 LT |
410 | } |
411 | ||
412 | /* Set flow control */ | |
b69c1499 AC |
413 | if (((iflag ^ old_iflag) & (IXOFF | IXON)) || |
414 | ((cflag ^ old_cflag) & CRTSCTS)) { | |
1da177e4 LT |
415 | urb_value = 0; |
416 | if ((iflag & IXOFF) || (iflag & IXON)) | |
417 | urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); | |
418 | else | |
419 | urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON); | |
420 | ||
421 | if (cflag & CRTSCTS) | |
422 | urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); | |
423 | else | |
424 | urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS); | |
425 | ||
426 | if (bad_flow_control) | |
427 | urb_value &= ~(BELKIN_SA_FLOW_IRTS); | |
428 | ||
429 | if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0) | |
194343d9 | 430 | dev_err(&port->dev, "Set flow control error\n"); |
1da177e4 LT |
431 | } |
432 | ||
433 | /* save off the modified port settings */ | |
434 | spin_lock_irqsave(&priv->lock, flags); | |
435 | priv->control_state = control_state; | |
436 | spin_unlock_irqrestore(&priv->lock, flags); | |
726ef428 | 437 | } |
1da177e4 | 438 | |
95da310e | 439 | static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state) |
1da177e4 | 440 | { |
95da310e | 441 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
442 | struct usb_serial *serial = port->serial; |
443 | ||
444 | if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0) | |
194343d9 | 445 | dev_err(&port->dev, "Set break_ctl %d\n", break_state); |
1da177e4 LT |
446 | } |
447 | ||
60b33c13 | 448 | static int belkin_sa_tiocmget(struct tty_struct *tty) |
1da177e4 | 449 | { |
95da310e | 450 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
451 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); |
452 | unsigned long control_state; | |
453 | unsigned long flags; | |
b69c1499 | 454 | |
1da177e4 LT |
455 | spin_lock_irqsave(&priv->lock, flags); |
456 | control_state = priv->control_state; | |
457 | spin_unlock_irqrestore(&priv->lock, flags); | |
458 | ||
459 | return control_state; | |
460 | } | |
461 | ||
20b9d177 | 462 | static int belkin_sa_tiocmset(struct tty_struct *tty, |
1da177e4 LT |
463 | unsigned int set, unsigned int clear) |
464 | { | |
95da310e | 465 | struct usb_serial_port *port = tty->driver_data; |
1da177e4 LT |
466 | struct usb_serial *serial = port->serial; |
467 | struct belkin_sa_private *priv = usb_get_serial_port_data(port); | |
468 | unsigned long control_state; | |
469 | unsigned long flags; | |
470 | int retval; | |
471 | int rts = 0; | |
472 | int dtr = 0; | |
b69c1499 | 473 | |
1da177e4 LT |
474 | spin_lock_irqsave(&priv->lock, flags); |
475 | control_state = priv->control_state; | |
476 | ||
477 | if (set & TIOCM_RTS) { | |
478 | control_state |= TIOCM_RTS; | |
479 | rts = 1; | |
480 | } | |
481 | if (set & TIOCM_DTR) { | |
482 | control_state |= TIOCM_DTR; | |
483 | dtr = 1; | |
484 | } | |
485 | if (clear & TIOCM_RTS) { | |
486 | control_state &= ~TIOCM_RTS; | |
487 | rts = 0; | |
488 | } | |
489 | if (clear & TIOCM_DTR) { | |
490 | control_state &= ~TIOCM_DTR; | |
491 | dtr = 0; | |
492 | } | |
493 | ||
494 | priv->control_state = control_state; | |
495 | spin_unlock_irqrestore(&priv->lock, flags); | |
496 | ||
497 | retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts); | |
498 | if (retval < 0) { | |
194343d9 | 499 | dev_err(&port->dev, "Set RTS error %d\n", retval); |
1da177e4 LT |
500 | goto exit; |
501 | } | |
502 | ||
503 | retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr); | |
504 | if (retval < 0) { | |
194343d9 | 505 | dev_err(&port->dev, "Set DTR error %d\n", retval); |
1da177e4 LT |
506 | goto exit; |
507 | } | |
508 | exit: | |
509 | return retval; | |
510 | } | |
511 | ||
68e24113 | 512 | module_usb_serial_driver(serial_drivers, id_table); |
1da177e4 | 513 | |
b69c1499 AC |
514 | MODULE_AUTHOR(DRIVER_AUTHOR); |
515 | MODULE_DESCRIPTION(DRIVER_DESC); | |
516 | MODULE_VERSION(DRIVER_VERSION); | |
1da177e4 LT |
517 | MODULE_LICENSE("GPL"); |
518 | ||
519 | module_param(debug, bool, S_IRUGO | S_IWUSR); | |
520 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |