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