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 /*
  93  * Vendor id and device id defines
  94  *
  95  * NOTE: Do not add new defines, add entries directly to the id_table instead.
  96  */
  97 #define USB_VENDOR_ID_BANDB              0x0856
  98 #define BANDB_DEVICE_ID_USO9ML2_2        0xAC22
  99 #define BANDB_DEVICE_ID_USO9ML2_2P       0xBC00
 100 #define BANDB_DEVICE_ID_USO9ML2_4        0xAC24
 101 #define BANDB_DEVICE_ID_USO9ML2_4P       0xBC01
 102 #define BANDB_DEVICE_ID_US9ML2_2         0xAC29
 103 #define BANDB_DEVICE_ID_US9ML2_4         0xAC30
 104 #define BANDB_DEVICE_ID_USPTL4_2         0xAC31
 105 #define BANDB_DEVICE_ID_USPTL4_4         0xAC32
 106 #define BANDB_DEVICE_ID_USOPTL4_2        0xAC42
 107 #define BANDB_DEVICE_ID_USOPTL4_2P       0xBC02
 108 #define BANDB_DEVICE_ID_USOPTL4_4        0xAC44
 109 #define BANDB_DEVICE_ID_USOPTL4_4P       0xBC03
 110
 111 /* Interrupt Routine Defines    */
 112
 113 #define SERIAL_IIR_RLS      0x06
 114 #define SERIAL_IIR_MS       0x00
 115
 116 /*
 117  *  Emulation of the bit mask on the LINE STATUS REGISTER.
 118  */
 119 #define SERIAL_LSR_DR       0x0001
 120 #define SERIAL_LSR_OE       0x0002
 121 #define SERIAL_LSR_PE       0x0004
 122 #define SERIAL_LSR_FE       0x0008
 123 #define SERIAL_LSR_BI       0x0010
 124
 125 #define MOS_MSR_DELTA_CTS   0x10
 126 #define MOS_MSR_DELTA_DSR   0x20
 127 #define MOS_MSR_DELTA_RI    0x40
 128 #define MOS_MSR_DELTA_CD    0x80
 129
 130 /* Serial Port register Address */
 131 #define INTERRUPT_ENABLE_REGISTER  ((__u16)(0x01))
 132 #define FIFO_CONTROL_REGISTER      ((__u16)(0x02))
 133 #define LINE_CONTROL_REGISTER      ((__u16)(0x03))
 134 #define MODEM_CONTROL_REGISTER     ((__u16)(0x04))
 135 #define LINE_STATUS_REGISTER       ((__u16)(0x05))
 136 #define MODEM_STATUS_REGISTER      ((__u16)(0x06))
 137 #define SCRATCH_PAD_REGISTER       ((__u16)(0x07))
 138 #define DIVISOR_LATCH_LSB          ((__u16)(0x00))
 139 #define DIVISOR_LATCH_MSB          ((__u16)(0x01))
 140
 141 #define CLK_MULTI_REGISTER         ((__u16)(0x02))
 142 #define CLK_START_VALUE_REGISTER   ((__u16)(0x03))
 143 #define GPIO_REGISTER              ((__u16)(0x07))
 144
 145 #define SERIAL_LCR_DLAB            ((__u16)(0x0080))
 146
 147 /*
 148  * URB POOL related defines
 149  */
 150 #define NUM_URBS                        16      /* URB Count */
 151 #define URB_TRANSFER_BUFFER_SIZE        32      /* URB Size  */
 152
 153 /* LED on/off milliseconds*/
 154 #define LED_ON_MS       500
 155 #define LED_OFF_MS      500
 156
 157 enum mos7840_flag {
 158         MOS7840_FLAG_LED_BUSY,
 159 };
 160
 161 #define MCS_PORT_MASK   GENMASK(2, 0)
 162 #define MCS_PORTS(nr)   ((nr) & MCS_PORT_MASK)
 163 #define MCS_LED         BIT(3)
 164
 165 #define MCS_DEVICE(vid, pid, flags) \
 166                 USB_DEVICE((vid), (pid)), .driver_info = (flags)
 167
 168 static const struct usb_device_id id_table[] = {
 169         { MCS_DEVICE(0x0557, 0x2011, MCS_PORTS(4)) },   /* ATEN UC2324 */
 170         { MCS_DEVICE(0x0557, 0x7820, MCS_PORTS(2)) },   /* ATEN UC2322 */
 171         { MCS_DEVICE(0x110a, 0x2210, MCS_PORTS(2)) },   /* Moxa UPort 2210 */
 172         { MCS_DEVICE(0x9710, 0x7810, MCS_PORTS(1) | MCS_LED) }, /* ASIX MCS7810 */
 173         { MCS_DEVICE(0x9710, 0x7820, MCS_PORTS(2)) },   /* MosChip MCS7820 */
 174         { MCS_DEVICE(0x9710, 0x7840, MCS_PORTS(4)) },   /* MosChip MCS7840 */
 175         { MCS_DEVICE(0x9710, 0x7843, MCS_PORTS(3)) },   /* ASIX MCS7840 3 port */
 176         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2) },
 177         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P) },
 178         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4) },
 179         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P) },
 180         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2) },
 181         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4) },
 182         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2) },
 183         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4) },
 184         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2) },
 185         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P) },
 186         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4) },
 187         { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P) },
 188         {}                      /* terminating entry */
 189 };
 190 MODULE_DEVICE_TABLE(usb, id_table);
 191
 192 /* This structure holds all of the local port information */
 193
 194 struct moschip_port {
 195         int port_num;           /*Actual port number in the device(1,2,etc) */
 196         struct urb *read_urb;   /* read URB for this port */
 197         __u8 shadowLCR;         /* last LCR value received */
 198         __u8 shadowMCR;         /* last MCR value received */
 199         struct usb_serial_port *port;   /* loop back to the owner of this object */
 200
 201         /* Offsets */
 202         __u8 SpRegOffset;
 203         __u8 ControlRegOffset;
 204         __u8 DcrRegOffset;
 205
 206         spinlock_t pool_lock;
 207         struct urb *write_urb_pool[NUM_URBS];
 208         char busy[NUM_URBS];
 209         bool read_urb_busy;
 210
 211         /* For device(s) with LED indicator */
 212         bool has_led;
 213         struct timer_list led_timer1;   /* Timer for LED on */
 214         struct timer_list led_timer2;   /* Timer for LED off */
 215         struct urb *led_urb;
 216         struct usb_ctrlrequest *led_dr;
 217
 218         unsigned long flags;
 219 };
 220
 221 /*
 222  * mos7840_set_reg_sync
 223  *      To set the Control register by calling usb_fill_control_urb function
 224  *      by passing usb_sndctrlpipe function as parameter.
 225  */
 226
 227 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
 228                                 __u16 val)
 229 {
 230         struct usb_device *dev = port->serial->dev;
 231         val = val & 0x00ff;
 232         dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val);
 233
 234         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
 235                                MCS_WR_RTYPE, val, reg, NULL, 0,
 236                                MOS_WDR_TIMEOUT);
 237 }
 238
 239 /*
 240  * mos7840_get_reg_sync
 241  *      To set the Uart register by calling usb_fill_control_urb function by
 242  *      passing usb_rcvctrlpipe function as parameter.
 243  */
 244
 245 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
 246                                 __u16 *val)
 247 {
 248         struct usb_device *dev = port->serial->dev;
 249         int ret = 0;
 250         u8 *buf;
 251
 252         buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
 253         if (!buf)
 254                 return -ENOMEM;
 255
 256         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
 257                               MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
 258                               MOS_WDR_TIMEOUT);
 259         if (ret < VENDOR_READ_LENGTH) {
 260                 if (ret >= 0)
 261                         ret = -EIO;
 262                 goto out;
 263         }
 264
 265         *val = buf[0];
 266         dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val);
 267 out:
 268         kfree(buf);
 269         return ret;
 270 }
 271
 272 /*
 273  * mos7840_set_uart_reg
 274  *      To set the Uart register by calling usb_fill_control_urb function by
 275  *      passing usb_sndctrlpipe function as parameter.
 276  */
 277
 278 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
 279                                 __u16 val)
 280 {
 281
 282         struct usb_device *dev = port->serial->dev;
 283         val = val & 0x00ff;
 284         /* For the UART control registers, the application number need
 285            to be Or'ed */
 286         if (port->serial->num_ports == 2 && port->port_number != 0)
 287                 val |= ((__u16)port->port_number + 2) << 8;
 288         else
 289                 val |= ((__u16)port->port_number + 1) << 8;
 290         dev_dbg(&port->dev, "%s application number is %x\n", __func__, val);
 291         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
 292                                MCS_WR_RTYPE, val, reg, NULL, 0,
 293                                MOS_WDR_TIMEOUT);
 294
 295 }
 296
 297 /*
 298  * mos7840_get_uart_reg
 299  *      To set the Control register by calling usb_fill_control_urb function
 300  *      by passing usb_rcvctrlpipe function as parameter.
 301  */
 302 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
 303                                 __u16 *val)
 304 {
 305         struct usb_device *dev = port->serial->dev;
 306         int ret = 0;
 307         __u16 Wval;
 308         u8 *buf;
 309
 310         buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
 311         if (!buf)
 312                 return -ENOMEM;
 313
 314         /* Wval  is same as application number */
 315         if (port->serial->num_ports == 2 && port->port_number != 0)
 316                 Wval = ((__u16)port->port_number + 2) << 8;
 317         else
 318                 Wval = ((__u16)port->port_number + 1) << 8;
 319         dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval);
 320         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
 321                               MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
 322                               MOS_WDR_TIMEOUT);
 323         if (ret < VENDOR_READ_LENGTH) {
 324                 if (ret >= 0)
 325                         ret = -EIO;
 326                 goto out;
 327         }
 328         *val = buf[0];
 329 out:
 330         kfree(buf);
 331         return ret;
 332 }
 333
 334 static void mos7840_dump_serial_port(struct usb_serial_port *port,
 335                                      struct moschip_port *mos7840_port)
 336 {
 337
 338         dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset);
 339         dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset);
 340         dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset);
 341
 342 }
 343
 344 /************************************************************************/
 345 /************************************************************************/
 346 /*            U S B  C A L L B A C K   F U N C T I O N S                */
 347 /*            U S B  C A L L B A C K   F U N C T I O N S                */
 348 /************************************************************************/
 349 /************************************************************************/
 350
 351 static void mos7840_set_led_callback(struct urb *urb)
 352 {
 353         switch (urb->status) {
 354         case 0:
 355                 /* Success */
 356                 break;
 357         case -ECONNRESET:
 358         case -ENOENT:
 359         case -ESHUTDOWN:
 360                 /* This urb is terminated, clean up */
 361                 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n",
 362                         __func__, urb->status);
 363                 break;
 364         default:
 365                 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n",
 366                         __func__, urb->status);
 367         }
 368 }
 369
 370 static void mos7840_set_led_async(struct moschip_port *mcs, __u16 wval,
 371                                 __u16 reg)
 372 {
 373         struct usb_device *dev = mcs->port->serial->dev;
 374         struct usb_ctrlrequest *dr = mcs->led_dr;
 375
 376         dr->bRequestType = MCS_WR_RTYPE;
 377         dr->bRequest = MCS_WRREQ;
 378         dr->wValue = cpu_to_le16(wval);
 379         dr->wIndex = cpu_to_le16(reg);
 380         dr->wLength = cpu_to_le16(0);
 381
 382         usb_fill_control_urb(mcs->led_urb, dev, usb_sndctrlpipe(dev, 0),
 383                 (unsigned char *)dr, NULL, 0, mos7840_set_led_callback, NULL);
 384
 385         usb_submit_urb(mcs->led_urb, GFP_ATOMIC);
 386 }
 387
 388 static void mos7840_set_led_sync(struct usb_serial_port *port, __u16 reg,
 389                                 __u16 val)
 390 {
 391         struct usb_device *dev = port->serial->dev;
 392
 393         usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, MCS_WR_RTYPE,
 394                         val, reg, NULL, 0, MOS_WDR_TIMEOUT);
 395 }
 396
 397 static void mos7840_led_off(struct timer_list *t)
 398 {
 399         struct moschip_port *mcs = from_timer(mcs, t, led_timer1);
 400
 401         /* Turn off LED */
 402         mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER);
 403         mod_timer(&mcs->led_timer2,
 404                                 jiffies + msecs_to_jiffies(LED_OFF_MS));
 405 }
 406
 407 static void mos7840_led_flag_off(struct timer_list *t)
 408 {
 409         struct moschip_port *mcs = from_timer(mcs, t, led_timer2);
 410
 411         clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags);
 412 }
 413
 414 static void mos7840_led_activity(struct usb_serial_port *port)
 415 {
 416         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 417
 418         if (test_and_set_bit_lock(MOS7840_FLAG_LED_BUSY, &mos7840_port->flags))
 419                 return;
 420
 421         mos7840_set_led_async(mos7840_port, 0x0301, MODEM_CONTROL_REGISTER);
 422         mod_timer(&mos7840_port->led_timer1,
 423                                 jiffies + msecs_to_jiffies(LED_ON_MS));
 424 }
 425
 426 /*****************************************************************************
 427  * mos7840_bulk_in_callback
 428  *      this is the callback function for when we have received data on the
 429  *      bulk in endpoint.
 430  *****************************************************************************/
 431
 432 static void mos7840_bulk_in_callback(struct urb *urb)
 433 {
 434         struct moschip_port *mos7840_port = urb->context;
 435         struct usb_serial_port *port = mos7840_port->port;
 436         int retval;
 437         unsigned char *data;
 438         int status = urb->status;
 439
 440         if (status) {
 441                 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
 442                 mos7840_port->read_urb_busy = false;
 443                 return;
 444         }
 445
 446         data = urb->transfer_buffer;
 447         usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 448
 449         if (urb->actual_length) {
 450                 struct tty_port *tport = &mos7840_port->port->port;
 451                 tty_insert_flip_string(tport, data, urb->actual_length);
 452                 tty_flip_buffer_push(tport);
 453                 port->icount.rx += urb->actual_length;
 454                 dev_dbg(&port->dev, "icount.rx is %d:\n", port->icount.rx);
 455         }
 456
 457         if (mos7840_port->has_led)
 458                 mos7840_led_activity(port);
 459
 460         mos7840_port->read_urb_busy = true;
 461         retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
 462
 463         if (retval) {
 464                 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
 465                 mos7840_port->read_urb_busy = false;
 466         }
 467 }
 468
 469 /*****************************************************************************
 470  * mos7840_bulk_out_data_callback
 471  *      this is the callback function for when we have finished sending
 472  *      serial data on the bulk out endpoint.
 473  *****************************************************************************/
 474
 475 static void mos7840_bulk_out_data_callback(struct urb *urb)
 476 {
 477         struct moschip_port *mos7840_port = urb->context;
 478         struct usb_serial_port *port = mos7840_port->port;
 479         int status = urb->status;
 480         unsigned long flags;
 481         int i;
 482
 483         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
 484         for (i = 0; i < NUM_URBS; i++) {
 485                 if (urb == mos7840_port->write_urb_pool[i]) {
 486                         mos7840_port->busy[i] = 0;
 487                         break;
 488                 }
 489         }
 490         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 491
 492         if (status) {
 493                 dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status);
 494                 return;
 495         }
 496
 497         tty_port_tty_wakeup(&port->port);
 498
 499 }
 500
 501 /************************************************************************/
 502 /*       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       */
 503 /************************************************************************/
 504
 505 /*****************************************************************************
 506  * mos7840_open
 507  *      this function is called by the tty driver when a port is opened
 508  *      If successful, we return 0
 509  *      Otherwise we return a negative error number.
 510  *****************************************************************************/
 511
 512 static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
 513 {
 514         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 515         struct usb_serial *serial = port->serial;
 516         int response;
 517         int j;
 518         struct urb *urb;
 519         __u16 Data;
 520         int status;
 521
 522         usb_clear_halt(serial->dev, port->write_urb->pipe);
 523         usb_clear_halt(serial->dev, port->read_urb->pipe);
 524
 525         /* Initialising the write urb pool */
 526         for (j = 0; j < NUM_URBS; ++j) {
 527                 urb = usb_alloc_urb(0, GFP_KERNEL);
 528                 mos7840_port->write_urb_pool[j] = urb;
 529                 if (!urb)
 530                         continue;
 531
 532                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
 533                                                                 GFP_KERNEL);
 534                 if (!urb->transfer_buffer) {
 535                         usb_free_urb(urb);
 536                         mos7840_port->write_urb_pool[j] = NULL;
 537                         continue;
 538                 }
 539         }
 540
 541 /*****************************************************************************
 542  * Initialize MCS7840 -- Write Init values to corresponding Registers
 543  *
 544  * Register Index
 545  * 1 : IER
 546  * 2 : FCR
 547  * 3 : LCR
 548  * 4 : MCR
 549  *
 550  * 0x08 : SP1/2 Control Reg
 551  *****************************************************************************/
 552
 553         /* NEED to check the following Block */
 554
 555         Data = 0x0;
 556         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
 557         if (status < 0) {
 558                 dev_dbg(&port->dev, "Reading Spreg failed\n");
 559                 goto err;
 560         }
 561         Data |= 0x80;
 562         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 563         if (status < 0) {
 564                 dev_dbg(&port->dev, "writing Spreg failed\n");
 565                 goto err;
 566         }
 567
 568         Data &= ~0x80;
 569         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 570         if (status < 0) {
 571                 dev_dbg(&port->dev, "writing Spreg failed\n");
 572                 goto err;
 573         }
 574         /* End of block to be checked */
 575
 576         Data = 0x0;
 577         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
 578                                                                         &Data);
 579         if (status < 0) {
 580                 dev_dbg(&port->dev, "Reading Controlreg failed\n");
 581                 goto err;
 582         }
 583         Data |= 0x08;           /* Driver done bit */
 584         Data |= 0x20;           /* rx_disable */
 585         status = mos7840_set_reg_sync(port,
 586                                 mos7840_port->ControlRegOffset, Data);
 587         if (status < 0) {
 588                 dev_dbg(&port->dev, "writing Controlreg failed\n");
 589                 goto err;
 590         }
 591         /* do register settings here */
 592         /* Set all regs to the device default values. */
 593         /***********************************
 594          * First Disable all interrupts.
 595          ***********************************/
 596         Data = 0x00;
 597         status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
 598         if (status < 0) {
 599                 dev_dbg(&port->dev, "disabling interrupts failed\n");
 600                 goto err;
 601         }
 602         /* Set FIFO_CONTROL_REGISTER to the default value */
 603         Data = 0x00;
 604         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
 605         if (status < 0) {
 606                 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
 607                 goto err;
 608         }
 609
 610         Data = 0xcf;
 611         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
 612         if (status < 0) {
 613                 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
 614                 goto err;
 615         }
 616
 617         Data = 0x03;
 618         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
 619         mos7840_port->shadowLCR = Data;
 620
 621         Data = 0x0b;
 622         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
 623         mos7840_port->shadowMCR = Data;
 624
 625         Data = 0x00;
 626         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
 627         mos7840_port->shadowLCR = Data;
 628
 629         Data |= SERIAL_LCR_DLAB;        /* data latch enable in LCR 0x80 */
 630         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
 631
 632         Data = 0x0c;
 633         status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
 634
 635         Data = 0x0;
 636         status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
 637
 638         Data = 0x00;
 639         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
 640
 641         Data = Data & ~SERIAL_LCR_DLAB;
 642         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
 643         mos7840_port->shadowLCR = Data;
 644
 645         /* clearing Bulkin and Bulkout Fifo */
 646         Data = 0x0;
 647         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
 648
 649         Data = Data | 0x0c;
 650         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 651
 652         Data = Data & ~0x0c;
 653         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
 654         /* Finally enable all interrupts */
 655         Data = 0x0c;
 656         status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
 657
 658         /* clearing rx_disable */
 659         Data = 0x0;
 660         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
 661                                                                         &Data);
 662         Data = Data & ~0x20;
 663         status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
 664                                                                         Data);
 665
 666         /* rx_negate */
 667         Data = 0x0;
 668         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
 669                                                                         &Data);
 670         Data = Data | 0x10;
 671         status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset,
 672                                                                         Data);
 673
 674         dev_dbg(&port->dev, "port number is %d\n", port->port_number);
 675         dev_dbg(&port->dev, "minor number is %d\n", port->minor);
 676         dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
 677         dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
 678         dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
 679         dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num);
 680         mos7840_port->read_urb = port->read_urb;
 681
 682         /* set up our bulk in urb */
 683         if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
 684                 usb_fill_bulk_urb(mos7840_port->read_urb,
 685                         serial->dev,
 686                         usb_rcvbulkpipe(serial->dev,
 687                                 (port->bulk_in_endpointAddress) + 2),
 688                         port->bulk_in_buffer,
 689                         mos7840_port->read_urb->transfer_buffer_length,
 690                         mos7840_bulk_in_callback, mos7840_port);
 691         } else {
 692                 usb_fill_bulk_urb(mos7840_port->read_urb,
 693                         serial->dev,
 694                         usb_rcvbulkpipe(serial->dev,
 695                                 port->bulk_in_endpointAddress),
 696                         port->bulk_in_buffer,
 697                         mos7840_port->read_urb->transfer_buffer_length,
 698                         mos7840_bulk_in_callback, mos7840_port);
 699         }
 700
 701         dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress);
 702         mos7840_port->read_urb_busy = true;
 703         response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
 704         if (response) {
 705                 dev_err(&port->dev, "%s - Error %d submitting control urb\n",
 706                         __func__, response);
 707                 mos7840_port->read_urb_busy = false;
 708         }
 709
 710         /* initialize our port settings */
 711         /* Must set to enable ints! */
 712         mos7840_port->shadowMCR = MCR_MASTER_IE;
 713
 714         return 0;
 715 err:
 716         for (j = 0; j < NUM_URBS; ++j) {
 717                 urb = mos7840_port->write_urb_pool[j];
 718                 if (!urb)
 719                         continue;
 720                 kfree(urb->transfer_buffer);
 721                 usb_free_urb(urb);
 722         }
 723         return status;
 724 }
 725
 726 /*****************************************************************************
 727  * mos7840_chars_in_buffer
 728  *      this function is called by the tty driver when it wants to know how many
 729  *      bytes of data we currently have outstanding in the port (data that has
 730  *      been written, but hasn't made it out the port yet)
 731  *****************************************************************************/
 732
 733 static unsigned int mos7840_chars_in_buffer(struct tty_struct *tty)
 734 {
 735         struct usb_serial_port *port = tty->driver_data;
 736         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 737         int i;
 738         unsigned int chars = 0;
 739         unsigned long flags;
 740
 741         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
 742         for (i = 0; i < NUM_URBS; ++i) {
 743                 if (mos7840_port->busy[i]) {
 744                         struct urb *urb = mos7840_port->write_urb_pool[i];
 745                         chars += urb->transfer_buffer_length;
 746                 }
 747         }
 748         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 749         dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
 750         return chars;
 751
 752 }
 753
 754 /*****************************************************************************
 755  * mos7840_close
 756  *      this function is called by the tty driver when a port is closed
 757  *****************************************************************************/
 758
 759 static void mos7840_close(struct usb_serial_port *port)
 760 {
 761         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 762         int j;
 763         __u16 Data;
 764
 765         for (j = 0; j < NUM_URBS; ++j)
 766                 usb_kill_urb(mos7840_port->write_urb_pool[j]);
 767
 768         /* Freeing Write URBs */
 769         for (j = 0; j < NUM_URBS; ++j) {
 770                 if (mos7840_port->write_urb_pool[j]) {
 771                         kfree(mos7840_port->write_urb_pool[j]->transfer_buffer);
 772                         usb_free_urb(mos7840_port->write_urb_pool[j]);
 773                 }
 774         }
 775
 776         usb_kill_urb(mos7840_port->read_urb);
 777         mos7840_port->read_urb_busy = false;
 778
 779         Data = 0x0;
 780         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
 781
 782         Data = 0x00;
 783         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
 784 }
 785
 786 /*****************************************************************************
 787  * mos7840_break
 788  *      this function sends a break to the port
 789  *****************************************************************************/
 790 static int mos7840_break(struct tty_struct *tty, int break_state)
 791 {
 792         struct usb_serial_port *port = tty->driver_data;
 793         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 794         unsigned char data;
 795
 796         if (break_state == -1)
 797                 data = mos7840_port->shadowLCR | LCR_SET_BREAK;
 798         else
 799                 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
 800
 801         /* FIXME: no locking on shadowLCR anywhere in driver */
 802         mos7840_port->shadowLCR = data;
 803         dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
 804
 805         return mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
 806                                     mos7840_port->shadowLCR);
 807 }
 808
 809 /*****************************************************************************
 810  * mos7840_write_room
 811  *      this function is called by the tty driver when it wants to know how many
 812  *      bytes of data we can accept for a specific port.
 813  *****************************************************************************/
 814
 815 static unsigned int mos7840_write_room(struct tty_struct *tty)
 816 {
 817         struct usb_serial_port *port = tty->driver_data;
 818         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 819         int i;
 820         unsigned int room = 0;
 821         unsigned long flags;
 822
 823         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
 824         for (i = 0; i < NUM_URBS; ++i) {
 825                 if (!mos7840_port->busy[i])
 826                         room += URB_TRANSFER_BUFFER_SIZE;
 827         }
 828         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 829
 830         room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
 831         dev_dbg(&mos7840_port->port->dev, "%s - returns %u\n", __func__, room);
 832         return room;
 833
 834 }
 835
 836 /*****************************************************************************
 837  * mos7840_write
 838  *      this function is called by the tty driver when data should be written to
 839  *      the port.
 840  *      If successful, we return the number of bytes written, otherwise we
 841  *      return a negative error number.
 842  *****************************************************************************/
 843
 844 static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
 845                          const unsigned char *data, int count)
 846 {
 847         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 848         struct usb_serial *serial = port->serial;
 849         int status;
 850         int i;
 851         int bytes_sent = 0;
 852         int transfer_size;
 853         unsigned long flags;
 854         struct urb *urb;
 855         /* __u16 Data; */
 856         const unsigned char *current_position = data;
 857
 858         /* try to find a free urb in the list */
 859         urb = NULL;
 860
 861         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
 862         for (i = 0; i < NUM_URBS; ++i) {
 863                 if (!mos7840_port->busy[i]) {
 864                         mos7840_port->busy[i] = 1;
 865                         urb = mos7840_port->write_urb_pool[i];
 866                         dev_dbg(&port->dev, "URB:%d\n", i);
 867                         break;
 868                 }
 869         }
 870         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 871
 872         if (urb == NULL) {
 873                 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
 874                 goto exit;
 875         }
 876
 877         if (urb->transfer_buffer == NULL) {
 878                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
 879                                                GFP_ATOMIC);
 880                 if (!urb->transfer_buffer) {
 881                         bytes_sent = -ENOMEM;
 882                         goto exit;
 883                 }
 884         }
 885         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
 886
 887         memcpy(urb->transfer_buffer, current_position, transfer_size);
 888
 889         /* fill urb with data and submit  */
 890         if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
 891                 usb_fill_bulk_urb(urb,
 892                         serial->dev,
 893                         usb_sndbulkpipe(serial->dev,
 894                                 (port->bulk_out_endpointAddress) + 2),
 895                         urb->transfer_buffer,
 896                         transfer_size,
 897                         mos7840_bulk_out_data_callback, mos7840_port);
 898         } else {
 899                 usb_fill_bulk_urb(urb,
 900                         serial->dev,
 901                         usb_sndbulkpipe(serial->dev,
 902                                 port->bulk_out_endpointAddress),
 903                         urb->transfer_buffer,
 904                         transfer_size,
 905                         mos7840_bulk_out_data_callback, mos7840_port);
 906         }
 907
 908         dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
 909
 910         if (mos7840_port->has_led)
 911                 mos7840_led_activity(port);
 912
 913         /* send it down the pipe */
 914         status = usb_submit_urb(urb, GFP_ATOMIC);
 915
 916         if (status) {
 917                 mos7840_port->busy[i] = 0;
 918                 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
 919                         "with status = %d\n", __func__, status);
 920                 bytes_sent = status;
 921                 goto exit;
 922         }
 923         bytes_sent = transfer_size;
 924         port->icount.tx += transfer_size;
 925         dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx);
 926 exit:
 927         return bytes_sent;
 928
 929 }
 930
 931 /*****************************************************************************
 932  * mos7840_throttle
 933  *      this function is called by the tty driver when it wants to stop the data
 934  *      being read from the port.
 935  *****************************************************************************/
 936
 937 static void mos7840_throttle(struct tty_struct *tty)
 938 {
 939         struct usb_serial_port *port = tty->driver_data;
 940         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 941         int status;
 942
 943         /* if we are implementing XON/XOFF, send the stop character */
 944         if (I_IXOFF(tty)) {
 945                 unsigned char stop_char = STOP_CHAR(tty);
 946                 status = mos7840_write(tty, port, &stop_char, 1);
 947                 if (status <= 0)
 948                         return;
 949         }
 950         /* if we are implementing RTS/CTS, toggle that line */
 951         if (C_CRTSCTS(tty)) {
 952                 mos7840_port->shadowMCR &= ~MCR_RTS;
 953                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
 954                                          mos7840_port->shadowMCR);
 955                 if (status < 0)
 956                         return;
 957         }
 958 }
 959
 960 /*****************************************************************************
 961  * mos7840_unthrottle
 962  *      this function is called by the tty driver when it wants to resume
 963  *      the data being read from the port (called after mos7840_throttle is
 964  *      called)
 965  *****************************************************************************/
 966 static void mos7840_unthrottle(struct tty_struct *tty)
 967 {
 968         struct usb_serial_port *port = tty->driver_data;
 969         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 970         int status;
 971
 972         /* if we are implementing XON/XOFF, send the start character */
 973         if (I_IXOFF(tty)) {
 974                 unsigned char start_char = START_CHAR(tty);
 975                 status = mos7840_write(tty, port, &start_char, 1);
 976                 if (status <= 0)
 977                         return;
 978         }
 979
 980         /* if we are implementing RTS/CTS, toggle that line */
 981         if (C_CRTSCTS(tty)) {
 982                 mos7840_port->shadowMCR |= MCR_RTS;
 983                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
 984                                          mos7840_port->shadowMCR);
 985                 if (status < 0)
 986                         return;
 987         }
 988 }
 989
 990 static int mos7840_tiocmget(struct tty_struct *tty)
 991 {
 992         struct usb_serial_port *port = tty->driver_data;
 993         unsigned int result;
 994         __u16 msr;
 995         __u16 mcr;
 996         int status;
 997
 998         status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
 999         if (status < 0)
1000                 return -EIO;
1001         status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
1002         if (status < 0)
1003                 return -EIO;
1004         result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1005             | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1006             | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1007             | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1008             | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1009             | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1010             | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1011
1012         dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1013
1014         return result;
1015 }
1016
1017 static int mos7840_tiocmset(struct tty_struct *tty,
1018                             unsigned int set, unsigned int clear)
1019 {
1020         struct usb_serial_port *port = tty->driver_data;
1021         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1022         unsigned int mcr;
1023         int status;
1024
1025         /* FIXME: What locks the port registers ? */
1026         mcr = mos7840_port->shadowMCR;
1027         if (clear & TIOCM_RTS)
1028                 mcr &= ~MCR_RTS;
1029         if (clear & TIOCM_DTR)
1030                 mcr &= ~MCR_DTR;
1031         if (clear & TIOCM_LOOP)
1032                 mcr &= ~MCR_LOOPBACK;
1033
1034         if (set & TIOCM_RTS)
1035                 mcr |= MCR_RTS;
1036         if (set & TIOCM_DTR)
1037                 mcr |= MCR_DTR;
1038         if (set & TIOCM_LOOP)
1039                 mcr |= MCR_LOOPBACK;
1040
1041         mos7840_port->shadowMCR = mcr;
1042
1043         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1044         if (status < 0) {
1045                 dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
1046                 return status;
1047         }
1048
1049         return 0;
1050 }
1051
1052 /*****************************************************************************
1053  * mos7840_calc_baud_rate_divisor
1054  *      this function calculates the proper baud rate divisor for the specified
1055  *      baud rate.
1056  *****************************************************************************/
1057 static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
1058                                           int baudRate, int *divisor,
1059                                           __u16 *clk_sel_val)
1060 {
1061         dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
1062
1063         if (baudRate <= 115200) {
1064                 *divisor = 115200 / baudRate;
1065                 *clk_sel_val = 0x0;
1066         }
1067         if ((baudRate > 115200) && (baudRate <= 230400)) {
1068                 *divisor = 230400 / baudRate;
1069                 *clk_sel_val = 0x10;
1070         } else if ((baudRate > 230400) && (baudRate <= 403200)) {
1071                 *divisor = 403200 / baudRate;
1072                 *clk_sel_val = 0x20;
1073         } else if ((baudRate > 403200) && (baudRate <= 460800)) {
1074                 *divisor = 460800 / baudRate;
1075                 *clk_sel_val = 0x30;
1076         } else if ((baudRate > 460800) && (baudRate <= 806400)) {
1077                 *divisor = 806400 / baudRate;
1078                 *clk_sel_val = 0x40;
1079         } else if ((baudRate > 806400) && (baudRate <= 921600)) {
1080                 *divisor = 921600 / baudRate;
1081                 *clk_sel_val = 0x50;
1082         } else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1083                 *divisor = 1572864 / baudRate;
1084                 *clk_sel_val = 0x60;
1085         } else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1086                 *divisor = 3145728 / baudRate;
1087                 *clk_sel_val = 0x70;
1088         }
1089         return 0;
1090 }
1091
1092 /*****************************************************************************
1093  * mos7840_send_cmd_write_baud_rate
1094  *      this function sends the proper command to change the baud rate of the
1095  *      specified port.
1096  *****************************************************************************/
1097
1098 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1099                                             int baudRate)
1100 {
1101         struct usb_serial_port *port = mos7840_port->port;
1102         int divisor = 0;
1103         int status;
1104         __u16 Data;
1105         __u16 clk_sel_val;
1106
1107         dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate);
1108         /* reset clk_uart_sel in spregOffset */
1109         if (baudRate > 115200) {
1110 #ifdef HW_flow_control
1111                 /* NOTE: need to see the pther register to modify */
1112                 /* setting h/w flow control bit to 1 */
1113                 Data = 0x2b;
1114                 mos7840_port->shadowMCR = Data;
1115                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1116                                                                         Data);
1117                 if (status < 0) {
1118                         dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1119                         return -1;
1120                 }
1121 #endif
1122
1123         } else {
1124 #ifdef HW_flow_control
1125                 /* setting h/w flow control bit to 0 */
1126                 Data = 0xb;
1127                 mos7840_port->shadowMCR = Data;
1128                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1129                                                                         Data);
1130                 if (status < 0) {
1131                         dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1132                         return -1;
1133                 }
1134 #endif
1135
1136         }
1137
1138         if (1) {                /* baudRate <= 115200) */
1139                 clk_sel_val = 0x0;
1140                 Data = 0x0;
1141                 status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
1142                                                    &clk_sel_val);
1143                 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1144                                                                  &Data);
1145                 if (status < 0) {
1146                         dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
1147                         return -1;
1148                 }
1149                 Data = (Data & 0x8f) | clk_sel_val;
1150                 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1151                                                                 Data);
1152                 if (status < 0) {
1153                         dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1154                         return -1;
1155                 }
1156                 /* Calculate the Divisor */
1157
1158                 if (status) {
1159                         dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1160                         return status;
1161                 }
1162                 /* Enable access to divisor latch */
1163                 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1164                 mos7840_port->shadowLCR = Data;
1165                 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1166
1167                 /* Write the divisor */
1168                 Data = (unsigned char)(divisor & 0xff);
1169                 dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
1170                 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1171
1172                 Data = (unsigned char)((divisor & 0xff00) >> 8);
1173                 dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
1174                 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1175
1176                 /* Disable access to divisor latch */
1177                 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1178                 mos7840_port->shadowLCR = Data;
1179                 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1180
1181         }
1182         return status;
1183 }
1184
1185 /*****************************************************************************
1186  * mos7840_change_port_settings
1187  *      This routine is called to set the UART on the device to match
1188  *      the specified new settings.
1189  *****************************************************************************/
1190
1191 static void mos7840_change_port_settings(struct tty_struct *tty,
1192                                          struct moschip_port *mos7840_port,
1193                                          const struct ktermios *old_termios)
1194 {
1195         struct usb_serial_port *port = mos7840_port->port;
1196         int baud;
1197         unsigned cflag;
1198         __u8 lData;
1199         __u8 lParity;
1200         __u8 lStop;
1201         int status;
1202         __u16 Data;
1203
1204         lData = LCR_BITS_8;
1205         lStop = LCR_STOP_1;
1206         lParity = LCR_PAR_NONE;
1207
1208         cflag = tty->termios.c_cflag;
1209
1210         /* Change the number of bits */
1211         switch (cflag & CSIZE) {
1212         case CS5:
1213                 lData = LCR_BITS_5;
1214                 break;
1215
1216         case CS6:
1217                 lData = LCR_BITS_6;
1218                 break;
1219
1220         case CS7:
1221                 lData = LCR_BITS_7;
1222                 break;
1223
1224         default:
1225         case CS8:
1226                 lData = LCR_BITS_8;
1227                 break;
1228         }
1229
1230         /* Change the Parity bit */
1231         if (cflag & PARENB) {
1232                 if (cflag & PARODD) {
1233                         lParity = LCR_PAR_ODD;
1234                         dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1235                 } else {
1236                         lParity = LCR_PAR_EVEN;
1237                         dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1238                 }
1239
1240         } else {
1241                 dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1242         }
1243
1244         if (cflag & CMSPAR)
1245                 lParity = lParity | 0x20;
1246
1247         /* Change the Stop bit */
1248         if (cflag & CSTOPB) {
1249                 lStop = LCR_STOP_2;
1250                 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1251         } else {
1252                 lStop = LCR_STOP_1;
1253                 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1254         }
1255
1256         /* Update the LCR with the correct value */
1257         mos7840_port->shadowLCR &=
1258             ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1259         mos7840_port->shadowLCR |= (lData | lParity | lStop);
1260
1261         dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
1262                 mos7840_port->shadowLCR);
1263         /* Disable Interrupts */
1264         Data = 0x00;
1265         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1266
1267         Data = 0x00;
1268         mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1269
1270         Data = 0xcf;
1271         mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1272
1273         /* Send the updated LCR value to the mos7840 */
1274         Data = mos7840_port->shadowLCR;
1275
1276         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1277
1278         Data = 0x00b;
1279         mos7840_port->shadowMCR = Data;
1280         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1281         Data = 0x00b;
1282         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1283
1284         /* set up the MCR register and send it to the mos7840 */
1285
1286         mos7840_port->shadowMCR = MCR_MASTER_IE;
1287         if (cflag & CBAUD)
1288                 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
1289
1290         if (cflag & CRTSCTS)
1291                 mos7840_port->shadowMCR |= (MCR_XON_ANY);
1292         else
1293                 mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
1294
1295         Data = mos7840_port->shadowMCR;
1296         mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1297
1298         /* Determine divisor based on baud rate */
1299         baud = tty_get_baud_rate(tty);
1300
1301         if (!baud) {
1302                 /* pick a default, any default... */
1303                 dev_dbg(&port->dev, "%s", "Picked default baud...\n");
1304                 baud = 9600;
1305         }
1306
1307         dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1308         status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
1309
1310         /* Enable Interrupts */
1311         Data = 0x0c;
1312         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1313
1314         if (!mos7840_port->read_urb_busy) {
1315                 mos7840_port->read_urb_busy = true;
1316                 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1317                 if (status) {
1318                         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1319                             status);
1320                         mos7840_port->read_urb_busy = false;
1321                 }
1322         }
1323         dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
1324                 mos7840_port->shadowLCR);
1325 }
1326
1327 /*****************************************************************************
1328  * mos7840_set_termios
1329  *      this function is called by the tty driver when it wants to change
1330  *      the termios structure
1331  *****************************************************************************/
1332
1333 static void mos7840_set_termios(struct tty_struct *tty,
1334                                 struct usb_serial_port *port,
1335                                 const struct ktermios *old_termios)
1336 {
1337         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1338         int status;
1339
1340         /* change the port settings to the new ones specified */
1341
1342         mos7840_change_port_settings(tty, mos7840_port, old_termios);
1343
1344         if (!mos7840_port->read_urb_busy) {
1345                 mos7840_port->read_urb_busy = true;
1346                 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1347                 if (status) {
1348                         dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1349                             status);
1350                         mos7840_port->read_urb_busy = false;
1351                 }
1352         }
1353 }
1354
1355 /*****************************************************************************
1356  * mos7840_get_lsr_info - get line status register info
1357  *
1358  * Purpose: Let user call ioctl() to get info when the UART physically
1359  *          is emptied.  On bus types like RS485, the transmitter must
1360  *          release the bus after transmitting. This must be done when
1361  *          the transmit shift register is empty, not be done when the
1362  *          transmit holding register is empty.  This functionality
1363  *          allows an RS485 driver to be written in user space.
1364  *****************************************************************************/
1365
1366 static int mos7840_get_lsr_info(struct tty_struct *tty,
1367                                 unsigned int __user *value)
1368 {
1369         int count;
1370         unsigned int result = 0;
1371
1372         count = mos7840_chars_in_buffer(tty);
1373         if (count == 0)
1374                 result = TIOCSER_TEMT;
1375
1376         if (copy_to_user(value, &result, sizeof(int)))
1377                 return -EFAULT;
1378         return 0;
1379 }
1380
1381 /*****************************************************************************
1382  * SerialIoctl
1383  *      this function handles any ioctl calls to the driver
1384  *****************************************************************************/
1385
1386 static int mos7840_ioctl(struct tty_struct *tty,
1387                          unsigned int cmd, unsigned long arg)
1388 {
1389         struct usb_serial_port *port = tty->driver_data;
1390         void __user *argp = (void __user *)arg;
1391
1392         switch (cmd) {
1393                 /* return number of bytes available */
1394
1395         case TIOCSERGETLSR:
1396                 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
1397                 return mos7840_get_lsr_info(tty, argp);
1398
1399         default:
1400                 break;
1401         }
1402         return -ENOIOCTLCMD;
1403 }
1404
1405 /*
1406  * Check if GPO (pin 42) is connected to GPI (pin 33) as recommended by ASIX
1407  * for MCS7810 by bit-banging a 16-bit word.
1408  *
1409  * Note that GPO is really RTS of the third port so this will toggle RTS of
1410  * port two or three on two- and four-port devices.
1411  */
1412 static int mos7810_check(struct usb_serial *serial)
1413 {
1414         int i, pass_count = 0;
1415         u8 *buf;
1416         __u16 data = 0, mcr_data = 0;
1417         __u16 test_pattern = 0x55AA;
1418         int res;
1419
1420         buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1421         if (!buf)
1422                 return 0;       /* failed to identify 7810 */
1423
1424         /* Store MCR setting */
1425         res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1426                 MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER,
1427                 buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1428         if (res == VENDOR_READ_LENGTH)
1429                 mcr_data = *buf;
1430
1431         for (i = 0; i < 16; i++) {
1432                 /* Send the 1-bit test pattern out to MCS7810 test pin */
1433                 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1434                         MCS_WRREQ, MCS_WR_RTYPE,
1435                         (0x0300 | (((test_pattern >> i) & 0x0001) << 1)),
1436                         MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT);
1437
1438                 /* Read the test pattern back */
1439                 res = usb_control_msg(serial->dev,
1440                                 usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ,
1441                                 MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1442                                 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1443                 if (res == VENDOR_READ_LENGTH)
1444                         data = *buf;
1445
1446                 /* If this is a MCS7810 device, both test patterns must match */
1447                 if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001)
1448                         break;
1449
1450                 pass_count++;
1451         }
1452
1453         /* Restore MCR setting */
1454         usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ,
1455                 MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL,
1456                 0, MOS_WDR_TIMEOUT);
1457
1458         kfree(buf);
1459
1460         if (pass_count == 16)
1461                 return 1;
1462
1463         return 0;
1464 }
1465
1466 static int mos7840_probe(struct usb_serial *serial,
1467                                 const struct usb_device_id *id)
1468 {
1469         unsigned long device_flags = id->driver_info;
1470         u8 *buf;
1471
1472         /* Skip device-type detection if we already have device flags. */
1473         if (device_flags)
1474                 goto out;
1475
1476         buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1477         if (!buf)
1478                 return -ENOMEM;
1479
1480         usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1481                         MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1482                         VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1483
1484         /* For a MCS7840 device GPIO0 must be set to 1 */
1485         if (buf[0] & 0x01)
1486                 device_flags = MCS_PORTS(4);
1487         else if (mos7810_check(serial))
1488                 device_flags = MCS_PORTS(1) | MCS_LED;
1489         else
1490                 device_flags = MCS_PORTS(2);
1491
1492         kfree(buf);
1493 out:
1494         usb_set_serial_data(serial, (void *)device_flags);
1495
1496         return 0;
1497 }
1498
1499 static int mos7840_calc_num_ports(struct usb_serial *serial,
1500                                         struct usb_serial_endpoints *epds)
1501 {
1502         unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1503         int num_ports = MCS_PORTS(device_flags);
1504
1505         if (num_ports == 0 || num_ports > 4)
1506                 return -ENODEV;
1507
1508         if (epds->num_bulk_in < num_ports || epds->num_bulk_out < num_ports) {
1509                 dev_err(&serial->interface->dev, "missing endpoints\n");
1510                 return -ENODEV;
1511         }
1512
1513         return num_ports;
1514 }
1515
1516 static int mos7840_attach(struct usb_serial *serial)
1517 {
1518         struct device *dev = &serial->interface->dev;
1519         int status;
1520         u16 val;
1521
1522         /* Zero Length flag enable */
1523         val = 0x0f;
1524         status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, val);
1525         if (status < 0)
1526                 dev_dbg(dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
1527         else
1528                 dev_dbg(dev, "ZLP_REG5 Writing success status%d\n", status);
1529
1530         return status;
1531 }
1532
1533 static int mos7840_port_probe(struct usb_serial_port *port)
1534 {
1535         struct usb_serial *serial = port->serial;
1536         unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1537         struct moschip_port *mos7840_port;
1538         int status;
1539         int pnum;
1540         __u16 Data;
1541
1542         /* we set up the pointers to the endpoints in the mos7840_open *
1543          * function, as the structures aren't created yet.             */
1544
1545         pnum = port->port_number;
1546
1547         dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
1548         mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
1549         if (!mos7840_port)
1550                 return -ENOMEM;
1551
1552         /* Initialize all port interrupt end point to port 0 int
1553          * endpoint. Our device has only one interrupt end point
1554          * common to all port */
1555
1556         mos7840_port->port = port;
1557         spin_lock_init(&mos7840_port->pool_lock);
1558
1559         /* minor is not initialised until later by
1560          * usb-serial.c:get_free_serial() and cannot therefore be used
1561          * to index device instances */
1562         mos7840_port->port_num = pnum + 1;
1563         dev_dbg(&port->dev, "port->minor = %d\n", port->minor);
1564         dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
1565
1566         if (mos7840_port->port_num == 1) {
1567                 mos7840_port->SpRegOffset = 0x0;
1568                 mos7840_port->ControlRegOffset = 0x1;
1569                 mos7840_port->DcrRegOffset = 0x4;
1570         } else {
1571                 u8 phy_num = mos7840_port->port_num;
1572
1573                 /* Port 2 in the 2-port case uses registers of port 3 */
1574                 if (serial->num_ports == 2)
1575                         phy_num = 3;
1576
1577                 mos7840_port->SpRegOffset = 0x8 + 2 * (phy_num - 2);
1578                 mos7840_port->ControlRegOffset = 0x9 + 2 * (phy_num - 2);
1579                 mos7840_port->DcrRegOffset = 0x16 + 3 * (phy_num - 2);
1580         }
1581         mos7840_dump_serial_port(port, mos7840_port);
1582         usb_set_serial_port_data(port, mos7840_port);
1583
1584         /* enable rx_disable bit in control register */
1585         status = mos7840_get_reg_sync(port,
1586                         mos7840_port->ControlRegOffset, &Data);
1587         if (status < 0) {
1588                 dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status);
1589                 goto error;
1590         } else
1591                 dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
1592         Data |= 0x08;   /* setting driver done bit */
1593         Data |= 0x04;   /* sp1_bit to have cts change reflect in
1594                            modem status reg */
1595
1596         /* Data |= 0x20; //rx_disable bit */
1597         status = mos7840_set_reg_sync(port,
1598                         mos7840_port->ControlRegOffset, Data);
1599         if (status < 0) {
1600                 dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
1601                 goto error;
1602         } else
1603                 dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
1604
1605         /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
1606            and 0x24 in DCR3 */
1607         Data = 0x01;
1608         status = mos7840_set_reg_sync(port,
1609                         (__u16) (mos7840_port->DcrRegOffset + 0), Data);
1610         if (status < 0) {
1611                 dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status);
1612                 goto error;
1613         } else
1614                 dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status);
1615
1616         Data = 0x05;
1617         status = mos7840_set_reg_sync(port,
1618                         (__u16) (mos7840_port->DcrRegOffset + 1), Data);
1619         if (status < 0) {
1620                 dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status);
1621                 goto error;
1622         } else
1623                 dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status);
1624
1625         Data = 0x24;
1626         status = mos7840_set_reg_sync(port,
1627                         (__u16) (mos7840_port->DcrRegOffset + 2), Data);
1628         if (status < 0) {
1629                 dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status);
1630                 goto error;
1631         } else
1632                 dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status);
1633
1634         /* write values in clkstart0x0 and clkmulti 0x20 */
1635         Data = 0x0;
1636         status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data);
1637         if (status < 0) {
1638                 dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
1639                 goto error;
1640         } else
1641                 dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
1642
1643         Data = 0x20;
1644         status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data);
1645         if (status < 0) {
1646                 dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
1647                 goto error;
1648         } else
1649                 dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
1650
1651         /* write value 0x0 to scratchpad register */
1652         Data = 0x00;
1653         status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data);
1654         if (status < 0) {
1655                 dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
1656                 goto error;
1657         } else
1658                 dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
1659
1660         /* Zero Length flag register */
1661         if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) {
1662                 Data = 0xff;
1663                 status = mos7840_set_reg_sync(port,
1664                                 (__u16) (ZLP_REG1 +
1665                                         ((__u16)mos7840_port->port_num)), Data);
1666                 dev_dbg(&port->dev, "ZLIP offset %x\n",
1667                                 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
1668                 if (status < 0) {
1669                         dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status);
1670                         goto error;
1671                 } else
1672                         dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status);
1673         } else {
1674                 Data = 0xff;
1675                 status = mos7840_set_reg_sync(port,
1676                                 (__u16) (ZLP_REG1 +
1677                                         ((__u16)mos7840_port->port_num) - 0x1), Data);
1678                 dev_dbg(&port->dev, "ZLIP offset %x\n",
1679                                 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
1680                 if (status < 0) {
1681                         dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status);
1682                         goto error;
1683                 } else
1684                         dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status);
1685
1686         }
1687
1688         mos7840_port->has_led = device_flags & MCS_LED;
1689
1690         /* Initialize LED timers */
1691         if (mos7840_port->has_led) {
1692                 mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
1693                 mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr),
1694                                                                 GFP_KERNEL);
1695                 if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
1696                         status = -ENOMEM;
1697                         goto error;
1698                 }
1699
1700                 timer_setup(&mos7840_port->led_timer1, mos7840_led_off, 0);
1701                 mos7840_port->led_timer1.expires =
1702                         jiffies + msecs_to_jiffies(LED_ON_MS);
1703                 timer_setup(&mos7840_port->led_timer2, mos7840_led_flag_off,
1704                             0);
1705                 mos7840_port->led_timer2.expires =
1706                         jiffies + msecs_to_jiffies(LED_OFF_MS);
1707
1708                 /* Turn off LED */
1709                 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1710         }
1711
1712         return 0;
1713 error:
1714         kfree(mos7840_port->led_dr);
1715         usb_free_urb(mos7840_port->led_urb);
1716         kfree(mos7840_port);
1717
1718         return status;
1719 }
1720
1721 static void mos7840_port_remove(struct usb_serial_port *port)
1722 {
1723         struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1724
1725         if (mos7840_port->has_led) {
1726                 /* Turn off LED */
1727                 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1728
1729                 timer_shutdown_sync(&mos7840_port->led_timer1);
1730                 timer_shutdown_sync(&mos7840_port->led_timer2);
1731
1732                 usb_kill_urb(mos7840_port->led_urb);
1733                 usb_free_urb(mos7840_port->led_urb);
1734                 kfree(mos7840_port->led_dr);
1735         }
1736
1737         kfree(mos7840_port);
1738 }
1739
1740 static struct usb_serial_driver moschip7840_4port_device = {
1741         .driver = {
1742                    .owner = THIS_MODULE,
1743                    .name = "mos7840",
1744                    },
1745         .description = DRIVER_DESC,
1746         .id_table = id_table,
1747         .num_interrupt_in = 1,
1748         .open = mos7840_open,
1749         .close = mos7840_close,
1750         .write = mos7840_write,
1751         .write_room = mos7840_write_room,
1752         .chars_in_buffer = mos7840_chars_in_buffer,
1753         .throttle = mos7840_throttle,
1754         .unthrottle = mos7840_unthrottle,
1755         .calc_num_ports = mos7840_calc_num_ports,
1756         .probe = mos7840_probe,
1757         .attach = mos7840_attach,
1758         .ioctl = mos7840_ioctl,
1759         .set_termios = mos7840_set_termios,
1760         .break_ctl = mos7840_break,
1761         .tiocmget = mos7840_tiocmget,
1762         .tiocmset = mos7840_tiocmset,
1763         .get_icount = usb_serial_generic_get_icount,
1764         .port_probe = mos7840_port_probe,
1765         .port_remove = mos7840_port_remove,
1766         .read_bulk_callback = mos7840_bulk_in_callback,
1767 };
1768
1769 static struct usb_serial_driver * const serial_drivers[] = {
1770         &moschip7840_4port_device, NULL
1771 };
1772
1773 module_usb_serial_driver(serial_drivers, id_table);
1774
1775 MODULE_DESCRIPTION(DRIVER_DESC);
1776 MODULE_LICENSE("GPL");