[J-u-boot.git] / include / video_console.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright (c) 2015 Google, Inc
 */

#ifndef __video_console_h
#define __video_console_h

#include <video.h>

struct video_priv;

#define VID_FRAC_DIV	256

#define VID_TO_PIXEL(x)	((x) / VID_FRAC_DIV)
#define VID_TO_POS(x)	((x) * VID_FRAC_DIV)

/*
 * The 16 colors supported by the console
 */
enum color_idx {
	VID_BLACK = 0,
	VID_RED,
	VID_GREEN,
	VID_BROWN,
	VID_BLUE,
	VID_MAGENTA,
	VID_CYAN,
	VID_LIGHT_GRAY,
	VID_GRAY,
	VID_LIGHT_RED,
	VID_LIGTH_GREEN,
	VID_YELLOW,
	VID_LIGHT_BLUE,
	VID_LIGHT_MAGENTA,
	VID_LIGHT_CYAN,
	VID_WHITE,

	VID_COLOR_COUNT
};

/**
 * struct vidconsole_priv - uclass-private data about a console device
 *
 * Drivers must set up @rows, @cols, @x_charsize, @y_charsize in their probe()
 * method. Drivers may set up @xstart_frac if desired.
 *
 * @sdev:		stdio device, acting as an output sink
 * @xcur_frac:		Current X position, in fractional units (VID_TO_POS(x))
 * @ycur:		Current Y position in pixels (0=top)
 * @rows:		Number of text rows
 * @cols:		Number of text columns
 * @x_charsize:		Character width in pixels
 * @y_charsize:		Character height in pixels
 * @tab_width_frac:	Tab width in fractional units
 * @xsize_frac:		Width of the display in fractional units
 * @xstart_frac:	Left margin for the text console in fractional units
 * @last_ch:		Last character written to the text console on this line
 * @escape:		TRUE if currently accumulating an ANSI escape sequence
 * @escape_len:		Length of accumulated escape sequence so far
 * @col_saved:		Saved X position, in fractional units (VID_TO_POS(x))
 * @row_saved:		Saved Y position in pixels (0=top)
 * @escape_buf:		Buffer to accumulate escape sequence
 */
struct vidconsole_priv {
	struct stdio_dev sdev;
	int xcur_frac;
	int ycur;
	int rows;
	int cols;
	int x_charsize;
	int y_charsize;
	int tab_width_frac;
	int xsize_frac;
	int xstart_frac;
	int last_ch;
	/*
	 * ANSI escape sequences are accumulated character by character,
	 * starting after the ESC char (0x1b) until the entire sequence
	 * is consumed at which point it is acted upon.
	 */
	int escape;
	int escape_len;
	int row_saved;
	int col_saved;
	char escape_buf[32];
};

/**
 * struct vidconsole_ops - Video console operations
 *
 * These operations work on either an absolute console position (measured
 * in pixels) or a text row number (measured in rows, where each row consists
 * of an entire line of text - typically 16 pixels).
 */
struct vidconsole_ops {
	/**
	 * putc_xy() - write a single character to a position
	 *
	 * @dev:	Device to write to
	 * @x_frac:	Fractional pixel X position (0=left-most pixel) which
	 *		is the X position multipled by VID_FRAC_DIV.
	 * @y:		Pixel Y position (0=top-most pixel)
	 * @ch:		Character to write
	 * @return number of fractional pixels that the cursor should move,
	 * if all is OK, -EAGAIN if we ran out of space on this line, other -ve
	 * on error
	 */
	int (*putc_xy)(struct udevice *dev, uint x_frac, uint y, char ch);

	/**
	 * move_rows() - Move text rows from one place to another
	 *
	 * @dev:	Device to adjust
	 * @rowdst:	Destination text row (0=top)
	 * @rowsrc:	Source start text row
	 * @count:	Number of text rows to move
	 * @return 0 if OK, -ve on error
	 */
	int (*move_rows)(struct udevice *dev, uint rowdst, uint rowsrc,
			  uint count);

	/**
	 * set_row() - Set the colour of a text row
	 *
	 * Every pixel contained within the text row is adjusted
	 *
	 * @dev:	Device to adjust
	 * @row:	Text row to adjust (0=top)
	 * @clr:	Raw colour (pixel value) to write to each pixel
	 * @return 0 if OK, -ve on error
	 */
	int (*set_row)(struct udevice *dev, uint row, int clr);

