[FBDEV] Massive cleanups of the cursor api.

5 files changed, 226 insertions, 194 deletions

diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 5e3de52ac4cb..d815d9149a2d 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -139,8 +139,6 @@ static int fbcon_set_origin(struct vc_data *);
 
 static int vbl_cursor_cnt;
 static int cursor_blink_rate;
-static int cursor_drawn;
-static int cursor_on;
 
 #define divides(a, b)	((!(a) || (b)%(a)) ? 0 : 1)
 
@@ -172,8 +170,6 @@ static int fbcon_scrolldelta(struct vc_data *vc, int lines);
  *  Internal routines
  */
 static void fbcon_set_display(struct vc_data *vc, int init, int logo);
-static void accel_cursor(struct vc_data *vc, struct fb_info *info, 
-			 struct fb_cursor *cursor, int yy);
 static __inline__ int real_y(struct display *p, int ypos);
 static __inline__ void updatescrollmode(struct display *p, struct vc_data *vc);
 static __inline__ void ywrap_up(struct vc_data *vc, int count);
@@ -195,32 +191,23 @@ static void fb_vbl_detect(int irq, void *dummy, struct pt_regs *fp)
 }
 #endif
 
-static void fb_callback(void *private)
+static void fb_flashcursor(void *private)
 {
 	struct fb_info *info = (struct fb_info *) private;
-	struct display *p = &fb_display[fg_console];
-	struct vc_data *vc = vc_cons[fg_console].d;
-	struct fb_cursor cursor;
 
-	if (!info || !cursor_on)
+	if (!info || !info->cursor.enable)
 		return;
-
-	if (vbl_cursor_cnt && --vbl_cursor_cnt == 0) {
-		cursor.set = 0;
-
-		if (!cursor_drawn)
-			cursor.set = FB_CUR_SETCUR;
-		accel_cursor(vc, info, &cursor, real_y(p, vc->vc_y));
-		cursor_drawn ^= 1;
-		vbl_cursor_cnt = cursor_blink_rate; 
-	}
+	info->fbops->fb_cursor(info, &info->cursor);
 }
 
 static void fb_vbl_handler(int irq, void *dev_id, struct pt_regs *fp)
 {
 	struct fb_info *info = dev_id;
 
-	schedule_work(&info->queue);	
+	if (vbl_cursor_cnt && --vbl_cursor_cnt == 0) {
+		schedule_work(&info->queue);	
+		vbl_cursor_cnt = cursor_blink_rate; 
+	}
 }
 	
 static void cursor_timer_handler(unsigned long dev_addr);
@@ -594,7 +581,7 @@ static const char *fbcon_startup(void)
 	}
 
 	/* Initialize the work queue */
-	INIT_WORK(&info->queue, fb_callback, info);
+	INIT_WORK(&info->queue, fb_flashcursor, info);
 	
 	/* Setup default font */
 	vc->vc_font.data = font->data;
@@ -993,111 +980,18 @@ static void fbcon_putcs(struct vc_data *vc, const unsigned short *s,
 	accel_putcs(vc, info, s, count, real_y(p, ypos), xpos);
 }
 
