git.oblomov.eu Git - linux-2.6/blob - drivers/staging/serqt_usb/serqt_usb.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/sched.h>
   8 #include <linux/slab.h>
   9 #include <linux/tty.h>
  10 #include <linux/tty_flip.h>
  11 #include <linux/module.h>
  12 #include <linux/usb.h>
  13 #include <linux/wait.h>
  14 #include <linux/types.h>
  15 #include <linux/version.h>
  16 #include <linux/uaccess.h>
  17
  18 /* Use our own dbg macro */
  19 /* #define DEBUG_ON */
  20 /* #undef dbg */
  21 #ifdef DEBUG_ON
  22 #define  mydbg(const...)    printk(const)
  23 #else
  24 #define  mydbg(const...)
  25 #endif
  26
  27 /* parity check flag */
  28 #define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
  29
  30 #define SERIAL_TTY_MAJOR                0       /* Nice legal number now */
  31 #define SERIAL_TTY_MINORS               255     /* loads of devices :) */
  32 #define MAX_NUM_PORTS                   8       /* The maximum number of ports one device can grab at once */
  33 #define PREFUFF_LEVEL_CONSERVATIVE  128
  34 #define ATC_DISABLED                0x00
  35
  36 #define RR_BITS             0x03        /* for clearing clock bits */
  37 #define DUPMODE_BITS        0xc0
  38
  39 #define RS232_MODE          0x00
  40 #define RTSCTS_TO_CONNECTOR 0x40
  41 #define CLKS_X4             0x02
  42
  43 #define LOOPMODE_BITS       0x41        /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
  44 #define ALL_LOOPBACK        0x01
  45 #define MODEM_CTRL          0x40
  46
  47 #define THISCHAR                    data[i]
  48 #define NEXTCHAR                    data[i + 1]
  49 #define THIRDCHAR                  data[i + 2]
  50 #define FOURTHCHAR                  data[i + 3]
  51
  52 /*
  53  * Useful defintions for port A, Port B and Port C
  54  */
  55 #define FULLPWRBIT          0x00000080
  56 #define NEXT_BOARD_POWER_BIT        0x00000004
  57
  58 #define SERIAL_LSR_OE       0x02
  59 #define SERIAL_LSR_PE       0x04
  60 #define SERIAL_LSR_FE       0x08
  61 #define SERIAL_LSR_BI       0x10
  62
  63 #define SERIAL_LSR_TEMT     0x40
  64
  65 #define  DIV_LATCH_LS               0x00
  66 #define  XMT_HOLD_REGISTER          0x00
  67 #define  XVR_BUFFER_REGISTER        0x00
  68 #define  DIV_LATCH_MS               0x01
  69 #define  FIFO_CONTROL_REGISTER      0x02
  70 #define  LINE_CONTROL_REGISTER      0x03
  71 #define  MODEM_CONTROL_REGISTER     0x04
  72 #define  LINE_STATUS_REGISTER       0x05
  73 #define  MODEM_STATUS_REGISTER      0x06
  74
  75 #define  SERIAL_MCR_DTR             0x01
  76 #define  SERIAL_MCR_RTS             0x02
  77 #define  SERIAL_MCR_LOOP            0x10
  78
  79 #define  SERIAL_MSR_CTS             0x10
  80 #define  SERIAL_MSR_CD              0x80
  81 #define  SERIAL_MSR_RI              0x40
  82 #define  SERIAL_MSR_DSR             0x20
  83 #define  SERIAL_MSR_MASK            0xf0
  84
  85 #define  SERIAL_8_DATA              0x03
  86 #define  SERIAL_7_DATA              0x02
  87 #define  SERIAL_6_DATA              0x01
  88 #define  SERIAL_5_DATA              0x00
  89
  90 #define  SERIAL_ODD_PARITY          0X08
  91 #define  SERIAL_EVEN_PARITY         0X18
  92 #define  SERIAL_TWO_STOPB           0x04
  93 #define  SERIAL_ONE_STOPB           0x00
  94
  95 #define  MAX_BAUD_RATE              460800
  96 #define  MAX_BAUD_REMAINDER         4608
  97
  98 #define QT_SET_GET_DEVICE           0xc2
  99 #define QT_OPEN_CLOSE_CHANNEL       0xca
 100 #define QT_GET_SET_PREBUF_TRIG_LVL  0xcc
 101 #define QT_SET_ATF                  0xcd
 102 #define QT_GET_SET_REGISTER         0xc0
 103 #define QT_GET_SET_UART             0xc1
 104 #define QT_HW_FLOW_CONTROL_MASK     0xc5
 105 #define QT_SW_FLOW_CONTROL_MASK     0xc6
 106 #define QT_SW_FLOW_CONTROL_DISABLE  0xc7
 107 #define QT_BREAK_CONTROL            0xc8
 108
 109 #define SERIALQT_PCI_IOC_MAGIC 'k'
 110 #define SERIALQT_WRITE_QOPR _IOW(SERIALQT_PCI_IOC_MAGIC, 0, int)
 111 #define SERIALQT_WRITE_QMCR _IOW(SERIALQT_PCI_IOC_MAGIC, 1, int)
 112 #define SERIALQT_GET_NUMOF_UNITS _IOR(SERIALQT_PCI_IOC_MAGIC, 2, void *)
 113 #define SERIALQT_GET_THIS_UNIT _IOR(SERIALQT_PCI_IOC_MAGIC, 3, void *)
 114 #define SERIALQT_READ_QOPR _IOR(SERIALQT_PCI_IOC_MAGIC, 4, int)
 115 #define SERIALQT_READ_QMCR _IOR(SERIALQT_PCI_IOC_MAGIC, 5, int)
 116 #define SERIALQT_IS422_EXTENDED _IOR(SERIALQT_PCI_IOC_MAGIC, 6, int)    /* returns successful if 422 extended */
 117
 118 #define USBD_TRANSFER_DIRECTION_IN    0xc0
 119 #define USBD_TRANSFER_DIRECTION_OUT   0x40
 120
 121 #define ATC_DISABLED                0x00
 122 #define ATC_RTS_ENABLED                 0x02
 123 #define ATC_DTR_ENABLED                 0x01
 124
 125 #define RR_BITS             0x03        /* for clearing clock bits */
 126 #define DUPMODE_BITS        0xc0
 127
 128 #define FULL_DUPLEX         0x00
 129 #define HALF_DUPLEX_RTS     0x40
 130 #define HALF_DUPLEX_DTR     0x80
 131
 132 #define QMCR_FULL_DUPLEX  0x00
 133 #define QMCR_HALF_DUPLEX_RTS 0x02
 134 #define QMCR_HALF_DUPLEX_DTR 0x01
 135 #define QMCR_HALF_DUPLEX_MASK 0x03
 136 #define QMCR_CONNECTOR_MASK 0x1C
 137
 138 #define QMCR_RX_EN_MASK 0x20
 139
 140 #define QMCR_ALL_LOOPBACK    0x10
 141 #define QMCR_MODEM_CONTROL   0X00
 142
 143 #define SERIALQT_IOC_MAXNR 6
 144
 145 struct usb_serial_port {
 146         struct usb_serial *serial;      /* pointer back to the owner of this port */
 147         struct tty_struct *tty; /* the coresponding tty for this port */
 148         unsigned char number;
 149         char active;            /* someone has this device open */
 150
 151         unsigned char *interrupt_in_buffer;
 152         struct urb *interrupt_in_urb;
 153         __u8 interrupt_in_endpointAddress;
 154
 155         unsigned char *bulk_in_buffer;
 156         unsigned char *xfer_to_tty_buffer;
 157         struct urb *read_urb;
 158         __u8 bulk_in_endpointAddress;
 159
 160         unsigned char *bulk_out_buffer;
 161         int bulk_out_size;
 162         struct urb *write_urb;
 163         __u8 bulk_out_endpointAddress;
 164
 165         wait_queue_head_t write_wait;
 166         wait_queue_head_t wait;
 167         struct work_struct work;
 168
 169         int open_count;         /* number of times this port has been opened */
 170         struct semaphore sem;   /* locks this structure */
 171
 172         __u8 shadowLCR;         /* last LCR value received */
 173         __u8 shadowMCR;         /* last MCR value received */
 174         __u8 shadowMSR;         /* last MSR value received */
 175         __u8 shadowLSR;         /* last LSR value received */
 176         int RxHolding;
 177         char closePending;
 178         int ReadBulkStopped;
 179
 180         void *private;          /* data private to the specific port */
 181 };
 182
 183 struct identity {
 184         int index;
 185         int n_identity;
 186 };
 187
 188 struct usb_serial {
 189         struct usb_device *dev;
 190         struct usb_interface *interface;        /* the interface for this device */
 191         struct tty_driver *tty_driver;  /* the tty_driver for this device */
 192         unsigned char minor;    /* the starting minor number for this device */
 193         unsigned char num_ports;        /* the number of ports this device has */
 194         char num_interrupt_in;  /* number of interrupt in endpoints we have */
 195         char num_bulk_in;       /* number of bulk in endpoints we have */
 196         char num_bulk_out;      /* number of bulk out endpoints we have */
 197         unsigned char num_OpenCount;    /* the number of ports this device has */
 198
 199         __u16 vendor;           /* vendor id of this device */
 200         __u16 product;          /* product id of this device */
 201         struct usb_serial_port port[MAX_NUM_PORTS];
 202
 203         void *private;          /* data private to the specific driver */
 204 };
 205
 206 static inline int port_paranoia_check(struct usb_serial_port *port,
 207                                       const char *function)
 208 {
 209         if (!port) {
 210                 dbg("%s - port == NULL", function);
 211                 return -1;
 212         }
 213         if (!port->serial) {
 214                 dbg("%s - port->serial == NULL\n", function);
 215                 return -1;
 216         }
 217         if (!port->tty) {
 218                 dbg("%s - port->tty == NULL\n", function);
 219                 return -1;
 220         }
 221
 222         return 0;
 223 }
 224
 225 /* Inline functions to check the sanity of a pointer that is passed to us */
 226 static inline int serial_paranoia_check(struct usb_serial *serial,
 227                                         const char *function)
 228 {
 229         if (!serial) {
 230                 dbg("%s - serial == NULL\n", function);
 231                 return -1;
 232         }
 233
 234         return 0;
 235 }
 236
 237 static inline struct usb_serial *get_usb_serial(struct usb_serial_port *port,
 238                                                 const char *function)
 239 {
 240         /* if no port was specified, or it fails a paranoia check */
 241         if (!port ||
 242             port_paranoia_check(port, function) ||
 243             serial_paranoia_check(port->serial, function)) {
 244                 /* then say that we dont have a valid usb_serial thing, which will
 245                  * end up genrating -ENODEV return values */
 246                 return NULL;
 247         }
 248
 249         return port->serial;
 250 }
 251
 252 struct qt_get_device_data {
 253         __u8 porta;
 254         __u8 portb;
 255         __u8 portc;
 256 };
 257
 258 struct qt_open_channel_data {
 259         __u8 line_status;
 260         __u8 modem_status;
 261 };
 262
 263 static void ProcessLineStatus(struct usb_serial_port *port,
 264                               unsigned char line_status);
 265 static void ProcessModemStatus(struct usb_serial_port *port,
 266                                unsigned char modem_status);
 267 static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data);
 268 static struct usb_serial *get_free_serial(int num_ports, int *minor);
 269
 270 static int serqt_probe(struct usb_interface *interface,
 271                        const struct usb_device_id *id);
 272
 273 static void serqt_usb_disconnect(struct usb_interface *interface);
 274 static int box_set_device(struct usb_serial *serial,
 275                           struct qt_get_device_data *pDeviceData);
 276 static int box_get_device(struct usb_serial *serial,
 277                           struct qt_get_device_data *pDeviceData);
 278 static int serial_open(struct tty_struct *tty, struct file *filp);
 279 static void serial_close(struct tty_struct *tty, struct file *filp);
 280 static int serial_write_room(struct tty_struct *tty);
 281 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 282                         unsigned int cmd, unsigned long arg);
 283 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old);
 284 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 285                         int count);
 286
 287 static void serial_throttle(struct tty_struct *tty);
 288 static void serial_unthrottle(struct tty_struct *tty);
 289 static int serial_break(struct tty_struct *tty, int break_state);
 290 static int serial_chars_in_buffer(struct tty_struct *tty);
 291
 292 static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
 293                                 struct file *filp);
 294 static int BoxSetPrebufferLevel(struct usb_serial *serial);
 295
 296 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode);
 297 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
 298                       unsigned short default_divisor,
 299                       unsigned char default_LCR);
 300
 301 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
 302                                __u16 OpenClose,
 303                                struct qt_open_channel_data *pDeviceData);
 304 static void qt_close(struct tty_struct *tty, struct usb_serial_port *port,
 305                                         struct file *filp);
 306 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
 307                           unsigned short Register_Num, __u8 *pValue);
 308 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
 309                           unsigned short Register_Num, unsigned short Value);
 310 static void qt_write_bulk_callback(struct urb *urb);
 311 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
 312                     const unsigned char *buf, int count);
 313 static void port_softint(struct work_struct *work);
 314 static int qt_write_room(struct usb_serial_port *port);
 315 static int qt_chars_in_buffer(struct usb_serial_port *port);
 316 static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
 317                 struct file *file, unsigned int cmd, unsigned long arg);
 318 static void qt_set_termios(struct tty_struct *tty,
 319                            struct usb_serial_port *port,
 320                            struct ktermios *old_termios);
 321 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
 322                              int bSet);
 323 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index);
 324 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value);
 325 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value);
 326 static struct usb_serial *find_the_box(unsigned int index);
 327 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
 328                      unsigned long arg);
 329
 330 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 Uart,
 331                              unsigned char stop_char, unsigned char start_char);
 332 static void qt_read_bulk_callback(struct urb *urb);
 333
 334 static void port_sofrint(void *private);
 335
 336 static void return_serial(struct usb_serial *serial);
 337
 338 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 339                            unsigned int set, unsigned int clear);
 340 static int serial_tiocmget(struct tty_struct *tty, struct file *file);
 341
 342 static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
 343                        struct file *file, unsigned int value);
 344
 345 static int qt_tiocmget(struct tty_struct *tty, struct usb_serial_port *port,
 346                                                         struct file *file);
 347
 348 /* Version Information */
 349 #define DRIVER_VERSION "v2.14"
 350 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
 351 #define DRIVER_DESC "Quatech USB to Serial Driver"
 352
 353 #define USB_VENDOR_ID_QUATECH                   0x061d  /* Quatech VID */
 354 #define DEVICE_ID_QUATECH_RS232_SINGLE_PORT     0xC020  /* SSU100 */
 355 #define DEVICE_ID_QUATECH_RS422_SINGLE_PORT     0xC030  /* SSU200 */
 356 #define DEVICE_ID_QUATECH_RS232_DUAL_PORT       0xC040  /* DSU100 */
 357 #define DEVICE_ID_QUATECH_RS422_DUAL_PORT       0xC050  /* DSU200 */
 358 #define DEVICE_ID_QUATECH_RS232_FOUR_PORT       0xC060  /* QSU100 */
 359 #define DEVICE_ID_QUATECH_RS422_FOUR_PORT       0xC070  /* QSU200 */
 360 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A    0xC080  /* ESU100A */
 361 #define DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B    0xC081  /* ESU100B */
 362 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A    0xC0A0  /* ESU200A */
 363 #define DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B    0xC0A1  /* ESU200B */
 364 #define DEVICE_ID_QUATECH_RS232_16_PORT_A       0xC090  /* HSU100A */
 365 #define DEVICE_ID_QUATECH_RS232_16_PORT_B       0xC091  /* HSU100B */
 366 #define DEVICE_ID_QUATECH_RS232_16_PORT_C       0xC092  /* HSU100C */
 367 #define DEVICE_ID_QUATECH_RS232_16_PORT_D       0xC093  /* HSU100D */
 368 #define DEVICE_ID_QUATECH_RS422_16_PORT_A       0xC0B0  /* HSU200A */
 369 #define DEVICE_ID_QUATECH_RS422_16_PORT_B       0xC0B1  /* HSU200B */
 370 #define DEVICE_ID_QUATECH_RS422_16_PORT_C       0xC0B2  /* HSU200C */
 371 #define DEVICE_ID_QUATECH_RS422_16_PORT_D       0xC0B3  /* HSU200D */
 372
 373 /* table of Quatech devices  */
 374 static struct usb_device_id serqt_table[] = {
 375         {USB_DEVICE
 376          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_SINGLE_PORT)},
 377         {USB_DEVICE
 378          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_SINGLE_PORT)},
 379         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_DUAL_PORT)},
 380         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_DUAL_PORT)},
 381         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_FOUR_PORT)},
 382         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_FOUR_PORT)},
 383         {USB_DEVICE
 384          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A)},
 385         {USB_DEVICE
 386          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B)},
 387         {USB_DEVICE
 388          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A)},
 389         {USB_DEVICE
 390          (USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B)},
 391         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_A)},
 392         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_B)},
 393         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_C)},
 394         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS232_16_PORT_D)},
 395         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_A)},
 396         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_B)},
 397         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_C)},
 398         {USB_DEVICE(USB_VENDOR_ID_QUATECH, DEVICE_ID_QUATECH_RS422_16_PORT_D)},
 399         {}                      /* Terminating entry */
 400 };
 401
 402 MODULE_DEVICE_TABLE(usb, serqt_table);
 403
 404 static int major_number;
 405 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];      /* initially all NULL */
 406
 407 /* table of Quatech 422devices  */
 408 static unsigned int serqt_422_table[] = {
 409         DEVICE_ID_QUATECH_RS422_SINGLE_PORT,
 410         DEVICE_ID_QUATECH_RS422_DUAL_PORT,
 411         DEVICE_ID_QUATECH_RS422_FOUR_PORT,
 412         DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A,
 413         DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B,
 414         DEVICE_ID_QUATECH_RS422_16_PORT_A,
 415         DEVICE_ID_QUATECH_RS422_16_PORT_B,
 416         DEVICE_ID_QUATECH_RS422_16_PORT_C,
 417         DEVICE_ID_QUATECH_RS422_16_PORT_D,
 418         0                       /* terminate with zero */
 419 };
 420
 421 /* usb specific object needed to register this driver with the usb subsystem */
 422 static struct usb_driver serqt_usb_driver = {
 423         .name = "quatech-usb-serial",
 424         .probe = serqt_probe,
 425         .disconnect = serqt_usb_disconnect,
 426         .id_table = serqt_table,
 427 };
 428
 429 static struct ktermios *serial_termios[SERIAL_TTY_MINORS];
 430 static struct ktermios *serial_termios_locked[SERIAL_TTY_MINORS];
 431
 432 static const struct tty_operations serial_ops = {
 433         .open = serial_open,
 434         .close = serial_close,
 435         .write = serial_write,
 436         .write_room = serial_write_room,
 437         .ioctl = serial_ioctl,
 438         .set_termios = serial_set_termios,
 439         .throttle = serial_throttle,
 440         .unthrottle = serial_unthrottle,
 441         .break_ctl = serial_break,
 442         .chars_in_buffer = serial_chars_in_buffer,
 443         .tiocmset = serial_tiocmset,
 444         .tiocmget = serial_tiocmget,
 445 };
 446
 447 static struct tty_driver serial_tty_driver = {
 448         .magic = TTY_DRIVER_MAGIC,
 449         .driver_name = "Quatech usb-serial",
 450         .name = "ttyQT_USB",
 451         .major = SERIAL_TTY_MAJOR,
 452         .minor_start = 0,
 453         .num = SERIAL_TTY_MINORS,
 454         .type = TTY_DRIVER_TYPE_SERIAL,
 455         .subtype = SERIAL_TYPE_NORMAL,
 456         .flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV,
 457
 458         .termios = serial_termios,
 459         .termios_locked = serial_termios_locked,
 460         .init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL,
 461
 462         .init_termios.c_iflag = ICRNL | IXON,
 463         .init_termios.c_oflag = OPOST,
 464
 465         .init_termios.c_lflag =
 466             ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,
 467 };
 468
 469 /* fops for parent device */
 470 static const struct file_operations serialqt_usb_fops = {
 471         .ioctl = ioctl_serial_usb,
 472 };
 473
 474  /**
 475  *        serqt_probe
 476  *
 477  *      Called by the usb core when a new device is connected that it thinks
 478  *      this driver might be interested in.
 479  *
 480  */
 481 static int serqt_probe(struct usb_interface *interface,
 482                        const struct usb_device_id *id)
 483 {
 484         struct usb_device *dev = interface_to_usbdev(interface);
 485         struct usb_serial *serial = NULL;
 486         struct usb_serial_port *port;
 487         struct usb_endpoint_descriptor *endpoint;
 488         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 489         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 490         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 491         int minor;
 492         int buffer_size;
 493         int i;
 494         struct usb_host_interface *iface_desc;
 495         int num_interrupt_in = 0;
 496         int num_bulk_in = 0;
 497         int num_bulk_out = 0;
 498         int num_ports;
 499         struct qt_get_device_data DeviceData;
 500         int status;
 501
 502         mydbg("In %s\n", __func__);
 503
 504         /* let's find the endpoints needed */
 505         /* check out the endpoints */
 506         iface_desc = interface->cur_altsetting;;
 507         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 508                 endpoint = &iface_desc->endpoint[i].desc;
 509
 510                 if ((endpoint->bEndpointAddress & 0x80) &&
 511                     ((endpoint->bmAttributes & 3) == 0x02)) {
 512                         /* we found a bulk in endpoint */
 513                         mydbg("found bulk in");
 514                         bulk_in_endpoint[num_bulk_in] = endpoint;
 515                         ++num_bulk_in;
 516                 }
 517
 518                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
 519                     ((endpoint->bmAttributes & 3) == 0x02)) {
 520                         /* we found a bulk out endpoint */
 521                         mydbg("found bulk out\n");
 522                         bulk_out_endpoint[num_bulk_out] = endpoint;
 523                         ++num_bulk_out;
 524                 }
 525
 526                 if ((endpoint->bEndpointAddress & 0x80) &&
 527                     ((endpoint->bmAttributes & 3) == 0x03)) {
 528                         /* we found a interrupt in endpoint */
 529                         mydbg("found interrupt in\n");
 530                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 531                         ++num_interrupt_in;
 532                 }
 533         }
 534
 535         /* found all that we need */
 536         dev_info(&interface->dev, "Quatech converter detected\n");
 537         num_ports = num_bulk_out;
 538         if (num_ports == 0) {
 539                 err("Quatech device with no bulk out, not allowed.");
 540                 return -ENODEV;
 541
 542         }
 543
 544         serial = get_free_serial(num_ports, &minor);
 545         if (serial == NULL) {
 546                 err("No more free serial devices");
 547                 return -ENODEV;
 548         }
 549
 550         serial->dev = dev;
 551         serial->interface = interface;
 552         serial->minor = minor;
 553         serial->num_ports = num_ports;
 554         serial->num_bulk_in = num_bulk_in;
 555         serial->num_bulk_out = num_bulk_out;
 556         serial->num_interrupt_in = num_interrupt_in;
 557         serial->vendor = dev->descriptor.idVendor;
 558         serial->product = dev->descriptor.idProduct;
 559
 560         /* set up the endpoint information */
 561         for (i = 0; i < num_bulk_in; ++i) {
 562                 endpoint = bulk_in_endpoint[i];
 563                 port = &serial->port[i];
 564                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 565                 if (!port->read_urb) {
 566                         err("No free urbs available");
 567                         goto probe_error;
 568                 }
 569                 buffer_size = endpoint->wMaxPacketSize;
 570                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 571                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 572                 port->xfer_to_tty_buffer = kmalloc(buffer_size, GFP_KERNEL);
 573                 if (!port->bulk_in_buffer) {
 574                         err("Couldn't allocate bulk_in_buffer");
 575                         goto probe_error;
 576                 }
 577                 usb_fill_bulk_urb(port->read_urb, dev,
 578                                   usb_rcvbulkpipe(dev,
 579                                                   endpoint->bEndpointAddress),
 580                                   port->bulk_in_buffer, buffer_size,
 581                                   qt_read_bulk_callback, port);
 582         }
 583
 584         for (i = 0; i < num_bulk_out; ++i) {
 585                 endpoint = bulk_out_endpoint[i];
 586                 port = &serial->port[i];
 587                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 588                 if (!port->write_urb) {
 589                         err("No free urbs available");
 590                         goto probe_error;
 591                 }
 592                 buffer_size = endpoint->wMaxPacketSize;
 593                 port->bulk_out_size = buffer_size;
 594                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 595                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 596                 if (!port->bulk_out_buffer) {
 597                         err("Couldn't allocate bulk_out_buffer");
 598                         goto probe_error;
 599                 }
 600                 usb_fill_bulk_urb(port->write_urb, dev,
 601                                   usb_sndbulkpipe(dev,
 602                                                   endpoint->bEndpointAddress),
 603                                   port->bulk_out_buffer, buffer_size,
 604                                   qt_write_bulk_callback, port);
 605
 606         }
 607
 608         /* For us numb of bulkin  or out = number of ports */
 609         mydbg("%s - setting up %d port structures for this device\n",
 610               __func__, num_bulk_in);
 611         for (i = 0; i < num_bulk_in; ++i) {
 612                 port = &serial->port[i];
 613                 port->number = i + serial->minor;
 614                 port->serial = serial;
 615
 616                 INIT_WORK(&port->work, port_softint);
 617
 618                 init_MUTEX(&port->sem);
 619
 620         }
 621         status = box_get_device(serial, &DeviceData);
 622         if (status < 0) {
 623                 mydbg(__FILE__ "box_get_device failed");
 624                 goto probe_error;
 625         }
 626
 627         mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
 628
 629         DeviceData.portb &= ~FULLPWRBIT;
 630         mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
 631
 632         status = box_set_device(serial, &DeviceData);
 633         if (status < 0) {
 634                 mydbg(__FILE__ "box_set_device failed\n");
 635                 goto probe_error;
 636         }
 637
 638         /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
 639         for (i = 0; i < serial->num_ports; ++i) {
 640                 dev_info(&interface->dev,
 641                          "Converter now attached to ttyUSB%d (or usb/tts/%d for devfs)",
 642                          serial->port[i].number, serial->port[i].number);
 643         }
 644
 645         /* usb_serial_console_init (debug, minor); */
 646
 647         /***********TAG add start next board here ****/
 648         status = box_get_device(serial, &DeviceData);
 649         if (status < 0) {
 650                 mydbg(__FILE__ "box_get_device failed");
 651                 goto probe_error;
 652         }
 653         /*
 654          * and before we power up lets initialiaze parnent device stuff here before
 655          * we set thmem via any other method such as the property pages
 656          */
 657         switch (serial->product) {
 658         case DEVICE_ID_QUATECH_RS232_SINGLE_PORT:
 659         case DEVICE_ID_QUATECH_RS232_DUAL_PORT:
 660         case DEVICE_ID_QUATECH_RS232_FOUR_PORT:
 661         case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_A:
 662         case DEVICE_ID_QUATECH_RS232_EIGHT_PORT_B:
 663         case DEVICE_ID_QUATECH_RS232_16_PORT_A:
 664         case DEVICE_ID_QUATECH_RS232_16_PORT_B:
 665         case DEVICE_ID_QUATECH_RS232_16_PORT_C:
 666         case DEVICE_ID_QUATECH_RS232_16_PORT_D:
 667                 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
 668                 DeviceData.porta |= CLKS_X4;
 669                 DeviceData.portb &= ~(LOOPMODE_BITS);
 670                 DeviceData.portb |= RS232_MODE;
 671                 break;
 672
 673         case DEVICE_ID_QUATECH_RS422_SINGLE_PORT:
 674         case DEVICE_ID_QUATECH_RS422_DUAL_PORT:
 675         case DEVICE_ID_QUATECH_RS422_FOUR_PORT:
 676         case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_A:
 677         case DEVICE_ID_QUATECH_RS422_EIGHT_PORT_B:
 678         case DEVICE_ID_QUATECH_RS422_16_PORT_A:
 679         case DEVICE_ID_QUATECH_RS422_16_PORT_B:
 680         case DEVICE_ID_QUATECH_RS422_16_PORT_C:
 681         case DEVICE_ID_QUATECH_RS422_16_PORT_D:
 682                 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
 683                 DeviceData.porta |= CLKS_X4;
 684                 DeviceData.portb &= ~(LOOPMODE_BITS);
 685                 DeviceData.portb |= ALL_LOOPBACK;
 686                 break;
 687         default:
 688                 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
 689                 DeviceData.porta |= CLKS_X4;
 690                 DeviceData.portb &= ~(LOOPMODE_BITS);
 691                 DeviceData.portb |= RS232_MODE;
 692                 break;
 693
 694         }
 695         status = BoxSetPrebufferLevel(serial);  /* sets to default vaue */
 696         if (status < 0) {
 697                 mydbg(__FILE__ "BoxSetPrebufferLevel failed\n");
 698                 goto probe_error;
 699         }
 700
 701         status = BoxSetATC(serial, ATC_DISABLED);
 702         if (status < 0) {
 703                 mydbg(__FILE__ "BoxSetATC failed\n");
 704                 goto probe_error;
 705         }
 706         /**********************************************************/
 707         mydbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
 708
 709         DeviceData.portb |= NEXT_BOARD_POWER_BIT;
 710         mydbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
 711
 712         status = box_set_device(serial, &DeviceData);
 713         if (status < 0) {
 714                 mydbg(__FILE__ "box_set_device failed\n");
 715                 goto probe_error;
 716         }
 717
 718         mydbg("Exit Success %s\n", __func__);
 719
 720         usb_set_intfdata(interface, serial);
 721         return 0;
 722
 723 probe_error:
 724
 725         for (i = 0; i < num_bulk_in; ++i) {
 726                 port = &serial->port[i];
 727                 usb_free_urb(port->read_urb);
 728                 kfree(port->bulk_in_buffer);
 729         }
 730         for (i = 0; i < num_bulk_out; ++i) {
 731                 port = &serial->port[i];
 732                 usb_free_urb(port->write_urb);
 733                 kfree(port->bulk_out_buffer);
 734                 kfree(port->xfer_to_tty_buffer);
 735         }
 736         for (i = 0; i < num_interrupt_in; ++i) {
 737                 port = &serial->port[i];
 738                 usb_free_urb(port->interrupt_in_urb);
 739                 kfree(port->interrupt_in_buffer);
 740         }
 741
 742         /* return the minor range that this device had */
 743         return_serial(serial);
 744         mydbg("Exit fail %s\n", __func__);
 745
 746         /* free up any memory that we allocated */
 747         kfree(serial);
 748         return -EIO;
 749 }
 750
 751 /*
 752  * returns the serial_table array pointers that are taken
 753  * up in consecutive positions for each port to a common usb_serial structure
 754  * back to NULL
 755  */
 756 static void return_serial(struct usb_serial *serial)
 757 {
 758         int i;
 759
 760         mydbg("%s\n", __func__);
 761
 762         if (serial == NULL)
 763                 return;
 764
 765         for (i = 0; i < serial->num_ports; ++i)
 766                 serial_table[serial->minor + i] = NULL;
 767
 768         return;
 769 }
 770
 771 /*
 772  * Finds the first locatio int the serial_table array where it can fit
 773  * num_ports number of consecutive points to a common usb_serial
 774  * structure,allocates a stucture points to it in all the structures, and
 775  * returns the index to the first location in the array in the "minor"
 776  * variable.
 777  */
 778 static struct usb_serial *get_free_serial(int num_ports, int *minor)
 779 {
 780         struct usb_serial *serial = NULL;
 781         int i, j;
 782         int good_spot;
 783
 784         mydbg("%s %d\n", __func__, num_ports);
 785
 786         *minor = 0;
 787         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 788                 if (serial_table[i])
 789                         continue;
 790
 791                 good_spot = 1;
 792                 /*
 793                  * find a spot in the array where you can fit consecutive
 794                  * positions to put the pointers to the usb_serail allocated
 795                  * structure for all the minor numbers (ie. ports)
 796                  */
 797                 for (j = 1; j <= num_ports - 1; ++j)
 798                         if (serial_table[i + j])
 799                                 good_spot = 0;
 800                 if (good_spot == 0)
 801                         continue;
 802
 803                 serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL);
 804                 if (!serial) {
 805                         err("%s - Out of memory", __func__);
 806                         return NULL;
 807                 }
 808                 memset(serial, 0, sizeof(struct usb_serial));
 809                 serial_table[i] = serial;
 810                 *minor = i;
 811                 mydbg("%s - minor base = %d\n", __func__, *minor);
 812
 813                 /*
 814                  * copy in the pointer into the array starting a the *minor
 815                  * position minor is the index into the array.
 816                  */
 817                 for (i = *minor + 1;
 818                      (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
 819                         serial_table[i] = serial;
 820                 return serial;
 821         }
 822         return NULL;
 823 }
 824
 825 static int flip_that(struct tty_struct *tty, __u16 index,
 826                      struct usb_serial *serial)
 827 {
 828         tty_flip_buffer_push(tty);
 829         tty_schedule_flip(tty);
 830         return 0;
 831 }
 832
 833 /* Handles processing and moving data to the tty layer */
 834 static void port_sofrint(void *private)
 835 {
 836         struct usb_serial_port *port = private;
 837         struct usb_serial *serial = get_usb_serial(port, __func__);
 838         struct tty_struct *tty = port->tty;
 839         unsigned char *data = port->read_urb->transfer_buffer;
 840         unsigned int index;
 841         struct urb *urb = port->read_urb;
 842         unsigned int RxCount = urb->actual_length;
 843         int i, result;
 844         int flag, flag_data;
 845
 846         /* index = MINOR(port->tty->device) - serial->minor; */
 847         index = tty->index - serial->minor;
 848
 849         mydbg("%s - port %d\n", __func__, port->number);
 850         mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
 851
 852         if (port_paranoia_check(port, __func__) != 0) {
 853                 mydbg("%s - port_paranoia_check, exiting\n", __func__);
 854                 port->ReadBulkStopped = 1;
 855                 return;
 856         }
 857
 858         if (!serial) {
 859                 mydbg("%s - bad serial pointer, exiting\n", __func__);
 860                 return;
 861         }
 862         if (port->closePending == 1) {
 863                 /* Were closing , stop reading */
 864                 mydbg("%s - (port->closepending == 1\n", __func__);
 865                 port->ReadBulkStopped = 1;
 866                 return;
 867         }
 868
 869         /*
 870          * RxHolding is asserted by throttle, if we assert it, we're not
 871          * receiving any more characters and let the box handle the flow
 872          * control
 873          */
 874         if (port->RxHolding == 1) {
 875                 port->ReadBulkStopped = 1;
 876                 return;
 877         }
 878
 879         if (urb->status) {
 880                 port->ReadBulkStopped = 1;
 881
 882                 mydbg("%s - nonzero read bulk status received: %d\n",
 883                       __func__, urb->status);
 884                 return;
 885         }
 886
 887         tty = port->tty;
 888         mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
 889
 890         if (tty && RxCount) {
 891                 flag_data = 0;
 892                 for (i = 0; i < RxCount; ++i) {
 893                         /* Look ahead code here */
 894                         if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b)
 895                             && (NEXTCHAR == 0x1b)) {
 896                                 flag = 0;
 897                                 switch (THIRDCHAR) {
 898                                 case 0x00:
 899                                         /* Line status change 4th byte must follow */
 900                                         if (i > (RxCount - 4)) {
 901                                                 mydbg("Illegal escape sequences in received data\n");
 902                                                 break;
 903                                         }
 904                                         ProcessLineStatus(port, FOURTHCHAR);
 905                                         i += 3;
 906                                         flag = 1;
 907                                         break;
 908
 909                                 case 0x01:
 910                                         /* Modem status status change 4th byte must follow */
 911                                         mydbg("Modem status status. \n");
 912                                         if (i > (RxCount - 4)) {
 913                                                 mydbg
 914                                                     ("Illegal escape sequences in received data\n");
 915                                                 break;
 916                                         }
 917                                         ProcessModemStatus(port, FOURTHCHAR);
 918                                         i += 3;
 919                                         flag = 1;
 920                                         break;
 921                                 case 0xff:
 922                                         mydbg("No status sequence. \n");
 923
 924                                         ProcessRxChar(port, THISCHAR);
 925                                         ProcessRxChar(port, NEXTCHAR);
 926                                         i += 2;
 927                                         break;
 928                                 }
 929                                 if (flag == 1)
 930                                         continue;
 931                         }
 932
 933                         if (tty && urb->actual_length) {
 934                                 tty_buffer_request_room(tty, 1);
 935                                 tty_insert_flip_string(tty, (data + i), 1);
 936                         }
 937
 938                 }
 939                 tty_flip_buffer_push(tty);
 940         }
 941
 942         /* Continue trying to always read  */
 943         usb_fill_bulk_urb(port->read_urb, serial->dev,
 944                           usb_rcvbulkpipe(serial->dev,
 945                                           port->bulk_in_endpointAddress),
 946                           port->read_urb->transfer_buffer,
 947                           port->read_urb->transfer_buffer_length,
 948                           qt_read_bulk_callback, port);
 949         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
 950         if (result)
 951                 mydbg("%s - failed resubmitting read urb, error %d",
 952                       __func__, result);
 953         else {
 954                 if (tty && RxCount)
 955                         flip_that(tty, index, serial);
 956         }
 957
 958         return;
 959
 960 }
 961
 962 static void qt_read_bulk_callback(struct urb *urb)
 963 {
 964
 965         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 966
 967         if (urb->status) {
 968                 port->ReadBulkStopped = 1;
 969                 mydbg("%s - nonzero write bulk status received: %d\n",
 970                       __func__, urb->status);
 971                 return;
 972         }
 973
 974         port_sofrint((void *)port);
 975         schedule_work(&port->work);
 976 }
 977
 978 static void ProcessRxChar(struct usb_serial_port *port, unsigned char Data)
 979 {
 980         struct tty_struct *tty;
 981         struct urb *urb = port->read_urb;
 982         tty = port->tty;
 983         /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
 984
 985         if (tty && urb->actual_length) {
 986                 tty_buffer_request_room(tty, 1);
 987                 tty_insert_flip_string(tty, &Data, 1);
 988                 /* tty_flip_buffer_push(tty); */
 989         }
 990
 991         return;
 992 }
 993
 994 static void ProcessLineStatus(struct usb_serial_port *port,
 995                               unsigned char line_status)
 996 {
 997
 998         port->shadowLSR =
 999             line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
1000                            SERIAL_LSR_BI);
1001         return;
1002 }
1003
1004 static void ProcessModemStatus(struct usb_serial_port *port,
1005                                unsigned char modem_status)
1006 {
1007
1008         port->shadowMSR = modem_status;
1009         wake_up_interruptible(&port->wait);
1010         return;
1011 }
1012
1013 static void serqt_usb_disconnect(struct usb_interface *interface)
1014 {
1015         struct usb_serial *serial = usb_get_intfdata(interface);
1016         /* struct device *dev = &interface->dev; */
1017         struct usb_serial_port *port;
1018         int i;
1019
1020         mydbg("%s\n", __func__);
1021         if (serial) {
1022
1023                 serial->dev = NULL;
1024
1025                 for (i = 0; i < serial->num_ports; ++i)
1026                         serial->port[i].open_count = 0;
1027
1028                 for (i = 0; i < serial->num_bulk_in; ++i) {
1029                         port = &serial->port[i];
1030                         usb_unlink_urb(port->read_urb);
1031                         usb_free_urb(port->read_urb);
1032                         kfree(port->bulk_in_buffer);
1033                 }
1034                 for (i = 0; i < serial->num_bulk_out; ++i) {
1035                         port = &serial->port[i];
1036                         usb_unlink_urb(port->write_urb);
1037                         usb_free_urb(port->write_urb);
1038                         kfree(port->bulk_out_buffer);
1039                 }
1040                 for (i = 0; i < serial->num_interrupt_in; ++i) {
1041                         port = &serial->port[i];
1042                         usb_unlink_urb(port->interrupt_in_urb);
1043                         usb_free_urb(port->interrupt_in_urb);
1044                         kfree(port->interrupt_in_buffer);
1045         }
1046
1047                 /* return the minor range that this device had */
1048                 return_serial(serial);
1049
1050                 /* free up any memory that we allocated */
1051                 kfree(serial);
1052
1053         } else {
1054                 dev_info(&interface->dev, "device disconnected");
1055         }
1056
1057 }
1058
1059 static struct usb_serial *get_serial_by_minor(unsigned int minor)
1060 {
1061         return serial_table[minor];
1062 }
1063
1064 /*****************************************************************************
1065  * Driver tty interface functions
1066  *****************************************************************************/
1067 static int serial_open(struct tty_struct *tty, struct file *filp)
1068 {
1069         struct usb_serial *serial;
1070         struct usb_serial_port *port;
1071         unsigned int portNumber;
1072         int retval = 0;
1073
1074         mydbg("%s\n", __func__);
1075
1076         /* initialize the pointer incase something fails */
1077         tty->driver_data = NULL;
1078
1079         /* get the serial object associated with this tty pointer */
1080         /* serial = get_serial_by_minor (MINOR(tty->device)); */
1081
1082         /* get the serial object associated with this tty pointer */
1083         serial = get_serial_by_minor(tty->index);
1084
1085         if (serial_paranoia_check(serial, __func__))
1086                 return -ENODEV;
1087
1088         /* set up our port structure making the tty driver remember our port object, and us it */
1089         portNumber = tty->index - serial->minor;
1090         port = &serial->port[portNumber];
1091         tty->driver_data = port;
1092
1093         down(&port->sem);
1094         port->tty = tty;
1095
1096         ++port->open_count;
1097         if (port->open_count == 1) {
1098                 port->closePending = 0;
1099                 mydbg("%s port->closepending = 0\n", __func__);
1100
1101                 port->RxHolding = 0;
1102                 mydbg("%s port->RxHolding = 0\n", __func__);
1103
1104                 retval = qt_open(tty, port, filp);
1105         }
1106
1107         if (retval)
1108                 port->open_count = 0;
1109         mydbg("%s returning port->closePending  = %d\n", __func__,
1110               port->closePending);
1111
1112         up(&port->sem);
1113         return retval;
1114 }
1115
1116 /*****************************************************************************
1117  *device's specific driver functions
1118  *****************************************************************************/
1119 static int qt_open(struct tty_struct *tty, struct usb_serial_port *port,
1120                                         struct file *filp)
1121 {
1122         struct usb_serial *serial = port->serial;
1123         int result = 0;
1124         unsigned int index;
1125         struct qt_get_device_data DeviceData;
1126         struct qt_open_channel_data ChannelData;
1127         unsigned short default_divisor = 0x30;          /* gives 9600 baud rate */
1128         unsigned char default_LCR = SERIAL_8_DATA;      /* 8, none , 1 */
1129         int status = 0;
1130
1131         if (port_paranoia_check(port, __func__))
1132                 return -ENODEV;
1133
1134         mydbg("%s - port %d\n", __func__, port->number);
1135
1136         index = tty->index - serial->minor;
1137
1138         status = box_get_device(serial, &DeviceData);
1139         if (status < 0) {
1140                 mydbg(__FILE__ "box_get_device failed\n");
1141                 return status;
1142         }
1143         serial->num_OpenCount++;
1144         mydbg("%s serial->num_OpenCount  = %d\n", __func__,
1145               serial->num_OpenCount);
1146         /* Open uart channel */
1147
1148         /* Port specific setups */
1149         status = BoxOPenCloseChannel(serial, index, 1, &ChannelData);
1150         if (status < 0) {
1151                 mydbg(__FILE__ "BoxOPenCloseChannel failed\n");
1152                 return status;
1153         }
1154         mydbg(__FILE__ "BoxOPenCloseChannel completed.\n");
1155
1156         port->shadowLSR = ChannelData.line_status &
1157             (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
1158
1159         port->shadowMSR = ChannelData.modem_status &
1160             (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
1161
1162         /* Set Baud rate to default and turn off (default)flow control here */
1163         status = BoxSetUart(serial, index, default_divisor, default_LCR);
1164         if (status < 0) {
1165                 mydbg(__FILE__ "BoxSetUart failed\n");
1166                 return status;
1167         }
1168         mydbg(__FILE__ "BoxSetUart completed.\n");
1169
1170         /* Put this here to make it responsive to stty and defauls set by the tty layer */
1171         qt_set_termios(tty, port, NULL);
1172
1173         /* Initialize the wait que head */
1174         init_waitqueue_head(&(port->wait));
1175
1176         /* if we have a bulk endpoint, start reading from it */
1177         if (serial->num_bulk_in) {
1178                 /* Start reading from the device */
1179                 usb_fill_bulk_urb(port->read_urb, serial->dev,
1180                                   usb_rcvbulkpipe(serial->dev,
1181                                                   port->
1182                                                   bulk_in_endpointAddress),
1183                                   port->read_urb->transfer_buffer,
1184                                   port->read_urb->transfer_buffer_length,
1185                                   qt_read_bulk_callback, port);
1186
1187                 port->ReadBulkStopped = 0;
1188
1189                 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1190
1191                 if (result) {
1192                         err("%s - failed resubmitting read urb, error %d\n",
1193                             __func__, result);
1194                         port->ReadBulkStopped = 1;
1195                 }
1196
1197         }
1198
1199         return result;
1200 }
1201
1202 static void serial_close(struct tty_struct *tty, struct file *filp)
1203 {
1204         struct usb_serial_port *port =
1205             tty->driver_data;
1206         struct usb_serial *serial = get_usb_serial(port, __func__);
1207
1208         if (!serial)
1209                 return;
1210
1211         down(&port->sem);
1212
1213         mydbg("%s - port %d\n", __func__, port->number);
1214
1215         /* if disconnect beat us to the punch here, there's nothing to do */
1216         if (tty->driver_data) {
1217                 if (!port->open_count) {
1218                         mydbg("%s - port not opened\n", __func__);
1219                         goto exit;
1220                 }
1221
1222                 --port->open_count;
1223                 if (port->open_count <= 0) {
1224                         port->closePending = 1;
1225                         mydbg("%s - port->closePending = 1\n", __func__);
1226
1227                         if (serial->dev) {
1228                                 qt_close(tty, port, filp);
1229                                 port->open_count = 0;
1230                         }
1231                 }
1232
1233         }
1234
1235 exit:
1236         up(&port->sem);
1237
1238         mydbg("%s - %d return\n", __func__, port->number);
1239
1240 }
1241
1242 static void qt_close(struct tty_struct *tty, struct usb_serial_port *port,
1243                                                         struct file *filp)
1244 {
1245         unsigned long jift = jiffies + 10 * HZ;
1246         u8 lsr, mcr;
1247         struct usb_serial *serial = port->serial;
1248         int status;
1249         unsigned int index;
1250
1251         struct qt_open_channel_data ChannelData;
1252         status = 0;
1253         lsr = 0;
1254
1255         mydbg("%s - port %d\n", __func__, port->number);
1256         index = tty->index - serial->minor;
1257
1258         /* shutdown any bulk reads that might be going on */
1259         if (serial->num_bulk_out)
1260                 usb_unlink_urb(port->write_urb);
1261         if (serial->num_bulk_in)
1262                 usb_unlink_urb(port->read_urb);
1263
1264         /* wait up to 30 seconds for transmitter to empty */
1265         do {
1266                 status = BoxGetRegister(serial, index, LINE_STATUS_REGISTER, &lsr);
1267                 if (status < 0) {
1268                         mydbg(__FILE__ "box_get_device failed\n");
1269                         break;
1270                 }
1271
1272                 if ((lsr & SERIAL_LSR_TEMT)
1273                     && (port->ReadBulkStopped == 1))
1274                         break;
1275                 schedule();
1276
1277         }
1278         while (jiffies <= jift);
1279
1280         if (jiffies > jift)
1281                 mydbg("%s - port %d timout of checking transmitter empty\n",
1282                       __func__, port->number);
1283         else
1284                 mydbg("%s - port %d checking transmitter empty succeded\n",
1285                       __func__, port->number);
1286
1287         status =
1288             BoxGetRegister(serial, index, MODEM_CONTROL_REGISTER,
1289                            &mcr);
1290         mydbg(__FILE__ "BoxGetRegister MCR = 0x%x.\n", mcr);
1291
1292         if (status >= 0) {
1293                 mcr &= ~(SERIAL_MCR_DTR | SERIAL_MCR_RTS);
1294                 /* status = BoxSetRegister(serial, index, MODEM_CONTROL_REGISTER, mcr); */
1295         }
1296
1297         /* Close uart channel */
1298         status = BoxOPenCloseChannel(serial, index, 0, &ChannelData);
1299         if (status < 0)
1300                 mydbg("%s - port %d BoxOPenCloseChannel failed.\n",
1301                       __func__, port->number);
1302
1303         serial->num_OpenCount--;
1304
1305 }
1306
1307 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
1308                         int count)
1309 {
1310         struct usb_serial_port *port = tty->driver_data;
1311         struct usb_serial *serial;
1312         int retval = -EINVAL;
1313         unsigned int index;
1314
1315         serial = get_usb_serial(port, __func__);
1316         if (serial == NULL)
1317                 return -ENODEV;
1318         /* This can happen if we get disconnected a */
1319         if (port->open_count == 0)
1320                 return -ENODEV;
1321         index = tty->index - serial->minor;
1322
1323         mydbg("%s - port %d, %d byte(s)\n", __func__, port->number, count);
1324         mydbg("%s - port->RxHolding =  %d\n", __func__, port->RxHolding);
1325
1326         if (!port->open_count) {
1327                 mydbg("%s - port not opened\n", __func__);
1328                 goto exit;
1329         }
1330
1331         retval = qt_write(tty, port, buf, count);
1332
1333 exit:
1334         return retval;
1335 }
1336
1337 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1338                                 const unsigned char *buf, int count)
1339 {
1340         int result;
1341         unsigned int index;
1342         struct usb_serial *serial = get_usb_serial(port, __func__);
1343
1344         if (serial == NULL)
1345                 return -ENODEV;
1346
1347         mydbg("%s - port %d\n", __func__, port->number);
1348
1349         if (count == 0) {
1350                 mydbg("%s - write request of 0 bytes\n", __func__);
1351                 return 0;
1352         }
1353
1354         index = tty->index - serial->minor;
1355         /* only do something if we have a bulk out endpoint */
1356         if (serial->num_bulk_out) {
1357                 if (port->write_urb->status == -EINPROGRESS) {
1358                         mydbg("%s - already writing\n", __func__);
1359                         return 0;
1360                 }
1361
1362                 count =
1363                     (count > port->bulk_out_size) ? port->bulk_out_size : count;
1364                 memcpy(port->write_urb->transfer_buffer, buf, count);
1365
1366                 /* usb_serial_debug_data(__FILE__, __func__, count, port->write_urb->transfer_buffer); */
1367
1368                 /* set up our urb */
1369
1370                 usb_fill_bulk_urb(port->write_urb, serial->dev,
1371                                   usb_sndbulkpipe(serial->dev,
1372                                                   port->
1373                                                   bulk_out_endpointAddress),
1374                                   port->write_urb->transfer_buffer, count,
1375                                   qt_write_bulk_callback, port);
1376
1377                 /* send the data out the bulk port */
1378                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1379                 if (result)
1380                         mydbg("%s - failed submitting write urb, error %d\n",
1381                               __func__, result);
1382                 else
1383                         result = count;
1384
1385                 return result;
1386         }
1387
1388         /* no bulk out, so return 0 bytes written */
1389         return 0;
1390 }
1391
1392 static void qt_write_bulk_callback(struct urb *urb)
1393 {
1394         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1395         struct usb_serial *serial = get_usb_serial(port, __func__);
1396
1397         mydbg("%s - port %d\n", __func__, port->number);
1398
1399         if (!serial) {
1400                 mydbg("%s - bad serial pointer, exiting\n", __func__);
1401                 return;
1402         }
1403
1404         if (urb->status) {
1405                 mydbg("%s - nonzero write bulk status received: %d\n",
1406                       __func__, urb->status);
1407                 return;
1408         }
1409         port_softint(&port->work);
1410         schedule_work(&port->work);
1411
1412         return;
1413 }
1414
1415 static void port_softint(struct work_struct *work)
1416 {
1417         struct usb_serial_port *port =
1418             container_of(work, struct usb_serial_port, work);
1419         struct usb_serial *serial = get_usb_serial(port, __func__);
1420         struct tty_struct *tty;
1421
1422         mydbg("%s - port %d\n", __func__, port->number);
1423
1424         if (!serial)
1425                 return;
1426
1427         tty = port->tty;
1428         if (!tty)
1429                 return;
1430 #if 0
1431         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP))
1432             && tty->ldisc.write_wakeup) {
1433                 mydbg("%s - write wakeup call.\n", __func__);
1434                 (tty->ldisc.write_wakeup) (tty);
1435         }
1436 #endif
1437
1438         wake_up_interruptible(&tty->write_wait);
1439 }
1440 static int serial_write_room(struct tty_struct *tty)
1441 {
1442         struct usb_serial_port *port = tty->driver_data;
1443         struct usb_serial *serial = get_usb_serial(port, __func__);
1444         int retval = -EINVAL;
1445
1446         if (!serial)
1447                 return -ENODEV;
1448
1449         down(&port->sem);
1450
1451         mydbg("%s - port %d\n", __func__, port->number);
1452
1453         if (!port->open_count) {
1454                 mydbg("%s - port not open\n", __func__);
1455                 goto exit;
1456         }
1457
1458         retval = qt_write_room(port);
1459
1460 exit:
1461         up(&port->sem);
1462         return retval;
1463 }
1464 static int qt_write_room(struct usb_serial_port *port)
1465 {
1466         struct usb_serial *serial = port->serial;
1467         int room = 0;
1468         if (port->closePending == 1) {
1469                 mydbg("%s - port->closePending == 1\n", __func__);
1470                 return -ENODEV;
1471         }
1472
1473         mydbg("%s - port %d\n", __func__, port->number);
1474
1475         if (serial->num_bulk_out) {
1476                 if (port->write_urb->status != -EINPROGRESS)
1477                         room = port->bulk_out_size;
1478         }
1479
1480         mydbg("%s - returns %d\n", __func__, room);
1481         return room;
1482 }
1483 static int serial_chars_in_buffer(struct tty_struct *tty)
1484 {
1485         struct usb_serial_port *port = tty->driver_data;
1486         struct usb_serial *serial = get_usb_serial(port, __func__);
1487         int retval = -EINVAL;
1488
1489         if (!serial)
1490                 return -ENODEV;
1491
1492         down(&port->sem);
1493
1494         mydbg("%s = port %d\n", __func__, port->number);
1495
1496         if (!port->open_count) {
1497                 mydbg("%s - port not open\n", __func__);
1498                 goto exit;
1499         }
1500
1501         retval = qt_chars_in_buffer(port);
1502
1503 exit:
1504         up(&port->sem);
1505         return retval;
1506 }
1507
1508 static int qt_chars_in_buffer(struct usb_serial_port *port)
1509 {
1510         struct usb_serial *serial = port->serial;
1511         int chars = 0;
1512
1513         mydbg("%s - port %d\n", __func__, port->number);
1514
1515         if (serial->num_bulk_out) {
1516                 if (port->write_urb->status == -EINPROGRESS)
1517                         chars = port->write_urb->transfer_buffer_length;
1518         }
1519
1520         mydbg("%s - returns %d\n", __func__, chars);
1521         return chars;
1522 }
1523
1524 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
1525                            unsigned int set, unsigned int clear)
1526 {
1527
1528         struct usb_serial_port *port = tty->driver_data;
1529         struct usb_serial *serial = get_usb_serial(port, __func__);
1530         int retval = -ENODEV;
1531         unsigned int index;
1532         mydbg("In %s \n", __func__);
1533
1534         if (!serial)
1535                 return -ENODEV;
1536
1537         index = tty->index - serial->minor;
1538
1539         down(&port->sem);
1540
1541         mydbg("%s - port %d \n", __func__, port->number);
1542         mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1543
1544         if (!port->open_count) {
1545                 mydbg("%s - port not open\n", __func__);
1546                 goto exit;
1547         }
1548
1549         retval = qt_tiocmset(tty, port, file, set);
1550
1551 exit:
1552         up(&port->sem);
1553         return retval;
1554 }
1555
1556 static int qt_tiocmset(struct tty_struct *tty, struct usb_serial_port *port,
1557                        struct file *file, unsigned int value)
1558 {
1559
1560         u8 mcr;
1561         int status;
1562         unsigned int index;
1563         struct usb_serial *serial = get_usb_serial(port, __func__);
1564
1565         if (serial == NULL)
1566                 return -ENODEV;
1567
1568         mydbg("%s - port %d\n", __func__, port->number);
1569
1570     /**************************************************************************************/
1571     /**  TIOCMGET
1572      */
1573         index = tty->index - serial->minor;
1574         status =
1575             BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1576                            &mcr);
1577         if (status < 0)
1578                 return -ESPIPE;
1579
1580         /*
1581          * Turn off the RTS and DTR and loopbcck and then only turn on what was
1582          * asked for
1583          */
1584         mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1585         if (value & TIOCM_RTS)
1586                 mcr |= SERIAL_MCR_RTS;
1587         if (value & TIOCM_DTR)
1588                 mcr |= SERIAL_MCR_DTR;
1589         if (value & TIOCM_LOOP)
1590                 mcr |= SERIAL_MCR_LOOP;
1591
1592         status =
1593             BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1594                            mcr);
1595         if (status < 0)
1596                 return -ESPIPE;
1597         else
1598                 return 0;
1599 }
1600
1601 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
1602 {
1603
1604         struct usb_serial_port *port = tty->driver_data;
1605         struct usb_serial *serial = get_usb_serial(port, __func__);
1606         int retval = -ENODEV;
1607         unsigned int index;
1608         mydbg("In %s \n", __func__);
1609
1610         if (!serial)
1611                 return -ENODEV;
1612
1613         index = tty->index - serial->minor;
1614
1615         down(&port->sem);
1616
1617         mydbg("%s - port %d\n", __func__, port->number);
1618         mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1619
1620         if (!port->open_count) {
1621                 mydbg("%s - port not open\n", __func__);
1622                 goto exit;
1623         }
1624
1625         retval = qt_tiocmget(tty, port, file);
1626
1627 exit:
1628         up(&port->sem);
1629         return retval;
1630 }
1631
1632 static int qt_tiocmget(struct tty_struct *tty,
1633                         struct usb_serial_port *port, struct file *file)
1634 {
1635
1636         u8 mcr;
1637         u8 msr;
1638         unsigned int result = 0;
1639         int status;
1640         unsigned int index;
1641
1642         struct usb_serial *serial = get_usb_serial(port, __func__);
1643         if (serial == NULL)
1644                 return -ENODEV;
1645
1646         mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1647
1648     /**************************************************************************************/
1649     /**  TIOCMGET
1650      */
1651         index = tty->index - serial->minor;
1652         status =
1653             BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER,
1654                            &mcr);
1655         if (status >= 0) {
1656                 status =
1657                     BoxGetRegister(port->serial, index,
1658                                    MODEM_STATUS_REGISTER, &msr);
1659
1660         }
1661
1662         if (status >= 0) {
1663                 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1664                     /* DTR IS SET */
1665                     | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1666                     /* RTS IS SET */
1667                     | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1668                     /* CTS is set */
1669                     | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1670                     /* Carrier detect is set */
1671                     | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1672                     /* Ring indicator set */
1673                     | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1674                 /* DSR is set */
1675                 return result;
1676
1677         } else
1678                 return -ESPIPE;
1679 }
1680
1681 static int serial_ioctl(struct tty_struct *tty, struct file *file,
1682                         unsigned int cmd, unsigned long arg)
1683 {
1684
1685         struct usb_serial_port *port = tty->driver_data;
1686         struct usb_serial *serial = get_usb_serial(port, __func__);
1687         int retval = -ENODEV;
1688         unsigned int index;
1689         mydbg("In %s \n", __func__);
1690
1691         if (!serial)
1692                 return -ENODEV;
1693
1694         index = tty->index - serial->minor;
1695
1696         down(&port->sem);
1697
1698         mydbg("%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd);
1699         mydbg("%s - port->RxHolding = %d\n", __func__, port->RxHolding);
1700
1701         if (!port->open_count) {
1702                 mydbg("%s - port not open\n", __func__);
1703                 goto exit;
1704         }
1705
1706         retval = qt_ioctl(tty, port, file, cmd, arg);
1707
1708 exit:
1709         up(&port->sem);
1710         return retval;
1711 }
1712 static int qt_ioctl(struct tty_struct *tty, struct usb_serial_port *port,
1713                         struct file *file, unsigned int cmd, unsigned long arg)
1714 {
1715         __u8 mcr;
1716         __u8 msr;
1717         unsigned short prev_msr;
1718         unsigned int value, result = 0;
1719         int status;
1720         unsigned int index;
1721
1722         struct usb_serial *serial = get_usb_serial(port, __func__);
1723         if (serial == NULL)
1724                 return -ENODEV;
1725
1726         mydbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1727
1728         /* TIOCMGET */
1729         index = tty->index - serial->minor;
1730
1731         if (cmd == TIOCMIWAIT) {
1732                 DECLARE_WAITQUEUE(wait, current);
1733                 prev_msr = port->shadowMSR & SERIAL_MSR_MASK;
1734                 while (1) {
1735                         add_wait_queue(&port->wait, &wait);
1736                         set_current_state(TASK_INTERRUPTIBLE);
1737                         schedule();
1738                         remove_wait_queue(&port->wait, &wait);
1739                         /* see if a signal woke us up */
1740                         if (signal_pending(current))
1741                                 return -ERESTARTSYS;
1742                         msr = port->shadowMSR & SERIAL_MSR_MASK;
1743                         if (msr == prev_msr)
1744                                 return -EIO;    /* no change error */
1745
1746                         if ((arg & TIOCM_RNG
1747                              && ((prev_msr & SERIAL_MSR_RI) ==
1748                                  (msr & SERIAL_MSR_RI)))
1749                             || (arg & TIOCM_DSR
1750                                 && ((prev_msr & SERIAL_MSR_DSR) ==
1751                                     (msr & SERIAL_MSR_DSR)))
1752                             || (arg & TIOCM_CD
1753                                 && ((prev_msr & SERIAL_MSR_CD) ==
1754                                     (msr & SERIAL_MSR_CD)))
1755                             || (arg & TIOCM_CTS
1756                                 && ((prev_msr & SERIAL_MSR_CTS) ==
1757                                     (msr & SERIAL_MSR_CTS)))) {
1758                                 return 0;
1759                         }
1760
1761                 }
1762
1763         }
1764         mydbg("%s -No ioctl for that one.  port = %d\n", __func__,
1765               port->number);
1766
1767         return -ENOIOCTLCMD;
1768 }
1769
1770 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
1771 {
1772         struct usb_serial_port *port =
1773             tty->driver_data;
1774         struct usb_serial *serial = get_usb_serial(port, __func__);
1775
1776         if (!serial)
1777                 return;
1778
1779         down(&port->sem);
1780
1781         mydbg("%s - port %d\n", __func__, port->number);
1782
1783         if (!port->open_count) {
1784                 mydbg("%s - port not open\n", __func__);
1785                 goto exit;
1786         }
1787
1788         /* pass on to the driver specific version of this function if it is available */
1789         qt_set_termios(tty, port, old);
1790
1791 exit:
1792         up(&port->sem);
1793 }
1794
1795 static void qt_set_termios(struct tty_struct *tty,
1796                            struct usb_serial_port *port,
1797                            struct ktermios *old_termios)
1798 {
1799         unsigned int cflag;
1800         int baud, divisor, remainder;
1801         unsigned char new_LCR = 0;
1802         int status;
1803         struct usb_serial *serial;
1804         __u16 index;
1805         __u16 tmp, tmp2;
1806
1807         mydbg("%s - port %d\n", __func__, port->number);
1808
1809         tmp = port->tty->index;
1810         mydbg("%s - MINOR(port->tty->index) =  %d\n", __func__, tmp);
1811
1812         serial = port->serial;
1813         tmp2 = serial->minor;
1814         mydbg("%s - serial->minor =  %d\n", __func__, tmp2);
1815
1816         index = port->tty->index - serial->minor;
1817
1818         cflag = tty->termios->c_cflag;
1819
1820         mydbg("%s - 3\n", __func__);
1821
1822         switch (cflag) {
1823         case CS5:
1824                 new_LCR |= SERIAL_5_DATA;
1825                 break;
1826         case CS6:
1827                 new_LCR |= SERIAL_6_DATA;
1828                 break;
1829         case CS7:
1830                 new_LCR |= SERIAL_7_DATA;
1831                 break;
1832         default:
1833         case CS8:
1834                 new_LCR |= SERIAL_8_DATA;
1835                 break;
1836         }
1837
1838         /* Parity stuff */
1839         if (cflag & PARENB) {
1840                 if (cflag & PARODD)
1841                         new_LCR |= SERIAL_ODD_PARITY;
1842                 else
1843                         new_LCR |= SERIAL_EVEN_PARITY;
1844         }
1845         if (cflag & CSTOPB)
1846                 new_LCR |= SERIAL_TWO_STOPB;
1847         else
1848                 new_LCR |= SERIAL_TWO_STOPB;
1849
1850         mydbg("%s - 4\n", __func__);
1851         /* Thats the LCR stuff, go ahead and set it */
1852         baud = tty_get_baud_rate(tty);
1853         if (!baud)
1854                 /* pick a default, any default... */
1855                 baud = 9600;
1856
1857         mydbg("%s - got baud = %d\n", __func__, baud);
1858
1859         divisor = MAX_BAUD_RATE / baud;
1860         remainder = MAX_BAUD_RATE % baud;
1861         /* Round to nearest divisor */
1862         if (((remainder * 2) >= baud) && (baud != 110))
1863                 divisor++;
1864
1865         /*
1866          * Set Baud rate to default and turn off (default)flow control here
1867          */
1868         status = BoxSetUart(serial, index, (unsigned short)divisor, new_LCR);
1869         if (status < 0) {
1870                 mydbg(__FILE__ "BoxSetUart failed\n");
1871                 return;
1872         }
1873
1874         /* Now determine flow control */
1875         if (cflag & CRTSCTS) {
1876                 mydbg("%s - Enabling HW flow control port %d\n", __func__,
1877                       port->number);
1878
1879                 /* Enable RTS/CTS flow control */
1880                 status = BoxSetHW_FlowCtrl(serial, index, 1);
1881
1882                 if (status < 0) {
1883                         mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1884                         return;
1885                 }
1886         } else {
1887                 /* Disable RTS/CTS flow control */
1888                 mydbg("%s - disabling HW flow control port %d\n", __func__,
1889                       port->number);
1890
1891                 status = BoxSetHW_FlowCtrl(serial, index, 0);
1892                 if (status < 0) {
1893                         mydbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1894                         return;
1895                 }
1896
1897         }
1898
1899         /* if we are implementing XON/XOFF, set the start and stop character in
1900          * the device */
1901         if (I_IXOFF(tty) || I_IXON(tty)) {
1902                 unsigned char stop_char = STOP_CHAR(tty);
1903                 unsigned char start_char = START_CHAR(tty);
1904                 status =
1905                     BoxSetSW_FlowCtrl(serial, index, stop_char,
1906                                       start_char);
1907                 if (status < 0)
1908                         mydbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
1909
1910         } else {
1911                 /* disable SW flow control */
1912                 status = BoxDisable_SW_FlowCtrl(serial, index);
1913                 if (status < 0)
1914                         mydbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
1915
1916         }
1917         tty->termios->c_cflag &= ~CMSPAR;
1918         /* FIXME: Error cases should be returning the actual bits changed only */
1919 }
1920
1921 /****************************************************************************
1922 * BoxGetRegister
1923 *       issuse a GET_REGISTER vendor-spcific request on the default control pipe
1924 *       If successful, fills in the  pValue with the register value asked for
1925 ****************************************************************************/
1926 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
1927                           unsigned short Register_Num, __u8 *pValue)
1928 {
1929         int result;
1930         __u16 current_length;
1931
1932         current_length = sizeof(struct qt_get_device_data);
1933
1934         result =
1935             usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1936                             QT_GET_SET_REGISTER, 0xC0, Register_Num,
1937                             Uart_Number, (void *)pValue, sizeof(*pValue), 300);
1938
1939         return result;
1940 }
1941
1942 /****************************************************************************
1943 * BoxSetRegister
1944 *       issuse a GET_REGISTER vendor-spcific request on the default control pipe
1945 *       If successful, fills in the  pValue with the register value asked for
1946 ****************************************************************************/
1947 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
1948                           unsigned short Register_Num, unsigned short Value)
1949 {
1950         int result;
1951         unsigned short RegAndByte;
1952
1953         RegAndByte = Value;
1954         RegAndByte = RegAndByte << 8;
1955         RegAndByte = RegAndByte + Register_Num;
1956
1957 /*
1958         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1959                                  QT_GET_SET_REGISTER, 0xC0, Register_Num,
1960                                  Uart_Number, NULL, 0, 300);
1961 */
1962
1963         result =
1964             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1965                             QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
1966                             NULL, 0, 300);
1967
1968         return result;
1969 }
1970
1971 /**
1972  * box_get_device
1973  *   Issue a GET_DEVICE vendor-specific request on the default control pipe If
1974  *   successful, fills in the qt_get_device_data structure pointed to by
1975  *   device_data, otherwise return a negative error number of the problem.
1976  */
1977 static int box_get_device(struct usb_serial *serial,
1978                           struct qt_get_device_data *device_data)
1979 {
1980         int result;
1981         __u16 current_length;
1982         unsigned char *transfer_buffer;
1983
1984         current_length = sizeof(struct qt_get_device_data);
1985         transfer_buffer = kmalloc(current_length, GFP_KERNEL);
1986         if (!transfer_buffer)
1987                 return -ENOMEM;
1988
1989         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1990                                  QT_SET_GET_DEVICE, 0xc0, 0, 0,
1991                                  transfer_buffer, current_length, 300);
1992         if (result > 0)
1993                 memcpy(device_data, transfer_buffer, current_length);
1994         kfree(transfer_buffer);
1995
1996         return result;
1997 }
1998
1999 /**
2000  * box_set_device
2001  *   Issue a SET_DEVICE vendor-specific request on the default control pipe If
2002  *   successful returns the number of bytes written, otherwise it returns a
2003  *   negative error number of the problem.
2004  */
2005 static int box_set_device(struct usb_serial *serial,
2006                           struct qt_get_device_data *device_data)
2007 {
2008         int result;
2009         __u16 length;
2010         __u16 PortSettings;
2011
2012         PortSettings = ((__u16) (device_data->portb));
2013         PortSettings = (PortSettings << 8);
2014         PortSettings += ((__u16) (device_data->porta));
2015
2016         length = sizeof(struct qt_get_device_data);
2017         mydbg("%s - PortSettings = 0x%x\n", __func__, PortSettings);
2018
2019         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2020                                  QT_SET_GET_DEVICE, 0x40, PortSettings,
2021                                  0, NULL, 0, 300);
2022         return result;
2023 }
2024
2025 /****************************************************************************
2026  * BoxOPenCloseChannel
2027  * This funciotn notifies the device that the device driver wishes to open a particular UART channel. its
2028  * purpose is to allow the device driver and the device to synchronize state information.
2029  * OpenClose = 1 for open , 0 for close
2030   ****************************************************************************/
2031 static int BoxOPenCloseChannel(struct usb_serial *serial, __u16 Uart_Number,
2032                                __u16 OpenClose,
2033                                struct qt_open_channel_data *pDeviceData)
2034 {
2035         int result;
2036         __u16 length;
2037         __u8 Direcion;
2038         unsigned int pipe;
2039         length = sizeof(struct qt_open_channel_data);
2040
2041         /* if opening... */
2042         if (OpenClose == 1) {
2043                 Direcion = USBD_TRANSFER_DIRECTION_IN;
2044                 pipe = usb_rcvctrlpipe(serial->dev, 0);
2045                 result =
2046                     usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2047                                     Direcion, OpenClose, Uart_Number,
2048                                     pDeviceData, length, 300);
2049
2050         } else {
2051                 Direcion = USBD_TRANSFER_DIRECTION_OUT;
2052                 pipe = usb_sndctrlpipe(serial->dev, 0);
2053                 result =
2054                     usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
2055                                     Direcion, OpenClose, Uart_Number, NULL, 0,
2056                                     300);
2057
2058         }
2059
2060         return result;
2061 }
2062
2063 /****************************************************************************
2064  *  BoxSetPrebufferLevel
2065    TELLS BOX WHEN TO ASSERT FLOW CONTROL
2066  ****************************************************************************/
2067 static int BoxSetPrebufferLevel(struct usb_serial *serial)
2068 {
2069         int result;
2070         __u16 buffer_length;
2071
2072         buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2073         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2074                                  QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
2075                                  buffer_length, 0, NULL, 0, 300);
2076         return result;
2077 }
2078
2079 /****************************************************************************
2080  *  BoxSetATC
2081    TELLS BOX WHEN TO ASSERT automatic transmitter control
2082    ****************************************************************************/
2083 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
2084 {
2085         int result;
2086         __u16 buffer_length;
2087
2088         buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
2089
2090         result =
2091             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2092                             QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
2093
2094         return result;
2095 }
2096
2097 /****************************************************************************
2098 * BoxSetUart
2099 *       issuse a SET_UART vendor-spcific request on the default control pipe
2100 *       If successful sets baud rate divisor and LCR value
2101 ****************************************************************************/
2102 static int BoxSetUart(struct usb_serial *serial, unsigned short Uart_Number,
2103                       unsigned short default_divisor, unsigned char default_LCR)
2104 {
2105         int result;
2106         unsigned short UartNumandLCR;
2107
2108         UartNumandLCR = (default_LCR << 8) + Uart_Number;
2109
2110         result =
2111             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2112                             QT_GET_SET_UART, 0x40, default_divisor,
2113                             UartNumandLCR, NULL, 0, 300);
2114
2115         return result;
2116 }
2117
2118 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
2119                              int bSet)
2120 {
2121         __u8 mcr = 0;
2122         __u8 msr = 0, MOUT_Value = 0;
2123         struct usb_serial_port *port;
2124         unsigned int status;
2125
2126         port = serial->port;
2127
2128         if (bSet == 1) {
2129                 /* flow control, box will clear RTS line to prevent remote */
2130                 mcr = SERIAL_MCR_RTS;
2131         }                       /* device from xmitting more chars */
2132         else {
2133                 /* no flow control to remote device */
2134                 mcr = 0;
2135
2136         }
2137         MOUT_Value = mcr << 8;
2138
2139         if (bSet == 1) {
2140                 /* flow control, box will inhibit xmit data if CTS line is
2141                  * asserted */
2142                 msr = SERIAL_MSR_CTS;
2143         } else {
2144                 /* Box will not inhimbe xmit data due to CTS line */
2145                 msr = 0;
2146         }
2147         MOUT_Value |= msr;
2148
2149         status =
2150             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2151                             QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
2152                             index, NULL, 0, 300);
2153         return status;
2154
2155 }
2156
2157 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
2158                              unsigned char stop_char, unsigned char start_char)
2159 {
2160         __u16 nSWflowout;
2161         int result;
2162
2163         nSWflowout = start_char << 8;
2164         nSWflowout = (unsigned short)stop_char;
2165
2166         result =
2167             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2168                             QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
2169                             index, NULL, 0, 300);
2170         return result;
2171
2172 }
2173 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
2174 {
2175         int result;
2176
2177         result =
2178             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2179                             QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
2180                             NULL, 0, 300);
2181         return result;
2182
2183 }
2184
2185 static void serial_throttle(struct tty_struct *tty)
2186 {
2187         struct usb_serial_port *port =
2188             tty->driver_data;
2189         struct usb_serial *serial = get_usb_serial(port, __func__);
2190         mydbg("%s - port %d\n", __func__, port->number);
2191
2192         if (!serial)
2193                 return;
2194
2195         down(&port->sem);
2196
2197         if (!port->open_count) {
2198                 mydbg("%s - port not open\n", __func__);
2199                 goto exit;
2200         }
2201         /* shut down any bulk reads that may be going on */
2202 /*      usb_unlink_urb (port->read_urb); */
2203         /* pass on to the driver specific version of this function */
2204         port->RxHolding = 1;
2205         mydbg("%s - port->RxHolding = 1\n", __func__);
2206
2207 exit:
2208         up(&port->sem);
2209         return;
2210 }
2211
2212 static void serial_unthrottle(struct tty_struct *tty)
2213 {
2214         struct usb_serial_port *port =
2215             tty->driver_data;
2216         struct usb_serial *serial = get_usb_serial(port, __func__);
2217         unsigned int result;
2218
2219         if (!serial)
2220                 return;
2221         down(&port->sem);
2222
2223         mydbg("%s - port %d\n", __func__, port->number);
2224
2225         if (!port->open_count) {
2226                 mydbg("%s - port not open\n", __func__);
2227                 goto exit;
2228         }
2229
2230         if (port->RxHolding == 1) {
2231                 mydbg("%s -port->RxHolding == 1\n", __func__);
2232
2233                 port->RxHolding = 0;
2234                 mydbg("%s - port->RxHolding = 0\n", __func__);
2235
2236                 /* if we have a bulk endpoint, start it up */
2237                 if ((serial->num_bulk_in) && (port->ReadBulkStopped == 1)) {
2238                         /* Start reading from the device */
2239                         usb_fill_bulk_urb(port->read_urb, serial->dev,
2240                                           usb_rcvbulkpipe(serial->dev,
2241                                                           port->
2242                                                           bulk_in_endpointAddress),
2243                                           port->read_urb->transfer_buffer,
2244                                           port->read_urb->
2245                                           transfer_buffer_length,
2246                                           qt_read_bulk_callback, port);
2247                         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
2248                         if (result)
2249                                 err("%s - failed restarting read urb, error %d",
2250                                     __func__, result);
2251                 }
2252         }
2253 exit:
2254         up(&port->sem);
2255         return;
2256
2257 }
2258
2259 static int serial_break(struct tty_struct *tty, int break_state)
2260 {
2261         struct usb_serial_port *port = tty->driver_data;
2262         struct usb_serial *serial = get_usb_serial(port, __func__);
2263         u16 index, onoff;
2264         unsigned int result;
2265
2266         index = tty->index - serial->minor;
2267         if (!serial)
2268                 return -ENODEV;
2269
2270         if (break_state == -1)
2271                 onoff = 1;
2272         else
2273                 onoff = 0;
2274
2275         down(&port->sem);
2276
2277         mydbg("%s - port %d\n", __func__, port->number);
2278
2279         if (!port->open_count) {
2280                 mydbg("%s - port not open\n", __func__);
2281                 goto exit;
2282         }
2283
2284         result =
2285             usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2286                             QT_BREAK_CONTROL, 0x40, onoff, index,
2287                             NULL, 0, 300);
2288
2289 exit:
2290         up(&port->sem);
2291         return 0;
2292 }
2293
2294 static int ioctl_serial_usb(struct inode *innod, struct file *filp, unsigned int cmd,
2295                      unsigned long arg)
2296 {
2297
2298         unsigned err;
2299         unsigned ucOPR_NewValue, uc_Value;
2300         int *p_Num_of_adapters, counts, index, *p_QMCR_Value;
2301         struct identity *p_Identity_of;
2302         struct identity Identity_of;
2303         struct usb_serial *lastserial, *serial;
2304
2305         mydbg(KERN_DEBUG "ioctl_serial_usb  cmd =\n");
2306         if (_IOC_TYPE(cmd) != SERIALQT_PCI_IOC_MAGIC)
2307                 return -ENOTTY;
2308         if (_IOC_NR(cmd) > SERIALQT_IOC_MAXNR)
2309                 return -ENOTTY;
2310         mydbg(KERN_DEBUG "ioctl_serial_usb  cmd = 0x%x\n", cmd);
2311         err = 0;
2312         switch (cmd) {
2313
2314         case SERIALQT_WRITE_QMCR:
2315                 err = -ENOTTY;
2316                 index = arg >> 16;
2317                 counts = 0;
2318
2319                 ucOPR_NewValue = arg;
2320
2321                 err = EmulateWriteQMCR_Reg(index, ucOPR_NewValue);
2322                 break;
2323
2324         case SERIALQT_READ_QMCR:
2325                 err = -ENOTTY;
2326                 p_QMCR_Value = (int *)arg;
2327                 index = arg >> 16;
2328                 counts = 0;
2329
2330                 err = EmulateReadQMCR_Reg(index, &uc_Value);
2331                 if (err == 0)
2332                         err = put_user(uc_Value, p_QMCR_Value);
2333                 break;
2334
2335         case SERIALQT_GET_NUMOF_UNITS:
2336                 p_Num_of_adapters = (int *)arg;
2337                 counts = 0;     /* Initialize counts to zero */
2338                 /* struct usb_serial *lastserial = serial_table[0], *serial; */
2339                 lastserial = serial_table[0];
2340
2341                 mydbg(KERN_DEBUG "SERIALQT_GET_NUMOF_UNITS \n");
2342                 /* if first pointer is nonull, we at least have one box */
2343                 if (lastserial)
2344                         counts = 1;     /* we at least have one box */
2345
2346                 for (index = 1; index < SERIAL_TTY_MINORS; index++) {
2347                         serial = serial_table[index];
2348                         if (serial) {
2349                                 if (serial != lastserial) {
2350                                         /* we had a change in the array, hence
2351                                          * another box is there */
2352                                         lastserial = serial;
2353                                         counts++;
2354                                 }
2355                         } else
2356                                 break;
2357                 }
2358
2359                 mydbg(KERN_DEBUG "ioctl_serial_usb writting counts = %d",
2360                       counts);
2361
2362                 err = put_user(counts, p_Num_of_adapters);
2363
2364                 break;
2365         case SERIALQT_GET_THIS_UNIT:
2366                 counts = 0;
2367                 p_Identity_of = (struct identity *)arg;
2368                 /* copy user structure to local variable */
2369                 get_user(Identity_of.index, &p_Identity_of->index);
2370                 mydbg(KERN_DEBUG "SERIALQT_GET_THIS_UNIT Identity_of.index\n");
2371                 mydbg(KERN_DEBUG
2372                       "SERIALQT_GET_THIS_UNIT Identity_of.index= 0x%x\n",
2373                       Identity_of.index);
2374
2375                 err = -ENOTTY;
2376                 serial = find_the_box(Identity_of.index);
2377                 if (serial) {
2378                         err =
2379                             put_user(serial->product,
2380                                      &p_Identity_of->n_identity);
2381
2382                 }
2383                 break;
2384
2385         case SERIALQT_IS422_EXTENDED:
2386                 err = -ENOTTY;
2387                 mydbg(KERN_DEBUG "SERIALQT_IS422_EXTENDED \n");
2388                 index = arg >> 16;
2389
2390                 counts = 0;
2391
2392                 mydbg(KERN_DEBUG
2393                       "SERIALQT_IS422_EXTENDED, looking Identity_of.indext = 0x%x\n",
2394                       index);
2395                 serial = find_the_box(index);
2396                 if (serial) {
2397                         mydbg("%s index = 0x%x, serial = 0x%p\n", __func__,
2398                               index, serial);
2399                         for (counts = 0; serqt_422_table[counts] != 0; counts++) {
2400
2401                                 mydbg
2402                                     ("%s serial->product = = 0x%x, serqt_422_table[counts] = 0x%x\n",
2403                                      __func__, serial->product,
2404                                      serqt_422_table[counts]);
2405                                 if (serial->product == serqt_422_table[counts]) {
2406                                         err = 0;
2407
2408                                         mydbg
2409                                             ("%s found match for 422extended\n",
2410                                              __func__);
2411                                         break;
2412                                 }
2413                         }
2414                 }
2415                 break;
2416
2417         default:
2418                 err = -ENOTTY;
2419         }
2420
2421         mydbg("%s returning err = 0x%x\n", __func__, err);
2422         return err;
2423 }
2424
2425 static struct usb_serial *find_the_box(unsigned int index)
2426 {
2427         struct usb_serial *lastserial, *foundserial, *serial;
2428         int counts = 0, index2;
2429         lastserial = serial_table[0];
2430         foundserial = NULL;
2431         for (index2 = 0; index2 < SERIAL_TTY_MINORS; index2++) {
2432                 serial = serial_table[index2];
2433
2434                 mydbg("%s index = 0x%x, index2 = 0x%x, serial = 0x%p\n",
2435                       __func__, index, index2, serial);
2436
2437                 if (serial) {
2438                         /* first see if this is the unit we'er looking for */
2439                         mydbg
2440                             ("%s inside if(serial) counts = 0x%x , index = 0x%x\n",
2441                              __func__, counts, index);
2442                         if (counts == index) {
2443                                 /* we found the one we're looking for, copythe
2444                                  * product Id to user */
2445                                 mydbg("%s we found the one we're looking for serial = 0x%p\n",
2446                                      __func__, serial);
2447                                 foundserial = serial;
2448                                 break;
2449                         }
2450
2451                         if (serial != lastserial) {
2452                                 /* when we have a change in the pointer */
2453                                 lastserial = serial;
2454                                 counts++;
2455                         }
2456                 } else
2457                         break;  /* no matches */
2458         }
2459
2460         mydbg("%s returning foundserial = 0x%p\n", __func__, foundserial);
2461         return foundserial;
2462 }
2463
2464 static int EmulateWriteQMCR_Reg(int index, unsigned uc_value)
2465 {
2466
2467         __u16 ATC_Mode = 0;
2468         struct usb_serial *serial;
2469         int status;
2470         struct qt_get_device_data DeviceData;
2471         unsigned uc_temp = 0;
2472         mydbg("Inside %s, uc_value = 0x%x\n", __func__, uc_value);
2473
2474         DeviceData.porta = 0;
2475         DeviceData.portb = 0;
2476         serial = find_the_box(index);
2477         /* Determine Duplex mode */
2478         if (!(serial))
2479                 return -ENOTTY;
2480         status = box_get_device(serial, &DeviceData);
2481         if (status < 0) {
2482                 mydbg(__FILE__ "box_set_device failed\n");
2483                 return status;
2484         }
2485
2486         uc_temp = uc_value & QMCR_HALF_DUPLEX_MASK;
2487         switch (uc_temp) {
2488         case QMCR_FULL_DUPLEX:
2489                 DeviceData.porta &= ~DUPMODE_BITS;
2490                 DeviceData.porta |= FULL_DUPLEX;
2491                 ATC_Mode = ATC_DISABLED;
2492                 break;
2493         case QMCR_HALF_DUPLEX_RTS:
2494                 DeviceData.porta &= ~DUPMODE_BITS;
2495                 DeviceData.porta |= HALF_DUPLEX_RTS;
2496                 ATC_Mode = ATC_RTS_ENABLED;
2497                 break;
2498         case QMCR_HALF_DUPLEX_DTR:
2499                 DeviceData.porta &= ~DUPMODE_BITS;
2500                 DeviceData.porta |= HALF_DUPLEX_DTR;
2501                 ATC_Mode = ATC_DTR_ENABLED;
2502                 break;
2503         default:
2504                 break;
2505         }
2506
2507         uc_temp = uc_value & QMCR_CONNECTOR_MASK;
2508         switch (uc_temp) {
2509         case QMCR_MODEM_CONTROL:
2510                 DeviceData.portb &= ~LOOPMODE_BITS;     /* reset connection bits */
2511                 DeviceData.portb |= MODEM_CTRL;
2512                 break;
2513         case QMCR_ALL_LOOPBACK:
2514                 DeviceData.portb &= ~LOOPMODE_BITS;     /* reset connection bits */
2515                 DeviceData.portb |= ALL_LOOPBACK;
2516                 break;
2517         }
2518
2519         mydbg(__FILE__ "Calling box_set_device with failed\n");
2520         status = box_set_device(serial, &DeviceData);
2521         if (status < 0) {
2522                 mydbg(__FILE__ "box_set_device failed\n");
2523                 return status;
2524         }
2525
2526         /* This bit (otherwise unused) i'll used  to detect whether ATC is
2527          * selected */
2528         if (uc_value & QMCR_RX_EN_MASK) {
2529
2530                 mydbg(__FILE__
2531                       "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2532                       DeviceData.porta, DeviceData.portb);
2533                 status = BoxSetATC(serial, ATC_Mode);
2534                 if (status < 0) {
2535                         mydbg(__FILE__ "BoxSetATC failed\n");
2536                         return status;
2537                 }
2538         } else {
2539
2540                 mydbg(__FILE__
2541                       "calling BoxsetATC with DeviceData.porta = 0x%x and DeviceData.portb = 0x%x\n",
2542                       DeviceData.porta, DeviceData.portb);
2543                 status = BoxSetATC(serial, ATC_DISABLED);
2544                 if (status < 0) {
2545                         mydbg(__FILE__ "BoxSetATC failed\n");
2546                         return status;
2547                 }
2548         }
2549
2550         return 0;
2551
2552 }
2553
2554 static int EmulateReadQMCR_Reg(int index, unsigned *uc_value)
2555 {
2556         struct usb_serial *serial;
2557         int status;
2558         struct qt_get_device_data DeviceData;
2559         __u8 uc_temp;
2560
2561         *uc_value = 0;
2562
2563         serial = find_the_box(index);
2564         if (!(serial))
2565                 return -ENOTTY;
2566
2567         status = box_get_device(serial, &DeviceData);
2568         if (status < 0) {
2569                 mydbg(__FILE__ "box_get_device failed\n");
2570                 return status;
2571         }
2572         uc_temp = DeviceData.porta & DUPMODE_BITS;
2573         switch (uc_temp) {
2574         case FULL_DUPLEX:
2575                 *uc_value |= QMCR_FULL_DUPLEX;
2576                 break;
2577         case HALF_DUPLEX_RTS:
2578                 *uc_value |= QMCR_HALF_DUPLEX_RTS;
2579                 break;
2580         case HALF_DUPLEX_DTR:
2581                 *uc_value |= QMCR_HALF_DUPLEX_DTR;
2582                 break;
2583         default:
2584                 break;
2585         }
2586
2587         /* I use this for ATC control se */
2588         uc_temp = DeviceData.portb & LOOPMODE_BITS;
2589
2590         switch (uc_temp) {
2591         case ALL_LOOPBACK:
2592                 *uc_value |= QMCR_ALL_LOOPBACK;
2593                 break;
2594         case MODEM_CTRL:
2595                 *uc_value |= QMCR_MODEM_CONTROL;
2596                 break;
2597         default:
2598                 break;
2599
2600         }
2601         return 0;
2602
2603 }
2604
2605 static int __init serqt_usb_init(void)
2606 {
2607         int i, result;
2608         int status = 0;
2609
2610         mydbg("%s\n", __func__);
2611         tty_set_operations(&serial_tty_driver, &serial_ops);
2612         result = tty_register_driver(&serial_tty_driver);
2613         if (result) {
2614                 mydbg("tty_register_driver failed error = 0x%x", result);
2615                 return result;
2616         }
2617
2618         /* Initalize our global data */
2619         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
2620                 serial_table[i] = NULL;
2621
2622         /* register this driver with the USB subsystem */
2623         result = usb_register(&serqt_usb_driver);
2624         if (result < 0) {
2625                 err("usb_register failed for the " __FILE__
2626                     " driver. Error number %d", result);
2627                 return result;
2628         }
2629         status = 0;             /* Dynamic assignment of major number */
2630         major_number =
2631             register_chrdev(status, "SerialQT_USB", &serialqt_usb_fops);
2632         if (major_number < 0) {
2633                 mydbg(KERN_DEBUG "No devices found \n\n");
2634                 return -EBUSY;
2635         } else
2636                 mydbg(KERN_DEBUG "SerQT_USB major number assignment = %d \n\n",
2637                       major_number);
2638
2639         printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION);
2640         return 0;
2641 }
2642
2643 static void __exit serqt_usb_exit(void)
2644 {
2645         /* deregister this driver with the USB subsystem */
2646         usb_deregister(&serqt_usb_driver);
2647         tty_unregister_driver(&serial_tty_driver);
2648         unregister_chrdev(major_number, "SerialQT_USB");
2649 }
2650
2651 module_init(serqt_usb_init);
2652 module_exit(serqt_usb_exit);
2653
2654 MODULE_AUTHOR(DRIVER_AUTHOR);
2655 MODULE_DESCRIPTION(DRIVER_DESC);
2656 MODULE_LICENSE("GPL");