[linux.git] / drivers / serial / sunhv.c

/* sunhv.c: Serial driver for SUN4V hypervisor console.
 *
 * Copyright (C) 2006 David S. Miller ([email protected])
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/major.h>
#include <linux/circ_buf.h>
#include <linux/serial.h>
#include <linux/sysrq.h>
#include <linux/console.h>
#include <linux/spinlock.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/init.h>

#include <asm/hypervisor.h>
#include <asm/spitfire.h>
#include <asm/prom.h>
#include <asm/of_device.h>
#include <asm/irq.h>

#if defined(CONFIG_MAGIC_SYSRQ)
#define SUPPORT_SYSRQ
#endif

#include <linux/serial_core.h>

#include "suncore.h"

#define CON_BREAK	((long)-1)
#define CON_HUP		((long)-2)

static inline long hypervisor_con_getchar(long *status)
{
	register unsigned long func asm("%o5");
	register unsigned long arg0 asm("%o0");
	register unsigned long arg1 asm("%o1");

	func = HV_FAST_CONS_GETCHAR;
	arg0 = 0;
	arg1 = 0;
	__asm__ __volatile__("ta	%6"
			     : "=&r" (func), "=&r" (arg0), "=&r" (arg1)
			     : "0" (func), "1" (arg0), "2" (arg1),
			       "i" (HV_FAST_TRAP));

	*status = arg0;

	return (long) arg1;
}

static inline long hypervisor_con_putchar(long ch)
{
	register unsigned long func asm("%o5");
	register unsigned long arg0 asm("%o0");

	func = HV_FAST_CONS_PUTCHAR;
	arg0 = ch;
	__asm__ __volatile__("ta	%4"
			     : "=&r" (func), "=&r" (arg0)
			     : "0" (func), "1" (arg0), "i" (HV_FAST_TRAP));

	return (long) arg0;
}

#define IGNORE_BREAK	0x1
#define IGNORE_ALL	0x2

static int hung_up = 0;

static struct tty_struct *receive_chars(struct uart_port *port)
{
	struct tty_struct *tty = NULL;
	int saw_console_brk = 0;
	int limit = 10000;

	if (port->info != NULL)		/* Unopened serial console */
		tty = port->info->tty;

	while (limit-- > 0) {
		long status;
		long c = hypervisor_con_getchar(&status);
		unsigned char flag;

		if (status == HV_EWOULDBLOCK)
			break;

		if (c == CON_BREAK) {
			if (uart_handle_break(port))
				continue;
			saw_console_brk = 1;
			c = 0;
		}

		if (c == CON_HUP) {
			hung_up = 1;
			uart_handle_dcd_change(port, 0);
		} else if (hung_up) {
			hung_up = 0;
			uart_handle_dcd_change(port, 1);
		}

		if (tty == NULL) {
			uart_handle_sysrq_char(port, c);
			continue;
		}

		flag = TTY_NORMAL;
		port->icount.rx++;
		if (c == CON_BREAK) {
			port->icount.brk++;
			if (uart_handle_break(port))
				continue;
			flag = TTY_BREAK;
		}

		if (uart_handle_sysrq_char(port, c))
			continue;

		if ((port->ignore_status_mask & IGNORE_ALL) ||
		    ((port->ignore_status_mask & IGNORE_BREAK) &&
		     (c == CON_BREAK)))
			continue;

		tty_insert_flip_char(tty, c, flag);
	}

	if (saw_console_brk)
		sun_do_break();

	return tty;
}

static void transmit_chars(struct uart_port *port)
{
	struct circ_buf *xmit;

	if (!port->info)
		return;

	xmit = &port->info->xmit;
	if (uart_circ_empty(xmit) || uart_tx_stopped(port))
		return;

	while (!uart_circ_empty(xmit)) {
		long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);

		if (status != HV_EOK)
			break;

		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
		port->icount.tx++;
	}

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