-static void accel_cursor(struct vc_data *vc, struct fb_info *info,
-			 struct fb_cursor *cursor, int yy)
+static void fbcon_cursor(struct vc_data *vc, int mode)
 {
+	struct fb_info *info = registered_fb[(int) con2fb_map[vc->vc_num]];
 	unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
 	int bgshift = (vc->vc_hi_font_mask) ? 13 : 12;
 	int fgshift = (vc->vc_hi_font_mask) ? 9 : 8;
-	static int fgcolor, bgcolor, shape, width, height;
-	static char mask[64], image[64], *dest;
-        char *font;
-        int c;
-
-        if (cursor->set & FB_CUR_SETCUR)
-                cursor->enable = 1;
-        else
-                cursor->enable = 0;
-
-	cursor->set = FB_CUR_SETPOS;
-
-	if (width != vc->vc_font.width || height != vc->vc_font.height) {
-                width = vc->vc_font.width;
-                height = vc->vc_font.height;
-                cursor->set |= FB_CUR_SETSIZE;
-        }
-
-        if ((vc->vc_cursor_type & 0x0f) != shape) {
-                shape = vc->vc_cursor_type & 0x0f;
-		cursor->set |= FB_CUR_SETSHAPE;
-        }
-
-        c = scr_readw((u16 *) vc->vc_pos);
-
-	if (fgcolor != (int) attr_fgcol(fgshift, c) ||
-            bgcolor != (int) attr_bgcol(bgshift, c)) {
-                fgcolor = (int) attr_fgcol(fgshift, c);
-                bgcolor = (int) attr_bgcol(bgshift, c);
-                cursor->set |= FB_CUR_SETCMAP;
-        }
-        c &= charmask;
-        font = vc->vc_font.data + (c * ((width + 7) / 8) * height);
-        if (font != dest) {
-                dest = font;
-                cursor->set |= FB_CUR_SETDEST;
-        }
-
-        if (cursor->set & FB_CUR_SETSIZE) {
-                memset(image, 0xff, 64);
-                cursor->set |= FB_CUR_SETSHAPE;
-        }
-
-	if (cursor->set & FB_CUR_SETSHAPE) {
-                int w, cur_height, size, i = 0;
-
-                w = (width + 7) / 8;
-
-                switch (shape) {
-                        case CUR_NONE:
-                                cur_height = 0;
-                                break;
-                        case CUR_UNDERLINE:
-                                cur_height = (height < 10) ? 1 : 2;
-                                break;
-                        case CUR_LOWER_THIRD:
-                                cur_height = height/3;
-                                break;
-                        case CUR_LOWER_HALF:
-                                cur_height = height/2;
-                                break;
-                        case CUR_TWO_THIRDS:
-                                cur_height = (height * 2)/3;
-                                break;
-                        case CUR_BLOCK:
-                        default:
-                                cur_height = height;
-                                break;
-                }
-	size = (height - cur_height) * w;
-                while (size--)
-                        mask[i++] = 0;
-                size = cur_height * w;
-                while (size--)
-                        mask[i++] = 0xff;
-        }
-
-        cursor->image.width = width;
-        cursor->image.height = height;
-        cursor->image.dx = vc->vc_x * width;
-        cursor->image.dy = yy * height;
-        cursor->image.depth = 1;
-        cursor->image.data = image;
-        cursor->image.bg_color = bgcolor;
-        cursor->image.fg_color = fgcolor;
-        cursor->mask = mask;
-        cursor->dest = dest;
-        cursor->rop = ROP_XOR;
-
-        if (info->fbops->fb_cursor)
-                info->fbops->fb_cursor(info, cursor);
-}
-	
-static void fbcon_cursor(struct vc_data *vc, int mode)
-{
-	struct fb_info *info = registered_fb[(int) con2fb_map[vc->vc_num]];
+	int w = (vc->vc_font.width + 7) >> 3, c;
 	struct display *p = &fb_display[vc->vc_num];
+	int y = real_y(p, vc->vc_y);
 	struct fb_cursor cursor;
-	int y = vc->vc_y;
+	static char mask[64];
+	static int shape;
 
 	if (mode & CM_SOFTBACK) {
 		mode &= ~CM_SOFTBACK;
@@ -1110,30 +1004,91 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
 	} else if (softback_lines)
 		fbcon_set_origin(vc);
 
-	/* Avoid flickering if there's no real change. */
-	if ((mode == CM_ERASE) == !cursor_on)
-		return;
-
-	cursor_on = 0;
+ 	c = scr_readw((u16 *) vc->vc_pos);
 
+	cursor.image.data = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height));
+	cursor.image.depth = 1;
+	
 	switch (mode) {
 	case CM_ERASE:
-		if (cursor_drawn) {
+		if (info->cursor.rop == ROP_XOR) {
 			cursor.set = 0;
-			accel_cursor(vc, info, &cursor,
-				     real_y(p, y));
+			cursor.image.dx = info->cursor.image.dx;
+			cursor.image.dy = info->cursor.image.dy;
+			cursor.image.width = info->cursor.image.width;
+			cursor.image.height = info->cursor.image.height;
+			cursor.image.fg_color = info->cursor.image.fg_color;
+			cursor.image.bg_color = info->cursor.image.bg_color;
+			cursor.mask = mask;
+			cursor.rop = ROP_COPY;
+
+			info->fbops->fb_cursor(info, &cursor);
 		}	
-		cursor_drawn = 0;
 		break;
 	case CM_MOVE:
 	case CM_DRAW:
-		if (cursor_drawn) {
-			cursor.set = FB_CUR_SETCUR;
-			accel_cursor(vc, info, &cursor, 
-				     real_y(p, y));
-		}	
+		cursor.set = FB_CUR_SETCUR;
+
+		if (info->cursor.image.fg_color != attr_fgcol(fgshift, c) ||
+	    	    info->cursor.image.bg_color != attr_bgcol(bgshift, c)) {
+			cursor.image.fg_color = attr_fgcol(fgshift, c);
+			cursor.image.bg_color = attr_bgcol(bgshift, c);
+			cursor.set |= FB_CUR_SETCMAP;
+		}
+		
+		if ((info->cursor.image.dx != (vc->vc_font.width * vc->vc_x)) ||
+		    (info->cursor.image.dy != (vc->vc_font.height * y))) {
+			cursor.image.dx = vc->vc_font.width * vc->vc_x;
+			cursor.image.dy = vc->vc_font.height * y;
+			cursor.set |= FB_CUR_SETPOS;
+		}			
+	
+		if (info->cursor.image.height != vc->vc_font.height ||
+		    info->cursor.image.width != vc->vc_font.width) {
+			cursor.image.height = vc->vc_font.height;
+			cursor.image.width = vc->vc_font.width;
+			cursor.set |= FB_CUR_SETSIZE;
+		}
+
+		if ((vc->vc_cursor_type & 0x0f) != shape) {
+			int cur_height, size, i = 0;
+
+			shape = vc->vc_cursor_type & 0x0f;
+			cursor.set |= FB_CUR_SETSHAPE;
+
+			switch (vc->vc_cursor_type & 0x0f) {
+			case CUR_NONE:
+				cur_height = 0;
+				break;
+			case CUR_UNDERLINE:
+				cur_height = (vc->vc_font.height < 10) ? 1 : 2;
+				break;
+			case CUR_LOWER_THIRD:
+				cur_height = vc->vc_font.height/3;
+				break;
+			case CUR_LOWER_HALF:
+				cur_height = vc->vc_font.height >> 1;
+				break;
+			case CUR_TWO_THIRDS:
+				cur_height = (vc->vc_font.height << 1)/3;
+				break;
+			case CUR_BLOCK:
+			default:
+				cur_height = vc->vc_font.height;
+				break;
+			}
+			size = (vc->vc_font.height - cur_height) * w;
+			while (size--)
+				mask[i++] = 0;
+			size = cur_height * w;
+			while (size--)
+				mask[i++] = 0xff;
+		}
+        	cursor.mask = mask;
+        	cursor.rop = ROP_XOR;
+
+		info->fbops->fb_cursor(info, &cursor);
 		vbl_cursor_cnt = CURSOR_DRAW_DELAY;
-		cursor_on = 1;
 		break;
 	}
 }
