[J-u-boot.git] / drivers / video / vidconsole-uclass.c

/*
 * Copyright (c) 2015 Google, Inc
 * (C) Copyright 2001-2015
 * DENX Software Engineering -- [email protected]
 * Compulab Ltd - http://compulab.co.il/
 * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <video.h>
#include <video_console.h>
#include <video_font.h>		/* Get font data, width and height */

/* By default we scroll by a single line */
#ifndef CONFIG_CONSOLE_SCROLL_LINES
#define CONFIG_CONSOLE_SCROLL_LINES 1
#endif

int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
{
	struct vidconsole_ops *ops = vidconsole_get_ops(dev);

	if (!ops->putc_xy)
		return -ENOSYS;
	return ops->putc_xy(dev, x, y, ch);
}

int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
			 uint count)
{
	struct vidconsole_ops *ops = vidconsole_get_ops(dev);

	if (!ops->move_rows)
		return -ENOSYS;
	return ops->move_rows(dev, rowdst, rowsrc, count);
}

int vidconsole_set_row(struct udevice *dev, uint row, int clr)
{
	struct vidconsole_ops *ops = vidconsole_get_ops(dev);

	if (!ops->set_row)
		return -ENOSYS;
	return ops->set_row(dev, row, clr);
}

/* Move backwards one space */
static void vidconsole_back(struct udevice *dev)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);

	if (--priv->curr_col < 0) {
		priv->curr_col = priv->cols - 1;
		if (--priv->curr_row < 0)
			priv->curr_row = 0;
	}

	vidconsole_putc_xy(dev, priv->curr_col * VIDEO_FONT_WIDTH,
			   priv->curr_row * VIDEO_FONT_HEIGHT, ' ');
}

/* Move to a newline, scrolling the display if necessary */
static void vidconsole_newline(struct udevice *dev)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	struct udevice *vid_dev = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
	const int rows = CONFIG_CONSOLE_SCROLL_LINES;
	int i;

	priv->curr_col = 0;

	/* Check if we need to scroll the terminal */
	if (++priv->curr_row >= priv->rows) {
		vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
		for (i = 0; i < rows; i++)
			vidconsole_set_row(dev, priv->rows - i - 1,
					   vid_priv->colour_bg);
		priv->curr_row -= rows;
	}
	video_sync(dev->parent);
}

int vidconsole_put_char(struct udevice *dev, char ch)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	int ret;

	switch (ch) {
	case '\r':
		priv->curr_col = 0;
		break;
	case '\n':
		vidconsole_newline(dev);
		break;
	case '\t':	/* Tab (8 chars alignment) */
		priv->curr_col +=  8;
		priv->curr_col &= ~7;

		if (priv->curr_col >= priv->cols)
			vidconsole_newline(dev);
		break;
	case '\b':
		vidconsole_back(dev);
		break;
	default:
		/*
		 * Failure of this function normally indicates an unsupported
		 * colour depth. Check this and return an error to help with
		 * diagnosis.
		 */
		ret = vidconsole_putc_xy(dev,
					 priv->curr_col * VIDEO_FONT_WIDTH,
					 priv->curr_row * VIDEO_FONT_HEIGHT,
					 ch);
		if (ret)
			return ret;
		if (++priv->curr_col >= priv->cols)
			vidconsole_newline(dev);
		break;
	}

	return 0;
}

static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
{
	struct udevice *dev = sdev->priv;

	vidconsole_put_char(dev, ch);
}

static void vidconsole_puts(struct stdio_dev *sdev, const char *s)
{
	struct udevice *dev = sdev->priv;

	while (*s)
		vidconsole_put_char(dev, *s++);
}

/* Set up the number of rows and colours (rotated drivers override this) */
static int vidconsole_pre_probe(struct udevice *dev)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	struct udevice *vid = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid);

	priv->rows = vid_priv->ysize / VIDEO_FONT_HEIGHT;
	priv->cols = vid_priv->xsize / VIDEO_FONT_WIDTH;

	return 0;
}

/* Register the device with stdio */
static int vidconsole_post_probe(struct udevice *dev)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	struct stdio_dev *sdev = &priv->sdev;
	int ret;

	if (dev->seq) {
		snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
			 dev->seq);
	} else {
		strcpy(sdev->name, "vidconsole");
	}
	sdev->flags = DEV_FLAGS_OUTPUT;
	sdev->putc = vidconsole_putc;
	sdev->puts = vidconsole_puts;
	sdev->priv = dev;
	ret = stdio_register(sdev);
	if (ret)
		return ret;

	return 0;
}

