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