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