UCLASS_DRIVER(vidconsole) = {
	.id		= UCLASS_VIDEO_CONSOLE,
	.name		= "vidconsole0",
	.pre_probe	= vidconsole_pre_probe,
	.post_probe	= vidconsole_post_probe,
	.per_device_auto_alloc_size	= sizeof(struct vidconsole_priv),
};

void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);

	priv->curr_col = min_t(short, col, priv->cols - 1);
	priv->curr_row = min_t(short, row, priv->rows - 1);
}

static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
			      char *const argv[])
{
	unsigned int col, row;
	struct udevice *dev;

	if (argc != 3)
		return CMD_RET_USAGE;

	uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev);
	if (!dev)
		return CMD_RET_FAILURE;
	col = simple_strtoul(argv[1], NULL, 10);
	row = simple_strtoul(argv[2], NULL, 10);
	vidconsole_position_cursor(dev, col, row);

	return 0;
}

static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
			 char *const argv[])
{
	struct udevice *dev;
	const char *s;

	if (argc != 2)
		return CMD_RET_USAGE;

	uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev);
	if (!dev)
		return CMD_RET_FAILURE;
	for (s = argv[1]; *s; s++)
		vidconsole_put_char(dev, *s);

	return 0;
}

U_BOOT_CMD(
	setcurs, 3,	1,	do_video_setcursor,
	"set cursor position within screen",
	"    <col> <row> in character"
);

U_BOOT_CMD(
	lcdputs, 2,	1,	do_video_puts,
	"print string on video framebuffer",
	"    <string>"
);
Commit	Line	Data
83510766 SG	1	/*
	2	* Copyright (c) 2015 Google, Inc
	3	* (C) Copyright 2001-2015
	4	* DENX Software Engineering -- [email protected]
	5	* Compulab Ltd - http://compulab.co.il/
	6	* Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
	7	*
	8	* SPDX-License-Identifier: GPL-2.0+
	9	*/
	10
	11	#include <common.h>
	12	#include <dm.h>
	13	#include <video.h>
	14	#include <video_console.h>
	15	#include <video_font.h> /* Get font data, width and height */
	16
	17	/* By default we scroll by a single line */
	18	#ifndef CONFIG_CONSOLE_SCROLL_LINES
	19	#define CONFIG_CONSOLE_SCROLL_LINES 1
	20	#endif
	21
	22	int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
	23	{
	24	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	25
	26	if (!ops->putc_xy)
	27	return -ENOSYS;
	28	return ops->putc_xy(dev, x, y, ch);
	29	}
	30
	31	int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
	32	uint count)
	33	{
	34	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	35
	36	if (!ops->move_rows)
	37	return -ENOSYS;
	38	return ops->move_rows(dev, rowdst, rowsrc, count);
	39	}
	40
	41	int vidconsole_set_row(struct udevice *dev, uint row, int clr)
	42	{
	43	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	44
	45	if (!ops->set_row)
	46	return -ENOSYS;
	47	return ops->set_row(dev, row, clr);
	48	}
	49
	50	/* Move backwards one space */
	51	static void vidconsole_back(struct udevice *dev)
	52	{
	53	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	54
	55	if (--priv->curr_col < 0) {
	56	priv->curr_col = priv->cols - 1;
	57	if (--priv->curr_row < 0)
	58	priv->curr_row = 0;
	59	}
	60
	61	vidconsole_putc_xy(dev, priv->curr_col * VIDEO_FONT_WIDTH,
	62	priv->curr_row * VIDEO_FONT_HEIGHT, ' ');
	63	}
	64
