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

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

#include <common.h>
#include <linux/ctype.h>
#include <dm.h>
#include <video.h>
#include <video_console.h>
#include <video_font.h>		/* Bitmap font for code page 437 */

/*
 * Structure to describe a console color
 */
struct vid_rgb {
	u32 r;
	u32 g;
	u32 b;
};

/* 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);
}

static int vidconsole_entry_start(struct udevice *dev)
{
	struct vidconsole_ops *ops = vidconsole_get_ops(dev);

	if (!ops->entry_start)
		return -ENOSYS;
	return ops->entry_start(dev);
}

/* Move backwards one space */
static int vidconsole_back(struct udevice *dev)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	int ret;

	if (ops->backspace) {
		ret = ops->backspace(dev);
		if (ret != -ENOSYS)
			return ret;
	}

	priv->xcur_frac -= VID_TO_POS(priv->x_charsize);
	if (priv->xcur_frac < priv->xstart_frac) {
		priv->xcur_frac = (priv->cols - 1) *
			VID_TO_POS(priv->x_charsize);
		priv->ycur -= priv->y_charsize;
		if (priv->ycur < 0)
			priv->ycur = 0;
	}
	video_sync(dev->parent, false);

	return 0;
}

/* 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->xcur_frac = priv->xstart_frac;
	priv->ycur += priv->y_charsize;

	/* Check if we need to scroll the terminal */
	if ((priv->ycur + priv->y_charsize) / priv->y_charsize > 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->ycur -= rows * priv->y_charsize;
	}
	priv->last_ch = 0;

	video_sync(dev->parent, false);
}

static const struct vid_rgb colors[VID_COLOR_COUNT] = {
	{ 0x00, 0x00, 0x00 },  /* black */
	{ 0xc0, 0x00, 0x00 },  /* red */
	{ 0x00, 0xc0, 0x00 },  /* green */
	{ 0xc0, 0x60, 0x00 },  /* brown */
	{ 0x00, 0x00, 0xc0 },  /* blue */
	{ 0xc0, 0x00, 0xc0 },  /* magenta */
	{ 0x00, 0xc0, 0xc0 },  /* cyan */
	{ 0xc0, 0xc0, 0xc0 },  /* light gray */
	{ 0x80, 0x80, 0x80 },  /* gray */
	{ 0xff, 0x00, 0x00 },  /* bright red */
	{ 0x00, 0xff, 0x00 },  /* bright green */
	{ 0xff, 0xff, 0x00 },  /* yellow */
	{ 0x00, 0x00, 0xff },  /* bright blue */
	{ 0xff, 0x00, 0xff },  /* bright magenta */
	{ 0x00, 0xff, 0xff },  /* bright cyan */
	{ 0xff, 0xff, 0xff },  /* white */
};

u32 vid_console_color(struct video_priv *priv, unsigned int idx)
{
	switch (priv->bpix) {
	case VIDEO_BPP16:
		return ((colors[idx].r >> 3) << 11) |
		       ((colors[idx].g >> 2) <<  5) |
		       ((colors[idx].b >> 3) <<  0);
	case VIDEO_BPP32:
		return (colors[idx].r << 16) |
		       (colors[idx].g <<  8) |
		       (colors[idx].b <<  0);
	default:
		/*
		 * For unknown bit arrangements just support
		 * black and white.
		 */
		if (idx)
			return 0xffffff; /* white */
		else
			return 0x000000; /* black */
	}
}

static char *parsenum(char *s, int *num)
{
	char *end;
	*num = simple_strtol(s, &end, 10);
	return end;
}

/**
 * set_cursor_position() - set cursor position
 *
 * @priv:	private data of the video console
 * @row:	new row
 * @col:	new column
 */
static void set_cursor_position(struct vidconsole_priv *priv, int row, int col)
{
	/*
	 * Ensure we stay in the bounds of the screen.
	 */
	if (row >= priv->rows)
		row = priv->rows - 1;
	if (col >= priv->cols)
		col = priv->cols - 1;

	priv->ycur = row * priv->y_charsize;
	priv->xcur_frac = priv->xstart_frac +
			  VID_TO_POS(col * priv->x_charsize);
}

/**
 * get_cursor_position() - get cursor position
 *
 * @priv:	private data of the video console
 * @row:	row
 * @col:	column
 */
static void get_cursor_position(struct vidconsole_priv *priv,
				int *row, int *col)
{
	*row = priv->ycur / priv->y_charsize;
	*col = VID_TO_PIXEL(priv->xcur_frac - priv->xstart_frac) /
	       priv->x_charsize;
}

