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