[deliverable/linux.git] / drivers / video / console / 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 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;
        int    currcon;	                /* Current VC. */
	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 */

#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,
	63	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;
1da177e4 LT	72	int currcon; /* Current VC. */
	73	int cursor_flash;
	74	int cursor_reset;
	75	int blank_state;
	76	int graphics;
d219adc1	77	int save_graphics; /* for debug enter/leave */
1da177e4	78	int flags;
e4fc2761 AD	79	int rotate;
e4fc2761 AD	80	int cur_rotate;
1da177e4	81	char *cursor_data;
e4fc2761 AD	82	u8 *fontbuffer;
e4fc2761 AD	83	u8 *fontdata;
e299dd4d DJ	84	u8 *cursor_src;
e299dd4d DJ	85	u32 cursor_size;
e4fc2761	86	u32 fd_size;
1da177e4 LT	87	};
	88	/*
	89	* Attribute Decoding
	90	*/
	91
	92	/* Color */
	93	#define attr_fgcol(fgshift,s) \
	94	(((s) >> (fgshift)) & 0x0f)
	95	#define attr_bgcol(bgshift,s) \
3838f59f	96	(((s) >> (bgshift)) & 0x0f)
1da177e4 LT	97
	98	/* Monochrome */
	99	#define attr_bold(s) \
	100	((s) & 0x200)
	101	#define attr_reverse(s) \
	102	((s) & 0x800)
	103	#define attr_underline(s) \
	104	((s) & 0x400)
	105	#define attr_blink(s) \
	106	((s) & 0x8000)
	107
22af89aa HH	108
	109	static inline int mono_col(const struct fb_info *info)
	110	{
	111	__u32 max_len;
	112	max_len = max(info->var.green.length, info->var.red.length);
	113	max_len = max(info->var.blue.length, max_len);
08650869	114	return (~(0xfff << max_len)) & 0xff;
22af89aa	115	}
91c43132 TP	116
	117	static inline int attr_col_ec(int shift, struct vc_data *vc,
	118	struct fb_info *info, int is_fg)
	119	{
	120	int is_mono01;
	121	int col;
	122	int fg;
	123	int bg;
	124
	125	if (!vc)
	126	return 0;
	127
	128	if (vc->vc_can_do_color)
	129	return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
	130	: attr_bgcol(shift,vc->vc_video_erase_char);
	131
	132	if (!info)
	133	return 0;
	134
	135	col = mono_col(info);
	136	is_mono01 = info->fix.visual == FB_VISUAL_MONO01;
	137
	138	if (attr_reverse(vc->vc_video_erase_char)) {
	139	fg = is_mono01 ? col : 0;
	140	bg = is_mono01 ? 0 : col;
	141	}
	142	else {
	143	fg = is_mono01 ? 0 : col;
	144	bg = is_mono01 ? col : 0;
	145	}
	146
	147	return is_fg ? fg : bg;
	148	}
	149
