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