Release 4.7 drivers/tty/serial/mux.c

/*
** 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/ioport.h>
#include <linux/init.h>
#include <linux/serial.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/console.h>
#include <linux/delay.h> /* for udelay */
#include <linux/device.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/parisc-device.h>

#if defined(CONFIG_SERIAL_MUX_CONSOLE) && defined(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;

struct mux_port {
	
struct uart_port port;
	
int enabled;
};

static struct mux_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)

/**
 * get_mux_port_count - Get the number of available ports on the Mux.
 * @dev: The parisc device.
 *
 * This function is used to determine the number of ports the Mux
 * supports.  The IODC data reports the number of ports the Mux
 * can support, but there are cases where not all the Mux ports
 * are connected.  This function can override the IODC and
 * return the true port count.
 */


static int __init get_mux_port_count(struct parisc_device *dev)
{
	int status;
	u8 iodc_data[32];
	unsigned long bytecnt;

	/* If this is the built-in Mux for the K-Class (Eole CAP/MUX),
         * we only need to allocate resources for 1 port since the
         * other 7 ports are not connected.
         */
	if(dev->id.hversion == 0x15)
		return 1;

	status = pdc_iodc_read(&bytecnt, dev->hpa.start, 0, iodc_data, 32);
	BUG_ON(status != PDC_OK);

	/* Return the number of ports specified in the iodc data. */
	return ((((iodc_data)[4] & 0xf0) >> 4) * 8) + 8;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
87
97.75%
2
66.67%
matthew wilcox
matthew wilcox
2
2.25%
1
33.33%
Total
89
100.00%
3
100.00%

/**
 * 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;
} 

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
20
90.91%
1
50.00%
ryan bradetich
ryan bradetich
2
9.09%
1
50.00%
Total
22
100.00%
2
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%

/**
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
13
100.00%
1
100.00%
Total
13
100.00%
1
100.00%

/**
 * 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->state->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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
185
99.46%
2
66.67%
alan cox
alan cox
1
0.54%
1
33.33%
Total
186
100.00%
3
100.00%

/**
 * 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)
{
	struct tty_port *tport = &port->state->port;
	int data;
	__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(tport, data & 0xFF, TTY_NORMAL);
	}
	
	if (start_count != port->icount.rx)
		tty_flip_buffer_push(tport);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
114
83.21%
2
40.00%
jiri slaby
jiri slaby
14
10.22%
2
40.00%
alan cox
alan cox
9
6.57%
1
20.00%
Total
137
100.00%
5
100.00%

/**
 * 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)
{
	mux_ports[port->line].enabled = 1;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
15
60.00%
1
50.00%
ryan bradetich
ryan bradetich
10
40.00%
1
50.00%
Total
25
100.00%
2
100.00%

/**
 * 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_ports[port->line].enabled = 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
13
59.09%
1
50.00%
matthew wilcox
matthew wilcox
9
40.91%
1
50.00%
Total
22
100.00%
2
100.00%

/**
 * 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 ktermios *termios,
	        struct ktermios *old)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
11
55.00%
1
25.00%
russell king
russell king
7
35.00%
2
50.00%
alan cox
alan cox
2
10.00%
1
25.00%
Total
20
100.00%
4
100.00%

/**
 * 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";
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%

/**
 * 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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%

/**
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%

/**
 * 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 function 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%

/**
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
31
100.00%
1
100.00%
Total
31
100.00%
1
100.00%

/**
 * 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].enabled)
			continue;

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

	mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
66
92.96%
3
75.00%
ryan bradetich
ryan bradetich
5
7.04%
1
25.00%
Total
71
100.00%
4
100.00%

#ifdef CONFIG_SERIAL_MUX_CONSOLE


static void mux_console_write(struct console *co, const char *s, unsigned count)
{
	/* Wait until the FIFO drains. */
	while(UART_GET_FIFO_CNT(&mux_ports[0].port))
		udelay(1);

	while(count--) {
		if(*s == '\n') {
			UART_PUT_CHAR(&mux_ports[0].port, '\r');
		}
		UART_PUT_CHAR(&mux_ports[0].port, *s++);
	}

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
52
63.41%
1
50.00%
matthew wilcox
matthew wilcox
30
36.59%
1
50.00%
Total
82
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
18
100.00%
1
100.00%
Total
18
100.00%
1
100.00%


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


#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,
	.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;

	int port_count = get_mux_port_count(dev);
	printk(KERN_INFO "Serial mux driver (%d ports) Revision: 0.6\n", port_count);

	dev_set_drvdata(&dev->dev, (void *)(long)port_count);
	request_mem_region(dev->hpa.start + MUX_OFFSET,
                           port_count * MUX_LINE_OFFSET, "Mux");

	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;
		}
	}

	for(i = 0; i < port_count; ++i, ++port_cnt) {
		struct uart_port *port = &mux_ports[port_cnt].port;
		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	= 0;
		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);
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
197
77.25%
4
30.77%
ryan bradetich
ryan bradetich
55
21.57%
6
46.15%
russell king
russell king
1
0.39%
1
7.69%
helge deller
helge deller
1
0.39%
1
7.69%
alan cox
alan cox
1
0.39%
1
7.69%
Total
255
100.00%
13
100.00%



static int mux_remove(struct parisc_device *dev)
{
	int i, j;
	int port_count = (long)dev_get_drvdata(&dev->dev);

	/* Find Port 0 for this card in the mux_ports list. */
	for(i = 0; i < port_cnt; ++i) {
		if(mux_ports[i].port.mapbase == dev->hpa.start + MUX_OFFSET)
			break;
	}
	BUG_ON(i + port_count > port_cnt);

	/* Release the resources associated with each port on the device. */
	for(j = 0; j < port_count; ++j, ++i) {
		struct uart_port *port = &mux_ports[i].port;

		uart_remove_one_port(&mux_driver, port);
		if(port->membase)
			iounmap(port->membase);
	}

	release_mem_region(dev->hpa.start + MUX_OFFSET, port_count * MUX_LINE_OFFSET);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
137
93.84%
3
50.00%
matthew wilcox
matthew wilcox
9
6.16%
3
50.00%
Total
146
100.00%
6
100.00%

/* Hack.  This idea was taken from the 8250_gsc.c on how to properly order
 * the serial port detection in the proper order.   The idea is we always
 * want the builtin mux to be detected before addin mux cards, so we
 * specifically probe for the builtin mux cards first.
 *
 * This table only contains the parisc_device_id of known builtin mux
 * devices.  All other mux cards will be detected by the generic mux_tbl.
 */

static struct parisc_device_id builtin_mux_tbl[] = {
	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x15, 0x0000D }, /* All K-class */
	{ HPHW_A_DIRECT, HVERSION_REV_ANY_ID, 0x44, 0x0000D }, /* E35, E45, and E55 */
	{ 0, }
};


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

MODULE_DEVICE_TABLE(parisc, builtin_mux_tbl);
MODULE_DEVICE_TABLE(parisc, mux_tbl);


static struct parisc_driver builtin_serial_mux_driver = {
	.name =		"builtin_serial_mux",
	.id_table =	builtin_mux_tbl,
	.probe =	mux_probe,
	.remove =       mux_remove,
};


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

/**
 * mux_init - Serial MUX initialization procedure.
 *
 * Register the Serial MUX driver.
 */


static int __init mux_init(void)
{
	register_parisc_driver(&builtin_serial_mux_driver);
	register_parisc_driver(&serial_mux_driver);

	if(port_cnt > 0) {
		/* Start the Mux timer */
		init_timer(&mux_timer);
		mux_timer.function = mux_poll;
		mod_timer(&mux_timer, jiffies + MUX_POLL_DELAY);

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

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
51
77.27%
2
50.00%
matthew wilcox
matthew wilcox
15
22.73%
2
50.00%
Total
66
100.00%
4
100.00%

/**
 * mux_exit - Serial MUX cleanup procedure.
 *
 * Unregister the Serial MUX driver from the tty layer.
 */


static void __exit mux_exit(void)
{
	/* Delete the Mux timer. */
	if(port_cnt > 0) {
		del_timer_sync(&mux_timer);
#ifdef CONFIG_SERIAL_MUX_CONSOLE
		unregister_console(&mux_console);
#endif
	}

	unregister_parisc_driver(&builtin_serial_mux_driver);
	unregister_parisc_driver(&serial_mux_driver);
	uart_unregister_driver(&mux_driver);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ryan bradetich
ryan bradetich
27
50.94%
3
42.86%
matthew wilcox
matthew wilcox
22
41.51%
2
28.57%
amol lad
amol lad
3
5.66%
1
14.29%
julia lawall
julia lawall
1
1.89%
1
14.29%
Total
53
100.00%
7
100.00%


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);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
matthew wilcox
matthew wilcox
1263
67.50%
6
18.18%
ryan bradetich
ryan bradetich
530
28.33%
9
27.27%
jiri slaby
jiri slaby
20
1.07%
3
9.09%
russell king
russell king
13
0.69%
4
12.12%
alan cox
alan cox
13
0.69%
4
12.12%
daniel thompson
daniel thompson
10
0.53%
1
3.03%
andrew morton
andrew morton
8
0.43%
1
3.03%
axel lin
axel lin
7
0.37%
1
3.03%
amol lad
amol lad
3
0.16%
1
3.03%
helge deller
helge deller
2
0.11%
1
3.03%
julia lawall
julia lawall
1
0.05%
1
3.03%
joe perches
joe perches
1
0.05%
1
3.03%
Total
1871
100.00%
33
100.00%
  
Directory: drivers/tty/serial

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.