[deliverable/linux.git] / drivers / tty / hvc / hvc_vio.c

/*
 * vio driver interface to hvc_console.c
 *
 * This code was moved here to allow the remaining code to be reused as a
 * generic polling mode with semi-reliable transport driver core to the
 * console and tty subsystems.
 *
 *
 * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
 * Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
 * Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
 * Copyright (C) 2004 IBM Corporation
 *
 * Additional Author(s):
 *  Ryan S. Arnold <rsa@us.ibm.com>
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 * TODO:
 *
 *   - handle error in sending hvsi protocol packets
 *   - retry nego on subsequent sends ?
 */

#undef DEBUG

#include <linux/types.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/console.h>
#include <linux/module.h>

#include <asm/hvconsole.h>
#include <asm/vio.h>
#include <asm/prom.h>
#include <asm/hvsi.h>
#include <asm/udbg.h>

#include "hvc_console.h"

static const char hvc_driver_name[] = "hvc_console";

static struct vio_device_id hvc_driver_table[] __devinitdata = {
	{"serial", "hvterm1"},
#ifndef HVC_OLD_HVSI
	{"serial", "hvterm-protocol"},
#endif
	{ "", "" }
};
MODULE_DEVICE_TABLE(vio, hvc_driver_table);

typedef enum hv_protocol {
	HV_PROTOCOL_RAW,
	HV_PROTOCOL_HVSI
} hv_protocol_t;

struct hvterm_priv {
	u32			termno;	/* HV term number */
	hv_protocol_t		proto;	/* Raw data or HVSI packets */
	struct hvsi_priv	hvsi;	/* HVSI specific data */
	spinlock_t		buf_lock;
	char			buf[SIZE_VIO_GET_CHARS];
	int			left;
	int			offset;
};
static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
/* For early boot console */
static struct hvterm_priv hvterm_priv0;

static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
{
	struct hvterm_priv *pv = hvterm_privs[vtermno];
	unsigned long i;
	unsigned long flags;
	int got;

	if (WARN_ON(!pv))
		return 0;

	spin_lock_irqsave(&pv->buf_lock, flags);

	if (pv->left == 0) {
		pv->offset = 0;
		pv->left = hvc_get_chars(pv->termno, pv->buf, count);

		/*
		 * Work around a HV bug where it gives us a null
		 * after every \r.  -- paulus
		 */
		for (i = 1; i < pv->left; ++i) {
			if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
				--pv->left;
				if (i < pv->left) {
					memmove(&pv->buf[i], &pv->buf[i+1],
						pv->left - i);
				}
			}
		}
	}

	got = min(count, pv->left);
	memcpy(buf, &pv->buf[pv->offset], got);
	pv->offset += got;
	pv->left -= got;

	spin_unlock_irqrestore(&pv->buf_lock, flags);

	return got;
}

static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
{
	struct hvterm_priv *pv = hvterm_privs[vtermno];

	if (WARN_ON(!pv))
		return 0;

	return hvc_put_chars(pv->termno, buf, count);
}

static const struct hv_ops hvterm_raw_ops = {
	.get_chars = hvterm_raw_get_chars,
	.put_chars = hvterm_raw_put_chars,
	.notifier_add = notifier_add_irq,
	.notifier_del = notifier_del_irq,
	.notifier_hangup = notifier_hangup_irq,
};

static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
{
	struct hvterm_priv *pv = hvterm_privs[vtermno];

	if (WARN_ON(!pv))
		return 0;

	return hvsilib_get_chars(&pv->hvsi, buf, count);
}

static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
{
	struct hvterm_priv *pv = hvterm_privs[vtermno];

	if (WARN_ON(!pv))
		return 0;

	return hvsilib_put_chars(&pv->hvsi, buf, count);
}

static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
{
	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	int rc;

	pr_devel("HVSI@%x: open !\n", pv->termno);

	rc = notifier_add_irq(hp, data);
	if (rc)
		return rc;

	return hvsilib_open(&pv->hvsi, hp);
}

static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
{
	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];

	pr_devel("HVSI@%x: do close !\n", pv->termno);

	hvsilib_close(&pv->hvsi, hp);

	notifier_del_irq(hp, data);
}

void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
{
	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];

	pr_devel("HVSI@%x: do hangup !\n", pv->termno);

	hvsilib_close(&pv->hvsi, hp);

	notifier_hangup_irq(hp, data);
}

