Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/staging/serqt_usb2/serqt_usb2.c

  1 /*
  2  * This code was developed for the Quatech USB line for linux, it used
  3  * much of the code developed by Greg Kroah-Hartman for USB serial devices
  4  *
  5  */
  6 
  7 #include <linux/errno.h>
  8 #include <linux/slab.h>
  9 #include <linux/tty.h>
 10 #include <linux/tty_driver.h>
 11 #include <linux/tty_flip.h>
 12 #include <linux/module.h>
 13 #include <linux/serial.h>
 14 #include <linux/usb.h>
 15 #include <linux/usb/serial.h>
 16 #include <linux/uaccess.h>
 17 
 18 /* Version Information */
 19 #define DRIVER_VERSION "v2.14"
 20 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
 21 #define DRIVER_DESC "Quatech USB to Serial Driver"
 22 
 23 #define USB_VENDOR_ID_QUATECH                   0x061d  /* Quatech VID */
 24 #define QUATECH_SSU200  0xC030  /* SSU200 */
 25 #define QUATECH_DSU100  0xC040  /* DSU100 */
 26 #define QUATECH_DSU200  0xC050  /* DSU200 */
 27 #define QUATECH_QSU100  0xC060  /* QSU100 */
 28 #define QUATECH_QSU200  0xC070  /* QSU200 */
 29 #define QUATECH_ESU100A 0xC080  /* ESU100A */
 30 #define QUATECH_ESU100B 0xC081  /* ESU100B */
 31 #define QUATECH_ESU200A 0xC0A0  /* ESU200A */
 32 #define QUATECH_ESU200B 0xC0A1  /* ESU200B */
 33 #define QUATECH_HSU100A 0xC090  /* HSU100A */
 34 #define QUATECH_HSU100B 0xC091  /* HSU100B */
 35 #define QUATECH_HSU100C 0xC092  /* HSU100C */
 36 #define QUATECH_HSU100D 0xC093  /* HSU100D */
 37 #define QUATECH_HSU200A 0xC0B0  /* HSU200A */
 38 #define QUATECH_HSU200B 0xC0B1  /* HSU200B */
 39 #define QUATECH_HSU200C 0xC0B2  /* HSU200C */
 40 #define QUATECH_HSU200D 0xC0B3  /* HSU200D */
 41 
 42 #define QT_SET_GET_DEVICE           0xc2
 43 #define QT_OPEN_CLOSE_CHANNEL       0xca
 44 #define QT_GET_SET_PREBUF_TRIG_LVL  0xcc
 45 #define QT_SET_ATF                  0xcd
 46 #define QT_GET_SET_REGISTER         0xc0
 47 #define QT_GET_SET_UART             0xc1
 48 #define QT_HW_FLOW_CONTROL_MASK     0xc5
 49 #define QT_SW_FLOW_CONTROL_MASK     0xc6
 50 #define QT_SW_FLOW_CONTROL_DISABLE  0xc7
 51 #define QT_BREAK_CONTROL            0xc8
 52 
 53 #define USBD_TRANSFER_DIRECTION_IN    0xc0
 54 #define USBD_TRANSFER_DIRECTION_OUT   0x40
 55 
 56 #define  MAX_BAUD_RATE              460800
 57 #define  MAX_BAUD_REMAINDER         4608
 58 
 59 #define  DIV_LATCH_LS               0x00
 60 #define  XMT_HOLD_REGISTER          0x00
 61 #define  XVR_BUFFER_REGISTER        0x00
 62 #define  DIV_LATCH_MS               0x01
 63 #define  FIFO_CONTROL_REGISTER      0x02
 64 #define  LINE_CONTROL_REGISTER      0x03
 65 #define  MODEM_CONTROL_REGISTER     0x04
 66 #define  LINE_STATUS_REGISTER       0x05
 67 #define  MODEM_STATUS_REGISTER      0x06
 68 
 69 #define  SERIAL_MCR_DTR             0x01
 70 #define  SERIAL_MCR_RTS             0x02
 71 #define  SERIAL_MCR_LOOP            0x10
 72 
 73 #define  SERIAL_MSR_CTS             0x10
 74 #define  SERIAL_MSR_CD              0x80
 75 #define  SERIAL_MSR_RI              0x40
 76 #define  SERIAL_MSR_DSR             0x20
 77 #define  SERIAL_MSR_MASK            0xf0
 78 
 79 #define  SERIAL_8_DATA              0x03
 80 #define  SERIAL_7_DATA              0x02
 81 #define  SERIAL_6_DATA              0x01
 82 #define  SERIAL_5_DATA              0x00
 83 
 84 #define  SERIAL_ODD_PARITY          0X08
 85 #define  SERIAL_EVEN_PARITY         0X18
 86 #define  SERIAL_TWO_STOPB           0x04
 87 #define  SERIAL_ONE_STOPB           0x00
 88 
 89 #define DEFAULT_DIVISOR  0x30   /* gives 9600 baud rate */
 90 #define DEFAULT_LCR SERIAL_8_DATA       /* 8, none , 1 */
 91 
 92 #define FULLPWRBIT          0x00000080
 93 #define NEXT_BOARD_POWER_BIT        0x00000004
 94 
 95 #define SERIAL_LSR_OE       0x02
 96 #define SERIAL_LSR_PE       0x04
 97 #define SERIAL_LSR_FE       0x08
 98 #define SERIAL_LSR_BI       0x10
 99 
