Merge /spare/repo/linux-2.6/

6 files changed, 303 insertions, 110 deletions

diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index 5fe182d6e4ab..eb83a7874c71 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -137,7 +137,7 @@ config FONT_8x8
 
 config FONT_8x16
         bool "VGA 8x16 font" if FONTS
-        depends on FRAMEBUFFER_CONSOLE || SGI_NEWPORT_CONSOLE=y
+        depends on FRAMEBUFFER_CONSOLE || SGI_NEWPORT_CONSOLE=y || USB_SISUSBVGA_CON
         default y if !SPARC32 && !SPARC64 && !FONTS
         help
           This is the "high resolution" font for the VGA frame buffer (the one
diff --git a/drivers/video/console/Makefile b/drivers/video/console/Makefile
index b562f6bb9d31..42c7b8dcd220 100644
--- a/drivers/video/console/Makefile
+++ b/drivers/video/console/Makefile
@@ -33,6 +33,10 @@ endif
 
 obj-$(CONFIG_FB_STI)              += sticore.o font.o
 
+ifeq ($(CONFIG_USB_SISUSBVGA_CON),y)
+obj-$(CONFIG_USB_SISUSBVGA)           += font.o
+endif
+
 # Targets that kbuild needs to know about
 targets := promcon_tbl.c
 
diff --git a/drivers/video/console/bitblit.c b/drivers/video/console/bitblit.c
index 3c731577fed6..9f70e512b88b 100644
--- a/drivers/video/console/bitblit.c
+++ b/drivers/video/console/bitblit.c
@@ -39,7 +39,7 @@ static inline int get_attribute(struct fb_info *info, u16 c)
 {
         int attribute = 0;
 
-        if (fb_get_color_depth(&info->var) == 1) {
+        if (fb_get_color_depth(&info->var, &info->fix) == 1) {
                 if (attr_underline(c))
                         attribute |= FBCON_ATTRIBUTE_UNDERLINE;
                 if (attr_reverse(c))
@@ -103,42 +103,104 @@ static void bit_clear(struct vc_data *vc, struct fb_info *info, int sy,
         info->fbops->fb_fillrect(info, &region);
 }
 
+static inline void bit_putcs_aligned(struct vc_data *vc, struct fb_info *info,
+                                     const u16 *s, u32 attr, u32 cnt,
+                                     u32 d_pitch, u32 s_pitch, u32 cellsize,
+                                     struct fb_image *image, u8 *buf, u8 *dst)
+{
+        u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
+        u32 idx = vc->vc_font.width >> 3;
+        u8 *src;
+
+        while (cnt--) {
+                src = vc->vc_font.data + (scr_readw(s++)&
+                                          charmask)*cellsize;
+
+                if (attr) {
+                        update_attr(buf, src, attr, vc);
+                        src = buf;
+                }
+
+                if (likely(idx == 1))
+                        __fb_pad_aligned_buffer(dst, d_pitch, src, idx,
+                                                image->height);
+                else
+                        fb_pad_aligned_buffer(dst, d_pitch, src, idx,
+                                              image->height);
+
+                dst += s_pitch;
+        }
+
+        info->fbops->fb_imageblit(info, image);
+}
+
+static inline void bit_putcs_unaligned(struct vc_data *vc,
+                                       struct fb_info *info, const u16 *s,
+                                       u32 attr, u32 cnt, u32 d_pitch,
+                                       u32 s_pitch, u32 cellsize,
+                                       struct fb_image *image, u8 *buf,
+                                       u8 *dst)
+{
+        u16 charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
+        u32 shift_low = 0, mod = vc->vc_font.width % 8;
+        u32 shift_high = 8;
+        u32 idx = vc->vc_font.width >> 3;
+        u8 *src;
+
+        while (cnt--) {
+                src = vc->vc_font.data + (scr_readw(s++)&
+                                          charmask)*cellsize;
+
+                if (attr) {
+                        update_attr(buf, src, attr, vc);
+                        src = buf;
+                }
+
+                fb_pad_unaligned_buffer(dst, d_pitch, src, idx,
+                                        image->height, shift_high,
+                                        shift_low, mod);
+                shift_low += mod;
+                dst += (shift_low >= 8) ? s_pitch : s_pitch - 1;
+                shift_low &= 7;
+                shift_high = 8 - shift_low;
+        }
+
+        info->fbops->fb_imageblit(info, image);
+
+}
+
 static void bit_putcs(struct vc_data *vc, struct fb_info *info,
                       const unsigned short *s, int count, int yy, int xx,
                       int fg, int bg)
 {
-        unsigned short charmask = vc->vc_hi_font_mask ? 0x1ff : 0xff;
-        unsigned int width = (vc->vc_font.width + 7) >> 3;
-        unsigned int cellsize = vc->vc_font.height * width;
-        unsigned int maxcnt = info->pixmap.size/cellsize;
-        unsigned int scan_align = info->pixmap.scan_align - 1;
-        unsigned int buf_align = info->pixmap.buf_align - 1;
-        unsigned int shift_low = 0, mod = vc->vc_font.width % 8;
-        unsigned int shift_high = 8, pitch, cnt, size, k;
-        unsigned int idx = vc->vc_font.width >> 3;
-        unsigned int attribute = get_attribute(info, scr_readw(s));
         struct fb_image image;
-        u8 *src, *dst, *buf = NULL;
-
-        if (attribute) {
-                buf = kmalloc(cellsize, GFP_KERNEL);
-                if (!buf)
-                        return;
-        }
+        u32 width = (vc->vc_font.width + 7)/8;
+        u32 cellsize = width * vc->vc_font.height;
+        u32 maxcnt = info->pixmap.size/cellsize;
+        u32 scan_align = info->pixmap.scan_align - 1;
+        u32 buf_align = info->pixmap.buf_align - 1;
+        u32 mod = vc->vc_font.width % 8, cnt, pitch, size;
+        u32 attribute = get_attribute(info, scr_readw(s));
+        u8 *dst, *buf = NULL;
 
         image.fg_color = fg;
         image.bg_color = bg;
-
         image.dx = xx * vc->vc_font.width;
         image.dy = yy * vc->vc_font.height;
         image.height = vc->vc_font.height;
         image.depth = 1;
 
+        if (attribute) {
+                buf = kmalloc(cellsize, GFP_KERNEL);
+                if (!buf)
+                        return;
+        }
+
         while (count) {
                 if (count > maxcnt)
-                        cnt = k = maxcnt;
+                        cnt = maxcnt;
                 else
-                        cnt = k = count;
+                        cnt = count;
 
                 image.width = vc->vc_font.width * cnt;
                 pitch = ((image.width + 7) >> 3) + scan_align;
@@ -147,41 +209,18 @@ static void bit_putcs(struct vc_data *vc, struct fb_info *info,
                 size &= ~buf_align;
                 dst = fb_get_buffer_offset(info, &info->pixmap, size);
                 image.data = dst;
-                if (mod) {
-                        while (k--) {
-                                src = vc->vc_font.data + (scr_readw(s++)&
-                                                          charmask)*cellsize;
-
-                                if (attribute) {
-                                        update_attr(buf, src, attribute, vc);
-                                        src = buf;
-                                }
-
-                                fb_pad_unaligned_buffer(dst, pitch, src, idx,
-                                                image.height, shift_high,
-                                                shift_low, mod);
-                                shift_low += mod;
-                                dst += (shift_low >= 8) ? width : width - 1;
-                                shift_low &= 7;
-                                shift_high = 8 - shift_low;
-                        }
-                } else {
-                        while (k--) {
-                                src = vc->vc_font.data + (scr_readw(s++)&
-                                                          charmask)*cellsize;
-
-                                if (attribute) {
-                                        update_attr(buf, src, attribute, vc);
-                                        src = buf;
-                                }
-
-                                fb_pad_aligned_buffer(dst, pitch, src, idx, image.height);
-                                dst += width;
-                        }
-                }
-                info->fbops->fb_imageblit(info, &image);
+
+                if (!mod)
+                        bit_putcs_aligned(vc, info, s, attribute, cnt, pitch,
+                                          width, cellsize, &image, buf, dst);
+                else
+                        bit_putcs_unaligned(vc, info, s, attribute, cnt,
+                                            pitch, width, cellsize, &image,
+                                            buf, dst);
+
                 image.dx += cnt * vc->vc_font.width;
                 count -= cnt;
+                s += cnt;
         }
 
         /* buf is always NULL except when in monochrome mode, so in this case
@@ -189,6 +228,7 @@ static void bit_putcs(struct vc_data *vc, struct fb_info *info,
            NULL pointers just fine */
         if (unlikely(buf))
                 kfree(buf);
+
 }
 
 static void bit_clear_margins(struct vc_data *vc, struct fb_info *info,
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 35c88bd7ba5e..2e93224d2d55 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -214,7 +214,7 @@ static inline int fbcon_is_inactive(struct vc_data *vc, struct fb_info *info)
 static inline int get_color(struct vc_data *vc, struct fb_info *info,
               u16 c, int is_fg)
 {
-        int depth = fb_get_color_depth(&info->var);
+        int depth = fb_get_color_depth(&info->var, &info->fix);
         int color = 0;
 
         if (console_blanked) {
@@ -230,9 +230,13 @@ static inline int get_color(struct vc_data *vc, struct fb_info *info,
         switch (depth) {
         case 1:
         {
+                int col = ~(0xfff << (max(info->var.green.length,
+                                          max(info->var.red.length,
+                                              info->var.blue.length)))) & 0xff;
+
                 /* 0 or 1 */
-                int fg = (info->fix.visual != FB_VISUAL_MONO01) ? 1 : 0;
-                int bg = (info->fix.visual != FB_VISUAL_MONO01) ? 0 : 1;
+                int fg = (info->fix.visual != FB_VISUAL_MONO01) ? col : 0;
+                int bg = (info->fix.visual != FB_VISUAL_MONO01) ? 0 : col;
 
                 if (console_blanked)
                         fg = bg;
@@ -243,9 +247,25 @@ static inline int get_color(struct vc_data *vc, struct fb_info *info,
         case 2:
                 /*
                  * Scale down 16-colors to 4 colors. Default 4-color palette
-                 * is grayscale.
+                 * is grayscale. However, simply dividing the values by 4
+                 * will not work, as colors 1, 2 and 3 will be scaled-down
+                 * to zero rendering them invisible.  So empirically convert
+                 * colors to a sane 4-level grayscale.
                  */
-                color /= 4;
+                switch (color) {
+                case 0:
+                        color = 0; /* black */
+                        break;
+                case 1 ... 6:
+                        color = 2; /* white */
+                        break;
+                case 7 ... 8:
+                        color = 1; /* gray */
+                        break;
+                default:
+                        color = 3; /* intense white */
+                        break;
+                }
                 break;
         case 3:
                 /*
@@ -311,6 +331,35 @@ static void cursor_timer_handler(unsigned long dev_addr)
         mod_timer(&ops->cursor_timer, jiffies + HZ/5);
 }
 
+static void fbcon_add_cursor_timer(struct fb_info *info)
+{
+        struct fbcon_ops *ops = info->fbcon_par;
+
+        if ((!info->queue.func || info->queue.func == fb_flashcursor) &&
+            !(ops->flags & FBCON_FLAGS_CURSOR_TIMER)) {
+                if (!info->queue.func)
+                        INIT_WORK(&info->queue, fb_flashcursor, info);
+
+                init_timer(&ops->cursor_timer);
+                ops->cursor_timer.function = cursor_timer_handler;
+                ops->cursor_timer.expires = jiffies + HZ / 5;
+                ops->cursor_timer.data = (unsigned long ) info;
+                add_timer(&ops->cursor_timer);
+                ops->flags |= FBCON_FLAGS_CURSOR_TIMER;
+        }
+}
+
+static void fbcon_del_cursor_timer(struct fb_info *info)
+{
+        struct fbcon_ops *ops = info->fbcon_par;
+
+        if (info->queue.func == fb_flashcursor &&
+            ops->flags & FBCON_FLAGS_CURSOR_TIMER) {
+                del_timer_sync(&ops->cursor_timer);
+                ops->flags &= ~FBCON_FLAGS_CURSOR_TIMER;
+        }
+}
+
 #ifndef MODULE
 static int __init fb_console_setup(char *this_opt)
 {
@@ -426,7 +475,7 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
          * remove underline attribute from erase character
          * if black and white framebuffer.
          */
-        if (fb_get_color_depth(&info->var) == 1)
+        if (fb_get_color_depth(&info->var, &info->fix) == 1)
                 erase &= ~0x400;
         logo_height = fb_prepare_logo(info);
         logo_lines = (logo_height + vc->vc_font.height - 1) /
@@ -563,9 +612,7 @@ static int con2fb_release_oldinfo(struct vc_data *vc, struct fb_info *oldinfo,
         }
 
         if (!err) {
-                if (oldinfo->queue.func == fb_flashcursor)
-                        del_timer_sync(&ops->cursor_timer);
-
+                fbcon_del_cursor_timer(oldinfo);
                 kfree(ops->cursor_state.mask);
                 kfree(ops->cursor_data);
                 kfree(oldinfo->fbcon_par);
@@ -576,22 +623,6 @@ static int con2fb_release_oldinfo(struct vc_data *vc, struct fb_info *oldinfo,
         return err;
 }
 
-static void con2fb_init_newinfo(struct fb_info *info)
-{
-        if (!info->queue.func || info->queue.func == fb_flashcursor) {
-                struct fbcon_ops *ops = info->fbcon_par;
-
-                if (!info->queue.func)
-                        INIT_WORK(&info->queue, fb_flashcursor, info);
-
-                init_timer(&ops->cursor_timer);
-                ops->cursor_timer.function = cursor_timer_handler;
-                ops->cursor_timer.expires = jiffies + HZ / 5;
-                ops->cursor_timer.data = (unsigned long ) info;
-                add_timer(&ops->cursor_timer);
-        }
-}
-
 static void con2fb_init_display(struct vc_data *vc, struct fb_info *info,
                                 int unit, int show_logo)
 {
@@ -675,7 +706,7 @@ static int set_con2fb_map(int unit, int newidx, int user)
                                  logo_shown != FBCON_LOGO_DONTSHOW);
 
                 if (!found)
-                        con2fb_init_newinfo(info);
+                        fbcon_add_cursor_timer(info);
                 con2fb_map_boot[unit] = newidx;
                 con2fb_init_display(vc, info, unit, show_logo);
         }
@@ -878,18 +909,7 @@ static const char *fbcon_startup(void)
         }
 #endif                          /* CONFIG_MAC */
 
-        /* Initialize the work queue. If the driver provides its
-         * own work queue this means it will use something besides 
-         * default timer to flash the cursor. */
-        if (!info->queue.func) {
-                INIT_WORK(&info->queue, fb_flashcursor, info);
-
-                init_timer(&ops->cursor_timer);
-                ops->cursor_timer.function = cursor_timer_handler;
-                ops->cursor_timer.expires = jiffies + HZ / 5;
-                ops->cursor_timer.data = (unsigned long ) info;
-                add_timer(&ops->cursor_timer);
-        }
+        fbcon_add_cursor_timer(info);
         return display_desc;
 }
 
@@ -930,7 +950,7 @@ static void fbcon_init(struct vc_data *vc, int init)
         }
         if (p->userfont)
                 charcnt = FNTCHARCNT(p->fontdata);
-        vc->vc_can_do_color = (fb_get_color_depth(&info->var) != 1);
+        vc->vc_can_do_color = (fb_get_color_depth(&info->var, &info->fix)!=1);
         vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
         if (charcnt == 256) {
                 vc->vc_hi_font_mask = 0;
@@ -1178,7 +1198,12 @@ static void fbcon_set_disp(struct fb_info *info, struct fb_var_screeninfo *var,
         if (p->userfont)
                 charcnt = FNTCHARCNT(p->fontdata);
 
-        vc->vc_can_do_color = (fb_get_color_depth(var) != 1);
+        var->activate = FB_ACTIVATE_NOW;
+        info->var.activate = var->activate;
+        info->var.yoffset = info->var.xoffset = 0;
+        fb_set_var(info, var);
+
+        vc->vc_can_do_color = (fb_get_color_depth(&info->var, &info->fix)!=1);
         vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
         if (charcnt == 256) {
                 vc->vc_hi_font_mask = 0;
@@ -1898,7 +1923,7 @@ static int fbcon_resize(struct vc_data *vc, unsigned int width,
 
 static int fbcon_switch(struct vc_data *vc)
 {
-        struct fb_info *info;
+        struct fb_info *info, *old_info = NULL;
         struct display *p = &fb_display[vc->vc_num];
         struct fb_var_screeninfo var;
         int i, prev_console;
@@ -1931,7 +1956,8 @@ static int fbcon_switch(struct vc_data *vc)
         }
 
         prev_console = ((struct fbcon_ops *)info->fbcon_par)->currcon;
-
+        if (prev_console != -1)
+                old_info = registered_fb[con2fb_map[prev_console]];
         /*
          * FIXME: If we have multiple fbdev's loaded, we need to
          * update all info->currcon.  Perhaps, we can place this
@@ -1959,15 +1985,17 @@ static int fbcon_switch(struct vc_data *vc)
         info->var.yoffset = info->var.xoffset = p->yscroll = 0;
         fb_set_var(info, &var);
 
-        if (prev_console != -1 &&
-            registered_fb[con2fb_map[prev_console]] != info &&
-            info->fbops->fb_set_par)
-                info->fbops->fb_set_par(info);
+        if (old_info != NULL && old_info != info) {
+                if (info->fbops->fb_set_par)
+                        info->fbops->fb_set_par(info);
+                fbcon_del_cursor_timer(old_info);
+                fbcon_add_cursor_timer(info);
+        }
 
         set_blitting_type(vc, info, p);
         ((struct fbcon_ops *)info->fbcon_par)->cursor_reset = 1;
 
-        vc->vc_can_do_color = (fb_get_color_depth(&info->var) != 1);
+        vc->vc_can_do_color = (fb_get_color_depth(&info->var, &info->fix)!=1);
         vc->vc_complement_mask = vc->vc_can_do_color ? 0x7700 : 0x0800;
         updatescrollmode(p, info, vc);
 
@@ -2048,11 +2076,16 @@ static int fbcon_blank(struct vc_data *vc, int blank, int mode_switch)
                                 fbcon_generic_blank(vc, info, blank);
                 }
 
-                if (!blank)
-                        update_screen(vc);
-        }
+                if (!blank)
+                        update_screen(vc);
+        }
 
-        return 0;
+        if (!blank)
+                fbcon_add_cursor_timer(info);
+        else
+                fbcon_del_cursor_timer(info);
+
+        return 0;
 }
 
 static void fbcon_free_font(struct display *p)
@@ -2332,7 +2365,7 @@ static int fbcon_set_palette(struct vc_data *vc, unsigned char *table)
         if (!CON_IS_VISIBLE(vc))
                 return 0;
 
-        depth = fb_get_color_depth(&info->var);
+        depth = fb_get_color_depth(&info->var, &info->fix);
         if (depth > 3) {
                 for (i = j = 0; i < 16; i++) {
                         k = table[i];
@@ -2593,6 +2626,51 @@ static void fbcon_modechanged(struct fb_info *info)
         }
 }
 
+static void fbcon_set_all_vcs(struct fb_info *info)
+{
+        struct fbcon_ops *ops = info->fbcon_par;
+        struct vc_data *vc;
+        struct display *p;
+        int i, rows, cols;
+
+        if (!ops || ops->currcon < 0)
+                return;
+
+        for (i = 0; i < MAX_NR_CONSOLES; i++) {
+                vc = vc_cons[i].d;
+                if (!vc || vc->vc_mode != KD_TEXT ||
+                    registered_fb[con2fb_map[i]] != info)
+                        continue;
+
+                p = &fb_display[vc->vc_num];
+
+                info->var.xoffset = info->var.yoffset = p->yscroll = 0;
+                var_to_display(p, &info->var, info);
+                cols = info->var.xres / vc->vc_font.width;
+                rows = info->var.yres / vc->vc_font.height;
+                vc_resize(vc, cols, rows);
+
+                if (CON_IS_VISIBLE(vc)) {
+                        updatescrollmode(p, info, vc);
+                        scrollback_max = 0;
+                        scrollback_current = 0;
+                        update_var(vc->vc_num, info);
+                        fbcon_set_palette(vc, color_table);
+                        update_screen(vc);
+                        if (softback_buf) {
+                                int l = fbcon_softback_size / vc->vc_size_row;
+                                if (l > 5)
+                                        softback_end = softback_buf + l * vc->vc_size_row;
+                                else {
+                                        /* Smaller scrollback makes no sense, and 0
+                                           would screw the operation totally */
+                                        softback_top = 0;
+                                }
+                        }
+                }
+        }
+}
+
 static int fbcon_mode_deleted(struct fb_info *info,
                               struct fb_videomode *mode)
 {
@@ -2708,6 +2786,9 @@ static int fbcon_event_notify(struct notifier_block *self,
         case FB_EVENT_MODE_CHANGE:
                 fbcon_modechanged(info);
                 break;
+        case FB_EVENT_MODE_CHANGE_ALL:
+                fbcon_set_all_vcs(info);
+                break;
         case FB_EVENT_MODE_DELETE:
                 mode = event->data;
                 ret = fbcon_mode_deleted(info, mode);
diff --git a/drivers/video/console/fbcon.h b/drivers/video/console/fbcon.h
index 5d377860bce2..08befafe11d1 100644
--- a/drivers/video/console/fbcon.h
+++ b/drivers/video/console/fbcon.h
@@ -18,7 +18,8 @@
 
 #include <asm/io.h>
 
-#define FBCON_FLAGS_INIT 1
+#define FBCON_FLAGS_INIT         1
+#define FBCON_FLAGS_CURSOR_TIMER 2
 
    /*
     *    This is the interface between the low-level console driver and the
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index d27fa91e5886..0705cd741411 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -497,6 +497,57 @@ static void vgacon_cursor(struct vc_data *c, int mode)
         }
 }
 
+static int vgacon_doresize(struct vc_data *c,
+                unsigned int width, unsigned int height)
+{
+        unsigned long flags;
+        unsigned int scanlines = height * c->vc_font.height;
+        u8 scanlines_lo, r7, vsync_end, mode;
+
+        spin_lock_irqsave(&vga_lock, flags);
+
+        outb_p(VGA_CRTC_MODE, vga_video_port_reg);
+        mode = inb_p(vga_video_port_val);
+
+        if (mode & 0x04)
+                scanlines >>= 1;
+
+        scanlines -= 1;
+        scanlines_lo = scanlines & 0xff;
+
+        outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
+        r7 = inb_p(vga_video_port_val) & ~0x42;
+
+        if (scanlines & 0x100)
+                r7 |= 0x02;
+        if (scanlines & 0x200)
+                r7 |= 0x40;
+
+        /* deprotect registers */
+        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+        vsync_end = inb_p(vga_video_port_val);
+        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+        outb_p(vsync_end & ~0x80, vga_video_port_val);
+
+        outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
+        outb_p(width - 1, vga_video_port_val);
+        outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
+        outb_p(width >> 1, vga_video_port_val);
+
+        outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
+        outb_p(scanlines_lo, vga_video_port_val);
+        outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
+        outb_p(r7,vga_video_port_val);
+
+        /* reprotect registers */
+        outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
+        outb_p(vsync_end, vga_video_port_val);
+
+        spin_unlock_irqrestore(&vga_lock, flags);
+
+        return 0;
+}
+
 static int vgacon_switch(struct vc_data *c)
 {
         /*
@@ -510,9 +561,13 @@ static int vgacon_switch(struct vc_data *c)
         /* We can only copy out the size of the video buffer here,
          * otherwise we get into VGA BIOS */
 
-        if (!vga_is_gfx)
+        if (!vga_is_gfx) {
                 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
-                            c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
+                            c->vc_screenbuf_size > vga_vram_size ?
+                                vga_vram_size : c->vc_screenbuf_size);
+                vgacon_doresize(c, c->vc_cols, c->vc_rows);
+        }
+
         return 0;               /* Redrawing not needed */
 }
 
@@ -962,6 +1017,17 @@ static int vgacon_font_get(struct vc_data *c, struct console_font *font)
 
 #endif
 
+static int vgacon_resize(struct vc_data *c, unsigned int width,
+                                unsigned int height)
+{
+        if (width % 2 || width > ORIG_VIDEO_COLS || height > ORIG_VIDEO_LINES)
+                return -EINVAL;
+
+        if (CON_IS_VISIBLE(c) && !vga_is_gfx) /* who knows */
+                vgacon_doresize(c, width, height);
+        return 0;
+}
+
 static int vgacon_scrolldelta(struct vc_data *c, int lines)
 {
         if (!lines)             /* Turn scrollback off */
@@ -1103,6 +1169,7 @@ const struct consw vga_con = {
         .con_blank = vgacon_blank,
         .con_font_set = vgacon_font_set,
         .con_font_get = vgacon_font_get,
+        .con_resize = vgacon_resize,
         .con_set_palette = vgacon_set_palette,
         .con_scrolldelta = vgacon_scrolldelta,
         .con_set_origin = vgacon_set_origin,