]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/usb/serial/keyspan.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'tty-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty
[mirror_ubuntu-artful-kernel.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/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 if (urb->actual_length) {
730 while (i < urb->actual_length) {
731
732 /* Check port number from message*/
733 if (data[i] >= serial->num_ports) {
734 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
735 __func__, data[i]);
736 return;
737 }
738 port = serial->port[data[i++]];
739 len = data[i++];
740
741 /* 0x80 bit is error flag */
742 if ((data[i] & 0x80) == 0) {
743 /* no error on any byte */
744 i++;
745 for (x = 1; x < len ; ++x)
746 tty_insert_flip_char(&port->port,
747 data[i++], 0);
748 } else {
749 /*
750 * some bytes had errors, every byte has status
751 */
752 for (x = 0; x + 1 < len; x += 2) {
753 int stat = data[i], flag = 0;
754 if (stat & RXERROR_OVERRUN)
755 flag |= TTY_OVERRUN;
756 if (stat & RXERROR_FRAMING)
757 flag |= TTY_FRAME;
758 if (stat & RXERROR_PARITY)
759 flag |= TTY_PARITY;
760 /* XXX should handle break (0x10) */
761 tty_insert_flip_char(&port->port,
762 data[i+1], flag);
763 i += 2;
764 }
765 }
766 tty_flip_buffer_push(&port->port);
767 }
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 usb_serial *serial = port->serial;
1119 struct keyspan_port_private *p_priv;
1120
1121 p_priv = usb_get_serial_port_data(port);
1122
1123 p_priv->rts_state = 0;
1124 p_priv->dtr_state = 0;
1125
1126 if (serial->dev) {
1127 keyspan_send_setup(port, 2);
1128 /* pilot-xfer seems to work best with this delay */
1129 mdelay(100);
1130 /* keyspan_set_termios(port, NULL); */
1131 }
1132
1133 /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
1134 dev_dbg(&port->dev, "%s - urb in progress\n", __func__);
1135 }*/
1136
1137 p_priv->out_flip = 0;
1138 p_priv->in_flip = 0;
1139
1140 if (serial->dev) {
1141 /* Stop reading/writing urbs */
1142 stop_urb(p_priv->inack_urb);
1143 /* stop_urb(p_priv->outcont_urb); */
1144 for (i = 0; i < 2; i++) {
1145 stop_urb(p_priv->in_urbs[i]);
1146 stop_urb(p_priv->out_urbs[i]);
1147 }
1148 }
1149 }
1150
1151 /* download the firmware to a pre-renumeration device */
1152 static int keyspan_fake_startup(struct usb_serial *serial)
1153 {
1154 char *fw_name;
1155
1156 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1157 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1158 le16_to_cpu(serial->dev->descriptor.idProduct));
1159
1160 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1161 != 0x8000) {
1162 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n");
1163 return 1;
1164 }
1165
1166 /* Select firmware image on the basis of idProduct */
1167 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1168 case keyspan_usa28_pre_product_id:
1169 fw_name = "keyspan/usa28.fw";
1170 break;
1171
1172 case keyspan_usa28x_pre_product_id:
1173 fw_name = "keyspan/usa28x.fw";
1174 break;
1175
1176 case keyspan_usa28xa_pre_product_id:
1177 fw_name = "keyspan/usa28xa.fw";
1178 break;
1179
1180 case keyspan_usa28xb_pre_product_id:
1181 fw_name = "keyspan/usa28xb.fw";
1182 break;
1183
1184 case keyspan_usa19_pre_product_id:
1185 fw_name = "keyspan/usa19.fw";
1186 break;
1187
1188 case keyspan_usa19qi_pre_product_id:
1189 fw_name = "keyspan/usa19qi.fw";
1190 break;
1191
1192 case keyspan_mpr_pre_product_id:
1193 fw_name = "keyspan/mpr.fw";
1194 break;
1195
1196 case keyspan_usa19qw_pre_product_id:
1197 fw_name = "keyspan/usa19qw.fw";
1198 break;
1199
1200 case keyspan_usa18x_pre_product_id:
1201 fw_name = "keyspan/usa18x.fw";
1202 break;
1203
1204 case keyspan_usa19w_pre_product_id:
1205 fw_name = "keyspan/usa19w.fw";
1206 break;
1207
1208 case keyspan_usa49w_pre_product_id:
1209 fw_name = "keyspan/usa49w.fw";
1210 break;
1211
1212 case keyspan_usa49wlc_pre_product_id:
1213 fw_name = "keyspan/usa49wlc.fw";
1214 break;
1215
1216 default:
1217 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1218 le16_to_cpu(serial->dev->descriptor.idProduct));
1219 return 1;
1220 }
1221
1222 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1223
1224 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1225 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1226 fw_name);
1227 return -ENOENT;
1228 }
1229
1230 /* after downloading firmware Renumeration will occur in a
1231 moment and the new device will bind to the real driver */
1232
1233 /* we don't want this device to have a driver assigned to it. */
1234 return 1;
1235 }
1236
1237 /* Helper functions used by keyspan_setup_urbs */
1238 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1239 int endpoint)
1240 {
1241 struct usb_host_interface *iface_desc;
1242 struct usb_endpoint_descriptor *ep;
1243 int i;
1244
1245 iface_desc = serial->interface->cur_altsetting;
1246 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1247 ep = &iface_desc->endpoint[i].desc;
1248 if (ep->bEndpointAddress == endpoint)
1249 return ep;
1250 }
1251 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1252 "endpoint %x\n", endpoint);
1253 return NULL;
1254 }
1255
1256 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1257 int dir, void *ctx, char *buf, int len,
1258 void (*callback)(struct urb *))
1259 {
1260 struct urb *urb;
1261 struct usb_endpoint_descriptor const *ep_desc;
1262 char const *ep_type_name;
1263
1264 if (endpoint == -1)
1265 return NULL; /* endpoint not needed */
1266
1267 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
1268 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1269 if (urb == NULL) {
1270 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
1271 return NULL;
1272 }
1273
1274 if (endpoint == 0) {
1275 /* control EP filled in when used */
1276 return urb;
1277 }
1278
1279 ep_desc = find_ep(serial, endpoint);
1280 if (!ep_desc) {
1281 /* leak the urb, something's wrong and the callers don't care */
1282 return urb;
1283 }
1284 if (usb_endpoint_xfer_int(ep_desc)) {
1285 ep_type_name = "INT";
1286 usb_fill_int_urb(urb, serial->dev,
1287 usb_sndintpipe(serial->dev, endpoint) | dir,
1288 buf, len, callback, ctx,
1289 ep_desc->bInterval);
1290 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1291 ep_type_name = "BULK";
1292 usb_fill_bulk_urb(urb, serial->dev,
1293 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1294 buf, len, callback, ctx);
1295 } else {
1296 dev_warn(&serial->interface->dev,
1297 "unsupported endpoint type %x\n",
1298 usb_endpoint_type(ep_desc));
1299 usb_free_urb(urb);
1300 return NULL;
1301 }
1302
1303 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1304 __func__, urb, ep_type_name, endpoint);
1305 return urb;
1306 }
1307
1308 static struct callbacks {
1309 void (*instat_callback)(struct urb *);
1310 void (*glocont_callback)(struct urb *);
1311 void (*indat_callback)(struct urb *);
1312 void (*outdat_callback)(struct urb *);
1313 void (*inack_callback)(struct urb *);
1314 void (*outcont_callback)(struct urb *);
1315 } keyspan_callbacks[] = {
1316 {
1317 /* msg_usa26 callbacks */
1318 .instat_callback = usa26_instat_callback,
1319 .glocont_callback = usa26_glocont_callback,
1320 .indat_callback = usa26_indat_callback,
1321 .outdat_callback = usa2x_outdat_callback,
1322 .inack_callback = usa26_inack_callback,
1323 .outcont_callback = usa26_outcont_callback,
1324 }, {
1325 /* msg_usa28 callbacks */
1326 .instat_callback = usa28_instat_callback,
1327 .glocont_callback = usa28_glocont_callback,
1328 .indat_callback = usa28_indat_callback,
1329 .outdat_callback = usa2x_outdat_callback,
1330 .inack_callback = usa28_inack_callback,
1331 .outcont_callback = usa28_outcont_callback,
1332 }, {
1333 /* msg_usa49 callbacks */
1334 .instat_callback = usa49_instat_callback,
1335 .glocont_callback = usa49_glocont_callback,
1336 .indat_callback = usa49_indat_callback,
1337 .outdat_callback = usa2x_outdat_callback,
1338 .inack_callback = usa49_inack_callback,
1339 .outcont_callback = usa49_outcont_callback,
1340 }, {
1341 /* msg_usa90 callbacks */
1342 .instat_callback = usa90_instat_callback,
1343 .glocont_callback = usa28_glocont_callback,
1344 .indat_callback = usa90_indat_callback,
1345 .outdat_callback = usa2x_outdat_callback,
1346 .inack_callback = usa28_inack_callback,
1347 .outcont_callback = usa90_outcont_callback,
1348 }, {
1349 /* msg_usa67 callbacks */
1350 .instat_callback = usa67_instat_callback,
1351 .glocont_callback = usa67_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 };
1358
1359 /* Generic setup urbs function that uses
1360 data in device_details */
1361 static void keyspan_setup_urbs(struct usb_serial *serial)
1362 {
1363 struct keyspan_serial_private *s_priv;
1364 const struct keyspan_device_details *d_details;
1365 struct callbacks *cback;
1366
1367 s_priv = usb_get_serial_data(serial);
1368 d_details = s_priv->device_details;
1369
1370 /* Setup values for the various callback routines */
1371 cback = &keyspan_callbacks[d_details->msg_format];
1372
1373 /* Allocate and set up urbs for each one that is in use,
1374 starting with instat endpoints */
1375 s_priv->instat_urb = keyspan_setup_urb
1376 (serial, d_details->instat_endpoint, USB_DIR_IN,
1377 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1378 cback->instat_callback);
1379
1380 s_priv->indat_urb = keyspan_setup_urb
1381 (serial, d_details->indat_endpoint, USB_DIR_IN,
1382 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1383 usa49wg_indat_callback);
1384
1385 s_priv->glocont_urb = keyspan_setup_urb
1386 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1387 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1388 cback->glocont_callback);
1389 }
1390
1391 /* usa19 function doesn't require prescaler */
1392 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1393 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1394 u8 *rate_low, u8 *prescaler, int portnum)
1395 {
1396 u32 b16, /* baud rate times 16 (actual rate used internally) */
1397 div, /* divisor */
1398 cnt; /* inverse of divisor (programmed into 8051) */
1399
1400 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1401
1402 /* prevent divide by zero... */
1403 b16 = baud_rate * 16L;
1404 if (b16 == 0)
1405 return KEYSPAN_INVALID_BAUD_RATE;
1406 /* Any "standard" rate over 57k6 is marginal on the USA-19
1407 as we run out of divisor resolution. */
1408 if (baud_rate > 57600)
1409 return KEYSPAN_INVALID_BAUD_RATE;
1410
1411 /* calculate the divisor and the counter (its inverse) */
1412 div = baudclk / b16;
1413 if (div == 0)
1414 return KEYSPAN_INVALID_BAUD_RATE;
1415 else
1416 cnt = 0 - div;
1417
1418 if (div > 0xffff)
1419 return KEYSPAN_INVALID_BAUD_RATE;
1420
1421 /* return the counter values if non-null */
1422 if (rate_low)
1423 *rate_low = (u8) (cnt & 0xff);
1424 if (rate_hi)
1425 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1426 if (rate_low && rate_hi)
1427 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1428 __func__, baud_rate, *rate_hi, *rate_low);
1429 return KEYSPAN_BAUD_RATE_OK;
1430 }
1431
1432 /* usa19hs function doesn't require prescaler */
1433 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1434 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1435 u8 *rate_low, u8 *prescaler, int portnum)
1436 {
1437 u32 b16, /* baud rate times 16 (actual rate used internally) */
1438 div; /* divisor */
1439
1440 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1441
1442 /* prevent divide by zero... */
1443 b16 = baud_rate * 16L;
1444 if (b16 == 0)
1445 return KEYSPAN_INVALID_BAUD_RATE;
1446
1447 /* calculate the divisor */
1448 div = baudclk / b16;
1449 if (div == 0)
1450 return KEYSPAN_INVALID_BAUD_RATE;
1451
1452 if (div > 0xffff)
1453 return KEYSPAN_INVALID_BAUD_RATE;
1454
1455 /* return the counter values if non-null */
1456 if (rate_low)
1457 *rate_low = (u8) (div & 0xff);
1458
1459 if (rate_hi)
1460 *rate_hi = (u8) ((div >> 8) & 0xff);
1461
1462 if (rate_low && rate_hi)
1463 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1464 __func__, baud_rate, *rate_hi, *rate_low);
1465
1466 return KEYSPAN_BAUD_RATE_OK;
1467 }
1468
1469 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1470 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1471 u8 *rate_low, u8 *prescaler, int portnum)
1472 {
1473 u32 b16, /* baud rate times 16 (actual rate used internally) */
1474 clk, /* clock with 13/8 prescaler */
1475 div, /* divisor using 13/8 prescaler */
1476 res, /* resulting baud rate using 13/8 prescaler */
1477 diff, /* error using 13/8 prescaler */
1478 smallest_diff;
1479 u8 best_prescaler;
1480 int i;
1481
1482 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1483
1484 /* prevent divide by zero */
1485 b16 = baud_rate * 16L;
1486 if (b16 == 0)
1487 return KEYSPAN_INVALID_BAUD_RATE;
1488
1489 /* Calculate prescaler by trying them all and looking
1490 for best fit */
1491
1492 /* start with largest possible difference */
1493 smallest_diff = 0xffffffff;
1494
1495 /* 0 is an invalid prescaler, used as a flag */
1496 best_prescaler = 0;
1497
1498 for (i = 8; i <= 0xff; ++i) {
1499 clk = (baudclk * 8) / (u32) i;
1500
1501 div = clk / b16;
1502 if (div == 0)
1503 continue;
1504
1505 res = clk / div;
1506 diff = (res > b16) ? (res-b16) : (b16-res);
1507
1508 if (diff < smallest_diff) {
1509 best_prescaler = i;
1510 smallest_diff = diff;
1511 }
1512 }
1513
1514 if (best_prescaler == 0)
1515 return KEYSPAN_INVALID_BAUD_RATE;
1516
1517 clk = (baudclk * 8) / (u32) best_prescaler;
1518 div = clk / b16;
1519
1520 /* return the divisor and prescaler if non-null */
1521 if (rate_low)
1522 *rate_low = (u8) (div & 0xff);
1523 if (rate_hi)
1524 *rate_hi = (u8) ((div >> 8) & 0xff);
1525 if (prescaler) {
1526 *prescaler = best_prescaler;
1527 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1528 }
1529 return KEYSPAN_BAUD_RATE_OK;
1530 }
1531
1532 /* USA-28 supports different maximum baud rates on each port */
1533 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1534 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1535 u8 *rate_low, u8 *prescaler, int portnum)
1536 {
1537 u32 b16, /* baud rate times 16 (actual rate used internally) */
1538 div, /* divisor */
1539 cnt; /* inverse of divisor (programmed into 8051) */
1540
1541 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1542
1543 /* prevent divide by zero */
1544 b16 = baud_rate * 16L;
1545 if (b16 == 0)
1546 return KEYSPAN_INVALID_BAUD_RATE;
1547
1548 /* calculate the divisor and the counter (its inverse) */
1549 div = KEYSPAN_USA28_BAUDCLK / b16;
1550 if (div == 0)
1551 return KEYSPAN_INVALID_BAUD_RATE;
1552 else
1553 cnt = 0 - div;
1554
1555 /* check for out of range, based on portnum,
1556 and return result */
1557 if (portnum == 0) {
1558 if (div > 0xffff)
1559 return KEYSPAN_INVALID_BAUD_RATE;
1560 } else {
1561 if (portnum == 1) {
1562 if (div > 0xff)
1563 return KEYSPAN_INVALID_BAUD_RATE;
1564 } else
1565 return KEYSPAN_INVALID_BAUD_RATE;
1566 }
1567
1568 /* return the counter values if not NULL
1569 (port 1 will ignore retHi) */
1570 if (rate_low)
1571 *rate_low = (u8) (cnt & 0xff);
1572 if (rate_hi)
1573 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1574 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
1575 return KEYSPAN_BAUD_RATE_OK;
1576 }
1577
1578 static int keyspan_usa26_send_setup(struct usb_serial *serial,
1579 struct usb_serial_port *port,
1580 int reset_port)
1581 {
1582 struct keyspan_usa26_portControlMessage msg;
1583 struct keyspan_serial_private *s_priv;
1584 struct keyspan_port_private *p_priv;
1585 const struct keyspan_device_details *d_details;
1586 int outcont_urb;
1587 struct urb *this_urb;
1588 int device_port, err;
1589
1590 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
1591
1592 s_priv = usb_get_serial_data(serial);
1593 p_priv = usb_get_serial_port_data(port);
1594 d_details = s_priv->device_details;
1595 device_port = port->number - port->serial->minor;
1596
1597 outcont_urb = d_details->outcont_endpoints[port->number];
1598 this_urb = p_priv->outcont_urb;
1599
1600 dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
1601
1602 /* Make sure we have an urb then send the message */
1603 if (this_urb == NULL) {
1604 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1605 return -1;
1606 }
1607
1608 /* Save reset port val for resend.
1609 Don't overwrite resend for open/close condition. */
1610 if ((reset_port + 1) > p_priv->resend_cont)
1611 p_priv->resend_cont = reset_port + 1;
1612 if (this_urb->status == -EINPROGRESS) {
1613 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1614 mdelay(5);
1615 return -1;
1616 }
1617
1618 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1619
1620 /* Only set baud rate if it's changed */
1621 if (p_priv->old_baud != p_priv->baud) {
1622 p_priv->old_baud = p_priv->baud;
1623 msg.setClocking = 0xff;
1624 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1625 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1626 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1627 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1628 __func__, p_priv->baud);
1629 msg.baudLo = 0;
1630 msg.baudHi = 125; /* Values for 9600 baud */
1631 msg.prescaler = 10;
1632 }
1633 msg.setPrescaler = 0xff;
1634 }
1635
1636 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1637 switch (p_priv->cflag & CSIZE) {
1638 case CS5:
1639 msg.lcr |= USA_DATABITS_5;
1640 break;
1641 case CS6:
1642 msg.lcr |= USA_DATABITS_6;
1643 break;
1644 case CS7:
1645 msg.lcr |= USA_DATABITS_7;
1646 break;
1647 case CS8:
1648 msg.lcr |= USA_DATABITS_8;
1649 break;
1650 }
1651 if (p_priv->cflag & PARENB) {
1652 /* note USA_PARITY_NONE == 0 */
1653 msg.lcr |= (p_priv->cflag & PARODD) ?
1654 USA_PARITY_ODD : USA_PARITY_EVEN;
1655 }
1656 msg.setLcr = 0xff;
1657
1658 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1659 msg.xonFlowControl = 0;
1660 msg.setFlowControl = 0xff;
1661 msg.forwardingLength = 16;
1662 msg.xonChar = 17;
1663 msg.xoffChar = 19;
1664
1665 /* Opening port */
1666 if (reset_port == 1) {
1667 msg._txOn = 1;
1668 msg._txOff = 0;
1669 msg.txFlush = 0;
1670 msg.txBreak = 0;
1671 msg.rxOn = 1;
1672 msg.rxOff = 0;
1673 msg.rxFlush = 1;
1674 msg.rxForward = 0;
1675 msg.returnStatus = 0;
1676 msg.resetDataToggle = 0xff;
1677 }
1678
1679 /* Closing port */
1680 else if (reset_port == 2) {
1681 msg._txOn = 0;
1682 msg._txOff = 1;
1683 msg.txFlush = 0;
1684 msg.txBreak = 0;
1685 msg.rxOn = 0;
1686 msg.rxOff = 1;
1687 msg.rxFlush = 1;
1688 msg.rxForward = 0;
1689 msg.returnStatus = 0;
1690 msg.resetDataToggle = 0;
1691 }
1692
1693 /* Sending intermediate configs */
1694 else {
1695 msg._txOn = (!p_priv->break_on);
1696 msg._txOff = 0;
1697 msg.txFlush = 0;
1698 msg.txBreak = (p_priv->break_on);
1699 msg.rxOn = 0;
1700 msg.rxOff = 0;
1701 msg.rxFlush = 0;
1702 msg.rxForward = 0;
1703 msg.returnStatus = 0;
1704 msg.resetDataToggle = 0x0;
1705 }
1706
1707 /* Do handshaking outputs */
1708 msg.setTxTriState_setRts = 0xff;
1709 msg.txTriState_rts = p_priv->rts_state;
1710
1711 msg.setHskoa_setDtr = 0xff;
1712 msg.hskoa_dtr = p_priv->dtr_state;
1713
1714 p_priv->resend_cont = 0;
1715 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1716
1717 /* send the data out the device on control endpoint */
1718 this_urb->transfer_buffer_length = sizeof(msg);
1719
1720 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1721 if (err != 0)
1722 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1723 #if 0
1724 else {
1725 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__
1726 outcont_urb, this_urb->transfer_buffer_length,
1727 usb_pipeendpoint(this_urb->pipe));
1728 }
1729 #endif
1730
1731 return 0;
1732 }
1733
1734 static int keyspan_usa28_send_setup(struct usb_serial *serial,
1735 struct usb_serial_port *port,
1736 int reset_port)
1737 {
1738 struct keyspan_usa28_portControlMessage msg;
1739 struct keyspan_serial_private *s_priv;
1740 struct keyspan_port_private *p_priv;
1741 const struct keyspan_device_details *d_details;
1742 struct urb *this_urb;
1743 int device_port, err;
1744
1745 s_priv = usb_get_serial_data(serial);
1746 p_priv = usb_get_serial_port_data(port);
1747 d_details = s_priv->device_details;
1748 device_port = port->number - port->serial->minor;
1749
1750 /* only do something if we have a bulk out endpoint */
1751 this_urb = p_priv->outcont_urb;
1752 if (this_urb == NULL) {
1753 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1754 return -1;
1755 }
1756
1757 /* Save reset port val for resend.
1758 Don't overwrite resend for open/close condition. */
1759 if ((reset_port + 1) > p_priv->resend_cont)
1760 p_priv->resend_cont = reset_port + 1;
1761 if (this_urb->status == -EINPROGRESS) {
1762 dev_dbg(&port->dev, "%s already writing\n", __func__);
1763 mdelay(5);
1764 return -1;
1765 }
1766
1767 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
1768
1769 msg.setBaudRate = 1;
1770 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1771 &msg.baudHi, &msg.baudLo, NULL,
1772 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1773 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
1774 __func__, p_priv->baud);
1775 msg.baudLo = 0xff;
1776 msg.baudHi = 0xb2; /* Values for 9600 baud */
1777 }
1778
1779 /* If parity is enabled, we must calculate it ourselves. */
1780 msg.parity = 0; /* XXX for now */
1781
1782 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1783 msg.xonFlowControl = 0;
1784
1785 /* Do handshaking outputs, DTR is inverted relative to RTS */
1786 msg.rts = p_priv->rts_state;
1787 msg.dtr = p_priv->dtr_state;
1788
1789 msg.forwardingLength = 16;
1790 msg.forwardMs = 10;
1791 msg.breakThreshold = 45;
1792 msg.xonChar = 17;
1793 msg.xoffChar = 19;
1794
1795 /*msg.returnStatus = 1;
1796 msg.resetDataToggle = 0xff;*/
1797 /* Opening port */
1798 if (reset_port == 1) {
1799 msg._txOn = 1;
1800 msg._txOff = 0;
1801 msg.txFlush = 0;
1802 msg.txForceXoff = 0;
1803 msg.txBreak = 0;
1804 msg.rxOn = 1;
1805 msg.rxOff = 0;
1806 msg.rxFlush = 1;
1807 msg.rxForward = 0;
1808 msg.returnStatus = 0;
1809 msg.resetDataToggle = 0xff;
1810 }
1811 /* Closing port */
1812 else if (reset_port == 2) {
1813 msg._txOn = 0;
1814 msg._txOff = 1;
1815 msg.txFlush = 0;
1816 msg.txForceXoff = 0;
1817 msg.txBreak = 0;
1818 msg.rxOn = 0;
1819 msg.rxOff = 1;
1820 msg.rxFlush = 1;
1821 msg.rxForward = 0;
1822 msg.returnStatus = 0;
1823 msg.resetDataToggle = 0;
1824 }
1825 /* Sending intermediate configs */
1826 else {
1827 msg._txOn = (!p_priv->break_on);
1828 msg._txOff = 0;
1829 msg.txFlush = 0;
1830 msg.txForceXoff = 0;
1831 msg.txBreak = (p_priv->break_on);
1832 msg.rxOn = 0;
1833 msg.rxOff = 0;
1834 msg.rxFlush = 0;
1835 msg.rxForward = 0;
1836 msg.returnStatus = 0;
1837 msg.resetDataToggle = 0x0;
1838 }
1839
1840 p_priv->resend_cont = 0;
1841 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1842
1843 /* send the data out the device on control endpoint */
1844 this_urb->transfer_buffer_length = sizeof(msg);
1845
1846 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1847 if (err != 0)
1848 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
1849 #if 0
1850 else {
1851 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) OK %d bytes\n", __func__,
1852 this_urb->transfer_buffer_length);
1853 }
1854 #endif
1855
1856 return 0;
1857 }
1858
1859 static int keyspan_usa49_send_setup(struct usb_serial *serial,
1860 struct usb_serial_port *port,
1861 int reset_port)
1862 {
1863 struct keyspan_usa49_portControlMessage msg;
1864 struct usb_ctrlrequest *dr = NULL;
1865 struct keyspan_serial_private *s_priv;
1866 struct keyspan_port_private *p_priv;
1867 const struct keyspan_device_details *d_details;
1868 struct urb *this_urb;
1869 int err, device_port;
1870
1871 s_priv = usb_get_serial_data(serial);
1872 p_priv = usb_get_serial_port_data(port);
1873 d_details = s_priv->device_details;
1874
1875 this_urb = s_priv->glocont_urb;
1876
1877 /* Work out which port within the device is being setup */
1878 device_port = port->number - port->serial->minor;
1879
1880 /* Make sure we have an urb then send the message */
1881 if (this_urb == NULL) {
1882 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__, port->number);
1883 return -1;
1884 }
1885
1886 dev_dbg(&port->dev, "%s - endpoint %d port %d (%d)\n",
1887 __func__, usb_pipeendpoint(this_urb->pipe),
1888 port->number, device_port);
1889
1890 /* Save reset port val for resend.
1891 Don't overwrite resend for open/close condition. */
1892 if ((reset_port + 1) > p_priv->resend_cont)
1893 p_priv->resend_cont = reset_port + 1;
1894
1895 if (this_urb->status == -EINPROGRESS) {
1896 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1897 mdelay(5);
1898 return -1;
1899 }
1900
1901 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
1902
1903 /*msg.portNumber = port->number;*/
1904 msg.portNumber = device_port;
1905
1906 /* Only set baud rate if it's changed */
1907 if (p_priv->old_baud != p_priv->baud) {
1908 p_priv->old_baud = p_priv->baud;
1909 msg.setClocking = 0xff;
1910 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1911 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1912 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1913 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1914 __func__, p_priv->baud);
1915 msg.baudLo = 0;
1916 msg.baudHi = 125; /* Values for 9600 baud */
1917 msg.prescaler = 10;
1918 }
1919 /* msg.setPrescaler = 0xff; */
1920 }
1921
1922 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1923 switch (p_priv->cflag & CSIZE) {
1924 case CS5:
1925 msg.lcr |= USA_DATABITS_5;
1926 break;
1927 case CS6:
1928 msg.lcr |= USA_DATABITS_6;
1929 break;
1930 case CS7:
1931 msg.lcr |= USA_DATABITS_7;
1932 break;
1933 case CS8:
1934 msg.lcr |= USA_DATABITS_8;
1935 break;
1936 }
1937 if (p_priv->cflag & PARENB) {
1938 /* note USA_PARITY_NONE == 0 */
1939 msg.lcr |= (p_priv->cflag & PARODD) ?
1940 USA_PARITY_ODD : USA_PARITY_EVEN;
1941 }
1942 msg.setLcr = 0xff;
1943
1944 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1945 msg.xonFlowControl = 0;
1946 msg.setFlowControl = 0xff;
1947
1948 msg.forwardingLength = 16;
1949 msg.xonChar = 17;
1950 msg.xoffChar = 19;
1951
1952 /* Opening port */
1953 if (reset_port == 1) {
1954 msg._txOn = 1;
1955 msg._txOff = 0;
1956 msg.txFlush = 0;
1957 msg.txBreak = 0;
1958 msg.rxOn = 1;
1959 msg.rxOff = 0;
1960 msg.rxFlush = 1;
1961 msg.rxForward = 0;
1962 msg.returnStatus = 0;
1963 msg.resetDataToggle = 0xff;
1964 msg.enablePort = 1;
1965 msg.disablePort = 0;
1966 }
1967 /* Closing port */
1968 else if (reset_port == 2) {
1969 msg._txOn = 0;
1970 msg._txOff = 1;
1971 msg.txFlush = 0;
1972 msg.txBreak = 0;
1973 msg.rxOn = 0;
1974 msg.rxOff = 1;
1975 msg.rxFlush = 1;
1976 msg.rxForward = 0;
1977 msg.returnStatus = 0;
1978 msg.resetDataToggle = 0;
1979 msg.enablePort = 0;
1980 msg.disablePort = 1;
1981 }
1982 /* Sending intermediate configs */
1983 else {
1984 msg._txOn = (!p_priv->break_on);
1985 msg._txOff = 0;
1986 msg.txFlush = 0;
1987 msg.txBreak = (p_priv->break_on);
1988 msg.rxOn = 0;
1989 msg.rxOff = 0;
1990 msg.rxFlush = 0;
1991 msg.rxForward = 0;
1992 msg.returnStatus = 0;
1993 msg.resetDataToggle = 0x0;
1994 msg.enablePort = 0;
1995 msg.disablePort = 0;
1996 }
1997
1998 /* Do handshaking outputs */
1999 msg.setRts = 0xff;
2000 msg.rts = p_priv->rts_state;
2001
2002 msg.setDtr = 0xff;
2003 msg.dtr = p_priv->dtr_state;
2004
2005 p_priv->resend_cont = 0;
2006
2007 /* if the device is a 49wg, we send control message on usb
2008 control EP 0 */
2009
2010 if (d_details->product_id == keyspan_usa49wg_product_id) {
2011 dr = (void *)(s_priv->ctrl_buf);
2012 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2013 dr->bRequest = 0xB0; /* 49wg control message */;
2014 dr->wValue = 0;
2015 dr->wIndex = 0;
2016 dr->wLength = cpu_to_le16(sizeof(msg));
2017
2018 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2019
2020 usb_fill_control_urb(this_urb, serial->dev,
2021 usb_sndctrlpipe(serial->dev, 0),
2022 (unsigned char *)dr, s_priv->glocont_buf,
2023 sizeof(msg), usa49_glocont_callback, serial);
2024
2025 } else {
2026 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2027
2028 /* send the data out the device on control endpoint */
2029 this_urb->transfer_buffer_length = sizeof(msg);
2030 }
2031 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2032 if (err != 0)
2033 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2034 #if 0
2035 else {
2036 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__,
2037 outcont_urb, this_urb->transfer_buffer_length,
2038 usb_pipeendpoint(this_urb->pipe));
2039 }
2040 #endif
2041
2042 return 0;
2043 }
2044
2045 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2046 struct usb_serial_port *port,
2047 int reset_port)
2048 {
2049 struct keyspan_usa90_portControlMessage msg;
2050 struct keyspan_serial_private *s_priv;
2051 struct keyspan_port_private *p_priv;
2052 const struct keyspan_device_details *d_details;
2053 struct urb *this_urb;
2054 int err;
2055 u8 prescaler;
2056
2057 s_priv = usb_get_serial_data(serial);
2058 p_priv = usb_get_serial_port_data(port);
2059 d_details = s_priv->device_details;
2060
2061 /* only do something if we have a bulk out endpoint */
2062 this_urb = p_priv->outcont_urb;
2063 if (this_urb == NULL) {
2064 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2065 return -1;
2066 }
2067
2068 /* Save reset port val for resend.
2069 Don't overwrite resend for open/close condition. */
2070 if ((reset_port + 1) > p_priv->resend_cont)
2071 p_priv->resend_cont = reset_port + 1;
2072 if (this_urb->status == -EINPROGRESS) {
2073 dev_dbg(&port->dev, "%s already writing\n", __func__);
2074 mdelay(5);
2075 return -1;
2076 }
2077
2078 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2079
2080 /* Only set baud rate if it's changed */
2081 if (p_priv->old_baud != p_priv->baud) {
2082 p_priv->old_baud = p_priv->baud;
2083 msg.setClocking = 0x01;
2084 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2085 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2086 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2087 __func__, p_priv->baud);
2088 p_priv->baud = 9600;
2089 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2090 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2091 }
2092 msg.setRxMode = 1;
2093 msg.setTxMode = 1;
2094 }
2095
2096 /* modes must always be correctly specified */
2097 if (p_priv->baud > 57600) {
2098 msg.rxMode = RXMODE_DMA;
2099 msg.txMode = TXMODE_DMA;
2100 } else {
2101 msg.rxMode = RXMODE_BYHAND;
2102 msg.txMode = TXMODE_BYHAND;
2103 }
2104
2105 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2106 switch (p_priv->cflag & CSIZE) {
2107 case CS5:
2108 msg.lcr |= USA_DATABITS_5;
2109 break;
2110 case CS6:
2111 msg.lcr |= USA_DATABITS_6;
2112 break;
2113 case CS7:
2114 msg.lcr |= USA_DATABITS_7;
2115 break;
2116 case CS8:
2117 msg.lcr |= USA_DATABITS_8;
2118 break;
2119 }
2120 if (p_priv->cflag & PARENB) {
2121 /* note USA_PARITY_NONE == 0 */
2122 msg.lcr |= (p_priv->cflag & PARODD) ?
2123 USA_PARITY_ODD : USA_PARITY_EVEN;
2124 }
2125 if (p_priv->old_cflag != p_priv->cflag) {
2126 p_priv->old_cflag = p_priv->cflag;
2127 msg.setLcr = 0x01;
2128 }
2129
2130 if (p_priv->flow_control == flow_cts)
2131 msg.txFlowControl = TXFLOW_CTS;
2132 msg.setTxFlowControl = 0x01;
2133 msg.setRxFlowControl = 0x01;
2134
2135 msg.rxForwardingLength = 16;
2136 msg.rxForwardingTimeout = 16;
2137 msg.txAckSetting = 0;
2138 msg.xonChar = 17;
2139 msg.xoffChar = 19;
2140
2141 /* Opening port */
2142 if (reset_port == 1) {
2143 msg.portEnabled = 1;
2144 msg.rxFlush = 1;
2145 msg.txBreak = (p_priv->break_on);
2146 }
2147 /* Closing port */
2148 else if (reset_port == 2)
2149 msg.portEnabled = 0;
2150 /* Sending intermediate configs */
2151 else {
2152 msg.portEnabled = 1;
2153 msg.txBreak = (p_priv->break_on);
2154 }
2155
2156 /* Do handshaking outputs */
2157 msg.setRts = 0x01;
2158 msg.rts = p_priv->rts_state;
2159
2160 msg.setDtr = 0x01;
2161 msg.dtr = p_priv->dtr_state;
2162
2163 p_priv->resend_cont = 0;
2164 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2165
2166 /* send the data out the device on control endpoint */
2167 this_urb->transfer_buffer_length = sizeof(msg);
2168
2169 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2170 if (err != 0)
2171 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2172 return 0;
2173 }
2174
2175 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2176 struct usb_serial_port *port,
2177 int reset_port)
2178 {
2179 struct keyspan_usa67_portControlMessage msg;
2180 struct keyspan_serial_private *s_priv;
2181 struct keyspan_port_private *p_priv;
2182 const struct keyspan_device_details *d_details;
2183 struct urb *this_urb;
2184 int err, device_port;
2185
2186 s_priv = usb_get_serial_data(serial);
2187 p_priv = usb_get_serial_port_data(port);
2188 d_details = s_priv->device_details;
2189
2190 this_urb = s_priv->glocont_urb;
2191
2192 /* Work out which port within the device is being setup */
2193 device_port = port->number - port->serial->minor;
2194
2195 /* Make sure we have an urb then send the message */
2196 if (this_urb == NULL) {
2197 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__,
2198 port->number);
2199 return -1;
2200 }
2201
2202 /* Save reset port val for resend.
2203 Don't overwrite resend for open/close condition. */
2204 if ((reset_port + 1) > p_priv->resend_cont)
2205 p_priv->resend_cont = reset_port + 1;
2206 if (this_urb->status == -EINPROGRESS) {
2207 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2208 mdelay(5);
2209 return -1;
2210 }
2211
2212 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2213
2214 msg.port = device_port;
2215
2216 /* Only set baud rate if it's changed */
2217 if (p_priv->old_baud != p_priv->baud) {
2218 p_priv->old_baud = p_priv->baud;
2219 msg.setClocking = 0xff;
2220 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2221 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2222 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2223 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2224 __func__, p_priv->baud);
2225 msg.baudLo = 0;
2226 msg.baudHi = 125; /* Values for 9600 baud */
2227 msg.prescaler = 10;
2228 }
2229 msg.setPrescaler = 0xff;
2230 }
2231
2232 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2233 switch (p_priv->cflag & CSIZE) {
2234 case CS5:
2235 msg.lcr |= USA_DATABITS_5;
2236 break;
2237 case CS6:
2238 msg.lcr |= USA_DATABITS_6;
2239 break;
2240 case CS7:
2241 msg.lcr |= USA_DATABITS_7;
2242 break;
2243 case CS8:
2244 msg.lcr |= USA_DATABITS_8;
2245 break;
2246 }
2247 if (p_priv->cflag & PARENB) {
2248 /* note USA_PARITY_NONE == 0 */
2249 msg.lcr |= (p_priv->cflag & PARODD) ?
2250 USA_PARITY_ODD : USA_PARITY_EVEN;
2251 }
2252 msg.setLcr = 0xff;
2253
2254 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2255 msg.xonFlowControl = 0;
2256 msg.setFlowControl = 0xff;
2257 msg.forwardingLength = 16;
2258 msg.xonChar = 17;
2259 msg.xoffChar = 19;
2260
2261 if (reset_port == 1) {
2262 /* Opening port */
2263 msg._txOn = 1;
2264 msg._txOff = 0;
2265 msg.txFlush = 0;
2266 msg.txBreak = 0;
2267 msg.rxOn = 1;
2268 msg.rxOff = 0;
2269 msg.rxFlush = 1;
2270 msg.rxForward = 0;
2271 msg.returnStatus = 0;
2272 msg.resetDataToggle = 0xff;
2273 } else if (reset_port == 2) {
2274 /* Closing port */
2275 msg._txOn = 0;
2276 msg._txOff = 1;
2277 msg.txFlush = 0;
2278 msg.txBreak = 0;
2279 msg.rxOn = 0;
2280 msg.rxOff = 1;
2281 msg.rxFlush = 1;
2282 msg.rxForward = 0;
2283 msg.returnStatus = 0;
2284 msg.resetDataToggle = 0;
2285 } else {
2286 /* Sending intermediate configs */
2287 msg._txOn = (!p_priv->break_on);
2288 msg._txOff = 0;
2289 msg.txFlush = 0;
2290 msg.txBreak = (p_priv->break_on);
2291 msg.rxOn = 0;
2292 msg.rxOff = 0;
2293 msg.rxFlush = 0;
2294 msg.rxForward = 0;
2295 msg.returnStatus = 0;
2296 msg.resetDataToggle = 0x0;
2297 }
2298
2299 /* Do handshaking outputs */
2300 msg.setTxTriState_setRts = 0xff;
2301 msg.txTriState_rts = p_priv->rts_state;
2302
2303 msg.setHskoa_setDtr = 0xff;
2304 msg.hskoa_dtr = p_priv->dtr_state;
2305
2306 p_priv->resend_cont = 0;
2307
2308 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2309
2310 /* send the data out the device on control endpoint */
2311 this_urb->transfer_buffer_length = sizeof(msg);
2312
2313 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2314 if (err != 0)
2315 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2316 return 0;
2317 }
2318
2319 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2320 {
2321 struct usb_serial *serial = port->serial;
2322 struct keyspan_serial_private *s_priv;
2323 const struct keyspan_device_details *d_details;
2324
2325 s_priv = usb_get_serial_data(serial);
2326 d_details = s_priv->device_details;
2327
2328 switch (d_details->msg_format) {
2329 case msg_usa26:
2330 keyspan_usa26_send_setup(serial, port, reset_port);
2331 break;
2332 case msg_usa28:
2333 keyspan_usa28_send_setup(serial, port, reset_port);
2334 break;
2335 case msg_usa49:
2336 keyspan_usa49_send_setup(serial, port, reset_port);
2337 break;
2338 case msg_usa90:
2339 keyspan_usa90_send_setup(serial, port, reset_port);
2340 break;
2341 case msg_usa67:
2342 keyspan_usa67_send_setup(serial, port, reset_port);
2343 break;
2344 }
2345 }
2346
2347
2348 /* Gets called by the "real" driver (ie once firmware is loaded
2349 and renumeration has taken place. */
2350 static int keyspan_startup(struct usb_serial *serial)
2351 {
2352 int i, err;
2353 struct keyspan_serial_private *s_priv;
2354 const struct keyspan_device_details *d_details;
2355
2356 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2357 if (d_details->product_id ==
2358 le16_to_cpu(serial->dev->descriptor.idProduct))
2359 break;
2360 if (d_details == NULL) {
2361 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2362 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2363 return 1;
2364 }
2365
2366 /* Setup private data for serial driver */
2367 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2368 if (!s_priv) {
2369 dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
2370 return -ENOMEM;
2371 }
2372
2373 s_priv->device_details = d_details;
2374 usb_set_serial_data(serial, s_priv);
2375
2376 keyspan_setup_urbs(serial);
2377
2378 if (s_priv->instat_urb != NULL) {
2379 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2380 if (err != 0)
2381 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2382 }
2383 if (s_priv->indat_urb != NULL) {
2384 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2385 if (err != 0)
2386 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2387 }
2388
2389 return 0;
2390 }
2391
2392 static void keyspan_disconnect(struct usb_serial *serial)
2393 {
2394 struct keyspan_serial_private *s_priv;
2395
2396 s_priv = usb_get_serial_data(serial);
2397
2398 stop_urb(s_priv->instat_urb);
2399 stop_urb(s_priv->glocont_urb);
2400 stop_urb(s_priv->indat_urb);
2401 }
2402
2403 static void keyspan_release(struct usb_serial *serial)
2404 {
2405 struct keyspan_serial_private *s_priv;
2406
2407 s_priv = usb_get_serial_data(serial);
2408
2409 usb_free_urb(s_priv->instat_urb);
2410 usb_free_urb(s_priv->indat_urb);
2411 usb_free_urb(s_priv->glocont_urb);
2412
2413 kfree(s_priv);
2414 }
2415
2416 static int keyspan_port_probe(struct usb_serial_port *port)
2417 {
2418 struct usb_serial *serial = port->serial;
2419 struct keyspan_serial_private *s_priv;
2420 struct keyspan_port_private *p_priv;
2421 const struct keyspan_device_details *d_details;
2422 struct callbacks *cback;
2423 int endp;
2424 int port_num;
2425 int i;
2426
2427 s_priv = usb_get_serial_data(serial);
2428 d_details = s_priv->device_details;
2429
2430 p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2431 if (!p_priv)
2432 return -ENOMEM;
2433
2434 p_priv->device_details = d_details;
2435
2436 /* Setup values for the various callback routines */
2437 cback = &keyspan_callbacks[d_details->msg_format];
2438
2439 port_num = port->number - port->serial->minor;
2440
2441 /* Do indat endpoints first, once for each flip */
2442 endp = d_details->indat_endpoints[port_num];
2443 for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2444 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2445 USB_DIR_IN, port,
2446 p_priv->in_buffer[i], 64,
2447 cback->indat_callback);
2448 }
2449 /* outdat endpoints also have flip */
2450 endp = d_details->outdat_endpoints[port_num];
2451 for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2452 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2453 USB_DIR_OUT, port,
2454 p_priv->out_buffer[i], 64,
2455 cback->outdat_callback);
2456 }
2457 /* inack endpoint */
2458 p_priv->inack_urb = keyspan_setup_urb(serial,
2459 d_details->inack_endpoints[port_num],
2460 USB_DIR_IN, port,
2461 p_priv->inack_buffer, 1,
2462 cback->inack_callback);
2463 /* outcont endpoint */
2464 p_priv->outcont_urb = keyspan_setup_urb(serial,
2465 d_details->outcont_endpoints[port_num],
2466 USB_DIR_OUT, port,
2467 p_priv->outcont_buffer, 64,
2468 cback->outcont_callback);
2469
2470 usb_set_serial_port_data(port, p_priv);
2471
2472 return 0;
2473 }
2474
2475 static int keyspan_port_remove(struct usb_serial_port *port)
2476 {
2477 struct keyspan_port_private *p_priv;
2478 int i;
2479
2480 p_priv = usb_get_serial_port_data(port);
2481
2482 stop_urb(p_priv->inack_urb);
2483 stop_urb(p_priv->outcont_urb);
2484 for (i = 0; i < 2; i++) {
2485 stop_urb(p_priv->in_urbs[i]);
2486 stop_urb(p_priv->out_urbs[i]);
2487 }
2488
2489 usb_free_urb(p_priv->inack_urb);
2490 usb_free_urb(p_priv->outcont_urb);
2491 for (i = 0; i < 2; i++) {
2492 usb_free_urb(p_priv->in_urbs[i]);
2493 usb_free_urb(p_priv->out_urbs[i]);
2494 }
2495
2496 kfree(p_priv);
2497
2498 return 0;
2499 }
2500
2501 MODULE_AUTHOR(DRIVER_AUTHOR);
2502 MODULE_DESCRIPTION(DRIVER_DESC);
2503 MODULE_LICENSE("GPL");
2504
2505 MODULE_FIRMWARE("keyspan/usa28.fw");
2506 MODULE_FIRMWARE("keyspan/usa28x.fw");
2507 MODULE_FIRMWARE("keyspan/usa28xa.fw");
2508 MODULE_FIRMWARE("keyspan/usa28xb.fw");
2509 MODULE_FIRMWARE("keyspan/usa19.fw");
2510 MODULE_FIRMWARE("keyspan/usa19qi.fw");
2511 MODULE_FIRMWARE("keyspan/mpr.fw");
2512 MODULE_FIRMWARE("keyspan/usa19qw.fw");
2513 MODULE_FIRMWARE("keyspan/usa18x.fw");
2514 MODULE_FIRMWARE("keyspan/usa19w.fw");
2515 MODULE_FIRMWARE("keyspan/usa49w.fw");
2516 MODULE_FIRMWARE("keyspan/usa49wlc.fw");
Ubuntu Artful kernel mirror