Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/usb/serial/oti6858.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us