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