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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2015 Google, Inc
 * (C) Copyright 2015
 * Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
 */

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

static int console_set_row_1(struct udevice *dev, uint row, int clr)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	int pbytes = VNBYTES(vid_priv->bpix);
	void *start, *line;
	int i, j;
	int ret;

	start = vid_priv->fb + vid_priv->line_length -
		(row + 1) * VIDEO_FONT_HEIGHT * pbytes;
	line = start;
	for (j = 0; j < vid_priv->ysize; j++) {
		switch (vid_priv->bpix) {
		case VIDEO_BPP8:
			if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
				uint8_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		case VIDEO_BPP16:
			if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
				uint16_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		case VIDEO_BPP32:
			if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
				uint32_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
	}
	ret = vidconsole_sync_copy(dev, start, line);
	if (ret)
		return ret;

	return 0;
}

static int console_move_rows_1(struct udevice *dev, uint rowdst, uint rowsrc,
			       uint count)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	int pbytes = VNBYTES(vid_priv->bpix);
	void *dst;
	void *src;
	int j, ret;

	dst = vid_priv->fb + vid_priv->line_length -
		(rowdst + count) * VIDEO_FONT_HEIGHT * pbytes;
	src = vid_priv->fb + vid_priv->line_length -
		(rowsrc + count) * VIDEO_FONT_HEIGHT * pbytes;

	for (j = 0; j < vid_priv->ysize; j++) {
		ret = vidconsole_memmove(dev, dst, src,
					 VIDEO_FONT_HEIGHT * pbytes * count);
		if (ret)
			return ret;
		src += vid_priv->line_length;
		dst += vid_priv->line_length;
	}

	return 0;
}

static int console_putc_xy_1(struct udevice *dev, uint x_frac, uint y, char ch)
{
	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	struct udevice *vid = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
	uchar *pfont = video_fontdata + (u8)ch * VIDEO_FONT_HEIGHT;
	int pbytes = VNBYTES(vid_priv->bpix);
	int i, col, x, linenum, ret;
	int mask = 0x80;
	void *start, *line;

	linenum = VID_TO_PIXEL(x_frac) + 1;
	x = y + 1;
	start = vid_priv->fb + linenum * vid_priv->line_length - x * pbytes;
	line = start;
	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
		return -EAGAIN;

	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
		switch (vid_priv->bpix) {
		case VIDEO_BPP8:
			if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
				uint8_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst-- = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		case VIDEO_BPP16:
			if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
				uint16_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst-- = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		case VIDEO_BPP32:
			if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
				uint32_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst-- = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
		mask >>= 1;
	}
	/* We draw backwards from 'start, so account for the first line */
	ret = vidconsole_sync_copy(dev, start - vid_priv->line_length, line);
	if (ret)
		return ret;

	return VID_TO_POS(VIDEO_FONT_WIDTH);
}


static int console_set_row_2(struct udevice *dev, uint row, int clr)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	void *start, *line, *end;
	int pixels = VIDEO_FONT_HEIGHT * vid_priv->xsize;
	int i, ret;

	start = vid_priv->fb + vid_priv->ysize * vid_priv->line_length -
		(row + 1) * VIDEO_FONT_HEIGHT * vid_priv->line_length;
	line = start;
	switch (vid_priv->bpix) {
	case VIDEO_BPP8:
		if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
			uint8_t *dst = line;

			for (i = 0; i < pixels; i++)
				*dst++ = clr;
			end = dst;
			break;
		}
	case VIDEO_BPP16:
		if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
			uint16_t *dst = line;

			for (i = 0; i < pixels; i++)
				*dst++ = clr;
			end = dst;
			break;
		}
	case VIDEO_BPP32:
		if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
			uint32_t *dst = line;

			for (i = 0; i < pixels; i++)
				*dst++ = clr;
			end = dst;
			break;
		}
	default:
		return -ENOSYS;
	}
	ret = vidconsole_sync_copy(dev, start, end);
	if (ret)
		return ret;

	return 0;
}

static int console_move_rows_2(struct udevice *dev, uint rowdst, uint rowsrc,
			       uint count)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	void *dst;
	void *src;
	void *end;

	end = vid_priv->fb + vid_priv->ysize * vid_priv->line_length;
	dst = end - (rowdst + count) * VIDEO_FONT_HEIGHT *
		vid_priv->line_length;
	src = end - (rowsrc + count) * VIDEO_FONT_HEIGHT *
		vid_priv->line_length;
	vidconsole_memmove(dev, dst, src,
			   VIDEO_FONT_HEIGHT * vid_priv->line_length * count);

	return 0;
}

