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