drivers/usb/serial/mos7840.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  *
  16  * Clean ups from Moschip version and a few ioctl implementations by:
  17  *      Paul B Schroeder <pschroeder "at" uplogix "dot" com>
  18  *
  19  * Originally based on drivers/usb/serial/io_edgeport.c which is:
  20  *      Copyright (C) 2000 Inside Out Networks, All rights reserved.
  21  *      Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
  22  *
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/errno.h>
  27 #include <linux/init.h>
  28 #include <linux/slab.h>
  29 #include <linux/tty.h>
  30 #include <linux/tty_driver.h>
  31 #include <linux/tty_flip.h>
  32 #include <linux/module.h>
  33 #include <linux/serial.h>
  34 #include <linux/usb.h>
  35 #include <linux/usb/serial.h>
  36 #include <linux/uaccess.h>
  37
  38 /*
  39  * Version Information
  40  */
  41 #define DRIVER_VERSION "1.3.2"
  42 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver"
  43
  44 /*
  45  * 16C50 UART register defines
  46  */
  47
  48 #define LCR_BITS_5             0x00     /* 5 bits/char */
  49 #define LCR_BITS_6             0x01     /* 6 bits/char */
  50 #define LCR_BITS_7             0x02     /* 7 bits/char */
  51 #define LCR_BITS_8             0x03     /* 8 bits/char */
  52 #define LCR_BITS_MASK          0x03     /* Mask for bits/char field */
  53
  54 #define LCR_STOP_1             0x00     /* 1 stop bit */
  55 #define LCR_STOP_1_5           0x04     /* 1.5 stop bits (if 5   bits/char) */
  56 #define LCR_STOP_2             0x04     /* 2 stop bits   (if 6-8 bits/char) */
  57 #define LCR_STOP_MASK          0x04     /* Mask for stop bits field */
  58
  59 #define LCR_PAR_NONE           0x00     /* No parity */
  60 #define LCR_PAR_ODD            0x08     /* Odd parity */
  61 #define LCR_PAR_EVEN           0x18     /* Even parity */
  62 #define LCR_PAR_MARK           0x28     /* Force parity bit to 1 */
  63 #define LCR_PAR_SPACE          0x38     /* Force parity bit to 0 */
  64 #define LCR_PAR_MASK           0x38     /* Mask for parity field */
  65
  66 #define LCR_SET_BREAK          0x40     /* Set Break condition */
  67 #define LCR_DL_ENABLE          0x80     /* Enable access to divisor latch */
  68
  69 #define MCR_DTR                0x01     /* Assert DTR */
  70 #define MCR_RTS                0x02     /* Assert RTS */
  71 #define MCR_OUT1               0x04     /* Loopback only: Sets state of RI */
  72 #define MCR_MASTER_IE          0x08     /* Enable interrupt outputs */
  73 #define MCR_LOOPBACK           0x10     /* Set internal (digital) loopback mode */
  74 #define MCR_XON_ANY            0x20     /* Enable any char to exit XOFF mode */
  75
  76 #define MOS7840_MSR_CTS        0x10     /* Current state of CTS */
  77 #define MOS7840_MSR_DSR        0x20     /* Current state of DSR */
  78 #define MOS7840_MSR_RI         0x40     /* Current state of RI */
  79 #define MOS7840_MSR_CD         0x80     /* Current state of CD */
  80
  81 /*
  82  * Defines used for sending commands to port
  83  */
  84
  85 #define WAIT_FOR_EVER   (HZ * 0)        /* timeout urb is wait for ever */
  86 #define MOS_WDR_TIMEOUT (HZ * 5)        /* default urb timeout */
  87
  88 #define MOS_PORT1       0x0200
  89 #define MOS_PORT2       0x0300
  90 #define MOS_VENREG      0x0000
  91 #define MOS_MAX_PORT    0x02
  92 #define MOS_WRITE       0x0E
  93 #define MOS_READ        0x0D
  94
  95 /* Requests */
  96 #define MCS_RD_RTYPE    0xC0
  97 #define MCS_WR_RTYPE    0x40
  98 #define MCS_RDREQ       0x0D
  99 #define MCS_WRREQ       0x0E
 100 #define MCS_CTRL_TIMEOUT        500
 101 #define VENDOR_READ_LENGTH      (0x01)
 102
 103 #define MAX_NAME_LEN    64
 104
 105 #define ZLP_REG1  0x3A          /* Zero_Flag_Reg1    58 */
 106 #define ZLP_REG5  0x3E          /* Zero_Flag_Reg5    62 */
 107
 108 /* For higher baud Rates use TIOCEXBAUD */
 109 #define TIOCEXBAUD     0x5462
 110
 111 /* vendor id and device id defines */
 112
 113 /* The native mos7840/7820 component */
 114 #define USB_VENDOR_ID_MOSCHIP           0x9710
 115 #define MOSCHIP_DEVICE_ID_7840          0x7840
 116 #define MOSCHIP_DEVICE_ID_7820          0x7820
 117 /* The native component can have its vendor/device id's overridden
 118  * in vendor-specific implementations.  Such devices can be handled
 119  * by making a change here, in moschip_port_id_table, and in
 120  * moschip_id_table_combined
 121  */
 122 #define USB_VENDOR_ID_BANDB              0x0856
 123 #define BANDB_DEVICE_ID_USO9ML2_2        0xAC22
 124 #define BANDB_DEVICE_ID_USO9ML2_2P       0xBC00
 125 #define BANDB_DEVICE_ID_USO9ML2_4        0xAC24
 126 #define BANDB_DEVICE_ID_USO9ML2_4P       0xBC01
 127 #define BANDB_DEVICE_ID_US9ML2_2         0xAC29
 128 #define BANDB_DEVICE_ID_US9ML2_4         0xAC30
 129 #define BANDB_DEVICE_ID_USPTL4_2         0xAC31
 130 #define BANDB_DEVICE_ID_USPTL4_4         0xAC32
 131 #define BANDB_DEVICE_ID_USOPTL4_2        0xAC42
 132 #define BANDB_DEVICE_ID_USOPTL4_2P       0xBC02
 133 #define BANDB_DEVICE_ID_USOPTL4_4        0xAC44
 134 #define BANDB_DEVICE_ID_USOPTL4_4P       0xBC03
 135 #define BANDB_DEVICE_ID_USOPTL2_4        0xAC24
 136
 137 /* This driver also supports
 138  * ATEN UC2324 device using Moschip MCS7840
 139  * ATEN UC2322 device using Moschip MCS7820
 140  */
 141 #define USB_VENDOR_ID_ATENINTL          0x0557
 142 #define ATENINTL_DEVICE_ID_UC2324       0x2011
 143 #define ATENINTL_DEVICE_ID_UC2322       0x7820
 144
 145 /* Interrupt Routine Defines    */
 146
 147 #define SERIAL_IIR_RLS      0x06
 148 #define SERIAL_IIR_MS       0x00
 149
 150 /*
 151  *  Emulation of the bit mask on the LINE STATUS REGISTER.
 152  */
 153 #define SERIAL_LSR_DR       0x0001
 154 #define SERIAL_LSR_OE       0x0002
 155 #define SERIAL_LSR_PE       0x0004
 156 #define SERIAL_LSR_FE       0x0008
 157 #define SERIAL_LSR_BI       0x0010
 158
 159 #define MOS_MSR_DELTA_CTS   0x10
 160 #define MOS_MSR_DELTA_DSR   0x20
 161 #define MOS_MSR_DELTA_RI    0x40
 162 #define MOS_MSR_DELTA_CD    0x80
 163
 164 /* Serial Port register Address */
 165 #define INTERRUPT_ENABLE_REGISTER  ((__u16)(0x01))
 166 #define FIFO_CONTROL_REGISTER      ((__u16)(0x02))
 167 #define LINE_CONTROL_REGISTER      ((__u16)(0x03))
 168 #define MODEM_CONTROL_REGISTER     ((__u16)(0x04))
 169 #define LINE_STATUS_REGISTER       ((__u16)(0x05))
 170 #define MODEM_STATUS_REGISTER      ((__u16)(0x06))
 171 #define SCRATCH_PAD_REGISTER       ((__u16)(0x07))
 172 #define DIVISOR_LATCH_LSB          ((__u16)(0x00))
 173 #define DIVISOR_LATCH_MSB          ((__u16)(0x01))
 174
 175 #define CLK_MULTI_REGISTER         ((__u16)(0x02))
 176 #define CLK_START_VALUE_REGISTER   ((__u16)(0x03))
 177 #define GPIO_REGISTER              ((__u16)(0x07))
 178
 179 #define SERIAL_LCR_DLAB            ((__u16)(0x0080))
 180
 181 /*
 182  * URB POOL related defines
 183  */
 184 #define NUM_URBS                        16      /* URB Count */
 185 #define URB_TRANSFER_BUFFER_SIZE        32      /* URB Size  */
 186
 187
 188 static const struct usb_device_id moschip_port_id_table[] = {
 189         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
 190         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
 191         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
 192         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P)},
 193         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
 194         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P)},
 195         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
 196         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
 197         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
 198         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
 199         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
 200         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P)},
 201         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
 202         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P)},
 203         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL2_4)},
 204         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
 205         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
 206         {}                      /* terminating entry */
 207 };
 208
 209 static const struct usb_device_id moschip_id_table_combined[] __devinitconst = {
 210         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)},
 211         {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)},
 212         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)},
 213         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P)},
 214         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)},
 215         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P)},
 216         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)},
 217         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)},
 218         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)},
 219         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)},
 220         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)},
 221         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P)},
 222         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)},
 223         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P)},
 224         {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL2_4)},
 225         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)},
 226         {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)},
 227         {}                      /* terminating entry */
 228 };
 229
 230 MODULE_DEVICE_TABLE(usb, moschip_id_table_combined);
 231
 232 /* This structure holds all of the local port information */
 233
 234 struct moschip_port {
 235         int port_num;           /*Actual port number in the device(1,2,etc) */
 236         struct urb *write_urb;  /* write URB for this port */
 237         struct urb *read_urb;   /* read URB for this port */
 238         struct urb *int_urb;
 239         __u8 shadowLCR;         /* last LCR value received */
 240         __u8 shadowMCR;         /* last MCR value received */
 241         char open;
 242         char open_ports;
 243         char zombie;
 244         wait_queue_head_t wait_chase;   /* for handling sleeping while waiting for chase to finish */
 245         wait_queue_head_t delta_msr_wait;       /* for handling sleeping while waiting for msr change to happen */
 246         int delta_msr_cond;
 247         struct async_icount icount;
 248         struct usb_serial_port *port;   /* loop back to the owner of this object */
 249
 250         /* Offsets */
 251         __u8 SpRegOffset;
 252         __u8 ControlRegOffset;
 253         __u8 DcrRegOffset;
 254         /* for processing control URBS in interrupt context */
 255         struct urb *control_urb;
 256         struct usb_ctrlrequest *dr;
 257         char *ctrl_buf;
 258         int MsrLsr;
 259
 260         spinlock_t pool_lock;
 261         struct urb *write_urb_pool[NUM_URBS];
 262         char busy[NUM_URBS];
 263         bool read_urb_busy;
 264 };
 265
 266
 267 static int debug;
 268
 269 /*
 270  * mos7840_set_reg_sync
 271  *      To set the Control register by calling usb_fill_control_urb function
 272  *      by passing usb_sndctrlpipe function as parameter.
 273  */
 274
 275 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
 276                                 __u16 val)
 277 {
 278         struct usb_device *dev = port->serial->dev;
 279         val = val & 0x00ff;
 280         dbg("mos7840_set_reg_sync offset is %x, value %x", reg, val);
 281
 282         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
 283                                MCS_WR_RTYPE, val, reg, NULL, 0,
 284                                MOS_WDR_TIMEOUT);
 285 }
 286
 287 /*
 288  * mos7840_get_reg_sync
 289  *      To set the Uart register by calling usb_fill_control_urb function by
 290  *      passing usb_rcvctrlpipe function as parameter.
 291  */
 292
 293 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
 294                                 __u16 *val)
 295 {
 296         struct usb_device *dev = port->serial->dev;
 297         int ret = 0;
 298         u8 *buf;
 299
 300         buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
 301         if (!buf)
 302                 return -ENOMEM;
 303
 304         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
 305                               MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
 306                               MOS_WDR_TIMEOUT);
 307         *val = buf[0];
 308         dbg("mos7840_get_reg_sync offset is %x, return val %x", reg, *val);
 309
 310         kfree(buf);
 311         return ret;
 312 }
 313
 314 /*
 315  * mos7840_set_uart_reg
 316  *      To set the Uart register by calling usb_fill_control_urb function by
 317  *      passing usb_sndctrlpipe function as parameter.
 318  */
 319
 320 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
 321                                 __u16 val)
 322 {
 323
 324         struct usb_device *dev = port->serial->dev;
 325         val = val & 0x00ff;
 326         /* For the UART control registers, the application number need
 327            to be Or'ed */
 328         if (port->serial->num_ports == 4) {
 329                 val |= (((__u16) port->number -
 330                                 (__u16) (port->serial->minor)) + 1) << 8;
 331                 dbg("mos7840_set_uart_reg application number is %x", val);
 332         } else {
 333                 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) {
 334                         val |= (((__u16) port->number -
 335                               (__u16) (port->serial->minor)) + 1) << 8;
 336                         dbg("mos7840_set_uart_reg application number is %x",
 337                             val);
 338                 } else {
 339                         val |=
 340                             (((__u16) port->number -
 341                               (__u16) (port->serial->minor)) + 2) << 8;
 342                         dbg("mos7840_set_uart_reg application number is %x",
 343                             val);
 344                 }
 345         }
 346         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
 347                                MCS_WR_RTYPE, val, reg, NULL, 0,
 348                                MOS_WDR_TIMEOUT);
 349
 350 }
 351
 352 /*
 353  * mos7840_get_uart_reg
 354  *      To set the Control register by calling usb_fill_control_urb function
 355  *      by passing usb_rcvctrlpipe function as parameter.
 356  */
 357 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
 358                                 __u16 *val)
 359 {
 360         struct usb_device *dev = port->serial->dev;
 361         int ret = 0;
 362         __u16 Wval;
 363         u8 *buf;
 364
 365         buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
 366         if (!buf)
 367                 return -ENOMEM;
 368
 369         /* dbg("application number is %4x",
 370             (((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); */
 371         /* Wval  is same as application number */
 372         if (port->serial->num_ports == 4) {
 373                 Wval =
 374                     (((__u16) port->number - (__u16) (port->serial->minor)) +
 375                      1) << 8;
 376                 dbg("mos7840_get_uart_reg application number is %x", Wval);
 377         } else {
 378                 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) {
 379                         Wval = (((__u16) port->number -
 380                               (__u16) (port->serial->minor)) + 1) << 8;
 381                         dbg("mos7840_get_uart_reg application number is %x",
 382                             Wval);
 383                 } else {
 384                         Wval = (((__u16) port->number -
 385                               (__u16) (port->serial->minor)) + 2) << 8;
 386                         dbg("mos7840_get_uart_reg application number is %x",
 387                             Wval);
 388                 }
 389         }
 390         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
 391                               MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
 392                               MOS_WDR_TIMEOUT);
 393         *val = buf[0];
 394
 395         kfree(buf);
 396         return ret;
 397 }
 398
 399 static void mos7840_dump_serial_port(struct moschip_port *mos7840_port)
 400 {
 401
 402         dbg("***************************************");
 403         dbg("SpRegOffset is %2x", mos7840_port->SpRegOffset);
 404         dbg("ControlRegOffset is %2x", mos7840_port->ControlRegOffset);
 405         dbg("DCRRegOffset is %2x", mos7840_port->DcrRegOffset);
 406         dbg("***************************************");
 407
 408 }
 409
 410 /************************************************************************/
 411 /************************************************************************/
 412 /*             I N T E R F A C E   F U N C T I O N S                    */
 413 /*             I N T E R F A C E   F U N C T I O N S                    */
 414 /************************************************************************/
 415 /************************************************************************/
 416
 417 static inline void mos7840_set_port_private(struct usb_serial_port *port,
 418                                             struct moschip_port *data)
 419 {
 420         usb_set_serial_port_data(port, (void *)data);
 421 }
 422
 423 static inline struct moschip_port *mos7840_get_port_private(struct
 424                                                             usb_serial_port
 425                                                             *port)
 426 {
 427         return (struct moschip_port *)usb_get_serial_port_data(port);
 428 }
 429
 430 static void mos7840_handle_new_msr(struct moschip_port *port, __u8 new_msr)
 431 {
 432         struct moschip_port *mos7840_port;
 433         struct async_icount *icount;
 434         mos7840_port = port;
 435         icount = &mos7840_port->icount;
 436         if (new_msr &
 437             (MOS_MSR_DELTA_CTS | MOS_MSR_DELTA_DSR | MOS_MSR_DELTA_RI |
 438              MOS_MSR_DELTA_CD)) {
 439                 icount = &mos7840_port->icount;
 440
 441                 /* update input line counters */
 442                 if (new_msr & MOS_MSR_DELTA_CTS) {
 443                         icount->cts++;
 444                         smp_wmb();
 445                 }
 446                 if (new_msr & MOS_MSR_DELTA_DSR) {
 447                         icount->dsr++;
 448                         smp_wmb();
 449                 }
 450                 if (new_msr & MOS_MSR_DELTA_CD) {
 451                         icount->dcd++;
 452                         smp_wmb();
 453                 }
 454                 if (new_msr & MOS_MSR_DELTA_RI) {
 455                         icount->rng++;
 456                         smp_wmb();
 457                 }
 458         }
 459 }
 460
 461 static void mos7840_handle_new_lsr(struct moschip_port *port, __u8 new_lsr)
 462 {
 463         struct async_icount *icount;
 464
 465         dbg("%s - %02x", __func__, new_lsr);
 466
 467         if (new_lsr & SERIAL_LSR_BI) {
 468                 /*
 469                  * Parity and Framing errors only count if they
 470                  * occur exclusive of a break being
 471                  * received.
 472                  */
 473                 new_lsr &= (__u8) (SERIAL_LSR_OE | SERIAL_LSR_BI);
 474         }
 475
 476         /* update input line counters */
 477         icount = &port->icount;
 478         if (new_lsr & SERIAL_LSR_BI) {
 479                 icount->brk++;
 480                 smp_wmb();
 481         }
 482         if (new_lsr & SERIAL_LSR_OE) {
 483                 icount->overrun++;
 484                 smp_wmb();
 485         }
 486         if (new_lsr & SERIAL_LSR_PE) {
 487                 icount->parity++;
 488                 smp_wmb();
 489         }
 490         if (new_lsr & SERIAL_LSR_FE) {
 491                 icount->frame++;
 492                 smp_wmb();
 493         }
 494 }
 495
 496 /************************************************************************/
 497 /************************************************************************/
 498 /*            U S B  C A L L B A C K   F U N C T I O N S                */
 499 /*            U S B  C A L L B A C K   F U N C T I O N S                */
 500 /************************************************************************/
 501 /************************************************************************/
 502
 503 static void mos7840_control_callback(struct urb *urb)
 504 {
 505         unsigned char *data;
 506         struct moschip_port *mos7840_port;
 507         __u8 regval = 0x0;
 508         int result = 0;
 509         int status = urb->status;
 510
 511         mos7840_port = urb->context;
 512
 513         switch (status) {
 514         case 0:
 515                 /* success */
 516                 break;
 517         case -ECONNRESET:
 518         case -ENOENT:
 519         case -ESHUTDOWN:
 520                 /* this urb is terminated, clean up */
 521                 dbg("%s - urb shutting down with status: %d", __func__,
 522                     status);
 523                 return;
 524         default:
 525                 dbg("%s - nonzero urb status received: %d", __func__,
 526                     status);
 527                 goto exit;
 528         }
 529
 530         dbg("%s urb buffer size is %d", __func__, urb->actual_length);
 531         dbg("%s mos7840_port->MsrLsr is %d port %d", __func__,
 532             mos7840_port->MsrLsr, mos7840_port->port_num);
 533         data = urb->transfer_buffer;
 534         regval = (__u8) data[0];
 535         dbg("%s data is %x", __func__, regval);
 536         if (mos7840_port->MsrLsr == 0)
 537                 mos7840_handle_new_msr(mos7840_port, regval);
 538         else if (mos7840_port->MsrLsr == 1)
 539                 mos7840_handle_new_lsr(mos7840_port, regval);
 540
 541 exit:
 542         spin_lock(&mos7840_port->pool_lock);
 543         if (!mos7840_port->zombie)
 544                 result = usb_submit_urb(mos7840_port->int_urb, GFP_ATOMIC);
 545         spin_unlock(&mos7840_port->pool_lock);
 546         if (result) {
 547                 dev_err(&urb->dev->dev,
 548                         "%s - Error %d submitting interrupt urb\n",
 549                         __func__, result);
 550         }
 551 }
 552
 553 static int mos7840_get_reg(struct moschip_port *mcs, __u16 Wval, __u16 reg,
 554                            __u16 *val)
 555 {
 556         struct usb_device *dev = mcs->port->serial->dev;
 557         struct usb_ctrlrequest *dr = mcs->dr;
 558         unsigned char *buffer = mcs->ctrl_buf;
 559         int ret;
 560
 561         dr->bRequestType = MCS_RD_RTYPE;
 562         dr->bRequest = MCS_RDREQ;
 563         dr->wValue = cpu_to_le16(Wval); /* 0 */
 564         dr->wIndex = cpu_to_le16(reg);
 565         dr->wLength = cpu_to_le16(2);
 566
 567         usb_fill_control_urb(mcs->control_urb, dev, usb_rcvctrlpipe(dev, 0),
 568                              (unsigned char *)dr, buffer, 2,
 569                              mos7840_control_callback, mcs);
 570         mcs->control_urb->transfer_buffer_length = 2;
 571         ret = usb_submit_urb(mcs->control_urb, GFP_ATOMIC);
 572         return ret;
 573 }
 574
 575 /*****************************************************************************
 576  * mos7840_interrupt_callback
 577  *      this is the callback function for when we have received data on the
 578  *      interrupt endpoint.
 579  *****************************************************************************/
 580
 581 static void mos7840_interrupt_callback(struct urb *urb)
 582 {
 583         int result;
 584         int length;
 585         struct moschip_port *mos7840_port;
 586         struct usb_serial *serial;
 587         __u16 Data;
 588         unsigned char *data;
 589         __u8 sp[5], st;
 590         int i, rv = 0;
 591         __u16 wval, wreg = 0;
 592         int status = urb->status;
 593
 594         dbg("%s", " : Entering");
 595
 596         switch (status) {
 597         case 0:
 598                 /* success */
 599                 break;
 600         case -ECONNRESET:
 601         case -ENOENT:
 602         case -ESHUTDOWN:
 603                 /* this urb is terminated, clean up */
 604                 dbg("%s - urb shutting down with status: %d", __func__,
 605                     status);
 606                 return;
 607         default:
 608                 dbg("%s - nonzero urb status received: %d", __func__,
 609                     status);
 610                 goto exit;
 611         }
 612
 613         length = urb->actual_length;
 614         data = urb->transfer_buffer;
 615
 616         serial = urb->context;
 617
 618         /* Moschip get 5 bytes
 619          * Byte 1 IIR Port 1 (port.number is 0)
 620          * Byte 2 IIR Port 2 (port.number is 1)
 621          * Byte 3 IIR Port 3 (port.number is 2)
 622          * Byte 4 IIR Port 4 (port.number is 3)
 623          * Byte 5 FIFO status for both */
 624
 625         if (length && length > 5) {
 626                 dbg("%s", "Wrong data !!!");
 627                 return;
 628         }
 629
 630         sp[0] = (__u8) data[0];
 631         sp[1] = (__u8) data[1];
 632         sp[2] = (__u8) data[2];
 633         sp[3] = (__u8) data[3];
 634         st = (__u8) data[4];
 635
 636         for (i = 0; i < serial->num_ports; i++) {
 637                 mos7840_port = mos7840_get_port_private(serial->port[i]);
 638                 wval =
 639                     (((__u16) serial->port[i]->number -
 640                       (__u16) (serial->minor)) + 1) << 8;
 641                 if (mos7840_port->open) {
 642                         if (sp[i] & 0x01) {
 643                                 dbg("SP%d No Interrupt !!!", i);
 644                         } else {
 645                                 switch (sp[i] & 0x0f) {
 646                                 case SERIAL_IIR_RLS:
 647                                         dbg("Serial Port %d: Receiver status error or ", i);
 648                                         dbg("address bit detected in 9-bit mode");
 649                                         mos7840_port->MsrLsr = 1;
 650                                         wreg = LINE_STATUS_REGISTER;
 651                                         break;
 652                                 case SERIAL_IIR_MS:
 653                                         dbg("Serial Port %d: Modem status change", i);
 654                                         mos7840_port->MsrLsr = 0;
 655                                         wreg = MODEM_STATUS_REGISTER;
 656                                         break;
 657                                 }
 658                                 spin_lock(&mos7840_port->pool_lock);
 659                                 if (!mos7840_port->zombie) {
 660                                         rv = mos7840_get_reg(mos7840_port, wval, wreg, &Data);
 661                                 } else {
 662                                         spin_unlock(&mos7840_port->pool_lock);
 663                                         return;
 664                                 }
 665                                 spin_unlock(&mos7840_port->pool_lock);
 666                         }
 667                 }
 668         }
 669         if (!(rv < 0))
 670                 /* the completion handler for the control urb will resubmit */
 671                 return;
 672 exit:
 673         result = usb_submit_urb(urb, GFP_ATOMIC);
 674         if (result) {
 675                 dev_err(&urb->dev->dev,
 676                         "%s - Error %d submitting interrupt urb\n",
 677                         __func__, result);
 678         }
 679 }
 680
 681 static int mos7840_port_paranoia_check(struct usb_serial_port *port,
 682                                        const char *function)
 683 {
 684         if (!port) {
 685                 dbg("%s - port == NULL", function);
 686                 return -1;
 687         }
 688         if (!port->serial) {
 689                 dbg("%s - port->serial == NULL", function);
 690                 return -1;
 691         }
 692
 693         return 0;
 694 }
 695
 696 /* Inline functions to check the sanity of a pointer that is passed to us */
 697 static int mos7840_serial_paranoia_check(struct usb_serial *serial,
 698                                          const char *function)
 699 {
 700         if (!serial) {
 701                 dbg("%s - serial == NULL", function);
 702                 return -1;
 703         }
 704         if (!serial->type) {
 705                 dbg("%s - serial->type == NULL!", function);
 706                 return -1;
 707         }
 708
 709         return 0;
 710 }
 711
 712 static struct usb_serial *mos7840_get_usb_serial(struct usb_serial_port *port,
 713                                                  const char *function)
 714 {
 715         /* if no port was specified, or it fails a paranoia check */
 716         if (!port ||
 717             mos7840_port_paranoia_check(port, function) ||
 718             mos7840_serial_paranoia_check(port->serial, function)) {
 719                 /* then say that we don't have a valid usb_serial thing,
 720                  * which will end up genrating -ENODEV return values */
 721                 return NULL;
 722         }
 723
 724         return port->serial;
 725 }
 726
 727 /*****************************************************************************
 728  * mos7840_bulk_in_callback
 729  *      this is the callback function for when we have received data on the
 730  *      bulk in endpoint.
 731  *****************************************************************************/
 732
 733 static void mos7840_bulk_in_callback(struct urb *urb)
 734 {
 735         int retval;
 736         unsigned char *data;
 737         struct usb_serial *serial;
 738         struct usb_serial_port *port;
 739         struct moschip_port *mos7840_port;
 740         struct tty_struct *tty;
 741         int status = urb->status;
 742
 743         mos7840_port = urb->context;
 744         if (!mos7840_port) {
 745                 dbg("%s", "NULL mos7840_port pointer");
 746                 return;
 747         }
 748
 749         if (status) {
 750                 dbg("nonzero read bulk status received: %d", status);
 751                 mos7840_port->read_urb_busy = false;
 752                 return;
 753         }
 754
 755         port = (struct usb_serial_port *)mos7840_port->port;
 756         if (mos7840_port_paranoia_check(port, __func__)) {
 757                 dbg("%s", "Port Paranoia failed");
 758                 mos7840_port->read_urb_busy = false;
 759                 return;
 760         }
 761
 762         serial = mos7840_get_usb_serial(port, __func__);
 763         if (!serial) {
 764                 dbg("%s", "Bad serial pointer");
 765                 mos7840_port->read_urb_busy = false;
 766                 return;
 767         }
 768
 769         dbg("%s", "Entering... ");
 770
 771         data = urb->transfer_buffer;
 772
 773         dbg("%s", "Entering ...........");
 774
 775         if (urb->actual_length) {
 776                 tty = tty_port_tty_get(&mos7840_port->port->port);
 777                 if (tty) {
 778                         tty_insert_flip_string(tty, data, urb->actual_length);
 779                         dbg(" %s ", data);
 780                         tty_flip_buffer_push(tty);
 781                         tty_kref_put(tty);
 782                 }
 783                 mos7840_port->icount.rx += urb->actual_length;
 784                 smp_wmb();
 785                 dbg("mos7840_port->icount.rx is %d:",
 786                     mos7840_port->icount.rx);
 787         }
 788
 789         if (!mos7840_port->read_urb) {
 790                 dbg("%s", "URB KILLED !!!");
 791                 mos7840_port->read_urb_busy = false;
 792                 return;
 793         }
 794
 795
 796         mos7840_port->read_urb->dev = serial->dev;
 797
 798         mos7840_port->read_urb_busy = true;
 799         retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
 800
 801         if (retval) {
 802                 dbg("usb_submit_urb(read bulk) failed, retval = %d", retval);
 803                 mos7840_port->read_urb_busy = false;
 804         }
 805 }
 806
 807 /*****************************************************************************
 808  * mos7840_bulk_out_data_callback
 809  *      this is the callback function for when we have finished sending
 810  *      serial data on the bulk out endpoint.
 811  *****************************************************************************/
 812
 813 static void mos7840_bulk_out_data_callback(struct urb *urb)
 814 {
 815         struct moschip_port *mos7840_port;
 816         struct tty_struct *tty;
 817         int status = urb->status;
 818         int i;
 819
 820         mos7840_port = urb->context;
 821         spin_lock(&mos7840_port->pool_lock);
 822         for (i = 0; i < NUM_URBS; i++) {
 823                 if (urb == mos7840_port->write_urb_pool[i]) {
 824                         mos7840_port->busy[i] = 0;
 825                         break;
 826                 }
 827         }
 828         spin_unlock(&mos7840_port->pool_lock);
 829
 830         if (status) {
 831                 dbg("nonzero write bulk status received:%d", status);
 832                 return;
 833         }
 834
 835         if (mos7840_port_paranoia_check(mos7840_port->port, __func__)) {
 836                 dbg("%s", "Port Paranoia failed");
 837                 return;
 838         }
 839
 840         dbg("%s", "Entering .........");
 841
 842         tty = tty_port_tty_get(&mos7840_port->port->port);
 843         if (tty && mos7840_port->open)
 844                 tty_wakeup(tty);
 845         tty_kref_put(tty);
 846
 847 }
 848
 849 /************************************************************************/
 850 /*       D R I V E R  T T Y  I N T E R F A C E  F U N C T I O N S       */
 851 /************************************************************************/
 852 #ifdef MCSSerialProbe
 853 static int mos7840_serial_probe(struct usb_serial *serial,
 854                                 const struct usb_device_id *id)
 855 {
 856
 857         /*need to implement the mode_reg reading and updating\
 858            structures usb_serial_ device_type\
 859            (i.e num_ports, num_bulkin,bulkout etc) */
 860         /* Also we can update the changes  attach */
 861         return 1;
 862 }
 863 #endif
 864
 865 /*****************************************************************************
 866  * mos7840_open
 867  *      this function is called by the tty driver when a port is opened
 868  *      If successful, we return 0
 869  *      Otherwise we return a negative error number.
 870  *****************************************************************************/
 871
 872 static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
 873 {
 874         int response;
 875         int j;
 876         struct usb_serial *serial;
 877         struct urb *urb;
 878         __u16 Data;
 879         int status;
 880         struct moschip_port *mos7840_port;
 881         struct moschip_port *port0;
 882
 883         dbg ("%s enter", __func__);
 884
 885         if (mos7840_port_paranoia_check(port, __func__)) {
 886                 dbg("%s", "Port Paranoia failed");
 887                 return -ENODEV;
 888         }
 889
 890         serial = port->serial;
 891
 892         if (mos7840_serial_paranoia_check(serial, __func__)) {
 893                 dbg("%s", "Serial Paranoia failed");
 894                 return -ENODEV;
 895         }
 896
 897         mos7840_port = mos7840_get_port_private(port);
 898         port0 = mos7840_get_port_private(serial->port[0]);
 899
 900         if (mos7840_port == NULL || port0 == NULL)
 901                 return -ENODEV;
 902
 903         usb_clear_halt(serial->dev, port->write_urb->pipe);
 904         usb_clear_halt(serial->dev, port->read_urb->pipe);
 905         port0->open_ports++;
 906
 907         /* Initialising the write urb pool */
 908         for (j = 0; j < NUM_URBS; ++j) {
 909                 urb = usb_alloc_urb(0, GFP_KERNEL);
 910                 mos7840_port->write_urb_pool[j] = urb;
 911
 912                 if (urb == NULL) {
 913                         dev_err(&port->dev, "No more urbs???\n");
 914                         continue;
 915                 }
 916
 917                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
 918                                                                 GFP_KERNEL);
 919                 if (!urb->transfer_buffer) {
 920                         usb_free_urb(urb);
 921                         mos7840_port->write_urb_pool[j] = NULL;
 922                         dev_err(&port->dev,
 923                                 "%s-out of memory for urb buffers.\n",
 924                                 __func__);
 925                         continue;
 926                 }
 927         }
 928
 929 /*****************************************************************************
 930  * Initialize MCS7840 -- Write Init values to corresponding Registers
 931  *
 932  * Register Index
 933  * 1 : IER
 934  * 2 : FCR
 935  * 3 : LCR
 936  * 4 : MCR
 937  *
 938  * 0x08 : SP1/2 Control Reg
 939  *****************************************************************************/
 940
 941         /* NEED to check the following Block */
 942
 943         Data = 0x0;
 944         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
 945         if (status < 0) {
 946                 dbg("Reading Spreg failed");
 947                 return -1;
 948         }
 949         Data |= 0x80;
 950         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 951         if (status < 0) {
 952                 dbg("writing Spreg failed");
 953                 return -1;
 954         }
 955
 956         Data &= ~0x80;
 957         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 958         if (status < 0) {
 959                 dbg("writing Spreg failed");
 960                 return -1;
 961         }
 962         /* End of block to be checked */
 963
 964         Data = 0x0;
 965         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
 966                                                                         &Data);
 967         if (status < 0) {
 968                 dbg("Reading Controlreg failed");
 969                 return -1;
 970         }
 971         Data |= 0x08;           /* Driver done bit */
 972         Data |= 0x20;           /* rx_disable */
 973         status = mos7840_set_reg_sync(port,
 974                                 mos7840_port->ControlRegOffset, Data);
 975         if (status < 0) {
 976                 dbg("writing Controlreg failed");
 977                 return -1;
 978         }
 979         /* do register settings here */
 980         /* Set all regs to the device default values. */
 981         /***********************************
 982          * First Disable all interrupts.
 983          ***********************************/
 984         Data = 0x00;
 985         status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
 986         if (status < 0) {
 987                 dbg("disabling interrupts failed");
 988                 return -1;
 989         }
 990         /* Set FIFO_CONTROL_REGISTER to the default value */
 991         Data = 0x00;
 992         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
 993         if (status < 0) {
 994                 dbg("Writing FIFO_CONTROL_REGISTER  failed");
 995                 return -1;
 996         }
 997
 998         Data = 0xcf;
 999         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1000         if (status < 0) {
1001                 dbg("Writing FIFO_CONTROL_REGISTER  failed");
1002                 return -1;
1003         }
1004
1005         Data = 0x03;
1006         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1007         mos7840_port->shadowLCR = Data;
1008
1009         Data = 0x0b;
1010         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1011         mos7840_port->shadowMCR = Data;
1012
1013         Data = 0x00;
1014         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
1015         mos7840_port->shadowLCR = Data;
1016
1017         Data |= SERIAL_LCR_DLAB;        /* data latch enable in LCR 0x80 */
1018         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1019
1020         Data = 0x0c;
1021         status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1022
1023         Data = 0x0;
1024         status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1025
1026         Data = 0x00;
1027         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
1028
1029         Data = Data & ~SERIAL_LCR_DLAB;
1030         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1031         mos7840_port->shadowLCR = Data;
1032
1033         /* clearing Bulkin and Bulkout Fifo */
1034         Data = 0x0;
1035         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
1036
1037         Data = Data | 0x0c;
1038         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
1039
1040         Data = Data & ~0x0c;
1041         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
1042         /* Finally enable all interrupts */
1043         Data = 0x0c;
1044         status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1045
1046         /* clearing rx_disable */
1047         Data = 0x0;
1048         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1049                                                                         &Data);
1050         Data = Data & ~0x20;
1051         status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1052                                                                         Data);
1053
1054         /* rx_negate */
1055         Data = 0x0;
1056         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
1057                                                                         &Data);
1058         Data = Data | 0x10;
1059         status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
1060                                                                         Data);
1061
1062         /* Check to see if we've set up our endpoint info yet    *
1063          * (can't set it up in mos7840_startup as the structures *
1064          * were not set up at that time.)                        */
1065         if (port0->open_ports == 1) {
1066                 if (serial->port[0]->interrupt_in_buffer == NULL) {
1067                         /* set up interrupt urb */
1068                         usb_fill_int_urb(serial->port[0]->interrupt_in_urb,
1069                                 serial->dev,
1070                                 usb_rcvintpipe(serial->dev,
1071                                 serial->port[0]->interrupt_in_endpointAddress),
1072                                 serial->port[0]->interrupt_in_buffer,
1073                                 serial->port[0]->interrupt_in_urb->
1074                                 transfer_buffer_length,
1075                                 mos7840_interrupt_callback,
1076                                 serial,
1077                                 serial->port[0]->interrupt_in_urb->interval);
1078
1079                         /* start interrupt read for mos7840               *
1080                          * will continue as long as mos7840 is connected  */
1081
1082                         response =
1083                             usb_submit_urb(serial->port[0]->interrupt_in_urb,
1084                                            GFP_KERNEL);
1085                         if (response) {
1086                                 dev_err(&port->dev, "%s - Error %d submitting "
1087                                         "interrupt urb\n", __func__, response);
1088                         }
1089
1090                 }
1091
1092         }
1093
1094         /* see if we've set up our endpoint info yet   *
1095          * (can't set it up in mos7840_startup as the  *
1096          * structures were not set up at that time.)   */
1097
1098         dbg("port number is %d", port->number);
1099         dbg("serial number is %d", port->serial->minor);
1100         dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress);
1101         dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress);
1102         dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress);
1103         dbg("port's number in the device is %d", mos7840_port->port_num);
1104         mos7840_port->read_urb = port->read_urb;
1105
1106         /* set up our bulk in urb */
1107         if ((serial->num_ports == 2)
1108                 && ((((__u16)port->number -
1109                         (__u16)(port->serial->minor)) % 2) != 0)) {
1110                 usb_fill_bulk_urb(mos7840_port->read_urb,
1111                         serial->dev,
1112                         usb_rcvbulkpipe(serial->dev,
1113                                 (port->bulk_in_endpointAddress) + 2),
1114                         port->bulk_in_buffer,
1115                         mos7840_port->read_urb->transfer_buffer_length,
1116                         mos7840_bulk_in_callback, mos7840_port);
1117         } else {
1118                 usb_fill_bulk_urb(mos7840_port->read_urb,
1119                         serial->dev,
1120                         usb_rcvbulkpipe(serial->dev,
1121                                 port->bulk_in_endpointAddress),
1122                         port->bulk_in_buffer,
1123                         mos7840_port->read_urb->transfer_buffer_length,
1124                         mos7840_bulk_in_callback, mos7840_port);
1125         }
1126
1127         dbg("mos7840_open: bulkin endpoint is %d",
1128             port->bulk_in_endpointAddress);
1129         mos7840_port->read_urb_busy = true;
1130         response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1131         if (response) {
1132                 dev_err(&port->dev, "%s - Error %d submitting control urb\n",
1133                         __func__, response);
1134                 mos7840_port->read_urb_busy = false;
1135         }
1136
1137         /* initialize our wait queues */
1138         init_waitqueue_head(&mos7840_port->wait_chase);
1139         init_waitqueue_head(&mos7840_port->delta_msr_wait);
1140
1141         /* initialize our icount structure */
1142         memset(&(mos7840_port->icount), 0x00, sizeof(mos7840_port->icount));
1143
1144         /* initialize our port settings */
1145         /* Must set to enable ints! */
1146         mos7840_port->shadowMCR = MCR_MASTER_IE;
1147         /* send a open port command */
1148         mos7840_port->open = 1;
1149         /* mos7840_change_port_settings(mos7840_port,old_termios); */
1150         mos7840_port->icount.tx = 0;
1151         mos7840_port->icount.rx = 0;
1152
1153         dbg("usb_serial serial:%p       mos7840_port:%p\n      usb_serial_port port:%p",
1154                                 serial, mos7840_port, port);
1155
1156         dbg ("%s leave", __func__);
1157
1158         return 0;
1159
1160 }
1161
1162 /*****************************************************************************
1163  * mos7840_chars_in_buffer
1164  *      this function is called by the tty driver when it wants to know how many
1165  *      bytes of data we currently have outstanding in the port (data that has
1166  *      been written, but hasn't made it out the port yet)
1167  *      If successful, we return the number of bytes left to be written in the
1168  *      system,
1169  *      Otherwise we return zero.
1170  *****************************************************************************/
1171
1172 static int mos7840_chars_in_buffer(struct tty_struct *tty)
1173 {
1174         struct usb_serial_port *port = tty->driver_data;
1175         int i;
1176         int chars = 0;
1177         unsigned long flags;
1178         struct moschip_port *mos7840_port;
1179
1180         dbg("%s", " mos7840_chars_in_buffer:entering ...........");
1181
1182         if (mos7840_port_paranoia_check(port, __func__)) {
1183                 dbg("%s", "Invalid port");
1184                 return 0;
1185         }
1186
1187         mos7840_port = mos7840_get_port_private(port);
1188         if (mos7840_port == NULL) {
1189                 dbg("%s", "mos7840_break:leaving ...........");
1190                 return 0;
1191         }
1192
1193         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1194         for (i = 0; i < NUM_URBS; ++i) {
1195                 if (mos7840_port->busy[i]) {
1196                         struct urb *urb = mos7840_port->write_urb_pool[i];
1197                         chars += urb->transfer_buffer_length;
1198                 }
1199         }
1200         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1201         dbg("%s - returns %d", __func__, chars);
1202         return chars;
1203
1204 }
1205
1206 /*****************************************************************************
1207  * mos7840_close
1208  *      this function is called by the tty driver when a port is closed
1209  *****************************************************************************/
1210
1211 static void mos7840_close(struct usb_serial_port *port)
1212 {
1213         struct usb_serial *serial;
1214         struct moschip_port *mos7840_port;
1215         struct moschip_port *port0;
1216         int j;
1217         __u16 Data;
1218
1219         dbg("%s", "mos7840_close:entering...");
1220
1221         if (mos7840_port_paranoia_check(port, __func__)) {
1222                 dbg("%s", "Port Paranoia failed");
1223                 return;
1224         }
1225
1226         serial = mos7840_get_usb_serial(port, __func__);
1227         if (!serial) {
1228                 dbg("%s", "Serial Paranoia failed");
1229                 return;
1230         }
1231
1232         mos7840_port = mos7840_get_port_private(port);
1233         port0 = mos7840_get_port_private(serial->port[0]);
1234
1235         if (mos7840_port == NULL || port0 == NULL)
1236                 return;
1237
1238         for (j = 0; j < NUM_URBS; ++j)
1239                 usb_kill_urb(mos7840_port->write_urb_pool[j]);
1240
1241         /* Freeing Write URBs */
1242         for (j = 0; j < NUM_URBS; ++j) {
1243                 if (mos7840_port->write_urb_pool[j]) {
1244                         if (mos7840_port->write_urb_pool[j]->transfer_buffer)
1245                                 kfree(mos7840_port->write_urb_pool[j]->
1246                                       transfer_buffer);
1247
1248                         usb_free_urb(mos7840_port->write_urb_pool[j]);
1249                 }
1250         }
1251
1252         /* While closing port, shutdown all bulk read, write  *
1253          * and interrupt read if they exists                  */
1254         if (serial->dev) {
1255                 if (mos7840_port->write_urb) {
1256                         dbg("%s", "Shutdown bulk write");
1257                         usb_kill_urb(mos7840_port->write_urb);
1258                 }
1259                 if (mos7840_port->read_urb) {
1260                         dbg("%s", "Shutdown bulk read");
1261                         usb_kill_urb(mos7840_port->read_urb);
1262                         mos7840_port->read_urb_busy = false;
1263                 }
1264                 if ((&mos7840_port->control_urb)) {
1265                         dbg("%s", "Shutdown control read");
1266                         /*/      usb_kill_urb (mos7840_port->control_urb); */
1267                 }
1268         }
1269 /*      if(mos7840_port->ctrl_buf != NULL) */
1270 /*              kfree(mos7840_port->ctrl_buf); */
1271         port0->open_ports--;
1272         dbg("mos7840_num_open_ports in close%d:in port%d",
1273             port0->open_ports, port->number);
1274         if (port0->open_ports == 0) {
1275                 if (serial->port[0]->interrupt_in_urb) {
1276                         dbg("%s", "Shutdown interrupt_in_urb");
1277                         usb_kill_urb(serial->port[0]->interrupt_in_urb);
1278                 }
1279         }
1280
1281         if (mos7840_port->write_urb) {
1282                 /* if this urb had a transfer buffer already (old tx) free it */
1283                 if (mos7840_port->write_urb->transfer_buffer != NULL)
1284                         kfree(mos7840_port->write_urb->transfer_buffer);
1285                 usb_free_urb(mos7840_port->write_urb);
1286         }
1287
1288         Data = 0x0;
1289         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1290
1291         Data = 0x00;
1292         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1293
1294         mos7840_port->open = 0;
1295
1296         dbg("%s", "Leaving ............");
1297 }
1298
1299 /************************************************************************
1300  *
1301  * mos7840_block_until_chase_response
1302  *
1303  *      This function will block the close until one of the following:
1304  *              1. Response to our Chase comes from mos7840
1305  *              2. A timeout of 10 seconds without activity has expired
1306  *                 (1K of mos7840 data @ 2400 baud ==> 4 sec to empty)
1307  *
1308  ************************************************************************/
1309
1310 static void mos7840_block_until_chase_response(struct tty_struct *tty,
1311                                         struct moschip_port *mos7840_port)
1312 {
1313         int timeout = 1 * HZ;
1314         int wait = 10;
1315         int count;
1316
1317         while (1) {
1318                 count = mos7840_chars_in_buffer(tty);
1319
1320                 /* Check for Buffer status */
1321                 if (count <= 0)
1322                         return;
1323
1324                 /* Block the thread for a while */
1325                 interruptible_sleep_on_timeout(&mos7840_port->wait_chase,
1326                                                timeout);
1327                 /* No activity.. count down section */
1328                 wait--;
1329                 if (wait == 0) {
1330                         dbg("%s - TIMEOUT", __func__);
1331                         return;
1332                 } else {
1333                         /* Reset timeout value back to seconds */
1334                         wait = 10;
1335                 }
1336         }
1337
1338 }
1339
1340 /*****************************************************************************
1341  * mos7840_break
1342  *      this function sends a break to the port
1343  *****************************************************************************/
1344 static void mos7840_break(struct tty_struct *tty, int break_state)
1345 {
1346         struct usb_serial_port *port = tty->driver_data;
1347         unsigned char data;
1348         struct usb_serial *serial;
1349         struct moschip_port *mos7840_port;
1350
1351         dbg("%s", "Entering ...........");
1352         dbg("mos7840_break: Start");
1353
1354         if (mos7840_port_paranoia_check(port, __func__)) {
1355                 dbg("%s", "Port Paranoia failed");
1356                 return;
1357         }
1358
1359         serial = mos7840_get_usb_serial(port, __func__);
1360         if (!serial) {
1361                 dbg("%s", "Serial Paranoia failed");
1362                 return;
1363         }
1364
1365         mos7840_port = mos7840_get_port_private(port);
1366
1367         if (mos7840_port == NULL)
1368                 return;
1369
1370         if (serial->dev)
1371                 /* flush and block until tx is empty */
1372                 mos7840_block_until_chase_response(tty, mos7840_port);
1373
1374         if (break_state == -1)
1375                 data = mos7840_port->shadowLCR | LCR_SET_BREAK;
1376         else
1377                 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
1378
1379         /* FIXME: no locking on shadowLCR anywhere in driver */
1380         mos7840_port->shadowLCR = data;
1381         dbg("mcs7840_break mos7840_port->shadowLCR is %x",
1382             mos7840_port->shadowLCR);
1383         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
1384                              mos7840_port->shadowLCR);
1385 }
1386
1387 /*****************************************************************************
1388  * mos7840_write_room
1389  *      this function is called by the tty driver when it wants to know how many
1390  *      bytes of data we can accept for a specific port.
1391  *      If successful, we return the amount of room that we have for this port
1392  *      Otherwise we return a negative error number.
1393  *****************************************************************************/
1394
1395 static int mos7840_write_room(struct tty_struct *tty)
1396 {
1397         struct usb_serial_port *port = tty->driver_data;
1398         int i;
1399         int room = 0;
1400         unsigned long flags;
1401         struct moschip_port *mos7840_port;
1402
1403         dbg("%s", " mos7840_write_room:entering ...........");
1404
1405         if (mos7840_port_paranoia_check(port, __func__)) {
1406                 dbg("%s", "Invalid port");
1407                 dbg("%s", " mos7840_write_room:leaving ...........");
1408                 return -1;
1409         }
1410
1411         mos7840_port = mos7840_get_port_private(port);
1412         if (mos7840_port == NULL) {
1413                 dbg("%s", "mos7840_break:leaving ...........");
1414                 return -1;
1415         }
1416
1417         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1418         for (i = 0; i < NUM_URBS; ++i) {
1419                 if (!mos7840_port->busy[i])
1420                         room += URB_TRANSFER_BUFFER_SIZE;
1421         }
1422         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1423
1424         room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
1425         dbg("%s - returns %d", __func__, room);
1426         return room;
1427
1428 }
1429
1430 /*****************************************************************************
1431  * mos7840_write
1432  *      this function is called by the tty driver when data should be written to
1433  *      the port.
1434  *      If successful, we return the number of bytes written, otherwise we
1435  *      return a negative error number.
1436  *****************************************************************************/
1437
1438 static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
1439                          const unsigned char *data, int count)
1440 {
1441         int status;
1442         int i;
1443         int bytes_sent = 0;
1444         int transfer_size;
1445         unsigned long flags;
1446
1447         struct moschip_port *mos7840_port;
1448         struct usb_serial *serial;
1449         struct urb *urb;
1450         /* __u16 Data; */
1451         const unsigned char *current_position = data;
1452         unsigned char *data1;
1453         dbg("%s", "entering ...........");
1454         /* dbg("mos7840_write: mos7840_port->shadowLCR is %x",
1455                                         mos7840_port->shadowLCR); */
1456
1457 #ifdef NOTMOS7840
1458         Data = 0x00;
1459         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
1460         mos7840_port->shadowLCR = Data;
1461         dbg("mos7840_write: LINE_CONTROL_REGISTER is %x", Data);
1462         dbg("mos7840_write: mos7840_port->shadowLCR is %x",
1463             mos7840_port->shadowLCR);
1464
1465         /* Data = 0x03; */
1466         /* status = mos7840_set_uart_reg(port,LINE_CONTROL_REGISTER,Data); */
1467         /* mos7840_port->shadowLCR=Data;//Need to add later */
1468
1469         Data |= SERIAL_LCR_DLAB;        /* data latch enable in LCR 0x80 */
1470         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1471
1472         /* Data = 0x0c; */
1473         /* status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); */
1474         Data = 0x00;
1475         status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data);
1476         dbg("mos7840_write:DLL value is %x", Data);
1477
1478         Data = 0x0;
1479         status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data);
1480         dbg("mos7840_write:DLM value is %x", Data);
1481
1482         Data = Data & ~SERIAL_LCR_DLAB;
1483         dbg("mos7840_write: mos7840_port->shadowLCR is %x",
1484             mos7840_port->shadowLCR);
1485         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1486 #endif
1487
1488         if (mos7840_port_paranoia_check(port, __func__)) {
1489                 dbg("%s", "Port Paranoia failed");
1490                 return -1;
1491         }
1492
1493         serial = port->serial;
1494         if (mos7840_serial_paranoia_check(serial, __func__)) {
1495                 dbg("%s", "Serial Paranoia failed");
1496                 return -1;
1497         }
1498
1499         mos7840_port = mos7840_get_port_private(port);
1500         if (mos7840_port == NULL) {
1501                 dbg("%s", "mos7840_port is NULL");
1502                 return -1;
1503         }
1504
1505         /* try to find a free urb in the list */
1506         urb = NULL;
1507
1508         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
1509         for (i = 0; i < NUM_URBS; ++i) {
1510                 if (!mos7840_port->busy[i]) {
1511                         mos7840_port->busy[i] = 1;
1512                         urb = mos7840_port->write_urb_pool[i];
1513                         dbg("URB:%d", i);
1514                         break;
1515                 }
1516         }
1517         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
1518
1519         if (urb == NULL) {
1520                 dbg("%s - no more free urbs", __func__);
1521                 goto exit;
1522         }
1523
1524         if (urb->transfer_buffer == NULL) {
1525                 urb->transfer_buffer =
1526                     kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);
1527
1528                 if (urb->transfer_buffer == NULL) {
1529                         dev_err(&port->dev, "%s no more kernel memory...\n",
1530                                 __func__);
1531                         goto exit;
1532                 }
1533         }
1534         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
1535
1536         memcpy(urb->transfer_buffer, current_position, transfer_size);
1537
1538         /* fill urb with data and submit  */
1539         if ((serial->num_ports == 2)
1540                 && ((((__u16)port->number -
1541                         (__u16)(port->serial->minor)) % 2) != 0)) {
1542                 usb_fill_bulk_urb(urb,
1543                         serial->dev,
1544                         usb_sndbulkpipe(serial->dev,
1545                                 (port->bulk_out_endpointAddress) + 2),
1546                         urb->transfer_buffer,
1547                         transfer_size,
1548                         mos7840_bulk_out_data_callback, mos7840_port);
1549         } else {
1550                 usb_fill_bulk_urb(urb,
1551                         serial->dev,
1552                         usb_sndbulkpipe(serial->dev,
1553                                 port->bulk_out_endpointAddress),
1554                         urb->transfer_buffer,
1555                         transfer_size,
1556                         mos7840_bulk_out_data_callback, mos7840_port);
1557         }
1558
1559         data1 = urb->transfer_buffer;
1560         dbg("bulkout endpoint is %d", port->bulk_out_endpointAddress);
1561
1562         /* send it down the pipe */
1563         status = usb_submit_urb(urb, GFP_ATOMIC);
1564
1565         if (status) {
1566                 mos7840_port->busy[i] = 0;
1567                 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
1568                         "with status = %d\n", __func__, status);
1569                 bytes_sent = status;
1570                 goto exit;
1571         }
1572         bytes_sent = transfer_size;
1573         mos7840_port->icount.tx += transfer_size;
1574         smp_wmb();
1575         dbg("mos7840_port->icount.tx is %d:", mos7840_port->icount.tx);
1576 exit:
1577         return bytes_sent;
1578
1579 }
1580
1581 /*****************************************************************************
1582  * mos7840_throttle
1583  *      this function is called by the tty driver when it wants to stop the data
1584  *      being read from the port.
1585  *****************************************************************************/
1586
1587 static void mos7840_throttle(struct tty_struct *tty)
1588 {
1589         struct usb_serial_port *port = tty->driver_data;
1590         struct moschip_port *mos7840_port;
1591         int status;
1592
1593         if (mos7840_port_paranoia_check(port, __func__)) {
1594                 dbg("%s", "Invalid port");
1595                 return;
1596         }
1597
1598         dbg("- port %d", port->number);
1599
1600         mos7840_port = mos7840_get_port_private(port);
1601
1602         if (mos7840_port == NULL)
1603                 return;
1604
1605         if (!mos7840_port->open) {
1606                 dbg("%s", "port not opened");
1607                 return;
1608         }
1609
1610         dbg("%s", "Entering ..........");
1611
1612         /* if we are implementing XON/XOFF, send the stop character */
1613         if (I_IXOFF(tty)) {
1614                 unsigned char stop_char = STOP_CHAR(tty);
1615                 status = mos7840_write(tty, port, &stop_char, 1);
1616                 if (status <= 0)
1617                         return;
1618         }
1619         /* if we are implementing RTS/CTS, toggle that line */
1620         if (tty->termios->c_cflag & CRTSCTS) {
1621                 mos7840_port->shadowMCR &= ~MCR_RTS;
1622                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1623                                          mos7840_port->shadowMCR);
1624                 if (status < 0)
1625                         return;
1626         }
1627 }
1628
1629 /*****************************************************************************
1630  * mos7840_unthrottle
1631  *      this function is called by the tty driver when it wants to resume
1632  *      the data being read from the port (called after mos7840_throttle is
1633  *      called)
1634  *****************************************************************************/
1635 static void mos7840_unthrottle(struct tty_struct *tty)
1636 {
1637         struct usb_serial_port *port = tty->driver_data;
1638         int status;
1639         struct moschip_port *mos7840_port = mos7840_get_port_private(port);
1640
1641         if (mos7840_port_paranoia_check(port, __func__)) {
1642                 dbg("%s", "Invalid port");
1643                 return;
1644         }
1645
1646         if (mos7840_port == NULL)
1647                 return;
1648
1649         if (!mos7840_port->open) {
1650                 dbg("%s - port not opened", __func__);
1651                 return;
1652         }
1653
1654         dbg("%s", "Entering ..........");
1655
1656         /* if we are implementing XON/XOFF, send the start character */
1657         if (I_IXOFF(tty)) {
1658                 unsigned char start_char = START_CHAR(tty);
1659                 status = mos7840_write(tty, port, &start_char, 1);
1660                 if (status <= 0)
1661                         return;
1662         }
1663
1664         /* if we are implementing RTS/CTS, toggle that line */
1665         if (tty->termios->c_cflag & CRTSCTS) {
1666                 mos7840_port->shadowMCR |= MCR_RTS;
1667                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1668                                          mos7840_port->shadowMCR);
1669                 if (status < 0)
1670                         return;
1671         }
1672 }
1673
1674 static int mos7840_tiocmget(struct tty_struct *tty)
1675 {
1676         struct usb_serial_port *port = tty->driver_data;
1677         struct moschip_port *mos7840_port;
1678         unsigned int result;
1679         __u16 msr;
1680         __u16 mcr;
1681         int status;
1682         mos7840_port = mos7840_get_port_private(port);
1683
1684         dbg("%s - port %d", __func__, port->number);
1685
1686         if (mos7840_port == NULL)
1687                 return -ENODEV;
1688
1689         status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
1690         status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
1691         result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1692             | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1693             | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1694             | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1695             | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1696             | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1697             | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1698
1699         dbg("%s - 0x%04X", __func__, result);
1700
1701         return result;
1702 }
1703
1704 static int mos7840_tiocmset(struct tty_struct *tty,
1705                             unsigned int set, unsigned int clear)
1706 {
1707         struct usb_serial_port *port = tty->driver_data;
1708         struct moschip_port *mos7840_port;
1709         unsigned int mcr;
1710         int status;
1711
1712         dbg("%s - port %d", __func__, port->number);
1713
1714         mos7840_port = mos7840_get_port_private(port);
1715
1716         if (mos7840_port == NULL)
1717                 return -ENODEV;
1718
1719         /* FIXME: What locks the port registers ? */
1720         mcr = mos7840_port->shadowMCR;
1721         if (clear & TIOCM_RTS)
1722                 mcr &= ~MCR_RTS;
1723         if (clear & TIOCM_DTR)
1724                 mcr &= ~MCR_DTR;
1725         if (clear & TIOCM_LOOP)
1726                 mcr &= ~MCR_LOOPBACK;
1727
1728         if (set & TIOCM_RTS)
1729                 mcr |= MCR_RTS;
1730         if (set & TIOCM_DTR)
1731                 mcr |= MCR_DTR;
1732         if (set & TIOCM_LOOP)
1733                 mcr |= MCR_LOOPBACK;
1734
1735         mos7840_port->shadowMCR = mcr;
1736
1737         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1738         if (status < 0) {
1739                 dbg("setting MODEM_CONTROL_REGISTER Failed");
1740                 return status;
1741         }
1742
1743         return 0;
1744 }
1745
1746 /*****************************************************************************
1747  * mos7840_calc_baud_rate_divisor
1748  *      this function calculates the proper baud rate divisor for the specified
1749  *      baud rate.
1750  *****************************************************************************/
1751 static int mos7840_calc_baud_rate_divisor(int baudRate, int *divisor,
1752                                           __u16 *clk_sel_val)
1753 {
1754
1755         dbg("%s - %d", __func__, baudRate);
1756
1757         if (baudRate <= 115200) {
1758                 *divisor = 115200 / baudRate;
1759                 *clk_sel_val = 0x0;
1760         }
1761         if ((baudRate > 115200) && (baudRate <= 230400)) {
1762                 *divisor = 230400 / baudRate;
1763                 *clk_sel_val = 0x10;
1764         } else if ((baudRate > 230400) && (baudRate <= 403200)) {
1765                 *divisor = 403200 / baudRate;
1766                 *clk_sel_val = 0x20;
1767         } else if ((baudRate > 403200) && (baudRate <= 460800)) {
1768                 *divisor = 460800 / baudRate;
1769                 *clk_sel_val = 0x30;
1770         } else if ((baudRate > 460800) && (baudRate <= 806400)) {
1771                 *divisor = 806400 / baudRate;
1772                 *clk_sel_val = 0x40;
1773         } else if ((baudRate > 806400) && (baudRate <= 921600)) {
1774                 *divisor = 921600 / baudRate;
1775                 *clk_sel_val = 0x50;
1776         } else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1777                 *divisor = 1572864 / baudRate;
1778                 *clk_sel_val = 0x60;
1779         } else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1780                 *divisor = 3145728 / baudRate;
1781                 *clk_sel_val = 0x70;
1782         }
1783         return 0;
1784
1785 #ifdef NOTMCS7840
1786
1787         for (i = 0; i < ARRAY_SIZE(mos7840_divisor_table); i++) {
1788                 if (mos7840_divisor_table[i].BaudRate == baudrate) {
1789                         *divisor = mos7840_divisor_table[i].Divisor;
1790                         return 0;
1791                 }
1792         }
1793
1794         /* After trying for all the standard baud rates    *
1795          * Try calculating the divisor for this baud rate  */
1796
1797         if (baudrate > 75 && baudrate < 230400) {
1798                 /* get the divisor */
1799                 custom = (__u16) (230400L / baudrate);
1800
1801                 /* Check for round off */
1802                 round1 = (__u16) (2304000L / baudrate);
1803                 round = (__u16) (round1 - (custom * 10));
1804                 if (round > 4)
1805                         custom++;
1806                 *divisor = custom;
1807
1808                 dbg(" Baud %d = %d", baudrate, custom);
1809                 return 0;
1810         }
1811
1812         dbg("%s", " Baud calculation Failed...");
1813         return -1;
1814 #endif
1815 }
1816
1817 /*****************************************************************************
1818  * mos7840_send_cmd_write_baud_rate
1819  *      this function sends the proper command to change the baud rate of the
1820  *      specified port.
1821  *****************************************************************************/
1822
1823 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1824                                             int baudRate)
1825 {
1826         int divisor = 0;
1827         int status;
1828         __u16 Data;
1829         unsigned char number;
1830         __u16 clk_sel_val;
1831         struct usb_serial_port *port;
1832
1833         if (mos7840_port == NULL)
1834                 return -1;
1835
1836         port = (struct usb_serial_port *)mos7840_port->port;
1837         if (mos7840_port_paranoia_check(port, __func__)) {
1838                 dbg("%s", "Invalid port");
1839                 return -1;
1840         }
1841
1842         if (mos7840_serial_paranoia_check(port->serial, __func__)) {
1843                 dbg("%s", "Invalid Serial");
1844                 return -1;
1845         }
1846
1847         dbg("%s", "Entering ..........");
1848
1849         number = mos7840_port->port->number - mos7840_port->port->serial->minor;
1850
1851         dbg("%s - port = %d, baud = %d", __func__,
1852             mos7840_port->port->number, baudRate);
1853         /* reset clk_uart_sel in spregOffset */
1854         if (baudRate > 115200) {
1855 #ifdef HW_flow_control
1856                 /* NOTE: need to see the pther register to modify */
1857                 /* setting h/w flow control bit to 1 */
1858                 Data = 0x2b;
1859                 mos7840_port->shadowMCR = Data;
1860                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1861                                                                         Data);
1862                 if (status < 0) {
1863                         dbg("Writing spreg failed in set_serial_baud");
1864                         return -1;
1865                 }
1866 #endif
1867
1868         } else {
1869 #ifdef HW_flow_control
1870                 /* setting h/w flow control bit to 0 */
1871                 Data = 0xb;
1872                 mos7840_port->shadowMCR = Data;
1873                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1874                                                                         Data);
1875                 if (status < 0) {
1876                         dbg("Writing spreg failed in set_serial_baud");
1877                         return -1;
1878                 }
1879 #endif
1880
1881         }
1882
1883         if (1) {                /* baudRate <= 115200) */
1884                 clk_sel_val = 0x0;
1885                 Data = 0x0;
1886                 status = mos7840_calc_baud_rate_divisor(baudRate, &divisor,
1887                                                    &clk_sel_val);
1888                 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1889                                                                  &Data);
1890                 if (status < 0) {
1891                         dbg("reading spreg failed in set_serial_baud");
1892                         return -1;
1893                 }
1894                 Data = (Data & 0x8f) | clk_sel_val;
1895                 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1896                                                                 Data);
1897                 if (status < 0) {
1898                         dbg("Writing spreg failed in set_serial_baud");
1899                         return -1;
1900                 }
1901                 /* Calculate the Divisor */
1902
1903                 if (status) {
1904                         dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1905                         return status;
1906                 }
1907                 /* Enable access to divisor latch */
1908                 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1909                 mos7840_port->shadowLCR = Data;
1910                 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1911
1912                 /* Write the divisor */
1913                 Data = (unsigned char)(divisor & 0xff);
1914                 dbg("set_serial_baud Value to write DLL is %x", Data);
1915                 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1916
1917                 Data = (unsigned char)((divisor & 0xff00) >> 8);
1918                 dbg("set_serial_baud Value to write DLM is %x", Data);
1919                 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1920
1921                 /* Disable access to divisor latch */
1922                 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1923                 mos7840_port->shadowLCR = Data;
1924                 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1925
1926         }
1927         return status;
1928 }
1929
1930 /*****************************************************************************
1931  * mos7840_change_port_settings
1932  *      This routine is called to set the UART on the device to match
1933  *      the specified new settings.
1934  *****************************************************************************/
1935
1936 static void mos7840_change_port_settings(struct tty_struct *tty,
1937         struct moschip_port *mos7840_port, struct ktermios *old_termios)
1938 {
1939         int baud;
1940         unsigned cflag;
1941         unsigned iflag;
1942         __u8 lData;
1943         __u8 lParity;
1944         __u8 lStop;
1945         int status;
1946         __u16 Data;
1947         struct usb_serial_port *port;
1948         struct usb_serial *serial;
1949
1950         if (mos7840_port == NULL)
1951                 return;
1952
1953         port = (struct usb_serial_port *)mos7840_port->port;
1954
1955         if (mos7840_port_paranoia_check(port, __func__)) {
1956                 dbg("%s", "Invalid port");
1957                 return;
1958         }
1959
1960         if (mos7840_serial_paranoia_check(port->serial, __func__)) {
1961                 dbg("%s", "Invalid Serial");
1962                 return;
1963         }
1964
1965         serial = port->serial;
1966
1967         dbg("%s - port %d", __func__, mos7840_port->port->number);
1968
1969         if (!mos7840_port->open) {
1970                 dbg("%s - port not opened", __func__);
1971                 return;
1972         }
1973
1974         dbg("%s", "Entering ..........");
1975
1976         lData = LCR_BITS_8;
1977         lStop = LCR_STOP_1;
1978         lParity = LCR_PAR_NONE;
1979
1980         cflag = tty->termios->c_cflag;
1981         iflag = tty->termios->c_iflag;
1982
1983         /* Change the number of bits */
1984         if (cflag & CSIZE) {
1985                 switch (cflag & CSIZE) {
1986                 case CS5:
1987                         lData = LCR_BITS_5;
1988                         break;
1989
1990                 case CS6:
1991                         lData = LCR_BITS_6;
1992                         break;
1993
1994                 case CS7:
1995                         lData = LCR_BITS_7;
1996                         break;
1997                 default:
1998                 case CS8:
1999                         lData = LCR_BITS_8;
2000                         break;
2001                 }
2002         }
2003         /* Change the Parity bit */
2004         if (cflag & PARENB) {
2005                 if (cflag & PARODD) {
2006                         lParity = LCR_PAR_ODD;
2007                         dbg("%s - parity = odd", __func__);
2008                 } else {
2009                         lParity = LCR_PAR_EVEN;
2010                         dbg("%s - parity = even", __func__);
2011                 }
2012
2013         } else {
2014                 dbg("%s - parity = none", __func__);
2015         }
2016
2017         if (cflag & CMSPAR)
2018                 lParity = lParity | 0x20;
2019
2020         /* Change the Stop bit */
2021         if (cflag & CSTOPB) {
2022                 lStop = LCR_STOP_2;
2023                 dbg("%s - stop bits = 2", __func__);
2024         } else {
2025                 lStop = LCR_STOP_1;
2026                 dbg("%s - stop bits = 1", __func__);
2027         }
2028
2029         /* Update the LCR with the correct value */
2030         mos7840_port->shadowLCR &=
2031             ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
2032         mos7840_port->shadowLCR |= (lData | lParity | lStop);
2033
2034         dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x",
2035             mos7840_port->shadowLCR);
2036         /* Disable Interrupts */
2037         Data = 0x00;
2038         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
2039
2040         Data = 0x00;
2041         mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
2042
2043         Data = 0xcf;
2044         mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
2045
2046         /* Send the updated LCR value to the mos7840 */
2047         Data = mos7840_port->shadowLCR;
2048
2049         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
2050
2051         Data = 0x00b;
2052         mos7840_port->shadowMCR = Data;
2053         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
2054         Data = 0x00b;
2055         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
2056
2057         /* set up the MCR register and send it to the mos7840 */
2058
2059         mos7840_port->shadowMCR = MCR_MASTER_IE;
2060         if (cflag & CBAUD)
2061                 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
2062
2063         if (cflag & CRTSCTS)
2064                 mos7840_port->shadowMCR |= (MCR_XON_ANY);
2065         else
2066                 mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
2067
2068         Data = mos7840_port->shadowMCR;
2069         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
2070
2071         /* Determine divisor based on baud rate */
2072         baud = tty_get_baud_rate(tty);
2073
2074         if (!baud) {
2075                 /* pick a default, any default... */
2076                 dbg("%s", "Picked default baud...");
2077                 baud = 9600;
2078         }
2079
2080         dbg("%s - baud rate = %d", __func__, baud);
2081         status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
2082
2083         /* Enable Interrupts */
2084         Data = 0x0c;
2085         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
2086
2087         if (mos7840_port->read_urb_busy == false) {
2088                 mos7840_port->read_urb->dev = serial->dev;
2089                 mos7840_port->read_urb_busy = true;
2090                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
2091                 if (status) {
2092                         dbg("usb_submit_urb(read bulk) failed, status = %d",
2093                             status);
2094                         mos7840_port->read_urb_busy = false;
2095                 }
2096         }
2097         wake_up(&mos7840_port->delta_msr_wait);
2098         mos7840_port->delta_msr_cond = 1;
2099         dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x",
2100             mos7840_port->shadowLCR);
2101 }
2102
2103 /*****************************************************************************
2104  * mos7840_set_termios
2105  *      this function is called by the tty driver when it wants to change
2106  *      the termios structure
2107  *****************************************************************************/
2108
2109 static void mos7840_set_termios(struct tty_struct *tty,
2110                                 struct usb_serial_port *port,
2111                                 struct ktermios *old_termios)
2112 {
2113         int status;
2114         unsigned int cflag;
2115         struct usb_serial *serial;
2116         struct moschip_port *mos7840_port;
2117         dbg("mos7840_set_termios: START");
2118         if (mos7840_port_paranoia_check(port, __func__)) {
2119                 dbg("%s", "Invalid port");
2120                 return;
2121         }
2122
2123         serial = port->serial;
2124
2125         if (mos7840_serial_paranoia_check(serial, __func__)) {
2126                 dbg("%s", "Invalid Serial");
2127                 return;
2128         }
2129
2130         mos7840_port = mos7840_get_port_private(port);
2131
2132         if (mos7840_port == NULL)
2133                 return;
2134
2135         if (!mos7840_port->open) {
2136                 dbg("%s - port not opened", __func__);
2137                 return;
2138         }
2139
2140         dbg("%s", "setting termios - ");
2141
2142         cflag = tty->termios->c_cflag;
2143
2144         dbg("%s - clfag %08x iflag %08x", __func__,
2145             tty->termios->c_cflag, RELEVANT_IFLAG(tty->termios->c_iflag));
2146         dbg("%s - old clfag %08x old iflag %08x", __func__,
2147             old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
2148         dbg("%s - port %d", __func__, port->number);
2149
2150         /* change the port settings to the new ones specified */
2151
2152         mos7840_change_port_settings(tty, mos7840_port, old_termios);
2153
2154         if (!mos7840_port->read_urb) {
2155                 dbg("%s", "URB KILLED !!!!!");
2156                 return;
2157         }
2158
2159         if (mos7840_port->read_urb_busy == false) {
2160                 mos7840_port->read_urb->dev = serial->dev;
2161                 mos7840_port->read_urb_busy = true;
2162                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
2163                 if (status) {
2164                         dbg("usb_submit_urb(read bulk) failed, status = %d",
2165                             status);
2166                         mos7840_port->read_urb_busy = false;
2167                 }
2168         }
2169 }
2170
2171 /*****************************************************************************
2172  * mos7840_get_lsr_info - get line status register info
2173  *
2174  * Purpose: Let user call ioctl() to get info when the UART physically
2175  *          is emptied.  On bus types like RS485, the transmitter must
2176  *          release the bus after transmitting. This must be done when
2177  *          the transmit shift register is empty, not be done when the
2178  *          transmit holding register is empty.  This functionality
2179  *          allows an RS485 driver to be written in user space.
2180  *****************************************************************************/
2181
2182 static int mos7840_get_lsr_info(struct tty_struct *tty,
2183                                 unsigned int __user *value)
2184 {
2185         int count;
2186         unsigned int result = 0;
2187
2188         count = mos7840_chars_in_buffer(tty);
2189         if (count == 0) {
2190                 dbg("%s -- Empty", __func__);
2191                 result = TIOCSER_TEMT;
2192         }
2193
2194         if (copy_to_user(value, &result, sizeof(int)))
2195                 return -EFAULT;
2196         return 0;
2197 }
2198
2199 /*****************************************************************************
2200  * mos7840_get_serial_info
2201  *      function to get information about serial port
2202  *****************************************************************************/
2203
2204 static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
2205                                    struct serial_struct __user *retinfo)
2206 {
2207         struct serial_struct tmp;
2208
2209         if (mos7840_port == NULL)
2210                 return -1;
2211
2212         if (!retinfo)
2213                 return -EFAULT;
2214
2215         memset(&tmp, 0, sizeof(tmp));
2216
2217         tmp.type = PORT_16550A;
2218         tmp.line = mos7840_port->port->serial->minor;
2219         tmp.port = mos7840_port->port->number;
2220         tmp.irq = 0;
2221         tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
2222         tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
2223         tmp.baud_base = 9600;
2224         tmp.close_delay = 5 * HZ;
2225         tmp.closing_wait = 30 * HZ;
2226
2227         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2228                 return -EFAULT;
2229         return 0;
2230 }
2231
2232 static int mos7840_get_icount(struct tty_struct *tty,
2233                         struct serial_icounter_struct *icount)
2234 {
2235         struct usb_serial_port *port = tty->driver_data;
2236         struct moschip_port *mos7840_port;
2237         struct async_icount cnow;
2238
2239         mos7840_port = mos7840_get_port_private(port);
2240         cnow = mos7840_port->icount;
2241
2242         smp_rmb();
2243         icount->cts = cnow.cts;
2244         icount->dsr = cnow.dsr;
2245         icount->rng = cnow.rng;
2246         icount->dcd = cnow.dcd;
2247         icount->rx = cnow.rx;
2248         icount->tx = cnow.tx;
2249         icount->frame = cnow.frame;
2250         icount->overrun = cnow.overrun;
2251         icount->parity = cnow.parity;
2252         icount->brk = cnow.brk;
2253         icount->buf_overrun = cnow.buf_overrun;
2254
2255         dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
2256                 port->number, icount->rx, icount->tx);
2257         return 0;
2258 }
2259
2260 /*****************************************************************************
2261  * SerialIoctl
2262  *      this function handles any ioctl calls to the driver
2263  *****************************************************************************/
2264
2265 static int mos7840_ioctl(struct tty_struct *tty,
2266                          unsigned int cmd, unsigned long arg)
2267 {
2268         struct usb_serial_port *port = tty->driver_data;
2269         void __user *argp = (void __user *)arg;
2270         struct moschip_port *mos7840_port;
2271
2272         struct async_icount cnow;
2273         struct async_icount cprev;
2274
2275         if (mos7840_port_paranoia_check(port, __func__)) {
2276                 dbg("%s", "Invalid port");
2277                 return -1;
2278         }
2279
2280         mos7840_port = mos7840_get_port_private(port);
2281
2282         if (mos7840_port == NULL)
2283                 return -1;
2284
2285         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
2286
2287         switch (cmd) {
2288                 /* return number of bytes available */
2289
2290         case TIOCSERGETLSR:
2291                 dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
2292                 return mos7840_get_lsr_info(tty, argp);
2293
2294         case TIOCGSERIAL:
2295                 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
2296                 return mos7840_get_serial_info(mos7840_port, argp);
2297
2298         case TIOCSSERIAL:
2299                 dbg("%s (%d) TIOCSSERIAL", __func__, port->number);
2300                 break;
2301
2302         case TIOCMIWAIT:
2303                 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
2304                 cprev = mos7840_port->icount;
2305                 while (1) {
2306                         /* interruptible_sleep_on(&mos7840_port->delta_msr_wait); */
2307                         mos7840_port->delta_msr_cond = 0;
2308                         wait_event_interruptible(mos7840_port->delta_msr_wait,
2309                                                  (mos7840_port->
2310                                                   delta_msr_cond == 1));
2311
2312                         /* see if a signal did it */
2313                         if (signal_pending(current))
2314                                 return -ERESTARTSYS;
2315                         cnow = mos7840_port->icount;
2316                         smp_rmb();
2317                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2318                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2319                                 return -EIO;    /* no change => error */
2320                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2321                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2322                             ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
2323                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
2324                                 return 0;
2325                         }
2326                         cprev = cnow;
2327                 }
2328                 /* NOTREACHED */
2329                 break;
2330
2331         default:
2332                 break;
2333         }
2334         return -ENOIOCTLCMD;
2335 }
2336
2337 static int mos7840_calc_num_ports(struct usb_serial *serial)
2338 {
2339         __u16 Data = 0x00;
2340         int ret = 0;
2341         int mos7840_num_ports;
2342
2343         ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2344                 MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, &Data,
2345                 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
2346
2347         if ((Data & 0x01) == 0) {
2348                 mos7840_num_ports = 2;
2349                 serial->num_bulk_in = 2;
2350                 serial->num_bulk_out = 2;
2351                 serial->num_ports = 2;
2352         } else {
2353                 mos7840_num_ports = 4;
2354                 serial->num_bulk_in = 4;
2355                 serial->num_bulk_out = 4;
2356                 serial->num_ports = 4;
2357         }
2358
2359         return mos7840_num_ports;
2360 }
2361
2362 /****************************************************************************
2363  * mos7840_startup
2364  ****************************************************************************/
2365
2366 static int mos7840_startup(struct usb_serial *serial)
2367 {
2368         struct moschip_port *mos7840_port;
2369         struct usb_device *dev;
2370         int i, status;
2371
2372         __u16 Data;
2373         dbg("%s", "mos7840_startup :Entering..........");
2374
2375         if (!serial) {
2376                 dbg("%s", "Invalid Handler");
2377                 return -1;
2378         }
2379
2380         dev = serial->dev;
2381
2382         dbg("%s", "Entering...");
2383         dbg ("mos7840_startup: serial = %p", serial);
2384
2385         /* we set up the pointers to the endpoints in the mos7840_open *
2386          * function, as the structures aren't created yet.             */
2387
2388         /* set up port private structures */
2389         for (i = 0; i < serial->num_ports; ++i) {
2390                 dbg ("mos7840_startup: configuring port %d............", i);
2391                 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
2392                 if (mos7840_port == NULL) {
2393                         dev_err(&dev->dev, "%s - Out of memory\n", __func__);
2394                         status = -ENOMEM;
2395                         i--; /* don't follow NULL pointer cleaning up */
2396                         goto error;
2397                 }
2398
2399                 /* Initialize all port interrupt end point to port 0 int
2400                  * endpoint. Our device has only one interrupt end point
2401                  * common to all port */
2402
2403                 mos7840_port->port = serial->port[i];
2404                 mos7840_set_port_private(serial->port[i], mos7840_port);
2405                 spin_lock_init(&mos7840_port->pool_lock);
2406
2407                 /* minor is not initialised until later by
2408                  * usb-serial.c:get_free_serial() and cannot therefore be used
2409                  * to index device instances */
2410                 mos7840_port->port_num = i + 1;
2411                 dbg ("serial->port[i]->number = %d", serial->port[i]->number);
2412                 dbg ("serial->port[i]->serial->minor = %d", serial->port[i]->serial->minor);
2413                 dbg ("mos7840_port->port_num = %d", mos7840_port->port_num);
2414                 dbg ("serial->minor = %d", serial->minor);
2415
2416                 if (mos7840_port->port_num == 1) {
2417                         mos7840_port->SpRegOffset = 0x0;
2418                         mos7840_port->ControlRegOffset = 0x1;
2419                         mos7840_port->DcrRegOffset = 0x4;
2420                 } else if ((mos7840_port->port_num == 2)
2421                            && (serial->num_ports == 4)) {
2422                         mos7840_port->SpRegOffset = 0x8;
2423                         mos7840_port->ControlRegOffset = 0x9;
2424                         mos7840_port->DcrRegOffset = 0x16;
2425                 } else if ((mos7840_port->port_num == 2)
2426                            && (serial->num_ports == 2)) {
2427                         mos7840_port->SpRegOffset = 0xa;
2428                         mos7840_port->ControlRegOffset = 0xb;
2429                         mos7840_port->DcrRegOffset = 0x19;
2430                 } else if ((mos7840_port->port_num == 3)
2431                            && (serial->num_ports == 4)) {
2432                         mos7840_port->SpRegOffset = 0xa;
2433                         mos7840_port->ControlRegOffset = 0xb;
2434                         mos7840_port->DcrRegOffset = 0x19;
2435                 } else if ((mos7840_port->port_num == 4)
2436                            && (serial->num_ports == 4)) {
2437                         mos7840_port->SpRegOffset = 0xc;
2438                         mos7840_port->ControlRegOffset = 0xd;
2439                         mos7840_port->DcrRegOffset = 0x1c;
2440                 }
2441                 mos7840_dump_serial_port(mos7840_port);
2442                 mos7840_set_port_private(serial->port[i], mos7840_port);
2443
2444                 /* enable rx_disable bit in control register */
2445                 status = mos7840_get_reg_sync(serial->port[i],
2446                                  mos7840_port->ControlRegOffset, &Data);
2447                 if (status < 0) {
2448                         dbg("Reading ControlReg failed status-0x%x", status);
2449                         break;
2450                 } else
2451                         dbg("ControlReg Reading success val is %x, status%d",
2452                             Data, status);
2453                 Data |= 0x08;   /* setting driver done bit */
2454                 Data |= 0x04;   /* sp1_bit to have cts change reflect in
2455                                    modem status reg */
2456
2457                 /* Data |= 0x20; //rx_disable bit */
2458                 status = mos7840_set_reg_sync(serial->port[i],
2459                                          mos7840_port->ControlRegOffset, Data);
2460                 if (status < 0) {
2461                         dbg("Writing ControlReg failed(rx_disable) status-0x%x", status);
2462                         break;
2463                 } else
2464                         dbg("ControlReg Writing success(rx_disable) status%d",
2465                             status);
2466
2467                 /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
2468                    and 0x24 in DCR3 */
2469                 Data = 0x01;
2470                 status = mos7840_set_reg_sync(serial->port[i],
2471                          (__u16) (mos7840_port->DcrRegOffset + 0), Data);
2472                 if (status < 0) {
2473                         dbg("Writing DCR0 failed status-0x%x", status);
2474                         break;
2475                 } else
2476                         dbg("DCR0 Writing success status%d", status);
2477
2478                 Data = 0x05;
2479                 status = mos7840_set_reg_sync(serial->port[i],
2480                          (__u16) (mos7840_port->DcrRegOffset + 1), Data);
2481                 if (status < 0) {
2482                         dbg("Writing DCR1 failed status-0x%x", status);
2483                         break;
2484                 } else
2485                         dbg("DCR1 Writing success status%d", status);
2486
2487                 Data = 0x24;
2488                 status = mos7840_set_reg_sync(serial->port[i],
2489                          (__u16) (mos7840_port->DcrRegOffset + 2), Data);
2490                 if (status < 0) {
2491                         dbg("Writing DCR2 failed status-0x%x", status);
2492                         break;
2493                 } else
2494                         dbg("DCR2 Writing success status%d", status);
2495
2496                 /* write values in clkstart0x0 and clkmulti 0x20 */
2497                 Data = 0x0;
2498                 status = mos7840_set_reg_sync(serial->port[i],
2499                                          CLK_START_VALUE_REGISTER, Data);
2500                 if (status < 0) {
2501                         dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x", status);
2502                         break;
2503                 } else
2504                         dbg("CLK_START_VALUE_REGISTER Writing success status%d", status);
2505
2506                 Data = 0x20;
2507                 status = mos7840_set_reg_sync(serial->port[i],
2508                                         CLK_MULTI_REGISTER, Data);
2509                 if (status < 0) {
2510                         dbg("Writing CLK_MULTI_REGISTER failed status-0x%x",
2511                             status);
2512                         goto error;
2513                 } else
2514                         dbg("CLK_MULTI_REGISTER Writing success status%d",
2515                             status);
2516
2517                 /* write value 0x0 to scratchpad register */
2518                 Data = 0x00;
2519                 status = mos7840_set_uart_reg(serial->port[i],
2520                                                 SCRATCH_PAD_REGISTER, Data);
2521                 if (status < 0) {
2522                         dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x",
2523                             status);
2524                         break;
2525                 } else
2526                         dbg("SCRATCH_PAD_REGISTER Writing success status%d",
2527                             status);
2528
2529                 /* Zero Length flag register */
2530                 if ((mos7840_port->port_num != 1)
2531                     && (serial->num_ports == 2)) {
2532
2533                         Data = 0xff;
2534                         status = mos7840_set_reg_sync(serial->port[i],
2535                                       (__u16) (ZLP_REG1 +
2536                                       ((__u16)mos7840_port->port_num)), Data);
2537                         dbg("ZLIP offset %x",
2538                             (__u16) (ZLP_REG1 +
2539                                         ((__u16) mos7840_port->port_num)));
2540                         if (status < 0) {
2541                                 dbg("Writing ZLP_REG%d failed status-0x%x",
2542                                     i + 2, status);
2543                                 break;
2544                         } else
2545                                 dbg("ZLP_REG%d Writing success status%d",
2546                                     i + 2, status);
2547                 } else {
2548                         Data = 0xff;
2549                         status = mos7840_set_reg_sync(serial->port[i],
2550                               (__u16) (ZLP_REG1 +
2551                               ((__u16)mos7840_port->port_num) - 0x1), Data);
2552                         dbg("ZLIP offset %x",
2553                             (__u16) (ZLP_REG1 +
2554                                      ((__u16) mos7840_port->port_num) - 0x1));
2555                         if (status < 0) {
2556                                 dbg("Writing ZLP_REG%d failed status-0x%x",
2557                                     i + 1, status);
2558                                 break;
2559                         } else
2560                                 dbg("ZLP_REG%d Writing success status%d",
2561                                     i + 1, status);
2562
2563                 }
2564                 mos7840_port->control_urb = usb_alloc_urb(0, GFP_KERNEL);
2565                 mos7840_port->ctrl_buf = kmalloc(16, GFP_KERNEL);
2566                 mos7840_port->dr = kmalloc(sizeof(struct usb_ctrlrequest),
2567                                                                 GFP_KERNEL);
2568                 if (!mos7840_port->control_urb || !mos7840_port->ctrl_buf ||
2569                                                         !mos7840_port->dr) {
2570                         status = -ENOMEM;
2571                         goto error;
2572                 }
2573         }
2574         dbg ("mos7840_startup: all ports configured...........");
2575
2576         /* Zero Length flag enable */
2577         Data = 0x0f;
2578         status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data);
2579         if (status < 0) {
2580                 dbg("Writing ZLP_REG5 failed status-0x%x", status);
2581                 goto error;
2582         } else
2583                 dbg("ZLP_REG5 Writing success status%d", status);
2584
2585         /* setting configuration feature to one */
2586         usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
2587                         (__u8) 0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5 * HZ);
2588         return 0;
2589 error:
2590         for (/* nothing */; i >= 0; i--) {
2591                 mos7840_port = mos7840_get_port_private(serial->port[i]);
2592
2593                 kfree(mos7840_port->dr);
2594                 kfree(mos7840_port->ctrl_buf);
2595                 usb_free_urb(mos7840_port->control_urb);
2596                 kfree(mos7840_port);
2597                 serial->port[i] = NULL;
2598         }
2599         return status;
2600 }
2601
2602 /****************************************************************************
2603  * mos7840_disconnect
2604  *      This function is called whenever the device is removed from the usb bus.
2605  ****************************************************************************/
2606
2607 static void mos7840_disconnect(struct usb_serial *serial)
2608 {
2609         int i;
2610         unsigned long flags;
2611         struct moschip_port *mos7840_port;
2612         dbg("%s", " disconnect :entering..........");
2613
2614         if (!serial) {
2615                 dbg("%s", "Invalid Handler");
2616                 return;
2617         }
2618
2619         /* check for the ports to be closed,close the ports and disconnect */
2620
2621         /* free private structure allocated for serial port  *
2622          * stop reads and writes on all ports                */
2623
2624         for (i = 0; i < serial->num_ports; ++i) {
2625                 mos7840_port = mos7840_get_port_private(serial->port[i]);
2626                 dbg ("mos7840_port %d = %p", i, mos7840_port);
2627                 if (mos7840_port) {
2628                         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
2629                         mos7840_port->zombie = 1;
2630                         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
2631                         usb_kill_urb(mos7840_port->control_urb);
2632                 }
2633         }
2634
2635         dbg("%s", "Thank u :: ");
2636
2637 }
2638
2639 /****************************************************************************
2640  * mos7840_release
2641  *      This function is called when the usb_serial structure is freed.
2642  ****************************************************************************/
2643
2644 static void mos7840_release(struct usb_serial *serial)
2645 {
2646         int i;
2647         struct moschip_port *mos7840_port;
2648         dbg("%s", " release :entering..........");
2649
2650         if (!serial) {
2651                 dbg("%s", "Invalid Handler");
2652                 return;
2653         }
2654
2655         /* check for the ports to be closed,close the ports and disconnect */
2656
2657         /* free private structure allocated for serial port  *
2658          * stop reads and writes on all ports                */
2659
2660         for (i = 0; i < serial->num_ports; ++i) {
2661                 mos7840_port = mos7840_get_port_private(serial->port[i]);
2662                 dbg("mos7840_port %d = %p", i, mos7840_port);
2663                 if (mos7840_port) {
2664                         kfree(mos7840_port->ctrl_buf);
2665                         kfree(mos7840_port->dr);
2666                         kfree(mos7840_port);
2667                 }
2668         }
2669
2670         dbg("%s", "Thank u :: ");
2671
2672 }
2673
2674 static struct usb_driver io_driver = {
2675         .name = "mos7840",
2676         .probe = usb_serial_probe,
2677         .disconnect = usb_serial_disconnect,
2678         .id_table = moschip_id_table_combined,
2679         .no_dynamic_id = 1,
2680 };
2681
2682 static struct usb_serial_driver moschip7840_4port_device = {
2683         .driver = {
2684                    .owner = THIS_MODULE,
2685                    .name = "mos7840",
2686                    },
2687         .description = DRIVER_DESC,
2688         .usb_driver = &io_driver,
2689         .id_table = moschip_port_id_table,
2690         .num_ports = 4,
2691         .open = mos7840_open,
2692         .close = mos7840_close,
2693         .write = mos7840_write,
2694         .write_room = mos7840_write_room,
2695         .chars_in_buffer = mos7840_chars_in_buffer,
2696         .throttle = mos7840_throttle,
2697         .unthrottle = mos7840_unthrottle,
2698         .calc_num_ports = mos7840_calc_num_ports,
2699 #ifdef MCSSerialProbe
2700         .probe = mos7840_serial_probe,
2701 #endif
2702         .ioctl = mos7840_ioctl,
2703         .set_termios = mos7840_set_termios,
2704         .break_ctl = mos7840_break,
2705         .tiocmget = mos7840_tiocmget,
2706         .tiocmset = mos7840_tiocmset,
2707         .get_icount = mos7840_get_icount,
2708         .attach = mos7840_startup,
2709         .disconnect = mos7840_disconnect,
2710         .release = mos7840_release,
2711         .read_bulk_callback = mos7840_bulk_in_callback,
2712         .read_int_callback = mos7840_interrupt_callback,
2713 };
2714
2715 /****************************************************************************
2716  * moschip7840_init
2717  *      This is called by the module subsystem, or on startup to initialize us
2718  ****************************************************************************/
2719 static int __init moschip7840_init(void)
2720 {
2721         int retval;
2722
2723         dbg("%s", " mos7840_init :entering..........");
2724
2725         /* Register with the usb serial */
2726         retval = usb_serial_register(&moschip7840_4port_device);
2727
2728         if (retval)
2729                 goto failed_port_device_register;
2730
2731         dbg("%s", "Entering...");
2732         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
2733                DRIVER_DESC "\n");
2734
2735         /* Register with the usb */
2736         retval = usb_register(&io_driver);
2737         if (retval == 0) {
2738                 dbg("%s", "Leaving...");
2739                 return 0;
2740         }
2741         usb_serial_deregister(&moschip7840_4port_device);
2742 failed_port_device_register:
2743         return retval;
2744 }
2745
2746 /****************************************************************************
2747  * moschip7840_exit
2748  *      Called when the driver is about to be unloaded.
2749  ****************************************************************************/
2750 static void __exit moschip7840_exit(void)
2751 {
2752
2753         dbg("%s", " mos7840_exit :entering..........");
2754
2755         usb_deregister(&io_driver);
2756
2757         usb_serial_deregister(&moschip7840_4port_device);
2758
2759         dbg("%s", "Entering...");
2760 }
2761
2762 module_init(moschip7840_init);
2763 module_exit(moschip7840_exit);
2764
2765 /* Module information */
2766 MODULE_DESCRIPTION(DRIVER_DESC);
2767 MODULE_LICENSE("GPL");
2768
2769 module_param(debug, bool, S_IRUGO | S_IWUSR);
2770 MODULE_PARM_DESC(debug, "Debug enabled or not");