if (vc->vc_mode != KD_TEXT)
                rc = -EINVAL;
        else if (vc->vc_sw->con_font_get)
-               rc = vc->vc_sw->con_font_get(vc, &font);
+               rc = vc->vc_sw->con_font_get(vc, &font, 32);
        else
                rc = -ENOSYS;
        console_unlock();
        else if (vc->vc_sw->con_font_set) {
                if (vc_is_sel(vc))
                        clear_selection();
-               rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
+               rc = vc->vc_sw->con_font_set(vc, &font, 32, op->flags);
        } else
                rc = -ENOSYS;
        console_unlock();
 
        return 1;
 }
 
-static int newport_set_font(int unit, struct console_font *op)
+static int newport_set_font(int unit, struct console_font *op, unsigned int vpitch)
 {
        int w = op->width;
        int h = op->height;
 
        /* ladis: when I grow up, there will be a day... and more sizes will
         * be supported ;-) */
-       if ((w != 8) || (h != 16)
+       if ((w != 8) || (h != 16) || (vpitch != 32)
            || (op->charcount != 256 && op->charcount != 512))
                return -EINVAL;
 
        return newport_set_def_font(vc->vc_num, op);
 }
 
-static int newport_font_set(struct vc_data *vc, struct console_font *font, unsigned flags)
+static int newport_font_set(struct vc_data *vc, struct console_font *font,
+                           unsigned int vpitch, unsigned int flags)
 {
-       return newport_set_font(vc->vc_num, font);
+       return newport_set_font(vc->vc_num, font, vpitch);
 }
 
 static bool newport_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
 
        return 0;
 }
 
-static int sticon_set_font(struct vc_data *vc, struct console_font *op)
+static int sticon_set_font(struct vc_data *vc, struct console_font *op,
+                          unsigned int vpitch)
 {
        struct sti_struct *sti = sticon_sti;
        int vc_cols, vc_rows, vc_old_cols, vc_old_rows;
        struct sti_cooked_font *cooked_font;
        unsigned char *data = op->data, *p;
 
-       if ((w < 6) || (h < 6) || (w > 32) || (h > 32)
+       if ((w < 6) || (h < 6) || (w > 32) || (h > 32) || (vpitch != 32)
            || (op->charcount != 256 && op->charcount != 512))
                return -EINVAL;
        pitch = ALIGN(w, 8) / 8;
 }
 
 static int sticon_font_set(struct vc_data *vc, struct console_font *font,
-                          unsigned int flags)
+                          unsigned int vpitch, unsigned int flags)
 {
-       return sticon_set_font(vc, font);
+       return sticon_set_font(vc, font, vpitch);
 }
 
 static void sticon_init(struct vc_data *c, int init)
 
 }
 
 static int vgacon_font_set(struct vc_data *c, struct console_font *font,
-                          unsigned int flags)
+                          unsigned int vpitch, unsigned int flags)
 {
        unsigned charcount = font->charcount;
        int rc;
        if (vga_video_type < VIDEO_TYPE_EGAM)
                return -EINVAL;
 
-       if (font->width != VGA_FONTWIDTH ||
+       if (font->width != VGA_FONTWIDTH || vpitch != 32 ||
            (charcount != 256 && charcount != 512))
                return -EINVAL;
 
        return rc;
 }
 
-static int vgacon_font_get(struct vc_data *c, struct console_font *font)
+static int vgacon_font_get(struct vc_data *c, struct console_font *font, unsigned int vpitch)
 {
-       if (vga_video_type < VIDEO_TYPE_EGAM)
+       if (vga_video_type < VIDEO_TYPE_EGAM || vpitch != 32)
                return -EINVAL;
 
        font->width = VGA_FONTWIDTH;
 
        return 0;
 }
 
-static int fbcon_get_font(struct vc_data *vc, struct console_font *font)
+static int fbcon_get_font(struct vc_data *vc, struct console_font *font, unsigned int vpitch)
 {
        u8 *fontdata = vc->vc_font.data;
        u8 *data = font->data;
 
                for (i = 0; i < font->charcount; i++) {
                        memcpy(data, fontdata, j);
-                       memset(data + j, 0, 32 - j);
-                       data += 32;
+                       memset(data + j, 0, vpitch - j);
+                       data += vpitch;
                        fontdata += j;
                }
        } else if (font->width <= 16) {
 
                for (i = 0; i < font->charcount; i++) {
                        memcpy(data, fontdata, j);
-                       memset(data + j, 0, 64 - j);
-                       data += 64;
+                       memset(data + j, 0, 2*vpitch - j);
+                       data += 2*vpitch;
                        fontdata += j;
                }
        } else if (font->width <= 24) {
                                *data++ = fontdata[2];
                                fontdata += sizeof(u32);
                        }
-                       memset(data, 0, 3 * (32 - j));
-                       data += 3 * (32 - j);
+                       memset(data, 0, 3 * (vpitch - j));
+                       data += 3 * (vpitch - j);
                }
        } else {
                j = vc->vc_font.height * 4;
 
                for (i = 0; i < font->charcount; i++) {
                        memcpy(data, fontdata, j);
-                       memset(data + j, 0, 128 - j);
-                       data += 128;
+                       memset(data + j, 0, 4 * vpitch - j);
+                       data += 4 * vpitch;
                        fontdata += j;
                }
        }
 }
 
 /*
- *  User asked to set font; we are guaranteed that
- *     a) width and height are in range 1..32
- *     b) charcount does not exceed 512
- *  but lets not assume that, since someone might someday want to use larger
- *  fonts. And charcount of 512 is small for unicode support.
- *
- *  However, user space gives the font in 32 rows , regardless of
- *  actual font height. So a new API is needed if support for larger fonts
- *  is ever implemented.
+ *  User asked to set font; we are guaranteed that charcount does not exceed 512
+ *  but lets not assume that, since charcount of 512 is small for unicode support.
  */
 
 static int fbcon_set_font(struct vc_data *vc, struct console_font *font,
-                         unsigned int flags)
+                         unsigned int vpitch, unsigned int flags)
 {
        struct fb_info *info = fbcon_info_from_console(vc->vc_num);
        unsigned charcount = font->charcount;
        FNTSIZE(new_data) = size;
        REFCOUNT(new_data) = 0; /* usage counter */
        for (i=0; i< charcount; i++) {
-               memcpy(new_data + i*h*pitch, data +  i*32*pitch, h*pitch);
+               memcpy(new_data + i*h*pitch, data +  i*vpitch*pitch, h*pitch);
        }
 
        /* Since linux has a nice crc32 function use it for counting font
 
        int     (*con_switch)(struct vc_data *vc);
        int     (*con_blank)(struct vc_data *vc, int blank, int mode_switch);
        int     (*con_font_set)(struct vc_data *vc, struct console_font *font,
-                       unsigned int flags);
-       int     (*con_font_get)(struct vc_data *vc, struct console_font *font);
+                       unsigned int vpitch, unsigned int flags);
+       int     (*con_font_get)(struct vc_data *vc, struct console_font *font,
+                       unsigned int vpitch);
        int     (*con_font_default)(struct vc_data *vc,
                        struct console_font *font, char *name);
        int     (*con_resize)(struct vc_data *vc, unsigned int width,