[mirror_ubuntu-bionic-kernel.git] / drivers / video / fbdev / core / fbcon.h

/*
 *  linux/drivers/video/console/fbcon.h -- Low level frame buffer based console driver
 *
 *	Copyright (C) 1997 Geert Uytterhoeven
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License.  See the file COPYING in the main directory of this archive
 *  for more details.
 */

#ifndef _VIDEO_FBCON_H
#define _VIDEO_FBCON_H

#include <linux/types.h>
#include <linux/vt_buffer.h>
#include <linux/vt_kern.h>

#include <asm/io.h>

#define FBCON_FLAGS_INIT         1
#define FBCON_FLAGS_CURSOR_TIMER 2

   /*
    *    This is the interface between the low-level console driver and the
    *    low-level frame buffer device
    */

struct display {
    /* Filled in by the low-level console driver */
    const u_char *fontdata;
    int userfont;                   /* != 0 if fontdata kmalloc()ed */
    u_short scrollmode;             /* Scroll Method */
    u_short inverse;                /* != 0 text black on white as default */
    short yscroll;                  /* Hardware scrolling */
    int vrows;                      /* number of virtual rows */
    int cursor_shape;
    int con_rotate;
    u32 xres_virtual;
    u32 yres_virtual;
    u32 height;
    u32 width;
    u32 bits_per_pixel;
    u32 grayscale;
    u32 nonstd;
    u32 accel_flags;
    u32 rotate;
    struct fb_bitfield red;
    struct fb_bitfield green;
    struct fb_bitfield blue;
    struct fb_bitfield transp;
    const struct fb_videomode *mode;
};

struct fbcon_ops {
	void (*bmove)(struct vc_data *vc, struct fb_info *info, int sy,
		      int sx, int dy, int dx, int height, int width);
	void (*clear)(struct vc_data *vc, struct fb_info *info, int sy,
		      int sx, int height, int width);
	void (*putcs)(struct vc_data *vc, struct fb_info *info,
		      const unsigned short *s, int count, int yy, int xx,
		      int fg, int bg);
	void (*clear_margins)(struct vc_data *vc, struct fb_info *info,
			      int color, int bottom_only);
	void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode,
		       int softback_lines, int fg, int bg);
	int  (*update_start)(struct fb_info *info);
	int  (*rotate_font)(struct fb_info *info, struct vc_data *vc);
	struct fb_var_screeninfo var;  /* copy of the current fb_var_screeninfo */
	struct timer_list cursor_timer; /* Cursor timer */
	struct fb_cursor cursor_state;
	struct display *p;
	struct fb_info *info;
        int    currcon;	                /* Current VC. */
	int    cur_blink_jiffies;
	int    cursor_flash;
	int    cursor_reset;
	int    blank_state;
	int    graphics;
	int    save_graphics; /* for debug enter/leave */
	int    flags;
	int    rotate;
	int    cur_rotate;
	char  *cursor_data;
	u8    *fontbuffer;
	u8    *fontdata;
	u8    *cursor_src;
	u32    cursor_size;
	u32    fd_size;
};
    /*
     *  Attribute Decoding
     */

/* Color */
#define attr_fgcol(fgshift,s)    \
	(((s) >> (fgshift)) & 0x0f)
#define attr_bgcol(bgshift,s)    \
	(((s) >> (bgshift)) & 0x0f)

/* Monochrome */
#define attr_bold(s) \
	((s) & 0x200)
#define attr_reverse(s) \
	((s) & 0x800)
#define attr_underline(s) \
	((s) & 0x400)
#define attr_blink(s) \
	((s) & 0x8000)
	

static inline int mono_col(const struct fb_info *info)
{
	__u32 max_len;
	max_len = max(info->var.green.length, info->var.red.length);
	max_len = max(info->var.blue.length, max_len);
	return (~(0xfff << max_len)) & 0xff;
}

static inline int attr_col_ec(int shift, struct vc_data *vc,
			      struct fb_info *info, int is_fg)
{
	int is_mono01;
	int col;
	int fg;
	int bg;

	if (!vc)
		return 0;