/*
 * Process a character while accumulating an escape string.  Chars are
 * accumulated into escape_buf until the end of escape sequence is
 * found, at which point the sequence is parsed and processed.
 */
static void vidconsole_escape_char(struct udevice *dev, char ch)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);

	if (!IS_ENABLED(CONFIG_VIDEO_ANSI))
		goto error;

	/* Sanity checking for bogus ESC sequences: */
	if (priv->escape_len >= sizeof(priv->escape_buf))
		goto error;
	if (priv->escape_len == 0) {
		switch (ch) {
		case '7':
			/* Save cursor position */
			get_cursor_position(priv, &priv->row_saved,
					    &priv->col_saved);
			priv->escape = 0;

			return;
		case '8': {
			/* Restore cursor position */
			int row = priv->row_saved;
			int col = priv->col_saved;

			set_cursor_position(priv, row, col);
			priv->escape = 0;
			return;
		}
		case '[':
			break;
		default:
			goto error;
		}
	}

	priv->escape_buf[priv->escape_len++] = ch;

	/*
	 * Escape sequences are terminated by a letter, so keep
	 * accumulating until we get one:
	 */
	if (!isalpha(ch))
		return;

	/*
	 * clear escape mode first, otherwise things will get highly
	 * surprising if you hit any debug prints that come back to
	 * this console.
	 */
	priv->escape = 0;

	switch (ch) {
	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F': {
		int row, col, num;
		char *s = priv->escape_buf;

		/*
		 * Cursor up/down: [%dA, [%dB, [%dE, [%dF
		 * Cursor left/right: [%dD, [%dC
		 */
		s++;    /* [ */
		s = parsenum(s, &num);
		if (num == 0)			/* No digit in sequence ... */
			num = 1;		/* ... means "move by 1". */

		get_cursor_position(priv, &row, &col);
		if (ch == 'A' || ch == 'F')
			row -= num;
		if (ch == 'C')
			col += num;
		if (ch == 'D')
			col -= num;
		if (ch == 'B' || ch == 'E')
			row += num;
		if (ch == 'E' || ch == 'F')
			col = 0;
		if (col < 0)
			col = 0;
		if (row < 0)
			row = 0;
		/* Right and bottom overflows are handled in the callee. */
		set_cursor_position(priv, row, col);
		break;
	}
	case 'H':
	case 'f': {
		int row, col;
		char *s = priv->escape_buf;

		/*
		 * Set cursor position: [%d;%df or [%d;%dH
		 */
		s++;    /* [ */
		s = parsenum(s, &row);
		s++;    /* ; */
		s = parsenum(s, &col);

		/*
		 * Video origin is [0, 0], terminal origin is [1, 1].
		 */
		if (row)
			--row;
		if (col)
			--col;

		set_cursor_position(priv, row, col);

		break;
	}
	case 'J': {
		int mode;

		/*
		 * Clear part/all screen:
		 *   [J or [0J - clear screen from cursor down
		 *   [1J       - clear screen from cursor up
		 *   [2J       - clear entire screen
		 *
		 * TODO we really only handle entire-screen case, others
		 * probably require some additions to video-uclass (and
		 * are not really needed yet by efi_console)
		 */
		parsenum(priv->escape_buf + 1, &mode);

		if (mode == 2) {
			video_clear(dev->parent);
			video_sync(dev->parent, false);
			priv->ycur = 0;
			priv->xcur_frac = priv->xstart_frac;
		} else {
			debug("unsupported clear mode: %d\n", mode);
		}
		break;
	}
	case 'K': {
		struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
		int mode;

		/*
		 * Clear (parts of) current line
		 *   [0K       - clear line to end
		 *   [2K       - clear entire line
		 */
		parsenum(priv->escape_buf + 1, &mode);

		if (mode == 2) {
			int row, col;

			get_cursor_position(priv, &row, &col);
			vidconsole_set_row(dev, row, vid_priv->colour_bg);
		}
		break;
	}
	case 'm': {
		struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
		char *s = priv->escape_buf;
		char *end = &priv->escape_buf[priv->escape_len];

		/*
		 * Set graphics mode: [%d;...;%dm
		 *
		 * Currently only supports the color attributes:
		 *
		 * Foreground Colors:
		 *
		 *   30	Black
		 *   31	Red
		 *   32	Green
		 *   33	Yellow
		 *   34	Blue
		 *   35	Magenta
		 *   36	Cyan
		 *   37	White
		 *
		 * Background Colors:
		 *
		 *   40	Black
		 *   41	Red
		 *   42	Green
		 *   43	Yellow
		 *   44	Blue
		 *   45	Magenta
		 *   46	Cyan
		 *   47	White
		 */

		s++;    /* [ */
		while (s < end) {
			int val;

			s = parsenum(s, &val);
			s++;

			switch (val) {
			case 0:
				/* all attributes off */
				video_set_default_colors(dev->parent, false);
				break;
			case 1:
				/* bold */
				vid_priv->fg_col_idx |= 8;
				vid_priv->colour_fg = vid_console_color(
						vid_priv, vid_priv->fg_col_idx);
				break;
			case 7:
				/* reverse video */
				vid_priv->colour_fg = vid_console_color(
						vid_priv, vid_priv->bg_col_idx);
				vid_priv->colour_bg = vid_console_color(
						vid_priv, vid_priv->fg_col_idx);
				break;
			case 30 ... 37:
				/* foreground color */
				vid_priv->fg_col_idx &= ~7;
				vid_priv->fg_col_idx |= val - 30;
				vid_priv->colour_fg = vid_console_color(
						vid_priv, vid_priv->fg_col_idx);
				break;
			case 40 ... 47:
				/* background color, also mask the bold bit */
				vid_priv->bg_col_idx &= ~0xf;
				vid_priv->bg_col_idx |= val - 40;
				vid_priv->colour_bg = vid_console_color(
						vid_priv, vid_priv->bg_col_idx);
				break;
			default:
				/* ignore unsupported SGR parameter */
				break;
			}
		}

		break;
	}
	default:
		debug("unrecognized escape sequence: %*s\n",
		      priv->escape_len, priv->escape_buf);
	}

	return;