cba603bf JB	150	#define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
cba603bf JB	151	#define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
91c43132	152
1da177e4 LT	153	/* Font */
	154	#define REFCOUNT(fd) (((int *)(fd))[-1])
	155	#define FNTSIZE(fd) (((int *)(fd))[-2])
	156	#define FNTCHARCNT(fd) (((int *)(fd))[-3])
	157	#define FNTSUM(fd) (((int *)(fd))[-4])
	158	#define FONT_EXTRA_WORDS 4
	159
	160	/*
	161	* Scroll Method
	162	*/
	163
	164	/* There are several methods fbcon can use to move text around the screen:
	165	*
	166	* Operation Pan Wrap
	167	*---------------------------------------------
	168	* SCROLL_MOVE copyarea No No
	169	* SCROLL_PAN_MOVE copyarea Yes No
	170	* SCROLL_WRAP_MOVE copyarea No Yes
	171	* SCROLL_REDRAW imageblit No No
	172	* SCROLL_PAN_REDRAW imageblit Yes No
	173	* SCROLL_WRAP_REDRAW imageblit No Yes
	174	*
	175	* (SCROLL_WRAP_REDRAW is not implemented yet)
	176	*
	177	* In general, fbcon will choose the best scrolling
	178	* method based on the rule below:
	179	*
	180	* Pan/Wrap > accel imageblit > accel copyarea >
	181	* soft imageblit > (soft copyarea)
	182	*
	183	* Exception to the rule: Pan + accel copyarea is
	184	* preferred over Pan + accel imageblit.
	185	*
	186	* The above is typical for PCI/AGP cards. Unless
	187	* overridden, fbcon will never use soft copyarea.
	188	*
	189	* If you need to override the above rule, set the
	190	* appropriate flags in fb_info->flags. For example,
	191	* to prefer copyarea over imageblit, set
	192	* FBINFO_READS_FAST.
	193	*
	194	* Other notes:
	195	* + use the hardware engine to move the text
	196	* (hw-accelerated copyarea() and fillrect())
	197	* + use hardware-supported panning on a large virtual screen
	198	* + amifb can not only pan, but also wrap the display by N lines
	199	* (i.e. visible line i = physical line (i+N) % yres).
	200	* + read what's already rendered on the screen and
	201	* write it in a different place (this is cfb_copyarea())
	202	* + re-render the text to the screen
	203	*
	204	* Whether to use wrapping or panning can only be figured out at
	205	* runtime (when we know whether our font height is a multiple
	206	* of the pan/wrap step)
	207	*
	208	*/
	209
	210	#define SCROLL_MOVE 0x001
	211	#define SCROLL_PAN_MOVE 0x002
	212	#define SCROLL_WRAP_MOVE 0x003
	213	#define SCROLL_REDRAW 0x004
	214	#define SCROLL_PAN_REDRAW 0x005
	215
	216	#ifdef CONFIG_FB_TILEBLITTING
b73deed3	217	extern void fbcon_set_tileops(struct vc_data vc, struct fb_info info);
1da177e4 LT	218	#endif
1da177e4 LT	219	extern void fbcon_set_bitops(struct fbcon_ops *ops);
c465e05a	220	extern int soft_cursor(struct fb_info info, struct fb_cursor cursor);
e4fc2761 AD	221
	222	#define FBCON_ATTRIBUTE_UNDERLINE 1
	223	#define FBCON_ATTRIBUTE_REVERSE 2
	224	#define FBCON_ATTRIBUTE_BOLD 4
	225
	226	static inline int real_y(struct display *p, int ypos)
	227	{
	228	int rows = p->vrows;
	229
	230	ypos += p->yscroll;
	231	return ypos < rows ? ypos : ypos - rows;
	232	}
	233
	234
	235	static inline int get_attribute(struct fb_info *info, u16 c)
	236	{
	237	int attribute = 0;
	238
	239	if (fb_get_color_depth(&info->var, &info->fix) == 1) {
	240	if (attr_underline(c))
	241	attribute \|= FBCON_ATTRIBUTE_UNDERLINE;
	242	if (attr_reverse(c))
	243	attribute \|= FBCON_ATTRIBUTE_REVERSE;
	244	if (attr_bold(c))
	245	attribute \|= FBCON_ATTRIBUTE_BOLD;
	246	}
	247
	248	return attribute;
	249	}
	250
	251	#define FBCON_SWAP(i,r,v) ({ \
	252	typeof(r) _r = (r); \
	253	typeof(v) _v = (v); \
	254	(void) (&_r == &_v); \
	255	(i == FB_ROTATE_UR \|\| i == FB_ROTATE_UD) ? _r : _v; })
	256
6cc50e1c AD	257	#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
	258	extern void fbcon_set_rotate(struct fbcon_ops *ops);
	259	#else
e4fc2761	260	#define fbcon_set_rotate(x) do {} while(0)
6cc50e1c	261	#endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */
e4fc2761	262
1da177e4	263	#endif /* _VIDEO_FBCON_H */
e4fc2761	264