	if (vc->vc_can_do_color)
		return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
			: attr_bgcol(shift,vc->vc_video_erase_char);

	if (!info)
		return 0;

	col = mono_col(info);
	is_mono01 = info->fix.visual == FB_VISUAL_MONO01;

	if (attr_reverse(vc->vc_video_erase_char)) {
		fg = is_mono01 ? col : 0;
		bg = is_mono01 ? 0 : col;
	}
	else {
		fg = is_mono01 ? 0 : col;
		bg = is_mono01 ? col : 0;
	}

	return is_fg ? fg : bg;
}

#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)

/* Font */
#define REFCOUNT(fd)	(((int *)(fd))[-1])
#define FNTSIZE(fd)	(((int *)(fd))[-2])
#define FNTCHARCNT(fd)	(((int *)(fd))[-3])
#define FNTSUM(fd)	(((int *)(fd))[-4])
#define FONT_EXTRA_WORDS 4

    /*
     *  Scroll Method
     */
     
/* There are several methods fbcon can use to move text around the screen:
 *
 *                     Operation   Pan    Wrap
 *---------------------------------------------
 * SCROLL_MOVE         copyarea    No     No
 * SCROLL_PAN_MOVE     copyarea    Yes    No
 * SCROLL_WRAP_MOVE    copyarea    No     Yes
 * SCROLL_REDRAW       imageblit   No     No
 * SCROLL_PAN_REDRAW   imageblit   Yes    No
 * SCROLL_WRAP_REDRAW  imageblit   No     Yes
 *
 * (SCROLL_WRAP_REDRAW is not implemented yet)
 *
 * In general, fbcon will choose the best scrolling
 * method based on the rule below:
 *
 * Pan/Wrap > accel imageblit > accel copyarea >
 * soft imageblit > (soft copyarea)
 *
 * Exception to the rule: Pan + accel copyarea is
 * preferred over Pan + accel imageblit.
 *
 * The above is typical for PCI/AGP cards. Unless
 * overridden, fbcon will never use soft copyarea.
 *
 * If you need to override the above rule, set the
 * appropriate flags in fb_info->flags.  For example,
 * to prefer copyarea over imageblit, set
 * FBINFO_READS_FAST.
 *
 * Other notes:
 * + use the hardware engine to move the text
 *    (hw-accelerated copyarea() and fillrect())
 * + use hardware-supported panning on a large virtual screen
 * + amifb can not only pan, but also wrap the display by N lines
 *    (i.e. visible line i = physical line (i+N) % yres).
 * + read what's already rendered on the screen and
 *     write it in a different place (this is cfb_copyarea())
 * + re-render the text to the screen
 *
 * Whether to use wrapping or panning can only be figured out at
 * runtime (when we know whether our font height is a multiple
 * of the pan/wrap step)
 *
 */

#define SCROLL_MOVE	   0x001
#define SCROLL_PAN_MOVE	   0x002
#define SCROLL_WRAP_MOVE   0x003
#define SCROLL_REDRAW	   0x004
#define SCROLL_PAN_REDRAW  0x005

#ifdef CONFIG_FB_TILEBLITTING
extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
#endif
extern void fbcon_set_bitops(struct fbcon_ops *ops);
extern int  soft_cursor(struct fb_info *info, struct fb_cursor *cursor);

#define FBCON_ATTRIBUTE_UNDERLINE 1
#define FBCON_ATTRIBUTE_REVERSE   2
#define FBCON_ATTRIBUTE_BOLD      4

static inline int real_y(struct display *p, int ypos)
{
	int rows = p->vrows;

	ypos += p->yscroll;
	return ypos < rows ? ypos : ypos - rows;
}


static inline int get_attribute(struct fb_info *info, u16 c)
{
	int attribute = 0;

	if (fb_get_color_depth(&info->var, &info->fix) == 1) {
		if (attr_underline(c))
			attribute |= FBCON_ATTRIBUTE_UNDERLINE;
		if (attr_reverse(c))
			attribute |= FBCON_ATTRIBUTE_REVERSE;
		if (attr_bold(c))
			attribute |= FBCON_ATTRIBUTE_BOLD;
	}

	return attribute;
}