static int console_putc_xy_2(struct udevice *dev, uint x_frac, uint y, char ch)
{
	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	struct udevice *vid = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
	int pbytes = VNBYTES(vid_priv->bpix);
	int i, row, x, linenum, ret;
	void *start, *line;

	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
		return -EAGAIN;
	linenum = vid_priv->ysize - y - 1;
	x = vid_priv->xsize - VID_TO_PIXEL(x_frac) - 1;
	start = vid_priv->fb + linenum * vid_priv->line_length + x * pbytes;
	line = start;

	for (row = 0; row < VIDEO_FONT_HEIGHT; row++) {
		unsigned int idx = (u8)ch * VIDEO_FONT_HEIGHT + row;
		uchar bits = video_fontdata[idx];

		switch (vid_priv->bpix) {
		case VIDEO_BPP8:
			if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
				uint8_t *dst = line;

				for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
					*dst-- = (bits & 0x80) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
					bits <<= 1;
				}
				break;
			}
		case VIDEO_BPP16:
			if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
				uint16_t *dst = line;

				for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
					*dst-- = (bits & 0x80) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
					bits <<= 1;
				}
				break;
			}
		case VIDEO_BPP32:
			if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
				uint32_t *dst = line;

				for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
					*dst-- = (bits & 0x80) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
					bits <<= 1;
				}
				break;
			}
		default:
			return -ENOSYS;
		}
		line -= vid_priv->line_length;
	}
	/* Add 4 bytes to allow for the first pixel writen */
	ret = vidconsole_sync_copy(dev, start + 4, line);
	if (ret)
		return ret;

	return VID_TO_POS(VIDEO_FONT_WIDTH);
}

static int console_set_row_3(struct udevice *dev, uint row, int clr)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	int pbytes = VNBYTES(vid_priv->bpix);
	void *start, *line;
	int i, j, ret;

	start = vid_priv->fb + row * VIDEO_FONT_HEIGHT * pbytes;
	line = start;
	for (j = 0; j < vid_priv->ysize; j++) {
		switch (vid_priv->bpix) {
		case VIDEO_BPP8:
			if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
				uint8_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		case VIDEO_BPP16:
			if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
				uint16_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		case VIDEO_BPP32:
			if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
				uint32_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
					*dst++ = clr;
				break;
			}
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
	}
	ret = vidconsole_sync_copy(dev, start, line);
	if (ret)
		return ret;

	return 0;
}

static int console_move_rows_3(struct udevice *dev, uint rowdst, uint rowsrc,
			       uint count)
{
	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	int pbytes = VNBYTES(vid_priv->bpix);
	void *dst;
	void *src;
	int j, ret;

	dst = vid_priv->fb + rowdst * VIDEO_FONT_HEIGHT * pbytes;
	src = vid_priv->fb + rowsrc * VIDEO_FONT_HEIGHT * pbytes;

	for (j = 0; j < vid_priv->ysize; j++) {
		ret = vidconsole_memmove(dev, dst, src,
					 VIDEO_FONT_HEIGHT * pbytes * count);
		if (ret)
			return ret;
		src += vid_priv->line_length;
		dst += vid_priv->line_length;
	}

	return 0;
}

static int console_putc_xy_3(struct udevice *dev, uint x_frac, uint y, char ch)
{
	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	struct udevice *vid = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
	uchar *pfont = video_fontdata + (u8)ch * VIDEO_FONT_HEIGHT;
	int pbytes = VNBYTES(vid_priv->bpix);
	int i, col, x, ret;
	int mask = 0x80;
	void *start, *line;

	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
		return -EAGAIN;
	x = vid_priv->ysize - VID_TO_PIXEL(x_frac) - 1;
	start = vid_priv->fb + x * vid_priv->line_length + y * pbytes;
	line = start;
	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
		switch (vid_priv->bpix) {
		case VIDEO_BPP8:
			if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
				uint8_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst++ = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		case VIDEO_BPP16:
			if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
				uint16_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst++ = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		case VIDEO_BPP32:
			if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
				uint32_t *dst = line;

				for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
					*dst++ = (pfont[i] & mask) ?
						vid_priv->colour_fg :
						vid_priv->colour_bg;
				}
				break;
			}
		default:
			return -ENOSYS;
		}
		line -= vid_priv->line_length;
		mask >>= 1;
	}
	/* Add a line to allow for the first pixels writen */
	ret = vidconsole_sync_copy(dev, start + vid_priv->line_length, line);
	if (ret)
		return ret;

	return VID_TO_POS(VIDEO_FONT_WIDTH);
}


