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