error:
	/* something went wrong, just revert to normal mode: */
	priv->escape = 0;
}

/* Put that actual character on the screen (using the CP437 code page). */
static int vidconsole_output_glyph(struct udevice *dev, char ch)
{
	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	int ret;

	/*
	 * 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->xcur_frac, priv->ycur, ch);
	if (ret == -EAGAIN) {
		vidconsole_newline(dev);
		ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
	}
	if (ret < 0)
		return ret;
	priv->xcur_frac += ret;
	priv->last_ch = ch;
	if (priv->xcur_frac >= priv->xsize_frac)
		vidconsole_newline(dev);

	return 0;
}

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

	if (priv->escape) {
		vidconsole_escape_char(dev, ch);
		return 0;
	}

	switch (ch) {
	case '\x1b':
		priv->escape_len = 0;
		priv->escape = 1;
		break;
	case '\a':
		/* beep */
		break;
	case '\r':
		priv->xcur_frac = priv->xstart_frac;
		break;
	case '\n':
		vidconsole_newline(dev);
		vidconsole_entry_start(dev);
		break;
	case '\t':	/* Tab (8 chars alignment) */
		priv->xcur_frac = ((priv->xcur_frac / priv->tab_width_frac)
				+ 1) * priv->tab_width_frac;

		if (priv->xcur_frac >= priv->xsize_frac)
			vidconsole_newline(dev);
		break;
	case '\b':
		vidconsole_back(dev);
		priv->last_ch = 0;
		break;
	default:
		ret = vidconsole_output_glyph(dev, ch);
		if (ret < 0)
			return ret;
		break;
	}

	return 0;
}

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

	vidconsole_put_char(dev, ch);
	video_sync(dev->parent, false);
}

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

	while (*s)
		vidconsole_put_char(dev, *s++);
	video_sync(dev->parent, false);
}

/* 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->xsize_frac = VID_TO_POS(vid_priv->xsize);

	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;

	if (!priv->tab_width_frac)
		priv->tab_width_frac = VID_TO_POS(priv->x_charsize) * 8;

	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;

	return stdio_register(sdev);
}

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);
	struct udevice *vid_dev = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);

	col *= priv->x_charsize;
	row *= priv->y_charsize;
	priv->xcur_frac = VID_TO_POS(min_t(short, col, vid_priv->xsize - 1));
	priv->ycur = min_t(short, row, vid_priv->ysize - 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;

	if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &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;

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

	video_sync(dev->parent, false);

	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
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
83510766 SG	2	/*
	3	* Copyright (c) 2015 Google, Inc
	4	* (C) Copyright 2001-2015
	5	* DENX Software Engineering -- wd@denx.de
	6	* Compulab Ltd - http://compulab.co.il/
	7	* Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
83510766 SG	8	*/
	9
	10	#include <common.h>