static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
{
	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];

	if (!pv)
		return -EINVAL;
	return pv->hvsi.mctrl;
}

static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
				unsigned int clear)
{
	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];

	pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
		 pv->termno, set, clear);

	if (set & TIOCM_DTR)
		hvsilib_write_mctrl(&pv->hvsi, 1);
	else if (clear & TIOCM_DTR)
		hvsilib_write_mctrl(&pv->hvsi, 0);

	return 0;
}

static const struct hv_ops hvterm_hvsi_ops = {
	.get_chars = hvterm_hvsi_get_chars,
	.put_chars = hvterm_hvsi_put_chars,
	.notifier_add = hvterm_hvsi_open,
	.notifier_del = hvterm_hvsi_close,
	.notifier_hangup = hvterm_hvsi_hangup,
	.tiocmget = hvterm_hvsi_tiocmget,
	.tiocmset = hvterm_hvsi_tiocmset,
};

static int __devinit hvc_vio_probe(struct vio_dev *vdev,
				   const struct vio_device_id *id)
{
	const struct hv_ops *ops;
	struct hvc_struct *hp;
	struct hvterm_priv *pv;
	hv_protocol_t proto;
	int i, termno = -1;

	/* probed with invalid parameters. */
	if (!vdev || !id)
		return -EPERM;

	if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
		proto = HV_PROTOCOL_RAW;
		ops = &hvterm_raw_ops;
	} else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
		proto = HV_PROTOCOL_HVSI;
		ops = &hvterm_hvsi_ops;
	} else {
		pr_err("hvc_vio: Unkown protocol for %s\n", vdev->dev.of_node->full_name);
		return -ENXIO;
	}

	pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
		 vdev->dev.of_node->full_name,
		 proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");

	/* Is it our boot one ? */
	if (hvterm_privs[0] == &hvterm_priv0 &&
	    vdev->unit_address == hvterm_priv0.termno) {
		pv = hvterm_privs[0];
		termno = 0;
		pr_devel("->boot console, using termno 0\n");
	}
	/* nope, allocate a new one */
	else {
		for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
			if (!hvterm_privs[i])
				termno = i;
		pr_devel("->non-boot console, using termno %d\n", termno);
		if (termno < 0)
			return -ENODEV;
		pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
		if (!pv)
			return -ENOMEM;
		pv->termno = vdev->unit_address;
		pv->proto = proto;
		spin_lock_init(&pv->buf_lock);
		hvterm_privs[termno] = pv;
		hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
			     pv->termno, 0);
	}

	hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
	if (IS_ERR(hp))
		return PTR_ERR(hp);
	dev_set_drvdata(&vdev->dev, hp);

	return 0;
}

static int __devexit hvc_vio_remove(struct vio_dev *vdev)
{
	struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
	int rc, termno;

	termno = hp->vtermno;
	rc = hvc_remove(hp);
	if (rc == 0) {
		if (hvterm_privs[termno] != &hvterm_priv0)
			kfree(hvterm_privs[termno]);
		hvterm_privs[termno] = NULL;
	}
	return rc;
}

static struct vio_driver hvc_vio_driver = {
	.id_table	= hvc_driver_table,
	.probe		= hvc_vio_probe,
	.remove		= hvc_vio_remove,
	.name		= hvc_driver_name,
};

static int __init hvc_vio_init(void)
{
	int rc;

	/* Register as a vio device to receive callbacks */
	rc = vio_register_driver(&hvc_vio_driver);

	return rc;
}
module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */

static void __exit hvc_vio_exit(void)
{
	vio_unregister_driver(&hvc_vio_driver);
}
module_exit(hvc_vio_exit);

static void udbg_hvc_putc(char c)
{
	int count = -1;

	if (c == '\n')
		udbg_hvc_putc('\r');

	do {
		switch(hvterm_priv0.proto) {
		case HV_PROTOCOL_RAW:
			count = hvterm_raw_put_chars(0, &c, 1);
			break;
		case HV_PROTOCOL_HVSI:
			count = hvterm_hvsi_put_chars(0, &c, 1);
			break;
		}
	} while(count == 0);
}

