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