[mirror_ubuntu-jammy-kernel.git] / arch / m68k / emu / nfcon.c

/*
 * ARAnyM console driver
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/uaccess.h>
#include <linux/io.h>

#include <asm/natfeat.h>

static int stderr_id;
static struct tty_port nfcon_tty_port;
static struct tty_driver *nfcon_tty_driver;

static void nfputs(const char *str, unsigned int count)
{
	char buf[68];
	unsigned long phys = virt_to_phys(buf);

	buf[64] = 0;
	while (count > 64) {
		memcpy(buf, str, 64);
		nf_call(stderr_id, phys);
		str += 64;
		count -= 64;
	}
	memcpy(buf, str, count);
	buf[count] = 0;
	nf_call(stderr_id, phys);
}

static void nfcon_write(struct console *con, const char *str,
			unsigned int count)
{
	nfputs(str, count);
}

static struct tty_driver *nfcon_device(struct console *con, int *index)
{
	*index = 0;
	return (con->flags & CON_ENABLED) ? nfcon_tty_driver : NULL;
}

static struct console nf_console = {
	.name	= "nfcon",
	.write	= nfcon_write,
	.device	= nfcon_device,
	.flags	= CON_PRINTBUFFER,
	.index	= -1,
};


static int nfcon_tty_open(struct tty_struct *tty, struct file *filp)
{
	return 0;
}

static void nfcon_tty_close(struct tty_struct *tty, struct file *filp)
{
}

static int nfcon_tty_write(struct tty_struct *tty, const unsigned char *buf,
			   int count)
{
	nfputs(buf, count);
	return count;
}

static int nfcon_tty_put_char(struct tty_struct *tty, unsigned char ch)
{
	char temp[2] = { ch, 0 };

	nf_call(stderr_id, virt_to_phys(temp));
	return 1;
}

static unsigned int nfcon_tty_write_room(struct tty_struct *tty)
{
	return 64;
}

static const struct tty_operations nfcon_tty_ops = {
	.open		= nfcon_tty_open,
	.close		= nfcon_tty_close,
	.write		= nfcon_tty_write,
	.put_char	= nfcon_tty_put_char,
	.write_room	= nfcon_tty_write_room,
};

#ifndef MODULE

static int __init nf_debug_setup(char *arg)
{
	if (strcmp(arg, "nfcon"))
		return 0;

	stderr_id = nf_get_id("NF_STDERR");
	if (stderr_id) {
		nf_console.flags |= CON_ENABLED;
		register_console(&nf_console);
	}

	return 0;
}

early_param("debug", nf_debug_setup);

#endif /* !MODULE */

static int __init nfcon_init(void)
{
	struct tty_driver *driver;
	int res;

	stderr_id = nf_get_id("NF_STDERR");
	if (!stderr_id)
		return -ENODEV;

	driver = alloc_tty_driver(1);
	if (!driver)
		return -ENOMEM;

	tty_port_init(&nfcon_tty_port);

	driver->driver_name = "nfcon";
	driver->name = "nfcon";
	driver->type = TTY_DRIVER_TYPE_SYSTEM;
	driver->subtype = SYSTEM_TYPE_TTY;
	driver->init_termios = tty_std_termios;
	driver->flags = TTY_DRIVER_REAL_RAW;

	tty_set_operations(driver, &nfcon_tty_ops);
	tty_port_link_device(&nfcon_tty_port, driver, 0);
	res = tty_register_driver(driver);
	if (res) {
		pr_err("failed to register nfcon tty driver\n");
		put_tty_driver(driver);
		tty_port_destroy(&nfcon_tty_port);
		return res;
	}

	nfcon_tty_driver = driver;

	if (!(nf_console.flags & CON_ENABLED))
		register_console(&nf_console);

	return 0;
}

static void __exit nfcon_exit(void)
{
	unregister_console(&nf_console);
	tty_unregister_driver(nfcon_tty_driver);
	put_tty_driver(nfcon_tty_driver);
	tty_port_destroy(&nfcon_tty_port);
}