static int udbg_hvc_getc_poll(void)
{
	int rc = 0;
	char c;

	switch(hvterm_priv0.proto) {
	case HV_PROTOCOL_RAW:
		rc = hvterm_raw_get_chars(0, &c, 1);
		break;
	case HV_PROTOCOL_HVSI:
		rc = hvterm_hvsi_get_chars(0, &c, 1);
		break;
	}
	if (!rc)
		return -1;
	return c;
}

static int udbg_hvc_getc(void)
{
	int ch;
	for (;;) {
		ch = udbg_hvc_getc_poll();
		if (ch == -1) {
			/* This shouldn't be needed...but... */
			volatile unsigned long delay;
			for (delay=0; delay < 2000000; delay++)
				;
		} else {
			return ch;
		}
	}
}

void __init hvc_vio_init_early(void)
{
	struct device_node *stdout_node;
	const u32 *termno;
	const char *name;
	const struct hv_ops *ops;

	/* find the boot console from /chosen/stdout */
	if (!of_chosen)
		return;
	name = of_get_property(of_chosen, "linux,stdout-path", NULL);
	if (name == NULL)
		return;
	stdout_node = of_find_node_by_path(name);
	if (!stdout_node)
		return;
	name = of_get_property(stdout_node, "name", NULL);
	if (!name) {
		printk(KERN_WARNING "stdout node missing 'name' property!\n");
		goto out;
	}

	/* Check if it's a virtual terminal */
	if (strncmp(name, "vty", 3) != 0)
		goto out;
	termno = of_get_property(stdout_node, "reg", NULL);
	if (termno == NULL)
		goto out;
	hvterm_priv0.termno = *termno;
	spin_lock_init(&hvterm_priv0.buf_lock);
	hvterm_privs[0] = &hvterm_priv0;

	/* Check the protocol */
	if (of_device_is_compatible(stdout_node, "hvterm1")) {
		hvterm_priv0.proto = HV_PROTOCOL_RAW;
		ops = &hvterm_raw_ops;
	}
	else if (of_device_is_compatible(stdout_node, "hvterm-protocol")) {
		hvterm_priv0.proto = HV_PROTOCOL_HVSI;
		ops = &hvterm_hvsi_ops;
		hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
			     hvterm_priv0.termno, 1);
		/* HVSI, perform the handshake now */
		hvsilib_establish(&hvterm_priv0.hvsi);
	} else
		goto out;
	udbg_putc = udbg_hvc_putc;
	udbg_getc = udbg_hvc_getc;
	udbg_getc_poll = udbg_hvc_getc_poll;
#ifdef HVC_OLD_HVSI
	/* When using the old HVSI driver don't register the HVC
	 * backend for HVSI, only do udbg
	 */
	if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
		goto out;
#endif
	add_preferred_console("hvc", 0, NULL);
	hvc_instantiate(0, 0, ops);
out:
	of_node_put(stdout_node);
}

/* call this from early_init() for a working debug console on
 * vterm capable LPAR machines
 */
#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
void __init udbg_init_debug_lpar(void)
{
	hvterm_privs[0] = &hvterm_priv0;
	hvterm_priv0.termno = 0;
	hvterm_priv0.proto = HV_PROTOCOL_RAW;
	spin_lock_init(&hvterm_priv0.buf_lock);
	udbg_putc = udbg_hvc_putc;
	udbg_getc = udbg_hvc_getc;
	udbg_getc_poll = udbg_hvc_getc_poll;
}
#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */

#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
void __init udbg_init_debug_lpar_hvsi(void)
{
	hvterm_privs[0] = &hvterm_priv0;
	hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
	spin_lock_init(&hvterm_priv0.buf_lock);
	udbg_putc = udbg_hvc_putc;
	udbg_getc = udbg_hvc_getc;
	udbg_getc_poll = udbg_hvc_getc_poll;
	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
		     hvterm_priv0.termno, 1);
	hvsilib_establish(&hvterm_priv0.hvsi);
}
#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */
Commit	Line	Data
acad9559 MM	1	/*
	2	* vio driver interface to hvc_console.c
	3	*
25985edc	4	* This code was moved here to allow the remaining code to be reused as a
acad9559 MM	5	* generic polling mode with semi-reliable transport driver core to the
	6	* console and tty subsystems.
	7	*
	8	*
	9	* Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
	10	* Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
	11	* Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
	12	* Copyright (C) 2004 IBM Corporation
	13	*
	14	* Additional Author(s):
	15	* Ryan S. Arnold <rsa@us.ibm.com>
	16	*
	17	* This program is free software; you can redistribute it and/or modify
	18	* it under the terms of the GNU General Public License as published by
	19	* the Free Software Foundation; either version 2 of the License, or
	20	* (at your option) any later version.
	21	*
	22	* This program is distributed in the hope that it will be useful,
	23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	25	* GNU General Public License for more details.
	26	*
	27	* You should have received a copy of the GNU General Public License
	28	* along with this program; if not, write to the Free Software
	29	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4d2bb3f5 BH	30	*
	31	* TODO:
	32	*
	33	* - handle error in sending hvsi protocol packets
	34	* - retry nego on subsequent sends ?
acad9559 MM	35	*/
acad9559 MM	36
4d2bb3f5 BH	37	#undef DEBUG
4d2bb3f5 BH	38
acad9559 MM	39	#include <linux/types.h>
acad9559 MM	40	#include <linux/init.h>
4d2bb3f5 BH	41	#include <linux/delay.h>
	42	#include <linux/slab.h>
	43	#include <linux/console.h>
