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

/*
 * Copyright (c) 2015 Google, Inc
 * (C) Copyright 2015
 * 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 */

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 *line;
	int i, j;

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

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

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

			for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
				*dst++ = clr;
			break;
		}
#endif
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
	}

	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);
	void *dst;
	void *src;
	int pbytes = VNBYTES(vid_priv->bpix);
	int j;

	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++) {
		memmove(dst, src, VIDEO_FONT_HEIGHT * pbytes * count);
		src += vid_priv->line_length;
		dst += vid_priv->line_length;
	}

	return 0;
}

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

	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
		switch (vid_priv->bpix) {
#ifdef CONFIG_VIDEO_BPP8
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP16
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP32
		case 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;
		}
#endif
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
		mask >>= 1;
	}

	return 0;
}


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 *line;
	int pixels = VIDEO_FONT_HEIGHT * vid_priv->xsize;
	int i;

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

		for (i = 0; i < pixels; i++)
			*dst++ = clr;
		break;
	}
#endif
#ifdef CONFIG_VIDEO_BPP16
	case VIDEO_BPP16: {
		uint16_t *dst = line;

		for (i = 0; i < pixels; i++)
			*dst++ = clr;
		break;
	}
#endif
#ifdef CONFIG_VIDEO_BPP32
	case VIDEO_BPP32: {
		uint32_t *dst = line;

		for (i = 0; i < pixels; i++)
			*dst++ = clr;
		break;
	}
#endif
	default:
		return -ENOSYS;
	}

	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;
	memmove(dst, src, VIDEO_FONT_HEIGHT * vid_priv->line_length * count);

	return 0;
}

static int console_putc_xy_2(struct udevice *dev, uint x, uint y, char ch)
{
	struct udevice *vid = dev->parent;
	struct video_priv *vid_priv = dev_get_uclass_priv(vid);
	int i, row;
	void *line;

	line = vid_priv->fb + (vid_priv->ysize - y - 1) *
		vid_priv->line_length +
		(vid_priv->xsize - x - VIDEO_FONT_WIDTH - 1) *
		VNBYTES(vid_priv->bpix);

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

		switch (vid_priv->bpix) {
#ifdef CONFIG_VIDEO_BPP8
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP16
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP32
		case 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;
		}
#endif
		default:
			return -ENOSYS;
		}
		line -= vid_priv->line_length;
	}

	return 0;
}

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 *line;
	int i, j;

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

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

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

			for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
				*dst++ = clr;
			break;
		}
#endif
		default:
			return -ENOSYS;
		}
		line += vid_priv->line_length;
	}

	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);
	void *dst;
	void *src;
	int pbytes = VNBYTES(vid_priv->bpix);
	int j;

	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++) {
		memmove(dst, src, VIDEO_FONT_HEIGHT * pbytes * count);
		src += vid_priv->line_length;
		dst += vid_priv->line_length;
	}

	return 0;
}

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

	for (col = 0; col < VIDEO_FONT_HEIGHT; col++) {
		switch (vid_priv->bpix) {
#ifdef CONFIG_VIDEO_BPP8
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP16
		case 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;
		}
#endif
#ifdef CONFIG_VIDEO_BPP32
		case 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;
		}
#endif
		default:
			return -ENOSYS;
		}
		line -= vid_priv->line_length;
		mask >>= 1;
	}

	return 0;
}


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

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

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

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