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