#define FBCON_SWAP(i,r,v) ({ \
        typeof(r) _r = (r);  \
        typeof(v) _v = (v);  \
        (void) (&_r == &_v); \
        (i == FB_ROTATE_UR || i == FB_ROTATE_UD) ? _r : _v; })

#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
extern void fbcon_set_rotate(struct fbcon_ops *ops);
#else
#define fbcon_set_rotate(x) do {} while(0)
#endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */

#ifdef CONFIG_DMI
int fbcon_platform_get_rotate(struct fb_info *info);
#else
#define fbcon_platform_get_rotate(i) FB_ROTATE_UR
#endif /* CONFIG_DMI */

#endif /* _VIDEO_FBCON_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/drivers/video/console/fbcon.h -- Low level frame buffer based console driver
	3	*
	4	* Copyright (C) 1997 Geert Uytterhoeven
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file COPYING in the main directory of this archive
	8	* for more details.
	9	*/
	10
	11	#ifndef _VIDEO_FBCON_H
	12	#define _VIDEO_FBCON_H
	13
1da177e4 LT	14	#include <linux/types.h>
	15	#include <linux/vt_buffer.h>
	16	#include <linux/vt_kern.h>
	17
	18	#include <asm/io.h>
	19
88fb2c6e AD	20	#define FBCON_FLAGS_INIT 1
88fb2c6e AD	21	#define FBCON_FLAGS_CURSOR_TIMER 2
1da177e4 LT	22
	23	/*
	24	* This is the interface between the low-level console driver and the
	25	* low-level frame buffer device
	26	*/
	27
	28	struct display {
1da177e4	29	/* Filled in by the low-level console driver */
2f4516db	30	const u_char *fontdata;
1da177e4 LT	31	int userfont; /* != 0 if fontdata kmalloc()ed */
1da177e4 LT	32	u_short scrollmode; /* Scroll Method */
e4fc2761	33	u_short inverse; /* != 0 text black on white as default */
1da177e4 LT	34	short yscroll; /* Hardware scrolling */
	35	int vrows; /* number of virtual rows */
	36	int cursor_shape;
e4fc2761	37	int con_rotate;
1da177e4 LT	38	u32 xres_virtual;
	39	u32 yres_virtual;
	40	u32 height;
	41	u32 width;
	42	u32 bits_per_pixel;
	43	u32 grayscale;
	44	u32 nonstd;
	45	u32 accel_flags;
	46	u32 rotate;
	47	struct fb_bitfield red;
	48	struct fb_bitfield green;
	49	struct fb_bitfield blue;
	50	struct fb_bitfield transp;
9791d763	51	const struct fb_videomode *mode;
1da177e4 LT	52	};
	53
	54	struct fbcon_ops {
	55	void (bmove)(struct vc_data vc, struct fb_info *info, int sy,
	56	int sx, int dy, int dx, int height, int width);
	57	void (clear)(struct vc_data vc, struct fb_info *info, int sy,
	58	int sx, int height, int width);
	59	void (putcs)(struct vc_data vc, struct fb_info *info,
	60	const unsigned short *s, int count, int yy, int xx,
	61	int fg, int bg);
	62	void (clear_margins)(struct vc_data vc, struct fb_info *info,
74c1c8b3	63	int color, int bottom_only);
b73deed3 AD	64	void (cursor)(struct vc_data vc, struct fb_info *info, int mode,
b73deed3 AD	65	int softback_lines, int fg, int bg);
e4fc2761	66	int (update_start)(struct fb_info info);
b73deed3	67	int (rotate_font)(struct fb_info info, struct vc_data *vc);
e4fc2761	68	struct fb_var_screeninfo var; /* copy of the current fb_var_screeninfo */
1da177e4 LT	69	struct timer_list cursor_timer; /* Cursor timer */
1da177e4 LT	70	struct fb_cursor cursor_state;
ab767201	71	struct display *p;
6c789357	72	struct fb_info *info;
1da177e4	73	int currcon; /* Current VC. */
27a4c827	74	int cur_blink_jiffies;
1da177e4 LT	75	int cursor_flash;
	76	int cursor_reset;
	77	int blank_state;
	78	int graphics;
d219adc1	79	int save_graphics; /* for debug enter/leave */
1da177e4	80	int flags;
e4fc2761 AD	81	int rotate;
e4fc2761 AD	82	int cur_rotate;
1da177e4	83	char *cursor_data;
e4fc2761 AD	84	u8 *fontbuffer;
e4fc2761 AD	85	u8 *fontdata;
e299dd4d DJ	86	u8 *cursor_src;
e299dd4d DJ	87	u32 cursor_size;
e4fc2761	88	u32 fd_size;
1da177e4 LT	89	};
	90	/*
	91	* Attribute Decoding
	92	*/
	93
	94	/* Color */
	95	#define attr_fgcol(fgshift,s) \
	96	(((s) >> (fgshift)) & 0x0f)
	97	#define attr_bgcol(bgshift,s) \