	/**
	 * entry_start() - Indicate that text entry is starting afresh
	 *
	 * Consoles which use proportional fonts need to track the position of
	 * each character output so that backspace will return to the correct
	 * place. This method signals to the console driver that a new entry
	 * line is being start (e.g. the user pressed return to start a new
	 * command). The driver can use this signal to empty its list of
	 * positions.
	 */
	int (*entry_start)(struct udevice *dev);

	/**
	 * backspace() - Handle erasing the last character
	 *
	 * With proportional fonts the vidconsole uclass cannot itself erase
	 * the previous character. This optional method will be called when
	 * a backspace is needed. The driver should erase the previous
	 * character and update the cursor position (xcur_frac, ycur) to the
	 * start of the previous character.
	 *
	 * If not implement, default behaviour will work for fixed-width
	 * characters.
	 */
	int (*backspace)(struct udevice *dev);
};

/* Get a pointer to the driver operations for a video console device */
#define vidconsole_get_ops(dev)  ((struct vidconsole_ops *)(dev)->driver->ops)

/**
 * vidconsole_putc_xy() - write a single character to a position
 *
 * @dev:	Device to write to
 * @x_frac:	Fractional pixel X position (0=left-most pixel) which
 *		is the X position multipled by VID_FRAC_DIV.
 * @y:		Pixel Y position (0=top-most pixel)
 * @ch:		Character to write
 * @return number of fractional pixels that the cursor should move,
 * if all is OK, -EAGAIN if we ran out of space on this line, other -ve
 * on error
 */
int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch);

/**
 * vidconsole_move_rows() - Move text rows from one place to another
 *
 * @dev:	Device to adjust
 * @rowdst:	Destination text row (0=top)
 * @rowsrc:	Source start text row
 * @count:	Number of text rows to move
 * @return 0 if OK, -ve on error
 */
int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
			 uint count);

/**
 * vidconsole_set_row() - Set the colour of a text row
 *
 * Every pixel contained within the text row is adjusted
 *
 * @dev:	Device to adjust
 * @row:	Text row to adjust (0=top)
 * @clr:	Raw colour (pixel value) to write to each pixel
 * @return 0 if OK, -ve on error
 */
int vidconsole_set_row(struct udevice *dev, uint row, int clr);

/**
 * vidconsole_put_char() - Output a character to the current console position
 *
 * Outputs a character to the console and advances the cursor. This function
 * handles wrapping to new lines and scrolling the console. Special
 * characters are handled also: \n, \r, \b and \t.
 *
 * The device always starts with the cursor at position 0,0 (top left). It
 * can be adjusted manually using vidconsole_position_cursor().
 *
 * @dev:	Device to adjust
 * @ch:		Character to write
 * @return 0 if OK, -ve on error
 */
int vidconsole_put_char(struct udevice *dev, char ch);

/**
 * vidconsole_put_string() - Output a string to the current console position
 *
 * Outputs a string to the console and advances the cursor. This function
 * handles wrapping to new lines and scrolling the console. Special
 * characters are handled also: \n, \r, \b and \t.
 *
 * The device always starts with the cursor at position 0,0 (top left). It
 * can be adjusted manually using vidconsole_position_cursor().
 *
 * @dev:	Device to adjust
 * @str:	String to write
 * @return 0 if OK, -ve on error
 */
int vidconsole_put_string(struct udevice *dev, const char *str);

/**
 * vidconsole_position_cursor() - Move the text cursor
 *
 * @dev:	Device to adjust
 * @col:	New cursor text column
 * @row:	New cursor text row
 * @return 0 if OK, -ve on error
 */
void vidconsole_position_cursor(struct udevice *dev, unsigned col,
				unsigned row);

/**
 * vid_console_color() - convert a color code to a pixel's internal
 * representation
 *
 * The caller has to guarantee that the color index is less than
 * VID_COLOR_COUNT.
 *
 * @priv	private data of the console device
 * @idx		color index
 * @return	color value
 */
u32 vid_console_color(struct video_priv *priv, unsigned int idx);

#ifdef CONFIG_VIDEO_COPY
/**
 * vidconsole_sync_copy() - Sync back to the copy framebuffer
 *
 * This ensures that the copy framebuffer has the same data as the framebuffer
 * for a particular region. It should be called after the framebuffer is updated
 *
 * @from and @to can be in either order. The region between them is synced.
 *
 * @dev: Vidconsole device being updated
 * @from: Start/end address within the framebuffer (->fb)
 * @to: Other address within the frame buffer
 * @return 0 if OK, -EFAULT if the start address is before the start of the
 *	frame buffer start
 */
int vidconsole_sync_copy(struct udevice *dev, void *from, void *to);

