]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/usb/serial/keyspan.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ttydev: Fix up compile failures in the PPC build
[mirror_ubuntu-artful-kernel.git] / drivers / usb / serial / keyspan.c
CommitLineData
1da177e4
LT		 1/*
2 Keyspan USB to Serial Converter driver
3
4 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org>
5 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 See http://misc.nu/hugh/keyspan.html for more information.
13
14 Code in this driver inspired by and in a number of places taken
15 from Brian Warner's original Keyspan-PDA driver.
16
17 This driver has been put together with the support of Innosys, Inc.
18 and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
19 Thanks Guys :)
20
21 Thanks to Paulus for miscellaneous tidy ups, some largish chunks
22 of much nicer and/or completely new code and (perhaps most uniquely)
23 having the patience to sit down and explain why and where he'd changed
24 stuff.
25
26 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
27 staff in their work on open source projects.
28
29 Change History
30
31 2003sep04 LPM (Keyspan) add support for new single port product USA19HS.
32 Improve setup message handling for all devices.
33
34 Wed Feb 19 22:00:00 PST 2003 (Jeffrey S. Laing <keyspan@jsl.com>)
35 Merged the current (1/31/03) Keyspan code with the current (2.4.21-pre4)
36 Linux source tree. The Linux tree lacked support for the 49WLC and
37 others. The Keyspan patches didn't work with the current kernel.
38
39 2003jan30 LPM add support for the 49WLC and MPR
40
41 Wed Apr 25 12:00:00 PST 2002 (Keyspan)
42 Started with Hugh Blemings' code dated Jan 17, 2002. All adapters
43 now supported (including QI and QW). Modified port open, port
44 close, and send setup() logic to fix various data and endpoint
45 synchronization bugs and device LED status bugs. Changed keyspan_
46 write_room() to accurately return transmit buffer availability.
47 Changed forwardingLength from 1 to 16 for all adapters.
48
49 Fri Oct 12 16:45:00 EST 2001
50 Preliminary USA-19QI and USA-28 support (both test OK for me, YMMV)
51
52 Wed Apr 25 12:00:00 PST 2002 (Keyspan)
53 Started with Hugh Blemings' code dated Jan 17, 2002. All adapters
54 now supported (including QI and QW). Modified port open, port
55 close, and send setup() logic to fix various data and endpoint
56 synchronization bugs and device LED status bugs. Changed keyspan_
57 write_room() to accurately return transmit buffer availability.
58 Changed forwardingLength from 1 to 16 for all adapters.
59
60 Fri Oct 12 16:45:00 EST 2001
61 Preliminary USA-19QI and USA-28 support (both test OK for me, YMMV)
62
63 Mon Oct 8 14:29:00 EST 2001 hugh
64 Fixed bug that prevented mulitport devices operating correctly
65 if they weren't the first unit attached.
66
67 Sat Oct 6 12:31:21 EST 2001 hugh
68 Added support for USA-28XA and -28XB, misc cleanups, break support
69 for usa26 based models thanks to David Gibson.
70
71 Thu May 31 11:56:42 PDT 2001 gkh
72 switched from using spinlock to a semaphore
73
74 (04/08/2001) gb
75 Identify version on module load.
76
77 (11/01/2000) Adam J. Richter
78 usb_device_id table support.
79
80 Tue Oct 10 23:15:33 EST 2000 Hugh
81 Merged Paul's changes with my USA-49W mods. Work in progress
82 still...
83
84 Wed Jul 19 14:00:42 EST 2000 gkh
85 Added module_init and module_exit functions to handle the fact that
86 this driver is a loadable module now.
87
88 Tue Jul 18 16:14:52 EST 2000 Hugh
89 Basic character input/output for USA-19 now mostly works,
90 fixed at 9600 baud for the moment.
91
92 Sat Jul 8 11:11:48 EST 2000 Hugh
93 First public release - nothing works except the firmware upload.
94 Tested on PPC and x86 architectures, seems to behave...
95*/
96
97
1da177e4
LT		 98#include <linux/kernel.h>
99#include <linux/jiffies.h>
100#include <linux/errno.h>
101#include <linux/init.h>
102#include <linux/slab.h>
103#include <linux/tty.h>
104#include <linux/tty_driver.h>
105#include <linux/tty_flip.h>
106#include <linux/module.h>
107#include <linux/spinlock.h>
2971c579
DW		 108#include <linux/firmware.h>
109#include <linux/ihex.h>
1da177e4
LT		 110#include <asm/uaccess.h>
111#include <linux/usb.h>
a969888c 112#include <linux/usb/serial.h>
1da177e4
LT		 113#include "keyspan.h"
114
115static int debug;
116
117/*
118 * Version Information
119 */
0ca1268e 120#define DRIVER_VERSION "v1.1.5"
1da177e4
LT		 121#define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
122#define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
123
124#define INSTAT_BUFLEN 32
125#define GLOCONT_BUFLEN 64
0ca1268e 126#define INDAT49W_BUFLEN 512
1da177e4
LT		 127
128 /* Per device and per port private data */
129struct keyspan_serial_private {
130 const struct keyspan_device_details *device_details;
131
132 struct urb *instat_urb;
133 char instat_buf[INSTAT_BUFLEN];
134
0ca1268e
LM		 135 /* added to support 49wg, where data from all 4 ports comes in on 1 EP */
136 /* and high-speed supported */
137 struct urb *indat_urb;
138 char indat_buf[INDAT49W_BUFLEN];
139
1da177e4
LT		 140 /* XXX this one probably will need a lock */
141 struct urb *glocont_urb;
142 char glocont_buf[GLOCONT_BUFLEN];
0ca1268e 143 char ctrl_buf[8]; // for EP0 control message
1da177e4
LT		 144};
145
146struct keyspan_port_private {
147 /* Keep track of which input & output endpoints to use */
148 int in_flip;
149 int out_flip;
150
151 /* Keep duplicate of device details in each port
152 structure as well - simplifies some of the
153 callback functions etc. */
154 const struct keyspan_device_details *device_details;
155
156 /* Input endpoints and buffer for this port */
157 struct urb *in_urbs[2];
158 char in_buffer[2][64];
159 /* Output endpoints and buffer for this port */
160 struct urb *out_urbs[2];
161 char out_buffer[2][64];
162
163 /* Input ack endpoint */
164 struct urb *inack_urb;
165 char inack_buffer[1];
166
167 /* Output control endpoint */
168 struct urb *outcont_urb;
169 char outcont_buffer[64];
170
171 /* Settings for the port */
172 int baud;
173 int old_baud;
174 unsigned int cflag;
175 unsigned int old_cflag;
176 enum {flow_none, flow_cts, flow_xon} flow_control;
177 int rts_state; /* Handshaking pins (outputs) */
178 int dtr_state;
179 int cts_state; /* Handshaking pins (inputs) */
180 int dsr_state;
181 int dcd_state;
182 int ri_state;
183 int break_on;
184
185 unsigned long tx_start_time[2];
186 int resend_cont; /* need to resend control packet */
187};
188
189
190/* Include Keyspan message headers. All current Keyspan Adapters
0ca1268e
LM		 191 make use of one of five message formats which are referred
192 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and within this driver. */
1da177e4
LT		 193#include "keyspan_usa26msg.h"
194#include "keyspan_usa28msg.h"
195#include "keyspan_usa49msg.h"
196#include "keyspan_usa90msg.h"
0ca1268e 197#include "keyspan_usa67msg.h"
1da177e4
LT		 198
199
200/* Functions used by new usb-serial code. */
201static int __init keyspan_init (void)
202{
203 int retval;
204 retval = usb_serial_register(&keyspan_pre_device);
205 if (retval)
206 goto failed_pre_device_register;
207 retval = usb_serial_register(&keyspan_1port_device);
208 if (retval)
209 goto failed_1port_device_register;
210 retval = usb_serial_register(&keyspan_2port_device);
211 if (retval)
212 goto failed_2port_device_register;
213 retval = usb_serial_register(&keyspan_4port_device);
214 if (retval)
215 goto failed_4port_device_register;
216 retval = usb_register(&keyspan_driver);
217 if (retval)
218 goto failed_usb_register;
219
220 info(DRIVER_VERSION ":" DRIVER_DESC);
221
222 return 0;
223failed_usb_register:
224 usb_serial_deregister(&keyspan_4port_device);
225failed_4port_device_register:
226 usb_serial_deregister(&keyspan_2port_device);
227failed_2port_device_register:
228 usb_serial_deregister(&keyspan_1port_device);
229failed_1port_device_register:
230 usb_serial_deregister(&keyspan_pre_device);
231failed_pre_device_register:
232 return retval;
233}
234
235static void __exit keyspan_exit (void)
236{
237 usb_deregister (&keyspan_driver);
238 usb_serial_deregister (&keyspan_pre_device);
239 usb_serial_deregister (&keyspan_1port_device);
240 usb_serial_deregister (&keyspan_2port_device);
241 usb_serial_deregister (&keyspan_4port_device);
242}
243
244module_init(keyspan_init);
245module_exit(keyspan_exit);
246
247static void keyspan_rx_throttle (struct usb_serial_port *port)
248{
441b62c1 249 dbg("%s - port %d", __func__, port->number);
1da177e4
LT		 250}
251
252
253static void keyspan_rx_unthrottle (struct usb_serial_port *port)
254{
441b62c1 255 dbg("%s - port %d", __func__, port->number);
1da177e4
LT		 256}
257
258
259static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
260{
261 struct keyspan_port_private *p_priv;
262
441b62c1 263 dbg("%s", __func__);
1da177e4
LT		 264
265 p_priv = usb_get_serial_port_data(port);
266
267 if (break_state == -1)
268 p_priv->break_on = 1;
269 else
270 p_priv->break_on = 0;
271
272 keyspan_send_setup(port, 0);
273}
274
275
276static void keyspan_set_termios (struct usb_serial_port *port,
606d099c 277 struct ktermios *old_termios)
1da177e4
LT		 278{
279 int baud_rate, device_port;
280 struct keyspan_port_private *p_priv;
281 const struct keyspan_device_details *d_details;
282 unsigned int cflag;
74240b07 283 struct tty_struct *tty = port->tty;
1da177e4 284
441b62c1 285 dbg("%s", __func__);
1da177e4
LT		 286
287 p_priv = usb_get_serial_port_data(port);
288 d_details = p_priv->device_details;
74240b07 289 cflag = tty->termios->c_cflag;
1da177e4
LT		 290 device_port = port->number - port->serial->minor;
291
292 /* Baud rate calculation takes baud rate as an integer
293 so other rates can be generated if desired. */
74240b07 294 baud_rate = tty_get_baud_rate(tty);
1da177e4 295 /* If no match or invalid, don't change */
74240b07 296 if (d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
1da177e4
LT		 297 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
298 /* FIXME - more to do here to ensure rate changes cleanly */
74240b07 299 /* FIXME - calcuate exact rate from divisor ? */
1da177e4 300 p_priv->baud = baud_rate;
74240b07
AC		 301 } else
302 baud_rate = tty_termios_baud_rate(old_termios);
1da177e4 303
74240b07 304 tty_encode_baud_rate(tty, baud_rate, baud_rate);
1da177e4
LT		 305 /* set CTS/RTS handshake etc. */
306 p_priv->cflag = cflag;
307 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
308
74240b07
AC		 309 /* Mark/Space not supported */
310 tty->termios->c_cflag &= ~CMSPAR;
311
1da177e4
LT		 312 keyspan_send_setup(port, 0);
313}
314
315static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file)
316{
317 unsigned int value;
318 struct keyspan_port_private *p_priv;
319
320 p_priv = usb_get_serial_port_data(port);
321
322 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
323 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
324 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
325 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
326 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
327 ((p_priv->ri_state) ? TIOCM_RNG : 0);
328
329 return value;
330}
331
332static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file,
333 unsigned int set, unsigned int clear)
334{
335 struct keyspan_port_private *p_priv;
336
337 p_priv = usb_get_serial_port_data(port);
338
339 if (set & TIOCM_RTS)
340 p_priv->rts_state = 1;
341 if (set & TIOCM_DTR)
342 p_priv->dtr_state = 1;
343
344 if (clear & TIOCM_RTS)
345 p_priv->rts_state = 0;
346 if (clear & TIOCM_DTR)
347 p_priv->dtr_state = 0;
348 keyspan_send_setup(port, 0);
349 return 0;
350}
351
352static int keyspan_ioctl(struct usb_serial_port *port, struct file *file,
353 unsigned int cmd, unsigned long arg)
354{
355 return -ENOIOCTLCMD;
356}
357
358 /* Write function is similar for the four protocols used
359 with only a minor change for usa90 (usa19hs) required */
360static int keyspan_write(struct usb_serial_port *port,
361 const unsigned char *buf, int count)
362{
363 struct keyspan_port_private *p_priv;
364 const struct keyspan_device_details *d_details;
365 int flip;
366 int left, todo;
367 struct urb *this_urb;
368 int err, maxDataLen, dataOffset;
369
370 p_priv = usb_get_serial_port_data(port);
371 d_details = p_priv->device_details;
372
373 if (d_details->msg_format == msg_usa90) {
374 maxDataLen = 64;
375 dataOffset = 0;
376 } else {
377 maxDataLen = 63;
378 dataOffset = 1;
379 }
380
381 dbg("%s - for port %d (%d chars), flip=%d",
441b62c1 382 __func__, port->number, count, p_priv->out_flip);
1da177e4
LT		 383
384 for (left = count; left > 0; left -= todo) {
385 todo = left;
386 if (todo > maxDataLen)
387 todo = maxDataLen;
388
389 flip = p_priv->out_flip;
390
391 /* Check we have a valid urb/endpoint before we use it... */
392 if ((this_urb = p_priv->out_urbs[flip]) == NULL) {
393 /* no bulk out, so return 0 bytes written */
441b62c1 394 dbg("%s - no output urb :(", __func__);
1da177e4
LT		 395 return count;
396 }
397
441b62c1 398 dbg("%s - endpoint %d flip %d", __func__, usb_pipeendpoint(this_urb->pipe), flip);
1da177e4
LT		 399
400 if (this_urb->status == -EINPROGRESS) {
1da177e4
LT		 401 if (time_before(jiffies, p_priv->tx_start_time[flip] + 10 * HZ))
402 break;
1da177e4
LT		 403 usb_unlink_urb(this_urb);
404 break;
405 }
406
407 /* First byte in buffer is "last flag" (except for usa19hx) - unused so
408 for now so set to zero */
409 ((char *)this_urb->transfer_buffer)[0] = 0;
410
411 memcpy (this_urb->transfer_buffer + dataOffset, buf, todo);
412 buf += todo;
413
414 /* send the data out the bulk port */
415 this_urb->transfer_buffer_length = todo + dataOffset;
416
1da177e4
LT		 417 this_urb->dev = port->serial->dev;
418 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
419 dbg("usb_submit_urb(write bulk) failed (%d)", err);
420 }
421 p_priv->tx_start_time[flip] = jiffies;
422
423 /* Flip for next time if usa26 or usa28 interface
424 (not used on usa49) */
425 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
426 }
427
428 return count - left;
429}
430
7d12e780 431static void usa26_indat_callback(struct urb *urb)
1da177e4
LT		 432{
433 int i, err;
434 int endpoint;
435 struct usb_serial_port *port;
436 struct tty_struct *tty;
437 unsigned char *data = urb->transfer_buffer;
95b93454 438 int status = urb->status;
1da177e4 439
441b62c1 440 dbg ("%s", __func__);
1da177e4
LT		 441
442 endpoint = usb_pipeendpoint(urb->pipe);
443
95b93454 444 if (status) {
1da177e4 445 dbg("%s - nonzero status: %x on endpoint %d.",
441b62c1 446 __func__, status, endpoint);
1da177e4
LT		 447 return;
448 }
449
cdc97792 450 port = urb->context;
1da177e4 451 tty = port->tty;
a5569a56 452 if (tty && urb->actual_length) {
1da177e4
LT		 453 /* 0x80 bit is error flag */
454 if ((data[0] & 0x80) == 0) {
455 /* no errors on individual bytes, only possible overrun err*/
456 if (data[0] & RXERROR_OVERRUN)
457 err = TTY_OVERRUN;
458 else err = 0;
459 for (i = 1; i < urb->actual_length ; ++i) {
460 tty_insert_flip_char(tty, data[i], err);
461 }
462 } else {
463 /* some bytes had errors, every byte has status */
441b62c1 464 dbg("%s - RX error!!!!", __func__);
1da177e4
LT		 465 for (i = 0; i + 1 < urb->actual_length; i += 2) {
466 int stat = data[i], flag = 0;
467 if (stat & RXERROR_OVERRUN)
468 flag |= TTY_OVERRUN;
469 if (stat & RXERROR_FRAMING)
470 flag |= TTY_FRAME;
471 if (stat & RXERROR_PARITY)
472 flag |= TTY_PARITY;
473 /* XXX should handle break (0x10) */
474 tty_insert_flip_char(tty, data[i+1], flag);
475 }
476 }
477 tty_flip_buffer_push(tty);
478 }
479
480 /* Resubmit urb so we continue receiving */
481 urb->dev = port->serial->dev;
482 if (port->open_count)
483 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 484 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 485 }
486 return;
487}
488
489 /* Outdat handling is common for all devices */
7d12e780 490static void usa2x_outdat_callback(struct urb *urb)
1da177e4
LT		 491{
492 struct usb_serial_port *port;
493 struct keyspan_port_private *p_priv;
494
cdc97792 495 port = urb->context;
1da177e4 496 p_priv = usb_get_serial_port_data(port);
441b62c1 497 dbg ("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
1da177e4
LT		 498
499 if (port->open_count)
cf2c7481 500 usb_serial_port_softint(port);
1da177e4
LT		 501}
502
7d12e780 503static void usa26_inack_callback(struct urb *urb)
1da177e4 504{
441b62c1 505 dbg ("%s", __func__);
1da177e4
LT		 506
507}
508
7d12e780 509static void usa26_outcont_callback(struct urb *urb)
1da177e4
LT		 510{
511 struct usb_serial_port *port;
512 struct keyspan_port_private *p_priv;
513
cdc97792 514 port = urb->context;
1da177e4
LT		 515 p_priv = usb_get_serial_port_data(port);
516
517 if (p_priv->resend_cont) {
441b62c1 518 dbg ("%s - sending setup", __func__);
1da177e4
LT		 519 keyspan_usa26_send_setup(port->serial, port, p_priv->resend_cont - 1);
520 }
521}
522
7d12e780 523static void usa26_instat_callback(struct urb *urb)
1da177e4
LT		 524{
525 unsigned char *data = urb->transfer_buffer;
526 struct keyspan_usa26_portStatusMessage *msg;
527 struct usb_serial *serial;
528 struct usb_serial_port *port;
529 struct keyspan_port_private *p_priv;
530 int old_dcd_state, err;
95b93454 531 int status = urb->status;
1da177e4 532
cdc97792 533 serial = urb->context;
1da177e4 534
95b93454 535 if (status) {
441b62c1 536 dbg("%s - nonzero status: %x", __func__, status);
1da177e4
LT		 537 return;
538 }
539 if (urb->actual_length != 9) {
441b62c1 540 dbg("%s - %d byte report??", __func__, urb->actual_length);
1da177e4
LT		 541 goto exit;
542 }
543
544 msg = (struct keyspan_usa26_portStatusMessage *)data;
545
546#if 0
547 dbg("%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
441b62c1 548 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff,
1da177e4
LT		 549 msg->_txXoff, msg->rxEnabled, msg->controlResponse);
550#endif
551
552 /* Now do something useful with the data */
553
554
555 /* Check port number from message and retrieve private data */
556 if (msg->port >= serial->num_ports) {
441b62c1 557 dbg ("%s - Unexpected port number %d", __func__, msg->port);
1da177e4
LT		 558 goto exit;
559 }
560 port = serial->port[msg->port];
561 p_priv = usb_get_serial_port_data(port);
562
563 /* Update handshaking pin state information */
564 old_dcd_state = p_priv->dcd_state;
565 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
566 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
567 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
568 p_priv->ri_state = ((msg->ri) ? 1 : 0);
569
570 if (port->tty && !C_CLOCAL(port->tty)
571 && old_dcd_state != p_priv->dcd_state) {
572 if (old_dcd_state)
573 tty_hangup(port->tty);
574 /* else */
575 /* wake_up_interruptible(&p_priv->open_wait); */
576 }
577
578 /* Resubmit urb so we continue receiving */
579 urb->dev = serial->dev;
580 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 581 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 582 }
583exit: ;
584}
585
7d12e780 586static void usa26_glocont_callback(struct urb *urb)
1da177e4 587{
441b62c1 588 dbg ("%s", __func__);
1da177e4
LT		 589
590}
591
592
7d12e780 593static void usa28_indat_callback(struct urb *urb)
1da177e4
LT		 594{
595 int i, err;
596 struct usb_serial_port *port;
597 struct tty_struct *tty;
598 unsigned char *data;
599 struct keyspan_port_private *p_priv;
95b93454 600 int status = urb->status;
1da177e4 601
441b62c1 602 dbg ("%s", __func__);
1da177e4 603
cdc97792 604 port = urb->context;
1da177e4
LT		 605 p_priv = usb_get_serial_port_data(port);
606 data = urb->transfer_buffer;
607
608 if (urb != p_priv->in_urbs[p_priv->in_flip])
609 return;
610
611 do {
95b93454 612 if (status) {
1da177e4 613 dbg("%s - nonzero status: %x on endpoint %d.",
441b62c1 614 __func__, status, usb_pipeendpoint(urb->pipe));
1da177e4
LT		 615 return;
616 }
617
cdc97792 618 port = urb->context;
1da177e4
LT		 619 p_priv = usb_get_serial_port_data(port);
620 data = urb->transfer_buffer;
621
622 tty = port->tty;
623 if (urb->actual_length) {
624 for (i = 0; i < urb->actual_length ; ++i) {
625 tty_insert_flip_char(tty, data[i], 0);
626 }
627 tty_flip_buffer_push(tty);
628 }
629
630 /* Resubmit urb so we continue receiving */
631 urb->dev = port->serial->dev;
632 if (port->open_count)
633 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 634 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 635 }
636 p_priv->in_flip ^= 1;
637
638 urb = p_priv->in_urbs[p_priv->in_flip];
639 } while (urb->status != -EINPROGRESS);
640}
641
7d12e780 642static void usa28_inack_callback(struct urb *urb)
1da177e4 643{
441b62c1 644 dbg ("%s", __func__);
1da177e4
LT		 645}
646
7d12e780 647static void usa28_outcont_callback(struct urb *urb)
1da177e4
LT		 648{
649 struct usb_serial_port *port;
650 struct keyspan_port_private *p_priv;
651
cdc97792 652 port = urb->context;
1da177e4
LT		 653 p_priv = usb_get_serial_port_data(port);
654
655 if (p_priv->resend_cont) {
441b62c1 656 dbg ("%s - sending setup", __func__);
1da177e4
LT		 657 keyspan_usa28_send_setup(port->serial, port, p_priv->resend_cont - 1);
658 }
659}
660
7d12e780 661static void usa28_instat_callback(struct urb *urb)
1da177e4
LT		 662{
663 int err;
664 unsigned char *data = urb->transfer_buffer;
665 struct keyspan_usa28_portStatusMessage *msg;
666 struct usb_serial *serial;
667 struct usb_serial_port *port;
668 struct keyspan_port_private *p_priv;
669 int old_dcd_state;
95b93454 670 int status = urb->status;
1da177e4 671
cdc97792 672 serial = urb->context;
1da177e4 673
95b93454 674 if (status) {
441b62c1 675 dbg("%s - nonzero status: %x", __func__, status);
1da177e4
LT		 676 return;
677 }
678
679 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
441b62c1 680 dbg("%s - bad length %d", __func__, urb->actual_length);
1da177e4
LT		 681 goto exit;
682 }
683
441b62c1 684 /*dbg("%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__
1da177e4
LT		 685 data[0], data[1], data[2], data[3], data[4], data[5],
686 data[6], data[7], data[8], data[9], data[10], data[11]);*/
687
688 /* Now do something useful with the data */
689 msg = (struct keyspan_usa28_portStatusMessage *)data;
690
691
692 /* Check port number from message and retrieve private data */
693 if (msg->port >= serial->num_ports) {
441b62c1 694 dbg ("%s - Unexpected port number %d", __func__, msg->port);
1da177e4
LT		 695 goto exit;
696 }
697 port = serial->port[msg->port];
698 p_priv = usb_get_serial_port_data(port);
699
700 /* Update handshaking pin state information */
701 old_dcd_state = p_priv->dcd_state;
702 p_priv->cts_state = ((msg->cts) ? 1 : 0);
703 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
704 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
705 p_priv->ri_state = ((msg->ri) ? 1 : 0);
706
707 if (port->tty && !C_CLOCAL(port->tty)
708 && old_dcd_state != p_priv->dcd_state) {
709 if (old_dcd_state)
710 tty_hangup(port->tty);
711 /* else */
712 /* wake_up_interruptible(&p_priv->open_wait); */
713 }
714
715 /* Resubmit urb so we continue receiving */
716 urb->dev = serial->dev;
717 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 718 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 719 }
720exit: ;
721}
722
7d12e780 723static void usa28_glocont_callback(struct urb *urb)
1da177e4 724{
441b62c1 725 dbg ("%s", __func__);
1da177e4
LT		 726}
727
728
7d12e780 729static void usa49_glocont_callback(struct urb *urb)
1da177e4
LT		 730{
731 struct usb_serial *serial;
732 struct usb_serial_port *port;
733 struct keyspan_port_private *p_priv;
734 int i;
735
441b62c1 736 dbg ("%s", __func__);
1da177e4 737
cdc97792 738 serial = urb->context;
1da177e4
LT		 739 for (i = 0; i < serial->num_ports; ++i) {
740 port = serial->port[i];
741 p_priv = usb_get_serial_port_data(port);
742
743 if (p_priv->resend_cont) {
441b62c1 744 dbg ("%s - sending setup", __func__);
1da177e4
LT		 745 keyspan_usa49_send_setup(serial, port, p_priv->resend_cont - 1);
746 break;
747 }
748 }
749}
750
751 /* This is actually called glostat in the Keyspan
752 doco */
7d12e780 753static void usa49_instat_callback(struct urb *urb)
1da177e4
LT		 754{
755 int err;
756 unsigned char *data = urb->transfer_buffer;
757 struct keyspan_usa49_portStatusMessage *msg;
758 struct usb_serial *serial;
759 struct usb_serial_port *port;
760 struct keyspan_port_private *p_priv;
761 int old_dcd_state;
95b93454 762 int status = urb->status;
1da177e4 763
441b62c1 764 dbg ("%s", __func__);
1da177e4 765
cdc97792 766 serial = urb->context;
1da177e4 767
95b93454 768 if (status) {
441b62c1 769 dbg("%s - nonzero status: %x", __func__, status);
1da177e4
LT		 770 return;
771 }
772
773 if (urb->actual_length != sizeof(struct keyspan_usa49_portStatusMessage)) {
441b62c1 774 dbg("%s - bad length %d", __func__, urb->actual_length);
1da177e4
LT		 775 goto exit;
776 }
777
441b62c1 778 /*dbg(" %x %x %x %x %x %x %x %x %x %x %x", __func__,
1da177e4
LT		 779 data[0], data[1], data[2], data[3], data[4], data[5],
780 data[6], data[7], data[8], data[9], data[10]);*/
781
782 /* Now do something useful with the data */
783 msg = (struct keyspan_usa49_portStatusMessage *)data;
784
785 /* Check port number from message and retrieve private data */
786 if (msg->portNumber >= serial->num_ports) {
441b62c1 787 dbg ("%s - Unexpected port number %d", __func__, msg->portNumber);
1da177e4
LT		 788 goto exit;
789 }
790 port = serial->port[msg->portNumber];
791 p_priv = usb_get_serial_port_data(port);
792
793 /* Update handshaking pin state information */
794 old_dcd_state = p_priv->dcd_state;
795 p_priv->cts_state = ((msg->cts) ? 1 : 0);
796 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
797 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
798 p_priv->ri_state = ((msg->ri) ? 1 : 0);
799
800 if (port->tty && !C_CLOCAL(port->tty)
801 && old_dcd_state != p_priv->dcd_state) {
802 if (old_dcd_state)
803 tty_hangup(port->tty);
804 /* else */
805 /* wake_up_interruptible(&p_priv->open_wait); */
806 }
807
808 /* Resubmit urb so we continue receiving */
809 urb->dev = serial->dev;
810
811 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 812 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 813 }
814exit: ;
815}
816
7d12e780 817static void usa49_inack_callback(struct urb *urb)
1da177e4 818{
441b62c1 819 dbg ("%s", __func__);
1da177e4
LT		 820}
821
7d12e780 822static void usa49_indat_callback(struct urb *urb)
1da177e4
LT		 823{
824 int i, err;
825 int endpoint;
826 struct usb_serial_port *port;
827 struct tty_struct *tty;
828 unsigned char *data = urb->transfer_buffer;
95b93454 829 int status = urb->status;
1da177e4 830
441b62c1 831 dbg ("%s", __func__);
1da177e4
LT		 832
833 endpoint = usb_pipeendpoint(urb->pipe);
834
95b93454 835 if (status) {
441b62c1 836 dbg("%s - nonzero status: %x on endpoint %d.", __func__,
95b93454 837 status, endpoint);
1da177e4
LT		 838 return;
839 }
840
cdc97792 841 port = urb->context;
1da177e4 842 tty = port->tty;
3004e537 843 if (tty && urb->actual_length) {
1da177e4
LT		 844 /* 0x80 bit is error flag */
845 if ((data[0] & 0x80) == 0) {
846 /* no error on any byte */
847 for (i = 1; i < urb->actual_length ; ++i) {
848 tty_insert_flip_char(tty, data[i], 0);
849 }
850 } else {
851 /* some bytes had errors, every byte has status */
852 for (i = 0; i + 1 < urb->actual_length; i += 2) {
853 int stat = data[i], flag = 0;
854 if (stat & RXERROR_OVERRUN)
855 flag |= TTY_OVERRUN;
856 if (stat & RXERROR_FRAMING)
857 flag |= TTY_FRAME;
858 if (stat & RXERROR_PARITY)
859 flag |= TTY_PARITY;
860 /* XXX should handle break (0x10) */
861 tty_insert_flip_char(tty, data[i+1], flag);
862 }
863 }
864 tty_flip_buffer_push(tty);
865 }
866
867 /* Resubmit urb so we continue receiving */
868 urb->dev = port->serial->dev;
869 if (port->open_count)
870 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 871 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 872 }
873}
874
0ca1268e
LM		 875static void usa49wg_indat_callback(struct urb *urb)
876{
877 int i, len, x, err;
878 struct usb_serial *serial;
879 struct usb_serial_port *port;
880 struct tty_struct *tty;
881 unsigned char *data = urb->transfer_buffer;
95b93454 882 int status = urb->status;
0ca1268e 883
441b62c1 884 dbg ("%s", __func__);
0ca1268e
LM		 885
886 serial = urb->context;
887
95b93454 888 if (status) {
441b62c1 889 dbg("%s - nonzero status: %x", __func__, status);
0ca1268e
LM		 890 return;
891 }
892
893 /* inbound data is in the form P#, len, status, data */
894 i = 0;
895 len = 0;
896
897 if (urb->actual_length) {
898 while (i < urb->actual_length) {
899
900 /* Check port number from message*/
901 if (data[i] >= serial->num_ports) {
902 dbg ("%s - Unexpected port number %d",
441b62c1 903 __func__, data[i]);
0ca1268e
LM		 904 return;
905 }
906 port = serial->port[data[i++]];
907 tty = port->tty;
908 len = data[i++];
909
910 /* 0x80 bit is error flag */
911 if ((data[i] & 0x80) == 0) {
912 /* no error on any byte */
913 i++;
914 for (x = 1; x < len ; ++x)
915 if (port->open_count)
916 tty_insert_flip_char(tty,
917 data[i++], 0);
918 else
919 i++;
920 } else {
921 /*
922 * some bytes had errors, every byte has status
923 */
924 for (x = 0; x + 1 < len; x += 2) {
925 int stat = data[i], flag = 0;
926 if (stat & RXERROR_OVERRUN)
927 flag |= TTY_OVERRUN;
928 if (stat & RXERROR_FRAMING)
929 flag |= TTY_FRAME;
930 if (stat & RXERROR_PARITY)
931 flag |= TTY_PARITY;
932 /* XXX should handle break (0x10) */
933 if (port->open_count)
934 tty_insert_flip_char(tty,
935 data[i+1], flag);
936 i += 2;
937 }
938 }
939 if (port->open_count)
940 tty_flip_buffer_push(tty);
941 }
942 }
943
944 /* Resubmit urb so we continue receiving */
945 urb->dev = serial->dev;
946
947 err = usb_submit_urb(urb, GFP_ATOMIC);
948 if (err != 0)
441b62c1 949 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
0ca1268e
LM		 950}
951
1da177e4 952/* not used, usa-49 doesn't have per-port control endpoints */
0ca1268e 953static void usa49_outcont_callback(struct urb *urb)
1da177e4 954{
441b62c1 955 dbg ("%s", __func__);
1da177e4
LT		 956}
957
0ca1268e 958static void usa90_indat_callback(struct urb *urb)
1da177e4
LT		 959{
960 int i, err;
961 int endpoint;
962 struct usb_serial_port *port;
963 struct keyspan_port_private *p_priv;
964 struct tty_struct *tty;
965 unsigned char *data = urb->transfer_buffer;
95b93454 966 int status = urb->status;
1da177e4 967
441b62c1 968 dbg ("%s", __func__);
1da177e4
LT		 969
970 endpoint = usb_pipeendpoint(urb->pipe);
971
95b93454 972 if (status) {
1da177e4 973 dbg("%s - nonzero status: %x on endpoint %d.",
441b62c1 974 __func__, status, endpoint);
1da177e4
LT		 975 return;
976 }
977
cdc97792 978 port = urb->context;
1da177e4
LT		 979 p_priv = usb_get_serial_port_data(port);
980
981 tty = port->tty;
982 if (urb->actual_length) {
983
984 /* if current mode is DMA, looks like usa28 format
985 otherwise looks like usa26 data format */
986
987 if (p_priv->baud > 57600) {
988 for (i = 0; i < urb->actual_length ; ++i)
989 tty_insert_flip_char(tty, data[i], 0);
990 }
991 else {
992
993 /* 0x80 bit is error flag */
994 if ((data[0] & 0x80) == 0) {
995 /* no errors on individual bytes, only possible overrun err*/
996 if (data[0] & RXERROR_OVERRUN)
997 err = TTY_OVERRUN;
998 else err = 0;
999 for (i = 1; i < urb->actual_length ; ++i)
1000 tty_insert_flip_char(tty, data[i], err);
1001
1002 }
1003 else {
1004 /* some bytes had errors, every byte has status */
441b62c1 1005 dbg("%s - RX error!!!!", __func__);
1da177e4
LT		 1006 for (i = 0; i + 1 < urb->actual_length; i += 2) {
1007 int stat = data[i], flag = 0;
1008 if (stat & RXERROR_OVERRUN)
1009 flag |= TTY_OVERRUN;
1010 if (stat & RXERROR_FRAMING)
1011 flag |= TTY_FRAME;
1012 if (stat & RXERROR_PARITY)
1013 flag |= TTY_PARITY;
1014 /* XXX should handle break (0x10) */
1015 tty_insert_flip_char(tty, data[i+1], flag);
1016 }
1017 }
1018 }
1019 tty_flip_buffer_push(tty);
1020 }
1021
1022 /* Resubmit urb so we continue receiving */
1023 urb->dev = port->serial->dev;
1024 if (port->open_count)
1025 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 1026 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 1027 }
1028 return;
1029}
1030
1031
7d12e780 1032static void usa90_instat_callback(struct urb *urb)
1da177e4
LT		 1033{
1034 unsigned char *data = urb->transfer_buffer;
1035 struct keyspan_usa90_portStatusMessage *msg;
1036 struct usb_serial *serial;
1037 struct usb_serial_port *port;
1038 struct keyspan_port_private *p_priv;
1039 int old_dcd_state, err;
95b93454 1040 int status = urb->status;
1da177e4 1041
cdc97792 1042 serial = urb->context;
1da177e4 1043
95b93454 1044 if (status) {
441b62c1 1045 dbg("%s - nonzero status: %x", __func__, status);
1da177e4
LT		 1046 return;
1047 }
1048 if (urb->actual_length < 14) {
441b62c1 1049 dbg("%s - %d byte report??", __func__, urb->actual_length);
1da177e4
LT		 1050 goto exit;
1051 }
1052
1053 msg = (struct keyspan_usa90_portStatusMessage *)data;
1054
1055 /* Now do something useful with the data */
1056
1057 port = serial->port[0];
1058 p_priv = usb_get_serial_port_data(port);
1059
1060 /* Update handshaking pin state information */
1061 old_dcd_state = p_priv->dcd_state;
1062 p_priv->cts_state = ((msg->cts) ? 1 : 0);
1063 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
1064 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
1065 p_priv->ri_state = ((msg->ri) ? 1 : 0);
1066
1067 if (port->tty && !C_CLOCAL(port->tty)
1068 && old_dcd_state != p_priv->dcd_state) {
1069 if (old_dcd_state)
1070 tty_hangup(port->tty);
1071 /* else */
1072 /* wake_up_interruptible(&p_priv->open_wait); */
1073 }
1074
1075 /* Resubmit urb so we continue receiving */
1076 urb->dev = serial->dev;
1077 if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
441b62c1 1078 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
1da177e4
LT		 1079 }
1080exit:
1081 ;
1082}
1083
7d12e780 1084static void usa90_outcont_callback(struct urb *urb)
1da177e4
LT		 1085{
1086 struct usb_serial_port *port;
1087 struct keyspan_port_private *p_priv;
1088
cdc97792 1089 port = urb->context;
1da177e4
LT		 1090 p_priv = usb_get_serial_port_data(port);
1091
1092 if (p_priv->resend_cont) {
441b62c1 1093 dbg ("%s - sending setup", __func__);
1da177e4
LT		 1094 keyspan_usa90_send_setup(port->serial, port, p_priv->resend_cont - 1);
1095 }
1096}
1097
0ca1268e
LM		 1098/* Status messages from the 28xg */
1099static void usa67_instat_callback(struct urb *urb)
1100{
1101 int err;
1102 unsigned char *data = urb->transfer_buffer;
1103 struct keyspan_usa67_portStatusMessage *msg;
1104 struct usb_serial *serial;
1105 struct usb_serial_port *port;
1106 struct keyspan_port_private *p_priv;
1107 int old_dcd_state;
95b93454 1108 int status = urb->status;
0ca1268e 1109
441b62c1 1110 dbg ("%s", __func__);
0ca1268e
LM		 1111
1112 serial = urb->context;
1113
95b93454 1114 if (status) {
441b62c1 1115 dbg("%s - nonzero status: %x", __func__, status);
0ca1268e
LM		 1116 return;
1117 }
1118
1119 if (urb->actual_length != sizeof(struct keyspan_usa67_portStatusMessage)) {
441b62c1 1120 dbg("%s - bad length %d", __func__, urb->actual_length);
0ca1268e
LM		 1121 return;
1122 }
1123
1124
1125 /* Now do something useful with the data */
1126 msg = (struct keyspan_usa67_portStatusMessage *)data;
1127
1128 /* Check port number from message and retrieve private data */
1129 if (msg->port >= serial->num_ports) {
441b62c1 1130 dbg ("%s - Unexpected port number %d", __func__, msg->port);
0ca1268e
LM		 1131 return;
1132 }
1133
1134 port = serial->port[msg->port];
1135 p_priv = usb_get_serial_port_data(port);
1136
1137 /* Update handshaking pin state information */
1138 old_dcd_state = p_priv->dcd_state;
1139 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
1140 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
1141
1142 if (port->tty && !C_CLOCAL(port->tty)
1143 && old_dcd_state != p_priv->dcd_state) {
1144 if (old_dcd_state)
1145 tty_hangup(port->tty);
1146 /* else */
1147 /* wake_up_interruptible(&p_priv->open_wait); */
1148 }
1149
1150 /* Resubmit urb so we continue receiving */
1151 urb->dev = serial->dev;
1152 err = usb_submit_urb(urb, GFP_ATOMIC);
1153 if (err != 0)
441b62c1 1154 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
0ca1268e
LM		 1155}
1156
1157static void usa67_glocont_callback(struct urb *urb)
1158{
1159 struct usb_serial *serial;
1160 struct usb_serial_port *port;
1161 struct keyspan_port_private *p_priv;
1162 int i;
1163
441b62c1 1164 dbg ("%s", __func__);
0ca1268e
LM		 1165
1166 serial = urb->context;
1167 for (i = 0; i < serial->num_ports; ++i) {
1168 port = serial->port[i];
1169 p_priv = usb_get_serial_port_data(port);
1170
1171 if (p_priv->resend_cont) {
441b62c1 1172 dbg ("%s - sending setup", __func__);
0ca1268e
LM		 1173 keyspan_usa67_send_setup(serial, port,
1174 p_priv->resend_cont - 1);
1175 break;
1176 }
1177 }
1178}
1179
1da177e4
LT		 1180static int keyspan_write_room (struct usb_serial_port *port)
1181{
1182 struct keyspan_port_private *p_priv;
1183 const struct keyspan_device_details *d_details;
1184 int flip;
1185 int data_len;
1186 struct urb *this_urb;
1187
441b62c1 1188 dbg("%s", __func__);
1da177e4
LT		 1189 p_priv = usb_get_serial_port_data(port);
1190 d_details = p_priv->device_details;
1191
a5b6f60c 1192 /* FIXME: locking */
1da177e4
LT		 1193 if (d_details->msg_format == msg_usa90)
1194 data_len = 64;
1195 else
1196 data_len = 63;
1197
1198 flip = p_priv->out_flip;
1199
1200 /* Check both endpoints to see if any are available. */
1201 if ((this_urb = p_priv->out_urbs[flip]) != NULL) {
1202 if (this_urb->status != -EINPROGRESS)
1203 return (data_len);
1204 flip = (flip + 1) & d_details->outdat_endp_flip;
1205 if ((this_urb = p_priv->out_urbs[flip]) != NULL)
1206 if (this_urb->status != -EINPROGRESS)
1207 return (data_len);
1208 }
a5b6f60c 1209 return 0;
1da177e4
LT		 1210}
1211
1212
1213static int keyspan_chars_in_buffer (struct usb_serial_port *port)
1214{
a5b6f60c 1215 return 0;
1da177e4
LT		 1216}
1217
1218
1219static int keyspan_open (struct usb_serial_port *port, struct file *filp)
1220{
f78ba157
AM		 1221 struct keyspan_port_private *p_priv;
1222 struct keyspan_serial_private *s_priv;
1223 struct usb_serial *serial = port->serial;
1da177e4
LT		 1224 const struct keyspan_device_details *d_details;
1225 int i, err;
f78ba157 1226 int baud_rate, device_port;
1da177e4 1227 struct urb *urb;
f78ba157 1228 unsigned int cflag;
1da177e4
LT		 1229
1230 s_priv = usb_get_serial_data(serial);
1231 p_priv = usb_get_serial_port_data(port);
1232 d_details = p_priv->device_details;
7eea4364 1233
441b62c1 1234 dbg("%s - port%d.", __func__, port->number);
1da177e4
LT		 1235
1236 /* Set some sane defaults */
1237 p_priv->rts_state = 1;
1238 p_priv->dtr_state = 1;
1239 p_priv->baud = 9600;
1240
1241 /* force baud and lcr to be set on open */
1242 p_priv->old_baud = 0;
1243 p_priv->old_cflag = 0;
1244
1245 p_priv->out_flip = 0;
1246 p_priv->in_flip = 0;
1247
1248 /* Reset low level data toggle and start reading from endpoints */
1249 for (i = 0; i < 2; i++) {
1250 if ((urb = p_priv->in_urbs[i]) == NULL)
1251 continue;
1252 urb->dev = serial->dev;
1253
1254 /* make sure endpoint data toggle is synchronized with the device */
7eea4364 1255
1da177e4
LT		 1256 usb_clear_halt(urb->dev, urb->pipe);
1257
1258 if ((err = usb_submit_urb(urb, GFP_KERNEL)) != 0) {
441b62c1 1259 dbg("%s - submit urb %d failed (%d)", __func__, i, err);
1da177e4
LT		 1260 }
1261 }
1262
1263 /* Reset low level data toggle on out endpoints */
1264 for (i = 0; i < 2; i++) {
1265 if ((urb = p_priv->out_urbs[i]) == NULL)
1266 continue;
1267 urb->dev = serial->dev;
1268 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe), 0); */
1269 }
1270
f78ba157
AM		 1271 /* get the terminal config for the setup message now so we don't
1272 * need to send 2 of them */
1273
1274 cflag = port->tty->termios->c_cflag;
1275 device_port = port->number - port->serial->minor;
1276
1277 /* Baud rate calculation takes baud rate as an integer
1278 so other rates can be generated if desired. */
1279 baud_rate = tty_get_baud_rate(port->tty);
1280 /* If no match or invalid, leave as default */
1281 if (baud_rate >= 0
1282 && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
1283 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1284 p_priv->baud = baud_rate;
1285 }
1286
1287 /* set CTS/RTS handshake etc. */
1288 p_priv->cflag = cflag;
1289 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
1290
1291 keyspan_send_setup(port, 1);
1292 //mdelay(100);
1293 //keyspan_set_termios(port, NULL);
1294
a5b6f60c 1295 return 0;
1da177e4
LT		 1296}
1297
1298static inline void stop_urb(struct urb *urb)
1299{
242cf670 1300 if (urb && urb->status == -EINPROGRESS)
1da177e4 1301 usb_kill_urb(urb);
1da177e4
LT		 1302}
1303
1304static void keyspan_close(struct usb_serial_port *port, struct file *filp)
1305{
1306 int i;
1307 struct usb_serial *serial = port->serial;
1308 struct keyspan_serial_private *s_priv;
1309 struct keyspan_port_private *p_priv;
1310
441b62c1 1311 dbg("%s", __func__);
1da177e4
LT		 1312 s_priv = usb_get_serial_data(serial);
1313 p_priv = usb_get_serial_port_data(port);
1314
1315 p_priv->rts_state = 0;
1316 p_priv->dtr_state = 0;
1317
1318 if (serial->dev) {
1319 keyspan_send_setup(port, 2);
1320 /* pilot-xfer seems to work best with this delay */
1321 mdelay(100);
1322 // keyspan_set_termios(port, NULL);
1323 }
1324
1325 /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
441b62c1 1326 dbg("%s - urb in progress", __func__);
1da177e4
LT		 1327 }*/
1328
1329 p_priv->out_flip = 0;
1330 p_priv->in_flip = 0;
1331
1332 if (serial->dev) {
1333 /* Stop reading/writing urbs */
1334 stop_urb(p_priv->inack_urb);
1335 /* stop_urb(p_priv->outcont_urb); */
1336 for (i = 0; i < 2; i++) {
1337 stop_urb(p_priv->in_urbs[i]);
1338 stop_urb(p_priv->out_urbs[i]);
1339 }
1340 }
1341 port->tty = NULL;
1342}
1343
1da177e4
LT		 1344 /* download the firmware to a pre-renumeration device */
1345static int keyspan_fake_startup (struct usb_serial *serial)
1346{
1347 int response;
2971c579 1348 const struct ihex_binrec *record;
1da177e4 1349 char *fw_name;
2971c579 1350 const struct firmware *fw;
1da177e4
LT		 1351
1352 dbg("Keyspan startup version %04x product %04x",
1353 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1354 le16_to_cpu(serial->dev->descriptor.idProduct));
1355
1356 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000) != 0x8000) {
1357 dbg("Firmware already loaded. Quitting.");
1358 return(1);
1359 }
1360
1361 /* Select firmware image on the basis of idProduct */
1362 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1363 case keyspan_usa28_pre_product_id:
2971c579 1364 fw_name = "keyspan/usa28.fw";
1da177e4
LT		 1365 break;
1366
1367 case keyspan_usa28x_pre_product_id:
2971c579 1368 fw_name = "keyspan/usa28x.fw";
1da177e4
LT		 1369 break;
1370
1371 case keyspan_usa28xa_pre_product_id:
2971c579 1372 fw_name = "keyspan/usa28xa.fw";
1da177e4
LT		 1373 break;
1374
1375 case keyspan_usa28xb_pre_product_id:
2971c579 1376 fw_name = "keyspan/usa28xb.fw";
1da177e4
LT		 1377 break;
1378
1379 case keyspan_usa19_pre_product_id:
2971c579 1380 fw_name = "keyspan/usa19.fw";
1da177e4
LT		 1381 break;
1382
1383 case keyspan_usa19qi_pre_product_id:
2971c579 1384 fw_name = "keyspan/usa19qi.fw";
1da177e4
LT		 1385 break;
1386
1387 case keyspan_mpr_pre_product_id:
2971c579 1388 fw_name = "keyspan/mpr.fw";
1da177e4
LT		 1389 break;
1390
1391 case keyspan_usa19qw_pre_product_id:
2971c579 1392 fw_name = "keyspan/usa19qw.fw";
1da177e4
LT		 1393 break;
1394
1395 case keyspan_usa18x_pre_product_id:
2971c579 1396 fw_name = "keyspan/usa18x.fw";
1da177e4
LT		 1397 break;
1398
1399 case keyspan_usa19w_pre_product_id:
2971c579 1400 fw_name = "keyspan/usa19w.fw";
1da177e4
LT		 1401 break;
1402
1403 case keyspan_usa49w_pre_product_id:
2971c579 1404 fw_name = "keyspan/usa49w.fw";
1da177e4
LT		 1405 break;
1406
1407 case keyspan_usa49wlc_pre_product_id:
2971c579 1408 fw_name = "keyspan/usa49wlc.fw";
1da177e4
LT		 1409 break;
1410
1411 default:
2971c579
DW		 1412 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1413 le16_to_cpu(serial->dev->descriptor.idProduct));
1414 return 1;
1da177e4
LT		 1415 }
1416
2971c579 1417 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
1da177e4
LT		 1418 dev_err(&serial->dev->dev, "Required keyspan firmware image (%s) unavailable.\n", fw_name);
1419 return(1);
1420 }
1421
1422 dbg("Uploading Keyspan %s firmware.", fw_name);
1423
1424 /* download the firmware image */
1425 response = ezusb_set_reset(serial, 1);
1426
2971c579
DW		 1427 record = (const struct ihex_binrec *)fw->data;
1428
1429 while (record) {
1430 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
1da177e4 1431 (unsigned char *)record->data,
2971c579 1432 be16_to_cpu(record->len), 0xa0);
1da177e4
LT		 1433 if (response < 0) {
1434 dev_err(&serial->dev->dev, "ezusb_writememory failed for Keyspan"
1435 "firmware (%d %04X %p %d)\n",
2971c579
DW		 1436 response, be32_to_cpu(record->addr),
1437 record->data, be16_to_cpu(record->len));
1da177e4
LT		 1438 break;
1439 }
2971c579 1440 record = ihex_next_binrec(record);
1da177e4 1441 }
2971c579 1442 release_firmware(fw);
1da177e4
LT		 1443 /* bring device out of reset. Renumeration will occur in a
1444 moment and the new device will bind to the real driver */
1445 response = ezusb_set_reset(serial, 0);
1446
1447 /* we don't want this device to have a driver assigned to it. */
1448 return (1);
1449}
1450
1451/* Helper functions used by keyspan_setup_urbs */
fdcba53e
RW		 1452static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1453 int endpoint)
1454{
1455 struct usb_host_interface *iface_desc;
1456 struct usb_endpoint_descriptor *ep;
1457 int i;
1458
1459 iface_desc = serial->interface->cur_altsetting;
1460 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1461 ep = &iface_desc->endpoint[i].desc;
1462 if (ep->bEndpointAddress == endpoint)
1463 return ep;
1464 }
1465 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1466 "endpoint %x\n", endpoint);
1467 return NULL;
1468}
1469
1da177e4
LT		 1470static struct urb *keyspan_setup_urb (struct usb_serial *serial, int endpoint,
1471 int dir, void *ctx, char *buf, int len,
7d12e780 1472 void (*callback)(struct urb *))
1da177e4
LT		 1473{
1474 struct urb *urb;
fdcba53e
RW		 1475 struct usb_endpoint_descriptor const *ep_desc;
1476 char const *ep_type_name;
1da177e4
LT		 1477
1478 if (endpoint == -1)
1479 return NULL; /* endpoint not needed */
1480
441b62c1 1481 dbg ("%s - alloc for endpoint %d.", __func__, endpoint);
1da177e4
LT		 1482 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1483 if (urb == NULL) {
441b62c1 1484 dbg ("%s - alloc for endpoint %d failed.", __func__, endpoint);
1da177e4
LT		 1485 return NULL;
1486 }
1487
0ca1268e
LM		 1488 if (endpoint == 0) {
1489 /* control EP filled in when used */
1490 return urb;
1491 }
1492
fdcba53e
RW		 1493 ep_desc = find_ep(serial, endpoint);
1494 if (!ep_desc) {
1495 /* leak the urb, something's wrong and the callers don't care */
1496 return urb;
1497 }
1498 if (usb_endpoint_xfer_int(ep_desc)) {
1499 ep_type_name = "INT";
1500 usb_fill_int_urb(urb, serial->dev,
1501 usb_sndintpipe(serial->dev, endpoint) | dir,
1502 buf, len, callback, ctx,
1503 ep_desc->bInterval);
1504 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1505 ep_type_name = "BULK";
1506 usb_fill_bulk_urb(urb, serial->dev,
1507 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1508 buf, len, callback, ctx);
1509 } else {
1510 dev_warn(&serial->interface->dev,
1511 "unsupported endpoint type %x\n",
1512 ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
1513 usb_free_urb(urb);
1514 return NULL;
1515 }
1da177e4 1516
fdcba53e
RW		 1517 dbg("%s - using urb %p for %s endpoint %x",
1518 __func__, urb, ep_type_name, endpoint);
1da177e4
LT		 1519 return urb;
1520}
1521
1522static struct callbacks {
7d12e780
DH		 1523 void (*instat_callback)(struct urb *);
1524 void (*glocont_callback)(struct urb *);
1525 void (*indat_callback)(struct urb *);
1526 void (*outdat_callback)(struct urb *);
1527 void (*inack_callback)(struct urb *);
1528 void (*outcont_callback)(struct urb *);
1da177e4
LT		 1529} keyspan_callbacks[] = {
1530 {
1531 /* msg_usa26 callbacks */
1532 .instat_callback = usa26_instat_callback,
1533 .glocont_callback = usa26_glocont_callback,
1534 .indat_callback = usa26_indat_callback,
1535 .outdat_callback = usa2x_outdat_callback,
1536 .inack_callback = usa26_inack_callback,
1537 .outcont_callback = usa26_outcont_callback,
1538 }, {
1539 /* msg_usa28 callbacks */
1540 .instat_callback = usa28_instat_callback,
1541 .glocont_callback = usa28_glocont_callback,
1542 .indat_callback = usa28_indat_callback,
1543 .outdat_callback = usa2x_outdat_callback,
1544 .inack_callback = usa28_inack_callback,
1545 .outcont_callback = usa28_outcont_callback,
1546 }, {
1547 /* msg_usa49 callbacks */
1548 .instat_callback = usa49_instat_callback,
1549 .glocont_callback = usa49_glocont_callback,
1550 .indat_callback = usa49_indat_callback,
1551 .outdat_callback = usa2x_outdat_callback,
1552 .inack_callback = usa49_inack_callback,
1553 .outcont_callback = usa49_outcont_callback,
1554 }, {
1555 /* msg_usa90 callbacks */
1556 .instat_callback = usa90_instat_callback,
1557 .glocont_callback = usa28_glocont_callback,
1558 .indat_callback = usa90_indat_callback,
1559 .outdat_callback = usa2x_outdat_callback,
1560 .inack_callback = usa28_inack_callback,
1561 .outcont_callback = usa90_outcont_callback,
0ca1268e
LM		 1562 }, {
1563 /* msg_usa67 callbacks */
1564 .instat_callback = usa67_instat_callback,
1565 .glocont_callback = usa67_glocont_callback,
1566 .indat_callback = usa26_indat_callback,
1567 .outdat_callback = usa2x_outdat_callback,
1568 .inack_callback = usa26_inack_callback,
1569 .outcont_callback = usa26_outcont_callback,
1da177e4
LT		 1570 }
1571};
1572
1573 /* Generic setup urbs function that uses
1574 data in device_details */
1575static void keyspan_setup_urbs(struct usb_serial *serial)
1576{
1577 int i, j;
1578 struct keyspan_serial_private *s_priv;
1579 const struct keyspan_device_details *d_details;
1580 struct usb_serial_port *port;
1581 struct keyspan_port_private *p_priv;
1582 struct callbacks *cback;
1583 int endp;
1584
441b62c1 1585 dbg ("%s", __func__);
1da177e4
LT		 1586
1587 s_priv = usb_get_serial_data(serial);
1588 d_details = s_priv->device_details;
1589
1590 /* Setup values for the various callback routines */
1591 cback = &keyspan_callbacks[d_details->msg_format];
1592
1593 /* Allocate and set up urbs for each one that is in use,
1594 starting with instat endpoints */
1595 s_priv->instat_urb = keyspan_setup_urb
1596 (serial, d_details->instat_endpoint, USB_DIR_IN,
1597 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1598 cback->instat_callback);
1599
0ca1268e
LM		 1600 s_priv->indat_urb = keyspan_setup_urb
1601 (serial, d_details->indat_endpoint, USB_DIR_IN,
1602 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1603 usa49wg_indat_callback);
1604
1da177e4
LT		 1605 s_priv->glocont_urb = keyspan_setup_urb
1606 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1607 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1608 cback->glocont_callback);
1609
1610 /* Setup endpoints for each port specific thing */
1611 for (i = 0; i < d_details->num_ports; i ++) {
1612 port = serial->port[i];
1613 p_priv = usb_get_serial_port_data(port);
1614
1615 /* Do indat endpoints first, once for each flip */
1616 endp = d_details->indat_endpoints[i];
1617 for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) {
1618 p_priv->in_urbs[j] = keyspan_setup_urb
1619 (serial, endp, USB_DIR_IN, port,
1620 p_priv->in_buffer[j], 64,
1621 cback->indat_callback);
1622 }
1623 for (; j < 2; ++j)
1624 p_priv->in_urbs[j] = NULL;
1625
1626 /* outdat endpoints also have flip */
1627 endp = d_details->outdat_endpoints[i];
1628 for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) {
1629 p_priv->out_urbs[j] = keyspan_setup_urb
1630 (serial, endp, USB_DIR_OUT, port,
1631 p_priv->out_buffer[j], 64,
1632 cback->outdat_callback);
1633 }
1634 for (; j < 2; ++j)
1635 p_priv->out_urbs[j] = NULL;
1636
1637 /* inack endpoint */
1638 p_priv->inack_urb = keyspan_setup_urb
1639 (serial, d_details->inack_endpoints[i], USB_DIR_IN,
1640 port, p_priv->inack_buffer, 1, cback->inack_callback);
1641
1642 /* outcont endpoint */
1643 p_priv->outcont_urb = keyspan_setup_urb
1644 (serial, d_details->outcont_endpoints[i], USB_DIR_OUT,
1645 port, p_priv->outcont_buffer, 64,
1646 cback->outcont_callback);
1647 }
1648
1649}
1650
1651/* usa19 function doesn't require prescaler */
1652static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1653 u8 *rate_low, u8 *prescaler, int portnum)
1654{
1655 u32 b16, /* baud rate times 16 (actual rate used internally) */
1656 div, /* divisor */
1657 cnt; /* inverse of divisor (programmed into 8051) */
1658
441b62c1 1659 dbg ("%s - %d.", __func__, baud_rate);
1da177e4
LT		 1660
1661 /* prevent divide by zero... */
1662 if( (b16 = (baud_rate * 16L)) == 0) {
1663 return (KEYSPAN_INVALID_BAUD_RATE);
1664 }
1665
1666 /* Any "standard" rate over 57k6 is marginal on the USA-19
1667 as we run out of divisor resolution. */
1668 if (baud_rate > 57600) {
1669 return (KEYSPAN_INVALID_BAUD_RATE);
1670 }
1671
1672 /* calculate the divisor and the counter (its inverse) */
1673 if( (div = (baudclk / b16)) == 0) {
1674 return (KEYSPAN_INVALID_BAUD_RATE);
1675 }
1676 else {
1677 cnt = 0 - div;
1678 }
1679
1680 if(div > 0xffff) {
1681 return (KEYSPAN_INVALID_BAUD_RATE);
1682 }
1683
1684 /* return the counter values if non-null */
1685 if (rate_low) {
1686 *rate_low = (u8) (cnt & 0xff);
1687 }
1688 if (rate_hi) {
1689 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1690 }
1691 if (rate_low && rate_hi) {
441b62c1 1692 dbg ("%s - %d %02x %02x.", __func__, baud_rate, *rate_hi, *rate_low);
1da177e4
LT		 1693 }
1694
1695 return (KEYSPAN_BAUD_RATE_OK);
1696}
1697
1698/* usa19hs function doesn't require prescaler */
1699static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1700 u8 *rate_low, u8 *prescaler, int portnum)
1701{
1702 u32 b16, /* baud rate times 16 (actual rate used internally) */
1703 div; /* divisor */
1704
441b62c1 1705 dbg ("%s - %d.", __func__, baud_rate);
1da177e4
LT		 1706
1707 /* prevent divide by zero... */
1708 if( (b16 = (baud_rate * 16L)) == 0)
1709 return (KEYSPAN_INVALID_BAUD_RATE);
1710
1711
1712
1713 /* calculate the divisor */
1714 if( (div = (baudclk / b16)) == 0)
1715 return (KEYSPAN_INVALID_BAUD_RATE);
1716
1717 if(div > 0xffff)
1718 return (KEYSPAN_INVALID_BAUD_RATE);
1719
1720 /* return the counter values if non-null */
1721 if (rate_low)
1722 *rate_low = (u8) (div & 0xff);
1723
1724 if (rate_hi)
1725 *rate_hi = (u8) ((div >> 8) & 0xff);
1726
1727 if (rate_low && rate_hi)
441b62c1 1728 dbg ("%s - %d %02x %02x.", __func__, baud_rate, *rate_hi, *rate_low);
1da177e4
LT		 1729
1730 return (KEYSPAN_BAUD_RATE_OK);
1731}
1732
1733static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1734 u8 *rate_low, u8 *prescaler, int portnum)
1735{
1736 u32 b16, /* baud rate times 16 (actual rate used internally) */
1737 clk, /* clock with 13/8 prescaler */
1738 div, /* divisor using 13/8 prescaler */
1739 res, /* resulting baud rate using 13/8 prescaler */
1740 diff, /* error using 13/8 prescaler */
1741 smallest_diff;
1742 u8 best_prescaler;
1743 int i;
1744
441b62c1 1745 dbg ("%s - %d.", __func__, baud_rate);
1da177e4
LT		 1746
1747 /* prevent divide by zero */
1748 if( (b16 = baud_rate * 16L) == 0) {
1749 return (KEYSPAN_INVALID_BAUD_RATE);
1750 }
1751
1752 /* Calculate prescaler by trying them all and looking
1753 for best fit */
1754
1755 /* start with largest possible difference */
1756 smallest_diff = 0xffffffff;
1757
1758 /* 0 is an invalid prescaler, used as a flag */
1759 best_prescaler = 0;
1760
1761 for(i = 8; i <= 0xff; ++i) {
1762 clk = (baudclk * 8) / (u32) i;
1763
1764 if( (div = clk / b16) == 0) {
1765 continue;
1766 }
1767
1768 res = clk / div;
1769 diff= (res > b16) ? (res-b16) : (b16-res);
1770
1771 if(diff < smallest_diff) {
1772 best_prescaler = i;
1773 smallest_diff = diff;
1774 }
1775 }
1776
1777 if(best_prescaler == 0) {
1778 return (KEYSPAN_INVALID_BAUD_RATE);
1779 }
1780
1781 clk = (baudclk * 8) / (u32) best_prescaler;
1782 div = clk / b16;
1783
1784 /* return the divisor and prescaler if non-null */
1785 if (rate_low) {
1786 *rate_low = (u8) (div & 0xff);
1787 }
1788 if (rate_hi) {
1789 *rate_hi = (u8) ((div >> 8) & 0xff);
1790 }
1791 if (prescaler) {
1792 *prescaler = best_prescaler;
441b62c1 1793 /* dbg("%s - %d %d", __func__, *prescaler, div); */
1da177e4
LT		 1794 }
1795 return (KEYSPAN_BAUD_RATE_OK);
1796}
1797
1798 /* USA-28 supports different maximum baud rates on each port */
1799static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1800 u8 *rate_low, u8 *prescaler, int portnum)
1801{
1802 u32 b16, /* baud rate times 16 (actual rate used internally) */
1803 div, /* divisor */
1804 cnt; /* inverse of divisor (programmed into 8051) */
1805
441b62c1 1806 dbg ("%s - %d.", __func__, baud_rate);
1da177e4
LT		 1807
1808 /* prevent divide by zero */
1809 if ((b16 = baud_rate * 16L) == 0)
1810 return (KEYSPAN_INVALID_BAUD_RATE);
1811
1812 /* calculate the divisor and the counter (its inverse) */
1813 if ((div = (KEYSPAN_USA28_BAUDCLK / b16)) == 0) {
1814 return (KEYSPAN_INVALID_BAUD_RATE);
1815 }
1816 else {
1817 cnt = 0 - div;
1818 }
1819
1820 /* check for out of range, based on portnum,
1821 and return result */
1822 if(portnum == 0) {
1823 if(div > 0xffff)
1824 return (KEYSPAN_INVALID_BAUD_RATE);
1825 }
1826 else {
1827 if(portnum == 1) {
1828 if(div > 0xff) {
1829 return (KEYSPAN_INVALID_BAUD_RATE);
1830 }
1831 }
1832 else {
1833 return (KEYSPAN_INVALID_BAUD_RATE);
1834 }
1835 }
1836
1837 /* return the counter values if not NULL
1838 (port 1 will ignore retHi) */
1839 if (rate_low) {
1840 *rate_low = (u8) (cnt & 0xff);
1841 }
1842 if (rate_hi) {
1843 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1844 }
441b62c1 1845 dbg ("%s - %d OK.", __func__, baud_rate);
1da177e4
LT		 1846 return (KEYSPAN_BAUD_RATE_OK);
1847}
1848
1849static int keyspan_usa26_send_setup(struct usb_serial *serial,
1850 struct usb_serial_port *port,
1851 int reset_port)
1852{
1853 struct keyspan_usa26_portControlMessage msg;
1854 struct keyspan_serial_private *s_priv;
1855 struct keyspan_port_private *p_priv;
1856 const struct keyspan_device_details *d_details;
1857 int outcont_urb;
1858 struct urb *this_urb;
1859 int device_port, err;
1860
441b62c1 1861 dbg ("%s reset=%d", __func__, reset_port);
1da177e4
LT		 1862
1863 s_priv = usb_get_serial_data(serial);
1864 p_priv = usb_get_serial_port_data(port);
1865 d_details = s_priv->device_details;
1866 device_port = port->number - port->serial->minor;
1867
1868 outcont_urb = d_details->outcont_endpoints[port->number];
1869 this_urb = p_priv->outcont_urb;
1870
441b62c1 1871 dbg("%s - endpoint %d", __func__, usb_pipeendpoint(this_urb->pipe));
1da177e4
LT		 1872
1873 /* Make sure we have an urb then send the message */
1874 if (this_urb == NULL) {
441b62c1 1875 dbg("%s - oops no urb.", __func__);
1da177e4
LT		 1876 return -1;
1877 }
1878
1879 /* Save reset port val for resend.
0ca1268e
LM		 1880 Don't overwrite resend for open/close condition. */
1881 if ((reset_port + 1) > p_priv->resend_cont)
1da177e4
LT		 1882 p_priv->resend_cont = reset_port + 1;
1883 if (this_urb->status == -EINPROGRESS) {
441b62c1 1884 /* dbg ("%s - already writing", __func__); */
1da177e4
LT		 1885 mdelay(5);
1886 return(-1);
1887 }
1888
1889 memset(&msg, 0, sizeof (struct keyspan_usa26_portControlMessage));
1890
1891 /* Only set baud rate if it's changed */
1892 if (p_priv->old_baud != p_priv->baud) {
1893 p_priv->old_baud = p_priv->baud;
1894 msg.setClocking = 0xff;
1895 if (d_details->calculate_baud_rate
1896 (p_priv->baud, d_details->baudclk, &msg.baudHi,
1897 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE ) {
441b62c1 1898 dbg("%s - Invalid baud rate %d requested, using 9600.", __func__,
1da177e4
LT		 1899 p_priv->baud);
1900 msg.baudLo = 0;
1901 msg.baudHi = 125; /* Values for 9600 baud */
1902 msg.prescaler = 10;
1903 }
1904 msg.setPrescaler = 0xff;
1905 }
1906
1907 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
1908 switch (p_priv->cflag & CSIZE) {
1909 case CS5:
1910 msg.lcr |= USA_DATABITS_5;
1911 break;
1912 case CS6:
1913 msg.lcr |= USA_DATABITS_6;
1914 break;
1915 case CS7:
1916 msg.lcr |= USA_DATABITS_7;
1917 break;
1918 case CS8:
1919 msg.lcr |= USA_DATABITS_8;
1920 break;
1921 }
1922 if (p_priv->cflag & PARENB) {
1923 /* note USA_PARITY_NONE == 0 */
1924 msg.lcr |= (p_priv->cflag & PARODD)?
1925 USA_PARITY_ODD: USA_PARITY_EVEN;
1926 }
1927 msg.setLcr = 0xff;
1928
1929 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1930 msg.xonFlowControl = 0;
1931 msg.setFlowControl = 0xff;
1932 msg.forwardingLength = 16;
1933 msg.xonChar = 17;
1934 msg.xoffChar = 19;
1935
1936 /* Opening port */
1937 if (reset_port == 1) {
1938 msg._txOn = 1;
1939 msg._txOff = 0;
1940 msg.txFlush = 0;
1941 msg.txBreak = 0;
1942 msg.rxOn = 1;
1943 msg.rxOff = 0;
1944 msg.rxFlush = 1;
1945 msg.rxForward = 0;
1946 msg.returnStatus = 0;
1947 msg.resetDataToggle = 0xff;
1948 }
1949
1950 /* Closing port */
1951 else if (reset_port == 2) {
1952 msg._txOn = 0;
1953 msg._txOff = 1;
1954 msg.txFlush = 0;
1955 msg.txBreak = 0;
1956 msg.rxOn = 0;
1957 msg.rxOff = 1;
1958 msg.rxFlush = 1;
1959 msg.rxForward = 0;
1960 msg.returnStatus = 0;
1961 msg.resetDataToggle = 0;
1962 }
1963
1964 /* Sending intermediate configs */
1965 else {
1966 msg._txOn = (! p_priv->break_on);
1967 msg._txOff = 0;
1968 msg.txFlush = 0;
1969 msg.txBreak = (p_priv->break_on);
1970 msg.rxOn = 0;
1971 msg.rxOff = 0;
1972 msg.rxFlush = 0;
1973 msg.rxForward = 0;
1974 msg.returnStatus = 0;
1975 msg.resetDataToggle = 0x0;
1976 }
1977
1978 /* Do handshaking outputs */
1979 msg.setTxTriState_setRts = 0xff;
1980 msg.txTriState_rts = p_priv->rts_state;
1981
1982 msg.setHskoa_setDtr = 0xff;
1983 msg.hskoa_dtr = p_priv->dtr_state;
1984
1985 p_priv->resend_cont = 0;
1986 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
1987
1988 /* send the data out the device on control endpoint */
1989 this_urb->transfer_buffer_length = sizeof(msg);
1990
1991 this_urb->dev = serial->dev;
1992 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
441b62c1 1993 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
1da177e4
LT		 1994 }
1995#if 0
1996 else {
441b62c1 1997 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__
1da177e4
LT		 1998 outcont_urb, this_urb->transfer_buffer_length,
1999 usb_pipeendpoint(this_urb->pipe));
2000 }
2001#endif
2002
a5b6f60c 2003 return 0;
1da177e4
LT		 2004}
2005
2006static int keyspan_usa28_send_setup(struct usb_serial *serial,
2007 struct usb_serial_port *port,
2008 int reset_port)
2009{
2010 struct keyspan_usa28_portControlMessage msg;
2011 struct keyspan_serial_private *s_priv;
2012 struct keyspan_port_private *p_priv;
2013 const struct keyspan_device_details *d_details;
2014 struct urb *this_urb;
2015 int device_port, err;
2016
441b62c1 2017 dbg ("%s", __func__);
1da177e4
LT		 2018
2019 s_priv = usb_get_serial_data(serial);
2020 p_priv = usb_get_serial_port_data(port);
2021 d_details = s_priv->device_details;
2022 device_port = port->number - port->serial->minor;
2023
2024 /* only do something if we have a bulk out endpoint */
2025 if ((this_urb = p_priv->outcont_urb) == NULL) {
441b62c1 2026 dbg("%s - oops no urb.", __func__);
1da177e4
LT		 2027 return -1;
2028 }
2029
2030 /* Save reset port val for resend.
0ca1268e
LM		 2031 Don't overwrite resend for open/close condition. */
2032 if ((reset_port + 1) > p_priv->resend_cont)
1da177e4
LT		 2033 p_priv->resend_cont = reset_port + 1;
2034 if (this_urb->status == -EINPROGRESS) {
441b62c1 2035 dbg ("%s already writing", __func__);
1da177e4
LT		 2036 mdelay(5);
2037 return(-1);
2038 }
2039
2040 memset(&msg, 0, sizeof (struct keyspan_usa28_portControlMessage));
2041
2042 msg.setBaudRate = 1;
2043 if (d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk,
2044 &msg.baudHi, &msg.baudLo, NULL, device_port) == KEYSPAN_INVALID_BAUD_RATE ) {
441b62c1 2045 dbg("%s - Invalid baud rate requested %d.", __func__, p_priv->baud);
1da177e4
LT		 2046 msg.baudLo = 0xff;
2047 msg.baudHi = 0xb2; /* Values for 9600 baud */
2048 }
2049
2050 /* If parity is enabled, we must calculate it ourselves. */
2051 msg.parity = 0; /* XXX for now */
2052
2053 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2054 msg.xonFlowControl = 0;
2055
2056 /* Do handshaking outputs, DTR is inverted relative to RTS */
2057 msg.rts = p_priv->rts_state;
2058 msg.dtr = p_priv->dtr_state;
2059
2060 msg.forwardingLength = 16;
2061 msg.forwardMs = 10;
2062 msg.breakThreshold = 45;
2063 msg.xonChar = 17;
2064 msg.xoffChar = 19;
2065
2066 /*msg.returnStatus = 1;
2067 msg.resetDataToggle = 0xff;*/
2068 /* Opening port */
2069 if (reset_port == 1) {
2070 msg._txOn = 1;
2071 msg._txOff = 0;
2072 msg.txFlush = 0;
2073 msg.txForceXoff = 0;
2074 msg.txBreak = 0;
2075 msg.rxOn = 1;
2076 msg.rxOff = 0;
2077 msg.rxFlush = 1;
2078 msg.rxForward = 0;
2079 msg.returnStatus = 0;
2080 msg.resetDataToggle = 0xff;
2081 }
2082 /* Closing port */
2083 else if (reset_port == 2) {
2084 msg._txOn = 0;
2085 msg._txOff = 1;
2086 msg.txFlush = 0;
2087 msg.txForceXoff = 0;
2088 msg.txBreak = 0;
2089 msg.rxOn = 0;
2090 msg.rxOff = 1;
2091 msg.rxFlush = 1;
2092 msg.rxForward = 0;
2093 msg.returnStatus = 0;
2094 msg.resetDataToggle = 0;
2095 }
2096 /* Sending intermediate configs */
2097 else {
2098 msg._txOn = (! p_priv->break_on);
2099 msg._txOff = 0;
2100 msg.txFlush = 0;
2101 msg.txForceXoff = 0;
2102 msg.txBreak = (p_priv->break_on);
2103 msg.rxOn = 0;
2104 msg.rxOff = 0;
2105 msg.rxFlush = 0;
2106 msg.rxForward = 0;
2107 msg.returnStatus = 0;
2108 msg.resetDataToggle = 0x0;
2109 }
2110
2111 p_priv->resend_cont = 0;
2112 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
2113
2114 /* send the data out the device on control endpoint */
2115 this_urb->transfer_buffer_length = sizeof(msg);
2116
2117 this_urb->dev = serial->dev;
2118 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
441b62c1 2119 dbg("%s - usb_submit_urb(setup) failed", __func__);
1da177e4
LT		 2120 }
2121#if 0
2122 else {
441b62c1 2123 dbg("%s - usb_submit_urb(setup) OK %d bytes", __func__,
1da177e4
LT		 2124 this_urb->transfer_buffer_length);
2125 }
2126#endif
2127
a5b6f60c 2128 return 0;
1da177e4
LT		 2129}
2130
2131static int keyspan_usa49_send_setup(struct usb_serial *serial,
2132 struct usb_serial_port *port,
2133 int reset_port)
2134{
0ca1268e
LM		 2135 struct keyspan_usa49_portControlMessage msg;
2136 struct usb_ctrlrequest *dr = NULL;
1da177e4
LT		 2137 struct keyspan_serial_private *s_priv;
2138 struct keyspan_port_private *p_priv;
2139 const struct keyspan_device_details *d_details;
1da177e4
LT		 2140 struct urb *this_urb;
2141 int err, device_port;
2142
441b62c1 2143 dbg ("%s", __func__);
1da177e4
LT		 2144
2145 s_priv = usb_get_serial_data(serial);
2146 p_priv = usb_get_serial_port_data(port);
2147 d_details = s_priv->device_details;
2148
1da177e4
LT		 2149 this_urb = s_priv->glocont_urb;
2150
0ca1268e 2151 /* Work out which port within the device is being setup */
1da177e4
LT		 2152 device_port = port->number - port->serial->minor;
2153
441b62c1 2154 dbg("%s - endpoint %d port %d (%d)",__func__, usb_pipeendpoint(this_urb->pipe), port->number, device_port);
1da177e4
LT		 2155
2156 /* Make sure we have an urb then send the message */
2157 if (this_urb == NULL) {
441b62c1 2158 dbg("%s - oops no urb for port %d.", __func__, port->number);
1da177e4
LT		 2159 return -1;
2160 }
2161
2162 /* Save reset port val for resend.
0ca1268e
LM		 2163 Don't overwrite resend for open/close condition. */
2164 if ((reset_port + 1) > p_priv->resend_cont)
1da177e4 2165 p_priv->resend_cont = reset_port + 1;
0ca1268e 2166
1da177e4 2167 if (this_urb->status == -EINPROGRESS) {
441b62c1 2168 /* dbg ("%s - already writing", __func__); */
1da177e4
LT		 2169 mdelay(5);
2170 return(-1);
2171 }
2172
2173 memset(&msg, 0, sizeof (struct keyspan_usa49_portControlMessage));
2174
2175 /*msg.portNumber = port->number;*/
2176 msg.portNumber = device_port;
2177
2178 /* Only set baud rate if it's changed */
2179 if (p_priv->old_baud != p_priv->baud) {
2180 p_priv->old_baud = p_priv->baud;
2181 msg.setClocking = 0xff;
2182 if (d_details->calculate_baud_rate
2183 (p_priv->baud, d_details->baudclk, &msg.baudHi,
2184 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE ) {
441b62c1 2185 dbg("%s - Invalid baud rate %d requested, using 9600.", __func__,
1da177e4
LT		 2186 p_priv->baud);
2187 msg.baudLo = 0;
2188 msg.baudHi = 125; /* Values for 9600 baud */
2189 msg.prescaler = 10;
2190 }
2191 //msg.setPrescaler = 0xff;
2192 }
2193
2194 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
2195 switch (p_priv->cflag & CSIZE) {
2196 case CS5:
2197 msg.lcr |= USA_DATABITS_5;
2198 break;
2199 case CS6:
2200 msg.lcr |= USA_DATABITS_6;
2201 break;
2202 case CS7:
2203 msg.lcr |= USA_DATABITS_7;
2204 break;
2205 case CS8:
2206 msg.lcr |= USA_DATABITS_8;
2207 break;
2208 }
2209 if (p_priv->cflag & PARENB) {
2210 /* note USA_PARITY_NONE == 0 */
2211 msg.lcr |= (p_priv->cflag & PARODD)?
2212 USA_PARITY_ODD: USA_PARITY_EVEN;
2213 }
2214 msg.setLcr = 0xff;
2215
2216 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2217 msg.xonFlowControl = 0;
2218 msg.setFlowControl = 0xff;
2219
2220 msg.forwardingLength = 16;
2221 msg.xonChar = 17;
2222 msg.xoffChar = 19;
2223
2224 /* Opening port */
2225 if (reset_port == 1) {
2226 msg._txOn = 1;
2227 msg._txOff = 0;
2228 msg.txFlush = 0;
2229 msg.txBreak = 0;
2230 msg.rxOn = 1;
2231 msg.rxOff = 0;
2232 msg.rxFlush = 1;
2233 msg.rxForward = 0;
2234 msg.returnStatus = 0;
2235 msg.resetDataToggle = 0xff;
2236 msg.enablePort = 1;
2237 msg.disablePort = 0;
2238 }
2239 /* Closing port */
2240 else if (reset_port == 2) {
2241 msg._txOn = 0;
2242 msg._txOff = 1;
2243 msg.txFlush = 0;
2244 msg.txBreak = 0;
2245 msg.rxOn = 0;
2246 msg.rxOff = 1;
2247 msg.rxFlush = 1;
2248 msg.rxForward = 0;
2249 msg.returnStatus = 0;
2250 msg.resetDataToggle = 0;
2251 msg.enablePort = 0;
2252 msg.disablePort = 1;
2253 }
2254 /* Sending intermediate configs */
2255 else {
2256 msg._txOn = (! p_priv->break_on);
2257 msg._txOff = 0;
2258 msg.txFlush = 0;
2259 msg.txBreak = (p_priv->break_on);
2260 msg.rxOn = 0;
2261 msg.rxOff = 0;
2262 msg.rxFlush = 0;
2263 msg.rxForward = 0;
2264 msg.returnStatus = 0;
2265 msg.resetDataToggle = 0x0;
2266 msg.enablePort = 0;
2267 msg.disablePort = 0;
2268 }
2269
2270 /* Do handshaking outputs */
2271 msg.setRts = 0xff;
2272 msg.rts = p_priv->rts_state;
2273
2274 msg.setDtr = 0xff;
2275 msg.dtr = p_priv->dtr_state;
2276
2277 p_priv->resend_cont = 0;
0ca1268e
LM		 2278
2279 /* if the device is a 49wg, we send control message on usb control EP 0 */
2280
2281 if (d_details->product_id == keyspan_usa49wg_product_id) {
2282 dr = (void *)(s_priv->ctrl_buf);
2283 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2284 dr->bRequest = 0xB0; /* 49wg control message */;
2285 dr->wValue = 0;
2286 dr->wIndex = 0;
2287 dr->wLength = cpu_to_le16(sizeof(msg));
2288
2289 memcpy (s_priv->glocont_buf, &msg, sizeof(msg));
2290
2291 usb_fill_control_urb(this_urb, serial->dev, usb_sndctrlpipe(serial->dev, 0),
2292 (unsigned char *)dr, s_priv->glocont_buf, sizeof(msg),
2293 usa49_glocont_callback, serial);
2294
2295 } else {
2296 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1da177e4 2297
0ca1268e
LM		 2298 /* send the data out the device on control endpoint */
2299 this_urb->transfer_buffer_length = sizeof(msg);
1da177e4 2300
0ca1268e
LM		 2301 this_urb->dev = serial->dev;
2302 }
1da177e4 2303 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
441b62c1 2304 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
1da177e4
LT		 2305 }
2306#if 0
2307 else {
441b62c1 2308 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__,
0ca1268e
LM		 2309 outcont_urb, this_urb->transfer_buffer_length,
2310 usb_pipeendpoint(this_urb->pipe));
1da177e4
LT		 2311 }
2312#endif
2313
a5b6f60c 2314 return 0;
1da177e4
LT		 2315}
2316
2317static int keyspan_usa90_send_setup(struct usb_serial *serial,
2318 struct usb_serial_port *port,
2319 int reset_port)
2320{
2321 struct keyspan_usa90_portControlMessage msg;
2322 struct keyspan_serial_private *s_priv;
2323 struct keyspan_port_private *p_priv;
2324 const struct keyspan_device_details *d_details;
2325 struct urb *this_urb;
2326 int err;
2327 u8 prescaler;
2328
441b62c1 2329 dbg ("%s", __func__);
1da177e4
LT		 2330
2331 s_priv = usb_get_serial_data(serial);
2332 p_priv = usb_get_serial_port_data(port);
2333 d_details = s_priv->device_details;
2334
2335 /* only do something if we have a bulk out endpoint */
2336 if ((this_urb = p_priv->outcont_urb) == NULL) {
441b62c1 2337 dbg("%s - oops no urb.", __func__);
1da177e4
LT		 2338 return -1;
2339 }
2340
2341 /* Save reset port val for resend.
2342 Don't overwrite resend for open/close condition. */
2343 if ((reset_port + 1) > p_priv->resend_cont)
2344 p_priv->resend_cont = reset_port + 1;
2345 if (this_urb->status == -EINPROGRESS) {
441b62c1 2346 dbg ("%s already writing", __func__);
1da177e4
LT		 2347 mdelay(5);
2348 return(-1);
2349 }
2350
2351 memset(&msg, 0, sizeof (struct keyspan_usa90_portControlMessage));
2352
2353 /* Only set baud rate if it's changed */
2354 if (p_priv->old_baud != p_priv->baud) {
2355 p_priv->old_baud = p_priv->baud;
2356 msg.setClocking = 0x01;
2357 if (d_details->calculate_baud_rate
2358 (p_priv->baud, d_details->baudclk, &msg.baudHi,
2359 &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE ) {
441b62c1 2360 dbg("%s - Invalid baud rate %d requested, using 9600.", __func__,
1da177e4
LT		 2361 p_priv->baud);
2362 p_priv->baud = 9600;
2363 d_details->calculate_baud_rate (p_priv->baud, d_details->baudclk,
2364 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2365 }
2366 msg.setRxMode = 1;
2367 msg.setTxMode = 1;
2368 }
2369
2370 /* modes must always be correctly specified */
2371 if (p_priv->baud > 57600)
2372 {
2373 msg.rxMode = RXMODE_DMA;
2374 msg.txMode = TXMODE_DMA;
2375 }
2376 else
2377 {
2378 msg.rxMode = RXMODE_BYHAND;
2379 msg.txMode = TXMODE_BYHAND;
2380 }
2381
2382 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
2383 switch (p_priv->cflag & CSIZE) {
2384 case CS5:
2385 msg.lcr |= USA_DATABITS_5;
2386 break;
2387 case CS6:
2388 msg.lcr |= USA_DATABITS_6;
2389 break;
2390 case CS7:
2391 msg.lcr |= USA_DATABITS_7;
2392 break;
2393 case CS8:
2394 msg.lcr |= USA_DATABITS_8;
2395 break;
2396 }
2397 if (p_priv->cflag & PARENB) {
2398 /* note USA_PARITY_NONE == 0 */
2399 msg.lcr |= (p_priv->cflag & PARODD)?
2400 USA_PARITY_ODD: USA_PARITY_EVEN;
2401 }
2402 if (p_priv->old_cflag != p_priv->cflag) {
2403 p_priv->old_cflag = p_priv->cflag;
2404 msg.setLcr = 0x01;
2405 }
2406
2407 if (p_priv->flow_control == flow_cts)
2408 msg.txFlowControl = TXFLOW_CTS;
2409 msg.setTxFlowControl = 0x01;
2410 msg.setRxFlowControl = 0x01;
2411
2412 msg.rxForwardingLength = 16;
2413 msg.rxForwardingTimeout = 16;
2414 msg.txAckSetting = 0;
2415 msg.xonChar = 17;
2416 msg.xoffChar = 19;
2417
2418 /* Opening port */
2419 if (reset_port == 1) {
2420 msg.portEnabled = 1;
2421 msg.rxFlush = 1;
2422 msg.txBreak = (p_priv->break_on);
2423 }
2424 /* Closing port */
2425 else if (reset_port == 2) {
2426 msg.portEnabled = 0;
2427 }
2428 /* Sending intermediate configs */
2429 else {
2430 if (port->open_count)
2431 msg.portEnabled = 1;
2432 msg.txBreak = (p_priv->break_on);
2433 }
2434
2435 /* Do handshaking outputs */
2436 msg.setRts = 0x01;
2437 msg.rts = p_priv->rts_state;
2438
2439 msg.setDtr = 0x01;
2440 msg.dtr = p_priv->dtr_state;
2441
2442 p_priv->resend_cont = 0;
2443 memcpy (this_urb->transfer_buffer, &msg, sizeof(msg));
2444
2445 /* send the data out the device on control endpoint */
2446 this_urb->transfer_buffer_length = sizeof(msg);
2447
2448 this_urb->dev = serial->dev;
2449 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
441b62c1 2450 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
1da177e4 2451 }
a5b6f60c 2452 return 0;
1da177e4
LT		 2453}
2454
0ca1268e
LM		 2455static int keyspan_usa67_send_setup(struct usb_serial *serial,
2456 struct usb_serial_port *port,
2457 int reset_port)
2458{
2459 struct keyspan_usa67_portControlMessage msg;
2460 struct keyspan_serial_private *s_priv;
2461 struct keyspan_port_private *p_priv;
2462 const struct keyspan_device_details *d_details;
2463 struct urb *this_urb;
2464 int err, device_port;
2465
441b62c1 2466 dbg ("%s", __func__);
0ca1268e
LM		 2467
2468 s_priv = usb_get_serial_data(serial);
2469 p_priv = usb_get_serial_port_data(port);
2470 d_details = s_priv->device_details;
2471
2472 this_urb = s_priv->glocont_urb;
2473
2474 /* Work out which port within the device is being setup */
2475 device_port = port->number - port->serial->minor;
2476
2477 /* Make sure we have an urb then send the message */
2478 if (this_urb == NULL) {
441b62c1 2479 dbg("%s - oops no urb for port %d.", __func__,
0ca1268e
LM		 2480 port->number);
2481 return -1;
2482 }
2483
2484 /* Save reset port val for resend.
2485 Don't overwrite resend for open/close condition. */
2486 if ((reset_port + 1) > p_priv->resend_cont)
2487 p_priv->resend_cont = reset_port + 1;
2488 if (this_urb->status == -EINPROGRESS) {
441b62c1 2489 /* dbg ("%s - already writing", __func__); */
0ca1268e
LM		 2490 mdelay(5);
2491 return(-1);
2492 }
2493
2494 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2495
2496 msg.port = device_port;
2497
2498 /* Only set baud rate if it's changed */
2499 if (p_priv->old_baud != p_priv->baud) {
2500 p_priv->old_baud = p_priv->baud;
2501 msg.setClocking = 0xff;
2502 if (d_details->calculate_baud_rate
2503 (p_priv->baud, d_details->baudclk, &msg.baudHi,
2504 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE ) {
441b62c1 2505 dbg("%s - Invalid baud rate %d requested, using 9600.", __func__,
0ca1268e
LM		 2506 p_priv->baud);
2507 msg.baudLo = 0;
2508 msg.baudHi = 125; /* Values for 9600 baud */
2509 msg.prescaler = 10;
2510 }
2511 msg.setPrescaler = 0xff;
2512 }
2513
2514 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2515 switch (p_priv->cflag & CSIZE) {
2516 case CS5:
2517 msg.lcr |= USA_DATABITS_5;
2518 break;
2519 case CS6:
2520 msg.lcr |= USA_DATABITS_6;
2521 break;
2522 case CS7:
2523 msg.lcr |= USA_DATABITS_7;
2524 break;
2525 case CS8:
2526 msg.lcr |= USA_DATABITS_8;
2527 break;
2528 }
2529 if (p_priv->cflag & PARENB) {
2530 /* note USA_PARITY_NONE == 0 */
2531 msg.lcr |= (p_priv->cflag & PARODD)?
2532 USA_PARITY_ODD: USA_PARITY_EVEN;
2533 }
2534 msg.setLcr = 0xff;
2535
2536 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2537 msg.xonFlowControl = 0;
2538 msg.setFlowControl = 0xff;
2539 msg.forwardingLength = 16;
2540 msg.xonChar = 17;
2541 msg.xoffChar = 19;
2542
2543 if (reset_port == 1) {
2544 /* Opening port */
2545 msg._txOn = 1;
2546 msg._txOff = 0;
2547 msg.txFlush = 0;
2548 msg.txBreak = 0;
2549 msg.rxOn = 1;
2550 msg.rxOff = 0;
2551 msg.rxFlush = 1;
2552 msg.rxForward = 0;
2553 msg.returnStatus = 0;
2554 msg.resetDataToggle = 0xff;
2555 } else if (reset_port == 2) {
2556 /* Closing port */
2557 msg._txOn = 0;
2558 msg._txOff = 1;
2559 msg.txFlush = 0;
2560 msg.txBreak = 0;
2561 msg.rxOn = 0;
2562 msg.rxOff = 1;
2563 msg.rxFlush = 1;
2564 msg.rxForward = 0;
2565 msg.returnStatus = 0;
2566 msg.resetDataToggle = 0;
2567 } else {
2568 /* Sending intermediate configs */
2569 msg._txOn = (! p_priv->break_on);
2570 msg._txOff = 0;
2571 msg.txFlush = 0;
2572 msg.txBreak = (p_priv->break_on);
2573 msg.rxOn = 0;
2574 msg.rxOff = 0;
2575 msg.rxFlush = 0;
2576 msg.rxForward = 0;
2577 msg.returnStatus = 0;
2578 msg.resetDataToggle = 0x0;
2579 }
2580
2581 /* Do handshaking outputs */
2582 msg.setTxTriState_setRts = 0xff;
2583 msg.txTriState_rts = p_priv->rts_state;
2584
2585 msg.setHskoa_setDtr = 0xff;
2586 msg.hskoa_dtr = p_priv->dtr_state;
2587
2588 p_priv->resend_cont = 0;
2589
2590 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2591
2592 /* send the data out the device on control endpoint */
2593 this_urb->transfer_buffer_length = sizeof(msg);
2594 this_urb->dev = serial->dev;
2595
2596 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2597 if (err != 0)
441b62c1 2598 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__,
0ca1268e 2599 err);
a5b6f60c 2600 return 0;
0ca1268e
LM		 2601}
2602
1da177e4
LT		 2603static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2604{
2605 struct usb_serial *serial = port->serial;
2606 struct keyspan_serial_private *s_priv;
2607 const struct keyspan_device_details *d_details;
2608
441b62c1 2609 dbg ("%s", __func__);
1da177e4
LT		 2610
2611 s_priv = usb_get_serial_data(serial);
2612 d_details = s_priv->device_details;
2613
2614 switch (d_details->msg_format) {
2615 case msg_usa26:
2616 keyspan_usa26_send_setup(serial, port, reset_port);
2617 break;
2618 case msg_usa28:
2619 keyspan_usa28_send_setup(serial, port, reset_port);
2620 break;
2621 case msg_usa49:
2622 keyspan_usa49_send_setup(serial, port, reset_port);
2623 break;
2624 case msg_usa90:
2625 keyspan_usa90_send_setup(serial, port, reset_port);
2626 break;
0ca1268e
LM		 2627 case msg_usa67:
2628 keyspan_usa67_send_setup(serial, port, reset_port);
2629 break;
1da177e4
LT		 2630 }
2631}
2632
2633
2634/* Gets called by the "real" driver (ie once firmware is loaded
2635 and renumeration has taken place. */
2636static int keyspan_startup (struct usb_serial *serial)
2637{
2638 int i, err;
2639 struct usb_serial_port *port;
2640 struct keyspan_serial_private *s_priv;
2641 struct keyspan_port_private *p_priv;
2642 const struct keyspan_device_details *d_details;
2643
441b62c1 2644 dbg("%s", __func__);
1da177e4
LT		 2645
2646 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2647 if (d_details->product_id == le16_to_cpu(serial->dev->descriptor.idProduct))
2648 break;
2649 if (d_details == NULL) {
441b62c1 2650 dev_err(&serial->dev->dev, "%s - unknown product id %x\n", __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
1da177e4
LT		 2651 return 1;
2652 }
2653
2654 /* Setup private data for serial driver */
80b6ca48 2655 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
1da177e4 2656 if (!s_priv) {
441b62c1 2657 dbg("%s - kmalloc for keyspan_serial_private failed.", __func__);
1da177e4
LT		 2658 return -ENOMEM;
2659 }
1da177e4
LT		 2660
2661 s_priv->device_details = d_details;
2662 usb_set_serial_data(serial, s_priv);
2663
2664 /* Now setup per port private data */
2665 for (i = 0; i < serial->num_ports; i++) {
2666 port = serial->port[i];
80b6ca48 2667 p_priv = kzalloc(sizeof(struct keyspan_port_private), GFP_KERNEL);
1da177e4 2668 if (!p_priv) {
441b62c1 2669 dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __func__, i);
1da177e4
LT		 2670 return (1);
2671 }
1da177e4
LT		 2672 p_priv->device_details = d_details;
2673 usb_set_serial_port_data(port, p_priv);
2674 }
2675
2676 keyspan_setup_urbs(serial);
2677
0ca1268e
LM		 2678 if (s_priv->instat_urb != NULL) {
2679 s_priv->instat_urb->dev = serial->dev;
2680 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2681 if (err != 0)
441b62c1 2682 dbg("%s - submit instat urb failed %d", __func__,
0ca1268e
LM		 2683 err);
2684 }
2685 if (s_priv->indat_urb != NULL) {
2686 s_priv->indat_urb->dev = serial->dev;
2687 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2688 if (err != 0)
441b62c1 2689 dbg("%s - submit indat urb failed %d", __func__,
0ca1268e 2690 err);
1da177e4
LT		 2691 }
2692
a5b6f60c 2693 return 0;
1da177e4
LT		 2694}
2695
2696static void keyspan_shutdown (struct usb_serial *serial)
2697{
2698 int i, j;
2699 struct usb_serial_port *port;
2700 struct keyspan_serial_private *s_priv;
2701 struct keyspan_port_private *p_priv;
2702
441b62c1 2703 dbg("%s", __func__);
1da177e4
LT		 2704
2705 s_priv = usb_get_serial_data(serial);
2706
2707 /* Stop reading/writing urbs */
2708 stop_urb(s_priv->instat_urb);
2709 stop_urb(s_priv->glocont_urb);
0ca1268e 2710 stop_urb(s_priv->indat_urb);
1da177e4
LT		 2711 for (i = 0; i < serial->num_ports; ++i) {
2712 port = serial->port[i];
2713 p_priv = usb_get_serial_port_data(port);
2714 stop_urb(p_priv->inack_urb);
2715 stop_urb(p_priv->outcont_urb);
2716 for (j = 0; j < 2; j++) {
2717 stop_urb(p_priv->in_urbs[j]);
2718 stop_urb(p_priv->out_urbs[j]);
2719 }
2720 }
2721
2722 /* Now free them */
1cadc137 2723 usb_free_urb(s_priv->instat_urb);
0ca1268e 2724 usb_free_urb(s_priv->indat_urb);
1cadc137 2725 usb_free_urb(s_priv->glocont_urb);
1da177e4
LT		 2726 for (i = 0; i < serial->num_ports; ++i) {
2727 port = serial->port[i];
2728 p_priv = usb_get_serial_port_data(port);
1cadc137
MK		 2729 usb_free_urb(p_priv->inack_urb);
2730 usb_free_urb(p_priv->outcont_urb);
1da177e4 2731 for (j = 0; j < 2; j++) {
1cadc137
MK		 2732 usb_free_urb(p_priv->in_urbs[j]);
2733 usb_free_urb(p_priv->out_urbs[j]);
1da177e4
LT		 2734 }
2735 }
2736
2737 /* dbg("Freeing serial->private."); */
2738 kfree(s_priv);
2739
2740 /* dbg("Freeing port->private."); */
2741 /* Now free per port private data */
2742 for (i = 0; i < serial->num_ports; i++) {
2743 port = serial->port[i];
2744 kfree(usb_get_serial_port_data(port));
2745 }
2746}
2747
2748MODULE_AUTHOR( DRIVER_AUTHOR );
2749MODULE_DESCRIPTION( DRIVER_DESC );
2750MODULE_LICENSE("GPL");
2751
2971c579
DW		 2752MODULE_FIRMWARE("keyspan/usa28.fw");
2753MODULE_FIRMWARE("keyspan/usa28x.fw");
2754MODULE_FIRMWARE("keyspan/usa28xa.fw");
2755MODULE_FIRMWARE("keyspan/usa28xb.fw");
2756MODULE_FIRMWARE("keyspan/usa19.fw");
2757MODULE_FIRMWARE("keyspan/usa19qi.fw");
2758MODULE_FIRMWARE("keyspan/mpr.fw");
2759MODULE_FIRMWARE("keyspan/usa19qw.fw");
2760MODULE_FIRMWARE("keyspan/usa18x.fw");
2761MODULE_FIRMWARE("keyspan/usa19w.fw");
2762MODULE_FIRMWARE("keyspan/usa49w.fw");
2763MODULE_FIRMWARE("keyspan/usa49wlc.fw");
2764
1da177e4
LT		 2765module_param(debug, bool, S_IRUGO | S_IWUSR);
2766MODULE_PARM_DESC(debug, "Debug enabled or not");
2767
Ubuntu Artful kernel mirror