module_init(nfcon_init);
module_exit(nfcon_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
37b0b65f RZ	1	/*
	2	* ARAnyM console driver
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file COPYING in the main directory of this archive
	6	* for more details.
	7	*/
	8
	9	#include <linux/module.h>
	10	#include <linux/init.h>
	11	#include <linux/console.h>
	12	#include <linux/tty.h>
	13	#include <linux/tty_driver.h>
	14	#include <linux/tty_flip.h>
	15	#include <linux/slab.h>
	16	#include <linux/err.h>
	17	#include <linux/uaccess.h>
55490050	18	#include <linux/io.h>
37b0b65f RZ	19
	20	#include <asm/natfeat.h>
	21
	22	static int stderr_id;
5920c2c9	23	static struct tty_port nfcon_tty_port;
37b0b65f RZ	24	static struct tty_driver *nfcon_tty_driver;
	25
	26	static void nfputs(const char *str, unsigned int count)
	27	{
	28	char buf[68];
55490050	29	unsigned long phys = virt_to_phys(buf);
37b0b65f RZ	30
	31	buf[64] = 0;
	32	while (count > 64) {
	33	memcpy(buf, str, 64);
55490050	34	nf_call(stderr_id, phys);
37b0b65f RZ	35	str += 64;
	36	count -= 64;
	37	}
	38	memcpy(buf, str, count);
	39	buf[count] = 0;
55490050	40	nf_call(stderr_id, phys);
37b0b65f RZ	41	}
	42
	43	static void nfcon_write(struct console con, const char str,
	44	unsigned int count)
	45	{
	46	nfputs(str, count);
	47	}
	48
	49	static struct tty_driver nfcon_device(struct console con, int *index)
	50	{
	51	*index = 0;
	52	return (con->flags & CON_ENABLED) ? nfcon_tty_driver : NULL;
	53	}
	54
	55	static struct console nf_console = {
	56	.name = "nfcon",
	57	.write = nfcon_write,
	58	.device = nfcon_device,
	59	.flags = CON_PRINTBUFFER,
	60	.index = -1,
	61	};
	62
	63
	64	static int nfcon_tty_open(struct tty_struct tty, struct file filp)
	65	{
	66	return 0;
	67	}
	68
	69	static void nfcon_tty_close(struct tty_struct tty, struct file filp)
	70	{
	71	}
	72
	73	static int nfcon_tty_write(struct tty_struct tty, const unsigned char buf,
	74	int count)
	75	{
	76	nfputs(buf, count);
	77	return count;
	78	}
	79
	80	static int nfcon_tty_put_char(struct tty_struct *tty, unsigned char ch)
	81	{
	82	char temp[2] = { ch, 0 };
	83
55490050	84	nf_call(stderr_id, virt_to_phys(temp));
37b0b65f RZ	85	return 1;
	86	}
	87
03b3b1a2	88	static unsigned int nfcon_tty_write_room(struct tty_struct *tty)
37b0b65f RZ	89	{
	90	return 64;
	91	}
	92
	93	static const struct tty_operations nfcon_tty_ops = {
	94	.open = nfcon_tty_open,
	95	.close = nfcon_tty_close,
	96	.write = nfcon_tty_write,
	97	.put_char = nfcon_tty_put_char,
	98	.write_room = nfcon_tty_write_room,
	99	};
	100
	101	#ifndef MODULE
	102
	103	static int __init nf_debug_setup(char *arg)
	104	{
	105	if (strcmp(arg, "nfcon"))
	106	return 0;
	107
	108	stderr_id = nf_get_id("NF_STDERR");
	109	if (stderr_id) {
	110	nf_console.flags \|= CON_ENABLED;
	111	register_console(&nf_console);
	112	}
	113
	114	return 0;
	115	}
	116
	117	early_param("debug", nf_debug_setup);
	118
	119	#endif /* !MODULE */
	120
	121	static int __init nfcon_init(void)
	122	{
0524513a	123	struct tty_driver *driver;
37b0b65f RZ	124	int res;
	125
	126	stderr_id = nf_get_id("NF_STDERR");
	127	if (!stderr_id)
	128	return -ENODEV;
	129
0524513a JS	130	driver = alloc_tty_driver(1);
0524513a JS	131	if (!driver)
37b0b65f RZ	132	return -ENOMEM;
37b0b65f RZ	133
191c5f10 JS	134	tty_port_init(&nfcon_tty_port);
191c5f10 JS	135
0524513a JS	136	driver->driver_name = "nfcon";
	137	driver->name = "nfcon";
	138	driver->type = TTY_DRIVER_TYPE_SYSTEM;
	139	driver->subtype = SYSTEM_TYPE_TTY;
	140	driver->init_termios = tty_std_termios;
	141	driver->flags = TTY_DRIVER_REAL_RAW;
37b0b65f	142
0524513a JS	143	tty_set_operations(driver, &nfcon_tty_ops);
	144	tty_port_link_device(&nfcon_tty_port, driver, 0);
	145	res = tty_register_driver(driver);
37b0b65f RZ	146	if (res) {
37b0b65f RZ	147	pr_err("failed to register nfcon tty driver\n");
0524513a	148	put_tty_driver(driver);
191c5f10	149	tty_port_destroy(&nfcon_tty_port);
37b0b65f RZ	150	return res;
	151	}
	152
0524513a JS	153	nfcon_tty_driver = driver;
0524513a JS	154
37b0b65f RZ	155	if (!(nf_console.flags & CON_ENABLED))
	156	register_console(&nf_console);
	157
	158	return 0;
	159	}
	160
	161	static void __exit nfcon_exit(void)
	162	{
	163	unregister_console(&nf_console);
	164	tty_unregister_driver(nfcon_tty_driver);
	165	put_tty_driver(nfcon_tty_driver);
191c5f10	166	tty_port_destroy(&nfcon_tty_port);
37b0b65f RZ	167	}
	168
	169	module_init(nfcon_init);
	170	module_exit(nfcon_exit);
	171
	172	MODULE_LICENSE("GPL");