static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
{
	struct uart_port *port = dev_id;
	struct tty_struct *tty;
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	tty = receive_chars(port);
	transmit_chars(port);
	spin_unlock_irqrestore(&port->lock, flags);

	if (tty)
		tty_flip_buffer_push(tty);

	return IRQ_HANDLED;
}

/* port->lock is not held.  */
static unsigned int sunhv_tx_empty(struct uart_port *port)
{
	/* Transmitter is always empty for us.  If the circ buffer
	 * is non-empty or there is an x_char pending, our caller
	 * will do the right thing and ignore what we return here.
	 */
	return TIOCSER_TEMT;
}

/* port->lock held by caller.  */
static void sunhv_set_mctrl(struct uart_port *port, unsigned int mctrl)
{
	return;
}

/* port->lock is held by caller and interrupts are disabled.  */
static unsigned int sunhv_get_mctrl(struct uart_port *port)
{
	return TIOCM_DSR | TIOCM_CAR | TIOCM_CTS;
}

/* port->lock held by caller.  */
static void sunhv_stop_tx(struct uart_port *port)
{
	return;
}

/* port->lock held by caller.  */
static void sunhv_start_tx(struct uart_port *port)
{
	struct circ_buf *xmit = &port->info->xmit;

	while (!uart_circ_empty(xmit)) {
		long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);

		if (status != HV_EOK)
			break;

		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
		port->icount.tx++;
	}
}

/* port->lock is not held.  */
static void sunhv_send_xchar(struct uart_port *port, char ch)
{
	unsigned long flags;
	int limit = 10000;

	spin_lock_irqsave(&port->lock, flags);

	while (limit-- > 0) {
		long status = hypervisor_con_putchar(ch);
		if (status == HV_EOK)
			break;
	}

	spin_unlock_irqrestore(&port->lock, flags);
}

/* port->lock held by caller.  */
static void sunhv_stop_rx(struct uart_port *port)
{
}

/* port->lock held by caller.  */
static void sunhv_enable_ms(struct uart_port *port)
{
}

/* port->lock is not held.  */
static void sunhv_break_ctl(struct uart_port *port, int break_state)
{
	if (break_state) {
		unsigned long flags;
		int limit = 1000000;

		spin_lock_irqsave(&port->lock, flags);

		while (limit-- > 0) {
			long status = hypervisor_con_putchar(CON_BREAK);
			if (status == HV_EOK)
				break;
			udelay(2);
		}

		spin_unlock_irqrestore(&port->lock, flags);
	}
}

/* port->lock is not held.  */
static int sunhv_startup(struct uart_port *port)
{
	return 0;
}

/* port->lock is not held.  */
static void sunhv_shutdown(struct uart_port *port)
{
}

/* port->lock is not held.  */
static void sunhv_set_termios(struct uart_port *port, struct termios *termios,
			      struct termios *old)
{
	unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
	unsigned int quot = uart_get_divisor(port, baud);
	unsigned int iflag, cflag;
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);

	iflag = termios->c_iflag;
	cflag = termios->c_cflag;

	port->ignore_status_mask = 0;
	if (iflag & IGNBRK)
		port->ignore_status_mask |= IGNORE_BREAK;
	if ((cflag & CREAD) == 0)
		port->ignore_status_mask |= IGNORE_ALL;

	/* XXX */
	uart_update_timeout(port, cflag,
			    (port->uartclk / (16 * quot)));

	spin_unlock_irqrestore(&port->lock, flags);
}

static const char *sunhv_type(struct uart_port *port)
{
	return "SUN4V HCONS";
}

static void sunhv_release_port(struct uart_port *port)
{
}

static int sunhv_request_port(struct uart_port *port)
{
	return 0;
}

static void sunhv_config_port(struct uart_port *port, int flags)
{
}

static int sunhv_verify_port(struct uart_port *port, struct serial_struct *ser)
{
	return -EINVAL;
}