3838f59f	98	(((s) >> (bgshift)) & 0x0f)
1da177e4 LT	99
	100	/* Monochrome */
	101	#define attr_bold(s) \
	102	((s) & 0x200)
	103	#define attr_reverse(s) \
	104	((s) & 0x800)
	105	#define attr_underline(s) \
	106	((s) & 0x400)
	107	#define attr_blink(s) \
	108	((s) & 0x8000)
	109
22af89aa HH	110
	111	static inline int mono_col(const struct fb_info *info)
	112	{
	113	__u32 max_len;
	114	max_len = max(info->var.green.length, info->var.red.length);
	115	max_len = max(info->var.blue.length, max_len);
08650869	116	return (~(0xfff << max_len)) & 0xff;
22af89aa	117	}
91c43132 TP	118
	119	static inline int attr_col_ec(int shift, struct vc_data *vc,
	120	struct fb_info *info, int is_fg)
	121	{
	122	int is_mono01;
	123	int col;
	124	int fg;
	125	int bg;
	126
	127	if (!vc)
	128	return 0;
	129
	130	if (vc->vc_can_do_color)
	131	return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
	132	: attr_bgcol(shift,vc->vc_video_erase_char);
	133
	134	if (!info)
	135	return 0;
	136
	137	col = mono_col(info);
	138	is_mono01 = info->fix.visual == FB_VISUAL_MONO01;
	139
	140	if (attr_reverse(vc->vc_video_erase_char)) {
	141	fg = is_mono01 ? col : 0;
	142	bg = is_mono01 ? 0 : col;
	143	}
	144	else {
	145	fg = is_mono01 ? 0 : col;
	146	bg = is_mono01 ? col : 0;
	147	}
	148
	149	return is_fg ? fg : bg;
	150	}
	151
cba603bf JB	152	#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
cba603bf JB	153	#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
91c43132	154
1da177e4 LT	155	/* Font */
	156	#define REFCOUNT(fd) (((int *)(fd))[-1])
	157	#define FNTSIZE(fd) (((int *)(fd))[-2])
	158	#define FNTCHARCNT(fd) (((int *)(fd))[-3])
	159	#define FNTSUM(fd) (((int *)(fd))[-4])
	160	#define FONT_EXTRA_WORDS 4
	161
	162	/*
	163	* Scroll Method
	164	*/
	165
	166	/* There are several methods fbcon can use to move text around the screen:
	167	*
	168	* Operation Pan Wrap
	169	*---------------------------------------------
	170	* SCROLL_MOVE copyarea No No
	171	* SCROLL_PAN_MOVE copyarea Yes No
	172	* SCROLL_WRAP_MOVE copyarea No Yes
	173	* SCROLL_REDRAW imageblit No No
	174	* SCROLL_PAN_REDRAW imageblit Yes No
	175	* SCROLL_WRAP_REDRAW imageblit No Yes
	176	*
	177	* (SCROLL_WRAP_REDRAW is not implemented yet)
	178	*
	179	* In general, fbcon will choose the best scrolling
	180	* method based on the rule below:
	181	*
	182	* Pan/Wrap > accel imageblit > accel copyarea >
	183	* soft imageblit > (soft copyarea)
	184	*
	185	* Exception to the rule: Pan + accel copyarea is
	186	* preferred over Pan + accel imageblit.
	187	*
	188	* The above is typical for PCI/AGP cards. Unless
	189	* overridden, fbcon will never use soft copyarea.
	190	*
	191	* If you need to override the above rule, set the
	192	* appropriate flags in fb_info->flags. For example,
	193	* to prefer copyarea over imageblit, set
	194	* FBINFO_READS_FAST.
	195	*
	196	* Other notes:
	197	* + use the hardware engine to move the text
	198	* (hw-accelerated copyarea() and fillrect())
	199	* + use hardware-supported panning on a large virtual screen
	200	* + amifb can not only pan, but also wrap the display by N lines
	201	* (i.e. visible line i = physical line (i+N) % yres).
	202	* + read what's already rendered on the screen and
	203	* write it in a different place (this is cfb_copyarea())
	204	* + re-render the text to the screen
	205	*
	206	* Whether to use wrapping or panning can only be figured out at
	207	* runtime (when we know whether our font height is a multiple
	208	* of the pan/wrap step)
	209	*
	210	*/
	211
	212	#define SCROLL_MOVE 0x001
	213	#define SCROLL_PAN_MOVE 0x002
	214	#define SCROLL_WRAP_MOVE 0x003
	215	#define SCROLL_REDRAW 0x004
	216	#define SCROLL_PAN_REDRAW 0x005
	217
	218	#ifdef CONFIG_FB_TILEBLITTING
b73deed3	219	extern void fbcon_set_tileops(struct vc_data vc, struct fb_info info);
1da177e4 LT	220	#endif
1da177e4 LT	221	extern void fbcon_set_bitops(struct fbcon_ops *ops);
c465e05a	222	extern int soft_cursor(struct fb_info info, struct fb_cursor cursor);
e4fc2761 AD	223
	224	#define FBCON_ATTRIBUTE_UNDERLINE 1
	225	#define FBCON_ATTRIBUTE_REVERSE 2
	226	#define FBCON_ATTRIBUTE_BOLD 4
	227
	228	static inline int real_y(struct display *p, int ypos)
	229	{
	230	int rows = p->vrows;
	231
	232	ypos += p->yscroll;
	233	return ypos < rows ? ypos : ypos - rows;
	234	}
	235
	236
	237	static inline int get_attribute(struct fb_info *info, u16 c)
	238	{
	239	int attribute = 0;
	240
	241	if (fb_get_color_depth(&info->var, &info->fix) == 1) {
	242	if (attr_underline(c))
	243	attribute \|= FBCON_ATTRIBUTE_UNDERLINE;
	244	if (attr_reverse(c))
	245	attribute \|= FBCON_ATTRIBUTE_REVERSE;
	246	if (attr_bold(c))
	247	attribute \|= FBCON_ATTRIBUTE_BOLD;
	248	}
	249
	250	return attribute;
	251	}
	252
	253	#define FBCON_SWAP(i,r,v) ({ \
	254	typeof(r) _r = (r); \
	255	typeof(v) _v = (v); \
	256	(void) (&_r == &_v); \
	257	(i == FB_ROTATE_UR \|\| i == FB_ROTATE_UD) ? _r : _v; })
	258
6cc50e1c AD	259	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
	260	extern void fbcon_set_rotate(struct fbcon_ops *ops);
	261	#else
e4fc2761	262	#define fbcon_set_rotate(x) do {} while(0)
6cc50e1c	263	#endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */
e4fc2761	264
b0d8e409 HG	265	#ifdef CONFIG_DMI
	266	int fbcon_platform_get_rotate(struct fb_info *info);
	267	#else
	268	#define fbcon_platform_get_rotate(i) FB_ROTATE_UR
	269	#endif /* CONFIG_DMI */
e4fc2761	270
b0d8e409	271	#endif /* _VIDEO_FBCON_H */