578b9ce0	44	#include <linux/module.h>
45d607ed	45
acad9559 MM	46	#include <asm/hvconsole.h>
	47	#include <asm/vio.h>
	48	#include <asm/prom.h>
4d2bb3f5 BH	49	#include <asm/hvsi.h>
4d2bb3f5 BH	50	#include <asm/udbg.h>
acad9559	51
45d607ed RA	52	#include "hvc_console.h"
45d607ed RA	53
5a71c61b	54	static const char hvc_driver_name[] = "hvc_console";
acad9559 MM	55
	56	static struct vio_device_id hvc_driver_table[] __devinitdata = {
	57	{"serial", "hvterm1"},
4d2bb3f5 BH	58	#ifndef HVC_OLD_HVSI
	59	{"serial", "hvterm-protocol"},
	60	#endif
fb120da6	61	{ "", "" }
acad9559 MM	62	};
	63	MODULE_DEVICE_TABLE(vio, hvc_driver_table);
	64
4d2bb3f5 BH	65	typedef enum hv_protocol {
	66	HV_PROTOCOL_RAW,
	67	HV_PROTOCOL_HVSI
	68	} hv_protocol_t;
	69
4d2bb3f5	70	struct hvterm_priv {
17bdc6c0 BH	71	u32 termno; /* HV term number */
	72	hv_protocol_t proto; /* Raw data or HVSI packets */
	73	struct hvsi_priv hvsi; /* HVSI specific data */
19df9abd AB	74	spinlock_t buf_lock;
	75	char buf[SIZE_VIO_GET_CHARS];
	76	int left;
	77	int offset;
4d2bb3f5 BH	78	};
4d2bb3f5 BH	79	static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
4d2bb3f5 BH	80	/* For early boot console */
	81	static struct hvterm_priv hvterm_priv0;
	82
	83	static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
70b234a4	84	{
4d2bb3f5	85	struct hvterm_priv *pv = hvterm_privs[vtermno];
19df9abd AB	86	unsigned long i;
	87	unsigned long flags;
	88	int got;
4d2bb3f5 BH	89
	90	if (WARN_ON(!pv))
	91	return 0;
70b234a4	92
19df9abd AB	93	spin_lock_irqsave(&pv->buf_lock, flags);
	94
	95	if (pv->left == 0) {
	96	pv->offset = 0;
	97	pv->left = hvc_get_chars(pv->termno, pv->buf, count);
	98
	99	/*
	100	* Work around a HV bug where it gives us a null
	101	* after every \r. -- paulus
	102	*/
	103	for (i = 1; i < pv->left; ++i) {
	104	if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
	105	--pv->left;
	106	if (i < pv->left) {
	107	memmove(&pv->buf[i], &pv->buf[i+1],
	108	pv->left - i);
	109	}
	110	}
70b234a4 MM	111	}
70b234a4 MM	112	}
19df9abd AB	113
	114	got = min(count, pv->left);
	115	memcpy(buf, &pv->buf[pv->offset], got);
	116	pv->offset += got;
	117	pv->left -= got;
	118
	119	spin_unlock_irqrestore(&pv->buf_lock, flags);
	120
70b234a4 MM	121	return got;
	122	}
	123
