cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

mos7720.c (48460B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * mos7720.c
      4 *   Controls the Moschip 7720 usb to dual port serial converter
      5 *
      6 * Copyright 2006 Moschip Semiconductor Tech. Ltd.
      7 *
      8 * Developed by:
      9 * 	Vijaya Kumar <vijaykumar.gn@gmail.com>
     10 *	Ajay Kumar <naanuajay@yahoo.com>
     11 *	Gurudeva <ngurudeva@yahoo.com>
     12 *
     13 * Cleaned up from the original by:
     14 *	Greg Kroah-Hartman <gregkh@suse.de>
     15 *
     16 * Originally based on drivers/usb/serial/io_edgeport.c which is:
     17 *	Copyright (C) 2000 Inside Out Networks, All rights reserved.
     18 *	Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com>
     19 */
     20#include <linux/kernel.h>
     21#include <linux/errno.h>
     22#include <linux/slab.h>
     23#include <linux/tty.h>
     24#include <linux/tty_driver.h>
     25#include <linux/tty_flip.h>
     26#include <linux/module.h>
     27#include <linux/spinlock.h>
     28#include <linux/serial.h>
     29#include <linux/serial_reg.h>
     30#include <linux/usb.h>
     31#include <linux/usb/serial.h>
     32#include <linux/uaccess.h>
     33#include <linux/parport.h>
     34
     35#define DRIVER_AUTHOR "Aspire Communications pvt Ltd."
     36#define DRIVER_DESC "Moschip USB Serial Driver"
     37
     38/* default urb timeout */
     39#define MOS_WDR_TIMEOUT	5000
     40
     41#define MOS_MAX_PORT	0x02
     42#define MOS_WRITE	0x0E
     43#define MOS_READ	0x0D
     44
     45/* Interrupt Routines Defines	*/
     46#define SERIAL_IIR_RLS	0x06
     47#define SERIAL_IIR_RDA	0x04
     48#define SERIAL_IIR_CTI	0x0c
     49#define SERIAL_IIR_THR	0x02
     50#define SERIAL_IIR_MS	0x00
     51
     52#define NUM_URBS			16	/* URB Count */
     53#define URB_TRANSFER_BUFFER_SIZE	32	/* URB Size */
     54
     55/* This structure holds all of the local serial port information */
     56struct moschip_port {
     57	__u8	shadowLCR;		/* last LCR value received */
     58	__u8	shadowMCR;		/* last MCR value received */
     59	__u8	shadowMSR;		/* last MSR value received */
     60	char			open;
     61	struct usb_serial_port	*port;	/* loop back to the owner */
     62	struct urb		*write_urb_pool[NUM_URBS];
     63};
     64
     65#define USB_VENDOR_ID_MOSCHIP		0x9710
     66#define MOSCHIP_DEVICE_ID_7720		0x7720
     67#define MOSCHIP_DEVICE_ID_7715		0x7715
     68
     69static const struct usb_device_id id_table[] = {
     70	{ USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
     71	{ USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7715) },
     72	{ } /* terminating entry */
     73};
     74MODULE_DEVICE_TABLE(usb, id_table);
     75
     76#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
     77
     78/* initial values for parport regs */
     79#define DCR_INIT_VAL       0x0c	/* SLCTIN, nINIT */
     80#define ECR_INIT_VAL       0x00	/* SPP mode */
     81
     82enum mos7715_pp_modes {
     83	SPP = 0<<5,
     84	PS2 = 1<<5,      /* moschip calls this 'NIBBLE' mode */
     85	PPF = 2<<5,	 /* moschip calls this 'CB-FIFO mode */
     86};
     87
     88struct mos7715_parport {
     89	struct parport          *pp;	       /* back to containing struct */
     90	struct kref             ref_count;     /* to instance of this struct */
     91	bool                    msg_pending;   /* usb sync call pending */
     92	struct completion       syncmsg_compl; /* usb sync call completed */
     93	struct work_struct      work;          /* restore deferred writes */
     94	struct usb_serial       *serial;       /* back to containing struct */
     95	__u8	                shadowECR;     /* parallel port regs... */
     96	__u8	                shadowDCR;
     97	atomic_t                shadowDSR;     /* updated in int-in callback */
     98};
     99
    100/* lock guards against dereferencing NULL ptr in parport ops callbacks */
    101static DEFINE_SPINLOCK(release_lock);
    102
    103#endif	/* CONFIG_USB_SERIAL_MOS7715_PARPORT */
    104
    105static const unsigned int dummy; /* for clarity in register access fns */
    106
    107enum mos_regs {
    108	MOS7720_THR,		  /* serial port regs */
    109	MOS7720_RHR,
    110	MOS7720_IER,
    111	MOS7720_FCR,
    112	MOS7720_ISR,
    113	MOS7720_LCR,
    114	MOS7720_MCR,
    115	MOS7720_LSR,
    116	MOS7720_MSR,
    117	MOS7720_SPR,
    118	MOS7720_DLL,
    119	MOS7720_DLM,
    120	MOS7720_DPR,		  /* parallel port regs */
    121	MOS7720_DSR,
    122	MOS7720_DCR,
    123	MOS7720_ECR,
    124	MOS7720_SP1_REG,	  /* device control regs */
    125	MOS7720_SP2_REG,	  /* serial port 2 (7720 only) */
    126	MOS7720_PP_REG,
    127	MOS7720_SP_CONTROL_REG,
    128};
    129
    130/*
    131 * Return the correct value for the Windex field of the setup packet
    132 * for a control endpoint message.  See the 7715 datasheet.
    133 */
    134static inline __u16 get_reg_index(enum mos_regs reg)
    135{
    136	static const __u16 mos7715_index_lookup_table[] = {
    137		0x00,		/* MOS7720_THR */
    138		0x00,		/* MOS7720_RHR */
    139		0x01,		/* MOS7720_IER */
    140		0x02,		/* MOS7720_FCR */
    141		0x02,		/* MOS7720_ISR */
    142		0x03,		/* MOS7720_LCR */
    143		0x04,		/* MOS7720_MCR */
    144		0x05,		/* MOS7720_LSR */
    145		0x06,		/* MOS7720_MSR */
    146		0x07,		/* MOS7720_SPR */
    147		0x00,		/* MOS7720_DLL */
    148		0x01,		/* MOS7720_DLM */
    149		0x00,		/* MOS7720_DPR */
    150		0x01,		/* MOS7720_DSR */
    151		0x02,		/* MOS7720_DCR */
    152		0x0a,		/* MOS7720_ECR */
    153		0x01,		/* MOS7720_SP1_REG */
    154		0x02,		/* MOS7720_SP2_REG (7720 only) */
    155		0x04,		/* MOS7720_PP_REG (7715 only) */
    156		0x08,		/* MOS7720_SP_CONTROL_REG */
    157	};
    158	return mos7715_index_lookup_table[reg];
    159}
    160
    161/*
    162 * Return the correct value for the upper byte of the Wvalue field of
    163 * the setup packet for a control endpoint message.
    164 */
    165static inline __u16 get_reg_value(enum mos_regs reg,
    166				  unsigned int serial_portnum)
    167{
    168	if (reg >= MOS7720_SP1_REG)	/* control reg */
    169		return 0x0000;
    170
    171	else if (reg >= MOS7720_DPR)	/* parallel port reg (7715 only) */
    172		return 0x0100;
    173
    174	else			      /* serial port reg */
    175		return (serial_portnum + 2) << 8;
    176}
    177
    178/*
    179 * Write data byte to the specified device register.  The data is embedded in
    180 * the value field of the setup packet. serial_portnum is ignored for registers
    181 * not specific to a particular serial port.
    182 */
    183static int write_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
    184			 enum mos_regs reg, __u8 data)
    185{
    186	struct usb_device *usbdev = serial->dev;
    187	unsigned int pipe = usb_sndctrlpipe(usbdev, 0);
    188	__u8 request = (__u8)0x0e;
    189	__u8 requesttype = (__u8)0x40;
    190	__u16 index = get_reg_index(reg);
    191	__u16 value = get_reg_value(reg, serial_portnum) + data;
    192	int status = usb_control_msg(usbdev, pipe, request, requesttype, value,
    193				     index, NULL, 0, MOS_WDR_TIMEOUT);
    194	if (status < 0)
    195		dev_err(&usbdev->dev,
    196			"mos7720: usb_control_msg() failed: %d\n", status);
    197	return status;
    198}
    199
    200/*
    201 * Read data byte from the specified device register.  The data returned by the
    202 * device is embedded in the value field of the setup packet.  serial_portnum is
    203 * ignored for registers that are not specific to a particular serial port.
    204 */
    205static int read_mos_reg(struct usb_serial *serial, unsigned int serial_portnum,
    206			enum mos_regs reg, __u8 *data)
    207{
    208	struct usb_device *usbdev = serial->dev;
    209	unsigned int pipe = usb_rcvctrlpipe(usbdev, 0);
    210	__u8 request = (__u8)0x0d;
    211	__u8 requesttype = (__u8)0xc0;
    212	__u16 index = get_reg_index(reg);
    213	__u16 value = get_reg_value(reg, serial_portnum);
    214	u8 *buf;
    215	int status;
    216
    217	buf = kmalloc(1, GFP_KERNEL);
    218	if (!buf) {
    219		*data = 0;
    220		return -ENOMEM;
    221	}
    222
    223	status = usb_control_msg(usbdev, pipe, request, requesttype, value,
    224				     index, buf, 1, MOS_WDR_TIMEOUT);
    225	if (status == 1) {
    226		*data = *buf;
    227	} else {
    228		dev_err(&usbdev->dev,
    229			"mos7720: usb_control_msg() failed: %d\n", status);
    230		if (status >= 0)
    231			status = -EIO;
    232		*data = 0;
    233	}
    234
    235	kfree(buf);
    236
    237	return status;
    238}
    239
    240#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
    241
    242static inline int mos7715_change_mode(struct mos7715_parport *mos_parport,
    243				      enum mos7715_pp_modes mode)
    244{
    245	mos_parport->shadowECR = mode;
    246	write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
    247		      mos_parport->shadowECR);
    248	return 0;
    249}
    250
    251static void destroy_mos_parport(struct kref *kref)
    252{
    253	struct mos7715_parport *mos_parport =
    254		container_of(kref, struct mos7715_parport, ref_count);
    255
    256	kfree(mos_parport);
    257}
    258
    259/*
    260 * This is the common top part of all parallel port callback operations that
    261 * send synchronous messages to the device.  This implements convoluted locking
    262 * that avoids two scenarios: (1) a port operation is called after usbserial
    263 * has called our release function, at which point struct mos7715_parport has
    264 * been destroyed, and (2) the device has been disconnected, but usbserial has
    265 * not called the release function yet because someone has a serial port open.
    266 * The shared release_lock prevents the first, and the mutex and disconnected
    267 * flag maintained by usbserial covers the second.  We also use the msg_pending
    268 * flag to ensure that all synchronous usb message calls have completed before
    269 * our release function can return.
    270 */
    271static int parport_prologue(struct parport *pp)
    272{
    273	struct mos7715_parport *mos_parport;
    274
    275	spin_lock(&release_lock);
    276	mos_parport = pp->private_data;
    277	if (unlikely(mos_parport == NULL)) {
    278		/* release fn called, port struct destroyed */
    279		spin_unlock(&release_lock);
    280		return -1;
    281	}
    282	mos_parport->msg_pending = true;   /* synch usb call pending */
    283	reinit_completion(&mos_parport->syncmsg_compl);
    284	spin_unlock(&release_lock);
    285
    286	/* ensure writes from restore are submitted before new requests */
    287	if (work_pending(&mos_parport->work))
    288		flush_work(&mos_parport->work);
    289
    290	mutex_lock(&mos_parport->serial->disc_mutex);
    291	if (mos_parport->serial->disconnected) {
    292		/* device disconnected */
    293		mutex_unlock(&mos_parport->serial->disc_mutex);
    294		mos_parport->msg_pending = false;
    295		complete(&mos_parport->syncmsg_compl);
    296		return -1;
    297	}
    298
    299	return 0;
    300}
    301
    302/*
    303 * This is the common bottom part of all parallel port functions that send
    304 * synchronous messages to the device.
    305 */
    306static inline void parport_epilogue(struct parport *pp)
    307{
    308	struct mos7715_parport *mos_parport = pp->private_data;
    309	mutex_unlock(&mos_parport->serial->disc_mutex);
    310	mos_parport->msg_pending = false;
    311	complete(&mos_parport->syncmsg_compl);
    312}
    313
    314static void deferred_restore_writes(struct work_struct *work)
    315{
    316	struct mos7715_parport *mos_parport;
    317
    318	mos_parport = container_of(work, struct mos7715_parport, work);
    319
    320	mutex_lock(&mos_parport->serial->disc_mutex);
    321
    322	/* if device disconnected, game over */
    323	if (mos_parport->serial->disconnected)
    324		goto done;
    325
    326	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
    327		      mos_parport->shadowDCR);
    328	write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
    329		      mos_parport->shadowECR);
    330done:
    331	mutex_unlock(&mos_parport->serial->disc_mutex);
    332}
    333
    334static void parport_mos7715_write_data(struct parport *pp, unsigned char d)
    335{
    336	struct mos7715_parport *mos_parport = pp->private_data;
    337
    338	if (parport_prologue(pp) < 0)
    339		return;
    340	mos7715_change_mode(mos_parport, SPP);
    341	write_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, (__u8)d);
    342	parport_epilogue(pp);
    343}
    344
    345static unsigned char parport_mos7715_read_data(struct parport *pp)
    346{
    347	struct mos7715_parport *mos_parport = pp->private_data;
    348	unsigned char d;
    349
    350	if (parport_prologue(pp) < 0)
    351		return 0;
    352	read_mos_reg(mos_parport->serial, dummy, MOS7720_DPR, &d);
    353	parport_epilogue(pp);
    354	return d;
    355}
    356
    357static void parport_mos7715_write_control(struct parport *pp, unsigned char d)
    358{
    359	struct mos7715_parport *mos_parport = pp->private_data;
    360	__u8 data;
    361
    362	if (parport_prologue(pp) < 0)
    363		return;
    364	data = ((__u8)d & 0x0f) | (mos_parport->shadowDCR & 0xf0);
    365	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR, data);
    366	mos_parport->shadowDCR = data;
    367	parport_epilogue(pp);
    368}
    369
    370static unsigned char parport_mos7715_read_control(struct parport *pp)
    371{
    372	struct mos7715_parport *mos_parport;
    373	__u8 dcr;
    374
    375	spin_lock(&release_lock);
    376	mos_parport = pp->private_data;
    377	if (unlikely(mos_parport == NULL)) {
    378		spin_unlock(&release_lock);
    379		return 0;
    380	}
    381	dcr = mos_parport->shadowDCR & 0x0f;
    382	spin_unlock(&release_lock);
    383	return dcr;
    384}
    385
    386static unsigned char parport_mos7715_frob_control(struct parport *pp,
    387						  unsigned char mask,
    388						  unsigned char val)
    389{
    390	struct mos7715_parport *mos_parport = pp->private_data;
    391	__u8 dcr;
    392
    393	mask &= 0x0f;
    394	val &= 0x0f;
    395	if (parport_prologue(pp) < 0)
    396		return 0;
    397	mos_parport->shadowDCR = (mos_parport->shadowDCR & (~mask)) ^ val;
    398	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
    399		      mos_parport->shadowDCR);
    400	dcr = mos_parport->shadowDCR & 0x0f;
    401	parport_epilogue(pp);
    402	return dcr;
    403}
    404
    405static unsigned char parport_mos7715_read_status(struct parport *pp)
    406{
    407	unsigned char status;
    408	struct mos7715_parport *mos_parport;
    409
    410	spin_lock(&release_lock);
    411	mos_parport = pp->private_data;
    412	if (unlikely(mos_parport == NULL)) {	/* release called */
    413		spin_unlock(&release_lock);
    414		return 0;
    415	}
    416	status = atomic_read(&mos_parport->shadowDSR) & 0xf8;
    417	spin_unlock(&release_lock);
    418	return status;
    419}
    420
    421static void parport_mos7715_enable_irq(struct parport *pp)
    422{
    423}
    424
    425static void parport_mos7715_disable_irq(struct parport *pp)
    426{
    427}
    428
    429static void parport_mos7715_data_forward(struct parport *pp)
    430{
    431	struct mos7715_parport *mos_parport = pp->private_data;
    432
    433	if (parport_prologue(pp) < 0)
    434		return;
    435	mos7715_change_mode(mos_parport, PS2);
    436	mos_parport->shadowDCR &=  ~0x20;
    437	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
    438		      mos_parport->shadowDCR);
    439	parport_epilogue(pp);
    440}
    441
    442static void parport_mos7715_data_reverse(struct parport *pp)
    443{
    444	struct mos7715_parport *mos_parport = pp->private_data;
    445
    446	if (parport_prologue(pp) < 0)
    447		return;
    448	mos7715_change_mode(mos_parport, PS2);
    449	mos_parport->shadowDCR |= 0x20;
    450	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
    451		      mos_parport->shadowDCR);
    452	parport_epilogue(pp);
    453}
    454
    455static void parport_mos7715_init_state(struct pardevice *dev,
    456				       struct parport_state *s)
    457{
    458	s->u.pc.ctr = DCR_INIT_VAL;
    459	s->u.pc.ecr = ECR_INIT_VAL;
    460}
    461
    462/* N.B. Parport core code requires that this function not block */
    463static void parport_mos7715_save_state(struct parport *pp,
    464				       struct parport_state *s)
    465{
    466	struct mos7715_parport *mos_parport;
    467
    468	spin_lock(&release_lock);
    469	mos_parport = pp->private_data;
    470	if (unlikely(mos_parport == NULL)) {	/* release called */
    471		spin_unlock(&release_lock);
    472		return;
    473	}
    474	s->u.pc.ctr = mos_parport->shadowDCR;
    475	s->u.pc.ecr = mos_parport->shadowECR;
    476	spin_unlock(&release_lock);
    477}
    478
    479/* N.B. Parport core code requires that this function not block */
    480static void parport_mos7715_restore_state(struct parport *pp,
    481					  struct parport_state *s)
    482{
    483	struct mos7715_parport *mos_parport;
    484
    485	spin_lock(&release_lock);
    486	mos_parport = pp->private_data;
    487	if (unlikely(mos_parport == NULL)) {	/* release called */
    488		spin_unlock(&release_lock);
    489		return;
    490	}
    491	mos_parport->shadowDCR = s->u.pc.ctr;
    492	mos_parport->shadowECR = s->u.pc.ecr;
    493
    494	schedule_work(&mos_parport->work);
    495	spin_unlock(&release_lock);
    496}
    497
    498static size_t parport_mos7715_write_compat(struct parport *pp,
    499					   const void *buffer,
    500					   size_t len, int flags)
    501{
    502	int retval;
    503	struct mos7715_parport *mos_parport = pp->private_data;
    504	int actual_len;
    505
    506	if (parport_prologue(pp) < 0)
    507		return 0;
    508	mos7715_change_mode(mos_parport, PPF);
    509	retval = usb_bulk_msg(mos_parport->serial->dev,
    510			      usb_sndbulkpipe(mos_parport->serial->dev, 2),
    511			      (void *)buffer, len, &actual_len,
    512			      MOS_WDR_TIMEOUT);
    513	parport_epilogue(pp);
    514	if (retval) {
    515		dev_err(&mos_parport->serial->dev->dev,
    516			"mos7720: usb_bulk_msg() failed: %d\n", retval);
    517		return 0;
    518	}
    519	return actual_len;
    520}
    521
    522static struct parport_operations parport_mos7715_ops = {
    523	.owner =		THIS_MODULE,
    524	.write_data =		parport_mos7715_write_data,
    525	.read_data =		parport_mos7715_read_data,
    526
    527	.write_control =	parport_mos7715_write_control,
    528	.read_control =		parport_mos7715_read_control,
    529	.frob_control =		parport_mos7715_frob_control,
    530
    531	.read_status =		parport_mos7715_read_status,
    532
    533	.enable_irq =		parport_mos7715_enable_irq,
    534	.disable_irq =		parport_mos7715_disable_irq,
    535
    536	.data_forward =		parport_mos7715_data_forward,
    537	.data_reverse =		parport_mos7715_data_reverse,
    538
    539	.init_state =		parport_mos7715_init_state,
    540	.save_state =		parport_mos7715_save_state,
    541	.restore_state =	parport_mos7715_restore_state,
    542
    543	.compat_write_data =	parport_mos7715_write_compat,
    544
    545	.nibble_read_data =	parport_ieee1284_read_nibble,
    546	.byte_read_data =	parport_ieee1284_read_byte,
    547};
    548
    549/*
    550 * Allocate and initialize parallel port control struct, initialize
    551 * the parallel port hardware device, and register with the parport subsystem.
    552 */
    553static int mos7715_parport_init(struct usb_serial *serial)
    554{
    555	struct mos7715_parport *mos_parport;
    556
    557	/* allocate and initialize parallel port control struct */
    558	mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
    559	if (!mos_parport)
    560		return -ENOMEM;
    561
    562	mos_parport->msg_pending = false;
    563	kref_init(&mos_parport->ref_count);
    564	usb_set_serial_data(serial, mos_parport); /* hijack private pointer */
    565	mos_parport->serial = serial;
    566	INIT_WORK(&mos_parport->work, deferred_restore_writes);
    567	init_completion(&mos_parport->syncmsg_compl);
    568
    569	/* cycle parallel port reset bit */
    570	write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x80);
    571	write_mos_reg(mos_parport->serial, dummy, MOS7720_PP_REG, (__u8)0x00);
    572
    573	/* initialize device registers */
    574	mos_parport->shadowDCR = DCR_INIT_VAL;
    575	write_mos_reg(mos_parport->serial, dummy, MOS7720_DCR,
    576		      mos_parport->shadowDCR);
    577	mos_parport->shadowECR = ECR_INIT_VAL;
    578	write_mos_reg(mos_parport->serial, dummy, MOS7720_ECR,
    579		      mos_parport->shadowECR);
    580
    581	/* register with parport core */
    582	mos_parport->pp = parport_register_port(0, PARPORT_IRQ_NONE,
    583						PARPORT_DMA_NONE,
    584						&parport_mos7715_ops);
    585	if (mos_parport->pp == NULL) {
    586		dev_err(&serial->interface->dev,
    587			"Could not register parport\n");
    588		kref_put(&mos_parport->ref_count, destroy_mos_parport);
    589		return -EIO;
    590	}
    591	mos_parport->pp->private_data = mos_parport;
    592	mos_parport->pp->modes = PARPORT_MODE_COMPAT | PARPORT_MODE_PCSPP;
    593	mos_parport->pp->dev = &serial->interface->dev;
    594	parport_announce_port(mos_parport->pp);
    595
    596	return 0;
    597}
    598#endif	/* CONFIG_USB_SERIAL_MOS7715_PARPORT */
    599
    600/*
    601 * mos7720_interrupt_callback
    602 *	this is the callback function for when we have received data on the
    603 *	interrupt endpoint.
    604 */
    605static void mos7720_interrupt_callback(struct urb *urb)
    606{
    607	int result;
    608	int length;
    609	int status = urb->status;
    610	struct device *dev = &urb->dev->dev;
    611	__u8 *data;
    612	__u8 sp1;
    613	__u8 sp2;
    614
    615	switch (status) {
    616	case 0:
    617		/* success */
    618		break;
    619	case -ECONNRESET:
    620	case -ENOENT:
    621	case -ESHUTDOWN:
    622		/* this urb is terminated, clean up */
    623		dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
    624		return;
    625	default:
    626		dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
    627		goto exit;
    628	}
    629
    630	length = urb->actual_length;
    631	data = urb->transfer_buffer;
    632
    633	/* Moschip get 4 bytes
    634	 * Byte 1 IIR Port 1 (port.number is 0)
    635	 * Byte 2 IIR Port 2 (port.number is 1)
    636	 * Byte 3 --------------
    637	 * Byte 4 FIFO status for both */
    638
    639	/* the above description is inverted
    640	 * 	oneukum 2007-03-14 */
    641
    642	if (unlikely(length != 4)) {
    643		dev_dbg(dev, "Wrong data !!!\n");
    644		return;
    645	}
    646
    647	sp1 = data[3];
    648	sp2 = data[2];
    649
    650	if ((sp1 | sp2) & 0x01) {
    651		/* No Interrupt Pending in both the ports */
    652		dev_dbg(dev, "No Interrupt !!!\n");
    653	} else {
    654		switch (sp1 & 0x0f) {
    655		case SERIAL_IIR_RLS:
    656			dev_dbg(dev, "Serial Port 1: Receiver status error or address bit detected in 9-bit mode\n");
    657			break;
    658		case SERIAL_IIR_CTI:
    659			dev_dbg(dev, "Serial Port 1: Receiver time out\n");
    660			break;
    661		case SERIAL_IIR_MS:
    662			/* dev_dbg(dev, "Serial Port 1: Modem status change\n"); */
    663			break;
    664		}
    665
    666		switch (sp2 & 0x0f) {
    667		case SERIAL_IIR_RLS:
    668			dev_dbg(dev, "Serial Port 2: Receiver status error or address bit detected in 9-bit mode\n");
    669			break;
    670		case SERIAL_IIR_CTI:
    671			dev_dbg(dev, "Serial Port 2: Receiver time out\n");
    672			break;
    673		case SERIAL_IIR_MS:
    674			/* dev_dbg(dev, "Serial Port 2: Modem status change\n"); */
    675			break;
    676		}
    677	}
    678
    679exit:
    680	result = usb_submit_urb(urb, GFP_ATOMIC);
    681	if (result)
    682		dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
    683}
    684
    685/*
    686 * mos7715_interrupt_callback
    687 *	this is the 7715's callback function for when we have received data on
    688 *	the interrupt endpoint.
    689 */
    690static void mos7715_interrupt_callback(struct urb *urb)
    691{
    692	int result;
    693	int length;
    694	int status = urb->status;
    695	struct device *dev = &urb->dev->dev;
    696	__u8 *data;
    697	__u8 iir;
    698
    699	switch (status) {
    700	case 0:
    701		/* success */
    702		break;
    703	case -ECONNRESET:
    704	case -ENOENT:
    705	case -ESHUTDOWN:
    706	case -ENODEV:
    707		/* this urb is terminated, clean up */
    708		dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
    709		return;
    710	default:
    711		dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
    712		goto exit;
    713	}
    714
    715	length = urb->actual_length;
    716	data = urb->transfer_buffer;
    717
    718	/* Structure of data from 7715 device:
    719	 * Byte 1: IIR serial Port
    720	 * Byte 2: unused
    721	 * Byte 2: DSR parallel port
    722	 * Byte 4: FIFO status for both */
    723
    724	if (unlikely(length != 4)) {
    725		dev_dbg(dev, "Wrong data !!!\n");
    726		return;
    727	}
    728
    729	iir = data[0];
    730	if (!(iir & 0x01)) {	/* serial port interrupt pending */
    731		switch (iir & 0x0f) {
    732		case SERIAL_IIR_RLS:
    733			dev_dbg(dev, "Serial Port: Receiver status error or address bit detected in 9-bit mode\n");
    734			break;
    735		case SERIAL_IIR_CTI:
    736			dev_dbg(dev, "Serial Port: Receiver time out\n");
    737			break;
    738		case SERIAL_IIR_MS:
    739			/* dev_dbg(dev, "Serial Port: Modem status change\n"); */
    740			break;
    741		}
    742	}
    743
    744#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
    745	{       /* update local copy of DSR reg */
    746		struct usb_serial_port *port = urb->context;
    747		struct mos7715_parport *mos_parport = port->serial->private;
    748		if (unlikely(mos_parport == NULL))
    749			return;
    750		atomic_set(&mos_parport->shadowDSR, data[2]);
    751	}
    752#endif
    753
    754exit:
    755	result = usb_submit_urb(urb, GFP_ATOMIC);
    756	if (result)
    757		dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
    758}
    759
    760/*
    761 * mos7720_bulk_in_callback
    762 *	this is the callback function for when we have received data on the
    763 *	bulk in endpoint.
    764 */
    765static void mos7720_bulk_in_callback(struct urb *urb)
    766{
    767	int retval;
    768	unsigned char *data ;
    769	struct usb_serial_port *port;
    770	int status = urb->status;
    771
    772	if (status) {
    773		dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
    774		return;
    775	}
    776
    777	port = urb->context;
    778
    779	dev_dbg(&port->dev, "Entering...%s\n", __func__);
    780
    781	data = urb->transfer_buffer;
    782
    783	if (urb->actual_length) {
    784		tty_insert_flip_string(&port->port, data, urb->actual_length);
    785		tty_flip_buffer_push(&port->port);
    786	}
    787
    788	if (port->read_urb->status != -EINPROGRESS) {
    789		retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
    790		if (retval)
    791			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
    792	}
    793}
    794
    795/*
    796 * mos7720_bulk_out_data_callback
    797 *	this is the callback function for when we have finished sending serial
    798 *	data on the bulk out endpoint.
    799 */
    800static void mos7720_bulk_out_data_callback(struct urb *urb)
    801{
    802	struct moschip_port *mos7720_port;
    803	int status = urb->status;
    804
    805	if (status) {
    806		dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
    807		return;
    808	}
    809
    810	mos7720_port = urb->context;
    811	if (!mos7720_port) {
    812		dev_dbg(&urb->dev->dev, "NULL mos7720_port pointer\n");
    813		return ;
    814	}
    815
    816	if (mos7720_port->open)
    817		tty_port_tty_wakeup(&mos7720_port->port->port);
    818}
    819
    820static int mos77xx_calc_num_ports(struct usb_serial *serial,
    821					struct usb_serial_endpoints *epds)
    822{
    823	u16 product = le16_to_cpu(serial->dev->descriptor.idProduct);
    824
    825	if (product == MOSCHIP_DEVICE_ID_7715) {
    826		/*
    827		 * The 7715 uses the first bulk in/out endpoint pair for the
    828		 * parallel port, and the second for the serial port. We swap
    829		 * the endpoint descriptors here so that the the first and
    830		 * only registered port structure uses the serial-port
    831		 * endpoints.
    832		 */
    833		swap(epds->bulk_in[0], epds->bulk_in[1]);
    834		swap(epds->bulk_out[0], epds->bulk_out[1]);
    835
    836		return 1;
    837	}
    838
    839	return 2;
    840}
    841
    842static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
    843{
    844	struct usb_serial *serial;
    845	struct urb *urb;
    846	struct moschip_port *mos7720_port;
    847	int response;
    848	int port_number;
    849	__u8 data;
    850	int allocated_urbs = 0;
    851	int j;
    852
    853	serial = port->serial;
    854
    855	mos7720_port = usb_get_serial_port_data(port);
    856	if (mos7720_port == NULL)
    857		return -ENODEV;
    858
    859	usb_clear_halt(serial->dev, port->write_urb->pipe);
    860	usb_clear_halt(serial->dev, port->read_urb->pipe);
    861
    862	/* Initialising the write urb pool */
    863	for (j = 0; j < NUM_URBS; ++j) {
    864		urb = usb_alloc_urb(0, GFP_KERNEL);
    865		mos7720_port->write_urb_pool[j] = urb;
    866		if (!urb)
    867			continue;
    868
    869		urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
    870					       GFP_KERNEL);
    871		if (!urb->transfer_buffer) {
    872			usb_free_urb(mos7720_port->write_urb_pool[j]);
    873			mos7720_port->write_urb_pool[j] = NULL;
    874			continue;
    875		}
    876		allocated_urbs++;
    877	}
    878
    879	if (!allocated_urbs)
    880		return -ENOMEM;
    881
    882	 /* Initialize MCS7720 -- Write Init values to corresponding Registers
    883	  *
    884	  * Register Index
    885	  * 0 : MOS7720_THR/MOS7720_RHR
    886	  * 1 : MOS7720_IER
    887	  * 2 : MOS7720_FCR
    888	  * 3 : MOS7720_LCR
    889	  * 4 : MOS7720_MCR
    890	  * 5 : MOS7720_LSR
    891	  * 6 : MOS7720_MSR
    892	  * 7 : MOS7720_SPR
    893	  *
    894	  * 0x08 : SP1/2 Control Reg
    895	  */
    896	port_number = port->port_number;
    897	read_mos_reg(serial, port_number, MOS7720_LSR, &data);
    898
    899	dev_dbg(&port->dev, "SS::%p LSR:%x\n", mos7720_port, data);
    900
    901	write_mos_reg(serial, dummy, MOS7720_SP1_REG, 0x02);
    902	write_mos_reg(serial, dummy, MOS7720_SP2_REG, 0x02);
    903
    904	write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
    905	write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
    906
    907	write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
    908	mos7720_port->shadowLCR = 0x03;
    909	write_mos_reg(serial, port_number, MOS7720_LCR,
    910		      mos7720_port->shadowLCR);
    911	mos7720_port->shadowMCR = 0x0b;
    912	write_mos_reg(serial, port_number, MOS7720_MCR,
    913		      mos7720_port->shadowMCR);
    914
    915	write_mos_reg(serial, port_number, MOS7720_SP_CONTROL_REG, 0x00);
    916	read_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, &data);
    917	data = data | (port->port_number + 1);
    918	write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, data);
    919	mos7720_port->shadowLCR = 0x83;
    920	write_mos_reg(serial, port_number, MOS7720_LCR,
    921		      mos7720_port->shadowLCR);
    922	write_mos_reg(serial, port_number, MOS7720_THR, 0x0c);
    923	write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
    924	mos7720_port->shadowLCR = 0x03;
    925	write_mos_reg(serial, port_number, MOS7720_LCR,
    926		      mos7720_port->shadowLCR);
    927	write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
    928
    929	response = usb_submit_urb(port->read_urb, GFP_KERNEL);
    930	if (response)
    931		dev_err(&port->dev, "%s - Error %d submitting read urb\n",
    932							__func__, response);
    933
    934	/* initialize our port settings */
    935	mos7720_port->shadowMCR = UART_MCR_OUT2; /* Must set to enable ints! */
    936
    937	/* send a open port command */
    938	mos7720_port->open = 1;
    939
    940	return 0;
    941}
    942
    943/*
    944 * mos7720_chars_in_buffer
    945 *	this function is called by the tty driver when it wants to know how many
    946 *	bytes of data we currently have outstanding in the port (data that has
    947 *	been written, but hasn't made it out the port yet)
    948 */
    949static unsigned int mos7720_chars_in_buffer(struct tty_struct *tty)
    950{
    951	struct usb_serial_port *port = tty->driver_data;
    952	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
    953	int i;
    954	unsigned int chars = 0;
    955
    956	for (i = 0; i < NUM_URBS; ++i) {
    957		if (mos7720_port->write_urb_pool[i] &&
    958		    mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
    959			chars += URB_TRANSFER_BUFFER_SIZE;
    960	}
    961	dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
    962	return chars;
    963}
    964
    965static void mos7720_close(struct usb_serial_port *port)
    966{
    967	struct usb_serial *serial;
    968	struct moschip_port *mos7720_port;
    969	int j;
    970
    971	serial = port->serial;
    972
    973	mos7720_port = usb_get_serial_port_data(port);
    974	if (mos7720_port == NULL)
    975		return;
    976
    977	for (j = 0; j < NUM_URBS; ++j)
    978		usb_kill_urb(mos7720_port->write_urb_pool[j]);
    979
    980	/* Freeing Write URBs */
    981	for (j = 0; j < NUM_URBS; ++j) {
    982		if (mos7720_port->write_urb_pool[j]) {
    983			kfree(mos7720_port->write_urb_pool[j]->transfer_buffer);
    984			usb_free_urb(mos7720_port->write_urb_pool[j]);
    985		}
    986	}
    987
    988	/* While closing port, shutdown all bulk read, write  *
    989	 * and interrupt read if they exists, otherwise nop   */
    990	usb_kill_urb(port->write_urb);
    991	usb_kill_urb(port->read_urb);
    992
    993	write_mos_reg(serial, port->port_number, MOS7720_MCR, 0x00);
    994	write_mos_reg(serial, port->port_number, MOS7720_IER, 0x00);
    995
    996	mos7720_port->open = 0;
    997}
    998
    999static void mos7720_break(struct tty_struct *tty, int break_state)
   1000{
   1001	struct usb_serial_port *port = tty->driver_data;
   1002	unsigned char data;
   1003	struct usb_serial *serial;
   1004	struct moschip_port *mos7720_port;
   1005
   1006	serial = port->serial;
   1007
   1008	mos7720_port = usb_get_serial_port_data(port);
   1009	if (mos7720_port == NULL)
   1010		return;
   1011
   1012	if (break_state == -1)
   1013		data = mos7720_port->shadowLCR | UART_LCR_SBC;
   1014	else
   1015		data = mos7720_port->shadowLCR & ~UART_LCR_SBC;
   1016
   1017	mos7720_port->shadowLCR  = data;
   1018	write_mos_reg(serial, port->port_number, MOS7720_LCR,
   1019		      mos7720_port->shadowLCR);
   1020}
   1021
   1022/*
   1023 * mos7720_write_room
   1024 *	this function is called by the tty driver when it wants to know how many
   1025 *	bytes of data we can accept for a specific port.
   1026 */
   1027static unsigned int mos7720_write_room(struct tty_struct *tty)
   1028{
   1029	struct usb_serial_port *port = tty->driver_data;
   1030	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
   1031	unsigned int room = 0;
   1032	int i;
   1033
   1034	/* FIXME: Locking */
   1035	for (i = 0; i < NUM_URBS; ++i) {
   1036		if (mos7720_port->write_urb_pool[i] &&
   1037		    mos7720_port->write_urb_pool[i]->status != -EINPROGRESS)
   1038			room += URB_TRANSFER_BUFFER_SIZE;
   1039	}
   1040
   1041	dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
   1042	return room;
   1043}
   1044
   1045static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
   1046				 const unsigned char *data, int count)
   1047{
   1048	int status;
   1049	int i;
   1050	int bytes_sent = 0;
   1051	int transfer_size;
   1052
   1053	struct moschip_port *mos7720_port;
   1054	struct usb_serial *serial;
   1055	struct urb    *urb;
   1056	const unsigned char *current_position = data;
   1057
   1058	serial = port->serial;
   1059
   1060	mos7720_port = usb_get_serial_port_data(port);
   1061	if (mos7720_port == NULL)
   1062		return -ENODEV;
   1063
   1064	/* try to find a free urb in the list */
   1065	urb = NULL;
   1066
   1067	for (i = 0; i < NUM_URBS; ++i) {
   1068		if (mos7720_port->write_urb_pool[i] &&
   1069		    mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
   1070			urb = mos7720_port->write_urb_pool[i];
   1071			dev_dbg(&port->dev, "URB:%d\n", i);
   1072			break;
   1073		}
   1074	}
   1075
   1076	if (urb == NULL) {
   1077		dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
   1078		goto exit;
   1079	}
   1080
   1081	if (urb->transfer_buffer == NULL) {
   1082		urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
   1083					       GFP_ATOMIC);
   1084		if (!urb->transfer_buffer) {
   1085			bytes_sent = -ENOMEM;
   1086			goto exit;
   1087		}
   1088	}
   1089	transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
   1090
   1091	memcpy(urb->transfer_buffer, current_position, transfer_size);
   1092	usb_serial_debug_data(&port->dev, __func__, transfer_size,
   1093			      urb->transfer_buffer);
   1094
   1095	/* fill urb with data and submit  */
   1096	usb_fill_bulk_urb(urb, serial->dev,
   1097			  usb_sndbulkpipe(serial->dev,
   1098					port->bulk_out_endpointAddress),
   1099			  urb->transfer_buffer, transfer_size,
   1100			  mos7720_bulk_out_data_callback, mos7720_port);
   1101
   1102	/* send it down the pipe */
   1103	status = usb_submit_urb(urb, GFP_ATOMIC);
   1104	if (status) {
   1105		dev_err_console(port, "%s - usb_submit_urb(write bulk) failed "
   1106			"with status = %d\n", __func__, status);
   1107		bytes_sent = status;
   1108		goto exit;
   1109	}
   1110	bytes_sent = transfer_size;
   1111
   1112exit:
   1113	return bytes_sent;
   1114}
   1115
   1116static void mos7720_throttle(struct tty_struct *tty)
   1117{
   1118	struct usb_serial_port *port = tty->driver_data;
   1119	struct moschip_port *mos7720_port;
   1120	int status;
   1121
   1122	mos7720_port = usb_get_serial_port_data(port);
   1123
   1124	if (mos7720_port == NULL)
   1125		return;
   1126
   1127	if (!mos7720_port->open) {
   1128		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
   1129		return;
   1130	}
   1131
   1132	/* if we are implementing XON/XOFF, send the stop character */
   1133	if (I_IXOFF(tty)) {
   1134		unsigned char stop_char = STOP_CHAR(tty);
   1135		status = mos7720_write(tty, port, &stop_char, 1);
   1136		if (status <= 0)
   1137			return;
   1138	}
   1139
   1140	/* if we are implementing RTS/CTS, toggle that line */
   1141	if (C_CRTSCTS(tty)) {
   1142		mos7720_port->shadowMCR &= ~UART_MCR_RTS;
   1143		write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
   1144			      mos7720_port->shadowMCR);
   1145	}
   1146}
   1147
   1148static void mos7720_unthrottle(struct tty_struct *tty)
   1149{
   1150	struct usb_serial_port *port = tty->driver_data;
   1151	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
   1152	int status;
   1153
   1154	if (mos7720_port == NULL)
   1155		return;
   1156
   1157	if (!mos7720_port->open) {
   1158		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
   1159		return;
   1160	}
   1161
   1162	/* if we are implementing XON/XOFF, send the start character */
   1163	if (I_IXOFF(tty)) {
   1164		unsigned char start_char = START_CHAR(tty);
   1165		status = mos7720_write(tty, port, &start_char, 1);
   1166		if (status <= 0)
   1167			return;
   1168	}
   1169
   1170	/* if we are implementing RTS/CTS, toggle that line */
   1171	if (C_CRTSCTS(tty)) {
   1172		mos7720_port->shadowMCR |= UART_MCR_RTS;
   1173		write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
   1174			      mos7720_port->shadowMCR);
   1175	}
   1176}
   1177
   1178/* FIXME: this function does not work */
   1179static int set_higher_rates(struct moschip_port *mos7720_port,
   1180			    unsigned int baud)
   1181{
   1182	struct usb_serial_port *port;
   1183	struct usb_serial *serial;
   1184	int port_number;
   1185	enum mos_regs sp_reg;
   1186	if (mos7720_port == NULL)
   1187		return -EINVAL;
   1188
   1189	port = mos7720_port->port;
   1190	serial = port->serial;
   1191
   1192	 /***********************************************
   1193	 *      Init Sequence for higher rates
   1194	 ***********************************************/
   1195	dev_dbg(&port->dev, "Sending Setting Commands ..........\n");
   1196	port_number = port->port_number;
   1197
   1198	write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
   1199	write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
   1200	write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
   1201	mos7720_port->shadowMCR = 0x0b;
   1202	write_mos_reg(serial, port_number, MOS7720_MCR,
   1203		      mos7720_port->shadowMCR);
   1204	write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x00);
   1205
   1206	/***********************************************
   1207	 *              Set for higher rates           *
   1208	 ***********************************************/
   1209	/* writing baud rate verbatum into uart clock field clearly not right */
   1210	if (port_number == 0)
   1211		sp_reg = MOS7720_SP1_REG;
   1212	else
   1213		sp_reg = MOS7720_SP2_REG;
   1214	write_mos_reg(serial, dummy, sp_reg, baud * 0x10);
   1215	write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG, 0x03);
   1216	mos7720_port->shadowMCR = 0x2b;
   1217	write_mos_reg(serial, port_number, MOS7720_MCR,
   1218		      mos7720_port->shadowMCR);
   1219
   1220	/***********************************************
   1221	 *              Set DLL/DLM
   1222	 ***********************************************/
   1223	mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
   1224	write_mos_reg(serial, port_number, MOS7720_LCR,
   1225		      mos7720_port->shadowLCR);
   1226	write_mos_reg(serial, port_number, MOS7720_DLL, 0x01);
   1227	write_mos_reg(serial, port_number, MOS7720_DLM, 0x00);
   1228	mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
   1229	write_mos_reg(serial, port_number, MOS7720_LCR,
   1230		      mos7720_port->shadowLCR);
   1231
   1232	return 0;
   1233}
   1234
   1235/* baud rate information */
   1236struct divisor_table_entry {
   1237	__u32  baudrate;
   1238	__u16  divisor;
   1239};
   1240
   1241/* Define table of divisors for moschip 7720 hardware	   *
   1242 * These assume a 3.6864MHz crystal, the standard /16, and *
   1243 * MCR.7 = 0.						   */
   1244static const struct divisor_table_entry divisor_table[] = {
   1245	{   50,		2304},
   1246	{   110,	1047},	/* 2094.545455 => 230450   => .0217 % over */
   1247	{   134,	857},	/* 1713.011152 => 230398.5 => .00065% under */
   1248	{   150,	768},
   1249	{   300,	384},
   1250	{   600,	192},
   1251	{   1200,	96},
   1252	{   1800,	64},
   1253	{   2400,	48},
   1254	{   4800,	24},
   1255	{   7200,	16},
   1256	{   9600,	12},
   1257	{   19200,	6},
   1258	{   38400,	3},
   1259	{   57600,	2},
   1260	{   115200,	1},
   1261};
   1262
   1263/*****************************************************************************
   1264 * calc_baud_rate_divisor
   1265 *	this function calculates the proper baud rate divisor for the specified
   1266 *	baud rate.
   1267 *****************************************************************************/
   1268static int calc_baud_rate_divisor(struct usb_serial_port *port, int baudrate, int *divisor)
   1269{
   1270	int i;
   1271	__u16 custom;
   1272	__u16 round1;
   1273	__u16 round;
   1274
   1275
   1276	dev_dbg(&port->dev, "%s - %d\n", __func__, baudrate);
   1277
   1278	for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
   1279		if (divisor_table[i].baudrate == baudrate) {
   1280			*divisor = divisor_table[i].divisor;
   1281			return 0;
   1282		}
   1283	}
   1284
   1285	/* After trying for all the standard baud rates    *
   1286	 * Try calculating the divisor for this baud rate  */
   1287	if (baudrate > 75 &&  baudrate < 230400) {
   1288		/* get the divisor */
   1289		custom = (__u16)(230400L  / baudrate);
   1290
   1291		/* Check for round off */
   1292		round1 = (__u16)(2304000L / baudrate);
   1293		round = (__u16)(round1 - (custom * 10));
   1294		if (round > 4)
   1295			custom++;
   1296		*divisor = custom;
   1297
   1298		dev_dbg(&port->dev, "Baud %d = %d\n", baudrate, custom);
   1299		return 0;
   1300	}
   1301
   1302	dev_dbg(&port->dev, "Baud calculation Failed...\n");
   1303	return -EINVAL;
   1304}
   1305
   1306/*
   1307 * send_cmd_write_baud_rate
   1308 *	this function sends the proper command to change the baud rate of the
   1309 *	specified port.
   1310 */
   1311static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
   1312				    int baudrate)
   1313{
   1314	struct usb_serial_port *port;
   1315	struct usb_serial *serial;
   1316	int divisor;
   1317	int status;
   1318	unsigned char number;
   1319
   1320	if (mos7720_port == NULL)
   1321		return -1;
   1322
   1323	port = mos7720_port->port;
   1324	serial = port->serial;
   1325
   1326	number = port->port_number;
   1327	dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudrate);
   1328
   1329	/* Calculate the Divisor */
   1330	status = calc_baud_rate_divisor(port, baudrate, &divisor);
   1331	if (status) {
   1332		dev_err(&port->dev, "%s - bad baud rate\n", __func__);
   1333		return status;
   1334	}
   1335
   1336	/* Enable access to divisor latch */
   1337	mos7720_port->shadowLCR = mos7720_port->shadowLCR | UART_LCR_DLAB;
   1338	write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
   1339
   1340	/* Write the divisor */
   1341	write_mos_reg(serial, number, MOS7720_DLL, (__u8)(divisor & 0xff));
   1342	write_mos_reg(serial, number, MOS7720_DLM,
   1343		      (__u8)((divisor & 0xff00) >> 8));
   1344
   1345	/* Disable access to divisor latch */
   1346	mos7720_port->shadowLCR = mos7720_port->shadowLCR & ~UART_LCR_DLAB;
   1347	write_mos_reg(serial, number, MOS7720_LCR, mos7720_port->shadowLCR);
   1348
   1349	return status;
   1350}
   1351
   1352/*
   1353 * change_port_settings
   1354 *	This routine is called to set the UART on the device to match
   1355 *      the specified new settings.
   1356 */
   1357static void change_port_settings(struct tty_struct *tty,
   1358				 struct moschip_port *mos7720_port,
   1359				 struct ktermios *old_termios)
   1360{
   1361	struct usb_serial_port *port;
   1362	struct usb_serial *serial;
   1363	int baud;
   1364	unsigned cflag;
   1365	__u8 lData;
   1366	__u8 lParity;
   1367	__u8 lStop;
   1368	int status;
   1369	int port_number;
   1370
   1371	if (mos7720_port == NULL)
   1372		return ;
   1373
   1374	port = mos7720_port->port;
   1375	serial = port->serial;
   1376	port_number = port->port_number;
   1377
   1378	if (!mos7720_port->open) {
   1379		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
   1380		return;
   1381	}
   1382
   1383	lStop = 0x00;	/* 1 stop bit */
   1384	lParity = 0x00;	/* No parity */
   1385
   1386	cflag = tty->termios.c_cflag;
   1387
   1388	lData = UART_LCR_WLEN(tty_get_char_size(cflag));
   1389
   1390	/* Change the Parity bit */
   1391	if (cflag & PARENB) {
   1392		if (cflag & PARODD) {
   1393			lParity = UART_LCR_PARITY;
   1394			dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
   1395		} else {
   1396			lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
   1397			dev_dbg(&port->dev, "%s - parity = even\n", __func__);
   1398		}
   1399
   1400	} else {
   1401		dev_dbg(&port->dev, "%s - parity = none\n", __func__);
   1402	}
   1403
   1404	if (cflag & CMSPAR)
   1405		lParity = lParity | 0x20;
   1406
   1407	/* Change the Stop bit */
   1408	if (cflag & CSTOPB) {
   1409		lStop = UART_LCR_STOP;
   1410		dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
   1411	} else {
   1412		lStop = 0x00;
   1413		dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
   1414	}
   1415
   1416#define LCR_BITS_MASK		0x03	/* Mask for bits/char field */
   1417#define LCR_STOP_MASK		0x04	/* Mask for stop bits field */
   1418#define LCR_PAR_MASK		0x38	/* Mask for parity field */
   1419
   1420	/* Update the LCR with the correct value */
   1421	mos7720_port->shadowLCR &=
   1422		~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
   1423	mos7720_port->shadowLCR |= (lData | lParity | lStop);
   1424
   1425
   1426	/* Disable Interrupts */
   1427	write_mos_reg(serial, port_number, MOS7720_IER, 0x00);
   1428	write_mos_reg(serial, port_number, MOS7720_FCR, 0x00);
   1429	write_mos_reg(serial, port_number, MOS7720_FCR, 0xcf);
   1430
   1431	/* Send the updated LCR value to the mos7720 */
   1432	write_mos_reg(serial, port_number, MOS7720_LCR,
   1433		      mos7720_port->shadowLCR);
   1434	mos7720_port->shadowMCR = 0x0b;
   1435	write_mos_reg(serial, port_number, MOS7720_MCR,
   1436		      mos7720_port->shadowMCR);
   1437
   1438	/* set up the MCR register and send it to the mos7720 */
   1439	mos7720_port->shadowMCR = UART_MCR_OUT2;
   1440	if (cflag & CBAUD)
   1441		mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS);
   1442
   1443	if (cflag & CRTSCTS) {
   1444		mos7720_port->shadowMCR |= (UART_MCR_XONANY);
   1445		/* To set hardware flow control to the specified *
   1446		 * serial port, in SP1/2_CONTROL_REG             */
   1447		if (port_number)
   1448			write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
   1449				      0x01);
   1450		else
   1451			write_mos_reg(serial, dummy, MOS7720_SP_CONTROL_REG,
   1452				      0x02);
   1453
   1454	} else
   1455		mos7720_port->shadowMCR &= ~(UART_MCR_XONANY);
   1456
   1457	write_mos_reg(serial, port_number, MOS7720_MCR,
   1458		      mos7720_port->shadowMCR);
   1459
   1460	/* Determine divisor based on baud rate */
   1461	baud = tty_get_baud_rate(tty);
   1462	if (!baud) {
   1463		/* pick a default, any default... */
   1464		dev_dbg(&port->dev, "Picked default baud...\n");
   1465		baud = 9600;
   1466	}
   1467
   1468	if (baud >= 230400) {
   1469		set_higher_rates(mos7720_port, baud);
   1470		/* Enable Interrupts */
   1471		write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
   1472		return;
   1473	}
   1474
   1475	dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
   1476	status = send_cmd_write_baud_rate(mos7720_port, baud);
   1477	/* FIXME: needs to write actual resulting baud back not just
   1478	   blindly do so */
   1479	if (cflag & CBAUD)
   1480		tty_encode_baud_rate(tty, baud, baud);
   1481	/* Enable Interrupts */
   1482	write_mos_reg(serial, port_number, MOS7720_IER, 0x0c);
   1483
   1484	if (port->read_urb->status != -EINPROGRESS) {
   1485		status = usb_submit_urb(port->read_urb, GFP_KERNEL);
   1486		if (status)
   1487			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
   1488	}
   1489}
   1490
   1491/*
   1492 * mos7720_set_termios
   1493 *	this function is called by the tty driver when it wants to change the
   1494 *	termios structure.
   1495 */
   1496static void mos7720_set_termios(struct tty_struct *tty,
   1497		struct usb_serial_port *port, struct ktermios *old_termios)
   1498{
   1499	int status;
   1500	struct moschip_port *mos7720_port;
   1501
   1502	mos7720_port = usb_get_serial_port_data(port);
   1503
   1504	if (mos7720_port == NULL)
   1505		return;
   1506
   1507	if (!mos7720_port->open) {
   1508		dev_dbg(&port->dev, "%s - port not opened\n", __func__);
   1509		return;
   1510	}
   1511
   1512	/* change the port settings to the new ones specified */
   1513	change_port_settings(tty, mos7720_port, old_termios);
   1514
   1515	if (port->read_urb->status != -EINPROGRESS) {
   1516		status = usb_submit_urb(port->read_urb, GFP_KERNEL);
   1517		if (status)
   1518			dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
   1519	}
   1520}
   1521
   1522/*
   1523 * get_lsr_info - get line status register info
   1524 *
   1525 * Purpose: Let user call ioctl() to get info when the UART physically
   1526 * 	    is emptied.  On bus types like RS485, the transmitter must
   1527 * 	    release the bus after transmitting. This must be done when
   1528 * 	    the transmit shift register is empty, not be done when the
   1529 * 	    transmit holding register is empty.  This functionality
   1530 * 	    allows an RS485 driver to be written in user space.
   1531 */
   1532static int get_lsr_info(struct tty_struct *tty,
   1533		struct moschip_port *mos7720_port, unsigned int __user *value)
   1534{
   1535	struct usb_serial_port *port = tty->driver_data;
   1536	unsigned int result = 0;
   1537	unsigned char data = 0;
   1538	int port_number = port->port_number;
   1539	int count;
   1540
   1541	count = mos7720_chars_in_buffer(tty);
   1542	if (count == 0) {
   1543		read_mos_reg(port->serial, port_number, MOS7720_LSR, &data);
   1544		if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
   1545					== (UART_LSR_TEMT | UART_LSR_THRE)) {
   1546			dev_dbg(&port->dev, "%s -- Empty\n", __func__);
   1547			result = TIOCSER_TEMT;
   1548		}
   1549	}
   1550	if (copy_to_user(value, &result, sizeof(int)))
   1551		return -EFAULT;
   1552	return 0;
   1553}
   1554
   1555static int mos7720_tiocmget(struct tty_struct *tty)
   1556{
   1557	struct usb_serial_port *port = tty->driver_data;
   1558	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
   1559	unsigned int result = 0;
   1560	unsigned int mcr ;
   1561	unsigned int msr ;
   1562
   1563	mcr = mos7720_port->shadowMCR;
   1564	msr = mos7720_port->shadowMSR;
   1565
   1566	result = ((mcr & UART_MCR_DTR)  ? TIOCM_DTR : 0)   /* 0x002 */
   1567	  | ((mcr & UART_MCR_RTS)   ? TIOCM_RTS : 0)   /* 0x004 */
   1568	  | ((msr & UART_MSR_CTS)   ? TIOCM_CTS : 0)   /* 0x020 */
   1569	  | ((msr & UART_MSR_DCD)   ? TIOCM_CAR : 0)   /* 0x040 */
   1570	  | ((msr & UART_MSR_RI)    ? TIOCM_RI :  0)   /* 0x080 */
   1571	  | ((msr & UART_MSR_DSR)   ? TIOCM_DSR : 0);  /* 0x100 */
   1572
   1573	return result;
   1574}
   1575
   1576static int mos7720_tiocmset(struct tty_struct *tty,
   1577			    unsigned int set, unsigned int clear)
   1578{
   1579	struct usb_serial_port *port = tty->driver_data;
   1580	struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
   1581	unsigned int mcr ;
   1582
   1583	mcr = mos7720_port->shadowMCR;
   1584
   1585	if (set & TIOCM_RTS)
   1586		mcr |= UART_MCR_RTS;
   1587	if (set & TIOCM_DTR)
   1588		mcr |= UART_MCR_DTR;
   1589	if (set & TIOCM_LOOP)
   1590		mcr |= UART_MCR_LOOP;
   1591
   1592	if (clear & TIOCM_RTS)
   1593		mcr &= ~UART_MCR_RTS;
   1594	if (clear & TIOCM_DTR)
   1595		mcr &= ~UART_MCR_DTR;
   1596	if (clear & TIOCM_LOOP)
   1597		mcr &= ~UART_MCR_LOOP;
   1598
   1599	mos7720_port->shadowMCR = mcr;
   1600	write_mos_reg(port->serial, port->port_number, MOS7720_MCR,
   1601		      mos7720_port->shadowMCR);
   1602
   1603	return 0;
   1604}
   1605
   1606static int mos7720_ioctl(struct tty_struct *tty,
   1607			 unsigned int cmd, unsigned long arg)
   1608{
   1609	struct usb_serial_port *port = tty->driver_data;
   1610	struct moschip_port *mos7720_port;
   1611
   1612	mos7720_port = usb_get_serial_port_data(port);
   1613	if (mos7720_port == NULL)
   1614		return -ENODEV;
   1615
   1616	switch (cmd) {
   1617	case TIOCSERGETLSR:
   1618		dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
   1619		return get_lsr_info(tty, mos7720_port,
   1620					(unsigned int __user *)arg);
   1621	}
   1622
   1623	return -ENOIOCTLCMD;
   1624}
   1625
   1626static int mos7720_startup(struct usb_serial *serial)
   1627{
   1628	struct usb_device *dev;
   1629	char data;
   1630	u16 product;
   1631	int ret_val;
   1632
   1633	product = le16_to_cpu(serial->dev->descriptor.idProduct);
   1634	dev = serial->dev;
   1635
   1636	if (product == MOSCHIP_DEVICE_ID_7715) {
   1637		struct urb *urb = serial->port[0]->interrupt_in_urb;
   1638
   1639		urb->complete = mos7715_interrupt_callback;
   1640
   1641#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
   1642		ret_val = mos7715_parport_init(serial);
   1643		if (ret_val < 0)
   1644			return ret_val;
   1645#endif
   1646	}
   1647	/* start the interrupt urb */
   1648	ret_val = usb_submit_urb(serial->port[0]->interrupt_in_urb, GFP_KERNEL);
   1649	if (ret_val) {
   1650		dev_err(&dev->dev, "failed to submit interrupt urb: %d\n",
   1651			ret_val);
   1652	}
   1653
   1654	/* LSR For Port 1 */
   1655	read_mos_reg(serial, 0, MOS7720_LSR, &data);
   1656	dev_dbg(&dev->dev, "LSR:%x\n", data);
   1657
   1658	return 0;
   1659}
   1660
   1661static void mos7720_release(struct usb_serial *serial)
   1662{
   1663	usb_kill_urb(serial->port[0]->interrupt_in_urb);
   1664
   1665#ifdef CONFIG_USB_SERIAL_MOS7715_PARPORT
   1666	/* close the parallel port */
   1667
   1668	if (le16_to_cpu(serial->dev->descriptor.idProduct)
   1669	    == MOSCHIP_DEVICE_ID_7715) {
   1670		struct mos7715_parport *mos_parport =
   1671			usb_get_serial_data(serial);
   1672
   1673		/* prevent NULL ptr dereference in port callbacks */
   1674		spin_lock(&release_lock);
   1675		mos_parport->pp->private_data = NULL;
   1676		spin_unlock(&release_lock);
   1677
   1678		/* wait for synchronous usb calls to return */
   1679		if (mos_parport->msg_pending)
   1680			wait_for_completion_timeout(&mos_parport->syncmsg_compl,
   1681					    msecs_to_jiffies(MOS_WDR_TIMEOUT));
   1682		/*
   1683		 * If delayed work is currently scheduled, wait for it to
   1684		 * complete. This also implies barriers that ensure the
   1685		 * below serial clearing is not hoisted above the ->work.
   1686		 */
   1687		cancel_work_sync(&mos_parport->work);
   1688
   1689		parport_remove_port(mos_parport->pp);
   1690		usb_set_serial_data(serial, NULL);
   1691		mos_parport->serial = NULL;
   1692
   1693		parport_del_port(mos_parport->pp);
   1694
   1695		kref_put(&mos_parport->ref_count, destroy_mos_parport);
   1696	}
   1697#endif
   1698}
   1699
   1700static int mos7720_port_probe(struct usb_serial_port *port)
   1701{
   1702	struct moschip_port *mos7720_port;
   1703
   1704	mos7720_port = kzalloc(sizeof(*mos7720_port), GFP_KERNEL);
   1705	if (!mos7720_port)
   1706		return -ENOMEM;
   1707
   1708	mos7720_port->port = port;
   1709
   1710	usb_set_serial_port_data(port, mos7720_port);
   1711
   1712	return 0;
   1713}
   1714
   1715static void mos7720_port_remove(struct usb_serial_port *port)
   1716{
   1717	struct moschip_port *mos7720_port;
   1718
   1719	mos7720_port = usb_get_serial_port_data(port);
   1720	kfree(mos7720_port);
   1721}
   1722
   1723static struct usb_serial_driver moschip7720_2port_driver = {
   1724	.driver = {
   1725		.owner =	THIS_MODULE,
   1726		.name =		"moschip7720",
   1727	},
   1728	.description		= "Moschip 2 port adapter",
   1729	.id_table		= id_table,
   1730	.num_bulk_in		= 2,
   1731	.num_bulk_out		= 2,
   1732	.num_interrupt_in	= 1,
   1733	.calc_num_ports		= mos77xx_calc_num_ports,
   1734	.open			= mos7720_open,
   1735	.close			= mos7720_close,
   1736	.throttle		= mos7720_throttle,
   1737	.unthrottle		= mos7720_unthrottle,
   1738	.attach			= mos7720_startup,
   1739	.release		= mos7720_release,
   1740	.port_probe		= mos7720_port_probe,
   1741	.port_remove		= mos7720_port_remove,
   1742	.ioctl			= mos7720_ioctl,
   1743	.tiocmget		= mos7720_tiocmget,
   1744	.tiocmset		= mos7720_tiocmset,
   1745	.set_termios		= mos7720_set_termios,
   1746	.write			= mos7720_write,
   1747	.write_room		= mos7720_write_room,
   1748	.chars_in_buffer	= mos7720_chars_in_buffer,
   1749	.break_ctl		= mos7720_break,
   1750	.read_bulk_callback	= mos7720_bulk_in_callback,
   1751	.read_int_callback	= mos7720_interrupt_callback,
   1752};
   1753
   1754static struct usb_serial_driver * const serial_drivers[] = {
   1755	&moschip7720_2port_driver, NULL
   1756};
   1757
   1758module_usb_serial_driver(serial_drivers, id_table);
   1759
   1760MODULE_AUTHOR(DRIVER_AUTHOR);
   1761MODULE_DESCRIPTION(DRIVER_DESC);
   1762MODULE_LICENSE("GPL v2");