static struct uart_ops sunhv_pops = {
	.tx_empty	= sunhv_tx_empty,
	.set_mctrl	= sunhv_set_mctrl,
	.get_mctrl	= sunhv_get_mctrl,
	.stop_tx	= sunhv_stop_tx,
	.start_tx	= sunhv_start_tx,
	.send_xchar	= sunhv_send_xchar,
	.stop_rx	= sunhv_stop_rx,
	.enable_ms	= sunhv_enable_ms,
	.break_ctl	= sunhv_break_ctl,
	.startup	= sunhv_startup,
	.shutdown	= sunhv_shutdown,
	.set_termios	= sunhv_set_termios,
	.type		= sunhv_type,
	.release_port	= sunhv_release_port,
	.request_port	= sunhv_request_port,
	.config_port	= sunhv_config_port,
	.verify_port	= sunhv_verify_port,
};

static struct uart_driver sunhv_reg = {
	.owner			= THIS_MODULE,
	.driver_name		= "serial",
	.dev_name		= "ttyS",
	.major			= TTY_MAJOR,
};

static struct uart_port *sunhv_port;

static inline void sunhv_console_putchar(struct uart_port *port, char c)
{
	unsigned long flags;
	int limit = 1000000;

	spin_lock_irqsave(&port->lock, flags);

	while (limit-- > 0) {
		long status = hypervisor_con_putchar(c);
		if (status == HV_EOK)
			break;
		udelay(2);
	}

	spin_unlock_irqrestore(&port->lock, flags);
}

static void sunhv_console_write(struct console *con, const char *s, unsigned n)
{
	struct uart_port *port = sunhv_port;
	int i;

	for (i = 0; i < n; i++) {
		if (*s == '\n')
			sunhv_console_putchar(port, '\r');
		sunhv_console_putchar(port, *s++);
	}
}

static struct console sunhv_console = {
	.name	=	"ttyHV",
	.write	=	sunhv_console_write,
	.device	=	uart_console_device,
	.flags	=	CON_PRINTBUFFER,
	.index	=	-1,
	.data	=	&sunhv_reg,
};

static inline struct console *SUNHV_CONSOLE(void)
{
	if (con_is_present())
		return NULL;

	sunhv_console.index = 0;

	return &sunhv_console;
}

static int __devinit hv_probe(struct of_device *op, const struct of_device_id *match)
{
	struct uart_port *port;
	int err;

	if (op->irqs[0] == 0xffffffff)
		return -ENODEV;

	port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
	if (unlikely(!port))
		return -ENOMEM;

	sunhv_port = port;

	port->line = 0;
	port->ops = &sunhv_pops;
	port->type = PORT_SUNHV;
	port->uartclk = ( 29491200 / 16 ); /* arbitrary */

	port->membase = (unsigned char __iomem *) __pa(port);

	port->irq = op->irqs[0];

	port->dev = &op->dev;

	sunhv_reg.minor = sunserial_current_minor;
	sunhv_reg.nr = 1;

	err = uart_register_driver(&sunhv_reg);
	if (err)
		goto out_free_port;

	sunhv_reg.tty_driver->name_base = sunhv_reg.minor - 64;
	sunserial_current_minor += 1;

	sunhv_reg.cons = SUNHV_CONSOLE();

	err = uart_add_one_port(&sunhv_reg, port);
	if (err)
		goto out_unregister_driver;

	err = request_irq(port->irq, sunhv_interrupt, 0, "hvcons", port);
	if (err)
		goto out_remove_port;

	dev_set_drvdata(&op->dev, port);

	return 0;

out_remove_port:
	uart_remove_one_port(&sunhv_reg, port);

out_unregister_driver:
	sunserial_current_minor -= 1;
	uart_unregister_driver(&sunhv_reg);

out_free_port:
	kfree(port);
	sunhv_port = NULL;
	return err;
}

static int __devexit hv_remove(struct of_device *dev)
{
	struct uart_port *port = dev_get_drvdata(&dev->dev);

	free_irq(port->irq, port);

	uart_remove_one_port(&sunhv_reg, port);

	sunserial_current_minor -= 1;
	uart_unregister_driver(&sunhv_reg);

	kfree(port);
	sunhv_port = NULL;

	dev_set_drvdata(&dev->dev, NULL);

	return 0;
}

static struct of_device_id hv_match[] = {
	{
		.name = "console",
		.compatible = "qcn",
	},
	{},
};
MODULE_DEVICE_TABLE(of, hv_match);

static struct of_platform_driver hv_driver = {
	.name		= "hv",
	.match_table	= hv_match,
	.probe		= hv_probe,
	.remove		= __devexit_p(hv_remove),
};

static int __init sunhv_init(void)
{
	if (tlb_type != hypervisor)
		return -ENODEV;

	return of_register_driver(&hv_driver, &of_bus_type);
}

static void __exit sunhv_exit(void)
{
	of_unregister_driver(&hv_driver);
}

module_init(sunhv_init);
module_exit(sunhv_exit);

MODULE_AUTHOR("David S. Miller");
MODULE_DESCRIPTION("SUN4V Hypervisor console driver");
MODULE_VERSION("2.0");
MODULE_LICENSE("GPL");
Commit	Line	Data
02fd473b DM	1	/* sunhv.c: Serial driver for SUN4V hypervisor console.
	2	*
	3	* Copyright (C) 2006 David S. Miller ([email protected])
	4	*/
	5
	6	#include <linux/module.h>
	7	#include <linux/kernel.h>
	8	#include <linux/errno.h>
	9	#include <linux/tty.h>
	10	#include <linux/tty_flip.h>
	11	#include <linux/major.h>
	12	#include <linux/circ_buf.h>
	13	#include <linux/serial.h>
	14	#include <linux/sysrq.h>
	15	#include <linux/console.h>
	16	#include <linux/spinlock.h>
	17	#include <linux/slab.h>
	18	#include <linux/delay.h>
	19	#include <linux/init.h>
	20
	21	#include <asm/hypervisor.h>
	22	#include <asm/spitfire.h>
93872ba2 DM	23	#include <asm/prom.h>
93872ba2 DM	24	#include <asm/of_device.h>
f4266ab4	25	#include <asm/irq.h>
02fd473b DM	26
	27	#if defined(CONFIG_MAGIC_SYSRQ)
	28	#define SUPPORT_SYSRQ
	29	#endif
	30
	31	#include <linux/serial_core.h>
	32
	33	#include "suncore.h"
	34
	35	#define CON_BREAK ((long)-1)
	36	#define CON_HUP ((long)-2)
	37
	38	static inline long hypervisor_con_getchar(long *status)
	39	{
	40	register unsigned long func asm("%o5");
	41	register unsigned long arg0 asm("%o0");
	42	register unsigned long arg1 asm("%o1");
	43
	44	func = HV_FAST_CONS_GETCHAR;
	45	arg0 = 0;
	46	arg1 = 0;
	47	__asm__ __volatile__("ta %6"
	48	: "=&r" (func), "=&r" (arg0), "=&r" (arg1)
	49	: "0" (func), "1" (arg0), "2" (arg1),
	50	"i" (HV_FAST_TRAP));
	51
	52	*status = arg0;
	53
	54	return (long) arg1;
	55	}
	56
	57	static inline long hypervisor_con_putchar(long ch)
	58	{
	59	register unsigned long func asm("%o5");
	60	register unsigned long arg0 asm("%o0");
	61
	62	func = HV_FAST_CONS_PUTCHAR;
	63	arg0 = ch;
	64	__asm__ __volatile__("ta %4"
	65	: "=&r" (func), "=&r" (arg0)
	66	: "0" (func), "1" (arg0), "i" (HV_FAST_TRAP));
	67
	68	return (long) arg0;
	69	}
	70
	71	#define IGNORE_BREAK 0x1
	72	#define IGNORE_ALL 0x2
	73
	74	static int hung_up = 0;
	75