a085aa1f	11	#include <linux/ctype.h>
83510766 SG	12	#include <dm.h>
	13	#include <video.h>
	14	#include <video_console.h>
5fba5329	15	#include <video_font.h> /* Bitmap font for code page 437 */
83510766	16
5c30fbb8 HS	17	/*
	18	* Structure to describe a console color
	19	*/
	20	struct vid_rgb {
	21	u32 r;
	22	u32 g;
	23	u32 b;
	24	};
	25
83510766 SG	26	/* By default we scroll by a single line */
	27	#ifndef CONFIG_CONSOLE_SCROLL_LINES
	28	#define CONFIG_CONSOLE_SCROLL_LINES 1
	29	#endif
	30
	31	int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch)
	32	{
	33	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	34
	35	if (!ops->putc_xy)
	36	return -ENOSYS;
	37	return ops->putc_xy(dev, x, y, ch);
	38	}
	39
	40	int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
	41	uint count)
	42	{
	43	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	44
	45	if (!ops->move_rows)
	46	return -ENOSYS;
	47	return ops->move_rows(dev, rowdst, rowsrc, count);
	48	}
	49
	50	int vidconsole_set_row(struct udevice *dev, uint row, int clr)
	51	{
	52	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	53
	54	if (!ops->set_row)
	55	return -ENOSYS;
	56	return ops->set_row(dev, row, clr);
	57	}
	58
58c733a7 SG	59	static int vidconsole_entry_start(struct udevice *dev)
	60	{
	61	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	62
	63	if (!ops->entry_start)
	64	return -ENOSYS;
	65	return ops->entry_start(dev);
	66	}
	67
83510766	68	/* Move backwards one space */
7b9f7e44	69	static int vidconsole_back(struct udevice *dev)
83510766 SG	70	{
83510766 SG	71	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
7b9f7e44 SG	72	struct vidconsole_ops *ops = vidconsole_get_ops(dev);
	73	int ret;
	74
	75	if (ops->backspace) {
	76	ret = ops->backspace(dev);
	77	if (ret != -ENOSYS)
	78	return ret;
	79	}
83510766	80
f2661786	81	priv->xcur_frac -= VID_TO_POS(priv->x_charsize);
c5b77d01	82	if (priv->xcur_frac < priv->xstart_frac) {
f2661786 SG	83	priv->xcur_frac = (priv->cols - 1) *
	84	VID_TO_POS(priv->x_charsize);
	85	priv->ycur -= priv->y_charsize;
	86	if (priv->ycur < 0)
	87	priv->ycur = 0;
83510766	88	}
55d39911	89	video_sync(dev->parent, false);
7b9f7e44 SG	90
7b9f7e44 SG	91	return 0;
83510766 SG	92	}
	93
	94	/* Move to a newline, scrolling the display if necessary */
	95	static void vidconsole_newline(struct udevice *dev)
	96	{
	97	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	98	struct udevice *vid_dev = dev->parent;
	99	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
	100	const int rows = CONFIG_CONSOLE_SCROLL_LINES;
	101	int i;
	102
c5b77d01	103	priv->xcur_frac = priv->xstart_frac;
f2661786	104	priv->ycur += priv->y_charsize;
83510766 SG	105
83510766 SG	106	/* Check if we need to scroll the terminal */
f2661786	107	if ((priv->ycur + priv->y_charsize) / priv->y_charsize > priv->rows) {
83510766 SG	108	vidconsole_move_rows(dev, 0, rows, priv->rows - rows);
	109	for (i = 0; i < rows; i++)
	110	vidconsole_set_row(dev, priv->rows - i - 1,
	111	vid_priv->colour_bg);
f2661786	112	priv->ycur -= rows * priv->y_charsize;
83510766	113	}
58c733a7 SG	114	priv->last_ch = 0;
58c733a7 SG	115
55d39911	116	video_sync(dev->parent, false);
83510766 SG	117	}
83510766 SG	118
5c30fbb8	119	static const struct vid_rgb colors[VID_COLOR_COUNT] = {
703d885c	120	{ 0x00, 0x00, 0x00 }, /* black */
9ffa4d12 HS	121	{ 0xc0, 0x00, 0x00 }, /* red */
	122	{ 0x00, 0xc0, 0x00 }, /* green */
	123	{ 0xc0, 0x60, 0x00 }, /* brown */
	124	{ 0x00, 0x00, 0xc0 }, /* blue */
	125	{ 0xc0, 0x00, 0xc0 }, /* magenta */
	126	{ 0x00, 0xc0, 0xc0 }, /* cyan */
	127	{ 0xc0, 0xc0, 0xc0 }, /* light gray */
	128	{ 0x80, 0x80, 0x80 }, /* gray */
	129	{ 0xff, 0x00, 0x00 }, /* bright red */
	130	{ 0x00, 0xff, 0x00 }, /* bright green */
703d885c	131	{ 0xff, 0xff, 0x00 }, /* yellow */
9ffa4d12 HS	132	{ 0x00, 0x00, 0xff }, /* bright blue */
	133	{ 0xff, 0x00, 0xff }, /* bright magenta */
	134	{ 0x00, 0xff, 0xff }, /* bright cyan */
703d885c RC	135	{ 0xff, 0xff, 0xff }, /* white */
	136	};
	137