static int console_probe_2(struct udevice *dev)
{
	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	struct udevice *vid_dev = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);

	vc_priv->x_charsize = VIDEO_FONT_WIDTH;
	vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
	vc_priv->cols = vid_priv->xsize / VIDEO_FONT_WIDTH;
	vc_priv->rows = vid_priv->ysize / VIDEO_FONT_HEIGHT;

	return 0;
}

static int console_probe_1_3(struct udevice *dev)
{
	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	struct udevice *vid_dev = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);

	vc_priv->x_charsize = VIDEO_FONT_WIDTH;
	vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
	vc_priv->cols = vid_priv->ysize / VIDEO_FONT_WIDTH;
	vc_priv->rows = vid_priv->xsize / VIDEO_FONT_HEIGHT;
	vc_priv->xsize_frac = VID_TO_POS(vid_priv->ysize);

	return 0;
}

struct vidconsole_ops console_ops_1 = {
	.putc_xy	= console_putc_xy_1,
	.move_rows	= console_move_rows_1,
	.set_row	= console_set_row_1,
};

struct vidconsole_ops console_ops_2 = {
	.putc_xy	= console_putc_xy_2,
	.move_rows	= console_move_rows_2,
	.set_row	= console_set_row_2,
};

struct vidconsole_ops console_ops_3 = {
	.putc_xy	= console_putc_xy_3,
	.move_rows	= console_move_rows_3,
	.set_row	= console_set_row_3,
};

U_BOOT_DRIVER(vidconsole_1) = {
	.name	= "vidconsole1",
	.id	= UCLASS_VIDEO_CONSOLE,
	.ops	= &console_ops_1,
	.probe	= console_probe_1_3,
};

U_BOOT_DRIVER(vidconsole_2) = {
	.name	= "vidconsole2",
	.id	= UCLASS_VIDEO_CONSOLE,
	.ops	= &console_ops_2,
	.probe	= console_probe_2,
};

U_BOOT_DRIVER(vidconsole_3) = {
	.name	= "vidconsole3",
	.id	= UCLASS_VIDEO_CONSOLE,
	.ops	= &console_ops_3,
	.probe	= console_probe_1_3,
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
b5146b28 SG	2	/*
	3	* Copyright (c) 2015 Google, Inc
	4	* (C) Copyright 2015
	5	* Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
b5146b28 SG	6	*/
	7
	8	#include <common.h>
	9	#include <dm.h>
	10	#include <video.h>
	11	#include <video_console.h>
	12	#include <video_font.h> /* Get font data, width and height */
	13
	14	static int console_set_row_1(struct udevice *dev, uint row, int clr)
	15	{
	16	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	17	int pbytes = VNBYTES(vid_priv->bpix);
c30c5f27	18	void start, line;
b5146b28	19	int i, j;
c30c5f27	20	int ret;
b5146b28	21
c30c5f27	22	start = vid_priv->fb + vid_priv->line_length -
b5146b28	23	(row + 1) * VIDEO_FONT_HEIGHT * pbytes;
c30c5f27	24	line = start;
b5146b28 SG	25	for (j = 0; j < vid_priv->ysize; j++) {
b5146b28 SG	26	switch (vid_priv->bpix) {
c6567319 SG	27	case VIDEO_BPP8:
	28	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	29	uint8_t *dst = line;
b5146b28	30
c6567319 SG	31	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	32	*dst++ = clr;
	33	break;
	34	}
	35	case VIDEO_BPP16:
	36	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	37	uint16_t *dst = line;
b5146b28	38
c6567319 SG	39	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	40	*dst++ = clr;
	41	break;
	42	}
	43	case VIDEO_BPP32:
	44	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	45	uint32_t *dst = line;
b5146b28	46
c6567319 SG	47	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	48	*dst++ = clr;
	49	break;
	50	}
b5146b28 SG	51	default:
	52	return -ENOSYS;
	53	}
	54	line += vid_priv->line_length;
	55	}
