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