drivers/usb/serial/mos7840.c

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