c30c5f27 SG	56	ret = vidconsole_sync_copy(dev, start, line);
	57	if (ret)
	58	return ret;
b5146b28 SG	59
	60	return 0;
	61	}
	62
	63	static int console_move_rows_1(struct udevice *dev, uint rowdst, uint rowsrc,
	64	uint count)
	65	{
	66	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
a254d11d	67	int pbytes = VNBYTES(vid_priv->bpix);
b5146b28 SG	68	void *dst;
b5146b28 SG	69	void *src;
c30c5f27	70	int j, ret;
b5146b28 SG	71
	72	dst = vid_priv->fb + vid_priv->line_length -
	73	(rowdst + count) * VIDEO_FONT_HEIGHT * pbytes;
	74	src = vid_priv->fb + vid_priv->line_length -
	75	(rowsrc + count) * VIDEO_FONT_HEIGHT * pbytes;
	76
	77	for (j = 0; j < vid_priv->ysize; j++) {
c30c5f27 SG	78	ret = vidconsole_memmove(dev, dst, src,
	79	VIDEO_FONT_HEIGHT * pbytes * count);
	80	if (ret)
	81	return ret;
b5146b28 SG	82	src += vid_priv->line_length;
	83	dst += vid_priv->line_length;
	84	}
	85
	86	return 0;
	87	}
	88
f2661786	89	static int console_putc_xy_1(struct udevice *dev, uint x_frac, uint y, char ch)
b5146b28	90	{
f2661786	91	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
b5146b28 SG	92	struct udevice *vid = dev->parent;
b5146b28 SG	93	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
a254d11d	94	uchar pfont = video_fontdata + (u8)ch VIDEO_FONT_HEIGHT;
b5146b28	95	int pbytes = VNBYTES(vid_priv->bpix);
c30c5f27	96	int i, col, x, linenum, ret;
b5146b28	97	int mask = 0x80;
c30c5f27	98	void start, line;
b5146b28	99
a254d11d SG	100	linenum = VID_TO_PIXEL(x_frac) + 1;
a254d11d SG	101	x = y + 1;
c30c5f27 SG	102	start = vid_priv->fb + linenum * vid_priv->line_length - x * pbytes;
c30c5f27 SG	103	line = start;
f2661786 SG	104	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
	105	return -EAGAIN;
	106
b5146b28 SG	107	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
b5146b28 SG	108	switch (vid_priv->bpix) {
c6567319 SG	109	case VIDEO_BPP8:
	110	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	111	uint8_t *dst = line;
	112
	113	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	114	*dst-- = (pfont[i] & mask) ?
	115	vid_priv->colour_fg :
	116	vid_priv->colour_bg;
	117	}
	118	break;
b5146b28	119	}
c6567319 SG	120	case VIDEO_BPP16:
	121	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	122	uint16_t *dst = line;
	123
	124	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	125	*dst-- = (pfont[i] & mask) ?
	126	vid_priv->colour_fg :
	127	vid_priv->colour_bg;
	128	}
	129	break;
b5146b28	130	}
c6567319 SG	131	case VIDEO_BPP32:
	132	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	133	uint32_t *dst = line;
	134
	135	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	136	*dst-- = (pfont[i] & mask) ?
	137	vid_priv->colour_fg :
	138	vid_priv->colour_bg;
	139	}
	140	break;
b5146b28	141	}
b5146b28 SG	142	default:
	143	return -ENOSYS;
	144	}
	145	line += vid_priv->line_length;
	146	mask >>= 1;
	147	}
c30c5f27 SG	148	/* We draw backwards from 'start, so account for the first line */
	149	ret = vidconsole_sync_copy(dev, start - vid_priv->line_length, line);
	150	if (ret)
	151	return ret;
b5146b28	152
f2661786	153	return VID_TO_POS(VIDEO_FONT_WIDTH);
b5146b28 SG	154	}
	155
	156
	157	static int console_set_row_2(struct udevice *dev, uint row, int clr)
	158	{
	159	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
c30c5f27	160	void start, line, *end;
b5146b28	161	int pixels = VIDEO_FONT_HEIGHT * vid_priv->xsize;
c30c5f27	162	int i, ret;
b5146b28	163
c30c5f27	164	start = vid_priv->fb + vid_priv->ysize * vid_priv->line_length -
b5146b28	165	(row + 1) * VIDEO_FONT_HEIGHT * vid_priv->line_length;
c30c5f27	166	line = start;
b5146b28	167	switch (vid_priv->bpix) {
c6567319 SG	168	case VIDEO_BPP8:
	169	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	170	uint8_t *dst = line;
b5146b28	171
c6567319 SG	172	for (i = 0; i < pixels; i++)
c6567319 SG	173	*dst++ = clr;
c30c5f27	174	end = dst;
c6567319 SG	175	break;
	176	}
	177	case VIDEO_BPP16:
	178	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	179	uint16_t *dst = line;
	180
	181	for (i = 0; i < pixels; i++)
	182	*dst++ = clr;
c30c5f27	183	end = dst;
c6567319 SG	184	break;
	185	}
	186	case VIDEO_BPP32:
	187	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	188	uint32_t *dst = line;
	189
	190	for (i = 0; i < pixels; i++)
	191	*dst++ = clr;
c30c5f27	192	end = dst;
c6567319 SG	193	break;
c6567319 SG	194	}
b5146b28 SG	195	default:
	196	return -ENOSYS;
	197	}
c30c5f27 SG	198	ret = vidconsole_sync_copy(dev, start, end);
	199	if (ret)
	200	return ret;
b5146b28 SG	201
	202	return 0;
	203	}
	204
	205	static int console_move_rows_2(struct udevice *dev, uint rowdst, uint rowsrc,
	206	uint count)
	207	{
	208	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	209	void *dst;
	210	void *src;
	211	void *end;
	212
	213	end = vid_priv->fb + vid_priv->ysize * vid_priv->line_length;
	214	dst = end - (rowdst + count) * VIDEO_FONT_HEIGHT *
	215	vid_priv->line_length;
	216	src = end - (rowsrc + count) * VIDEO_FONT_HEIGHT *
	217	vid_priv->line_length;
c30c5f27 SG	218	vidconsole_memmove(dev, dst, src,
c30c5f27 SG	219	VIDEO_FONT_HEIGHT * vid_priv->line_length * count);
b5146b28 SG	220
	221	return 0;
	222	}
	223
f2661786	224	static int console_putc_xy_2(struct udevice *dev, uint x_frac, uint y, char ch)
b5146b28	225	{
f2661786	226	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
b5146b28 SG	227	struct udevice *vid = dev->parent;
b5146b28 SG	228	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
a254d11d	229	int pbytes = VNBYTES(vid_priv->bpix);
c30c5f27 SG	230	int i, row, x, linenum, ret;
c30c5f27 SG	231	void start, line;
b5146b28	232
f2661786 SG	233	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
f2661786 SG	234	return -EAGAIN;
a254d11d	235	linenum = vid_priv->ysize - y - 1;
9beb364a	236	x = vid_priv->xsize - VID_TO_PIXEL(x_frac) - 1;
c30c5f27 SG	237	start = vid_priv->fb + linenum * vid_priv->line_length + x * pbytes;
c30c5f27 SG	238	line = start;
b5146b28 SG	239
b5146b28 SG	240	for (row = 0; row < VIDEO_FONT_HEIGHT; row++) {
96c9bf7e AP	241	unsigned int idx = (u8)ch * VIDEO_FONT_HEIGHT + row;
96c9bf7e AP	242	uchar bits = video_fontdata[idx];
b5146b28 SG	243
b5146b28 SG	244	switch (vid_priv->bpix) {
c6567319 SG	245	case VIDEO_BPP8:
	246	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	247	uint8_t *dst = line;
	248
	249	for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
	250	*dst-- = (bits & 0x80) ?
	251	vid_priv->colour_fg :
	252	vid_priv->colour_bg;
	253	bits <<= 1;
	254	}
	255	break;
b5146b28	256	}
c6567319 SG	257	case VIDEO_BPP16:
	258	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	259	uint16_t *dst = line;
	260
	261	for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
	262	*dst-- = (bits & 0x80) ?
	263	vid_priv->colour_fg :
	264	vid_priv->colour_bg;
	265	bits <<= 1;
	266	}
	267	break;
b5146b28	268	}
c6567319 SG	269	case VIDEO_BPP32:
	270	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	271	uint32_t *dst = line;
	272
	273	for (i = 0; i < VIDEO_FONT_WIDTH; i++) {
	274	*dst-- = (bits & 0x80) ?
	275	vid_priv->colour_fg :
	276	vid_priv->colour_bg;
	277	bits <<= 1;
	278	}
	279	break;
b5146b28	280	}
b5146b28 SG	281	default:
	282	return -ENOSYS;
	283	}
	284	line -= vid_priv->line_length;
	285	}
c30c5f27 SG	286	/* Add 4 bytes to allow for the first pixel writen */
	287	ret = vidconsole_sync_copy(dev, start + 4, line);
	288	if (ret)
	289	return ret;
b5146b28	290
f2661786	291	return VID_TO_POS(VIDEO_FONT_WIDTH);
b5146b28 SG	292	}
	293
	294	static int console_set_row_3(struct udevice *dev, uint row, int clr)
	295	{
	296	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
	297	int pbytes = VNBYTES(vid_priv->bpix);
c30c5f27 SG	298	void start, line;
c30c5f27 SG	299	int i, j, ret;
b5146b28	300
c30c5f27 SG	301	start = vid_priv->fb + row * VIDEO_FONT_HEIGHT * pbytes;
c30c5f27 SG	302	line = start;
b5146b28 SG	303	for (j = 0; j < vid_priv->ysize; j++) {
b5146b28 SG	304	switch (vid_priv->bpix) {
c6567319 SG	305	case VIDEO_BPP8:
	306	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	307	uint8_t *dst = line;
b5146b28	308
c6567319 SG	309	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	310	*dst++ = clr;
	311	break;
	312	}
	313	case VIDEO_BPP16:
	314	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	315	uint16_t *dst = line;
b5146b28	316
c6567319 SG	317	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	318	*dst++ = clr;
	319	break;
	320	}
	321	case VIDEO_BPP32:
	322	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	323	uint32_t *dst = line;
b5146b28	324
c6567319 SG	325	for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
	326	*dst++ = clr;
	327	break;
	328	}
b5146b28 SG	329	default:
	330	return -ENOSYS;
	331	}
	332	line += vid_priv->line_length;
	333	}
c30c5f27 SG	334	ret = vidconsole_sync_copy(dev, start, line);
	335	if (ret)
	336	return ret;
b5146b28 SG	337
	338	return 0;
	339	}
	340
	341	static int console_move_rows_3(struct udevice *dev, uint rowdst, uint rowsrc,
	342	uint count)
	343	{
	344	struct video_priv *vid_priv = dev_get_uclass_priv(dev->parent);
a254d11d	345	int pbytes = VNBYTES(vid_priv->bpix);
b5146b28 SG	346	void *dst;
b5146b28 SG	347	void *src;
c30c5f27	348	int j, ret;
b5146b28 SG	349
	350	dst = vid_priv->fb + rowdst * VIDEO_FONT_HEIGHT * pbytes;
	351	src = vid_priv->fb + rowsrc * VIDEO_FONT_HEIGHT * pbytes;
	352
	353	for (j = 0; j < vid_priv->ysize; j++) {
c30c5f27 SG	354	ret = vidconsole_memmove(dev, dst, src,
	355	VIDEO_FONT_HEIGHT * pbytes * count);
	356	if (ret)
	357	return ret;
b5146b28 SG	358	src += vid_priv->line_length;
	359	dst += vid_priv->line_length;
	360	}
	361
	362	return 0;
	363	}
	364
f2661786	365	static int console_putc_xy_3(struct udevice *dev, uint x_frac, uint y, char ch)
b5146b28	366	{
f2661786	367	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
b5146b28 SG	368	struct udevice *vid = dev->parent;
b5146b28 SG	369	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
a254d11d	370	uchar pfont = video_fontdata + (u8)ch VIDEO_FONT_HEIGHT;
b5146b28	371	int pbytes = VNBYTES(vid_priv->bpix);
c30c5f27	372	int i, col, x, ret;
b5146b28	373	int mask = 0x80;
c30c5f27	374	void start, line;
b5146b28	375
f2661786 SG	376	if (x_frac + VID_TO_POS(vc_priv->x_charsize) > vc_priv->xsize_frac)
f2661786 SG	377	return -EAGAIN;
a254d11d	378	x = vid_priv->ysize - VID_TO_PIXEL(x_frac) - 1;
c30c5f27 SG	379	start = vid_priv->fb + x * vid_priv->line_length + y * pbytes;
c30c5f27 SG	380	line = start;
b5146b28 SG	381	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
b5146b28 SG	382	switch (vid_priv->bpix) {
c6567319 SG	383	case VIDEO_BPP8:
	384	if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
	385	uint8_t *dst = line;
	386
	387	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	388	*dst++ = (pfont[i] & mask) ?
	389	vid_priv->colour_fg :
	390	vid_priv->colour_bg;
	391	}
	392	break;
b5146b28	393	}
c6567319 SG	394	case VIDEO_BPP16:
	395	if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
	396	uint16_t *dst = line;
	397
	398	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	399	*dst++ = (pfont[i] & mask) ?
	400	vid_priv->colour_fg :
	401	vid_priv->colour_bg;
	402	}
	403	break;
b5146b28	404	}
c6567319 SG	405	case VIDEO_BPP32:
	406	if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
	407	uint32_t *dst = line;
	408
	409	for (i = 0; i < VIDEO_FONT_HEIGHT; i++) {
	410	*dst++ = (pfont[i] & mask) ?
	411	vid_priv->colour_fg :
	412	vid_priv->colour_bg;
	413	}
	414	break;
b5146b28	415	}
b5146b28 SG	416	default:
	417	return -ENOSYS;
	418	}
	419	line -= vid_priv->line_length;
	420	mask >>= 1;
	421	}
c30c5f27 SG	422	/* Add a line to allow for the first pixels writen */
	423	ret = vidconsole_sync_copy(dev, start + vid_priv->line_length, line);
	424	if (ret)
	425	return ret;
b5146b28	426
f2661786	427	return VID_TO_POS(VIDEO_FONT_WIDTH);
b5146b28 SG	428	}
	429
	430
f2661786 SG	431	static int console_probe_2(struct udevice *dev)
	432	{
	433	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	434	struct udevice *vid_dev = dev->parent;
	435	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
	436
	437	vc_priv->x_charsize = VIDEO_FONT_WIDTH;
	438	vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
	439	vc_priv->cols = vid_priv->xsize / VIDEO_FONT_WIDTH;
	440	vc_priv->rows = vid_priv->ysize / VIDEO_FONT_HEIGHT;
	441
	442	return 0;
	443	}
	444
b5146b28 SG	445	static int console_probe_1_3(struct udevice *dev)
b5146b28 SG	446	{
f2661786 SG	447	struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
	448	struct udevice *vid_dev = dev->parent;
	449	struct video_priv *vid_priv = dev_get_uclass_priv(vid_dev);
b5146b28	450
f2661786 SG	451	vc_priv->x_charsize = VIDEO_FONT_WIDTH;
	452	vc_priv->y_charsize = VIDEO_FONT_HEIGHT;
	453	vc_priv->cols = vid_priv->ysize / VIDEO_FONT_WIDTH;
	454	vc_priv->rows = vid_priv->xsize / VIDEO_FONT_HEIGHT;
	455	vc_priv->xsize_frac = VID_TO_POS(vid_priv->ysize);
b5146b28 SG	456
	457	return 0;
	458	}
	459
	460	struct vidconsole_ops console_ops_1 = {
	461	.putc_xy = console_putc_xy_1,
	462	.move_rows = console_move_rows_1,
	463	.set_row = console_set_row_1,
	464	};
	465
	466	struct vidconsole_ops console_ops_2 = {
	467	.putc_xy = console_putc_xy_2,
	468	.move_rows = console_move_rows_2,
	469	.set_row = console_set_row_2,
	470	};
	471
	472	struct vidconsole_ops console_ops_3 = {
	473	.putc_xy = console_putc_xy_3,
	474	.move_rows = console_move_rows_3,
	475	.set_row = console_set_row_3,
	476	};
	477
	478	U_BOOT_DRIVER(vidconsole_1) = {
	479	.name = "vidconsole1",
	480	.id = UCLASS_VIDEO_CONSOLE,
	481	.ops = &console_ops_1,
	482	.probe = console_probe_1_3,
	483	};
	484
	485	U_BOOT_DRIVER(vidconsole_2) = {
	486	.name = "vidconsole2",
	487	.id = UCLASS_VIDEO_CONSOLE,
	488	.ops = &console_ops_2,
f2661786	489	.probe = console_probe_2,
b5146b28 SG	490	};
	491
	492	U_BOOT_DRIVER(vidconsole_3) = {
	493	.name = "vidconsole3",
	494	.id = UCLASS_VIDEO_CONSOLE,
	495	.ops = &console_ops_3,
	496	.probe = console_probe_1_3,
	497	};