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