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