4d2bb3f5 BH	124	static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
	125	{
	126	struct hvterm_priv *pv = hvterm_privs[vtermno];
	127
	128	if (WARN_ON(!pv))
	129	return 0;
	130
	131	return hvc_put_chars(pv->termno, buf, count);
	132	}
	133
	134	static const struct hv_ops hvterm_raw_ops = {
	135	.get_chars = hvterm_raw_get_chars,
	136	.put_chars = hvterm_raw_put_chars,
611e097d CB	137	.notifier_add = notifier_add_irq,
611e097d CB	138	.notifier_del = notifier_del_irq,
fc362e2e	139	.notifier_hangup = notifier_hangup_irq,
030ffad2 MM	140	};
030ffad2 MM	141
4d2bb3f5 BH	142	static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
	143	{
	144	struct hvterm_priv *pv = hvterm_privs[vtermno];
4d2bb3f5 BH	145
	146	if (WARN_ON(!pv))
	147	return 0;
	148
87fa35dd	149	return hvsilib_get_chars(&pv->hvsi, buf, count);
4d2bb3f5 BH	150	}
	151
	152	static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
	153	{
	154	struct hvterm_priv *pv = hvterm_privs[vtermno];
4d2bb3f5 BH	155
	156	if (WARN_ON(!pv))
	157	return 0;
	158
87fa35dd	159	return hvsilib_put_chars(&pv->hvsi, buf, count);
4d2bb3f5 BH	160	}
	161
	162	static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
	163	{
	164	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	165	int rc;
	166
	167	pr_devel("HVSI@%x: open !\n", pv->termno);
	168
	169	rc = notifier_add_irq(hp, data);
	170	if (rc)
	171	return rc;
	172
87fa35dd	173	return hvsilib_open(&pv->hvsi, hp);
4d2bb3f5 BH	174	}
	175
	176	static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
	177	{
	178	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	179
17bdc6c0	180	pr_devel("HVSI@%x: do close !\n", pv->termno);
4d2bb3f5	181
87fa35dd	182	hvsilib_close(&pv->hvsi, hp);
4d2bb3f5 BH	183
	184	notifier_del_irq(hp, data);
	185	}
	186
	187	void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
	188	{
	189	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	190
17bdc6c0	191	pr_devel("HVSI@%x: do hangup !\n", pv->termno);
4d2bb3f5	192
87fa35dd	193	hvsilib_close(&pv->hvsi, hp);
4d2bb3f5 BH	194
	195	notifier_hangup_irq(hp, data);
	196	}
	197
	198	static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
	199	{
	200	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	201
	202	if (!pv)
	203	return -EINVAL;
17bdc6c0	204	return pv->hvsi.mctrl;
4d2bb3f5 BH	205	}
	206
	207	static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
	208	unsigned int clear)
	209	{
	210	struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
	211
	212	pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
	213	pv->termno, set, clear);
	214
	215	if (set & TIOCM_DTR)
87fa35dd	216	hvsilib_write_mctrl(&pv->hvsi, 1);
4d2bb3f5	217	else if (clear & TIOCM_DTR)
87fa35dd	218	hvsilib_write_mctrl(&pv->hvsi, 0);
4d2bb3f5 BH	219
	220	return 0;
	221	}
	222
	223	static const struct hv_ops hvterm_hvsi_ops = {
	224	.get_chars = hvterm_hvsi_get_chars,
	225	.put_chars = hvterm_hvsi_put_chars,
	226	.notifier_add = hvterm_hvsi_open,
	227	.notifier_del = hvterm_hvsi_close,
	228	.notifier_hangup = hvterm_hvsi_hangup,
	229	.tiocmget = hvterm_hvsi_tiocmget,
	230	.tiocmset = hvterm_hvsi_tiocmset,
	231	};
	232