7d12e780	76	static struct tty_struct receive_chars(struct uart_port port)
02fd473b DM	77	{
	78	struct tty_struct *tty = NULL;
	79	int saw_console_brk = 0;
	80	int limit = 10000;
	81
	82	if (port->info != NULL) /* Unopened serial console */
	83	tty = port->info->tty;
	84
	85	while (limit-- > 0) {
	86	long status;
	87	long c = hypervisor_con_getchar(&status);
	88	unsigned char flag;
	89
	90	if (status == HV_EWOULDBLOCK)
	91	break;
	92
	93	if (c == CON_BREAK) {
135066a2 DM	94	if (uart_handle_break(port))
135066a2 DM	95	continue;
02fd473b DM	96	saw_console_brk = 1;
	97	c = 0;
	98	}
	99
	100	if (c == CON_HUP) {
	101	hung_up = 1;
	102	uart_handle_dcd_change(port, 0);
	103	} else if (hung_up) {
	104	hung_up = 0;
	105	uart_handle_dcd_change(port, 1);
	106	}
	107
	108	if (tty == NULL) {
7d12e780	109	uart_handle_sysrq_char(port, c);
02fd473b DM	110	continue;
	111	}
	112
	113	flag = TTY_NORMAL;
	114	port->icount.rx++;
	115	if (c == CON_BREAK) {
	116	port->icount.brk++;
	117	if (uart_handle_break(port))
	118	continue;
	119	flag = TTY_BREAK;
	120	}
	121
7d12e780	122	if (uart_handle_sysrq_char(port, c))
02fd473b DM	123	continue;
	124
	125	if ((port->ignore_status_mask & IGNORE_ALL) \|\|
	126	((port->ignore_status_mask & IGNORE_BREAK) &&
	127	(c == CON_BREAK)))
	128	continue;
	129
	130	tty_insert_flip_char(tty, c, flag);
	131	}
	132
	133	if (saw_console_brk)
	134	sun_do_break();
	135
	136	return tty;
	137	}
	138
	139	static void transmit_chars(struct uart_port *port)
	140	{
db33f9bc DM	141	struct circ_buf *xmit;
	142
	143	if (!port->info)
	144	return;
02fd473b	145
db33f9bc	146	xmit = &port->info->xmit;
02fd473b DM	147	if (uart_circ_empty(xmit) \|\| uart_tx_stopped(port))
	148	return;
	149
	150	while (!uart_circ_empty(xmit)) {
	151	long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);
	152
	153	if (status != HV_EOK)
	154	break;
	155
	156	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
	157	port->icount.tx++;
	158	}
	159
	160	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
	161	uart_write_wakeup(port);
	162	}
	163
7d12e780	164	static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
02fd473b DM	165	{
	166	struct uart_port *port = dev_id;
	167	struct tty_struct *tty;
	168	unsigned long flags;
	169
	170	spin_lock_irqsave(&port->lock, flags);
7d12e780	171	tty = receive_chars(port);
02fd473b DM	172	transmit_chars(port);
	173	spin_unlock_irqrestore(&port->lock, flags);
	174
	175	if (tty)
	176	tty_flip_buffer_push(tty);
	177
	178	return IRQ_HANDLED;
	179	}
	180
	181	/* port->lock is not held. */
	182	static unsigned int sunhv_tx_empty(struct uart_port *port)
	183	{
	184	/* Transmitter is always empty for us. If the circ buffer
	185	* is non-empty or there is an x_char pending, our caller
	186	* will do the right thing and ignore what we return here.
	187	*/
	188	return TIOCSER_TEMT;
	189	}
	190
	191	/* port->lock held by caller. */
	192	static void sunhv_set_mctrl(struct uart_port *port, unsigned int mctrl)
	193	{
	194	return;
	195	}
	196
	197	/* port->lock is held by caller and interrupts are disabled. */
	198	static unsigned int sunhv_get_mctrl(struct uart_port *port)
	199	{
	200	return TIOCM_DSR \| TIOCM_CAR \| TIOCM_CTS;
	201	}
	202
	203	/* port->lock held by caller. */
	204	static void sunhv_stop_tx(struct uart_port *port)
	205	{
	206	return;
	207	}
	208
	209	/* port->lock held by caller. */
	210	static void sunhv_start_tx(struct uart_port *port)
	211	{
	212	struct circ_buf *xmit = &port->info->xmit;
02fd473b DM	213
	214	while (!uart_circ_empty(xmit)) {
	215	long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);
	216
	217	if (status != HV_EOK)
	218	break;
	219
	220	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
	221	port->icount.tx++;
	222	}
02fd473b DM	223	}
	224
	225	/* port->lock is not held. */
	226	static void sunhv_send_xchar(struct uart_port *port, char ch)
	227	{
	228	unsigned long flags;
	229	int limit = 10000;
	230
	231	spin_lock_irqsave(&port->lock, flags);
	232
	233	while (limit-- > 0) {
	234	long status = hypervisor_con_putchar(ch);
	235	if (status == HV_EOK)
	236	break;
	237	}
	238
	239	spin_unlock_irqrestore(&port->lock, flags);
	240	}
	241
	242	/* port->lock held by caller. */
	243	static void sunhv_stop_rx(struct uart_port *port)
	244	{
	245	}
	246
	247	/* port->lock held by caller. */
	248	static void sunhv_enable_ms(struct uart_port *port)
	249	{
	250	}
	251
	252	/* port->lock is not held. */
	253	static void sunhv_break_ctl(struct uart_port *port, int break_state)
	254	{
	255	if (break_state) {
	256	unsigned long flags;
843dfb4d	257	int limit = 1000000;
02fd473b DM	258
	259	spin_lock_irqsave(&port->lock, flags);
	260
	261	while (limit-- > 0) {
	262	long status = hypervisor_con_putchar(CON_BREAK);
	263	if (status == HV_EOK)
	264	break;
843dfb4d	265	udelay(2);
02fd473b DM	266	}
	267
	268	spin_unlock_irqrestore(&port->lock, flags);
	269	}
	270	}
	271
	272	/* port->lock is not held. */
	273	static int sunhv_startup(struct uart_port *port)
	274	{
	275	return 0;
	276	}
	277
	278	/* port->lock is not held. */
	279	static void sunhv_shutdown(struct uart_port *port)
	280	{
	281	}
	282
	283	/* port->lock is not held. */
	284	static void sunhv_set_termios(struct uart_port port, struct termios termios,
	285	struct termios *old)
	286	{
	287	unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
	288	unsigned int quot = uart_get_divisor(port, baud);
	289	unsigned int iflag, cflag;
	290	unsigned long flags;
	291
	292	spin_lock_irqsave(&port->lock, flags);
	293
	294	iflag = termios->c_iflag;
	295	cflag = termios->c_cflag;
	296
	297	port->ignore_status_mask = 0;
	298	if (iflag & IGNBRK)
	299	port->ignore_status_mask \|= IGNORE_BREAK;
	300	if ((cflag & CREAD) == 0)
	301	port->ignore_status_mask \|= IGNORE_ALL;
	302
	303	/* XXX */
	304	uart_update_timeout(port, cflag,
	305	(port->uartclk / (16 * quot)));
	306
	307	spin_unlock_irqrestore(&port->lock, flags);
	308	}
	309
	310	static const char sunhv_type(struct uart_port port)
	311	{
	312	return "SUN4V HCONS";
	313	}
	314
	315	static void sunhv_release_port(struct uart_port *port)
	316	{
	317	}
	318
	319	static int sunhv_request_port(struct uart_port *port)
	320	{
	321	return 0;
	322	}
	323
	324	static void sunhv_config_port(struct uart_port *port, int flags)
	325	{
	326	}
	327
	328	static int sunhv_verify_port(struct uart_port port, struct serial_struct ser)
	329	{
330	return -EINVAL;
331	}
332
333	static struct uart_ops sunhv_pops = {
334	.tx_empty = sunhv_tx_empty,
335	.set_mctrl = sunhv_set_mctrl,
336	.get_mctrl = sunhv_get_mctrl,
337	.stop_tx = sunhv_stop_tx,
338	.start_tx = sunhv_start_tx,
339	.send_xchar = sunhv_send_xchar,
340	.stop_rx = sunhv_stop_rx,
341	.enable_ms = sunhv_enable_ms,
342	.break_ctl = sunhv_break_ctl,
343	.startup = sunhv_startup,
344	.shutdown = sunhv_shutdown,
345	.set_termios = sunhv_set_termios,
346	.type = sunhv_type,
347	.release_port = sunhv_release_port,
348	.request_port = sunhv_request_port,
349	.config_port = sunhv_config_port,
350	.verify_port = sunhv_verify_port,
351	};
352
353	static struct uart_driver sunhv_reg = {
354	.owner = THIS_MODULE,
355	.driver_name = "serial",
02fd473b DM	356	.dev_name = "ttyS",
	357	.major = TTY_MAJOR,
	358	};
	359
	360	static struct uart_port *sunhv_port;
	361
	362	static inline void sunhv_console_putchar(struct uart_port *port, char c)
	363	{
	364	unsigned long flags;
d5a2aa24	365	int limit = 1000000;
02fd473b DM	366
	367	spin_lock_irqsave(&port->lock, flags);
	368
	369	while (limit-- > 0) {
	370	long status = hypervisor_con_putchar(c);
	371	if (status == HV_EOK)
	372	break;
d5a2aa24	373	udelay(2);
02fd473b DM	374	}
	375
	376	spin_unlock_irqrestore(&port->lock, flags);
	377	}
	378
	379	static void sunhv_console_write(struct console con, const char s, unsigned n)
	380	{
	381	struct uart_port *port = sunhv_port;
	382	int i;
	383
	384	for (i = 0; i < n; i++) {
	385	if (*s == '\n')
	386	sunhv_console_putchar(port, '\r');
	387	sunhv_console_putchar(port, *s++);
	388	}
	389	}
	390