/**
 * vidconsole_memmove() - Perform a memmove() within the frame buffer
 *
 * This handles a memmove(), e.g. for scrolling. It also updates the copy
 * framebuffer.
 *
 * @dev: Vidconsole device being updated
 * @dst: Destination address within the framebuffer (->fb)
 * @src: Source address within the framebuffer (->fb)
 * @size: Number of bytes to transfer
 * @return 0 if OK, -EFAULT if the start address is before the start of the
 *	frame buffer start
 */
int vidconsole_memmove(struct udevice *dev, void *dst, const void *src,
		       int size);
#else
static inline int vidconsole_sync_copy(struct udevice *dev, void *from,
				       void *to)
{
	return 0;
}

static inline int vidconsole_memmove(struct udevice *dev, void *dst,
				     const void *src, int size)
{
	memmove(dst, src, size);

	return 0;
}

#endif

#endif
Commit	Line	Data
83d290c5	1	/* SPDX-License-Identifier: GPL-2.0+ */
83510766 SG	2	/*
83510766 SG	3	* Copyright (c) 2015 Google, Inc
83510766 SG	4	*/
	5
	6	#ifndef __video_console_h
	7	#define __video_console_h
	8
5c30fbb8 HS	9	#include <video.h>
5c30fbb8 HS	10
2d7c268b SG	11	struct video_priv;
2d7c268b SG	12
f2661786 SG	13	#define VID_FRAC_DIV 256
	14
	15	#define VID_TO_PIXEL(x) ((x) / VID_FRAC_DIV)
	16	#define VID_TO_POS(x) ((x) * VID_FRAC_DIV)
	17
5c30fbb8	18	/*
9ffa4d12	19	* The 16 colors supported by the console
5c30fbb8 HS	20	*/
	21	enum color_idx {
	22	VID_BLACK = 0,
	23	VID_RED,
	24	VID_GREEN,
9ffa4d12	25	VID_BROWN,
5c30fbb8 HS	26	VID_BLUE,
	27	VID_MAGENTA,
	28	VID_CYAN,
9ffa4d12 HS	29	VID_LIGHT_GRAY,
	30	VID_GRAY,
	31	VID_LIGHT_RED,
	32	VID_LIGTH_GREEN,
	33	VID_YELLOW,
	34	VID_LIGHT_BLUE,
	35	VID_LIGHT_MAGENTA,
	36	VID_LIGHT_CYAN,
5c30fbb8 HS	37	VID_WHITE,
	38
	39	VID_COLOR_COUNT
	40	};
	41