5c30fbb8	138	u32 vid_console_color(struct video_priv *priv, unsigned int idx)
703d885c RC	139	{
	140	switch (priv->bpix) {
	141	case VIDEO_BPP16:
5c30fbb8 HS	142	return ((colors[idx].r >> 3) << 11) \|
	143	((colors[idx].g >> 2) << 5) \|
	144	((colors[idx].b >> 3) << 0);
703d885c	145	case VIDEO_BPP32:
5c30fbb8 HS	146	return (colors[idx].r << 16) \|
	147	(colors[idx].g << 8) \|
	148	(colors[idx].b << 0);
703d885c	149	default:
5c30fbb8 HS	150	/*
	151	* For unknown bit arrangements just support
	152	* black and white.
	153	*/
	154	if (idx)
	155	return 0xffffff; /* white */
	156	else
	157	return 0x000000; /* black */
703d885c RC	158	}
	159	}
	160
a085aa1f RC	161	static char parsenum(char s, int *num)
	162	{
	163	char *end;
	164	*num = simple_strtol(s, &end, 10);
	165	return end;
	166	}
	167
662f381a HS	168	/**
	169	* set_cursor_position() - set cursor position
	170	*
	171	* @priv: private data of the video console
	172	* @row: new row
	173	* @col: new column
	174	*/
	175	static void set_cursor_position(struct vidconsole_priv *priv, int row, int col)
	176	{
	177	/*
	178	* Ensure we stay in the bounds of the screen.
	179	*/
	180	if (row >= priv->rows)
	181	row = priv->rows - 1;
	182	if (col >= priv->cols)
	183	col = priv->cols - 1;
	184
	185	priv->ycur = row * priv->y_charsize;
	186	priv->xcur_frac = priv->xstart_frac +
	187	VID_TO_POS(col * priv->x_charsize);
	188	}
	189
	190	/**
	191	* get_cursor_position() - get cursor position
	192	*
	193	* @priv: private data of the video console
	194	* @row: row
	195	* @col: column
	196	*/
	197	static void get_cursor_position(struct vidconsole_priv *priv,
	198	int row, int col)
	199	{
	200	*row = priv->ycur / priv->y_charsize;
	201	*col = VID_TO_PIXEL(priv->xcur_frac - priv->xstart_frac) /
	202	priv->x_charsize;
	203	}
	204
