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