[linux-block.git] / drivers / tty / hvc / hvc_vio.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * 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 <asm/hvconsole.h>
#include <asm/vio.h>
#include <asm/prom.h>
#include <asm/hvsi.h>
#include <asm/udbg.h>
#include <asm/machdep.h>

#include "hvc_console.h"

static const char hvc_driver_name[] = "hvc_console";

static const struct vio_device_id hvc_driver_table[] = {
	{"serial", "hvterm1"},
#ifndef HVC_OLD_HVSI
	{"serial", "hvterm-protocol"},
#endif
	{ "", "" }
};

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 void udbg_hvc_putc(char c)
{
	int count = -1;

	if (!hvterm_privs[0])
		return;

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

	do {
		switch(hvterm_privs[0]->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;

	if (!hvterm_privs[0])
		return -1;

	switch(hvterm_privs[0]->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;

	if (!hvterm_privs[0])
		return -1;

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

static int 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: Unknown protocol for %pOF\n", vdev->dev.of_node);
		return -ENXIO;
	}

	pr_devel("hvc_vio_probe() device %pOF, using %s protocol\n",
		 vdev->dev.of_node,
		 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);

	/* register udbg if it's not there already for console 0 */
	if (hp->index == 0 && !udbg_putc) {
		udbg_putc = udbg_hvc_putc;
		udbg_getc = udbg_hvc_getc;
		udbg_getc_poll = udbg_hvc_getc_poll;
	}

	return 0;
}

static struct vio_driver hvc_vio_driver = {
	.id_table	= hvc_driver_table,
	.probe		= hvc_vio_probe,
	.name		= hvc_driver_name,
	.driver = {
		.suppress_bind_attrs	= true,
	},
};

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;
}
device_initcall(hvc_vio_init); /* after drivers/tty/hvc/hvc_console.c */

void __init hvc_vio_init_early(void)
{
	const __be32 *termno;
	const char *name;
	const struct hv_ops *ops;

	/* find the boot console from /chosen/stdout */
	if (!of_stdout)
		return;
	name = of_get_property(of_stdout, "name", NULL);
	if (!name) {
		printk(KERN_WARNING "stdout node missing 'name' property!\n");
		return;
	}

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

	/* Check the protocol */
	if (of_device_is_compatible(of_stdout, "hvterm1")) {
		hvterm_priv0.proto = HV_PROTOCOL_RAW;
		ops = &hvterm_raw_ops;
	}
	else if (of_device_is_compatible(of_stdout, "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
		return;
	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)
		return;
#endif
	/* Check whether the user has requested a different console. */
	if (!strstr(boot_command_line, "console="))
		add_preferred_console("hvc", 0, NULL);
	hvc_instantiate(0, 0, ops);
}

/* 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)
{
	/*
	 * If we're running as a hypervisor then we definitely can't call the
	 * hypervisor to print debug output (we *are* the hypervisor), so don't
	 * register if we detect that MSR_HV=1.
	 */
	if (mfmsr() & MSR_HV)
		return;

	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)
{
	/* See comment above in udbg_init_debug_lpar() */
	if (mfmsr() & MSR_HV)
		return;

	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
e3b3d0f5	1	// SPDX-License-Identifier: GPL-2.0+
acad9559 MM	2	/*
	3	* vio driver interface to hvc_console.c
	4	*
25985edc	5	* This code was moved here to allow the remaining code to be reused as a
acad9559 MM	6	* generic polling mode with semi-reliable transport driver core to the
	7	* console and tty subsystems.
	8	*
	9	*
	10	* Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
	11	* Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
	12	* Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
	13	* Copyright (C) 2004 IBM Corporation
	14	*
	15	* Additional Author(s):
	16	* Ryan S. Arnold <rsa@us.ibm.com>
	17	*
	18	* This program is free software; you can redistribute it and/or modify
	19	* it under the terms of the GNU General Public License as published by
	20	* the Free Software Foundation; either version 2 of the License, or
	21	* (at your option) any later version.
	22	*
	23	* This program is distributed in the hope that it will be useful,
	24	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	25	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	26	* GNU General Public License for more details.
	27	*
	28	* You should have received a copy of the GNU General Public License
	29	* along with this program; if not, write to the Free Software
	30	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4d2bb3f5 BH	31	*
	32	* TODO:
	33	*
	34	* - handle error in sending hvsi protocol packets
	35	* - retry nego on subsequent sends ?
acad9559 MM	36	*/
acad9559 MM	37
4d2bb3f5 BH	38	#undef DEBUG
4d2bb3f5 BH	39
acad9559 MM	40	#include <linux/types.h>
acad9559 MM	41	#include <linux/init.h>
4d2bb3f5 BH	42	#include <linux/delay.h>
	43	#include <linux/slab.h>
	44	#include <linux/console.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>
1926d0ae	51	#include <asm/machdep.h>
acad9559	52
45d607ed RA	53	#include "hvc_console.h"
45d607ed RA	54
5a71c61b	55	static const char hvc_driver_name[] = "hvc_console";
acad9559	56
7298bd1d	57	static const struct vio_device_id hvc_driver_table[] = {
acad9559	58	{"serial", "hvterm1"},
4d2bb3f5 BH	59	#ifndef HVC_OLD_HVSI
	60	{"serial", "hvterm-protocol"},
	61	#endif
fb120da6	62	{ "", "" }
acad9559	63	};
acad9559	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
d1cfc0ce BH	233	static void udbg_hvc_putc(char c)
	234	{
	235	int count = -1;
	236
	237	if (!hvterm_privs[0])
	238	return;
	239
	240	if (c == '\n')
	241	udbg_hvc_putc('\r');
	242
	243	do {
	244	switch(hvterm_privs[0]->proto) {
	245	case HV_PROTOCOL_RAW:
	246	count = hvterm_raw_put_chars(0, &c, 1);
	247	break;
	248	case HV_PROTOCOL_HVSI:
	249	count = hvterm_hvsi_put_chars(0, &c, 1);
	250	break;
	251	}
	252	} while(count == 0);
	253	}
	254
	255	static int udbg_hvc_getc_poll(void)
	256	{
	257	int rc = 0;
	258	char c;
	259
	260	if (!hvterm_privs[0])
	261	return -1;
	262
	263	switch(hvterm_privs[0]->proto) {
	264	case HV_PROTOCOL_RAW:
	265	rc = hvterm_raw_get_chars(0, &c, 1);
	266	break;
	267	case HV_PROTOCOL_HVSI:
	268	rc = hvterm_hvsi_get_chars(0, &c, 1);
	269	break;
	270	}
	271	if (!rc)
	272	return -1;
	273	return c;
	274	}
	275
	276	static int udbg_hvc_getc(void)
	277	{
	278	int ch;
	279
	280	if (!hvterm_privs[0])
	281	return -1;
	282
	283	for (;;) {
	284	ch = udbg_hvc_getc_poll();
	285	if (ch == -1) {
	286	/* This shouldn't be needed...but... */
	287	volatile unsigned long delay;
	288	for (delay=0; delay < 2000000; delay++)
	289	;
	290	} else {
	291	return ch;
	292	}
	293	}
	294	}
	295
9671f099	296	static int hvc_vio_probe(struct vio_dev *vdev,
4d2bb3f5	297	const struct vio_device_id *id)
acad9559	298	{
4d2bb3f5	299	const struct hv_ops *ops;
acad9559	300	struct hvc_struct *hp;
4d2bb3f5 BH	301	struct hvterm_priv *pv;
	302	hv_protocol_t proto;
	303	int i, termno = -1;
acad9559 MM	304
	305	/* probed with invalid parameters. */
	306	if (!vdev \|\| !id)
	307	return -EPERM;
	308
4d2bb3f5 BH	309	if (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
	310	proto = HV_PROTOCOL_RAW;
	311	ops = &hvterm_raw_ops;
	312	} else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
	313	proto = HV_PROTOCOL_HVSI;
	314	ops = &hvterm_hvsi_ops;
	315	} else {
a73ee843	316	pr_err("hvc_vio: Unknown protocol for %pOF\n", vdev->dev.of_node);
4d2bb3f5 BH	317	return -ENXIO;
	318	}
	319
a73ee843 RH	320	pr_devel("hvc_vio_probe() device %pOF, using %s protocol\n",
a73ee843 RH	321	vdev->dev.of_node,
4d2bb3f5 BH	322	proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
	323
	324	/* Is it our boot one ? */
	325	if (hvterm_privs[0] == &hvterm_priv0 &&
	326	vdev->unit_address == hvterm_priv0.termno) {
	327	pv = hvterm_privs[0];
	328	termno = 0;
	329	pr_devel("->boot console, using termno 0\n");
	330	}
	331	/* nope, allocate a new one */
	332	else {
	333	for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
	334	if (!hvterm_privs[i])
	335	termno = i;
	336	pr_devel("->non-boot console, using termno %d\n", termno);
	337	if (termno < 0)
	338	return -ENODEV;
	339	pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
	340	if (!pv)
	341	return -ENOMEM;
	342	pv->termno = vdev->unit_address;
	343	pv->proto = proto;
19df9abd	344	spin_lock_init(&pv->buf_lock);
4d2bb3f5	345	hvterm_privs[termno] = pv;
87fa35dd BH	346	hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
87fa35dd BH	347	pv->termno, 0);
4d2bb3f5 BH	348	}
	349
	350	hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
acad9559 MM	351	if (IS_ERR(hp))
	352	return PTR_ERR(hp);
	353	dev_set_drvdata(&vdev->dev, hp);
	354
d1cfc0ce BH	355	/* register udbg if it's not there already for console 0 */
	356	if (hp->index == 0 && !udbg_putc) {
	357	udbg_putc = udbg_hvc_putc;
	358	udbg_getc = udbg_hvc_getc;
	359	udbg_getc_poll = udbg_hvc_getc_poll;
	360	}
	361
acad9559 MM	362	return 0;
	363	}
	364
acad9559	365	static struct vio_driver hvc_vio_driver = {
acad9559 MM	366	.id_table = hvc_driver_table,
acad9559 MM	367	.probe = hvc_vio_probe,
cb52d897	368	.name = hvc_driver_name,
e3c5fc4d PG	369	.driver = {
	370	.suppress_bind_attrs = true,
	371	},
acad9559 MM	372	};
acad9559 MM	373
948c28fe	374	static int __init hvc_vio_init(void)
acad9559 MM	375	{
	376	int rc;
	377
	378	/* Register as a vio device to receive callbacks */
	379	rc = vio_register_driver(&hvc_vio_driver);
	380
	381	return rc;
	382	}
e3c5fc4d	383	device_initcall(hvc_vio_init); /* after drivers/tty/hvc/hvc_console.c */
acad9559	384
4d2bb3f5 BH	385	void __init hvc_vio_init_early(void)
4d2bb3f5 BH	386	{
1502b480	387	const __be32 *termno;
4d2bb3f5 BH	388	const char *name;
	389	const struct hv_ops *ops;
	390
	391	/* find the boot console from /chosen/stdout */
a752ee56	392	if (!of_stdout)
4d2bb3f5	393	return;
a752ee56	394	name = of_get_property(of_stdout, "name", NULL);
4d2bb3f5 BH	395	if (!name) {
4d2bb3f5 BH	396	printk(KERN_WARNING "stdout node missing 'name' property!\n");
a752ee56	397	return;
4d2bb3f5 BH	398	}
	399
	400	/* Check if it's a virtual terminal */
	401	if (strncmp(name, "vty", 3) != 0)
a752ee56 GL	402	return;
a752ee56 GL	403	termno = of_get_property(of_stdout, "reg", NULL);
4d2bb3f5	404	if (termno == NULL)
a752ee56	405	return;
1502b480	406	hvterm_priv0.termno = of_read_number(termno, 1);
19df9abd	407	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	408	hvterm_privs[0] = &hvterm_priv0;
	409
	410	/* Check the protocol */
a752ee56	411	if (of_device_is_compatible(of_stdout, "hvterm1")) {
4d2bb3f5 BH	412	hvterm_priv0.proto = HV_PROTOCOL_RAW;
	413	ops = &hvterm_raw_ops;
	414	}
a752ee56	415	else if (of_device_is_compatible(of_stdout, "hvterm-protocol")) {
4d2bb3f5 BH	416	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
4d2bb3f5 BH	417	ops = &hvterm_hvsi_ops;
87fa35dd BH	418	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
87fa35dd BH	419	hvterm_priv0.termno, 1);
4d2bb3f5	420	/* HVSI, perform the handshake now */
87fa35dd	421	hvsilib_establish(&hvterm_priv0.hvsi);
4d2bb3f5	422	} else
a752ee56	423	return;
4d2bb3f5 BH	424	udbg_putc = udbg_hvc_putc;
	425	udbg_getc = udbg_hvc_getc;
	426	udbg_getc_poll = udbg_hvc_getc_poll;
	427	#ifdef HVC_OLD_HVSI
	428	/* When using the old HVSI driver don't register the HVC
	429	* backend for HVSI, only do udbg
	430	*/
	431	if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
a752ee56	432	return;
4d2bb3f5	433	#endif
1926d0ae	434	/* Check whether the user has requested a different console. */
3e47d147	435	if (!strstr(boot_command_line, "console="))
1926d0ae	436	add_preferred_console("hvc", 0, NULL);
4d2bb3f5	437	hvc_instantiate(0, 0, ops);
4d2bb3f5 BH	438	}
	439
	440	/* call this from early_init() for a working debug console on
	441	* vterm capable LPAR machines
	442	*/
	443	#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
	444	void __init udbg_init_debug_lpar(void)
	445	{
9227f043 ME	446	/*
	447	* If we're running as a hypervisor then we definitely can't call the
	448	* hypervisor to print debug output (we are the hypervisor), so don't
	449	* register if we detect that MSR_HV=1.
	450	*/
	451	if (mfmsr() & MSR_HV)
	452	return;
	453
4d2bb3f5 BH	454	hvterm_privs[0] = &hvterm_priv0;
	455	hvterm_priv0.termno = 0;
	456	hvterm_priv0.proto = HV_PROTOCOL_RAW;
f7723f0e	457	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	458	udbg_putc = udbg_hvc_putc;
	459	udbg_getc = udbg_hvc_getc;
	460	udbg_getc_poll = udbg_hvc_getc_poll;
	461	}
	462	#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
acad9559	463
4d2bb3f5 BH	464	#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
	465	void __init udbg_init_debug_lpar_hvsi(void)
	466	{
9227f043 ME	467	/* See comment above in udbg_init_debug_lpar() */
	468	if (mfmsr() & MSR_HV)
	469	return;
	470
4d2bb3f5 BH	471	hvterm_privs[0] = &hvterm_priv0;
	472	hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
	473	hvterm_priv0.proto = HV_PROTOCOL_HVSI;
f7723f0e	474	spin_lock_init(&hvterm_priv0.buf_lock);
4d2bb3f5 BH	475	udbg_putc = udbg_hvc_putc;
	476	udbg_getc = udbg_hvc_getc;
	477	udbg_getc_poll = udbg_hvc_getc_poll;
87fa35dd BH	478	hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
	479	hvterm_priv0.termno, 1);
	480	hvsilib_establish(&hvterm_priv0.hvsi);
acad9559	481	}
4d2bb3f5	482	#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */