Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
oti6858.c
Go to the documentation of this file.
1 /*
2  * Ours Technology Inc. OTi-6858 USB to serial adapter driver.
3  *
4  * Copyleft (C) 2007 Kees Lemmens (adapted for kernel 2.6.20)
5  * Copyright (C) 2006 Tomasz Michal Lukaszewski (FIXME: add e-mail)
6  * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])
7  * Copyright (C) 2003 IBM Corp.
8  *
9  * Many thanks to the authors of pl2303 driver: all functions in this file
10  * are heavily based on pl2303 code, buffering code is a 1-to-1 copy.
11  *
12  * Warning! You use this driver on your own risk! The only official
13  * description of this device I have is datasheet from manufacturer,
14  * and it doesn't contain almost any information needed to write a driver.
15  * Almost all knowlegde used while writing this driver was gathered by:
16  * - analyzing traffic between device and the M$ Windows 2000 driver,
17  * - trying different bit combinations and checking pin states
18  * with a voltmeter,
19  * - receiving malformed frames and producing buffer overflows
20  * to learn how errors are reported,
21  * So, THIS CODE CAN DESTROY OTi-6858 AND ANY OTHER DEVICES, THAT ARE
22  * CONNECTED TO IT!
23  *
24  * This program is free software; you can redistribute it and/or modify
25  * it under the terms of the GNU General Public License as published by
26  * the Free Software Foundation; either version 2 of the License.
27  *
28  * See Documentation/usb/usb-serial.txt for more information on using this
29  * driver
30  *
31  * TODO:
32  * - implement correct flushing for ioctls and oti6858_close()
33  * - check how errors (rx overflow, parity error, framing error) are reported
34  * - implement oti6858_break_ctl()
35  * - implement more ioctls
36  * - test/implement flow control
37  * - allow setting custom baud rates
38  */
39 
40 #include <linux/kernel.h>
41 #include <linux/errno.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/tty.h>
45 #include <linux/tty_driver.h>
46 #include <linux/tty_flip.h>
47 #include <linux/serial.h>
48 #include <linux/module.h>
49 #include <linux/moduleparam.h>
50 #include <linux/spinlock.h>
51 #include <linux/usb.h>
52 #include <linux/usb/serial.h>
53 #include <linux/uaccess.h>
54 #include <linux/kfifo.h>
55 #include "oti6858.h"
56 
57 #define OTI6858_DESCRIPTION \
58  "Ours Technology Inc. OTi-6858 USB to serial adapter driver"
59 #define OTI6858_AUTHOR "Tomasz Michal Lukaszewski <FIXME@FIXME>"
60 #define OTI6858_VERSION "0.2"
61 
62 static const struct usb_device_id id_table[] = {
63  { USB_DEVICE(OTI6858_VENDOR_ID, OTI6858_PRODUCT_ID) },
64  { }
65 };
66 
67 MODULE_DEVICE_TABLE(usb, id_table);
68 
69 /* requests */
70 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
71 #define OTI6858_REQ_T_GET_STATUS 0x01
72 
73 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
74 #define OTI6858_REQ_T_SET_LINE 0x00
75 
76 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
77 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
78 
79 /* format of the control packet */
80 struct oti6858_control_pkt {
81  __le16 divisor; /* baud rate = 96000000 / (16 * divisor), LE */
82 #define OTI6858_MAX_BAUD_RATE 3000000
83  u8 frame_fmt;
84 #define FMT_STOP_BITS_MASK 0xc0
85 #define FMT_STOP_BITS_1 0x00
86 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
87 #define FMT_PARITY_MASK 0x38
88 #define FMT_PARITY_NONE 0x00
89 #define FMT_PARITY_ODD 0x08
90 #define FMT_PARITY_EVEN 0x18
91 #define FMT_PARITY_MARK 0x28
92 #define FMT_PARITY_SPACE 0x38
93 #define FMT_DATA_BITS_MASK 0x03
94 #define FMT_DATA_BITS_5 0x00
95 #define FMT_DATA_BITS_6 0x01
96 #define FMT_DATA_BITS_7 0x02
97 #define FMT_DATA_BITS_8 0x03
98  u8 something; /* always equals 0x43 */
99  u8 control; /* settings of flow control lines */
100 #define CONTROL_MASK 0x0c
101 #define CONTROL_DTR_HIGH 0x08
102 #define CONTROL_RTS_HIGH 0x04
103  u8 tx_status;
104 #define TX_BUFFER_EMPTIED 0x09
105  u8 pin_state;
106 #define PIN_MASK 0x3f
107 #define PIN_RTS 0x20 /* output pin */
108 #define PIN_CTS 0x10 /* input pin, active low */
109 #define PIN_DSR 0x08 /* input pin, active low */
110 #define PIN_DTR 0x04 /* output pin */
111 #define PIN_RI 0x02 /* input pin, active low */
112 #define PIN_DCD 0x01 /* input pin, active low */
113  u8 rx_bytes_avail; /* number of bytes in rx buffer */;
114 };
115 
116 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
117 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
118  (((a)->divisor == (priv)->pending_setup.divisor) \
119  && ((a)->control == (priv)->pending_setup.control) \
120  && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
121 
122 /* function prototypes */
123 static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port);
124 static void oti6858_close(struct usb_serial_port *port);
125 static void oti6858_set_termios(struct tty_struct *tty,
126  struct usb_serial_port *port, struct ktermios *old);
127 static void oti6858_init_termios(struct tty_struct *tty);
128 static int oti6858_ioctl(struct tty_struct *tty,
129  unsigned int cmd, unsigned long arg);
130 static void oti6858_read_int_callback(struct urb *urb);
131 static void oti6858_read_bulk_callback(struct urb *urb);
132 static void oti6858_write_bulk_callback(struct urb *urb);
133 static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
134  const unsigned char *buf, int count);
135 static int oti6858_write_room(struct tty_struct *tty);
136 static int oti6858_chars_in_buffer(struct tty_struct *tty);
137 static int oti6858_tiocmget(struct tty_struct *tty);
138 static int oti6858_tiocmset(struct tty_struct *tty,
139  unsigned int set, unsigned int clear);
140 static int oti6858_port_probe(struct usb_serial_port *port);
141 static int oti6858_port_remove(struct usb_serial_port *port);
142 
143 /* device info */
144 static struct usb_serial_driver oti6858_device = {
145  .driver = {
146  .owner = THIS_MODULE,
147  .name = "oti6858",
148  },
149  .id_table = id_table,
150  .num_ports = 1,
151  .open = oti6858_open,
152  .close = oti6858_close,
153  .write = oti6858_write,
154  .ioctl = oti6858_ioctl,
155  .set_termios = oti6858_set_termios,
156  .init_termios = oti6858_init_termios,
157  .tiocmget = oti6858_tiocmget,
158  .tiocmset = oti6858_tiocmset,
159  .read_bulk_callback = oti6858_read_bulk_callback,
160  .read_int_callback = oti6858_read_int_callback,
161  .write_bulk_callback = oti6858_write_bulk_callback,
162  .write_room = oti6858_write_room,
163  .chars_in_buffer = oti6858_chars_in_buffer,
164  .port_probe = oti6858_port_probe,
165  .port_remove = oti6858_port_remove,
166 };
167 
168 static struct usb_serial_driver * const serial_drivers[] = {
169  &oti6858_device, NULL
170 };
171 
172 struct oti6858_private {
173  spinlock_t lock;
174 
175  struct oti6858_control_pkt status;
176 
177  struct {
178  u8 read_urb_in_use;
179  u8 write_urb_in_use;
180  } flags;
181  struct delayed_work delayed_write_work;
182 
183  struct {
184  __le16 divisor;
185  u8 frame_fmt;
186  u8 control;
187  } pending_setup;
188  u8 transient;
189  u8 setup_done;
190  struct delayed_work delayed_setup_work;
191 
192  wait_queue_head_t intr_wait;
193  struct usb_serial_port *port; /* USB port with which associated */
194 };
195 
196 static void setup_line(struct work_struct *work)
197 {
198  struct oti6858_private *priv = container_of(work,
199  struct oti6858_private, delayed_setup_work.work);
200  struct usb_serial_port *port = priv->port;
201  struct oti6858_control_pkt *new_setup;
202  unsigned long flags;
203  int result;
204 
205  new_setup = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
206  if (new_setup == NULL) {
207  dev_err(&port->dev, "%s(): out of memory!\n", __func__);
208  /* we will try again */
209  schedule_delayed_work(&priv->delayed_setup_work,
210  msecs_to_jiffies(2));
211  return;
212  }
213 
214  result = usb_control_msg(port->serial->dev,
215  usb_rcvctrlpipe(port->serial->dev, 0),
216  OTI6858_REQ_T_GET_STATUS,
217  OTI6858_REQ_GET_STATUS,
218  0, 0,
219  new_setup, OTI6858_CTRL_PKT_SIZE,
220  100);
221 
222  if (result != OTI6858_CTRL_PKT_SIZE) {
223  dev_err(&port->dev, "%s(): error reading status\n", __func__);
224  kfree(new_setup);
225  /* we will try again */
226  schedule_delayed_work(&priv->delayed_setup_work,
227  msecs_to_jiffies(2));
228  return;
229  }
230 
231  spin_lock_irqsave(&priv->lock, flags);
232  if (!OTI6858_CTRL_EQUALS_PENDING(new_setup, priv)) {
233  new_setup->divisor = priv->pending_setup.divisor;
234  new_setup->control = priv->pending_setup.control;
235  new_setup->frame_fmt = priv->pending_setup.frame_fmt;
236 
237  spin_unlock_irqrestore(&priv->lock, flags);
238  result = usb_control_msg(port->serial->dev,
239  usb_sndctrlpipe(port->serial->dev, 0),
240  OTI6858_REQ_T_SET_LINE,
241  OTI6858_REQ_SET_LINE,
242  0, 0,
243  new_setup, OTI6858_CTRL_PKT_SIZE,
244  100);
245  } else {
246  spin_unlock_irqrestore(&priv->lock, flags);
247  result = 0;
248  }
249  kfree(new_setup);
250 
251  spin_lock_irqsave(&priv->lock, flags);
252  if (result != OTI6858_CTRL_PKT_SIZE)
253  priv->transient = 0;
254  priv->setup_done = 1;
255  spin_unlock_irqrestore(&priv->lock, flags);
256 
257  dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
258  result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
259  if (result != 0) {
260  dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
261  __func__, result);
262  }
263 }
264 
265 static void send_data(struct work_struct *work)
266 {
267  struct oti6858_private *priv = container_of(work,
268  struct oti6858_private, delayed_write_work.work);
269  struct usb_serial_port *port = priv->port;
270  int count = 0, result;
271  unsigned long flags;
272  u8 *allow;
273 
274  spin_lock_irqsave(&priv->lock, flags);
275  if (priv->flags.write_urb_in_use) {
276  spin_unlock_irqrestore(&priv->lock, flags);
277  schedule_delayed_work(&priv->delayed_write_work,
278  msecs_to_jiffies(2));
279  return;
280  }
281  priv->flags.write_urb_in_use = 1;
282  spin_unlock_irqrestore(&priv->lock, flags);
283 
284  spin_lock_irqsave(&port->lock, flags);
285  count = kfifo_len(&port->write_fifo);
286  spin_unlock_irqrestore(&port->lock, flags);
287 
288  if (count > port->bulk_out_size)
289  count = port->bulk_out_size;
290 
291  if (count != 0) {
292  allow = kmalloc(1, GFP_KERNEL);
293  if (!allow) {
294  dev_err_console(port, "%s(): kmalloc failed\n",
295  __func__);
296  return;
297  }
298  result = usb_control_msg(port->serial->dev,
299  usb_rcvctrlpipe(port->serial->dev, 0),
300  OTI6858_REQ_T_CHECK_TXBUFF,
301  OTI6858_REQ_CHECK_TXBUFF,
302  count, 0, allow, 1, 100);
303  if (result != 1 || *allow != 0)
304  count = 0;
305  kfree(allow);
306  }
307 
308  if (count == 0) {
309  priv->flags.write_urb_in_use = 0;
310 
311  dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
312  result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
313  if (result != 0) {
314  dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
315  __func__, result);
316  }
317  return;
318  }
319 
320  count = kfifo_out_locked(&port->write_fifo,
321  port->write_urb->transfer_buffer,
322  count, &port->lock);
323  port->write_urb->transfer_buffer_length = count;
324  result = usb_submit_urb(port->write_urb, GFP_NOIO);
325  if (result != 0) {
326  dev_err_console(port, "%s(): usb_submit_urb() failed with error %d\n",
327  __func__, result);
328  priv->flags.write_urb_in_use = 0;
329  }
330 
331  usb_serial_port_softint(port);
332 }
333 
334 static int oti6858_port_probe(struct usb_serial_port *port)
335 {
336  struct oti6858_private *priv;
337 
338  priv = kzalloc(sizeof(*priv), GFP_KERNEL);
339  if (!priv)
340  return -ENOMEM;
341 
342  spin_lock_init(&priv->lock);
343  init_waitqueue_head(&priv->intr_wait);
344  priv->port = port;
345  INIT_DELAYED_WORK(&priv->delayed_setup_work, setup_line);
346  INIT_DELAYED_WORK(&priv->delayed_write_work, send_data);
347 
348  usb_set_serial_port_data(port, priv);
349 
350  return 0;
351 }
352 
353 static int oti6858_port_remove(struct usb_serial_port *port)
354 {
355  struct oti6858_private *priv;
356 
357  priv = usb_get_serial_port_data(port);
358  kfree(priv);
359 
360  return 0;
361 }
362 
363 static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
364  const unsigned char *buf, int count)
365 {
366  if (!count)
367  return count;
368 
369  count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
370 
371  return count;
372 }
373 
374 static int oti6858_write_room(struct tty_struct *tty)
375 {
376  struct usb_serial_port *port = tty->driver_data;
377  int room = 0;
378  unsigned long flags;
379 
380  spin_lock_irqsave(&port->lock, flags);
381  room = kfifo_avail(&port->write_fifo);
382  spin_unlock_irqrestore(&port->lock, flags);
383 
384  return room;
385 }
386 
387 static int oti6858_chars_in_buffer(struct tty_struct *tty)
388 {
389  struct usb_serial_port *port = tty->driver_data;
390  int chars = 0;
391  unsigned long flags;
392 
393  spin_lock_irqsave(&port->lock, flags);
394  chars = kfifo_len(&port->write_fifo);
395  spin_unlock_irqrestore(&port->lock, flags);
396 
397  return chars;
398 }
399 
400 static void oti6858_init_termios(struct tty_struct *tty)
401 {
402  tty->termios = tty_std_termios;
403  tty->termios.c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
404  tty->termios.c_ispeed = 38400;
405  tty->termios.c_ospeed = 38400;
406 }
407 
408 static void oti6858_set_termios(struct tty_struct *tty,
409  struct usb_serial_port *port, struct ktermios *old_termios)
410 {
411  struct oti6858_private *priv = usb_get_serial_port_data(port);
412  unsigned long flags;
413  unsigned int cflag;
414  u8 frame_fmt, control;
415  __le16 divisor;
416  int br;
417 
418  if (!tty)
419  return;
420 
421  cflag = tty->termios.c_cflag;
422 
423  spin_lock_irqsave(&priv->lock, flags);
424  divisor = priv->pending_setup.divisor;
425  frame_fmt = priv->pending_setup.frame_fmt;
426  control = priv->pending_setup.control;
427  spin_unlock_irqrestore(&priv->lock, flags);
428 
429  frame_fmt &= ~FMT_DATA_BITS_MASK;
430  switch (cflag & CSIZE) {
431  case CS5:
432  frame_fmt |= FMT_DATA_BITS_5;
433  break;
434  case CS6:
435  frame_fmt |= FMT_DATA_BITS_6;
436  break;
437  case CS7:
438  frame_fmt |= FMT_DATA_BITS_7;
439  break;
440  default:
441  case CS8:
442  frame_fmt |= FMT_DATA_BITS_8;
443  break;
444  }
445 
446  /* manufacturer claims that this device can work with baud rates
447  * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
448  * guarantee that any other baud rate will work (especially
449  * the higher ones)
450  */
451  br = tty_get_baud_rate(tty);
452  if (br == 0) {
453  divisor = 0;
454  } else {
455  int real_br;
456  int new_divisor;
457  br = min(br, OTI6858_MAX_BAUD_RATE);
458 
459  new_divisor = (96000000 + 8 * br) / (16 * br);
460  real_br = 96000000 / (16 * new_divisor);
461  divisor = cpu_to_le16(new_divisor);
462  tty_encode_baud_rate(tty, real_br, real_br);
463  }
464 
465  frame_fmt &= ~FMT_STOP_BITS_MASK;
466  if ((cflag & CSTOPB) != 0)
467  frame_fmt |= FMT_STOP_BITS_2;
468  else
469  frame_fmt |= FMT_STOP_BITS_1;
470 
471  frame_fmt &= ~FMT_PARITY_MASK;
472  if ((cflag & PARENB) != 0) {
473  if ((cflag & PARODD) != 0)
474  frame_fmt |= FMT_PARITY_ODD;
475  else
476  frame_fmt |= FMT_PARITY_EVEN;
477  } else {
478  frame_fmt |= FMT_PARITY_NONE;
479  }
480 
481  control &= ~CONTROL_MASK;
482  if ((cflag & CRTSCTS) != 0)
483  control |= (CONTROL_DTR_HIGH | CONTROL_RTS_HIGH);
484 
485  /* change control lines if we are switching to or from B0 */
486  /* FIXME:
487  spin_lock_irqsave(&priv->lock, flags);
488  control = priv->line_control;
489  if ((cflag & CBAUD) == B0)
490  priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
491  else
492  priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
493  if (control != priv->line_control) {
494  control = priv->line_control;
495  spin_unlock_irqrestore(&priv->lock, flags);
496  set_control_lines(serial->dev, control);
497  } else {
498  spin_unlock_irqrestore(&priv->lock, flags);
499  }
500  */
501 
502  spin_lock_irqsave(&priv->lock, flags);
503  if (divisor != priv->pending_setup.divisor
504  || control != priv->pending_setup.control
505  || frame_fmt != priv->pending_setup.frame_fmt) {
506  priv->pending_setup.divisor = divisor;
507  priv->pending_setup.control = control;
508  priv->pending_setup.frame_fmt = frame_fmt;
509  }
510  spin_unlock_irqrestore(&priv->lock, flags);
511 }
512 
513 static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
514 {
515  struct oti6858_private *priv = usb_get_serial_port_data(port);
516  struct ktermios tmp_termios;
517  struct usb_serial *serial = port->serial;
518  struct oti6858_control_pkt *buf;
519  unsigned long flags;
520  int result;
521 
522  usb_clear_halt(serial->dev, port->write_urb->pipe);
523  usb_clear_halt(serial->dev, port->read_urb->pipe);
524 
525  buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
526  if (buf == NULL) {
527  dev_err(&port->dev, "%s(): out of memory!\n", __func__);
528  return -ENOMEM;
529  }
530 
531  result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
532  OTI6858_REQ_T_GET_STATUS,
533  OTI6858_REQ_GET_STATUS,
534  0, 0,
535  buf, OTI6858_CTRL_PKT_SIZE,
536  100);
537  if (result != OTI6858_CTRL_PKT_SIZE) {
538  /* assume default (after power-on reset) values */
539  buf->divisor = cpu_to_le16(0x009c); /* 38400 bps */
540  buf->frame_fmt = 0x03; /* 8N1 */
541  buf->something = 0x43;
542  buf->control = 0x4c; /* DTR, RTS */
543  buf->tx_status = 0x00;
544  buf->pin_state = 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
545  buf->rx_bytes_avail = 0x00;
546  }
547 
548  spin_lock_irqsave(&priv->lock, flags);
549  memcpy(&priv->status, buf, OTI6858_CTRL_PKT_SIZE);
550  priv->pending_setup.divisor = buf->divisor;
551  priv->pending_setup.frame_fmt = buf->frame_fmt;
552  priv->pending_setup.control = buf->control;
553  spin_unlock_irqrestore(&priv->lock, flags);
554  kfree(buf);
555 
556  dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
557  result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
558  if (result != 0) {
559  dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
560  __func__, result);
561  oti6858_close(port);
562  return result;
563  }
564 
565  /* setup termios */
566  if (tty)
567  oti6858_set_termios(tty, port, &tmp_termios);
568  port->port.drain_delay = 256; /* FIXME: check the FIFO length */
569  return 0;
570 }
571 
572 static void oti6858_close(struct usb_serial_port *port)
573 {
574  struct oti6858_private *priv = usb_get_serial_port_data(port);
575  unsigned long flags;
576 
577  spin_lock_irqsave(&port->lock, flags);
578  /* clear out any remaining data in the buffer */
579  kfifo_reset_out(&port->write_fifo);
580  spin_unlock_irqrestore(&port->lock, flags);
581 
582  dev_dbg(&port->dev, "%s(): after buf_clear()\n", __func__);
583 
584  /* cancel scheduled setup */
585  cancel_delayed_work_sync(&priv->delayed_setup_work);
586  cancel_delayed_work_sync(&priv->delayed_write_work);
587 
588  /* shutdown our urbs */
589  dev_dbg(&port->dev, "%s(): shutting down urbs\n", __func__);
590  usb_kill_urb(port->write_urb);
591  usb_kill_urb(port->read_urb);
592  usb_kill_urb(port->interrupt_in_urb);
593 }
594 
595 static int oti6858_tiocmset(struct tty_struct *tty,
596  unsigned int set, unsigned int clear)
597 {
598  struct usb_serial_port *port = tty->driver_data;
599  struct oti6858_private *priv = usb_get_serial_port_data(port);
600  unsigned long flags;
601  u8 control;
602 
603  dev_dbg(&port->dev, "%s(set = 0x%08x, clear = 0x%08x)\n",
604  __func__, set, clear);
605 
606  /* FIXME: check if this is correct (active high/low) */
607  spin_lock_irqsave(&priv->lock, flags);
608  control = priv->pending_setup.control;
609  if ((set & TIOCM_RTS) != 0)
610  control |= CONTROL_RTS_HIGH;
611  if ((set & TIOCM_DTR) != 0)
612  control |= CONTROL_DTR_HIGH;
613  if ((clear & TIOCM_RTS) != 0)
614  control &= ~CONTROL_RTS_HIGH;
615  if ((clear & TIOCM_DTR) != 0)
616  control &= ~CONTROL_DTR_HIGH;
617 
618  if (control != priv->pending_setup.control)
619  priv->pending_setup.control = control;
620 
621  spin_unlock_irqrestore(&priv->lock, flags);
622  return 0;
623 }
624 
625 static int oti6858_tiocmget(struct tty_struct *tty)
626 {
627  struct usb_serial_port *port = tty->driver_data;
628  struct oti6858_private *priv = usb_get_serial_port_data(port);
629  unsigned long flags;
630  unsigned pin_state;
631  unsigned result = 0;
632 
633  spin_lock_irqsave(&priv->lock, flags);
634  pin_state = priv->status.pin_state & PIN_MASK;
635  spin_unlock_irqrestore(&priv->lock, flags);
636 
637  /* FIXME: check if this is correct (active high/low) */
638  if ((pin_state & PIN_RTS) != 0)
639  result |= TIOCM_RTS;
640  if ((pin_state & PIN_CTS) != 0)
641  result |= TIOCM_CTS;
642  if ((pin_state & PIN_DSR) != 0)
643  result |= TIOCM_DSR;
644  if ((pin_state & PIN_DTR) != 0)
645  result |= TIOCM_DTR;
646  if ((pin_state & PIN_RI) != 0)
647  result |= TIOCM_RI;
648  if ((pin_state & PIN_DCD) != 0)
649  result |= TIOCM_CD;
650 
651  dev_dbg(&port->dev, "%s() = 0x%08x\n", __func__, result);
652 
653  return result;
654 }
655 
656 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
657 {
658  struct oti6858_private *priv = usb_get_serial_port_data(port);
659  unsigned long flags;
660  unsigned int prev, status;
661  unsigned int changed;
662 
663  spin_lock_irqsave(&priv->lock, flags);
664  prev = priv->status.pin_state;
665  spin_unlock_irqrestore(&priv->lock, flags);
666 
667  while (1) {
668  wait_event_interruptible(priv->intr_wait,
669  priv->status.pin_state != prev);
670  if (signal_pending(current))
671  return -ERESTARTSYS;
672 
673  spin_lock_irqsave(&priv->lock, flags);
674  status = priv->status.pin_state & PIN_MASK;
675  spin_unlock_irqrestore(&priv->lock, flags);
676 
677  changed = prev ^ status;
678  /* FIXME: check if this is correct (active high/low) */
679  if (((arg & TIOCM_RNG) && (changed & PIN_RI)) ||
680  ((arg & TIOCM_DSR) && (changed & PIN_DSR)) ||
681  ((arg & TIOCM_CD) && (changed & PIN_DCD)) ||
682  ((arg & TIOCM_CTS) && (changed & PIN_CTS)))
683  return 0;
684  prev = status;
685  }
686 
687  /* NOTREACHED */
688  return 0;
689 }
690 
691 static int oti6858_ioctl(struct tty_struct *tty,
692  unsigned int cmd, unsigned long arg)
693 {
694  struct usb_serial_port *port = tty->driver_data;
695 
696  dev_dbg(&port->dev, "%s(cmd = 0x%04x, arg = 0x%08lx)\n", __func__, cmd, arg);
697 
698  switch (cmd) {
699  case TIOCMIWAIT:
700  dev_dbg(&port->dev, "%s(): TIOCMIWAIT\n", __func__);
701  return wait_modem_info(port, arg);
702  default:
703  dev_dbg(&port->dev, "%s(): 0x%04x not supported\n", __func__, cmd);
704  break;
705  }
706  return -ENOIOCTLCMD;
707 }
708 
709 static void oti6858_read_int_callback(struct urb *urb)
710 {
711  struct usb_serial_port *port = urb->context;
712  struct oti6858_private *priv = usb_get_serial_port_data(port);
713  int transient = 0, can_recv = 0, resubmit = 1;
714  int status = urb->status;
715 
716  switch (status) {
717  case 0:
718  /* success */
719  break;
720  case -ECONNRESET:
721  case -ENOENT:
722  case -ESHUTDOWN:
723  /* this urb is terminated, clean up */
724  dev_dbg(&urb->dev->dev, "%s(): urb shutting down with status: %d\n",
725  __func__, status);
726  return;
727  default:
728  dev_dbg(&urb->dev->dev, "%s(): nonzero urb status received: %d\n",
729  __func__, status);
730  break;
731  }
732 
733  if (status == 0 && urb->actual_length == OTI6858_CTRL_PKT_SIZE) {
734  struct oti6858_control_pkt *xs = urb->transfer_buffer;
735  unsigned long flags;
736 
737  spin_lock_irqsave(&priv->lock, flags);
738 
739  if (!priv->transient) {
740  if (!OTI6858_CTRL_EQUALS_PENDING(xs, priv)) {
741  if (xs->rx_bytes_avail == 0) {
742  priv->transient = 4;
743  priv->setup_done = 0;
744  resubmit = 0;
745  dev_dbg(&port->dev, "%s(): scheduling setup_line()\n", __func__);
746  schedule_delayed_work(&priv->delayed_setup_work, 0);
747  }
748  }
749  } else {
750  if (OTI6858_CTRL_EQUALS_PENDING(xs, priv)) {
751  priv->transient = 0;
752  } else if (!priv->setup_done) {
753  resubmit = 0;
754  } else if (--priv->transient == 0) {
755  if (xs->rx_bytes_avail == 0) {
756  priv->transient = 4;
757  priv->setup_done = 0;
758  resubmit = 0;
759  dev_dbg(&port->dev, "%s(): scheduling setup_line()\n", __func__);
760  schedule_delayed_work(&priv->delayed_setup_work, 0);
761  }
762  }
763  }
764 
765  if (!priv->transient) {
766  if (xs->pin_state != priv->status.pin_state)
767  wake_up_interruptible(&priv->intr_wait);
768  memcpy(&priv->status, xs, OTI6858_CTRL_PKT_SIZE);
769  }
770 
771  if (!priv->transient && xs->rx_bytes_avail != 0) {
772  can_recv = xs->rx_bytes_avail;
773  priv->flags.read_urb_in_use = 1;
774  }
775 
776  transient = priv->transient;
777  spin_unlock_irqrestore(&priv->lock, flags);
778  }
779 
780  if (can_recv) {
781  int result;
782 
783  result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
784  if (result != 0) {
785  priv->flags.read_urb_in_use = 0;
786  dev_err(&port->dev, "%s(): usb_submit_urb() failed,"
787  " error %d\n", __func__, result);
788  } else {
789  resubmit = 0;
790  }
791  } else if (!transient) {
792  unsigned long flags;
793  int count;
794 
795  spin_lock_irqsave(&port->lock, flags);
796  count = kfifo_len(&port->write_fifo);
797  spin_unlock_irqrestore(&port->lock, flags);
798 
799  spin_lock_irqsave(&priv->lock, flags);
800  if (priv->flags.write_urb_in_use == 0 && count != 0) {
801  schedule_delayed_work(&priv->delayed_write_work, 0);
802  resubmit = 0;
803  }
804  spin_unlock_irqrestore(&priv->lock, flags);
805  }
806 
807  if (resubmit) {
808  int result;
809 
810 /* dev_dbg(&urb->dev->dev, "%s(): submitting interrupt urb\n", __func__); */
811  result = usb_submit_urb(urb, GFP_ATOMIC);
812  if (result != 0) {
813  dev_err(&urb->dev->dev,
814  "%s(): usb_submit_urb() failed with"
815  " error %d\n", __func__, result);
816  }
817  }
818 }
819 
820 static void oti6858_read_bulk_callback(struct urb *urb)
821 {
822  struct usb_serial_port *port = urb->context;
823  struct oti6858_private *priv = usb_get_serial_port_data(port);
824  struct tty_struct *tty;
825  unsigned char *data = urb->transfer_buffer;
826  unsigned long flags;
827  int status = urb->status;
828  int result;
829 
830  spin_lock_irqsave(&priv->lock, flags);
831  priv->flags.read_urb_in_use = 0;
832  spin_unlock_irqrestore(&priv->lock, flags);
833 
834  if (status != 0) {
835  dev_dbg(&urb->dev->dev, "%s(): unable to handle the error, exiting\n", __func__);
836  return;
837  }
838 
839  tty = tty_port_tty_get(&port->port);
840  if (tty != NULL && urb->actual_length > 0) {
841  tty_insert_flip_string(tty, data, urb->actual_length);
842  tty_flip_buffer_push(tty);
843  }
844  tty_kref_put(tty);
845 
846  /* schedule the interrupt urb */
847  result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
848  if (result != 0 && result != -EPERM) {
849  dev_err(&port->dev, "%s(): usb_submit_urb() failed,"
850  " error %d\n", __func__, result);
851  }
852 }
853 
854 static void oti6858_write_bulk_callback(struct urb *urb)
855 {
856  struct usb_serial_port *port = urb->context;
857  struct oti6858_private *priv = usb_get_serial_port_data(port);
858  int status = urb->status;
859  int result;
860 
861  switch (status) {
862  case 0:
863  /* success */
864  break;
865  case -ECONNRESET:
866  case -ENOENT:
867  case -ESHUTDOWN:
868  /* this urb is terminated, clean up */
869  dev_dbg(&urb->dev->dev, "%s(): urb shutting down with status: %d\n", __func__, status);
870  priv->flags.write_urb_in_use = 0;
871  return;
872  default:
873  /* error in the urb, so we have to resubmit it */
874  dev_dbg(&urb->dev->dev, "%s(): nonzero write bulk status received: %d\n", __func__, status);
875  dev_dbg(&urb->dev->dev, "%s(): overflow in write\n", __func__);
876 
877  port->write_urb->transfer_buffer_length = 1;
878  result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
879  if (result) {
880  dev_err_console(port, "%s(): usb_submit_urb() failed,"
881  " error %d\n", __func__, result);
882  } else {
883  return;
884  }
885  }
886 
887  priv->flags.write_urb_in_use = 0;
888 
889  /* schedule the interrupt urb if we are still open */
890  dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
891  result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
892  if (result != 0) {
893  dev_err(&port->dev, "%s(): failed submitting int urb,"
894  " error %d\n", __func__, result);
895  }
896 }
897 
898 module_usb_serial_driver(serial_drivers, id_table);
899 
900 MODULE_DESCRIPTION(OTI6858_DESCRIPTION);
901 MODULE_AUTHOR(OTI6858_AUTHOR);
902 MODULE_VERSION(OTI6858_VERSION);
903 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 14:38:25 for Linux Kernel by   doxygen 1.8.2