65	/* Move to a newline, scrolling the display if necessary */
66	static void vidconsole_newline(struct udevice *dev)
67	{
68	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
69	struct udevice *vid_dev = dev->parent;
70	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
71	const int rows = CONFIG_CONSOLE_SCROLL_LINES;
72	int i;
73
74	priv->curr_col = 0;
75
76	/* Check if we need to scroll the terminal */
77	if (++priv->curr_row >= priv->rows) {
78	vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
79	for (i = 0; i < rows; i++)
80	vidconsole_set_row(dev, priv->rows - i - 1,
81	vid_priv->colour_bg);
82	priv->curr_row -= rows;
83	}
84	video_sync(dev->parent);
85	}
86
87	int vidconsole_put_char(struct udevice *dev, char ch)
88	{
89	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
90	int ret;
91
92	switch (ch) {
93	case '\r':
94	priv->curr_col = 0;
95	break;
96	case '\n':
97	vidconsole_newline(dev);
98	break;
99	case '\t': /* Tab (8 chars alignment) */
100	priv->curr_col += 8;
101	priv->curr_col &= ~7;
102
103	if (priv->curr_col >= priv->cols)
104	vidconsole_newline(dev);
105	break;
106	case '\b':
107	vidconsole_back(dev);
108	break;
109	default:
110	/*
111	* Failure of this function normally indicates an unsupported
112	* colour depth. Check this and return an error to help with
113	* diagnosis.
114	*/
115	ret = vidconsole_putc_xy(dev,
116	priv->curr_col * VIDEO_FONT_WIDTH,
117	priv->curr_row * VIDEO_FONT_HEIGHT,
118	ch);
119	if (ret)
120	return ret;
121	if (++priv->curr_col >= priv->cols)
122	vidconsole_newline(dev);
123	break;
124	}
125
126	return 0;
127	}
128
129	static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
130	{
131	struct udevice *dev = sdev->priv;
132
133	vidconsole_put_char(dev, ch);
134	}
135
136	static void vidconsole_puts(struct stdio_dev sdev, const char s)
137	{
138	struct udevice *dev = sdev->priv;
139
140	while (*s)
141	vidconsole_put_char(dev, *s++);
142	}
143
144	/* Set up the number of rows and colours (rotated drivers override this) */
145	static int vidconsole_pre_probe(struct udevice *dev)
146	{
147	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
148	struct udevice *vid = dev->parent;
149	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
150
151	priv->rows = vid_priv->ysize / VIDEO_FONT_HEIGHT;
152	priv->cols = vid_priv->xsize / VIDEO_FONT_WIDTH;
153
154	return 0;
155	}
156
157	/* Register the device with stdio */
158	static int vidconsole_post_probe(struct udevice *dev)
159	{
160	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
161	struct stdio_dev *sdev = &priv->sdev;
162	int ret;
163
f1a1247d SG	164	if (dev->seq) {
	165	snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
	166	dev->seq);
	167	} else {
	168	strcpy(sdev->name, "vidconsole");
	169	}
83510766 SG	170	sdev->flags = DEV_FLAGS_OUTPUT;
	171	sdev->putc = vidconsole_putc;
	172	sdev->puts = vidconsole_puts;
	173	sdev->priv = dev;
	174	ret = stdio_register(sdev);
	175	if (ret)
	176	return ret;
	177
	178	return 0;
	179	}
	180
	181	UCLASS_DRIVER(vidconsole) = {
	182	.id = UCLASS_VIDEO_CONSOLE,
	183	.name = "vidconsole0",
	184	.pre_probe = vidconsole_pre_probe,
	185	.post_probe = vidconsole_post_probe,
	186	.per_device_auto_alloc_size = sizeof(struct vidconsole_priv),
	187	};
	188
	189	void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
	190	{
	191	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	192
	193	priv->curr_col = min_t(short, col, priv->cols - 1);
	194	priv->curr_row = min_t(short, row, priv->rows - 1);
	195	}
	196
	197	static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
	198	char *const argv[])
	199	{
	200	unsigned int col, row;
	201	struct udevice *dev;
	202
	203	if (argc != 3)
	204	return CMD_RET_USAGE;
	205
	206	uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev);
	207	if (!dev)
	208	return CMD_RET_FAILURE;
	209	col = simple_strtoul(argv[1], NULL, 10);
	210	row = simple_strtoul(argv[2], NULL, 10);
	211	vidconsole_position_cursor(dev, col, row);
	212
	213	return 0;
	214	}
	215
	216	static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
	217	char *const argv[])
	218	{
	219	struct udevice *dev;
	220	const char *s;
	221
	222	if (argc != 2)
	223	return CMD_RET_USAGE;
	224
	225	uclass_first_device(UCLASS_VIDEO_CONSOLE, &dev);
	226	if (!dev)
	227	return CMD_RET_FAILURE;
	228	for (s = argv[1]; *s; s++)
	229	vidconsole_put_char(dev, *s);
	230
	231	return 0;
	232	}
	233
234	U_BOOT_CMD(
235	setcurs, 3, 1, do_video_setcursor,
236	"set cursor position within screen",
237	" <col> <row> in character"
238	);
239
240	U_BOOT_CMD(
241	lcdputs, 2, 1, do_video_puts,
242	"print string on video framebuffer",
243	" <string>"
244	);