@@ -1145,7 +1100,7 @@ static int scrollback_current = 0;
 int update_var(int con, struct fb_info *info)
 {
 	if (con == info->currcon) 
-		return fb_pan_display(&info->var, info);
+		return fb_pan_display(info, &info->var);
 	return 0;
 }
 
@@ -1648,16 +1603,16 @@ static int fbcon_resize(struct vc_data *vc, unsigned int width,
 	if (x_diff < 0 || x_diff > fw ||
 	   (y_diff < 0 || y_diff > fh)) {
 		var.activate = FB_ACTIVATE_TEST;
-		err = fb_set_var(&var, info);
+		err = fb_set_var(info, &var);
 		if (err || width > var.xres/fw ||
 		    height > var.yres/fh)
 			return -EINVAL;
 		DPRINTK("resize now %ix%i\n", var.xres, var.yres);
 		var.activate = FB_ACTIVATE_NOW;
-		fb_set_var(&var, info);
+		fb_set_var(info, &var);
 	}
 	p->vrows = var.yres_virtual/fh;
-	if(var.yres > (fh * (height + 1)))
+	if (var.yres > (fh * (height + 1)))
 		p->vrows -= (var.yres - (fh * height)) / fh;
 	return 0;
 }
@@ -1764,7 +1719,7 @@ static int fbcon_blank(struct vc_data *vc, int blank)
 			update_screen(vc->vc_num);
 		return 0;
 	} else
-		return fb_blank(blank, info);
+		return fb_blank(info, blank);
 }
 
 static void fbcon_free_font(struct display *p)
diff --git a/drivers/video/fbcmap.c b/drivers/video/fbcmap.c
index ce45b9ce5ca7..c119e3b15712 100644
--- a/drivers/video/fbcmap.c
+++ b/drivers/video/fbcmap.c
@@ -154,11 +154,11 @@ void fb_dealloc_cmap(struct fb_cmap *cmap)
  *
  */
 