a085aa1f RC	205	/*
	206	* Process a character while accumulating an escape string. Chars are
	207	* accumulated into escape_buf until the end of escape sequence is
	208	* found, at which point the sequence is parsed and processed.
	209	*/
	210	static void vidconsole_escape_char(struct udevice *dev, char ch)
	211	{
	212	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	213
	214	if (!IS_ENABLED(CONFIG_VIDEO_ANSI))
	215	goto error;
	216
	217	/* Sanity checking for bogus ESC sequences: */
	218	if (priv->escape_len >= sizeof(priv->escape_buf))
	219	goto error;
662f381a HS	220	if (priv->escape_len == 0) {
	221	switch (ch) {
	222	case '7':
	223	/* Save cursor position */
	224	get_cursor_position(priv, &priv->row_saved,
	225	&priv->col_saved);
	226	priv->escape = 0;
	227
	228	return;
	229	case '8': {
	230	/* Restore cursor position */
	231	int row = priv->row_saved;
	232	int col = priv->col_saved;
	233
	234	set_cursor_position(priv, row, col);
	235	priv->escape = 0;
	236	return;
	237	}
	238	case '[':
	239	break;
	240	default:
	241	goto error;
	242	}
	243	}
a085aa1f RC	244
	245	priv->escape_buf[priv->escape_len++] = ch;
	246
	247	/*
	248	* Escape sequences are terminated by a letter, so keep
	249	* accumulating until we get one:
	250	*/
	251	if (!isalpha(ch))
	252	return;
	253
	254	/*
	255	* clear escape mode first, otherwise things will get highly
	256	* surprising if you hit any debug prints that come back to
	257	* this console.
	258	*/
	259	priv->escape = 0;
	260
	261	switch (ch) {
29c158b9 AP	262	case 'A':
	263	case 'B':
	264	case 'C':
	265	case 'D':
	266	case 'E':
	267	case 'F': {
	268	int row, col, num;
	269	char *s = priv->escape_buf;
	270
	271	/*
	272	* Cursor up/down: [%dA, [%dB, [%dE, [%dF
	273	* Cursor left/right: [%dD, [%dC
	274	*/
	275	s++; /* [ */
	276	s = parsenum(s, &num);
	277	if (num == 0) /* No digit in sequence ... */
	278	num = 1; /* ... means "move by 1". */
	279
	280	get_cursor_position(priv, &row, &col);
	281	if (ch == 'A' \|\| ch == 'F')
	282	row -= num;
	283	if (ch == 'C')
	284	col += num;
	285	if (ch == 'D')
	286	col -= num;
	287	if (ch == 'B' \|\| ch == 'E')
	288	row += num;
	289	if (ch == 'E' \|\| ch == 'F')
	290	col = 0;
	291	if (col < 0)
	292	col = 0;
	293	if (row < 0)
	294	row = 0;
	295	/* Right and bottom overflows are handled in the callee. */
	296	set_cursor_position(priv, row, col);
	297	break;
	298	}
a085aa1f RC	299	case 'H':
	300	case 'f': {
	301	int row, col;
	302	char *s = priv->escape_buf;
	303
	304	/*
	305	* Set cursor position: [%d;%df or [%d;%dH
	306	*/
	307	s++; /* [ */
	308	s = parsenum(s, &row);
	309	s++; /* ; */
	310	s = parsenum(s, &col);
	311
118f020d HS	312	/*
	313	* Video origin is [0, 0], terminal origin is [1, 1].
	314	*/
	315	if (row)
	316	--row;
	317	if (col)
	318	--col;
	319
662f381a	320	set_cursor_position(priv, row, col);
a085aa1f RC	321
	322	break;
	323	}
	324	case 'J': {
	325	int mode;
	326
	327	/*
	328	* Clear part/all screen:
	329	* [J or [0J - clear screen from cursor down
	330	* [1J - clear screen from cursor up
	331	* [2J - clear entire screen
	332	*
	333	* TODO we really only handle entire-screen case, others
	334	* probably require some additions to video-uclass (and
	335	* are not really needed yet by efi_console)
	336	*/
	337	parsenum(priv->escape_buf + 1, &mode);
	338
	339	if (mode == 2) {
	340	video_clear(dev->parent);
55d39911	341	video_sync(dev->parent, false);
a085aa1f RC	342	priv->ycur = 0;
	343	priv->xcur_frac = priv->xstart_frac;
	344	} else {
	345	debug("unsupported clear mode: %d\n", mode);
	346	}
	347	break;
	348	}
4422294c AP	349	case 'K': {
	350	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	351	int mode;
	352
	353	/*
	354	* Clear (parts of) current line
	355	* [0K - clear line to end
	356	* [2K - clear entire line
	357	*/
	358	parsenum(priv->escape_buf + 1, &mode);
	359
	360	if (mode == 2) {
	361	int row, col;
	362
	363	get_cursor_position(priv, &row, &col);
	364	vidconsole_set_row(dev, row, vid_priv->colour_bg);
	365	}
	366	break;
	367	}
703d885c RC	368	case 'm': {
	369	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	370	char *s = priv->escape_buf;
	371	char *end = &priv->escape_buf[priv->escape_len];
	372
	373	/*
	374	* Set graphics mode: [%d;...;%dm
	375	*
	376	* Currently only supports the color attributes:
	377	*
	378	* Foreground Colors:
	379	*
	380	* 30 Black
	381	* 31 Red
	382	* 32 Green
	383	* 33 Yellow
	384	* 34 Blue
	385	* 35 Magenta
	386	* 36 Cyan
	387	* 37 White
	388	*
	389	* Background Colors:
	390	*
	391	* 40 Black
	392	* 41 Red
	393	* 42 Green
	394	* 43 Yellow
	395	* 44 Blue
	396	* 45 Magenta
	397	* 46 Cyan
	398	* 47 White
	399	*/
	400
	401	s++; /* [ */
	402	while (s < end) {
	403	int val;
	404
	405	s = parsenum(s, &val);
	406	s++;
	407
	408	switch (val) {
9ffa4d12 HS	409	case 0:
9ffa4d12 HS	410	/* all attributes off */
b9f210a3	411	video_set_default_colors(dev->parent, false);
9ffa4d12 HS	412	break;
	413	case 1:
	414	/* bold */
	415	vid_priv->fg_col_idx \|= 8;
	416	vid_priv->colour_fg = vid_console_color(
	417	vid_priv, vid_priv->fg_col_idx);
	418	break;
eabb0725 AP	419	case 7:
	420	/* reverse video */
	421	vid_priv->colour_fg = vid_console_color(
	422	vid_priv, vid_priv->bg_col_idx);
	423	vid_priv->colour_bg = vid_console_color(
	424	vid_priv, vid_priv->fg_col_idx);
	425	break;
703d885c	426	case 30 ... 37:
5c30fbb8	427	/* foreground color */
9ffa4d12 HS	428	vid_priv->fg_col_idx &= ~7;
9ffa4d12 HS	429	vid_priv->fg_col_idx \|= val - 30;
5c30fbb8	430	vid_priv->colour_fg = vid_console_color(
9ffa4d12	431	vid_priv, vid_priv->fg_col_idx);
703d885c RC	432	break;
703d885c RC	433	case 40 ... 47:
eabb0725 AP	434	/* background color, also mask the bold bit */
	435	vid_priv->bg_col_idx &= ~0xf;
	436	vid_priv->bg_col_idx \|= val - 40;
5c30fbb8	437	vid_priv->colour_bg = vid_console_color(
eabb0725	438	vid_priv, vid_priv->bg_col_idx);
703d885c RC	439	break;
703d885c RC	440	default:
5c30fbb8	441	/* ignore unsupported SGR parameter */
703d885c RC	442	break;
	443	}
	444	}
	445
	446	break;
	447	}
a085aa1f RC	448	default:
	449	debug("unrecognized escape sequence: %*s\n",
	450	priv->escape_len, priv->escape_buf);
	451	}
	452
	453	return;
	454
	455	error:
	456	/* something went wrong, just revert to normal mode: */
	457	priv->escape = 0;
	458	}
	459
