drivers/serial/mux.c - fp2-dev/kernel/msm - Gitiles

 /*
 ** mux.c:
 **	serial driver for the Mux console found in some PA-RISC servers.
 **
 **	(c) Copyright 2002 Ryan Bradetich
 **	(c) Copyright 2002 Hewlett-Packard Company
 **
 ** 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 Driver currently only supports the console (port 0) on the MUX.
 ** Additional work will be needed on this driver to enable the full
 ** functionality of the MUX.
 **
 */

 #include <linux/module.h>
 #include <linux/tty.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/console.h>
 #include <linux/slab.h>
 #include <linux/delay.h> /* for udelay */
 #include <linux/device.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/parisc-device.h>

 #ifdef CONFIG_MAGIC_SYSRQ
 #include <linux/sysrq.h>
 #define SUPPORT_SYSRQ
 #endif

 #include <linux/serial_core.h>

 #define MUX_OFFSET 0x800
 #define MUX_LINE_OFFSET 0x80

 #define MUX_FIFO_SIZE 255
 #define MUX_POLL_DELAY (30 * HZ / 1000)

 #define IO_DATA_REG_OFFSET 0x3c
 #define IO_DCOUNT_REG_OFFSET 0x40

 #define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
 #define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
 #define MUX_BREAK(status) ((status & 0xF000) == 0x2000)

 #define MUX_NR 256
 static unsigned int port_cnt __read_mostly;
 static struct uart_port mux_ports[MUX_NR];

 static struct uart_driver mux_driver = {
 	.owner = THIS_MODULE,
 	.driver_name = "ttyB",
 	.dev_name = "ttyB",
 	.major = MUX_MAJOR,
 	.minor = 0,
 	.nr = MUX_NR,
 };

 static struct timer_list mux_timer;

 #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
 #define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
 #define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8

 /**
  * mux_tx_empty - Check if the transmitter fifo is empty.
  * @port: Ptr to the uart_port.
  *
  * This function test if the transmitter fifo for the port
  * described by 'port' is empty.  If it is empty, this function
  * should return TIOCSER_TEMT, otherwise return 0.
  */
 static unsigned int mux_tx_empty(struct uart_port *port)
 {
 	return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
 }

 /**
  * mux_set_mctrl - Set the current state of the modem control inputs.
  * @ports: Ptr to the uart_port.
  * @mctrl: Modem control bits.
  *
  * The Serial MUX does not support CTS, DCD or DSR so this function
  * is ignored.
  */
 static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 }

 /**
  * mux_get_mctrl - Returns the current state of modem control inputs.
  * @port: Ptr to the uart_port.
  *
  * The Serial MUX does not support CTS, DCD or DSR so these lines are
  * treated as permanently active.
  */
 static unsigned int mux_get_mctrl(struct uart_port *port)
 {
 	return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
 }

 /**
  * mux_stop_tx - Stop transmitting characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial MUX does not support this function.
  */
 static void mux_stop_tx(struct uart_port *port)
 {
 }

 /**
  * mux_start_tx - Start transmitting characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_start_tx(struct uart_port *port)
 {
 }

 /**
  * mux_stop_rx - Stop receiving characters.
  * @port: Ptr to the uart_port.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_stop_rx(struct uart_port *port)
 {
 }

 /**
  * mux_enable_ms - Enable modum status interrupts.
  * @port: Ptr to the uart_port.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_enable_ms(struct uart_port *port)
 {
 }

 /**
  * mux_break_ctl - Control the transmitssion of a break signal.
  * @port: Ptr to the uart_port.
  * @break_state: Raise/Lower the break signal.
  *
  * The Serial Mux does not support this function.
  */
 static void mux_break_ctl(struct uart_port *port, int break_state)
 {
 }

 /**
  * mux_write - Write chars to the mux fifo.
  * @port: Ptr to the uart_port.
  *
  * This function writes all the data from the uart buffer to
  * the mux fifo.
  */
 static void mux_write(struct uart_port *port)
 {
 	int count;
 	struct circ_buf *xmit = &port->info->xmit;

 	if(port->x_char) {
 		UART_PUT_CHAR(port, port->x_char);
 		port->icount.tx++;
 		port->x_char = 0;
 		return;
 	}

 	if(uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 		mux_stop_tx(port);
 		return;
 	}

 	count = (port->fifosize) - UART_GET_FIFO_CNT(port);
 	do {
 		UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
 		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 		port->icount.tx++;
 		if(uart_circ_empty(xmit))
 			break;

 	} while(--count > 0);

 	while(UART_GET_FIFO_CNT(port))
 		udelay(1);

 	if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 		uart_write_wakeup(port);

 	if (uart_circ_empty(xmit))
 		mux_stop_tx(port);
 }

 /**
  * mux_read - Read chars from the mux fifo.
  * @port: Ptr to the uart_port.
  *
  * This reads all available data from the mux's fifo and pushes
  * the data to the tty layer.
  */
 static void mux_read(struct uart_port *port)
 {
 	int data;
 	struct tty_struct *tty = port->info->tty;
 	__u32 start_count = port->icount.rx;

 	while(1) {
 		data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);

 		if (MUX_STATUS(data))
 			continue;

 		if (MUX_EOFIFO(data))
 			break;

 		port->icount.rx++;

 		if (MUX_BREAK(data)) {
 			port->icount.brk++;
 			if(uart_handle_break(port))
 				continue;
 		}

 		if (uart_handle_sysrq_char(port, data & 0xffu))
 			continue;

 		tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
 	}

 	if (start_count != port->icount.rx) {
 		tty_flip_buffer_push(tty);
 	}
 }

 /**
  * mux_startup - Initialize the port.
  * @port: Ptr to the uart_port.
  *
  * Grab any resources needed for this port and start the
  * mux timer.
  */
 static int mux_startup(struct uart_port *port)
 {
 	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 	return 0;
 }

 /**
  * mux_shutdown - Disable the port.
  * @port: Ptr to the uart_port.
  *
  * Release any resources needed for the port.
  */
 static void mux_shutdown(struct uart_port *port)
 {
 }

 /**
  * mux_set_termios - Chane port parameters.
  * @port: Ptr to the uart_port.
  * @termios: new termios settings.
  * @old: old termios settings.
  *
  * The Serial Mux does not support this function.
  */
 static void
 mux_set_termios(struct uart_port *port, struct termios *termios,
 	        struct termios *old)
 {
 }

 /**
  * mux_type - Describe the port.
  * @port: Ptr to the uart_port.
  *
  * Return a pointer to a string constant describing the
  * specified port.
  */
 static const char *mux_type(struct uart_port *port)
 {
 	return "Mux";
 }

 /**
  * mux_release_port - Release memory and IO regions.
  * @port: Ptr to the uart_port.
  *
  * Release any memory and IO region resources currently in use by
  * the port.
  */
 static void mux_release_port(struct uart_port *port)
 {
 }

 /**
  * mux_request_port - Request memory and IO regions.
  * @port: Ptr to the uart_port.
  *
  * Request any memory and IO region resources required by the port.
  * If any fail, no resources should be registered when this function
  * returns, and it should return -EBUSY on failure.
  */
 static int mux_request_port(struct uart_port *port)
 {
 	return 0;
 }

 /**
  * mux_config_port - Perform port autoconfiguration.
  * @port: Ptr to the uart_port.
  * @type: Bitmask of required configurations.
  *
  * Perform any autoconfiguration steps for the port.  This functino is
  * called if the UPF_BOOT_AUTOCONF flag is specified for the port.
  * [Note: This is required for now because of a bug in the Serial core.
  *  rmk has already submitted a patch to linus, should be available for
  *  2.5.47.]
  */
 static void mux_config_port(struct uart_port *port, int type)
 {
 	port->type = PORT_MUX;
 }

 /**
  * mux_verify_port - Verify the port information.
  * @port: Ptr to the uart_port.
  * @ser: Ptr to the serial information.
  *
  * Verify the new serial port information contained within serinfo is
  * suitable for this port type.
  */
 static int mux_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
 	if(port->membase == NULL)
 		return -EINVAL;

 	return 0;
 }

 /**
  * mux_drv_poll - Mux poll function.
  * @unused: Unused variable
  *
  * This function periodically polls the Serial MUX to check for new data.
  */
 static void mux_poll(unsigned long unused)
 {
 	int i;

 	for(i = 0; i < port_cnt; ++i) {
 		if(!mux_ports[i].info)
 			continue;

 		mux_read(&mux_ports[i]);
 		mux_write(&mux_ports[i]);
 	}

 	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
 }


 #ifdef CONFIG_SERIAL_MUX_CONSOLE
 static void mux_console_write(struct console *co, const char *s, unsigned count)
 {
         while(count--)
                 pdc_iodc_putc(*s++);
 }

 static int mux_console_setup(struct console *co, char *options)
 {
         return 0;
 }

 struct tty_driver *mux_console_device(struct console *co, int *index)
 {
         *index = co->index;
 	return mux_driver.tty_driver;
 }

 static struct console mux_console = {
 	.name =		"ttyB",
 	.write =	mux_console_write,
 	.device =	mux_console_device,
 	.setup =	mux_console_setup,
 	.flags =	CON_ENABLED | CON_PRINTBUFFER,
 	.index =	0,
 };

 #define MUX_CONSOLE	&mux_console
 #else
 #define MUX_CONSOLE	NULL
 #endif

 static struct uart_ops mux_pops = {
 	.tx_empty =		mux_tx_empty,
 	.set_mctrl =		mux_set_mctrl,
 	.get_mctrl =		mux_get_mctrl,
 	.stop_tx =		mux_stop_tx,
 	.start_tx =		mux_start_tx,
 	.stop_rx =		mux_stop_rx,
 	.enable_ms =		mux_enable_ms,
 	.break_ctl =		mux_break_ctl,
 	.startup =		mux_startup,
 	.shutdown =		mux_shutdown,
 	.set_termios =		mux_set_termios,
 	.type =			mux_type,
 	.release_port =		mux_release_port,
 	.request_port =		mux_request_port,
 	.config_port =		mux_config_port,
 	.verify_port =		mux_verify_port,
 };

 /**
  * mux_probe - Determine if the Serial Mux should claim this device.
  * @dev: The parisc device.
  *
  * Deterimine if the Serial Mux should claim this chip (return 0)
  * or not (return 1).
  */
 static int __init mux_probe(struct parisc_device *dev)
 {
 	int i, status, ports;
 	u8 iodc_data[32];
 	unsigned long bytecnt;
 	struct uart_port *port;

 	status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
 	if(status != PDC_OK) {
 		printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
 		return 1;
 	}

 	ports = GET_MUX_PORTS(iodc_data);
  	printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);

 	if(!port_cnt) {
 		mux_driver.cons = MUX_CONSOLE;

 		status = uart_register_driver(&mux_driver);
 		if(status) {
 			printk(KERN_ERR "Serial mux: Unable to register driver.\n");
 			return 1;
 		}

 		init_timer(&mux_timer);
 		mux_timer.function = mux_poll;
 	}

 	for(i = 0; i < ports; ++i, ++port_cnt) {
 		port = &mux_ports[port_cnt];
 		port->iobase	= 0;
 		port->mapbase	= dev->hpa.start + MUX_OFFSET +
 						(i * MUX_LINE_OFFSET);
 		port->membase	= ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
 		port->iotype	= UPIO_MEM;
 		port->type	= PORT_MUX;
 		port->irq	= NO_IRQ;
 		port->uartclk	= 0;
 		port->fifosize	= MUX_FIFO_SIZE;
 		port->ops	= &mux_pops;
 		port->flags	= UPF_BOOT_AUTOCONF;
 		port->line	= port_cnt;

 		/* The port->timeout needs to match what is present in
 		 * uart_wait_until_sent in serial_core.c.  Otherwise
 		 * the time spent in msleep_interruptable will be very
 		 * long, causing the appearance of a console hang.
 		 */
 		port->timeout   = HZ / 50;
 		spin_lock_init(&port->lock);
 		status = uart_add_one_port(&mux_driver, port);
 		BUG_ON(status);
 	}

 #ifdef CONFIG_SERIAL_MUX_CONSOLE
         register_console(&mux_console);
 #endif
 	return 0;
 }

 static struct parisc_device_id mux_tbl[] = {
 	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
 	{ 0, }
 };

 MODULE_DEVICE_TABLE(parisc, mux_tbl);

 static struct parisc_driver serial_mux_driver = {
 	.name =		"serial_mux",
 	.id_table =	mux_tbl,
 	.probe =	mux_probe,
 };

 /**
  * mux_init - Serial MUX initalization procedure.
  *
  * Register the Serial MUX driver.
  */
 static int __init mux_init(void)
 {
 	return register_parisc_driver(&serial_mux_driver);
 }

 /**
  * mux_exit - Serial MUX cleanup procedure.
  *
  * Unregister the Serial MUX driver from the tty layer.
  */
 static void __exit mux_exit(void)
 {
 	int i;

 	for (i = 0; i < port_cnt; i++) {
 		uart_remove_one_port(&mux_driver, &mux_ports[i]);
 		if (mux_ports[i].membase)
 			iounmap(mux_ports[i].membase);
 	}

 	uart_unregister_driver(&mux_driver);
 }

 module_init(mux_init);
 module_exit(mux_exit);

 MODULE_AUTHOR("Ryan Bradetich");
 MODULE_DESCRIPTION("Serial MUX driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);
	/*
	** mux.c:
	** serial driver for the Mux console found in some PA-RISC servers.
	**
	** (c) Copyright 2002 Ryan Bradetich
	** (c) Copyright 2002 Hewlett-Packard Company
	**
	** 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 Driver currently only supports the console (port 0) on the MUX.
	** Additional work will be needed on this driver to enable the full
	** functionality of the MUX.
	**
	*/

	#include <linux/module.h>
	#include <linux/tty.h>
	#include <linux/ioport.h>
	#include <linux/init.h>
	#include <linux/serial.h>
	#include <linux/console.h>
	#include <linux/slab.h>
	#include <linux/delay.h> /* for udelay */
	#include <linux/device.h>
	#include <asm/io.h>
	#include <asm/irq.h>
	#include <asm/parisc-device.h>

	#ifdef CONFIG_MAGIC_SYSRQ
	#include <linux/sysrq.h>
	#define SUPPORT_SYSRQ
	#endif

	#include <linux/serial_core.h>

	#define MUX_OFFSET 0x800
	#define MUX_LINE_OFFSET 0x80

	#define MUX_FIFO_SIZE 255
	#define MUX_POLL_DELAY (30 * HZ / 1000)

	#define IO_DATA_REG_OFFSET 0x3c
	#define IO_DCOUNT_REG_OFFSET 0x40

	#define MUX_EOFIFO(status) ((status & 0xF000) == 0xF000)
	#define MUX_STATUS(status) ((status & 0xF000) == 0x8000)
	#define MUX_BREAK(status) ((status & 0xF000) == 0x2000)

	#define MUX_NR 256
	static unsigned int port_cnt __read_mostly;
	static struct uart_port mux_ports[MUX_NR];

	static struct uart_driver mux_driver = {
	.owner = THIS_MODULE,
	.driver_name = "ttyB",
	.dev_name = "ttyB",
	.major = MUX_MAJOR,
	.minor = 0,
	.nr = MUX_NR,
	};

	static struct timer_list mux_timer;

	#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + IO_DATA_REG_OFFSET)
	#define UART_GET_FIFO_CNT(p) __raw_readl((p)->membase + IO_DCOUNT_REG_OFFSET)
	#define GET_MUX_PORTS(iodc_data) ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8

	/**
	* mux_tx_empty - Check if the transmitter fifo is empty.
	* @port: Ptr to the uart_port.
	*
	* This function test if the transmitter fifo for the port
	* described by 'port' is empty. If it is empty, this function
	* should return TIOCSER_TEMT, otherwise return 0.
	*/
	static unsigned int mux_tx_empty(struct uart_port *port)
	{
	return UART_GET_FIFO_CNT(port) ? 0 : TIOCSER_TEMT;
	}

	/**
	* mux_set_mctrl - Set the current state of the modem control inputs.
	* @ports: Ptr to the uart_port.
	* @mctrl: Modem control bits.
	*
	* The Serial MUX does not support CTS, DCD or DSR so this function
	* is ignored.
	*/
	static void mux_set_mctrl(struct uart_port *port, unsigned int mctrl)
	{
	}

	/**
	* mux_get_mctrl - Returns the current state of modem control inputs.
	* @port: Ptr to the uart_port.
	*
	* The Serial MUX does not support CTS, DCD or DSR so these lines are
	* treated as permanently active.
	*/
	static unsigned int mux_get_mctrl(struct uart_port *port)
	{
	return TIOCM_CAR \| TIOCM_DSR \| TIOCM_CTS;
	}

	/**
	* mux_stop_tx - Stop transmitting characters.
	* @port: Ptr to the uart_port.
	*
	* The Serial MUX does not support this function.
	*/
	static void mux_stop_tx(struct uart_port *port)
	{
	}

	/**
	* mux_start_tx - Start transmitting characters.
	* @port: Ptr to the uart_port.
	*
	* The Serial Mux does not support this function.
	*/
	static void mux_start_tx(struct uart_port *port)
	{
	}

	/**
	* mux_stop_rx - Stop receiving characters.
	* @port: Ptr to the uart_port.
	*
	* The Serial Mux does not support this function.
	*/
	static void mux_stop_rx(struct uart_port *port)
	{
	}

	/**
	* mux_enable_ms - Enable modum status interrupts.
	* @port: Ptr to the uart_port.
	*
	* The Serial Mux does not support this function.
	*/
	static void mux_enable_ms(struct uart_port *port)
	{
	}

	/**
	* mux_break_ctl - Control the transmitssion of a break signal.
	* @port: Ptr to the uart_port.
	* @break_state: Raise/Lower the break signal.
	*
	* The Serial Mux does not support this function.
	*/
	static void mux_break_ctl(struct uart_port *port, int break_state)
	{
	}

	/**
	* mux_write - Write chars to the mux fifo.
	* @port: Ptr to the uart_port.
	*
	* This function writes all the data from the uart buffer to
	* the mux fifo.
	*/
	static void mux_write(struct uart_port *port)
	{
	int count;
	struct circ_buf *xmit = &port->info->xmit;

	if(port->x_char) {
	UART_PUT_CHAR(port, port->x_char);
	port->icount.tx++;
	port->x_char = 0;
	return;
	}

	if(uart_circ_empty(xmit) \|\| uart_tx_stopped(port)) {
	mux_stop_tx(port);
	return;
	}

	count = (port->fifosize) - UART_GET_FIFO_CNT(port);
	do {
	UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
	port->icount.tx++;
	if(uart_circ_empty(xmit))
	break;

	} while(--count > 0);

	while(UART_GET_FIFO_CNT(port))
	udelay(1);

	if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
	uart_write_wakeup(port);

	if (uart_circ_empty(xmit))
	mux_stop_tx(port);
	}

	/**
	* mux_read - Read chars from the mux fifo.
	* @port: Ptr to the uart_port.
	*
	* This reads all available data from the mux's fifo and pushes
	* the data to the tty layer.
	*/
	static void mux_read(struct uart_port *port)
	{
	int data;
	struct tty_struct *tty = port->info->tty;
	__u32 start_count = port->icount.rx;

	while(1) {
	data = __raw_readl(port->membase + IO_DATA_REG_OFFSET);

	if (MUX_STATUS(data))
	continue;

	if (MUX_EOFIFO(data))
	break;

	port->icount.rx++;

	if (MUX_BREAK(data)) {
	port->icount.brk++;
	if(uart_handle_break(port))
	continue;
	}

	if (uart_handle_sysrq_char(port, data & 0xffu))
	continue;

	tty_insert_flip_char(tty, data & 0xFF, TTY_NORMAL);
	}

	if (start_count != port->icount.rx) {
	tty_flip_buffer_push(tty);
	}
	}

	/**
	* mux_startup - Initialize the port.
	* @port: Ptr to the uart_port.
	*
	* Grab any resources needed for this port and start the
	* mux timer.
	*/
	static int mux_startup(struct uart_port *port)
	{
	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
	return 0;
	}

	/**
	* mux_shutdown - Disable the port.
	* @port: Ptr to the uart_port.
	*
	* Release any resources needed for the port.
	*/
	static void mux_shutdown(struct uart_port *port)
	{
	}

	/**
	* mux_set_termios - Chane port parameters.
	* @port: Ptr to the uart_port.
	* @termios: new termios settings.
	* @old: old termios settings.
	*
	* The Serial Mux does not support this function.
	*/
	static void
	mux_set_termios(struct uart_port port, struct termios termios,
	struct termios *old)
	{
	}

	/**
	* mux_type - Describe the port.
	* @port: Ptr to the uart_port.
	*
	* Return a pointer to a string constant describing the
	* specified port.
	*/
	static const char mux_type(struct uart_port port)
	{
	return "Mux";
	}

	/**
	* mux_release_port - Release memory and IO regions.
	* @port: Ptr to the uart_port.
	*
	* Release any memory and IO region resources currently in use by
	* the port.
	*/
	static void mux_release_port(struct uart_port *port)
	{
	}

	/**
	* mux_request_port - Request memory and IO regions.
	* @port: Ptr to the uart_port.
	*
	* Request any memory and IO region resources required by the port.
	* If any fail, no resources should be registered when this function
	* returns, and it should return -EBUSY on failure.
	*/
	static int mux_request_port(struct uart_port *port)
	{
	return 0;
	}

	/**
	* mux_config_port - Perform port autoconfiguration.
	* @port: Ptr to the uart_port.
	* @type: Bitmask of required configurations.
	*
	* Perform any autoconfiguration steps for the port. This functino is
	* called if the UPF_BOOT_AUTOCONF flag is specified for the port.
	* [Note: This is required for now because of a bug in the Serial core.
	* rmk has already submitted a patch to linus, should be available for
	* 2.5.47.]
	*/
	static void mux_config_port(struct uart_port *port, int type)
	{
	port->type = PORT_MUX;
	}

	/**
	* mux_verify_port - Verify the port information.
	* @port: Ptr to the uart_port.
	* @ser: Ptr to the serial information.
	*
	* Verify the new serial port information contained within serinfo is
	* suitable for this port type.
	*/
	static int mux_verify_port(struct uart_port port, struct serial_struct ser)
	{
	if(port->membase == NULL)
	return -EINVAL;

	return 0;
	}

	/**
	* mux_drv_poll - Mux poll function.
	* @unused: Unused variable
	*
	* This function periodically polls the Serial MUX to check for new data.
	*/
	static void mux_poll(unsigned long unused)
	{
	int i;

	for(i = 0; i < port_cnt; ++i) {
	if(!mux_ports[i].info)
	continue;

	mux_read(&mux_ports[i]);
	mux_write(&mux_ports[i]);
	}

	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
	}


	#ifdef CONFIG_SERIAL_MUX_CONSOLE
	static void mux_console_write(struct console co, const char s, unsigned count)
	{
	while(count--)
	pdc_iodc_putc(*s++);
	}

	static int mux_console_setup(struct console co, char options)
	{
	return 0;
	}

	struct tty_driver mux_console_device(struct console co, int *index)
	{
	*index = co->index;
	return mux_driver.tty_driver;
	}

	static struct console mux_console = {
	.name = "ttyB",
	.write = mux_console_write,
	.device = mux_console_device,
	.setup = mux_console_setup,
	.flags = CON_ENABLED \| CON_PRINTBUFFER,
	.index = 0,
	};

	#define MUX_CONSOLE &mux_console
	#else
	#define MUX_CONSOLE NULL
	#endif

	static struct uart_ops mux_pops = {
	.tx_empty = mux_tx_empty,
	.set_mctrl = mux_set_mctrl,
	.get_mctrl = mux_get_mctrl,
	.stop_tx = mux_stop_tx,
	.start_tx = mux_start_tx,
	.stop_rx = mux_stop_rx,
	.enable_ms = mux_enable_ms,
	.break_ctl = mux_break_ctl,
	.startup = mux_startup,
	.shutdown = mux_shutdown,
	.set_termios = mux_set_termios,
	.type = mux_type,
	.release_port = mux_release_port,
	.request_port = mux_request_port,
	.config_port = mux_config_port,
	.verify_port = mux_verify_port,
	};

	/**
	* mux_probe - Determine if the Serial Mux should claim this device.
	* @dev: The parisc device.
	*
	* Deterimine if the Serial Mux should claim this chip (return 0)
	* or not (return 1).
	*/
	static int __init mux_probe(struct parisc_device *dev)
	{
	int i, status, ports;
	u8 iodc_data[32];
	unsigned long bytecnt;
	struct uart_port *port;

	status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
	if(status != PDC_OK) {
	printk(KERN_ERR "Serial mux: Unable to read IODC.\n");
	return 1;
	}

	ports = GET_MUX_PORTS(iodc_data);
	printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.3\n", ports);

	if(!port_cnt) {
	mux_driver.cons = MUX_CONSOLE;

	status = uart_register_driver(&mux_driver);
	if(status) {
	printk(KERN_ERR "Serial mux: Unable to register driver.\n");
	return 1;
	}

	init_timer(&mux_timer);
	mux_timer.function = mux_poll;
	}

	for(i = 0; i < ports; ++i, ++port_cnt) {
	port = &mux_ports[port_cnt];
	port->iobase = 0;
	port->mapbase = dev->hpa.start + MUX_OFFSET +
	(i * MUX_LINE_OFFSET);
	port->membase = ioremap_nocache(port->mapbase, MUX_LINE_OFFSET);
	port->iotype = UPIO_MEM;
	port->type = PORT_MUX;
	port->irq = NO_IRQ;
	port->uartclk = 0;
	port->fifosize = MUX_FIFO_SIZE;
	port->ops = &mux_pops;
	port->flags = UPF_BOOT_AUTOCONF;
	port->line = port_cnt;

	/* The port->timeout needs to match what is present in
	* uart_wait_until_sent in serial_core.c. Otherwise
	* the time spent in msleep_interruptable will be very
	* long, causing the appearance of a console hang.
	*/
	port->timeout = HZ / 50;
	spin_lock_init(&port->lock);
	status = uart_add_one_port(&mux_driver, port);
	BUG_ON(status);
	}

	#ifdef CONFIG_SERIAL_MUX_CONSOLE
	register_console(&mux_console);
	#endif
	return 0;
	}

	static struct parisc_device_id mux_tbl[] = {
	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0000D },
	{ 0, }
	};

	MODULE_DEVICE_TABLE(parisc, mux_tbl);

	static struct parisc_driver serial_mux_driver = {
	.name = "serial_mux",
	.id_table = mux_tbl,
	.probe = mux_probe,
	};

	/**
	* mux_init - Serial MUX initalization procedure.
	*
	* Register the Serial MUX driver.
	*/
	static int __init mux_init(void)
	{
	return register_parisc_driver(&serial_mux_driver);
	}

	/**
	* mux_exit - Serial MUX cleanup procedure.
	*
	* Unregister the Serial MUX driver from the tty layer.
	*/
	static void __exit mux_exit(void)
	{
	int i;

	for (i = 0; i < port_cnt; i++) {
	uart_remove_one_port(&mux_driver, &mux_ports[i]);
	if (mux_ports[i].membase)
	iounmap(mux_ports[i].membase);
	}

	uart_unregister_driver(&mux_driver);
	}

	module_init(mux_init);
	module_exit(mux_exit);

	MODULE_AUTHOR("Ryan Bradetich");
	MODULE_DESCRIPTION("Serial MUX driver");
	MODULE_LICENSE("GPL");
	MODULE_ALIAS_CHARDEV_MAJOR(MUX_MAJOR);