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