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