acad9559	233	static int __devinit hvc_vio_probe(struct vio_dev *vdev,
4d2bb3f5	234	const struct vio_device_id *id)
acad9559	235	{
4d2bb3f5	236	const struct hv_ops *ops;
acad9559	237	struct hvc_struct *hp;
4d2bb3f5 BH	238	struct hvterm_priv *pv;
	239	hv_protocol_t proto;
	240	int i, termno = -1;
acad9559 MM	241
	242	/* probed with invalid parameters. */
	243	if (!vdev \|\| !id)
	244	return -EPERM;
	245
4d2bb3f5 BH	246	if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
	247	proto = HV_PROTOCOL_RAW;
	248	ops = &hvterm_raw_ops;
	249	} else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
	250	proto = HV_PROTOCOL_HVSI;
	251	ops = &hvterm_hvsi_ops;
	252	} else {
	253	pr_err("hvc_vio: Unkown protocol for %s\n", vdev->dev.of_node->full_name);
	254	return -ENXIO;
	255	}
	256
	257	pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
	258	vdev->dev.of_node->full_name,
	259	proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
	260
	261	/* Is it our boot one ? */
	262	if (hvterm_privs[0] == &hvterm_priv0 &&
	263	vdev->unit_address == hvterm_priv0.termno) {
	264	pv = hvterm_privs[0];
	265	termno = 0;
	266	pr_devel("->boot console, using termno 0\n");
	267	}
	268	/* nope, allocate a new one */
	269	else {
	270	for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
	271	if (!hvterm_privs[i])
	272	termno = i;
	273	pr_devel("->non-boot console, using termno %d\n", termno);
	274	if (termno < 0)
	275	return -ENODEV;
	276	pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
	277	if (!pv)
	278	return -ENOMEM;
	279	pv->termno = vdev->unit_address;
	280	pv->proto = proto;
19df9abd	281	spin_lock_init(&pv->buf_lock);
4d2bb3f5	282	hvterm_privs[termno] = pv;
87fa35dd BH	283	hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
87fa35dd BH	284	pv->termno, 0);
4d2bb3f5 BH	285	}
	286
	287	hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
acad9559 MM	288	if (IS_ERR(hp))
	289	return PTR_ERR(hp);
	290	dev_set_drvdata(&vdev->dev, hp);
	291
	292	return 0;
	293	}
	294
	295	static int __devexit hvc_vio_remove(struct vio_dev *vdev)
	296	{
	297	struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
4d2bb3f5	298	int rc, termno;
acad9559	299
4d2bb3f5 BH	300	termno = hp->vtermno;
	301	rc = hvc_remove(hp);
	302	if (rc == 0) {
	303	if (hvterm_privs[termno] != &hvterm_priv0)
	304	kfree(hvterm_privs[termno]);
	305	hvterm_privs[termno] = NULL;
	306	}
	307	return rc;
acad9559 MM	308	}
	309
	310	static struct vio_driver hvc_vio_driver = {
acad9559 MM	311	.id_table = hvc_driver_table,
acad9559 MM	312	.probe = hvc_vio_probe,
cb52d897 BH	313	.remove = hvc_vio_remove,
cb52d897 BH	314	.name = hvc_driver_name,
acad9559 MM	315	};
acad9559 MM	316
948c28fe	317	static int __init hvc_vio_init(void)
acad9559 MM	318	{
	319	int rc;
	320
	321	/* Register as a vio device to receive callbacks */
	322	rc = vio_register_driver(&hvc_vio_driver);
	323
	324	return rc;
	325	}
	326	module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */
	327
948c28fe	328	static void __exit hvc_vio_exit(void)
acad9559 MM	329	{
	330	vio_unregister_driver(&hvc_vio_driver);
	331	}
	332	module_exit(hvc_vio_exit);
	333
4d2bb3f5	334	static void udbg_hvc_putc(char c)
acad9559	335	{
4d2bb3f5	336	int count = -1;
acad9559	337
4d2bb3f5 BH	338	if (c == '\n')
4d2bb3f5 BH	339	udbg_hvc_putc('\r');
acad9559	340
4d2bb3f5 BH	341	do {
	342	switch(hvterm_priv0.proto) {
	343	case HV_PROTOCOL_RAW:
	344	count = hvterm_raw_put_chars(0, &c, 1);
	345	break;
	346	case HV_PROTOCOL_HVSI:
	347	count = hvterm_hvsi_put_chars(0, &c, 1);
acad9559	348	break;
dc42149f	349	}
4d2bb3f5 BH	350	} while(count == 0);
	351	}
	352
	353	static int udbg_hvc_getc_poll(void)
	354	{
	355	int rc = 0;
	356	char c;
acad9559	357
4d2bb3f5 BH	358	switch(hvterm_priv0.proto) {
	359	case HV_PROTOCOL_RAW:
	360	rc = hvterm_raw_get_chars(0, &c, 1);
	361	break;
	362	case HV_PROTOCOL_HVSI:
	363	rc = hvterm_hvsi_get_chars(0, &c, 1);
	364	break;
	365	}
	366	if (!rc)
	367	return -1;
	368	return c;
	369	}