02fd473b	391	static struct console sunhv_console = {
d5a2aa24	392	.name = "ttyHV",
02fd473b DM	393	.write = sunhv_console_write,
02fd473b DM	394	.device = uart_console_device,
02fd473b DM	395	.flags = CON_PRINTBUFFER,
	396	.index = -1,
	397	.data = &sunhv_reg,
	398	};
	399
d5a2aa24	400	static inline struct console *SUNHV_CONSOLE(void)
02fd473b DM	401	{
02fd473b DM	402	if (con_is_present())
d5a2aa24	403	return NULL;
02fd473b DM	404
02fd473b DM	405	sunhv_console.index = 0;
d5a2aa24 DM	406
d5a2aa24 DM	407	return &sunhv_console;
02fd473b DM	408	}
02fd473b DM	409
93872ba2	410	static int __devinit hv_probe(struct of_device op, const struct of_device_id match)
02fd473b DM	411	{
02fd473b DM	412	struct uart_port *port;
93872ba2	413	int err;
02fd473b	414
93872ba2	415	if (op->irqs[0] == 0xffffffff)
02fd473b DM	416	return -ENODEV;
02fd473b DM	417
93872ba2	418	port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
02fd473b DM	419	if (unlikely(!port))
	420	return -ENOMEM;
	421
93872ba2	422	sunhv_port = port;
db33f9bc	423
02fd473b DM	424	port->line = 0;
	425	port->ops = &sunhv_pops;
	426	port->type = PORT_SUNHV;
	427	port->uartclk = ( 29491200 / 16 ); /* arbitrary */
	428
db33f9bc DM	429	port->membase = (unsigned char __iomem *) __pa(port);
db33f9bc DM	430
93872ba2 DM	431	port->irq = op->irqs[0];
	432
	433	port->dev = &op->dev;
02fd473b DM	434
	435	sunhv_reg.minor = sunserial_current_minor;
	436	sunhv_reg.nr = 1;
02fd473b	437
93872ba2 DM	438	err = uart_register_driver(&sunhv_reg);
	439	if (err)
	440	goto out_free_port;
02fd473b	441
f5deb807	442	sunhv_reg.tty_driver->name_base = sunhv_reg.minor - 64;
02fd473b DM	443	sunserial_current_minor += 1;
02fd473b DM	444
d5a2aa24 DM	445	sunhv_reg.cons = SUNHV_CONSOLE();
d5a2aa24 DM	446
93872ba2 DM	447	err = uart_add_one_port(&sunhv_reg, port);
	448	if (err)
	449	goto out_unregister_driver;
02fd473b	450
93872ba2 DM	451	err = request_irq(port->irq, sunhv_interrupt, 0, "hvcons", port);
	452	if (err)
	453	goto out_remove_port;
db33f9bc	454
93872ba2	455	dev_set_drvdata(&op->dev, port);
02fd473b DM	456
02fd473b DM	457	return 0;
93872ba2 DM	458
	459	out_remove_port:
	460	uart_remove_one_port(&sunhv_reg, port);
	461
	462	out_unregister_driver:
	463	sunserial_current_minor -= 1;
	464	uart_unregister_driver(&sunhv_reg);
	465
	466	out_free_port:
	467	kfree(port);
	468	sunhv_port = NULL;
	469	return err;
02fd473b DM	470	}
02fd473b DM	471
93872ba2	472	static int __devexit hv_remove(struct of_device *dev)
02fd473b	473	{
93872ba2	474	struct uart_port *port = dev_get_drvdata(&dev->dev);
02fd473b	475
db33f9bc DM	476	free_irq(port->irq, port);
db33f9bc DM	477
02fd473b	478	uart_remove_one_port(&sunhv_reg, port);
02fd473b	479
93872ba2	480	sunserial_current_minor -= 1;
02fd473b DM	481	uart_unregister_driver(&sunhv_reg);
02fd473b DM	482
93872ba2	483	kfree(port);
02fd473b	484	sunhv_port = NULL;
93872ba2 DM	485
	486	dev_set_drvdata(&dev->dev, NULL);
	487
	488	return 0;
	489	}
	490
	491	static struct of_device_id hv_match[] = {
	492	{
	493	.name = "console",
	494	.compatible = "qcn",
	495	},
	496	{},
	497	};
	498	MODULE_DEVICE_TABLE(of, hv_match);
	499
	500	static struct of_platform_driver hv_driver = {
	501	.name = "hv",
	502	.match_table = hv_match,
	503	.probe = hv_probe,
	504	.remove = __devexit_p(hv_remove),
	505	};
	506
	507	static int __init sunhv_init(void)
	508	{
	509	if (tlb_type != hypervisor)
	510	return -ENODEV;
	511
	512	return of_register_driver(&hv_driver, &of_bus_type);
	513	}
	514
	515	static void __exit sunhv_exit(void)
	516	{
	517	of_unregister_driver(&hv_driver);
02fd473b DM	518	}
	519
	520	module_init(sunhv_init);
	521	module_exit(sunhv_exit);
	522
	523	MODULE_AUTHOR("David S. Miller");
93872ba2 DM	524	MODULE_DESCRIPTION("SUN4V Hypervisor console driver");
93872ba2 DM	525	MODULE_VERSION("2.0");
02fd473b	526	MODULE_LICENSE("GPL");