Commit a6adbbc4 authored by Thomas Zimmermann's avatar Thomas Zimmermann
Browse files

fbcon: Rename struct fbcon_ops to struct fbcon_par 



The type struct fbcon_ops contains fbcon state and callbacks. As the
callbacks will be removed from struct fbcon_ops, rename the data type
to struct fbcon_par. Also rename the variables from ops to par.

The _par postfix ("private access registers") is used throughout the
fbdev subsystem for per-driver state. The fbcon pointer within struct
fb_info is also named fbcon_par. Hence, the new naming fits existing
practice.

v2:
- rename struct fbcon_ops to struct fbcon_par
- fix build for CONFIG_FB_TILEBITTING=n (kernel test robot)
- fix indention

Signed-off-by: default avatarThomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: default avatarSam Ravnborg <sam@ravnborg.org>
Link: https://lore.kernel.org/r/20250909124616.143365-3-tzimmermann@suse.de
parent 20fd6b1b

drivers/video/fbdev/core/bitblit.c

+61 −61
Original line number Diff line number Diff line
@@ -236,10 +236,10 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		       int fg, int bg)

{

	struct fb_cursor cursor;

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;

	int w = DIV_ROUND_UP(vc->vc_font.width, 8), c;

	int y = real_y(ops->p, vc->state.y);

	int y = real_y(par->p, vc->state.y);

	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;

	int err = 1;

	char *src;
@@ -253,9 +253,9 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
	attribute = get_attribute(info, c);

	src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height));



	if (ops->cursor_state.image.data != src ||

	    ops->cursor_reset) {

	    ops->cursor_state.image.data = src;

	if (par->cursor_state.image.data != src ||

	    par->cursor_reset) {

		par->cursor_state.image.data = src;

		cursor.set |= FB_CUR_SETIMAGE;

	}
@@ -265,46 +265,46 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		dst = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC);

		if (!dst)

			return;

		kfree(ops->cursor_data);

		ops->cursor_data = dst;

		kfree(par->cursor_data);

		par->cursor_data = dst;

		update_attr(dst, src, attribute, vc);

		src = dst;

	}



	if (ops->cursor_state.image.fg_color != fg ||

	    ops->cursor_state.image.bg_color != bg ||

	    ops->cursor_reset) {

		ops->cursor_state.image.fg_color = fg;

		ops->cursor_state.image.bg_color = bg;

	if (par->cursor_state.image.fg_color != fg ||

	    par->cursor_state.image.bg_color != bg ||

	    par->cursor_reset) {

		par->cursor_state.image.fg_color = fg;

		par->cursor_state.image.bg_color = bg;

		cursor.set |= FB_CUR_SETCMAP;

	}



	if ((ops->cursor_state.image.dx != (vc->vc_font.width * vc->state.x)) ||

	    (ops->cursor_state.image.dy != (vc->vc_font.height * y)) ||

	    ops->cursor_reset) {

		ops->cursor_state.image.dx = vc->vc_font.width * vc->state.x;

		ops->cursor_state.image.dy = vc->vc_font.height * y;

	if ((par->cursor_state.image.dx != (vc->vc_font.width * vc->state.x)) ||

	    (par->cursor_state.image.dy != (vc->vc_font.height * y)) ||

	    par->cursor_reset) {

		par->cursor_state.image.dx = vc->vc_font.width * vc->state.x;

		par->cursor_state.image.dy = vc->vc_font.height * y;

		cursor.set |= FB_CUR_SETPOS;

	}



	if (ops->cursor_state.image.height != vc->vc_font.height ||

	    ops->cursor_state.image.width != vc->vc_font.width ||

	    ops->cursor_reset) {

		ops->cursor_state.image.height = vc->vc_font.height;

		ops->cursor_state.image.width = vc->vc_font.width;

	if (par->cursor_state.image.height != vc->vc_font.height ||

	    par->cursor_state.image.width != vc->vc_font.width ||

	    par->cursor_reset) {

		par->cursor_state.image.height = vc->vc_font.height;

		par->cursor_state.image.width = vc->vc_font.width;

		cursor.set |= FB_CUR_SETSIZE;

	}



	if (ops->cursor_state.hot.x || ops->cursor_state.hot.y ||

	    ops->cursor_reset) {

		ops->cursor_state.hot.x = cursor.hot.y = 0;

	if (par->cursor_state.hot.x || par->cursor_state.hot.y ||

	    par->cursor_reset) {

		par->cursor_state.hot.x = cursor.hot.y = 0;

		cursor.set |= FB_CUR_SETHOT;

	}



	if (cursor.set & FB_CUR_SETSIZE ||

	    vc->vc_cursor_type != ops->p->cursor_shape ||

	    ops->cursor_state.mask == NULL ||

	    ops->cursor_reset) {

	    vc->vc_cursor_type != par->p->cursor_shape ||

	    par->cursor_state.mask == NULL ||

	    par->cursor_reset) {

		char *mask = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC);

		int cur_height, size, i = 0;

		u8 msk = 0xff;
@@ -312,13 +312,13 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		if (!mask)

			return;



		kfree(ops->cursor_state.mask);

		ops->cursor_state.mask = mask;

		kfree(par->cursor_state.mask);

		par->cursor_state.mask = mask;



		ops->p->cursor_shape = vc->vc_cursor_type;

		par->p->cursor_shape = vc->vc_cursor_type;

		cursor.set |= FB_CUR_SETSHAPE;



		switch (CUR_SIZE(ops->p->cursor_shape)) {

		switch (CUR_SIZE(par->p->cursor_shape)) {

		case CUR_NONE:

			cur_height = 0;

			break;
@@ -347,19 +347,19 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
			mask[i++] = msk;

	}



	ops->cursor_state.enable = enable && !use_sw;

	par->cursor_state.enable = enable && !use_sw;



	cursor.image.data = src;

	cursor.image.fg_color = ops->cursor_state.image.fg_color;

	cursor.image.bg_color = ops->cursor_state.image.bg_color;

	cursor.image.dx = ops->cursor_state.image.dx;

	cursor.image.dy = ops->cursor_state.image.dy;

	cursor.image.height = ops->cursor_state.image.height;

	cursor.image.width = ops->cursor_state.image.width;

	cursor.hot.x = ops->cursor_state.hot.x;

	cursor.hot.y = ops->cursor_state.hot.y;

	cursor.mask = ops->cursor_state.mask;

	cursor.enable = ops->cursor_state.enable;

	cursor.image.fg_color = par->cursor_state.image.fg_color;

	cursor.image.bg_color = par->cursor_state.image.bg_color;

	cursor.image.dx = par->cursor_state.image.dx;

	cursor.image.dy = par->cursor_state.image.dy;

	cursor.image.height = par->cursor_state.image.height;

	cursor.image.width = par->cursor_state.image.width;

	cursor.hot.x = par->cursor_state.hot.x;

	cursor.hot.y = par->cursor_state.hot.y;

	cursor.mask = par->cursor_state.mask;

	cursor.enable = par->cursor_state.enable;

	cursor.image.depth = 1;

	cursor.rop = ROP_XOR;
@@ -369,31 +369,31 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
	if (err)

		soft_cursor(info, &cursor);



	ops->cursor_reset = 0;

	par->cursor_reset = 0;

}



static int bit_update_start(struct fb_info *info)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	int err;



	err = fb_pan_display(info, &ops->var);

	ops->var.xoffset = info->var.xoffset;

	ops->var.yoffset = info->var.yoffset;

	ops->var.vmode = info->var.vmode;

	err = fb_pan_display(info, &par->var);

	par->var.xoffset = info->var.xoffset;

	par->var.yoffset = info->var.yoffset;

	par->var.vmode = info->var.vmode;

	return err;

}



void fbcon_set_bitops(struct fbcon_ops *ops)

void fbcon_set_bitops(struct fbcon_par *par)

{

	ops->bmove = bit_bmove;

	ops->clear = bit_clear;

	ops->putcs = bit_putcs;

	ops->clear_margins = bit_clear_margins;

	ops->cursor = bit_cursor;

	ops->update_start = bit_update_start;

	ops->rotate_font = NULL;



	if (ops->rotate)

		fbcon_set_rotate(ops);

	par->bmove = bit_bmove;

	par->clear = bit_clear;

	par->putcs = bit_putcs;

	par->clear_margins = bit_clear_margins;

	par->cursor = bit_cursor;

	par->update_start = bit_update_start;

	par->rotate_font = NULL;



	if (par->rotate)

		fbcon_set_rotate(par);

}

drivers/video/fbdev/core/fbcon.c

+204 −215

File changed.

Preview size limit exceeded, changes collapsed.

drivers/video/fbdev/core/fbcon.h

+3 −3
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ struct fbcon_display { 
    const struct fb_videomode *mode;

};



struct fbcon_ops {

struct fbcon_par {

	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,
@@ -186,7 +186,7 @@ static inline u_short fb_scrollmode(struct fbcon_display *fb) 
#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 void fbcon_set_bitops(struct fbcon_par *par);

extern int  soft_cursor(struct fb_info *info, struct fb_cursor *cursor);



#define FBCON_ATTRIBUTE_UNDERLINE 1
@@ -225,7 +225,7 @@ static inline int get_attribute(struct fb_info *info, u16 c) 
        (i == FB_ROTATE_UR || i == FB_ROTATE_UD) ? _r : _v; })



#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION

extern void fbcon_set_rotate(struct fbcon_ops *ops);

extern void fbcon_set_rotate(struct fbcon_par *par);

#else

#define fbcon_set_rotate(x) do {} while(0)

#endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */

drivers/video/fbdev/core/fbcon_ccw.c

+73 −73
Original line number Diff line number Diff line
@@ -63,9 +63,9 @@ static void ccw_update_attr(u8 *dst, u8 *src, int attribute, 
static void ccw_bmove(struct vc_data *vc, struct fb_info *info, int sy,

		     int sx, int dy, int dx, int height, int width)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	struct fb_copyarea area;

	u32 vyres = GETVYRES(ops->p, info);

	u32 vyres = GETVYRES(par->p, info);



	area.sx = sy * vc->vc_font.height;

	area.sy = vyres - ((sx + width) * vc->vc_font.width);
@@ -80,9 +80,9 @@ static void ccw_bmove(struct vc_data *vc, struct fb_info *info, int sy, 
static void ccw_clear(struct vc_data *vc, struct fb_info *info, int sy,

		     int sx, int height, int width, int fg, int bg)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	struct fb_fillrect region;

	u32 vyres = GETVYRES(ops->p, info);

	u32 vyres = GETVYRES(par->p, info);



	region.color = bg;

	region.dx = sy * vc->vc_font.height;
@@ -99,13 +99,13 @@ static inline void ccw_putcs_aligned(struct vc_data *vc, struct fb_info *info, 
				    u32 d_pitch, u32 s_pitch, u32 cellsize,

				    struct fb_image *image, u8 *buf, u8 *dst)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;

	u32 idx = (vc->vc_font.height + 7) >> 3;

	u8 *src;



	while (cnt--) {

		src = ops->fontbuffer + (scr_readw(s--) & charmask)*cellsize;

		src = par->fontbuffer + (scr_readw(s--) & charmask) * cellsize;



		if (attr) {

			ccw_update_attr(buf, src, attr, vc);
@@ -130,7 +130,7 @@ static void ccw_putcs(struct vc_data *vc, struct fb_info *info, 
		      int fg, int bg)

{

	struct fb_image image;

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	u32 width = (vc->vc_font.height + 7)/8;

	u32 cellsize = width * vc->vc_font.width;

	u32 maxcnt = info->pixmap.size/cellsize;
@@ -139,9 +139,9 @@ static void ccw_putcs(struct vc_data *vc, struct fb_info *info, 
	u32 cnt, pitch, size;

	u32 attribute = get_attribute(info, scr_readw(s));

	u8 *dst, *buf = NULL;

	u32 vyres = GETVYRES(ops->p, info);

	u32 vyres = GETVYRES(par->p, info);



	if (!ops->fontbuffer)

	if (!par->fontbuffer)

		return;



	image.fg_color = fg;
@@ -221,27 +221,27 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		       int fg, int bg)

{

	struct fb_cursor cursor;

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;

	int w = (vc->vc_font.height + 7) >> 3, c;

	int y = real_y(ops->p, vc->state.y);

	int y = real_y(par->p, vc->state.y);

	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;

	int err = 1, dx, dy;

	char *src;

	u32 vyres = GETVYRES(ops->p, info);

	u32 vyres = GETVYRES(par->p, info);



	if (!ops->fontbuffer)

	if (!par->fontbuffer)

		return;



	cursor.set = 0;



 	c = scr_readw((u16 *) vc->vc_pos);

	attribute = get_attribute(info, c);

	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));

	src = par->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));



	if (ops->cursor_state.image.data != src ||

	    ops->cursor_reset) {

	    ops->cursor_state.image.data = src;

	if (par->cursor_state.image.data != src ||

	    par->cursor_reset) {

		par->cursor_state.image.data = src;

		cursor.set |= FB_CUR_SETIMAGE;

	}
@@ -251,49 +251,49 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC);

		if (!dst)

			return;

		kfree(ops->cursor_data);

		ops->cursor_data = dst;

		kfree(par->cursor_data);

		par->cursor_data = dst;

		ccw_update_attr(dst, src, attribute, vc);

		src = dst;

	}



	if (ops->cursor_state.image.fg_color != fg ||

	    ops->cursor_state.image.bg_color != bg ||

	    ops->cursor_reset) {

		ops->cursor_state.image.fg_color = fg;

		ops->cursor_state.image.bg_color = bg;

	if (par->cursor_state.image.fg_color != fg ||

	    par->cursor_state.image.bg_color != bg ||

	    par->cursor_reset) {

		par->cursor_state.image.fg_color = fg;

		par->cursor_state.image.bg_color = bg;

		cursor.set |= FB_CUR_SETCMAP;

	}



	if (ops->cursor_state.image.height != vc->vc_font.width ||

	    ops->cursor_state.image.width != vc->vc_font.height ||

	    ops->cursor_reset) {

		ops->cursor_state.image.height = vc->vc_font.width;

		ops->cursor_state.image.width = vc->vc_font.height;

	if (par->cursor_state.image.height != vc->vc_font.width ||

	    par->cursor_state.image.width != vc->vc_font.height ||

	    par->cursor_reset) {

		par->cursor_state.image.height = vc->vc_font.width;

		par->cursor_state.image.width = vc->vc_font.height;

		cursor.set |= FB_CUR_SETSIZE;

	}



	dx = y * vc->vc_font.height;

	dy = vyres - ((vc->state.x + 1) * vc->vc_font.width);



	if (ops->cursor_state.image.dx != dx ||

	    ops->cursor_state.image.dy != dy ||

	    ops->cursor_reset) {

		ops->cursor_state.image.dx = dx;

		ops->cursor_state.image.dy = dy;

	if (par->cursor_state.image.dx != dx ||

	    par->cursor_state.image.dy != dy ||

	    par->cursor_reset) {

		par->cursor_state.image.dx = dx;

		par->cursor_state.image.dy = dy;

		cursor.set |= FB_CUR_SETPOS;

	}



	if (ops->cursor_state.hot.x || ops->cursor_state.hot.y ||

	    ops->cursor_reset) {

		ops->cursor_state.hot.x = cursor.hot.y = 0;

	if (par->cursor_state.hot.x || par->cursor_state.hot.y ||

	    par->cursor_reset) {

		par->cursor_state.hot.x = cursor.hot.y = 0;

		cursor.set |= FB_CUR_SETHOT;

	}



	if (cursor.set & FB_CUR_SETSIZE ||

	    vc->vc_cursor_type != ops->p->cursor_shape ||

	    ops->cursor_state.mask == NULL ||

	    ops->cursor_reset) {

	    vc->vc_cursor_type != par->p->cursor_shape ||

	    par->cursor_state.mask == NULL ||

	    par->cursor_reset) {

		char *tmp, *mask = kmalloc_array(w, vc->vc_font.width,

						 GFP_ATOMIC);

		int cur_height, size, i = 0;
@@ -309,13 +309,13 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
			return;

		}



		kfree(ops->cursor_state.mask);

		ops->cursor_state.mask = mask;

		kfree(par->cursor_state.mask);

		par->cursor_state.mask = mask;



		ops->p->cursor_shape = vc->vc_cursor_type;

		par->p->cursor_shape = vc->vc_cursor_type;

		cursor.set |= FB_CUR_SETSHAPE;



		switch (CUR_SIZE(ops->p->cursor_shape)) {

		switch (CUR_SIZE(par->p->cursor_shape)) {

		case CUR_NONE:

			cur_height = 0;

			break;
@@ -348,19 +348,19 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		kfree(tmp);

	}



	ops->cursor_state.enable = enable && !use_sw;

	par->cursor_state.enable = enable && !use_sw;



	cursor.image.data = src;

	cursor.image.fg_color = ops->cursor_state.image.fg_color;

	cursor.image.bg_color = ops->cursor_state.image.bg_color;

	cursor.image.dx = ops->cursor_state.image.dx;

	cursor.image.dy = ops->cursor_state.image.dy;

	cursor.image.height = ops->cursor_state.image.height;

	cursor.image.width = ops->cursor_state.image.width;

	cursor.hot.x = ops->cursor_state.hot.x;

	cursor.hot.y = ops->cursor_state.hot.y;

	cursor.mask = ops->cursor_state.mask;

	cursor.enable = ops->cursor_state.enable;

	cursor.image.fg_color = par->cursor_state.image.fg_color;

	cursor.image.bg_color = par->cursor_state.image.bg_color;

	cursor.image.dx = par->cursor_state.image.dx;

	cursor.image.dy = par->cursor_state.image.dy;

	cursor.image.height = par->cursor_state.image.height;

	cursor.image.width = par->cursor_state.image.width;

	cursor.hot.x = par->cursor_state.hot.x;

	cursor.hot.y = par->cursor_state.hot.y;

	cursor.mask = par->cursor_state.mask;

	cursor.enable = par->cursor_state.enable;

	cursor.image.depth = 1;

	cursor.rop = ROP_XOR;
@@ -370,32 +370,32 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
	if (err)

		soft_cursor(info, &cursor);



	ops->cursor_reset = 0;

	par->cursor_reset = 0;

}



static int ccw_update_start(struct fb_info *info)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	u32 yoffset;

	u32 vyres = GETVYRES(ops->p, info);

	u32 vyres = GETVYRES(par->p, info);

	int err;



	yoffset = (vyres - info->var.yres) - ops->var.xoffset;

	ops->var.xoffset = ops->var.yoffset;

	ops->var.yoffset = yoffset;

	err = fb_pan_display(info, &ops->var);

	ops->var.xoffset = info->var.xoffset;

	ops->var.yoffset = info->var.yoffset;

	ops->var.vmode = info->var.vmode;

	yoffset = (vyres - info->var.yres) - par->var.xoffset;

	par->var.xoffset = par->var.yoffset;

	par->var.yoffset = yoffset;

	err = fb_pan_display(info, &par->var);

	par->var.xoffset = info->var.xoffset;

	par->var.yoffset = info->var.yoffset;

	par->var.vmode = info->var.vmode;

	return err;

}



void fbcon_rotate_ccw(struct fbcon_ops *ops)

void fbcon_rotate_ccw(struct fbcon_par *par)

{

	ops->bmove = ccw_bmove;

	ops->clear = ccw_clear;

	ops->putcs = ccw_putcs;

	ops->clear_margins = ccw_clear_margins;

	ops->cursor = ccw_cursor;

	ops->update_start = ccw_update_start;

	par->bmove = ccw_bmove;

	par->clear = ccw_clear;

	par->putcs = ccw_putcs;

	par->clear_margins = ccw_clear_margins;

	par->cursor = ccw_cursor;

	par->update_start = ccw_update_start;

}

drivers/video/fbdev/core/fbcon_cw.c

+73 −73
Original line number Diff line number Diff line
@@ -48,9 +48,9 @@ static void cw_update_attr(u8 *dst, u8 *src, int attribute, 
static void cw_bmove(struct vc_data *vc, struct fb_info *info, int sy,

		     int sx, int dy, int dx, int height, int width)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	struct fb_copyarea area;

	u32 vxres = GETVXRES(ops->p, info);

	u32 vxres = GETVXRES(par->p, info);



	area.sx = vxres - ((sy + height) * vc->vc_font.height);

	area.sy = sx * vc->vc_font.width;
@@ -65,9 +65,9 @@ static void cw_bmove(struct vc_data *vc, struct fb_info *info, int sy, 
static void cw_clear(struct vc_data *vc, struct fb_info *info, int sy,

		     int sx, int height, int width, int fg, int bg)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	struct fb_fillrect region;

	u32 vxres = GETVXRES(ops->p, info);

	u32 vxres = GETVXRES(par->p, info);



	region.color = bg;

	region.dx = vxres - ((sy + height) * vc->vc_font.height);
@@ -84,13 +84,13 @@ static inline void cw_putcs_aligned(struct vc_data *vc, struct fb_info *info, 
				    u32 d_pitch, u32 s_pitch, u32 cellsize,

				    struct fb_image *image, u8 *buf, u8 *dst)

{

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;

	u32 idx = (vc->vc_font.height + 7) >> 3;

	u8 *src;



	while (cnt--) {

		src = ops->fontbuffer + (scr_readw(s++) & charmask)*cellsize;

		src = par->fontbuffer + (scr_readw(s++) & charmask) * cellsize;



		if (attr) {

			cw_update_attr(buf, src, attr, vc);
@@ -115,7 +115,7 @@ static void cw_putcs(struct vc_data *vc, struct fb_info *info, 
		      int fg, int bg)

{

	struct fb_image image;

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	u32 width = (vc->vc_font.height + 7)/8;

	u32 cellsize = width * vc->vc_font.width;

	u32 maxcnt = info->pixmap.size/cellsize;
@@ -124,9 +124,9 @@ static void cw_putcs(struct vc_data *vc, struct fb_info *info, 
	u32 cnt, pitch, size;

	u32 attribute = get_attribute(info, scr_readw(s));

	u8 *dst, *buf = NULL;

	u32 vxres = GETVXRES(ops->p, info);

	u32 vxres = GETVXRES(par->p, info);



	if (!ops->fontbuffer)

	if (!par->fontbuffer)

		return;



	image.fg_color = fg;
@@ -204,27 +204,27 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		      int fg, int bg)

{

	struct fb_cursor cursor;

	struct fbcon_ops *ops = info->fbcon_par;

	struct fbcon_par *par = info->fbcon_par;

	unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;

	int w = (vc->vc_font.height + 7) >> 3, c;

	int y = real_y(ops->p, vc->state.y);

	int y = real_y(par->p, vc->state.y);

	int attribute, use_sw = vc->vc_cursor_type & CUR_SW;

	int err = 1, dx, dy;

	char *src;

	u32 vxres = GETVXRES(ops->p, info);

	u32 vxres = GETVXRES(par->p, info);



	if (!ops->fontbuffer)

	if (!par->fontbuffer)

		return;



	cursor.set = 0;



 	c = scr_readw((u16 *) vc->vc_pos);

	attribute = get_attribute(info, c);

	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));

	src = par->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));



	if (ops->cursor_state.image.data != src ||

	    ops->cursor_reset) {

	    ops->cursor_state.image.data = src;

	if (par->cursor_state.image.data != src ||

	    par->cursor_reset) {

		par->cursor_state.image.data = src;

		cursor.set |= FB_CUR_SETIMAGE;

	}
@@ -234,49 +234,49 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC);

		if (!dst)

			return;

		kfree(ops->cursor_data);

		ops->cursor_data = dst;

		kfree(par->cursor_data);

		par->cursor_data = dst;

		cw_update_attr(dst, src, attribute, vc);

		src = dst;

	}



	if (ops->cursor_state.image.fg_color != fg ||

	    ops->cursor_state.image.bg_color != bg ||

	    ops->cursor_reset) {

		ops->cursor_state.image.fg_color = fg;

		ops->cursor_state.image.bg_color = bg;

	if (par->cursor_state.image.fg_color != fg ||

	    par->cursor_state.image.bg_color != bg ||

	    par->cursor_reset) {

		par->cursor_state.image.fg_color = fg;

		par->cursor_state.image.bg_color = bg;

		cursor.set |= FB_CUR_SETCMAP;

	}



	if (ops->cursor_state.image.height != vc->vc_font.width ||

	    ops->cursor_state.image.width != vc->vc_font.height ||

	    ops->cursor_reset) {

		ops->cursor_state.image.height = vc->vc_font.width;

		ops->cursor_state.image.width = vc->vc_font.height;

	if (par->cursor_state.image.height != vc->vc_font.width ||

	    par->cursor_state.image.width != vc->vc_font.height ||

	    par->cursor_reset) {

		par->cursor_state.image.height = vc->vc_font.width;

		par->cursor_state.image.width = vc->vc_font.height;

		cursor.set |= FB_CUR_SETSIZE;

	}



	dx = vxres - ((y * vc->vc_font.height) + vc->vc_font.height);

	dy = vc->state.x * vc->vc_font.width;



	if (ops->cursor_state.image.dx != dx ||

	    ops->cursor_state.image.dy != dy ||

	    ops->cursor_reset) {

		ops->cursor_state.image.dx = dx;

		ops->cursor_state.image.dy = dy;

	if (par->cursor_state.image.dx != dx ||

	    par->cursor_state.image.dy != dy ||

	    par->cursor_reset) {

		par->cursor_state.image.dx = dx;

		par->cursor_state.image.dy = dy;

		cursor.set |= FB_CUR_SETPOS;

	}



	if (ops->cursor_state.hot.x || ops->cursor_state.hot.y ||

	    ops->cursor_reset) {

		ops->cursor_state.hot.x = cursor.hot.y = 0;

	if (par->cursor_state.hot.x || par->cursor_state.hot.y ||

	    par->cursor_reset) {

		par->cursor_state.hot.x = cursor.hot.y = 0;

		cursor.set |= FB_CUR_SETHOT;

	}



	if (cursor.set & FB_CUR_SETSIZE ||

	    vc->vc_cursor_type != ops->p->cursor_shape ||

	    ops->cursor_state.mask == NULL ||

	    ops->cursor_reset) {

	    vc->vc_cursor_type != par->p->cursor_shape ||

	    par->cursor_state.mask == NULL ||

	    par->cursor_reset) {

		char *tmp, *mask = kmalloc_array(w, vc->vc_font.width,

						 GFP_ATOMIC);

		int cur_height, size, i = 0;
@@ -292,13 +292,13 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
			return;

		}



		kfree(ops->cursor_state.mask);

		ops->cursor_state.mask = mask;

		kfree(par->cursor_state.mask);

		par->cursor_state.mask = mask;



		ops->p->cursor_shape = vc->vc_cursor_type;

		par->p->cursor_shape = vc->vc_cursor_type;

		cursor.set |= FB_CUR_SETSHAPE;



		switch (CUR_SIZE(ops->p->cursor_shape)) {

		switch (CUR_SIZE(par->p->cursor_shape)) {

		case CUR_NONE:

			cur_height = 0;

			break;
@@ -331,19 +331,19 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
		kfree(tmp);

	}



	ops->cursor_state.enable = enable && !use_sw;

	par->cursor_state.enable = enable && !use_sw;



	cursor.image.data = src;

	cursor.image.fg_color = ops->cursor_state.image.fg_color;

	cursor.image.bg_color = ops->cursor_state.image.bg_color;

	cursor.image.dx = ops->cursor_state.image.dx;

	cursor.image.dy = ops->cursor_state.image.dy;

	cursor.image.height = ops->cursor_state.image.height;

	cursor.image.width = ops->cursor_state.image.width;

	cursor.hot.x = ops->cursor_state.hot.x;

	cursor.hot.y = ops->cursor_state.hot.y;

	cursor.mask = ops->cursor_state.mask;

	cursor.enable = ops->cursor_state.enable;

	cursor.image.fg_color = par->cursor_state.image.fg_color;

	cursor.image.bg_color = par->cursor_state.image.bg_color;

	cursor.image.dx = par->cursor_state.image.dx;

	cursor.image.dy = par->cursor_state.image.dy;

	cursor.image.height = par->cursor_state.image.height;

	cursor.image.width = par->cursor_state.image.width;

	cursor.hot.x = par->cursor_state.hot.x;

	cursor.hot.y = par->cursor_state.hot.y;

	cursor.mask = par->cursor_state.mask;

	cursor.enable = par->cursor_state.enable;

	cursor.image.depth = 1;

	cursor.rop = ROP_XOR;
@@ -353,32 +353,32 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable, 
	if (err)

		soft_cursor(info, &cursor);



	ops->cursor_reset = 0;

	par->cursor_reset = 0;

}



static int cw_update_start(struct fb_info *info)

{

	struct fbcon_ops *ops = info->fbcon_par;

	u32 vxres = GETVXRES(ops->p, info);

	struct fbcon_par *par = info->fbcon_par;

	u32 vxres = GETVXRES(par->p, info);

	u32 xoffset;

	int err;



	xoffset = vxres - (info->var.xres + ops->var.yoffset);

	ops->var.yoffset = ops->var.xoffset;

	ops->var.xoffset = xoffset;

	err = fb_pan_display(info, &ops->var);

	ops->var.xoffset = info->var.xoffset;

	ops->var.yoffset = info->var.yoffset;

	ops->var.vmode = info->var.vmode;

	xoffset = vxres - (info->var.xres + par->var.yoffset);

	par->var.yoffset = par->var.xoffset;

	par->var.xoffset = xoffset;

	err = fb_pan_display(info, &par->var);

	par->var.xoffset = info->var.xoffset;

	par->var.yoffset = info->var.yoffset;

	par->var.vmode = info->var.vmode;

	return err;

}



void fbcon_rotate_cw(struct fbcon_ops *ops)

void fbcon_rotate_cw(struct fbcon_par *par)

{

	ops->bmove = cw_bmove;

	ops->clear = cw_clear;

	ops->putcs = cw_putcs;

	ops->clear_margins = cw_clear_margins;

	ops->cursor = cw_cursor;

	ops->update_start = cw_update_start;

	par->bmove = cw_bmove;

	par->clear = cw_clear;

	par->putcs = cw_putcs;

	par->clear_margins = cw_clear_margins;

	par->cursor = cw_cursor;

	par->update_start = cw_update_start;

}