acad9559	370
4d2bb3f5 BH	371	static int udbg_hvc_getc(void)
	372	{
	373	int ch;
	374	for (;;) {
	375	ch = udbg_hvc_getc_poll();
	376	if (ch == -1) {
	377	/* This shouldn't be needed...but... */
	378	volatile unsigned long delay;
	379	for (delay=0; delay < 2000000; delay++)
	380	;
	381	} else {
	382	return ch;
acad9559 MM	383	}
acad9559 MM	384	}
4d2bb3f5 BH	385	}
	386
	387	void __init hvc_vio_init_early(void)
	388	{
	389	struct device_node *stdout_node;
	390	const u32 *termno;
	391	const char *name;
	392	const struct hv_ops *ops;
	393
	394	/* find the boot console from /chosen/stdout */
	395	if (!of_chosen)
	396	return;
	397	name = of_get_property(of_chosen, "linux,stdout-path", NULL);
	398	if (name == NULL)
	399	return;
	400	stdout_node = of_find_node_by_path(name);
	401	if (!stdout_node)
	402	return;
	403	name = of_get_property(stdout_node, "name", NULL);
	404	if (!name) {
	405	printk(KERN_WARNING "stdout node missing 'name' property!\n");
	406	goto out;
	407	}
	408
	409	/* Check if it's a virtual terminal */
	410	if (strncmp(name, "vty", 3) != 0)
	411	goto out;
	412	termno = of_get_property(stdout_node, "reg", NULL);
	413	if (termno == NULL)
	414	goto out;
	415	hvterm_priv0.termno = *termno;
19df9abd	416	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	417	hvterm_privs[0] = &hvterm_priv0;
	418
	419	/* Check the protocol */
	420	if (of_device_is_compatible(stdout_node, "hvterm1")) {
	421	hvterm_priv0.proto = HV_PROTOCOL_RAW;
	422	ops = &hvterm_raw_ops;
	423	}
	424	else if (of_device_is_compatible(stdout_node, "hvterm-protocol")) {
	425	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
	426	ops = &hvterm_hvsi_ops;
87fa35dd BH	427	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
87fa35dd BH	428	hvterm_priv0.termno, 1);
4d2bb3f5	429	/* HVSI, perform the handshake now */
87fa35dd	430	hvsilib_establish(&hvterm_priv0.hvsi);
4d2bb3f5 BH	431	} else
	432	goto out;
	433	udbg_putc = udbg_hvc_putc;
	434	udbg_getc = udbg_hvc_getc;
	435	udbg_getc_poll = udbg_hvc_getc_poll;
	436	#ifdef HVC_OLD_HVSI
	437	/* When using the old HVSI driver don't register the HVC
	438	* backend for HVSI, only do udbg
	439	*/
	440	if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
	441	goto out;
	442	#endif
	443	add_preferred_console("hvc", 0, NULL);
	444	hvc_instantiate(0, 0, ops);
	445	out:
	446	of_node_put(stdout_node);
	447	}
	448
	449	/* call this from early_init() for a working debug console on
	450	* vterm capable LPAR machines
	451	*/
	452	#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
	453	void __init udbg_init_debug_lpar(void)
	454	{
	455	hvterm_privs[0] = &hvterm_priv0;
	456	hvterm_priv0.termno = 0;
	457	hvterm_priv0.proto = HV_PROTOCOL_RAW;
f7723f0e	458	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	459	udbg_putc = udbg_hvc_putc;
	460	udbg_getc = udbg_hvc_getc;
	461	udbg_getc_poll = udbg_hvc_getc_poll;
	462	}
	463	#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
acad9559	464
4d2bb3f5 BH	465	#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
	466	void __init udbg_init_debug_lpar_hvsi(void)
	467	{
	468	hvterm_privs[0] = &hvterm_priv0;
	469	hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
	470	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
f7723f0e	471	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	472	udbg_putc = udbg_hvc_putc;
	473	udbg_getc = udbg_hvc_getc;
	474	udbg_getc_poll = udbg_hvc_getc_poll;
87fa35dd BH	475	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
	476	hvterm_priv0.termno, 1);
	477	hvsilib_establish(&hvterm_priv0.hvsi);
acad9559	478	}
4d2bb3f5	479	#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */