Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 3243 insertions, 0 deletions

diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
new file mode 100644
index 00000000000..7c24fbe831f
--- /dev/null
+++ b/drivers/char/moxa.c
@@ -0,0 +1,3243 @@
+/*****************************************************************************/
+/*
+ *           moxa.c  -- MOXA Intellio family multiport serial driver.
+ *
+ *      Copyright (C) 1999-2000  Moxa Technologies (support@moxa.com.tw).
+ *
+ *      This code is loosely based on the Linux serial driver, written by
+ *      Linus Torvalds, Theodore T'so and others.
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ *    MOXA Intellio Series Driver
+ *      for             : LINUX
+ *      date            : 1999/1/7
+ *      version         : 5.1
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/errno.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/major.h>
+#include <linux/string.h>
+#include <linux/fcntl.h>
+#include <linux/ptrace.h>
+#include <linux/serial.h>
+#include <linux/tty_driver.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#define		MOXA_VERSION		"5.1k"
+
+#define MOXAMAJOR       172
+#define MOXACUMAJOR     173
+
+#define put_to_user(arg1, arg2) put_user(arg1, (unsigned long *)arg2)
+#define get_from_user(arg1, arg2) get_user(arg1, (unsigned int *)arg2)
+
+#define MAX_BOARDS 		4	/* Don't change this value */
+#define MAX_PORTS_PER_BOARD	32	/* Don't change this value */
+#define MAX_PORTS 		128	/* Don't change this value */
+
+/*
+ *    Define the Moxa PCI vendor and device IDs.
+ */
+#define MOXA_BUS_TYPE_ISA		0
+#define MOXA_BUS_TYPE_PCI		1
+
+#ifndef	PCI_VENDOR_ID_MOXA
+#define	PCI_VENDOR_ID_MOXA	0x1393
+#endif
+#ifndef PCI_DEVICE_ID_CP204J
+#define PCI_DEVICE_ID_CP204J	0x2040
+#endif
+#ifndef PCI_DEVICE_ID_C218
+#define PCI_DEVICE_ID_C218	0x2180
+#endif
+#ifndef PCI_DEVICE_ID_C320
+#define PCI_DEVICE_ID_C320	0x3200
+#endif
+
+enum {
+	MOXA_BOARD_C218_PCI = 1,
+	MOXA_BOARD_C218_ISA,
+	MOXA_BOARD_C320_PCI,
+	MOXA_BOARD_C320_ISA,
+	MOXA_BOARD_CP204J,
+};
+
+static char *moxa_brdname[] =
+{
+	"C218 Turbo PCI series",
+	"C218 Turbo ISA series",
+	"C320 Turbo PCI series",
+	"C320 Turbo ISA series",
+	"CP-204J series",
+};
+
+#ifdef CONFIG_PCI
+static struct pci_device_id moxa_pcibrds[] = {
+	{ PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C218, PCI_ANY_ID, PCI_ANY_ID, 
+	  0, 0, MOXA_BOARD_C218_PCI },
+	{ PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_C320, PCI_ANY_ID, PCI_ANY_ID, 
+	  0, 0, MOXA_BOARD_C320_PCI },
+	{ PCI_VENDOR_ID_MOXA, PCI_DEVICE_ID_CP204J, PCI_ANY_ID, PCI_ANY_ID, 
+	  0, 0, MOXA_BOARD_CP204J },
+	{ 0 }
+};
+MODULE_DEVICE_TABLE(pci, moxa_pcibrds);
+#endif /* CONFIG_PCI */
+
+typedef struct _moxa_isa_board_conf {
+	int boardType;
+	int numPorts;
+	unsigned long baseAddr;
+} moxa_isa_board_conf;
+
+static moxa_isa_board_conf moxa_isa_boards[] =
+{
+/*       {MOXA_BOARD_C218_ISA,8,0xDC000}, */
+};
+
+typedef struct _moxa_pci_devinfo {
+	ushort busNum;
+	ushort devNum;
+} moxa_pci_devinfo;
+
+typedef struct _moxa_board_conf {
+	int boardType;
+	int numPorts;
+	unsigned long baseAddr;
+	int busType;
+	moxa_pci_devinfo pciInfo;
+} moxa_board_conf;
+
+static moxa_board_conf moxa_boards[MAX_BOARDS];
+static void __iomem *moxaBaseAddr[MAX_BOARDS];
+
+struct moxa_str {
+	int type;
+	int port;
+	int close_delay;
+	unsigned short closing_wait;
+	int count;
+	int blocked_open;
+	long event; /* long req'd for set_bit --RR */
+	int asyncflags;
+	unsigned long statusflags;
+	struct tty_struct *tty;
+	int cflag;
+	wait_queue_head_t open_wait;
+	wait_queue_head_t close_wait;
+	struct work_struct tqueue;
+};
+
+struct mxser_mstatus {
+	tcflag_t cflag;
+	int cts;
+	int dsr;
+	int ri;
+	int dcd;
+};
+
+static struct mxser_mstatus GMStatus[MAX_PORTS];
+
+/* statusflags */
+#define TXSTOPPED	0x1
+#define LOWWAIT 	0x2
+#define EMPTYWAIT	0x4
+#define THROTTLE	0x8
+
+/* event */
+#define MOXA_EVENT_HANGUP	1
+
+#define SERIAL_DO_RESTART
+
+
+#define SERIAL_TYPE_NORMAL	1
+
+#define WAKEUP_CHARS		256
+
+#define PORTNO(x)		((x)->index)
+
+static int verbose = 0;
+static int ttymajor = MOXAMAJOR;
+/* Variables for insmod */
+#ifdef MODULE
+static int baseaddr[] 	= 	{0, 0, 0, 0};
+static int type[]	=	{0, 0, 0, 0};
+static int numports[] 	=	{0, 0, 0, 0};
+#endif
+
+MODULE_AUTHOR("William Chen");
+MODULE_DESCRIPTION("MOXA Intellio Family Multiport Board Device Driver");
+MODULE_LICENSE("GPL");
+#ifdef MODULE
+module_param_array(type, int, NULL, 0);
+module_param_array(baseaddr, int, NULL, 0);
+module_param_array(numports, int, NULL, 0);
+#endif
+module_param(ttymajor, int, 0);
+module_param(verbose, bool, 0644);
+
+static struct tty_driver *moxaDriver;
+static struct moxa_str moxaChannels[MAX_PORTS];
+static unsigned char *moxaXmitBuff;
+static int moxaTimer_on;
+static struct timer_list moxaTimer;
+static int moxaEmptyTimer_on[MAX_PORTS];
+static struct timer_list moxaEmptyTimer[MAX_PORTS];
+static struct semaphore moxaBuffSem;
+
+/*
+ * static functions:
+ */
+static void do_moxa_softint(void *);
+static int moxa_open(struct tty_struct *, struct file *);
+static void moxa_close(struct tty_struct *, struct file *);
+static int moxa_write(struct tty_struct *, const unsigned char *, int);
+static int moxa_write_room(struct tty_struct *);
+static void moxa_flush_buffer(struct tty_struct *);
+static int moxa_chars_in_buffer(struct tty_struct *);
+static void moxa_flush_chars(struct tty_struct *);
+static void moxa_put_char(struct tty_struct *, unsigned char);
+static int moxa_ioctl(struct tty_struct *, struct file *, unsigned int, unsigned long);
+static void moxa_throttle(struct tty_struct *);
+static void moxa_unthrottle(struct tty_struct *);
+static void moxa_set_termios(struct tty_struct *, struct termios *);
+static void moxa_stop(struct tty_struct *);
+static void moxa_start(struct tty_struct *);
+static void moxa_hangup(struct tty_struct *);
+static int moxa_tiocmget(struct tty_struct *tty, struct file *file);
+static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
+			 unsigned int set, unsigned int clear);
+static void moxa_poll(unsigned long);
+static void set_tty_param(struct tty_struct *);
+static int block_till_ready(struct tty_struct *, struct file *,
+			    struct moxa_str *);
+static void setup_empty_event(struct tty_struct *);
+static void check_xmit_empty(unsigned long);
+static void shut_down(struct moxa_str *);
+static void receive_data(struct moxa_str *);
+/*
+ * moxa board interface functions:
+ */
+static void MoxaDriverInit(void);
+static int MoxaDriverIoctl(unsigned int, unsigned long, int);
+static int MoxaDriverPoll(void);
+static int MoxaPortsOfCard(int);
+static int MoxaPortIsValid(int);
+static void MoxaPortEnable(int);
+static void MoxaPortDisable(int);
+static long MoxaPortGetMaxBaud(int);
+static long MoxaPortSetBaud(int, long);
+static int MoxaPortSetTermio(int, struct termios *);
+static int MoxaPortGetLineOut(int, int *, int *);
+static void MoxaPortLineCtrl(int, int, int);
+static void MoxaPortFlowCtrl(int, int, int, int, int, int);
+static int MoxaPortLineStatus(int);
+static int MoxaPortDCDChange(int);
+static int MoxaPortDCDON(int);
+static void MoxaPortFlushData(int, int);
+static int MoxaPortWriteData(int, unsigned char *, int);
+static int MoxaPortReadData(int, unsigned char *, int);
+static int MoxaPortTxQueue(int);
+static int MoxaPortRxQueue(int);
+static int MoxaPortTxFree(int);
+static void MoxaPortTxDisable(int);
+static void MoxaPortTxEnable(int);
+static int MoxaPortResetBrkCnt(int);
+static void MoxaPortSendBreak(int, int);
+static int moxa_get_serial_info(struct moxa_str *, struct serial_struct __user *);
+static int moxa_set_serial_info(struct moxa_str *, struct serial_struct __user *);
+static void MoxaSetFifo(int port, int enable);
+
+static struct tty_operations moxa_ops = {
+	.open = moxa_open,
+	.close = moxa_close,
+	.write = moxa_write,
+	.write_room = moxa_write_room,
+	.flush_buffer = moxa_flush_buffer,
+	.chars_in_buffer = moxa_chars_in_buffer,
+	.flush_chars = moxa_flush_chars,
+	.put_char = moxa_put_char,
+	.ioctl = moxa_ioctl,
+	.throttle = moxa_throttle,
+	.unthrottle = moxa_unthrottle,
+	.set_termios = moxa_set_termios,
+	.stop = moxa_stop,
+	.start = moxa_start,
+	.hangup = moxa_hangup,
+	.tiocmget = moxa_tiocmget,
+	.tiocmset = moxa_tiocmset,
+};
+
+#ifdef CONFIG_PCI
+static int moxa_get_PCI_conf(struct pci_dev *p, int board_type, moxa_board_conf * board)
+{
+	board->baseAddr = pci_resource_start (p, 2);
+	board->boardType = board_type;
+	switch (board_type) {
+	case MOXA_BOARD_C218_ISA:
+	case MOXA_BOARD_C218_PCI:
+		board->numPorts = 8;
+		break;
+
+	case MOXA_BOARD_CP204J:
+		board->numPorts = 4;
+		break;
+	default:
+		board->numPorts = 0;
+		break;
+	}
+	board->busType = MOXA_BUS_TYPE_PCI;
+	board->pciInfo.busNum = p->bus->number;
+	board->pciInfo.devNum = p->devfn >> 3;
+
+	return (0);
+}
+#endif /* CONFIG_PCI */
+
+static int __init moxa_init(void)
+{
+	int i, numBoards;
+	struct moxa_str *ch;
+
+	printk(KERN_INFO "MOXA Intellio family driver version %s\n", MOXA_VERSION);
+	moxaDriver = alloc_tty_driver(MAX_PORTS + 1);
+	if (!moxaDriver)
+		return -ENOMEM;
+
+	init_MUTEX(&moxaBuffSem);
+	moxaDriver->owner = THIS_MODULE;
+	moxaDriver->name = "ttya";
+	moxaDriver->devfs_name = "tts/a";
+	moxaDriver->major = ttymajor;
+	moxaDriver->minor_start = 0;
+	moxaDriver->type = TTY_DRIVER_TYPE_SERIAL;
+	moxaDriver->subtype = SERIAL_TYPE_NORMAL;
+	moxaDriver->init_termios = tty_std_termios;
+	moxaDriver->init_termios.c_iflag = 0;
+	moxaDriver->init_termios.c_oflag = 0;
+	moxaDriver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
+	moxaDriver->init_termios.c_lflag = 0;
+	moxaDriver->flags = TTY_DRIVER_REAL_RAW;
+	tty_set_operations(moxaDriver, &moxa_ops);
+
+	moxaXmitBuff = NULL;
+
+	for (i = 0, ch = moxaChannels; i < MAX_PORTS; i++, ch++) {
+		ch->type = PORT_16550A;
+		ch->port = i;
+		INIT_WORK(&ch->tqueue, do_moxa_softint, ch);
+		ch->tty = NULL;
+		ch->close_delay = 5 * HZ / 10;
+		ch->closing_wait = 30 * HZ;
+		ch->count = 0;
+		ch->blocked_open = 0;
+		ch->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
+		init_waitqueue_head(&ch->open_wait);
+		init_waitqueue_head(&ch->close_wait);
+	}
+
+	for (i = 0; i < MAX_BOARDS; i++) {
+		moxa_boards[i].boardType = 0;
+		moxa_boards[i].numPorts = 0;
+		moxa_boards[i].baseAddr = 0;
+		moxa_boards[i].busType = 0;
+		moxa_boards[i].pciInfo.busNum = 0;
+		moxa_boards[i].pciInfo.devNum = 0;
+	}
+	MoxaDriverInit();
+	printk("Tty devices major number = %d\n", ttymajor);
+
+	if (tty_register_driver(moxaDriver)) {
+		printk(KERN_ERR "Couldn't install MOXA Smartio family driver !\n");
+		put_tty_driver(moxaDriver);
+		return -1;
+	}
+	for (i = 0; i < MAX_PORTS; i++) {
+		init_timer(&moxaEmptyTimer[i]);
+		moxaEmptyTimer[i].function = check_xmit_empty;
+		moxaEmptyTimer[i].data = (unsigned long) & moxaChannels[i];
+		moxaEmptyTimer_on[i] = 0;
+	}
+
+	init_timer(&moxaTimer);
+	moxaTimer.function = moxa_poll;
+	moxaTimer.expires = jiffies + (HZ / 50);
+	moxaTimer_on = 1;
+	add_timer(&moxaTimer);
+
+	/* Find the boards defined in source code */
+	numBoards = 0;
+	for (i = 0; i < MAX_BOARDS; i++) {
+		if ((moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA) ||
+		 (moxa_isa_boards[i].boardType == MOXA_BOARD_C320_ISA)) {
+			moxa_boards[numBoards].boardType = moxa_isa_boards[i].boardType;
+			if (moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA)
+				moxa_boards[numBoards].numPorts = 8;
+			else
+				moxa_boards[numBoards].numPorts = moxa_isa_boards[i].numPorts;
+			moxa_boards[numBoards].busType = MOXA_BUS_TYPE_ISA;
+			moxa_boards[numBoards].baseAddr = moxa_isa_boards[i].baseAddr;
+			if (verbose)
+				printk("Board %2d: %s board(baseAddr=%lx)\n",
+				       numBoards + 1,
+				       moxa_brdname[moxa_boards[numBoards].boardType - 1],
+				       moxa_boards[numBoards].baseAddr);
+			numBoards++;
+		}
+	}
+	/* Find the boards defined form module args. */
+#ifdef MODULE
+	for (i = 0; i < MAX_BOARDS; i++) {
+		if ((type[i] == MOXA_BOARD_C218_ISA) ||
+		    (type[i] == MOXA_BOARD_C320_ISA)) {
+			if (verbose)
+				printk("Board %2d: %s board(baseAddr=%lx)\n",
+				       numBoards + 1,
+				       moxa_brdname[type[i] - 1],
+				       (unsigned long) baseaddr[i]);
+			if (numBoards >= MAX_BOARDS) {
+				if (verbose)
+					printk("More than %d MOXA Intellio family boards found. Board is ignored.", MAX_BOARDS);
+				continue;
+			}
+			moxa_boards[numBoards].boardType = type[i];
+			if (moxa_isa_boards[i].boardType == MOXA_BOARD_C218_ISA)
+				moxa_boards[numBoards].numPorts = 8;
+			else
+				moxa_boards[numBoards].numPorts = numports[i];
+			moxa_boards[numBoards].busType = MOXA_BUS_TYPE_ISA;
+			moxa_boards[numBoards].baseAddr = baseaddr[i];
+			numBoards++;
+		}
+	}
+#endif
+	/* Find PCI boards here */
+#ifdef CONFIG_PCI
+	{
+		struct pci_dev *p = NULL;
+		int n = (sizeof(moxa_pcibrds) / sizeof(moxa_pcibrds[0])) - 1;
+		i = 0;
+		while (i < n) {
+			while ((p = pci_find_device(moxa_pcibrds[i].vendor, moxa_pcibrds[i].device, p))!=NULL)
+			{
+				if (pci_enable_device(p))
+					continue;
+				if (numBoards >= MAX_BOARDS) {
+					if (verbose)
+						printk("More than %d MOXA Intellio family boards found. Board is ignored.", MAX_BOARDS);
+				} else {
+					moxa_get_PCI_conf(p, moxa_pcibrds[i].driver_data,
+						&moxa_boards[numBoards]);
+					numBoards++;
+				}
+			}
+			i++;
+		}
+	}
+#endif
+	for (i = 0; i < numBoards; i++) {
+		moxaBaseAddr[i] = ioremap((unsigned long) moxa_boards[i].baseAddr, 0x4000);
+	}
+
+	return (0);
+}
+
+static void __exit moxa_exit(void)
+{
+	int i;
+
+	if (verbose)
+		printk("Unloading module moxa ...\n");
+
+	if (moxaTimer_on)
+		del_timer(&moxaTimer);
+
+	for (i = 0; i < MAX_PORTS; i++)
+		if (moxaEmptyTimer_on[i])
+			del_timer(&moxaEmptyTimer[i]);
+
+	if (tty_unregister_driver(moxaDriver))
+		printk("Couldn't unregister MOXA Intellio family serial driver\n");
+	put_tty_driver(moxaDriver);
+	if (verbose)
+		printk("Done\n");
+}
+
+module_init(moxa_init);
+module_exit(moxa_exit);
+
+static void do_moxa_softint(void *private_)
+{
+	struct moxa_str *ch = (struct moxa_str *) private_;
+	struct tty_struct *tty;
+
+	if (ch && (tty = ch->tty)) {
+		if (test_and_clear_bit(MOXA_EVENT_HANGUP, &ch->event)) {
+			tty_hangup(tty);	/* FIXME: module removal race here - AKPM */
+			wake_up_interruptible(&ch->open_wait);
+			ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
+		}
+	}
+}
+
+static int moxa_open(struct tty_struct *tty, struct file *filp)
+{
+	struct moxa_str *ch;
+	int port;
+	int retval;
+	unsigned long page;
+
+	port = PORTNO(tty);
+	if (port == MAX_PORTS) {
+		return (0);
+	}
+	if (!MoxaPortIsValid(port)) {
+		tty->driver_data = NULL;
+		return (-ENODEV);
+	}
+	down(&moxaBuffSem);
+	if (!moxaXmitBuff) {
+		page = get_zeroed_page(GFP_KERNEL);
+		if (!page) {
+			up(&moxaBuffSem);
+			return (-ENOMEM);
+		}
+		/* This test is guarded by the BuffSem so no longer needed
+		   delete me in 2.5 */
+		if (moxaXmitBuff)
+			free_page(page);
+		else
+			moxaXmitBuff = (unsigned char *) page;
+	}
+	up(&moxaBuffSem);
+
+	ch = &moxaChannels[port];
+	ch->count++;
+	tty->driver_data = ch;
+	ch->tty = tty;
+	if (!(ch->asyncflags & ASYNC_INITIALIZED)) {
+		ch->statusflags = 0;
+		set_tty_param(tty);
+		MoxaPortLineCtrl(ch->port, 1, 1);
+		MoxaPortEnable(ch->port);
+		ch->asyncflags |= ASYNC_INITIALIZED;
+	}
+	retval = block_till_ready(tty, filp, ch);
+
+	moxa_unthrottle(tty);
+
+	if (ch->type == PORT_16550A) {
+		MoxaSetFifo(ch->port, 1);
+	} else {
+		MoxaSetFifo(ch->port, 0);
+	}
+
+	return (retval);
+}
+
+static void moxa_close(struct tty_struct *tty, struct file *filp)
+{
+	struct moxa_str *ch;
+	int port;
+
+	port = PORTNO(tty);
+	if (port == MAX_PORTS) {
+		return;
+	}
+	if (!MoxaPortIsValid(port)) {
+#ifdef SERIAL_DEBUG_CLOSE
+		printk("Invalid portno in moxa_close\n");
+#endif
+		tty->driver_data = NULL;
+		return;
+	}
+	if (tty->driver_data == NULL) {
+		return;
+	}
+	if (tty_hung_up_p(filp)) {
+		return;
+	}
+	ch = (struct moxa_str *) tty->driver_data;
+
+	if ((tty->count == 1) && (ch->count != 1)) {
+		printk("moxa_close: bad serial port count; tty->count is 1, "
+		       "ch->count is %d\n", ch->count);
+		ch->count = 1;
+	}
+	if (--ch->count < 0) {
+		printk("moxa_close: bad serial port count, device=%s\n",
+		       tty->name);
+		ch->count = 0;
+	}
+	if (ch->count) {
+		return;
+	}
+	ch->asyncflags |= ASYNC_CLOSING;
+
+	ch->cflag = tty->termios->c_cflag;
+	if (ch->asyncflags & ASYNC_INITIALIZED) {
+		setup_empty_event(tty);
+		tty_wait_until_sent(tty, 30 * HZ);	/* 30 seconds timeout */
+		moxaEmptyTimer_on[ch->port] = 0;
+		del_timer(&moxaEmptyTimer[ch->port]);
+	}
+	shut_down(ch);
+	MoxaPortFlushData(port, 2);
+
+	if (tty->driver->flush_buffer)
+		tty->driver->flush_buffer(tty);
+	tty_ldisc_flush(tty);
+			
+	tty->closing = 0;
+	ch->event = 0;
+	ch->tty = NULL;
+	if (ch->blocked_open) {
+		if (ch->close_delay) {
+			msleep_interruptible(jiffies_to_msecs(ch->close_delay));
+		}
+		wake_up_interruptible(&ch->open_wait);
+	}
+	ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
+	wake_up_interruptible(&ch->close_wait);
+}
+
+static int moxa_write(struct tty_struct *tty,
+		      const unsigned char *buf, int count)
+{
+	struct moxa_str *ch;
+	int len, port;
+	unsigned long flags;
+
+	ch = (struct moxa_str *) tty->driver_data;
+	if (ch == NULL)
+		return (0);
+	port = ch->port;
+	save_flags(flags);
+	cli();
+	len = MoxaPortWriteData(port, (unsigned char *) buf, count);
+	restore_flags(flags);
+
+	/*********************************************
+	if ( !(ch->statusflags & LOWWAIT) &&
+	     ((len != count) || (MoxaPortTxFree(port) <= 100)) )
+	************************************************/
+	ch->statusflags |= LOWWAIT;
+	return (len);
+}
+
+static int moxa_write_room(struct tty_struct *tty)
+{
+	struct moxa_str *ch;
+
+	if (tty->stopped)
+		return (0);
+	ch = (struct moxa_str *) tty->driver_data;
+	if (ch == NULL)
+		return (0);
+	return (MoxaPortTxFree(ch->port));
+}
+
+static void moxa_flush_buffer(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	if (ch == NULL)
+		return;
+	MoxaPortFlushData(ch->port, 1);
+	tty_wakeup(tty);
+}
+
+static int moxa_chars_in_buffer(struct tty_struct *tty)
+{
+	int chars;
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	/*
+	 * Sigh...I have to check if driver_data is NULL here, because
+	 * if an open() fails, the TTY subsystem eventually calls
+	 * tty_wait_until_sent(), which calls the driver's chars_in_buffer()
+	 * routine.  And since the open() failed, we return 0 here.  TDJ
+	 */
+	if (ch == NULL)
+		return (0);
+	chars = MoxaPortTxQueue(ch->port);
+	if (chars) {
+		/*
+		 * Make it possible to wakeup anything waiting for output
+		 * in tty_ioctl.c, etc.
+		 */
+		if (!(ch->statusflags & EMPTYWAIT))
+			setup_empty_event(tty);
+	}
+	return (chars);
+}
+
+static void moxa_flush_chars(struct tty_struct *tty)
+{
+	/*
+	 * Don't think I need this, because this is called to empty the TX
+	 * buffer for the 16450, 16550, etc.
+	 */
+}
+
+static void moxa_put_char(struct tty_struct *tty, unsigned char c)
+{
+	struct moxa_str *ch;
+	int port;
+	unsigned long flags;
+
+	ch = (struct moxa_str *) tty->driver_data;
+	if (ch == NULL)
+		return;
+	port = ch->port;
+	save_flags(flags);
+	cli();
+	moxaXmitBuff[0] = c;
+	MoxaPortWriteData(port, moxaXmitBuff, 1);
+	restore_flags(flags);
+	/************************************************
+	if ( !(ch->statusflags & LOWWAIT) && (MoxaPortTxFree(port) <= 100) )
+	*************************************************/
+	ch->statusflags |= LOWWAIT;
+}
+
+static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+	int port;
+	int flag = 0, dtr, rts;
+
+	port = PORTNO(tty);
+	if ((port != MAX_PORTS) && (!ch))
+		return (-EINVAL);
+
+	MoxaPortGetLineOut(ch->port, &dtr, &rts);
+	if (dtr)
+		flag |= TIOCM_DTR;
+	if (rts)
+		flag |= TIOCM_RTS;
+	dtr = MoxaPortLineStatus(ch->port);
+	if (dtr & 1)
+		flag |= TIOCM_CTS;
+	if (dtr & 2)
+		flag |= TIOCM_DSR;
+	if (dtr & 4)
+		flag |= TIOCM_CD;
+	return flag;
+}
+
+static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
+			 unsigned int set, unsigned int clear)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+	int port;
+	int dtr, rts;
+
+	port = PORTNO(tty);
+	if ((port != MAX_PORTS) && (!ch))
+		return (-EINVAL);
+
+	MoxaPortGetLineOut(ch->port, &dtr, &rts);
+	if (set & TIOCM_RTS)
+		rts = 1;
+	if (set & TIOCM_DTR)
+		dtr = 1;
+	if (clear & TIOCM_RTS)
+		rts = 0;
+	if (clear & TIOCM_DTR)
+		dtr = 0;
+	MoxaPortLineCtrl(ch->port, dtr, rts);
+	return 0;
+}
+
+static int moxa_ioctl(struct tty_struct *tty, struct file *file,
+		      unsigned int cmd, unsigned long arg)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+	register int port;
+	void __user *argp = (void __user *)arg;
+	int retval;
+
+	port = PORTNO(tty);
+	if ((port != MAX_PORTS) && (!ch))
+		return (-EINVAL);
+
+	switch (cmd) {
+	case TCSBRK:		/* SVID version: non-zero arg --> no break */
+		retval = tty_check_change(tty);
+		if (retval)
+			return (retval);
+		setup_empty_event(tty);
+		tty_wait_until_sent(tty, 0);
+		if (!arg)
+			MoxaPortSendBreak(ch->port, 0);
+		return (0);
+	case TCSBRKP:		/* support for POSIX tcsendbreak() */
+		retval = tty_check_change(tty);
+		if (retval)
+			return (retval);
+		setup_empty_event(tty);
+		tty_wait_until_sent(tty, 0);
+		MoxaPortSendBreak(ch->port, arg);
+		return (0);
+	case TIOCGSOFTCAR:
+		return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *) argp);
+	case TIOCSSOFTCAR:
+		if(get_user(retval, (unsigned long __user *) argp))
+			return -EFAULT;
+		arg = retval;
+		tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) |
+					 (arg ? CLOCAL : 0));
+		if (C_CLOCAL(tty))
+			ch->asyncflags &= ~ASYNC_CHECK_CD;
+		else
+			ch->asyncflags |= ASYNC_CHECK_CD;
+		return (0);
+	case TIOCGSERIAL:
+		return moxa_get_serial_info(ch, argp);
+
+	case TIOCSSERIAL:
+		return moxa_set_serial_info(ch, argp);
+	default:
+		retval = MoxaDriverIoctl(cmd, arg, port);
+	}
+	return (retval);
+}
+
+static void moxa_throttle(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	ch->statusflags |= THROTTLE;
+}
+
+static void moxa_unthrottle(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	ch->statusflags &= ~THROTTLE;
+}
+
+static void moxa_set_termios(struct tty_struct *tty,
+			     struct termios *old_termios)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	if (ch == NULL)
+		return;
+	set_tty_param(tty);
+	if (!(old_termios->c_cflag & CLOCAL) &&
+	    (tty->termios->c_cflag & CLOCAL))
+		wake_up_interruptible(&ch->open_wait);
+}
+
+static void moxa_stop(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	if (ch == NULL)
+		return;
+	MoxaPortTxDisable(ch->port);
+	ch->statusflags |= TXSTOPPED;
+}
+
+
+static void moxa_start(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	if (ch == NULL)
+		return;
+
+	if (!(ch->statusflags & TXSTOPPED))
+		return;
+
+	MoxaPortTxEnable(ch->port);
+	ch->statusflags &= ~TXSTOPPED;
+}
+
+static void moxa_hangup(struct tty_struct *tty)
+{
+	struct moxa_str *ch = (struct moxa_str *) tty->driver_data;
+
+	moxa_flush_buffer(tty);
+	shut_down(ch);
+	ch->event = 0;
+	ch->count = 0;
+	ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
+	ch->tty = NULL;
+	wake_up_interruptible(&ch->open_wait);
+}
+
+static void moxa_poll(unsigned long ignored)
+{
+	register int card;
+	struct moxa_str *ch;
+	struct tty_struct *tp;
+	int i, ports;
+
+	moxaTimer_on = 0;
+	del_timer(&moxaTimer);
+
+	if (MoxaDriverPoll() < 0) {
+		moxaTimer.function = moxa_poll;
+		moxaTimer.expires = jiffies + (HZ / 50);
+		moxaTimer_on = 1;
+		add_timer(&moxaTimer);
+		return;
+	}
+	for (card = 0; card < MAX_BOARDS; card++) {
+		if ((ports = MoxaPortsOfCard(card)) <= 0)
+			continue;
+		ch = &moxaChannels[card * MAX_PORTS_PER_BOARD];
+		for (i = 0; i < ports; i++, ch++) {
+			if ((ch->asyncflags & ASYNC_INITIALIZED) == 0)
+				continue;
+			if (!(ch->statusflags & THROTTLE) &&
+			    (MoxaPortRxQueue(ch->port) > 0))
+				receive_data(ch);
+			if ((tp = ch->tty) == 0)
+				continue;
+			if (ch->statusflags & LOWWAIT) {
+				if (MoxaPortTxQueue(ch->port) <= WAKEUP_CHARS) {
+					if (!tp->stopped) {
+						ch->statusflags &= ~LOWWAIT;
+						tty_wakeup(tp);
+					}
+				}
+			}
+			if (!I_IGNBRK(tp) && (MoxaPortResetBrkCnt(ch->port) > 0)) {
+				tty_insert_flip_char(tp, 0, TTY_BREAK);
+				tty_schedule_flip(tp);
+			}
+			if (MoxaPortDCDChange(ch->port)) {
+				if (ch->asyncflags & ASYNC_CHECK_CD) {
+					if (MoxaPortDCDON(ch->port))
+						wake_up_interruptible(&ch->open_wait);
+					else {
+						set_bit(MOXA_EVENT_HANGUP, &ch->event);
+						schedule_work(&ch->tqueue);
+					}
+				}
+			}
+		}
+	}
+
+	moxaTimer.function = moxa_poll;
+	moxaTimer.expires = jiffies + (HZ / 50);
+	moxaTimer_on = 1;
+	add_timer(&moxaTimer);
+}
+
+/******************************************************************************/
+
+static void set_tty_param(struct tty_struct *tty)
+{
+	register struct termios *ts;
+	struct moxa_str *ch;
+	int rts, cts, txflow, rxflow, xany;
+
+	ch = (struct moxa_str *) tty->driver_data;
+	ts = tty->termios;
+	if (ts->c_cflag & CLOCAL)
+		ch->asyncflags &= ~ASYNC_CHECK_CD;
+	else
+		ch->asyncflags |= ASYNC_CHECK_CD;
+	rts = cts = txflow = rxflow = xany = 0;
+	if (ts->c_cflag & CRTSCTS)
+		rts = cts = 1;
+	if (ts->c_iflag & IXON)
+		txflow = 1;
+	if (ts->c_iflag & IXOFF)
+		rxflow = 1;
+	if (ts->c_iflag & IXANY)
+		xany = 1;
+	MoxaPortFlowCtrl(ch->port, rts, cts, txflow, rxflow, xany);
+	MoxaPortSetTermio(ch->port, ts);
+}
+
+static int block_till_ready(struct tty_struct *tty, struct file *filp,
+			    struct moxa_str *ch)
+{
+	DECLARE_WAITQUEUE(wait,current);
+	unsigned long flags;
+	int retval;
+	int do_clocal = C_CLOCAL(tty);
+
+	/*
+	 * If the device is in the middle of being closed, then block
+	 * until it's done, and then try again.
+	 */
+	if (tty_hung_up_p(filp) || (ch->asyncflags & ASYNC_CLOSING)) {
+		if (ch->asyncflags & ASYNC_CLOSING)
+			interruptible_sleep_on(&ch->close_wait);
+#ifdef SERIAL_DO_RESTART
+		if (ch->asyncflags & ASYNC_HUP_NOTIFY)
+			return (-EAGAIN);
+		else
+			return (-ERESTARTSYS);
+#else
+		return (-EAGAIN);
+#endif
+	}
+	/*
+	 * If non-blocking mode is set, then make the check up front
+	 * and then exit.
+	 */
+	if (filp->f_flags & O_NONBLOCK) {
+		ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
+		return (0);
+	}
+	/*
+	 * Block waiting for the carrier detect and the line to become free
+	 */
+	retval = 0;
+	add_wait_queue(&ch->open_wait, &wait);
+#ifdef SERIAL_DEBUG_OPEN
+	printk("block_til_ready before block: ttys%d, count = %d\n",
+	       ch->line, ch->count);
+#endif
+	save_flags(flags);
+	cli();
+	if (!tty_hung_up_p(filp))
+		ch->count--;
+	restore_flags(flags);
+	ch->blocked_open++;
+	while (1) {
+		set_current_state(TASK_INTERRUPTIBLE);
+		if (tty_hung_up_p(filp) ||
+		    !(ch->asyncflags & ASYNC_INITIALIZED)) {
+#ifdef SERIAL_DO_RESTART
+			if (ch->asyncflags & ASYNC_HUP_NOTIFY)
+				retval = -EAGAIN;
+			else
+				retval = -ERESTARTSYS;
+#else
+			retval = -EAGAIN;
+#endif
+			break;
+		}
+		if (!(ch->asyncflags & ASYNC_CLOSING) && (do_clocal ||
+						MoxaPortDCDON(ch->port)))
+			break;
+
+		if (signal_pending(current)) {
+			retval = -ERESTARTSYS;
+			break;
+		}
+		schedule();
+	}
+	set_current_state(TASK_RUNNING);
+	remove_wait_queue(&ch->open_wait, &wait);
+	if (!tty_hung_up_p(filp))
+		ch->count++;
+	ch->blocked_open--;
+#ifdef SERIAL_DEBUG_OPEN
+	printk("block_til_ready after blocking: ttys%d, count = %d\n",
+	       ch->line, ch->count);
+#endif
+	if (retval)
+		return (retval);
+	ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
+	return (0);
+}
+
+static void setup_empty_event(struct tty_struct *tty)
+{
+	struct moxa_str *ch = tty->driver_data;
+	unsigned long flags;
+
+	save_flags(flags);
+	cli();
+	ch->statusflags |= EMPTYWAIT;
+	moxaEmptyTimer_on[ch->port] = 0;
+	del_timer(&moxaEmptyTimer[ch->port]);
+	moxaEmptyTimer[ch->port].expires = jiffies + HZ;
+	moxaEmptyTimer_on[ch->port] = 1;
+	add_timer(&moxaEmptyTimer[ch->port]);
+	restore_flags(flags);
+}
+
+static void check_xmit_empty(unsigned long data)
+{
+	struct moxa_str *ch;
+
+	ch = (struct moxa_str *) data;
+	moxaEmptyTimer_on[ch->port] = 0;
+	del_timer(&moxaEmptyTimer[ch->port]);
+	if (ch->tty && (ch->statusflags & EMPTYWAIT)) {
+		if (MoxaPortTxQueue(ch->port) == 0) {
+			ch->statusflags &= ~EMPTYWAIT;
+			tty_wakeup(ch->tty);
+			return;
+		}
+		moxaEmptyTimer[ch->port].expires = jiffies + HZ;
+		moxaEmptyTimer_on[ch->port] = 1;
+		add_timer(&moxaEmptyTimer[ch->port]);
+	} else
+		ch->statusflags &= ~EMPTYWAIT;
+}
+
+static void shut_down(struct moxa_str *ch)
+{
+	struct tty_struct *tp;
+
+	if (!(ch->asyncflags & ASYNC_INITIALIZED))
+		return;
+
+	tp = ch->tty;
+
+	MoxaPortDisable(ch->port);
+
+	/*
+	 * If we're a modem control device and HUPCL is on, drop RTS & DTR.
+	 */
+	if (tp->termios->c_cflag & HUPCL)
+		MoxaPortLineCtrl(ch->port, 0, 0);
+
+	ch->asyncflags &= ~ASYNC_INITIALIZED;
+}
+
+static void receive_data(struct moxa_str *ch)
+{
+	struct tty_struct *tp;
+	struct termios *ts;
+	int i, count, rc, space;
+	unsigned char *charptr, *flagptr;
+	unsigned long flags;
+
+	ts = NULL;
+	tp = ch->tty;
+	if (tp)
+		ts = tp->termios;
+	/**************************************************
+	if ( !tp || !ts || !(ts->c_cflag & CREAD) ) {
+	*****************************************************/
+	if (!tp || !ts) {
+		MoxaPortFlushData(ch->port, 0);
+		return;
+	}
+	space = TTY_FLIPBUF_SIZE - tp->flip.count;
+	if (space <= 0)
+		return;
+	charptr = tp->flip.char_buf_ptr;
+	flagptr = tp->flip.flag_buf_ptr;
+	rc = tp->flip.count;
+	save_flags(flags);
+	cli();
+	count = MoxaPortReadData(ch->port, charptr, space);
+	restore_flags(flags);
+	for (i = 0; i < count; i++)
+		*flagptr++ = 0;
+	charptr += count;
+	rc += count;
+	tp->flip.count = rc;
+	tp->flip.char_buf_ptr = charptr;
+	tp->flip.flag_buf_ptr = flagptr;
+	tty_schedule_flip(ch->tty);
+}
+
+#define Magic_code	0x404
+
+/*
+ *    System Configuration
+ */
+/*
+ *    for C218 BIOS initialization
+ */
+#define C218_ConfBase	0x800