83510766 SG	42	/**
	43	* struct vidconsole_priv - uclass-private data about a console device
	44	*
f2661786 SG	45	* Drivers must set up @rows, @cols, @x_charsize, @y_charsize in their probe()
	46	* method. Drivers may set up @xstart_frac if desired.
	47	*
662f381a HS	48	* @sdev: stdio device, acting as an output sink
	49	* @xcur_frac: Current X position, in fractional units (VID_TO_POS(x))
	50	* @ycur: Current Y position in pixels (0=top)
	51	* @rows: Number of text rows
	52	* @cols: Number of text columns
	53	* @x_charsize: Character width in pixels
	54	* @y_charsize: Character height in pixels
f2661786	55	* @tab_width_frac: Tab width in fractional units
662f381a	56	* @xsize_frac: Width of the display in fractional units
c5b77d01	57	* @xstart_frac: Left margin for the text console in fractional units
662f381a HS	58	* @last_ch: Last character written to the text console on this line
	59	* @escape: TRUE if currently accumulating an ANSI escape sequence
	60	* @escape_len: Length of accumulated escape sequence so far
	61	* @col_saved: Saved X position, in fractional units (VID_TO_POS(x))
	62	* @row_saved: Saved Y position in pixels (0=top)
	63	* @escape_buf: Buffer to accumulate escape sequence
83510766 SG	64	*/
	65	struct vidconsole_priv {
	66	struct stdio_dev sdev;
f2661786 SG	67	int xcur_frac;
f2661786 SG	68	int ycur;
83510766 SG	69	int rows;
83510766 SG	70	int cols;
f2661786 SG	71	int x_charsize;
	72	int y_charsize;
	73	int tab_width_frac;
	74	int xsize_frac;
c5b77d01	75	int xstart_frac;
58c733a7	76	int last_ch;
a085aa1f RC	77	/*
	78	* ANSI escape sequences are accumulated character by character,
	79	* starting after the ESC char (0x1b) until the entire sequence
	80	* is consumed at which point it is acted upon.
	81	*/
	82	int escape;
	83	int escape_len;
662f381a HS	84	int row_saved;
662f381a HS	85	int col_saved;
a085aa1f	86	char escape_buf[32];
83510766 SG	87	};
	88
	89	/**
	90	* struct vidconsole_ops - Video console operations
	91	*
	92	* These operations work on either an absolute console position (measured
	93	* in pixels) or a text row number (measured in rows, where each row consists
	94	* of an entire line of text - typically 16 pixels).
	95	*/
	96	struct vidconsole_ops {
	97	/**
	98	* putc_xy() - write a single character to a position
	99	*
	100	* @dev: Device to write to
f2661786 SG	101	* @x_frac: Fractional pixel X position (0=left-most pixel) which
f2661786 SG	102	* is the X position multipled by VID_FRAC_DIV.
83510766 SG	103	* @y: Pixel Y position (0=top-most pixel)
83510766 SG	104	* @ch: Character to write
f2661786 SG	105	* @return number of fractional pixels that the cursor should move,
	106	* if all is OK, -EAGAIN if we ran out of space on this line, other -ve
	107	* on error
83510766	108	*/
f2661786	109	int (putc_xy)(struct udevice dev, uint x_frac, uint y, char ch);
83510766 SG	110
	111	/**
	112	* move_rows() - Move text rows from one place to another
	113	*
	114	* @dev: Device to adjust
	115	* @rowdst: Destination text row (0=top)
	116	* @rowsrc: Source start text row
	117	* @count: Number of text rows to move
	118	* @return 0 if OK, -ve on error
	119	*/
	120	int (move_rows)(struct udevice dev, uint rowdst, uint rowsrc,
	121	uint count);
	122
	123	/**
	124	* set_row() - Set the colour of a text row
	125	*
	126	* Every pixel contained within the text row is adjusted
	127	*
	128	* @dev: Device to adjust
	129	* @row: Text row to adjust (0=top)
	130	* @clr: Raw colour (pixel value) to write to each pixel
	131	* @return 0 if OK, -ve on error
	132	*/
	133	int (set_row)(struct udevice dev, uint row, int clr);
58c733a7 SG	134
	135	/**
	136	* entry_start() - Indicate that text entry is starting afresh
	137	*
	138	* Consoles which use proportional fonts need to track the position of
	139	* each character output so that backspace will return to the correct
	140	* place. This method signals to the console driver that a new entry
	141	* line is being start (e.g. the user pressed return to start a new
	142	* command). The driver can use this signal to empty its list of
	143	* positions.
	144	*/
	145	int (entry_start)(struct udevice dev);
7b9f7e44 SG	146
	147	/**
	148	* backspace() - Handle erasing the last character
	149	*
	150	* With proportional fonts the vidconsole uclass cannot itself erase
	151	* the previous character. This optional method will be called when
	152	* a backspace is needed. The driver should erase the previous
	153	* character and update the cursor position (xcur_frac, ycur) to the
	154	* start of the previous character.
	155	*
	156	* If not implement, default behaviour will work for fixed-width
	157	* characters.
	158	*/
	159	int (backspace)(struct udevice dev);
83510766 SG	160	};
	161
	162	/* Get a pointer to the driver operations for a video console device */
	163	#define vidconsole_get_ops(dev) ((struct vidconsole_ops *)(dev)->driver->ops)
	164
	165	/**
	166	* vidconsole_putc_xy() - write a single character to a position
	167	*
	168	* @dev: Device to write to
f2661786 SG	169	* @x_frac: Fractional pixel X position (0=left-most pixel) which
f2661786 SG	170	* is the X position multipled by VID_FRAC_DIV.
83510766 SG	171	* @y: Pixel Y position (0=top-most pixel)
83510766 SG	172	* @ch: Character to write
f2661786 SG	173	* @return number of fractional pixels that the cursor should move,
	174	* if all is OK, -EAGAIN if we ran out of space on this line, other -ve
	175	* on error
83510766 SG	176	*/
	177	int vidconsole_putc_xy(struct udevice *dev, uint x, uint y, char ch);
	178
	179	/**
	180	* vidconsole_move_rows() - Move text rows from one place to another
	181	*
	182	* @dev: Device to adjust
	183	* @rowdst: Destination text row (0=top)
	184	* @rowsrc: Source start text row
	185	* @count: Number of text rows to move
	186	* @return 0 if OK, -ve on error
	187	*/
	188	int vidconsole_move_rows(struct udevice *dev, uint rowdst, uint rowsrc,
	189	uint count);
	190
	191	/**
	192	* vidconsole_set_row() - Set the colour of a text row
	193	*
	194	* Every pixel contained within the text row is adjusted
	195	*
	196	* @dev: Device to adjust
	197	* @row: Text row to adjust (0=top)
	198	* @clr: Raw colour (pixel value) to write to each pixel
	199	* @return 0 if OK, -ve on error
	200	*/
	201	int vidconsole_set_row(struct udevice *dev, uint row, int clr);
	202
	203	/**
	204	* vidconsole_put_char() - Output a character to the current console position
	205	*
	206	* Outputs a character to the console and advances the cursor. This function
	207	* handles wrapping to new lines and scrolling the console. Special
	208	* characters are handled also: \n, \r, \b and \t.
	209	*
	210	* The device always starts with the cursor at position 0,0 (top left). It
	211	* can be adjusted manually using vidconsole_position_cursor().
	212	*
	213	* @dev: Device to adjust
	214	* @ch: Character to write
	215	* @return 0 if OK, -ve on error
	216	*/
	217	int vidconsole_put_char(struct udevice *dev, char ch);
	218