-void fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to, int fsfromto)
+int fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to, int fsfromto)
 {
-    int size;
     int tooff = 0, fromoff = 0;
-
+    int size;
+    
     if (to->start > from->start)
 	fromoff = to->start-from->start;
     else
@@ -167,7 +167,7 @@ void fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to, int fsfromto)
     if (size > (int) (from->len - fromoff))
 	size = from->len-fromoff;
     if (size <= 0)
-	return;
+	return -EINVAL;
     size *= sizeof(u16);
     
     switch (fsfromto) {
@@ -179,20 +179,29 @@ void fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to, int fsfromto)
 	    memcpy(to->transp+tooff, from->transp+fromoff, size);
         break;
     case 1:
-	copy_from_user(to->red+tooff, from->red+fromoff, size);
-	copy_from_user(to->green+tooff, from->green+fromoff, size);
-	copy_from_user(to->blue+tooff, from->blue+fromoff, size);
+	if (copy_from_user(to->red+tooff, from->red+fromoff, size))
+		return -EFAULT;
+	if (copy_from_user(to->green+tooff, from->green+fromoff, size))
+		return -EFAULT;	
+	if (copy_from_user(to->blue+tooff, from->blue+fromoff, size))
+		return -EFAULT;
 	if (from->transp && to->transp)
-            copy_from_user(to->transp+tooff, from->transp+fromoff, size);
+            if (copy_from_user(to->transp+tooff, from->transp+fromoff, size))
+		    return -EFAULT;	
 	break;
     case 2:
-	copy_to_user(to->red+tooff, from->red+fromoff, size);
-	copy_to_user(to->green+tooff, from->green+fromoff, size);
-	copy_to_user(to->blue+tooff, from->blue+fromoff, size);
+	if (copy_to_user(to->red+tooff, from->red+fromoff, size))
+		return -EFAULT;
+	if (copy_to_user(to->green+tooff, from->green+fromoff, size))
+		return -EFAULT;
+	if (copy_to_user(to->blue+tooff, from->blue+fromoff, size))
+		return -EFAULT;
 	if (from->transp && to->transp)
-	    copy_to_user(to->transp+tooff, from->transp+fromoff, size);
+		if (copy_to_user(to->transp+tooff, from->transp+fromoff, size))
+			return -EFAULT;
 	break;
     }
+    return 0;
 }
 
 /**
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 912324b3a476..5b442c28fdd2 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -665,7 +665,7 @@ int fb_prepare_logo(struct fb_info *info)
 	/* What depth we asked for might be different from what we get */
 	if (fb_logo.logo->type == LINUX_LOGO_CLUT224)
 		fb_logo.depth = 8;
-	else if (fb_logo.logo->type = LINUX_LOGO_VGA16)
+	else if (fb_logo.logo->type == LINUX_LOGO_VGA16)
 		fb_logo.depth = 4;
 	else
 		fb_logo.depth = 1;		
@@ -847,7 +847,49 @@ static void try_to_load(int fb)
 #endif /* CONFIG_KMOD */
 
 int
-fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+fb_cursor(struct fb_info *info, struct fb_cursor *sprite)
+{
+	struct fb_cursor cursor;
+	int err;
+	
+	if (copy_from_user(&cursor, sprite, sizeof(struct fb_cursor)))
+		return -EFAULT;
+
+	if (cursor.set & FB_CUR_SETCMAP) {
+		err = fb_copy_cmap(&cursor.image.cmap, &sprite->image.cmap, 1);
+		if (err)
+			return err;
+	}
+	
+	if (cursor.set & FB_CUR_SETSHAPE) {
+		int size = ((cursor.image.width + 7) >> 3) * cursor.image.height;		
+		if ((cursor.image.height != info->cursor.image.height) ||
+		    (cursor.image.width != info->cursor.image.width))
+			cursor.set |= FB_CUR_SETSIZE;
+		
+		cursor.image.data = kmalloc(size, GFP_KERNEL);
+		if (!cursor.image.data)
+			return -ENOMEM;
+		
+		cursor.mask = kmalloc(size, GFP_KERNEL);
+		if (!cursor.mask) {
+			kfree(cursor.image.data);
+			return -ENOMEM;
+		}
+		
+		if (copy_from_user(&cursor.image.data, sprite->image.data, size) ||
+		    copy_from_user(cursor.mask, sprite->mask, size)) { 
+			kfree(cursor.image.data);
+			kfree(cursor.mask);
+			return -EFAULT;
+		}
+	}
+	err = info->fbops->fb_cursor(info, &cursor);
+	return err;
+}
+
+int
+fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
 {
         int xoffset = var->xoffset;
         int yoffset = var->yoffset;
@@ -869,7 +911,7 @@ fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 }
 
 int