7035ec3c AP	460	/* Put that actual character on the screen (using the CP437 code page). */
	461	static int vidconsole_output_glyph(struct udevice *dev, char ch)
	462	{
	463	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	464	int ret;
	465
	466	/*
	467	* Failure of this function normally indicates an unsupported
	468	* colour depth. Check this and return an error to help with
	469	* diagnosis.
	470	*/
	471	ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
	472	if (ret == -EAGAIN) {
	473	vidconsole_newline(dev);
	474	ret = vidconsole_putc_xy(dev, priv->xcur_frac, priv->ycur, ch);
	475	}
	476	if (ret < 0)
	477	return ret;
	478	priv->xcur_frac += ret;
	479	priv->last_ch = ch;
	480	if (priv->xcur_frac >= priv->xsize_frac)
	481	vidconsole_newline(dev);
	482
	483	return 0;
	484	}
	485
83510766 SG	486	int vidconsole_put_char(struct udevice *dev, char ch)
	487	{
	488	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	489	int ret;
	490
a085aa1f RC	491	if (priv->escape) {
	492	vidconsole_escape_char(dev, ch);
	493	return 0;
	494	}
	495
83510766	496	switch (ch) {
a085aa1f RC	497	case '\x1b':
	498	priv->escape_len = 0;
	499	priv->escape = 1;
	500	break;
5508f10a SG	501	case '\a':
	502	/* beep */
	503	break;
83510766	504	case '\r':
c5b77d01	505	priv->xcur_frac = priv->xstart_frac;
83510766 SG	506	break;
	507	case '\n':
	508	vidconsole_newline(dev);
58c733a7	509	vidconsole_entry_start(dev);
83510766 SG	510	break;
83510766 SG	511	case '\t': /* Tab (8 chars alignment) */
f2661786 SG	512	priv->xcur_frac = ((priv->xcur_frac / priv->tab_width_frac)
f2661786 SG	513	+ 1) * priv->tab_width_frac;
83510766	514
f2661786	515	if (priv->xcur_frac >= priv->xsize_frac)
83510766 SG	516	vidconsole_newline(dev);
	517	break;
	518	case '\b':
	519	vidconsole_back(dev);
58c733a7	520	priv->last_ch = 0;
83510766 SG	521	break;
83510766 SG	522	default:
7035ec3c	523	ret = vidconsole_output_glyph(dev, ch);
f2661786	524	if (ret < 0)
83510766	525	return ret;
83510766 SG	526	break;
	527	}
	528
	529	return 0;
	530	}
	531
	532	static void vidconsole_putc(struct stdio_dev *sdev, const char ch)
	533	{
	534	struct udevice *dev = sdev->priv;
	535
	536	vidconsole_put_char(dev, ch);
55d39911	537	video_sync(dev->parent, false);
83510766 SG	538	}
	539
	540	static void vidconsole_puts(struct stdio_dev sdev, const char s)
	541	{
	542	struct udevice *dev = sdev->priv;
	543
	544	while (*s)
	545	vidconsole_put_char(dev, *s++);
55d39911	546	video_sync(dev->parent, false);
83510766 SG	547	}
	548
	549	/* Set up the number of rows and colours (rotated drivers override this) */
	550	static int vidconsole_pre_probe(struct udevice *dev)
	551	{
	552	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	553	struct udevice *vid = dev->parent;
	554	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
	555
f2661786	556	priv->xsize_frac = VID_TO_POS(vid_priv->xsize);
83510766 SG	557
	558	return 0;
	559	}
	560
	561	/* Register the device with stdio */
	562	static int vidconsole_post_probe(struct udevice *dev)
	563	{
	564	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
	565	struct stdio_dev *sdev = &priv->sdev;
83510766	566
f2661786 SG	567	if (!priv->tab_width_frac)
	568	priv->tab_width_frac = VID_TO_POS(priv->x_charsize) * 8;
	569
f1a1247d SG	570	if (dev->seq) {
	571	snprintf(sdev->name, sizeof(sdev->name), "vidconsole%d",
	572	dev->seq);
	573	} else {
	574	strcpy(sdev->name, "vidconsole");
	575	}
f2661786	576
83510766 SG	577	sdev->flags = DEV_FLAGS_OUTPUT;
	578	sdev->putc = vidconsole_putc;
	579	sdev->puts = vidconsole_puts;
	580	sdev->priv = dev;
83510766	581
720873bf	582	return stdio_register(sdev);
83510766 SG	583	}
	584
	585	UCLASS_DRIVER(vidconsole) = {
	586	.id = UCLASS_VIDEO_CONSOLE,
	587	.name = "vidconsole0",
	588	.pre_probe = vidconsole_pre_probe,
	589	.post_probe = vidconsole_post_probe,
	590	.per_device_auto_alloc_size = sizeof(struct vidconsole_priv),
	591	};
	592
	593	void vidconsole_position_cursor(struct udevice *dev, unsigned col, unsigned row)
	594	{
	595	struct vidconsole_priv *priv = dev_get_uclass_priv(dev);
f2661786 SG	596	struct udevice *vid_dev = dev->parent;
f2661786 SG	597	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
83510766	598
9949ee87 SG	599	col *= priv->x_charsize;
9949ee87 SG	600	row *= priv->y_charsize;
f2661786 SG	601	priv->xcur_frac = VID_TO_POS(min_t(short, col, vid_priv->xsize - 1));
f2661786 SG	602	priv->ycur = min_t(short, row, vid_priv->ysize - 1);
83510766 SG	603	}
	604
	605	static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
	606	char *const argv[])
	607	{
	608	unsigned int col, row;
	609	struct udevice *dev;
	610
	611	if (argc != 3)
	612	return CMD_RET_USAGE;
	613
3f603cbb	614	if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
83510766 SG	615	return CMD_RET_FAILURE;
	616	col = simple_strtoul(argv[1], NULL, 10);
	617	row = simple_strtoul(argv[2], NULL, 10);
	618	vidconsole_position_cursor(dev, col, row);
	619
	620	return 0;
	621	}
	622
	623	static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
	624	char *const argv[])
	625	{
	626	struct udevice *dev;
	627	const char *s;
	628
	629	if (argc != 2)
	630	return CMD_RET_USAGE;
	631
3f603cbb	632	if (uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev))
83510766 SG	633	return CMD_RET_FAILURE;
	634	for (s = argv[1]; *s; s++)
	635	vidconsole_put_char(dev, *s);
	636
55d39911	637	video_sync(dev->parent, false);
889808da	638
83510766 SG	639	return 0;
	640	}
	641
	642	U_BOOT_CMD(
	643	setcurs, 3, 1, do_video_setcursor,
	644	"set cursor position within screen",
	645	" <col> <row> in character"
	646	);
	647
	648	U_BOOT_CMD(
	649	lcdputs, 2, 1, do_video_puts,
	650	"print string on video framebuffer",
	651	" <string>"
	652	);