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