-fb_set_var(struct fb_var_screeninfo *var, struct fb_info *info)
+fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 {
 	int err;
 
@@ -888,7 +930,7 @@ fb_set_var(struct fb_var_screeninfo *var, struct fb_info *info)
 			if (info->fbops->fb_set_par)
 				info->fbops->fb_set_par(info);
 
-			fb_pan_display(&info->var, info);
+			fb_pan_display(info, &info->var);
 
 			fb_set_cmap(&info->cmap, 1, info);
 		}
@@ -897,7 +939,7 @@ fb_set_var(struct fb_var_screeninfo *var, struct fb_info *info)
 }
 
 int
-fb_blank(int blank, struct fb_info *info)
+fb_blank(struct fb_info *info, int blank)
 {	
 	/* ??? Varible sized stack allocation.  */
 	u16 black[info->cmap.len];
@@ -931,7 +973,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 	struct fb_cmap cmap;
 	int i;
 	
-	if (! fb)
+	if (!fb)
 		return -ENODEV;
 	switch (cmd) {
 	case FBIOGET_VSCREENINFO:
@@ -940,7 +982,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 	case FBIOPUT_VSCREENINFO:
 		if (copy_from_user(&var, (void *) arg, sizeof(var)))
 			return -EFAULT;
-		i = fb_set_var(&var, info);
+		i = fb_set_var(info, &var);
 		if (i) return i;
 		if (copy_to_user((void *) arg, &var, sizeof(var)))
 			return -EFAULT;
@@ -954,16 +996,17 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 	case FBIOGETCMAP:
 		if (copy_from_user(&cmap, (void *) arg, sizeof(cmap)))
 			return -EFAULT;
-		fb_copy_cmap(&info->cmap, &cmap, 0);
-		return 0;
+		return (fb_copy_cmap(&info->cmap, &cmap, 0));
 	case FBIOPAN_DISPLAY:
 		if (copy_from_user(&var, (void *) arg, sizeof(var)))
 			return -EFAULT;
-		if ((i = fb_pan_display(&var, info)))
+		if ((i = fb_pan_display(info, &var)))
 			return i;
 		if (copy_to_user((void *) arg, &var, sizeof(var)))
 			return -EFAULT;
-		return i;
+		return 0;
+	case FBIO_CURSOR:
+		return (fb_cursor(info, (struct fb_cursor *) arg));
 #ifdef CONFIG_FRAMEBUFFER_CONSOLE
 	case FBIOGET_CON2FBMAP:
 		if (copy_from_user(&con2fb, (void *)arg, sizeof(con2fb)))
@@ -993,7 +1036,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 		return 0;
 #endif	/* CONFIG_FRAMEBUFFER_CONSOLE */
 	case FBIOBLANK:
-		return fb_blank(arg, info);
+		return fb_blank(info, arg);
 	default:
 		if (fb->fb_ioctl == NULL)
 			return -EINVAL;
diff --git a/drivers/video/softcursor.c b/drivers/video/softcursor.c
index 12db05247678..e7d03ec12cc6 100644
--- a/drivers/video/softcursor.c
+++ b/drivers/video/softcursor.c
@@ -19,39 +19,66 @@
 
 int soft_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-	int i, size = ((cursor->image.width + 7) / 8) * cursor->image.height;
-	struct fb_image image;
-	static char data[64];
+	unsigned int scan_align = info->pixmap.scan_align - 1;
+	unsigned int buf_align = info->pixmap.buf_align - 1;
+	unsigned int i, size, dsize, s_pitch, d_pitch;
+	u8 *dst, src[64];
 
-	if (cursor->enable) {
+	info->cursor.enable = (cursor->set & FB_CUR_SETCUR) ? 1 : 0;
+
+	if (cursor->set & FB_CUR_SETSIZE) {
+		info->cursor.image.height = cursor->image.height;
+		info->cursor.image.width = cursor->image.width;
+	}
+
+	if (cursor->set & FB_CUR_SETPOS) {
+		info->cursor.image.dx = cursor->image.dx;
+		info->cursor.image.dy = cursor->image.dy;
+	}
+
+	if (cursor->set & FB_CUR_SETHOT)
+		info->cursor.hot = cursor->hot;
+	
+	if (cursor->set & FB_CUR_SETCMAP) {
+		if (cursor->image.depth == 1) {
+			info->cursor.image.bg_color = cursor->image.bg_color;
+			info->cursor.image.fg_color = cursor->image.fg_color;
+		} else {
+			if (cursor->image.cmap.len)
+				fb_copy_cmap(&cursor->image.cmap, &info->cursor.image.cmap, 0);
+		}
+		info->cursor.image.depth = cursor->image.depth;
+	}	
+
+	s_pitch = (info->cursor.image.width + 7) >> 3;
+	dsize = s_pitch * info->cursor.image.height;
+	d_pitch = (s_pitch + scan_align) & ~scan_align;
+	size = d_pitch * info->cursor.image.height + buf_align;
+	size &= ~buf_align;
+	dst = info->pixmap.addr + fb_get_buffer_offset(info, size);
+	
+	if (info->cursor.enable) {
 		switch (cursor->rop) {
 		case ROP_XOR:
 			for (i = 0; i < size; i++)
-				data[i] = (cursor->image.data[i] &
-					   cursor->mask[i]) ^
-				    	   cursor->dest[i];
+				src[i] = cursor->image.data[i] ^ cursor->mask[i]; 
 			break;
 		case ROP_COPY:
 		default:
 			for (i = 0; i < size; i++)
-				data[i] =
-				    cursor->image.data[i] & cursor->mask[i];
+				src[i] = cursor->image.data[i] & cursor->mask[i];
 			break;
 		}
-	} else
-		memcpy(data, cursor->dest, size);
-
-	image.bg_color = cursor->image.bg_color;
-	image.fg_color = cursor->image.fg_color;
-	image.dx = cursor->image.dx;
-	image.dy = cursor->image.dy;
-	image.width = cursor->image.width;
-	image.height = cursor->image.height;
-	image.depth = cursor->image.depth;
-	image.data = data;
-
-	if (info->fbops->fb_imageblit)
-		info->fbops->fb_imageblit(info, &image);
+	} else {
+		for (i = 0; i < size; i++)
+			src[i] = cursor->image.data[i];
+	}
+	move_buf_aligned(info, dst, src, d_pitch, s_pitch,info->cursor.image.height);
+	
+	info->cursor.image.data = dst;
+	info->cursor.rop = cursor->rop;
+	
+	info->fbops->fb_imageblit(info, &info->cursor.image);
 	atomic_dec(&info->pixmap.count);
 	smp_mb__after_atomic_dec();	
 	return 0;
diff --git a/include/linux/fb.h b/include/linux/fb.h
index fa77d12eb5b8..61dc9788e8b8 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -311,7 +311,6 @@ struct fb_image {
 #define FB_CUR_SETCMAP  0x08
 #define FB_CUR_SETSHAPE 0x10
 #define FB_CUR_SETSIZE	0x20
-#define FB_CUR_SETDEST	0x40
 #define FB_CUR_SETALL   0xFF
 
 struct fbcurpos {
@@ -323,7 +322,6 @@ struct fb_cursor {
 	__u16 enable;		/* cursor on/off */
 	__u16 rop;		/* bitop operation */
 	char *mask;		/* cursor mask bits */
-	char *dest;		/* destination */
 	struct fbcurpos hot;	/* cursor hot spot */
 	struct fb_image	image;	/* Cursor image */
 };
@@ -471,9 +469,9 @@ struct fb_info {
      *  `Generic' versions of the frame buffer device operations
      */
 
-extern int fb_set_var(struct fb_var_screeninfo *var, struct fb_info *info); 
-extern int fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info); 
-extern int fb_blank(int blank, struct fb_info *info);
+extern int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var); 
+extern int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var); 
+extern int fb_blank(struct fb_info *info, int blank);
 extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
 extern void cfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect); 
 extern void cfb_copyarea(struct fb_info *info, const struct fb_copyarea *area); 
@@ -511,8 +509,8 @@ extern int fb_validate_mode(struct fb_var_screeninfo *var,
 /* drivers/video/fbcmap.c */
 extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
 extern void fb_dealloc_cmap(struct fb_cmap *cmap);
-extern void fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to,
-			 int fsfromto);
+extern int fb_copy_cmap(struct fb_cmap *from, struct fb_cmap *to,
+			int fsfromto);
 extern int fb_set_cmap(struct fb_cmap *cmap, int kspc, struct fb_info *fb_info);
 extern struct fb_cmap *fb_default_cmap(int len);
 extern void fb_invert_cmaps(void);