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