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