100 #define  SERIAL_MSR_CTS             0x10
101 #define  SERIAL_MSR_CD              0x80
102 #define  SERIAL_MSR_RI              0x40
103 #define  SERIAL_MSR_DSR             0x20
104 #define  SERIAL_MSR_MASK            0xf0
105 
106 #define PREFUFF_LEVEL_CONSERVATIVE  128
107 #define ATC_DISABLED                0x0
108 
109 #define RR_BITS             0x03        /* for clearing clock bits */
110 #define DUPMODE_BITS        0xc0
111 #define CLKS_X4             0x02
112 
113 #define LOOPMODE_BITS       0x41        /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
114 #define ALL_LOOPBACK        0x01
115 #define MODEM_CTRL          0x40
116 #define RS232_MODE          0x00
117 
118 static const struct usb_device_id id_table[] = {
119         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)},
120         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)},
121         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)},
122         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100)},
123         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU200)},
124         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100A)},
125         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100B)},
126         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200A)},
127         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200B)},
128         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100A)},
129         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100B)},
130         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100C)},
131         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100D)},
132         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200A)},
133         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)},
134         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)},
135         {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)},
136         {}                      /* Terminating entry */
137 };
138 MODULE_DEVICE_TABLE(usb, id_table);
139 
140 struct qt_get_device_data {
141         __u8 porta;
142         __u8 portb;
143         __u8 portc;
144 };
145 
146 struct qt_open_channel_data {
147         __u8 line_status;
148         __u8 modem_status;
149 };
150 
151 struct quatech_port {
152         int port_num;           /* number of the port */
153         struct urb *write_urb;  /* write URB for this port */
154         struct urb *read_urb;   /* read URB for this port */
155         struct urb *int_urb;
156 
157         __u8 shadow_lcr;                /* last LCR value received */
158         __u8 shadow_mcr;                /* last MCR value received */
159         __u8 shadow_msr;                /* last MSR value received */
160         __u8 shadow_lsr;                /* last LSR value received */
161         char open_ports;
162 
163         /* Used for TIOCMIWAIT */
164         wait_queue_head_t msr_wait;
165         char prev_status, diff_status;
166 
167         wait_queue_head_t wait;
168 
169         struct async_icount icount;
170 
171         struct usb_serial_port *port;   /* owner of this object */
172         struct qt_get_device_data device_data;
173         struct mutex lock;
174         bool read_urb_busy;
175         int rx_holding;
176         int read_bulk_stopped;
177         char close_pending;
178 };
179 
180 static int port_paranoia_check(struct usb_serial_port *port,
181                                const char *function)
182 {
183         if (!port) {
184                 pr_debug("%s - port == NULL", function);
185                 return -1;
186         }
187         if (!port->serial) {
188                 pr_debug("%s - port->serial == NULL\n", function);
189                 return -1;
190         }
191 
192         return 0;
193 }
194 
195 static int serial_paranoia_check(struct usb_serial *serial,
196                                  const char *function)
197 {
198         if (!serial) {
199                 pr_debug("%s - serial == NULL\n", function);
200                 return -1;
201         }
202 
203         if (!serial->type) {
204                 pr_debug("%s - serial->type == NULL!", function);
205                 return -1;
206         }
207 
208         return 0;
209 }
210 
211 static inline struct quatech_port *qt_get_port_private(struct usb_serial_port
212                                                        *port)
213 {
214         return (struct quatech_port *)usb_get_serial_port_data(port);
215 }
216 
217 static inline void qt_set_port_private(struct usb_serial_port *port,
218                                        struct quatech_port *data)
219 {
220         usb_set_serial_port_data(port, (void *)data);
221 }
222 
223 static struct usb_serial *get_usb_serial(struct usb_serial_port *port,
224                                          const char *function)
225 {
226         /* if no port was specified, or it fails a paranoia check */
227         if (!port ||
228             port_paranoia_check(port, function) ||
229             serial_paranoia_check(port->serial, function)) {
230                 /*
231                  * then say that we dont have a valid usb_serial thing,
232                  * which will end up genrating -ENODEV return values
233                  */
234                 return NULL;
235         }
236 
237         return port->serial;
238 }
239 
240 static void process_line_status(struct quatech_port *qt_port,
241                               unsigned char line_status)
242 {
243 
244         qt_port->shadow_lsr =
245             line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
246                            SERIAL_LSR_BI);
247 }
248 
249 static void process_modem_status(struct quatech_port *qt_port,
250                                unsigned char modem_status)
251 {
252 
253         qt_port->shadow_msr = modem_status;
254         wake_up_interruptible(&qt_port->wait);
255 }
256 
257 static void process_rx_char(struct usb_serial_port *port, unsigned char data)
258 {
259         struct urb *urb = port->read_urb;
260         if (urb->actual_length)
261                 tty_insert_flip_char(&port->port, data, TTY_NORMAL);
262 }
263 
264 static void qt_write_bulk_callback(struct urb *urb)
265 {
266         int status;
267         struct quatech_port *quatech_port;
268 
269         status = urb->status;
270 
271         if (status) {
272                 dev_dbg(&urb->dev->dev,
273                         "nonzero write bulk status received:%d\n", status);
274                 return;
275         }
276 
277         quatech_port = urb->context;
278 
279         tty_port_tty_wakeup(&quatech_port->port->port);
280 }
281 
282 static void qt_interrupt_callback(struct urb *urb)
283 {
284         /* FIXME */
285 }
286 
287 static void qt_status_change_check(struct urb *urb,
288                                    struct quatech_port *qt_port,
289                                    struct usb_serial_port *port)
290 {
291         int flag, i;
292         unsigned char *data = urb->transfer_buffer;
293         unsigned int rx_count = urb->actual_length;
294 
295         for (i = 0; i < rx_count; ++i) {
296                 /* Look ahead code here */
297                 if ((i <= (rx_count - 3)) && (data[i] == 0x1b)
298                     && (data[i + 1] == 0x1b)) {
299                         flag = 0;
300                         switch (data[i + 2]) {
301                         case 0x00:
302                                 if (i > (rx_count - 4)) {
303                                         dev_dbg(&port->dev,
304                                                 "Illegal escape seuences in received data\n");
305                                         break;
306                                 }
307 
308                                 process_line_status(qt_port, data[i + 3]);
309 
310                                 i += 3;
311                                 flag = 1;
312                                 break;
313 
314                         case 0x01:
315                                 if (i > (rx_count - 4)) {
316                                         dev_dbg(&port->dev,
317                                                 "Illegal escape seuences in received data\n");
318                                         break;
319                                 }
320 
321                                 process_modem_status(qt_port, data[i + 3]);
322 
323                                 i += 3;
324                                 flag = 1;
325                                 break;
326 
327                         case 0xff:
328                                 dev_dbg(&port->dev, "No status sequence.\n");
329 
330                                 process_rx_char(port, data[i]);
331                                 process_rx_char(port, data[i + 1]);
332 
333                                 i += 2;
334                                 break;
335                         }
336                         if (flag == 1)
337                                 continue;
338                 }
339 
340                 if (urb->actual_length)
341                         tty_insert_flip_char(&port->port, data[i], TTY_NORMAL);
342 
343         }
344         tty_flip_buffer_push(&port->port);
345 }
346 
347 static void qt_read_bulk_callback(struct urb *urb)
348 {
349 
350         struct usb_serial_port *port = urb->context;
351         struct usb_serial *serial = get_usb_serial(port, __func__);
352         struct quatech_port *qt_port = qt_get_port_private(port);
353         int result;
354 
355         if (urb->status) {
356                 qt_port->read_bulk_stopped = 1;
357                 dev_dbg(&urb->dev->dev,
358                         "%s - nonzero write bulk status received: %d\n",
359                         __func__, urb->status);
360                 return;
361         }
362 
363         dev_dbg(&port->dev,
364                 "%s - port->rx_holding = %d\n", __func__, qt_port->rx_holding);
365 
366         if (port_paranoia_check(port, __func__) != 0) {
367                 qt_port->read_bulk_stopped = 1;
368                 return;
369         }
370 
371         if (!serial)
372                 return;
373 
374         if (qt_port->close_pending == 1) {
375                 /* Were closing , stop reading */
376                 dev_dbg(&port->dev,
377                         "%s - (qt_port->close_pending == 1\n", __func__);
378                 qt_port->read_bulk_stopped = 1;
379                 return;
380         }
381 
382         /*
383          * rx_holding is asserted by throttle, if we assert it, we're not
384          * receiving any more characters and let the box handle the flow
385          * control
386          */
387         if (qt_port->rx_holding == 1) {
388                 qt_port->read_bulk_stopped = 1;
389                 return;
390         }
391 
392         if (urb->status) {
393                 qt_port->read_bulk_stopped = 1;
394 
395                 dev_dbg(&port->dev,
396                         "%s - nonzero read bulk status received: %d\n",
397                         __func__, urb->status);
398                 return;
399         }
400 
401         if (urb->actual_length)
402                 qt_status_change_check(urb, qt_port, port);
403 
404         /* Continue trying to always read  */
405         usb_fill_bulk_urb(port->read_urb, serial->dev,
406                           usb_rcvbulkpipe(serial->dev,
407                                           port->bulk_in_endpointAddress),
408                           port->read_urb->transfer_buffer,
409                           port->read_urb->transfer_buffer_length,
410                           qt_read_bulk_callback, port);
411         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
412         if (result)
413                 dev_dbg(&port->dev,
414                         "%s - failed resubmitting read urb, error %d",
415                         __func__, result);
416         else {
417                 if (urb->actual_length) {
418                         tty_flip_buffer_push(&port->port);
419                         tty_schedule_flip(&port->port);
420                 }
421         }
422 
423         schedule_work(&port->work);
424 }
425 
426 /*
427  * qt_get_device
428  *   Issue a GET_DEVICE vendor-specific request on the default control pipe If
429  *   successful, fills in the qt_get_device_data structure pointed to by
430  *   device_data, otherwise return a negative error number of the problem.
431  */
432 
433 static int qt_get_device(struct usb_serial *serial,
434                          struct qt_get_device_data *device_data)
435 {
436         int result;
437         unsigned char *transfer_buffer;
438 
439         transfer_buffer =
440             kmalloc(sizeof(struct qt_get_device_data), GFP_KERNEL);
441         if (!transfer_buffer)
442                 return -ENOMEM;
443 
444         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
445                                  QT_SET_GET_DEVICE, 0xc0, 0, 0,
446                                  transfer_buffer,
447                                  sizeof(struct qt_get_device_data), 300);
448         if (result > 0)
449                 memcpy(device_data, transfer_buffer,
450                        sizeof(struct qt_get_device_data));
451         kfree(transfer_buffer);
452 
453         return result;
454 }
455 
456 /****************************************************************************
457  *  box_set_prebuffer_level
458    TELLS BOX WHEN TO ASSERT FLOW CONTROL
459  ****************************************************************************/
460 static int box_set_prebuffer_level(struct usb_serial *serial)
461 {
462         int result;
463         __u16 buffer_length;
464 
465         buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
466         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
467                                  QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
468                                  buffer_length, 0, NULL, 0, 300);
469         return result;
470 }
471 
472 /****************************************************************************
473  *  box_set_atc
474    TELLS BOX WHEN TO ASSERT automatic transmitter control
475    ****************************************************************************/
476 static int box_set_atc(struct usb_serial *serial, __u16 n_mode)
477 {
478         int result;
479         __u16 buffer_length;
480 
481         buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
482 
483         result =
484             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
485                             QT_SET_ATF, 0x40, n_mode, 0, NULL, 0, 300);
486 
487         return result;
488 }
489 
490 /**
491  * qt_set_device
492  *   Issue a SET_DEVICE vendor-specific request on the default control pipe If
493  *   successful returns the number of bytes written, otherwise it returns a
494  *   negative error number of the problem.
495  */
496 static int qt_set_device(struct usb_serial *serial,
497                          struct qt_get_device_data *device_data)
498 {
499         int result;
500         __u16 length;
501         __u16 port_settings;
502 
503         port_settings = ((__u16) (device_data->portb));
504         port_settings = (port_settings << 8);
505         port_settings += ((__u16) (device_data->porta));
506 
507         length = sizeof(struct qt_get_device_data);
508 
509         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
510                                  QT_SET_GET_DEVICE, 0x40, port_settings,
511                                  0, NULL, 0, 300);
512         return result;
513 }
514 
515 static int qt_open_channel(struct usb_serial *serial, __u16 uart_num,
516                            struct qt_open_channel_data *pdevice_data)
517 {
518         int result;
519 
520         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
521                                  QT_OPEN_CLOSE_CHANNEL,
522                                  USBD_TRANSFER_DIRECTION_IN, 1, uart_num,
523                                  pdevice_data,
524                                  sizeof(struct qt_open_channel_data), 300);
525 
526         return result;
527 
528 }
529 
530 static int qt_close_channel(struct usb_serial *serial, __u16 uart_num)
531 {
532         int result;
533 
534         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
535                                  QT_OPEN_CLOSE_CHANNEL,
536                                  USBD_TRANSFER_DIRECTION_OUT, 0, uart_num,
537                                  NULL, 0, 300);
538 
539         return result;
540 
541 }
542 
543 /****************************************************************************
544 * box_get_register
545 *       issuse a GET_REGISTER vendor-spcific request on the default control pipe
546 *       If successful, fills in the  p_value with the register value asked for
547 ****************************************************************************/
548 static int box_get_register(struct usb_serial *serial, unsigned short uart_num,
549                           unsigned short register_num, __u8 *p_value)
550 {
551         int result;
552         __u16 current_length;
553 
554         current_length = sizeof(struct qt_get_device_data);
555 
556         result =
557             usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
558                             QT_GET_SET_REGISTER, 0xC0, register_num,
559                             uart_num, (void *)p_value, sizeof(*p_value), 300);
560 
561         return result;
562 }
563 
564 /****************************************************************************
565 * box_set_register
566 *       issuse a GET_REGISTER vendor-spcific request on the default control pipe
567 *       If successful, fills in the  p_value with the register value asked for
568 ****************************************************************************/
569 static int box_set_register(struct usb_serial *serial, unsigned short uart_num,
570                           unsigned short register_num, unsigned short value)
571 {
572         int result;
573         unsigned short reg_and_byte;
574 
575         reg_and_byte = value;
576         reg_and_byte = reg_and_byte << 8;
577         reg_and_byte = reg_and_byte + register_num;
578 
579 /*
580         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
581                                  QT_GET_SET_REGISTER, 0xC0, register_num,
582                                  uart_num, NULL, 0, 300);
583 */
584 
585         result =
586             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
587                             QT_GET_SET_REGISTER, 0x40, reg_and_byte, uart_num,
588                             NULL, 0, 300);
589 
590         return result;
591 }
592 
593 /*
594  * qt_setuart
595  * issues a SET_UART vendor-specific request on the default control pipe
596  * If successful sets baud rate divisor and LCR value
597  */
598 static int qt_setuart(struct usb_serial *serial, unsigned short uart_num,
599                       unsigned short default_divisor, unsigned char default_lcr)
600 {
601         int result;
602         unsigned short uart_num_and_lcr;
603 
604         uart_num_and_lcr = (default_lcr << 8) + uart_num;
605 
606         result =
607             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
608                             QT_GET_SET_UART, 0x40, default_divisor,
609                             uart_num_and_lcr, NULL, 0, 300);
610 
611         return result;
612 }
613 
614 static int box_set_hw_flow_ctrl(struct usb_serial *serial, unsigned int index,
615                              int b_set)
616 {
617         __u8 mcr = 0;
618         __u8 msr = 0, mout_value = 0;
619         unsigned int status;
620 
621         if (b_set == 1) {
622                 /* flow control, box will clear RTS line to prevent remote */
623                 mcr = SERIAL_MCR_RTS;
624         } /* device from xmitting more chars */
625         else {
626                 /* no flow control to remote device */
627                 mcr = 0;
628 
629         }
630         mout_value = mcr << 8;
631 
632         if (b_set == 1) {
633                 /* flow control, box will inhibit xmit data if CTS line is
634                  * asserted */
635                 msr = SERIAL_MSR_CTS;
636         } else {
637                 /* Box will not inhimbe xmit data due to CTS line */
638                 msr = 0;
639         }
640         mout_value |= msr;
641 
642         status =
643             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
644                             QT_HW_FLOW_CONTROL_MASK, 0x40, mout_value,
645                             index, NULL, 0, 300);
646         return status;
647 
648 }
649 
650 static int box_set_sw_flow_ctrl(struct usb_serial *serial, __u16 index,
651                              unsigned char stop_char, unsigned char start_char)
652 {
653         __u16 n_sw_flow_out;
654         int result;
655 
656         n_sw_flow_out = start_char << 8;
657         n_sw_flow_out = (unsigned short)stop_char;
658 
659         result =
660             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
661                             QT_SW_FLOW_CONTROL_MASK, 0x40, n_sw_flow_out,
662                             index, NULL, 0, 300);
663         return result;
664 
665 }
666 
667 static int box_disable_sw_flow_ctrl(struct usb_serial *serial, __u16 index)
668 {
669         int result;
670 
671         result =
672             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
673                             QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
674                             NULL, 0, 300);
675         return result;
676 
677 }
678 
679 static int qt_startup(struct usb_serial *serial)
680 {
681         struct device *dev = &serial->dev->dev;
682         struct usb_serial_port *port;
683         struct quatech_port *qt_port;
684         struct qt_get_device_data device_data;
685         int i;
686         int status;
687 
688         /* Now setup per port private data */
689         for (i = 0; i < serial->num_ports; i++) {
690                 port = serial->port[i];
691                 qt_port = kzalloc(sizeof(*qt_port), GFP_KERNEL);
692                 if (!qt_port) {
693                         for (--i; i >= 0; i--) {
694                                 port = serial->port[i];
695                                 kfree(usb_get_serial_port_data(port));
696                                 usb_set_serial_port_data(port, NULL);
697                         }
698                         return -ENOMEM;
699                 }
700                 mutex_init(&qt_port->lock);
701 
702                 usb_set_serial_port_data(port, qt_port);
703 
704         }
705 
706         status = qt_get_device(serial, &device_data);
707         if (status < 0)
708                 goto startup_error;
709 
710         dev_dbg(dev, "device_data.portb = 0x%x\n", device_data.portb);
711 
712         device_data.portb &= ~FULLPWRBIT;
713         dev_dbg(dev, "Changing device_data.portb to 0x%x\n", device_data.portb);
714 
715         status = qt_set_device(serial, &device_data);
716         if (status < 0) {
717                 dev_dbg(dev, "qt_set_device failed\n");
718                 goto startup_error;
719         }
720 
721         status = qt_get_device(serial, &device_data);
722         if (status < 0) {
723                 dev_dbg(dev, "qt_get_device failed\n");
724                 goto startup_error;
725         }
726 
727         switch (serial->dev->descriptor.idProduct) {
728         case QUATECH_DSU100:
729         case QUATECH_QSU100:
730         case QUATECH_ESU100A:
731         case QUATECH_ESU100B:
732         case QUATECH_HSU100A:
733         case QUATECH_HSU100B:
734         case QUATECH_HSU100C:
735         case QUATECH_HSU100D:
736                 device_data.porta &= ~(RR_BITS | DUPMODE_BITS);
737                 device_data.porta |= CLKS_X4;
738                 device_data.portb &= ~(LOOPMODE_BITS);
739                 device_data.portb |= RS232_MODE;
740                 break;
741 
742         case QUATECH_SSU200:
743         case QUATECH_DSU200:
744         case QUATECH_QSU200:
745         case QUATECH_ESU200A:
746         case QUATECH_ESU200B:
747         case QUATECH_HSU200A:
748         case QUATECH_HSU200B:
749         case QUATECH_HSU200C:
750         case QUATECH_HSU200D:
751                 device_data.porta &= ~(RR_BITS | DUPMODE_BITS);
752                 device_data.porta |= CLKS_X4;
753                 device_data.portb &= ~(LOOPMODE_BITS);
754                 device_data.portb |= ALL_LOOPBACK;
755                 break;
756         default:
757                 device_data.porta &= ~(RR_BITS | DUPMODE_BITS);
758                 device_data.porta |= CLKS_X4;
759                 device_data.portb &= ~(LOOPMODE_BITS);
760                 device_data.portb |= RS232_MODE;
761                 break;
762 
763         }
764 
765         status = box_set_prebuffer_level(serial);       /* sets to default value */
766         if (status < 0) {
767                 dev_dbg(dev, "box_set_prebuffer_level failed\n");
768                 goto startup_error;
769         }
770 
771         status = box_set_atc(serial, ATC_DISABLED);
772         if (status < 0) {
773                 dev_dbg(dev, "box_set_atc failed\n");
774                 goto startup_error;
775         }
776 
777         dev_dbg(dev, "device_data.portb = 0x%x\n", device_data.portb);
778 
779         device_data.portb |= NEXT_BOARD_POWER_BIT;
780         dev_dbg(dev, "Changing device_data.portb to 0x%x\n", device_data.portb);
781 
782         status = qt_set_device(serial, &device_data);
783         if (status < 0) {
784                 dev_dbg(dev, "qt_set_device failed\n");
785                 goto startup_error;
786         }
787 
788         return 0;
789 
790 startup_error:
791         for (i = 0; i < serial->num_ports; i++) {
792                 port = serial->port[i];
793                 qt_port = qt_get_port_private(port);
794                 kfree(qt_port);
795                 usb_set_serial_port_data(port, NULL);
796         }
797 
798         return -EIO;
799 }
800 
801 static void qt_release(struct usb_serial *serial)
802 {
803         struct usb_serial_port *port;
804         struct quatech_port *qt_port;
805         int i;
806 
807         for (i = 0; i < serial->num_ports; i++) {
808                 port = serial->port[i];
809                 if (!port)
810                         continue;
811 
812                 qt_port = usb_get_serial_port_data(port);
813                 kfree(qt_port);
814                 usb_set_serial_port_data(port, NULL);
815         }
816 
817 }
818 
819 static void qt_submit_urb_from_open(struct usb_serial *serial,
820                                     struct usb_serial_port *port)
821 {
822         int result;
823         struct usb_serial_port *port0 = serial->port[0];
824 
825         /* set up interrupt urb */
826         usb_fill_int_urb(port0->interrupt_in_urb,
827                          serial->dev,
828                          usb_rcvintpipe(serial->dev,
829                                         port0->interrupt_in_endpointAddress),
830                          port0->interrupt_in_buffer,
831                          port0->interrupt_in_urb->transfer_buffer_length,
832                          qt_interrupt_callback, serial,
833                          port0->interrupt_in_urb->interval);
834 
835         result = usb_submit_urb(port0->interrupt_in_urb,
836                                 GFP_KERNEL);
837         if (result) {
838                 dev_err(&port->dev,
839                         "%s - Error %d submitting interrupt urb\n",
840                         __func__, result);
841         }
842 }
843 
844 static int qt_open(struct tty_struct *tty,
845                    struct usb_serial_port *port)
846 {
847         struct usb_serial *serial;
848         struct quatech_port *quatech_port;
849         struct quatech_port *port0;
850         struct qt_open_channel_data channel_data;
851 
852         int result;
853 
854         if (port_paranoia_check(port, __func__))
855                 return -ENODEV;
856 
857         serial = port->serial;
858 
859         if (serial_paranoia_check(serial, __func__))
860                 return -ENODEV;
861 
862         quatech_port = qt_get_port_private(port);
863         port0 = qt_get_port_private(serial->port[0]);
864 
865         if (quatech_port == NULL || port0 == NULL)
866                 return -ENODEV;
867 
868         usb_clear_halt(serial->dev, port->write_urb->pipe);
869         usb_clear_halt(serial->dev, port->read_urb->pipe);
870         port0->open_ports++;
871 
872         result = qt_get_device(serial, &port0->device_data);
873 
874         /* Port specific setups */
875         result = qt_open_channel(serial, port->port_number, &channel_data);
876         if (result < 0) {
877                 dev_dbg(&port->dev, "qt_open_channel failed\n");
878                 return result;
879         }
880         dev_dbg(&port->dev, "qt_open_channel completed.\n");
881 
882 /* FIXME: are these needed?  Does it even do anything useful? */
883         quatech_port->shadow_lsr = channel_data.line_status &
884             (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
885 
886         quatech_port->shadow_msr = channel_data.modem_status &
887             (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
888 
889         /* Set Baud rate to default and turn off (default)flow control here */
890         result = qt_setuart(serial, port->port_number, DEFAULT_DIVISOR, DEFAULT_LCR);
891         if (result < 0) {
892                 dev_dbg(&port->dev, "qt_setuart failed\n");
893                 return result;
894         }
895         dev_dbg(&port->dev, "qt_setuart completed.\n");
896 
897         /*
898          * Put this here to make it responsive to stty and defaults set by
899          * the tty layer
900          */
901 
902         /*  Check to see if we've set up our endpoint info yet */
903         if (port0->open_ports == 1) {
904                 if (serial->port[0]->interrupt_in_buffer == NULL)
905                         qt_submit_urb_from_open(serial, port);
906         }
907 
908         dev_dbg(&port->dev, "minor number is %d\n", port->minor);
909         dev_dbg(&port->dev,
910                 "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
911         dev_dbg(&port->dev,
912                 "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
913         dev_dbg(&port->dev, "Interrupt endpoint is %d\n",
914                 port->interrupt_in_endpointAddress);
915         dev_dbg(&port->dev, "port's number in the device is %d\n",
916                 quatech_port->port_num);
917         quatech_port->read_urb = port->read_urb;
918 
919         /* set up our bulk in urb */
920 
921         usb_fill_bulk_urb(quatech_port->read_urb,
922                           serial->dev,
923                           usb_rcvbulkpipe(serial->dev,
924                                           port->bulk_in_endpointAddress),
925                           port->bulk_in_buffer,
926                           quatech_port->read_urb->transfer_buffer_length,
927                           qt_read_bulk_callback, quatech_port);
928 
929         dev_dbg(&port->dev, "qt_open: bulkin endpoint is %d\n",
930                 port->bulk_in_endpointAddress);
931         quatech_port->read_urb_busy = true;
932         result = usb_submit_urb(quatech_port->read_urb, GFP_KERNEL);
933         if (result) {
934                 dev_err(&port->dev,
935                         "%s - Error %d submitting control urb\n",
936                         __func__, result);
937                 quatech_port->read_urb_busy = false;
938         }
939 
940         /* initialize our wait queues */
941         init_waitqueue_head(&quatech_port->wait);
942         init_waitqueue_head(&quatech_port->msr_wait);
943 
944         /* initialize our icount structure */
945         memset(&(quatech_port->icount), 0x00, sizeof(quatech_port->icount));
946 
947         return 0;
948 
949 }
950 
951 static int qt_chars_in_buffer(struct tty_struct *tty)
952 {
953         struct usb_serial_port *port = tty->driver_data;
954         struct usb_serial *serial;
955         int chars = 0;
956 
957         serial = get_usb_serial(port, __func__);
958 
959         if (serial->num_bulk_out) {
960                 if (port->write_urb->status == -EINPROGRESS)
961                         chars = port->write_urb->transfer_buffer_length;
962         }
963 
964         return chars;
965 }
966 
967 static void qt_block_until_empty(struct tty_struct *tty,
968                                  struct quatech_port *qt_port)
969 {
970         int timeout = HZ / 10;
971         int wait = 30;
972 
973         /* returns if we get a signal, an error, or the buffer is empty */
974         while (wait_event_interruptible_timeout(qt_port->wait,
975                                         qt_chars_in_buffer(tty) <= 0,
976                                         timeout) == 0) {
977                 wait--;
978                 if (wait == 0) {
979                         dev_dbg(&qt_port->port->dev, "%s - TIMEOUT", __func__);
980                         return;
981                 } else {
982                         wait = 30;
983                 }
984         }
985 }
986 
987 static void qt_close(struct usb_serial_port *port)
988 {
989         struct usb_serial *serial = port->serial;
990         struct quatech_port *qt_port;
991         struct quatech_port *port0;
992         struct tty_struct *tty;
993         int status;
994         unsigned int index;
995         status = 0;
996 
997         tty = tty_port_tty_get(&port->port);
998         index = port->port_number;
999 
1000         qt_port = qt_get_port_private(port);
1001         port0 = qt_get_port_private(serial->port[0]);
1002 
1003         /* shutdown any bulk reads that might be going on */
1004         if (serial->num_bulk_out)
1005                 usb_unlink_urb(port->write_urb);
1006         if (serial->num_bulk_in)
1007                 usb_unlink_urb(port->read_urb);
1008 
1009         /* wait up to for transmitter to empty */
1010         if (serial->dev)
1011                 qt_block_until_empty(tty, qt_port);
1012         tty_kref_put(tty);
1013 
1014         /* Close uart channel */
1015         status = qt_close_channel(serial, index);
1016         if (status < 0)
1017                 dev_dbg(&port->dev, "%s - qt_close_channel failed.\n", __func__);
1018 
1019         port0->open_ports--;
1020 
1021         dev_dbg(&port->dev, "qt_num_open_ports in close%d\n", port0->open_ports);
1022 
1023         if (port0->open_ports == 0) {
1024                 if (serial->port[0]->interrupt_in_urb) {
1025                         dev_dbg(&port->dev, "Shutdown interrupt_in_urb\n");
1026                         usb_kill_urb(serial->port[0]->interrupt_in_urb);
1027                 }
1028 
1029         }
1030 
1031         if (qt_port->write_urb) {
1032                 /* if this urb had a transfer buffer already (old tx) free it */
1033                 kfree(qt_port->write_urb->transfer_buffer);
1034                 usb_free_urb(qt_port->write_urb);
1035         }
1036 
1037 }
1038 
1039 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1040                     const unsigned char *buf, int count)
1041 {
1042         int result;
1043         struct usb_serial *serial = get_usb_serial(port, __func__);
1044 
1045         if (serial == NULL)
1046                 return -ENODEV;
1047 
1048         if (count == 0) {
1049                 dev_dbg(&port->dev,
1050                         "%s - write request of 0 bytes\n", __func__);
1051                 return 0;
1052         }
1053 
1054         /* only do something if we have a bulk out endpoint */
1055         if (serial->num_bulk_out) {
1056                 if (port->write_urb->status == -EINPROGRESS) {
1057                         dev_dbg(&port->dev, "%s - already writing\n", __func__);
1058                         return 0;
1059                 }
1060 
1061                 count =
1062                     (count > port->bulk_out_size) ? port->bulk_out_size : count;
1063                 memcpy(port->write_urb->transfer_buffer, buf, count);
1064 
1065                 /* set up our urb */
1066 
1067                 usb_fill_bulk_urb(port->write_urb, serial->dev,
1068                                   usb_sndbulkpipe(serial->dev,
1069                                                   port->
1070                                                   bulk_out_endpointAddress),
1071                                   port->write_urb->transfer_buffer, count,
1072                                   qt_write_bulk_callback, port);
1073 
1074                 /* send the data out the bulk port */
1075                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1076                 if (result)
1077                         dev_dbg(&port->dev,
1078                                 "%s - failed submitting write urb, error %d\n",
1079                                 __func__, result);
1080                 else
1081                         result = count;
1082 
1083                 return result;
1084         }
1085 
1086         /* no bulk out, so return 0 bytes written */
1087         return 0;
1088 }
1089 
1090 static int qt_write_room(struct tty_struct *tty)
1091 {
1092         struct usb_serial_port *port = tty->driver_data;
1093         struct usb_serial *serial;
1094         struct quatech_port *qt_port;
1095 
1096         int retval = -EINVAL;
1097 
1098         if (port_paranoia_check(port, __func__))
1099                 return -1;
1100 
1101         serial = get_usb_serial(port, __func__);
1102 
1103         if (!serial)
1104                 return -ENODEV;
1105 
1106         qt_port = qt_get_port_private(port);
1107 
1108         mutex_lock(&qt_port->lock);
1109 
1110         if (serial->num_bulk_out) {
1111                 if (port->write_urb->status != -EINPROGRESS)
1112                         retval = port->bulk_out_size;
1113         }
1114 
1115         mutex_unlock(&qt_port->lock);
1116         return retval;
1117 
1118 }
1119 
1120 static int qt_ioctl(struct tty_struct *tty,
1121                     unsigned int cmd, unsigned long arg)
1122 {
1123         struct usb_serial_port *port = tty->driver_data;
1124         struct quatech_port *qt_port = qt_get_port_private(port);
1125         unsigned int index;
1126 
1127         dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
1128 
1129         index = port->port_number;
1130 
1131         if (cmd == TIOCMIWAIT) {
1132                 while (qt_port != NULL) {
1133 #if 0
1134                         /* this never wakes up */
1135                         interruptible_sleep_on(&qt_port->msr_wait);
1136 #endif
1137                         if (signal_pending(current))
1138                                 return -ERESTARTSYS;
1139                         else {
1140                                 char diff = qt_port->diff_status;
1141 
1142                                 if (diff == 0)
1143                                         return -EIO;    /* no change => error */
1144 
1145                                 /* Consume all events */
1146                                 qt_port->diff_status = 0;
1147 
1148                                 if (((arg & TIOCM_RNG)
1149                                      && (diff & SERIAL_MSR_RI))
1150                                     || ((arg & TIOCM_DSR)
1151                                         && (diff & SERIAL_MSR_DSR))
1152                                     || ((arg & TIOCM_CD)
1153                                         && (diff & SERIAL_MSR_CD))
1154                                     || ((arg & TIOCM_CTS)
1155                                         && (diff & SERIAL_MSR_CTS))) {
1156                                         return 0;
1157                                 }
1158                         }
1159                 }
1160                 return 0;
1161         }
1162 
1163         dev_dbg(&port->dev, "%s -No ioctl for that one.\n", __func__);
1164         return -ENOIOCTLCMD;
1165 }
1166 
1167 static void qt_set_termios(struct tty_struct *tty,
1168                            struct usb_serial_port *port,
1169                            struct ktermios *old_termios)
1170 {
1171         struct ktermios *termios = &tty->termios;
1172         unsigned char new_lcr = 0;
1173         unsigned int cflag = termios->c_cflag;
1174         unsigned int index;
1175         int baud, divisor, remainder;
1176         int status;
1177 
1178         index = port->port_number;
1179 
1180         switch (cflag & CSIZE) {
1181         case CS5:
1182                 new_lcr |= SERIAL_5_DATA;
1183                 break;
1184         case CS6:
1185                 new_lcr |= SERIAL_6_DATA;
1186                 break;
1187         case CS7:
1188                 new_lcr |= SERIAL_7_DATA;
1189                 break;
1190         default:
1191                 termios->c_cflag &= ~CSIZE;
1192                 termios->c_cflag |= CS8;
1193         case CS8:
1194                 new_lcr |= SERIAL_8_DATA;
1195                 break;
1196         }
1197 
1198         /* Parity stuff */
1199         if (cflag & PARENB) {
1200                 if (cflag & PARODD)
1201                         new_lcr |= SERIAL_ODD_PARITY;
1202                 else
1203                         new_lcr |= SERIAL_EVEN_PARITY;
1204         }
1205         if (cflag & CSTOPB)
1206                 new_lcr |= SERIAL_TWO_STOPB;
1207         else
1208                 new_lcr |= SERIAL_ONE_STOPB;
1209 
1210         dev_dbg(&port->dev, "%s - 4\n", __func__);
1211 
1212         /* Thats the LCR stuff, go ahead and set it */
1213         baud = tty_get_baud_rate(tty);
1214         if (!baud)
1215                 /* pick a default, any default... */
1216                 baud = 9600;
1217 
1218         dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
1219 
1220         divisor = MAX_BAUD_RATE / baud;
1221         remainder = MAX_BAUD_RATE % baud;
1222         /* Round to nearest divisor */
1223         if (((remainder * 2) >= baud) && (baud != 110))
1224                 divisor++;
1225 
1226         /*
1227          * Set Baud rate to default and turn off (default)flow control here
1228          */
1229         status =
1230             qt_setuart(port->serial, index, (unsigned short)divisor, new_lcr);
1231         if (status < 0) {
1232                 dev_dbg(&port->dev, "qt_setuart failed\n");
1233                 return;
1234         }
1235 
1236         /* Now determine flow control */
1237         if (cflag & CRTSCTS) {
1238                 dev_dbg(&port->dev, "%s - Enabling HW flow control\n", __func__);
1239 
1240                 /* Enable RTS/CTS flow control */
1241                 status = box_set_hw_flow_ctrl(port->serial, index, 1);
1242 
1243                 if (status < 0) {
1244                         dev_dbg(&port->dev, "box_set_hw_flow_ctrl failed\n");
1245                         return;
1246                 }
1247         } else {
1248                 /* Disable RTS/CTS flow control */
1249                 dev_dbg(&port->dev,
1250                         "%s - disabling HW flow control\n", __func__);
1251 
1252                 status = box_set_hw_flow_ctrl(port->serial, index, 0);
1253                 if (status < 0) {
1254                         dev_dbg(&port->dev, "box_set_hw_flow_ctrl failed\n");
1255                         return;
1256                 }
1257 
1258         }
1259 
1260         /* if we are implementing XON/XOFF, set the start and stop character in
1261          * the device */
1262         if (I_IXOFF(tty) || I_IXON(tty)) {
1263                 unsigned char stop_char = STOP_CHAR(tty);
1264                 unsigned char start_char = START_CHAR(tty);
1265                 status =
1266                     box_set_sw_flow_ctrl(port->serial, index, stop_char,
1267                                       start_char);
1268                 if (status < 0)
1269                         dev_dbg(&port->dev,
1270                                 "box_set_sw_flow_ctrl (enabled) failed\n");
1271 
1272         } else {
1273                 /* disable SW flow control */
1274                 status = box_disable_sw_flow_ctrl(port->serial, index);
1275                 if (status < 0)
1276                         dev_dbg(&port->dev,
1277                                 "box_set_sw_flow_ctrl (diabling) failed\n");
1278 
1279         }
1280         termios->c_cflag &= ~CMSPAR;
1281         /* FIXME:
1282            Error cases should be returning the actual bits changed only
1283         */
1284 }
1285 
1286 static void qt_break(struct tty_struct *tty, int break_state)
1287 {
1288         struct usb_serial_port *port = tty->driver_data;
1289         struct usb_serial *serial = get_usb_serial(port, __func__);
1290         struct quatech_port *qt_port;
1291         u16 index, onoff;
1292         unsigned int result;
1293 
1294         index = port->port_number;
1295 
1296         qt_port = qt_get_port_private(port);
1297 
1298         if (break_state == -1)
1299                 onoff = 1;
1300         else
1301                 onoff = 0;
1302 
1303         mutex_lock(&qt_port->lock);
1304 
1305         result =
1306             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1307                             QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300);
1308 
1309         mutex_unlock(&qt_port->lock);
1310 }
1311 
1312 static inline int qt_real_tiocmget(struct tty_struct *tty,
1313                                    struct usb_serial_port *port,
1314                                    struct usb_serial *serial)
1315 {
1316 
1317         u8 mcr;
1318         u8 msr;
1319         unsigned int result = 0;
1320         int status;
1321         unsigned int index;
1322 
1323         index = port->port_number;
1324         status =
1325             box_get_register(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1326         if (status >= 0) {
1327                 status =
1328                     box_get_register(port->serial, index,
1329                                    MODEM_STATUS_REGISTER, &msr);
1330 
1331         }
1332 
1333         if (status >= 0) {
1334                 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1335                     /* DTR IS SET */
1336                     | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1337                     /* RTS IS SET */
1338                     | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1339                     /* CTS is set */
1340                     | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1341                     /* Carrier detect is set */
1342                     | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1343                     /* Ring indicator set */
1344                     | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1345                 /* DSR is set */
1346                 return result;
1347 
1348         } else
1349                 return -ESPIPE;
1350 }
1351 
1352 static inline int qt_real_tiocmset(struct tty_struct *tty,
1353                                    struct usb_serial_port *port,
1354                                    struct usb_serial *serial,
1355                                    unsigned int value)
1356 {
1357 
1358         u8 mcr;
1359         int status;
1360         unsigned int index;
1361 
1362         index = port->port_number;
1363         status =
1364             box_get_register(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1365         if (status < 0)
1366                 return -ESPIPE;
1367 
1368         /*
1369          * Turn off the RTS and DTR and loopback and then only turn on what was
1370          * asked for
1371          */
1372         mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1373         if (value & TIOCM_RTS)
1374                 mcr |= SERIAL_MCR_RTS;
1375         if (value & TIOCM_DTR)
1376                 mcr |= SERIAL_MCR_DTR;
1377         if (value & TIOCM_LOOP)
1378                 mcr |= SERIAL_MCR_LOOP;
1379 
1380         status =
1381             box_set_register(port->serial, index, MODEM_CONTROL_REGISTER, mcr);
1382         if (status < 0)
1383                 return -ESPIPE;
1384         else
1385                 return 0;
1386 }
1387 
1388 static int qt_tiocmget(struct tty_struct *tty)
1389 {
1390         struct usb_serial_port *port = tty->driver_data;
1391         struct usb_serial *serial = get_usb_serial(port, __func__);
1392         struct quatech_port *qt_port = qt_get_port_private(port);
1393         int retval;
1394 
1395         if (!serial)
1396                 return -ENODEV;
1397 
1398         mutex_lock(&qt_port->lock);
1399         retval = qt_real_tiocmget(tty, port, serial);
1400         mutex_unlock(&qt_port->lock);
1401         return retval;
1402 }
1403 
1404 static int qt_tiocmset(struct tty_struct *tty,
1405                        unsigned int set, unsigned int clear)
1406 {
1407 
1408         struct usb_serial_port *port = tty->driver_data;
1409         struct usb_serial *serial = get_usb_serial(port, __func__);
1410         struct quatech_port *qt_port = qt_get_port_private(port);
1411         int retval;
1412 
1413         if (!serial)
1414                 return -ENODEV;
1415 
1416         mutex_lock(&qt_port->lock);
1417         retval = qt_real_tiocmset(tty, port, serial, set);
1418         mutex_unlock(&qt_port->lock);
1419         return retval;
1420 }
1421 
1422 static void qt_throttle(struct tty_struct *tty)
1423 {
1424         struct usb_serial_port *port = tty->driver_data;
1425         struct usb_serial *serial = get_usb_serial(port, __func__);
1426         struct quatech_port *qt_port;
1427 
1428         if (!serial)
1429                 return;
1430 
1431         qt_port = qt_get_port_private(port);
1432 
1433         mutex_lock(&qt_port->lock);
1434 
1435         /* pass on to the driver specific version of this function */
1436         qt_port->rx_holding = 1;
1437 
1438         mutex_unlock(&qt_port->lock);
1439 }
1440 
1441 static void qt_submit_urb_from_unthrottle(struct usb_serial_port *port,
1442                                           struct usb_serial *serial)
1443 {
1444         int result;
1445 
1446         /* Start reading from the device */
1447         usb_fill_bulk_urb(port->read_urb, serial->dev,
1448                           usb_rcvbulkpipe(serial->dev,
1449                                           port->bulk_in_endpointAddress),
1450                           port->read_urb->transfer_buffer,
1451                           port->read_urb->transfer_buffer_length,
1452                           qt_read_bulk_callback, port);
1453 
1454         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1455 
1456         if (result)
1457                 dev_err(&port->dev,
1458                         "%s - failed restarting read urb, error %d\n",
1459                         __func__, result);
1460 }
1461 
1462 static void qt_unthrottle(struct tty_struct *tty)
1463 {
1464         struct usb_serial_port *port = tty->driver_data;
1465         struct usb_serial *serial = get_usb_serial(port, __func__);
1466         struct quatech_port *qt_port;
1467 
1468         if (!serial)
1469                 return;
1470 
1471         qt_port = qt_get_port_private(port);
1472 
1473         mutex_lock(&qt_port->lock);
1474 
1475         if (qt_port->rx_holding == 1) {
1476                 dev_dbg(&port->dev, "%s -qt_port->rx_holding == 1\n", __func__);
1477 
1478                 qt_port->rx_holding = 0;
1479                 dev_dbg(&port->dev, "%s - qt_port->rx_holding = 0\n", __func__);
1480 
1481                 /* if we have a bulk endpoint, start it up */
1482                 if ((serial->num_bulk_in) && (qt_port->read_bulk_stopped == 1))
1483                         qt_submit_urb_from_unthrottle(port, serial);
1484         }
1485         mutex_unlock(&qt_port->lock);
1486 }
1487 
1488 static int qt_calc_num_ports(struct usb_serial *serial)
1489 {
1490         int num_ports;
1491 
1492         num_ports =
1493             (serial->interface->cur_altsetting->desc.bNumEndpoints - 1) / 2;
1494 
1495         return num_ports;
1496 }
1497 
1498 static struct usb_serial_driver quatech_device = {
1499         .driver = {
1500                    .owner = THIS_MODULE,
1501                    .name = "serqt",
1502                    },
1503         .description = DRIVER_DESC,
1504         .id_table = id_table,
1505         .num_ports = 8,
1506         .open = qt_open,
1507         .close = qt_close,
1508         .write = qt_write,
1509         .write_room = qt_write_room,
1510         .chars_in_buffer = qt_chars_in_buffer,
1511         .throttle = qt_throttle,
1512         .unthrottle = qt_unthrottle,
1513         .calc_num_ports = qt_calc_num_ports,
1514         .ioctl = qt_ioctl,
1515         .set_termios = qt_set_termios,
1516         .break_ctl = qt_break,
1517         .tiocmget = qt_tiocmget,
1518         .tiocmset = qt_tiocmset,
1519         .attach = qt_startup,
1520         .release = qt_release,
1521 };
1522 
1523 static struct usb_serial_driver * const serial_drivers[] = {
1524         &quatech_device, NULL
1525 };
1526 
1527 module_usb_serial_driver(serial_drivers, id_table);
1528 
1529 MODULE_AUTHOR(DRIVER_AUTHOR);
1530 MODULE_DESCRIPTION(DRIVER_DESC);
1531 MODULE_LICENSE("GPL");
1532 

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