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