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
 158enum 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
 169static 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};
 192MODULE_DEVICE_TABLE(usb, id_table);
 193
 194/* This structure holds all of the local port information */
 195
 196struct 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
 229static 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
 247static 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);
 269out:
 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
 280static 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 */
 304static 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];
 331out:
 332	kfree(buf);
 333	return ret;
 334}
 335
 336static 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
 353static 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
 372static 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
 390static 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
 399static 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
 409static 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
 416static 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
 434static 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
 477static 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
 514static 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;
 717err:
 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
 738static 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
 764static 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 *****************************************************************************/
 795static 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
 821static 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
 850static 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			goto exit;
 
 888	}
 889	transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
 890
 891	memcpy(urb->transfer_buffer, current_position, transfer_size);
 892
 893	/* fill urb with data and submit  */
 894	if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) {
 895		usb_fill_bulk_urb(urb,
 896			serial->dev,
 897			usb_sndbulkpipe(serial->dev,
 898				(port->bulk_out_endpointAddress) + 2),
 899			urb->transfer_buffer,
 900			transfer_size,
 901			mos7840_bulk_out_data_callback, mos7840_port);
 902	} else {
 903		usb_fill_bulk_urb(urb,
 904			serial->dev,
 905			usb_sndbulkpipe(serial->dev,
 906				port->bulk_out_endpointAddress),
 907			urb->transfer_buffer,
 908			transfer_size,
 909			mos7840_bulk_out_data_callback, mos7840_port);
 910	}
 911
 912	dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
 913
 914	if (mos7840_port->has_led)
 915		mos7840_led_activity(port);
 916
 917	/* send it down the pipe */
 918	status = usb_submit_urb(urb, GFP_ATOMIC);
 919
 920	if (status) {
 921		mos7840_port->busy[i] = 0;
 922		dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
 923			"with status = %d\n", __func__, status);
 924		bytes_sent = status;
 925		goto exit;
 926	}
 927	bytes_sent = transfer_size;
 928	port->icount.tx += transfer_size;
 929	dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx);
 930exit:
 931	return bytes_sent;
 932
 933}
 934
 935/*****************************************************************************
 936 * mos7840_throttle
 937 *	this function is called by the tty driver when it wants to stop the data
 938 *	being read from the port.
 939 *****************************************************************************/
 940
 941static void mos7840_throttle(struct tty_struct *tty)
 942{
 943	struct usb_serial_port *port = tty->driver_data;
 944	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 945	int status;
 946
 947	/* if we are implementing XON/XOFF, send the stop character */
 948	if (I_IXOFF(tty)) {
 949		unsigned char stop_char = STOP_CHAR(tty);
 950		status = mos7840_write(tty, port, &stop_char, 1);
 951		if (status <= 0)
 952			return;
 953	}
 954	/* if we are implementing RTS/CTS, toggle that line */
 955	if (C_CRTSCTS(tty)) {
 956		mos7840_port->shadowMCR &= ~MCR_RTS;
 957		status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
 958					 mos7840_port->shadowMCR);
 959		if (status < 0)
 960			return;
 961	}
 962}
 963
 964/*****************************************************************************
 965 * mos7840_unthrottle
 966 *	this function is called by the tty driver when it wants to resume
 967 *	the data being read from the port (called after mos7840_throttle is
 968 *	called)
 969 *****************************************************************************/
 970static void mos7840_unthrottle(struct tty_struct *tty)
 971{
 972	struct usb_serial_port *port = tty->driver_data;
 973	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
 974	int status;
 975
 976	/* if we are implementing XON/XOFF, send the start character */
 977	if (I_IXOFF(tty)) {
 978		unsigned char start_char = START_CHAR(tty);
 979		status = mos7840_write(tty, port, &start_char, 1);
 980		if (status <= 0)
 981			return;
 982	}
 983
 984	/* if we are implementing RTS/CTS, toggle that line */
 985	if (C_CRTSCTS(tty)) {
 986		mos7840_port->shadowMCR |= MCR_RTS;
 987		status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
 988					 mos7840_port->shadowMCR);
 989		if (status < 0)
 990			return;
 991	}
 992}
 993
 994static int mos7840_tiocmget(struct tty_struct *tty)
 995{
 996	struct usb_serial_port *port = tty->driver_data;
 997	unsigned int result;
 998	__u16 msr;
 999	__u16 mcr;
1000	int status;
1001
1002	status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
1003	if (status < 0)
1004		return -EIO;
1005	status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
1006	if (status < 0)
1007		return -EIO;
1008	result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
1009	    | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
1010	    | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
1011	    | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)
1012	    | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)
1013	    | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
1014	    | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
1015
1016	dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1017
1018	return result;
1019}
1020
1021static int mos7840_tiocmset(struct tty_struct *tty,
1022			    unsigned int set, unsigned int clear)
1023{
1024	struct usb_serial_port *port = tty->driver_data;
1025	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1026	unsigned int mcr;
1027	int status;
1028
1029	/* FIXME: What locks the port registers ? */
1030	mcr = mos7840_port->shadowMCR;
1031	if (clear & TIOCM_RTS)
1032		mcr &= ~MCR_RTS;
1033	if (clear & TIOCM_DTR)
1034		mcr &= ~MCR_DTR;
1035	if (clear & TIOCM_LOOP)
1036		mcr &= ~MCR_LOOPBACK;
1037
1038	if (set & TIOCM_RTS)
1039		mcr |= MCR_RTS;
1040	if (set & TIOCM_DTR)
1041		mcr |= MCR_DTR;
1042	if (set & TIOCM_LOOP)
1043		mcr |= MCR_LOOPBACK;
1044
1045	mos7840_port->shadowMCR = mcr;
1046
1047	status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
1048	if (status < 0) {
1049		dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
1050		return status;
1051	}
1052
1053	return 0;
1054}
1055
1056/*****************************************************************************
1057 * mos7840_calc_baud_rate_divisor
1058 *	this function calculates the proper baud rate divisor for the specified
1059 *	baud rate.
1060 *****************************************************************************/
1061static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
1062					  int baudRate, int *divisor,
1063					  __u16 *clk_sel_val)
1064{
1065	dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
1066
1067	if (baudRate <= 115200) {
1068		*divisor = 115200 / baudRate;
1069		*clk_sel_val = 0x0;
1070	}
1071	if ((baudRate > 115200) && (baudRate <= 230400)) {
1072		*divisor = 230400 / baudRate;
1073		*clk_sel_val = 0x10;
1074	} else if ((baudRate > 230400) && (baudRate <= 403200)) {
1075		*divisor = 403200 / baudRate;
1076		*clk_sel_val = 0x20;
1077	} else if ((baudRate > 403200) && (baudRate <= 460800)) {
1078		*divisor = 460800 / baudRate;
1079		*clk_sel_val = 0x30;
1080	} else if ((baudRate > 460800) && (baudRate <= 806400)) {
1081		*divisor = 806400 / baudRate;
1082		*clk_sel_val = 0x40;
1083	} else if ((baudRate > 806400) && (baudRate <= 921600)) {
1084		*divisor = 921600 / baudRate;
1085		*clk_sel_val = 0x50;
1086	} else if ((baudRate > 921600) && (baudRate <= 1572864)) {
1087		*divisor = 1572864 / baudRate;
1088		*clk_sel_val = 0x60;
1089	} else if ((baudRate > 1572864) && (baudRate <= 3145728)) {
1090		*divisor = 3145728 / baudRate;
1091		*clk_sel_val = 0x70;
1092	}
1093	return 0;
1094}
1095
1096/*****************************************************************************
1097 * mos7840_send_cmd_write_baud_rate
1098 *	this function sends the proper command to change the baud rate of the
1099 *	specified port.
1100 *****************************************************************************/
1101
1102static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
1103					    int baudRate)
1104{
1105	struct usb_serial_port *port = mos7840_port->port;
1106	int divisor = 0;
1107	int status;
1108	__u16 Data;
1109	__u16 clk_sel_val;
1110
1111	dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate);
1112	/* reset clk_uart_sel in spregOffset */
1113	if (baudRate > 115200) {
1114#ifdef HW_flow_control
1115		/* NOTE: need to see the pther register to modify */
1116		/* setting h/w flow control bit to 1 */
1117		Data = 0x2b;
1118		mos7840_port->shadowMCR = Data;
1119		status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1120									Data);
1121		if (status < 0) {
1122			dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1123			return -1;
1124		}
1125#endif
1126
1127	} else {
1128#ifdef HW_flow_control
1129		/* setting h/w flow control bit to 0 */
1130		Data = 0xb;
1131		mos7840_port->shadowMCR = Data;
1132		status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
1133									Data);
1134		if (status < 0) {
1135			dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1136			return -1;
1137		}
1138#endif
1139
1140	}
1141
1142	if (1) {		/* baudRate <= 115200) */
1143		clk_sel_val = 0x0;
1144		Data = 0x0;
1145		status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
1146						   &clk_sel_val);
1147		status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
1148								 &Data);
1149		if (status < 0) {
1150			dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
1151			return -1;
1152		}
1153		Data = (Data & 0x8f) | clk_sel_val;
1154		status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
1155								Data);
1156		if (status < 0) {
1157			dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
1158			return -1;
1159		}
1160		/* Calculate the Divisor */
1161
1162		if (status) {
1163			dev_err(&port->dev, "%s - bad baud rate\n", __func__);
1164			return status;
1165		}
1166		/* Enable access to divisor latch */
1167		Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB;
1168		mos7840_port->shadowLCR = Data;
1169		mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1170
1171		/* Write the divisor */
1172		Data = (unsigned char)(divisor & 0xff);
1173		dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
1174		mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
1175
1176		Data = (unsigned char)((divisor & 0xff00) >> 8);
1177		dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
1178		mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
1179
1180		/* Disable access to divisor latch */
1181		Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB;
1182		mos7840_port->shadowLCR = Data;
1183		mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1184
1185	}
1186	return status;
1187}
1188
1189/*****************************************************************************
1190 * mos7840_change_port_settings
1191 *	This routine is called to set the UART on the device to match
1192 *      the specified new settings.
1193 *****************************************************************************/
1194
1195static void mos7840_change_port_settings(struct tty_struct *tty,
1196	struct moschip_port *mos7840_port, struct ktermios *old_termios)
1197{
1198	struct usb_serial_port *port = mos7840_port->port;
1199	int baud;
1200	unsigned cflag;
1201	__u8 lData;
1202	__u8 lParity;
1203	__u8 lStop;
1204	int status;
1205	__u16 Data;
1206
1207	lData = LCR_BITS_8;
1208	lStop = LCR_STOP_1;
1209	lParity = LCR_PAR_NONE;
1210
1211	cflag = tty->termios.c_cflag;
1212
1213	/* Change the number of bits */
1214	switch (cflag & CSIZE) {
1215	case CS5:
1216		lData = LCR_BITS_5;
1217		break;
1218
1219	case CS6:
1220		lData = LCR_BITS_6;
1221		break;
1222
1223	case CS7:
1224		lData = LCR_BITS_7;
1225		break;
1226
1227	default:
1228	case CS8:
1229		lData = LCR_BITS_8;
1230		break;
1231	}
1232
1233	/* Change the Parity bit */
1234	if (cflag & PARENB) {
1235		if (cflag & PARODD) {
1236			lParity = LCR_PAR_ODD;
1237			dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
1238		} else {
1239			lParity = LCR_PAR_EVEN;
1240			dev_dbg(&port->dev, "%s - parity = even\n", __func__);
1241		}
1242
1243	} else {
1244		dev_dbg(&port->dev, "%s - parity = none\n", __func__);
1245	}
1246
1247	if (cflag & CMSPAR)
1248		lParity = lParity | 0x20;
1249
1250	/* Change the Stop bit */
1251	if (cflag & CSTOPB) {
1252		lStop = LCR_STOP_2;
1253		dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
1254	} else {
1255		lStop = LCR_STOP_1;
1256		dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
1257	}
1258
1259	/* Update the LCR with the correct value */
1260	mos7840_port->shadowLCR &=
1261	    ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
1262	mos7840_port->shadowLCR |= (lData | lParity | lStop);
1263
1264	dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
1265		mos7840_port->shadowLCR);
1266	/* Disable Interrupts */
1267	Data = 0x00;
1268	mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1269
1270	Data = 0x00;
1271	mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1272
1273	Data = 0xcf;
1274	mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
1275
1276	/* Send the updated LCR value to the mos7840 */
1277	Data = mos7840_port->shadowLCR;
1278
1279	mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
1280
1281	Data = 0x00b;
1282	mos7840_port->shadowMCR = Data;
1283	mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1284	Data = 0x00b;
1285	mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1286
1287	/* set up the MCR register and send it to the mos7840 */
1288
1289	mos7840_port->shadowMCR = MCR_MASTER_IE;
1290	if (cflag & CBAUD)
1291		mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS);
1292
1293	if (cflag & CRTSCTS)
1294		mos7840_port->shadowMCR |= (MCR_XON_ANY);
1295	else
1296		mos7840_port->shadowMCR &= ~(MCR_XON_ANY);
1297
1298	Data = mos7840_port->shadowMCR;
1299	mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
1300
1301	/* Determine divisor based on baud rate */
1302	baud = tty_get_baud_rate(tty);
1303
1304	if (!baud) {
1305		/* pick a default, any default... */
1306		dev_dbg(&port->dev, "%s", "Picked default baud...\n");
1307		baud = 9600;
1308	}
1309
1310	dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
1311	status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
1312
1313	/* Enable Interrupts */
1314	Data = 0x0c;
1315	mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
1316
1317	if (!mos7840_port->read_urb_busy) {
1318		mos7840_port->read_urb_busy = true;
1319		status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1320		if (status) {
1321			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1322			    status);
1323			mos7840_port->read_urb_busy = false;
1324		}
1325	}
1326	dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
1327		mos7840_port->shadowLCR);
1328}
1329
1330/*****************************************************************************
1331 * mos7840_set_termios
1332 *	this function is called by the tty driver when it wants to change
1333 *	the termios structure
1334 *****************************************************************************/
1335
1336static void mos7840_set_termios(struct tty_struct *tty,
1337				struct usb_serial_port *port,
1338				struct ktermios *old_termios)
1339{
1340	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1341	int status;
1342
1343	/* change the port settings to the new ones specified */
1344
1345	mos7840_change_port_settings(tty, mos7840_port, old_termios);
1346
1347	if (!mos7840_port->read_urb_busy) {
1348		mos7840_port->read_urb_busy = true;
1349		status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
1350		if (status) {
1351			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
1352			    status);
1353			mos7840_port->read_urb_busy = false;
1354		}
1355	}
1356}
1357
1358/*****************************************************************************
1359 * mos7840_get_lsr_info - get line status register info
1360 *
1361 * Purpose: Let user call ioctl() to get info when the UART physically
1362 * 	    is emptied.  On bus types like RS485, the transmitter must
1363 * 	    release the bus after transmitting. This must be done when
1364 * 	    the transmit shift register is empty, not be done when the
1365 * 	    transmit holding register is empty.  This functionality
1366 * 	    allows an RS485 driver to be written in user space.
1367 *****************************************************************************/
1368
1369static int mos7840_get_lsr_info(struct tty_struct *tty,
1370				unsigned int __user *value)
1371{
1372	int count;
1373	unsigned int result = 0;
1374
1375	count = mos7840_chars_in_buffer(tty);
1376	if (count == 0)
1377		result = TIOCSER_TEMT;
1378
1379	if (copy_to_user(value, &result, sizeof(int)))
1380		return -EFAULT;
1381	return 0;
1382}
1383
1384/*****************************************************************************
1385 * mos7840_get_serial_info
1386 *      function to get information about serial port
1387 *****************************************************************************/
1388
1389static int mos7840_get_serial_info(struct tty_struct *tty,
1390				   struct serial_struct *ss)
1391{
1392	struct usb_serial_port *port = tty->driver_data;
1393	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1394
1395	ss->type = PORT_16550A;
1396	ss->line = mos7840_port->port->minor;
1397	ss->port = mos7840_port->port->port_number;
1398	ss->irq = 0;
1399	ss->xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE;
1400	ss->baud_base = 9600;
1401	ss->close_delay = 5 * HZ;
1402	ss->closing_wait = 30 * HZ;
1403	return 0;
1404}
1405
1406/*****************************************************************************
1407 * SerialIoctl
1408 *	this function handles any ioctl calls to the driver
1409 *****************************************************************************/
1410
1411static int mos7840_ioctl(struct tty_struct *tty,
1412			 unsigned int cmd, unsigned long arg)
1413{
1414	struct usb_serial_port *port = tty->driver_data;
1415	void __user *argp = (void __user *)arg;
1416
1417	switch (cmd) {
1418		/* return number of bytes available */
1419
1420	case TIOCSERGETLSR:
1421		dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
1422		return mos7840_get_lsr_info(tty, argp);
1423
1424	default:
1425		break;
1426	}
1427	return -ENOIOCTLCMD;
1428}
1429
1430/*
1431 * Check if GPO (pin 42) is connected to GPI (pin 33) as recommended by ASIX
1432 * for MCS7810 by bit-banging a 16-bit word.
1433 *
1434 * Note that GPO is really RTS of the third port so this will toggle RTS of
1435 * port two or three on two- and four-port devices.
1436 */
1437static int mos7810_check(struct usb_serial *serial)
1438{
1439	int i, pass_count = 0;
1440	u8 *buf;
1441	__u16 data = 0, mcr_data = 0;
1442	__u16 test_pattern = 0x55AA;
1443	int res;
1444
1445	buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1446	if (!buf)
1447		return 0;	/* failed to identify 7810 */
1448
1449	/* Store MCR setting */
1450	res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1451		MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER,
1452		buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1453	if (res == VENDOR_READ_LENGTH)
1454		mcr_data = *buf;
1455
1456	for (i = 0; i < 16; i++) {
1457		/* Send the 1-bit test pattern out to MCS7810 test pin */
1458		usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1459			MCS_WRREQ, MCS_WR_RTYPE,
1460			(0x0300 | (((test_pattern >> i) & 0x0001) << 1)),
1461			MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT);
1462
1463		/* Read the test pattern back */
1464		res = usb_control_msg(serial->dev,
1465				usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ,
1466				MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1467				VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1468		if (res == VENDOR_READ_LENGTH)
1469			data = *buf;
1470
1471		/* If this is a MCS7810 device, both test patterns must match */
1472		if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001)
1473			break;
1474
1475		pass_count++;
1476	}
1477
1478	/* Restore MCR setting */
1479	usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ,
1480		MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL,
1481		0, MOS_WDR_TIMEOUT);
1482
1483	kfree(buf);
1484
1485	if (pass_count == 16)
1486		return 1;
1487
1488	return 0;
1489}
1490
1491static int mos7840_probe(struct usb_serial *serial,
1492				const struct usb_device_id *id)
1493{
1494	unsigned long device_flags = id->driver_info;
1495	u8 *buf;
1496
1497	/* Skip device-type detection if we already have device flags. */
1498	if (device_flags)
1499		goto out;
1500
1501	buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL);
1502	if (!buf)
1503		return -ENOMEM;
1504
1505	usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
1506			MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf,
1507			VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT);
1508
1509	/* For a MCS7840 device GPIO0 must be set to 1 */
1510	if (buf[0] & 0x01)
1511		device_flags = MCS_PORTS(4);
1512	else if (mos7810_check(serial))
1513		device_flags = MCS_PORTS(1) | MCS_LED;
1514	else
1515		device_flags = MCS_PORTS(2);
1516
1517	kfree(buf);
1518out:
1519	usb_set_serial_data(serial, (void *)device_flags);
1520
1521	return 0;
1522}
1523
1524static int mos7840_calc_num_ports(struct usb_serial *serial,
1525					struct usb_serial_endpoints *epds)
1526{
1527	unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1528	int num_ports = MCS_PORTS(device_flags);
1529
1530	if (num_ports == 0 || num_ports > 4)
1531		return -ENODEV;
1532
1533	if (epds->num_bulk_in < num_ports || epds->num_bulk_out < num_ports) {
1534		dev_err(&serial->interface->dev, "missing endpoints\n");
1535		return -ENODEV;
1536	}
1537
1538	return num_ports;
1539}
1540
1541static int mos7840_attach(struct usb_serial *serial)
1542{
1543	struct device *dev = &serial->interface->dev;
1544	int status;
1545	u16 val;
1546
1547	/* Zero Length flag enable */
1548	val = 0x0f;
1549	status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, val);
1550	if (status < 0)
1551		dev_dbg(dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
1552	else
1553		dev_dbg(dev, "ZLP_REG5 Writing success status%d\n", status);
1554
1555	return status;
1556}
1557
1558static int mos7840_port_probe(struct usb_serial_port *port)
1559{
1560	struct usb_serial *serial = port->serial;
1561	unsigned long device_flags = (unsigned long)usb_get_serial_data(serial);
1562	struct moschip_port *mos7840_port;
1563	int status;
1564	int pnum;
1565	__u16 Data;
1566
1567	/* we set up the pointers to the endpoints in the mos7840_open *
1568	 * function, as the structures aren't created yet.             */
1569
1570	pnum = port->port_number;
1571
1572	dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
1573	mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
1574	if (!mos7840_port)
1575		return -ENOMEM;
1576
1577	/* Initialize all port interrupt end point to port 0 int
1578	 * endpoint. Our device has only one interrupt end point
1579	 * common to all port */
1580
1581	mos7840_port->port = port;
1582	spin_lock_init(&mos7840_port->pool_lock);
1583
1584	/* minor is not initialised until later by
1585	 * usb-serial.c:get_free_serial() and cannot therefore be used
1586	 * to index device instances */
1587	mos7840_port->port_num = pnum + 1;
1588	dev_dbg(&port->dev, "port->minor = %d\n", port->minor);
1589	dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
1590
1591	if (mos7840_port->port_num == 1) {
1592		mos7840_port->SpRegOffset = 0x0;
1593		mos7840_port->ControlRegOffset = 0x1;
1594		mos7840_port->DcrRegOffset = 0x4;
1595	} else {
1596		u8 phy_num = mos7840_port->port_num;
1597
1598		/* Port 2 in the 2-port case uses registers of port 3 */
1599		if (serial->num_ports == 2)
1600			phy_num = 3;
1601
1602		mos7840_port->SpRegOffset = 0x8 + 2 * (phy_num - 2);
1603		mos7840_port->ControlRegOffset = 0x9 + 2 * (phy_num - 2);
1604		mos7840_port->DcrRegOffset = 0x16 + 3 * (phy_num - 2);
1605	}
1606	mos7840_dump_serial_port(port, mos7840_port);
1607	usb_set_serial_port_data(port, mos7840_port);
1608
1609	/* enable rx_disable bit in control register */
1610	status = mos7840_get_reg_sync(port,
1611			mos7840_port->ControlRegOffset, &Data);
1612	if (status < 0) {
1613		dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status);
1614		goto error;
1615	} else
1616		dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
1617	Data |= 0x08;	/* setting driver done bit */
1618	Data |= 0x04;	/* sp1_bit to have cts change reflect in
1619			   modem status reg */
1620
1621	/* Data |= 0x20; //rx_disable bit */
1622	status = mos7840_set_reg_sync(port,
1623			mos7840_port->ControlRegOffset, Data);
1624	if (status < 0) {
1625		dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
1626		goto error;
1627	} else
1628		dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
1629
1630	/* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
1631	   and 0x24 in DCR3 */
1632	Data = 0x01;
1633	status = mos7840_set_reg_sync(port,
1634			(__u16) (mos7840_port->DcrRegOffset + 0), Data);
1635	if (status < 0) {
1636		dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status);
1637		goto error;
1638	} else
1639		dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status);
1640
1641	Data = 0x05;
1642	status = mos7840_set_reg_sync(port,
1643			(__u16) (mos7840_port->DcrRegOffset + 1), Data);
1644	if (status < 0) {
1645		dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status);
1646		goto error;
1647	} else
1648		dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status);
1649
1650	Data = 0x24;
1651	status = mos7840_set_reg_sync(port,
1652			(__u16) (mos7840_port->DcrRegOffset + 2), Data);
1653	if (status < 0) {
1654		dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status);
1655		goto error;
1656	} else
1657		dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status);
1658
1659	/* write values in clkstart0x0 and clkmulti 0x20 */
1660	Data = 0x0;
1661	status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data);
1662	if (status < 0) {
1663		dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
1664		goto error;
1665	} else
1666		dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
1667
1668	Data = 0x20;
1669	status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data);
1670	if (status < 0) {
1671		dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
1672		goto error;
1673	} else
1674		dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
1675
1676	/* write value 0x0 to scratchpad register */
1677	Data = 0x00;
1678	status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data);
1679	if (status < 0) {
1680		dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
1681		goto error;
1682	} else
1683		dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
1684
1685	/* Zero Length flag register */
1686	if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) {
1687		Data = 0xff;
1688		status = mos7840_set_reg_sync(port,
1689				(__u16) (ZLP_REG1 +
1690					((__u16)mos7840_port->port_num)), Data);
1691		dev_dbg(&port->dev, "ZLIP offset %x\n",
1692				(__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
1693		if (status < 0) {
1694			dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status);
1695			goto error;
1696		} else
1697			dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status);
1698	} else {
1699		Data = 0xff;
1700		status = mos7840_set_reg_sync(port,
1701				(__u16) (ZLP_REG1 +
1702					((__u16)mos7840_port->port_num) - 0x1), Data);
1703		dev_dbg(&port->dev, "ZLIP offset %x\n",
1704				(__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
1705		if (status < 0) {
1706			dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status);
1707			goto error;
1708		} else
1709			dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status);
1710
1711	}
1712
1713	mos7840_port->has_led = device_flags & MCS_LED;
1714
1715	/* Initialize LED timers */
1716	if (mos7840_port->has_led) {
1717		mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL);
1718		mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr),
1719								GFP_KERNEL);
1720		if (!mos7840_port->led_urb || !mos7840_port->led_dr) {
1721			status = -ENOMEM;
1722			goto error;
1723		}
1724
1725		timer_setup(&mos7840_port->led_timer1, mos7840_led_off, 0);
1726		mos7840_port->led_timer1.expires =
1727			jiffies + msecs_to_jiffies(LED_ON_MS);
1728		timer_setup(&mos7840_port->led_timer2, mos7840_led_flag_off,
1729			    0);
1730		mos7840_port->led_timer2.expires =
1731			jiffies + msecs_to_jiffies(LED_OFF_MS);
1732
1733		/* Turn off LED */
1734		mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1735	}
1736
1737	return 0;
1738error:
1739	kfree(mos7840_port->led_dr);
1740	usb_free_urb(mos7840_port->led_urb);
1741	kfree(mos7840_port);
1742
1743	return status;
1744}
1745
1746static int mos7840_port_remove(struct usb_serial_port *port)
1747{
1748	struct moschip_port *mos7840_port = usb_get_serial_port_data(port);
1749
1750	if (mos7840_port->has_led) {
1751		/* Turn off LED */
1752		mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300);
1753
1754		del_timer_sync(&mos7840_port->led_timer1);
1755		del_timer_sync(&mos7840_port->led_timer2);
1756
1757		usb_kill_urb(mos7840_port->led_urb);
1758		usb_free_urb(mos7840_port->led_urb);
1759		kfree(mos7840_port->led_dr);
1760	}
1761
1762	kfree(mos7840_port);
1763
1764	return 0;
1765}
1766
1767static struct usb_serial_driver moschip7840_4port_device = {
1768	.driver = {
1769		   .owner = THIS_MODULE,
1770		   .name = "mos7840",
1771		   },
1772	.description = DRIVER_DESC,
1773	.id_table = id_table,
1774	.num_interrupt_in = 1,
1775	.open = mos7840_open,
1776	.close = mos7840_close,
1777	.write = mos7840_write,
1778	.write_room = mos7840_write_room,
1779	.chars_in_buffer = mos7840_chars_in_buffer,
1780	.throttle = mos7840_throttle,
1781	.unthrottle = mos7840_unthrottle,
1782	.calc_num_ports = mos7840_calc_num_ports,
1783	.probe = mos7840_probe,
1784	.attach = mos7840_attach,
1785	.ioctl = mos7840_ioctl,
1786	.get_serial = mos7840_get_serial_info,
1787	.set_termios = mos7840_set_termios,
1788	.break_ctl = mos7840_break,
1789	.tiocmget = mos7840_tiocmget,
1790	.tiocmset = mos7840_tiocmset,
1791	.get_icount = usb_serial_generic_get_icount,
1792	.port_probe = mos7840_port_probe,
1793	.port_remove = mos7840_port_remove,
1794	.read_bulk_callback = mos7840_bulk_in_callback,
1795};
1796
1797static struct usb_serial_driver * const serial_drivers[] = {
1798	&moschip7840_4port_device, NULL
1799};
1800
1801module_usb_serial_driver(serial_drivers, id_table);
1802
1803MODULE_DESCRIPTION(DRIVER_DESC);
1804MODULE_LICENSE("GPL");