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