e63168a9 MV	219	/**
	220	* vidconsole_put_string() - Output a string to the current console position
	221	*
	222	* Outputs a string to the console and advances the cursor. This function
	223	* handles wrapping to new lines and scrolling the console. Special
	224	* characters are handled also: \n, \r, \b and \t.
	225	*
	226	* The device always starts with the cursor at position 0,0 (top left). It
	227	* can be adjusted manually using vidconsole_position_cursor().
	228	*
	229	* @dev: Device to adjust
	230	* @str: String to write
	231	* @return 0 if OK, -ve on error
	232	*/
	233	int vidconsole_put_string(struct udevice dev, const char str);
	234
83510766 SG	235	/**
	236	* vidconsole_position_cursor() - Move the text cursor
	237	*
	238	* @dev: Device to adjust
	239	* @col: New cursor text column
	240	* @row: New cursor text row
	241	* @return 0 if OK, -ve on error
	242	*/
	243	void vidconsole_position_cursor(struct udevice *dev, unsigned col,
	244	unsigned row);
	245
5c30fbb8 HS	246	/**
	247	* vid_console_color() - convert a color code to a pixel's internal
	248	* representation
	249	*
	250	* The caller has to guarantee that the color index is less than
	251	* VID_COLOR_COUNT.
	252	*
	253	* @priv private data of the console device
	254	* @idx color index
	255	* @return color value
	256	*/
	257	u32 vid_console_color(struct video_priv *priv, unsigned int idx);
	258
8c0b5d26 SG	259	#ifdef CONFIG_VIDEO_COPY
	260	/**
	261	* vidconsole_sync_copy() - Sync back to the copy framebuffer
	262	*
	263	* This ensures that the copy framebuffer has the same data as the framebuffer
	264	* for a particular region. It should be called after the framebuffer is updated
	265	*
	266	* @from and @to can be in either order. The region between them is synced.
	267	*
	268	* @dev: Vidconsole device being updated
	269	* @from: Start/end address within the framebuffer (->fb)
	270	* @to: Other address within the frame buffer
	271	* @return 0 if OK, -EFAULT if the start address is before the start of the
	272	* frame buffer start
	273	*/
	274	int vidconsole_sync_copy(struct udevice dev, void from, void *to);
	275
	276	/**
	277	* vidconsole_memmove() - Perform a memmove() within the frame buffer
	278	*
	279	* This handles a memmove(), e.g. for scrolling. It also updates the copy
	280	* framebuffer.
	281	*
	282	* @dev: Vidconsole device being updated
	283	* @dst: Destination address within the framebuffer (->fb)
	284	* @src: Source address within the framebuffer (->fb)
	285	* @size: Number of bytes to transfer
	286	* @return 0 if OK, -EFAULT if the start address is before the start of the
	287	* frame buffer start
	288	*/
	289	int vidconsole_memmove(struct udevice dev, void dst, const void *src,
	290	int size);
	291	#else
	292	static inline int vidconsole_sync_copy(struct udevice dev, void from,
	293	void *to)
	294	{
	295	return 0;
	296	}
	297
	298	static inline int vidconsole_memmove(struct udevice dev, void dst,
	299	const void *src, int size)
	300	{
	301	memmove(dst, src, size);
	302
	303	return 0;
	304	}
	305
	306	#endif
	307
5c30fbb8	308	#endif