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