drivers/video/console/vgacon.c

   1 /*
   2  *  linux/drivers/video/vgacon.c -- Low level VGA based console driver
   3  *
   4  *      Created 28 Sep 1997 by Geert Uytterhoeven
   5  *
   6  *      Rewritten by Martin Mares <mj@ucw.cz>, July 1998
   7  *
   8  *  This file is based on the old console.c, vga.c and vesa_blank.c drivers.
   9  *
  10  *      Copyright (C) 1991, 1992  Linus Torvalds
  11  *                          1995  Jay Estabrook
  12  *
  13  *      User definable mapping table and font loading by Eugene G. Crosser,
  14  *      <crosser@average.org>
  15  *
  16  *      Improved loadable font/UTF-8 support by H. Peter Anvin
  17  *      Feb-Sep 1995 <peter.anvin@linux.org>
  18  *
  19  *      Colour palette handling, by Simon Tatham
  20  *      17-Jun-95 <sgt20@cam.ac.uk>
  21  *
  22  *      if 512 char mode is already enabled don't re-enable it,
  23  *      because it causes screen to flicker, by Mitja Horvat
  24  *      5-May-96 <mitja.horvat@guest.arnes.si>
  25  *
  26  *      Use 2 outw instead of 4 outb_p to reduce erroneous text
  27  *      flashing on RHS of screen during heavy console scrolling .
  28  *      Oct 1996, Paul Gortmaker.
  29  *
  30  *
  31  *  This file is subject to the terms and conditions of the GNU General Public
  32  *  License.  See the file COPYING in the main directory of this archive for
  33  *  more details.
  34  */
  35
  36 #include <linux/module.h>
  37 #include <linux/types.h>
  38 #include <linux/fs.h>
  39 #include <linux/kernel.h>
  40 #include <linux/console.h>
  41 #include <linux/string.h>
  42 #include <linux/kd.h>
  43 #include <linux/slab.h>
  44 #include <linux/vt_kern.h>
  45 #include <linux/sched.h>
  46 #include <linux/selection.h>
  47 #include <linux/spinlock.h>
  48 #include <linux/ioport.h>
  49 #include <linux/init.h>
  50 #include <linux/screen_info.h>
  51 #include <video/vga.h>
  52 #include <asm/io.h>
  53
  54 static DEFINE_RAW_SPINLOCK(vga_lock);
  55 static int cursor_size_lastfrom;
  56 static int cursor_size_lastto;
  57 static u32 vgacon_xres;
  58 static u32 vgacon_yres;
  59 static struct vgastate vgastate;
  60
  61 #define BLANK 0x0020
  62
  63 #define VGA_FONTWIDTH       8   /* VGA does not support fontwidths != 8 */
  64 /*
  65  *  Interface used by the world
  66  */
  67
  68 static const char *vgacon_startup(void);
  69 static void vgacon_init(struct vc_data *c, int init);
  70 static void vgacon_deinit(struct vc_data *c);
  71 static void vgacon_cursor(struct vc_data *c, int mode);
  72 static int vgacon_switch(struct vc_data *c);
  73 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch);
  74 static void vgacon_scrolldelta(struct vc_data *c, int lines);
  75 static int vgacon_set_origin(struct vc_data *c);
  76 static void vgacon_save_screen(struct vc_data *c);
  77 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
  78 static struct uni_pagedir *vgacon_uni_pagedir;
  79 static int vgacon_refcount;
  80
  81 /* Description of the hardware situation */
  82 static bool             vga_init_done;
  83 static unsigned long    vga_vram_base           __read_mostly;  /* Base of video memory */
  84 static unsigned long    vga_vram_end            __read_mostly;  /* End of video memory */
  85 static unsigned int     vga_vram_size           __read_mostly;  /* Size of video memory */
  86 static u16              vga_video_port_reg      __read_mostly;  /* Video register select port */
  87 static u16              vga_video_port_val      __read_mostly;  /* Video register value port */
  88 static unsigned int     vga_video_num_columns;                  /* Number of text columns */
  89 static unsigned int     vga_video_num_lines;                    /* Number of text lines */
  90 static bool             vga_can_do_color;                       /* Do we support colors? */
  91 static unsigned int     vga_default_font_height __read_mostly;  /* Height of default screen font */
  92 static unsigned char    vga_video_type          __read_mostly;  /* Card type */
  93 static bool             vga_font_is_default = true;
  94 static int              vga_vesa_blanked;
  95 static bool             vga_palette_blanked;
  96 static bool             vga_is_gfx;
  97 static bool             vga_512_chars;
  98 static int              vga_video_font_height;
  99 static int              vga_scan_lines          __read_mostly;
 100 static unsigned int     vga_rolled_over;
 101
 102 static bool vgacon_text_mode_force;
 103 static bool vga_hardscroll_enabled;
 104 static bool vga_hardscroll_user_enable = true;
 105
 106 bool vgacon_text_force(void)
 107 {
 108         return vgacon_text_mode_force;
 109 }
 110 EXPORT_SYMBOL(vgacon_text_force);
 111
 112 static int __init text_mode(char *str)
 113 {
 114         vgacon_text_mode_force = true;
 115         return 1;
 116 }
 117
 118 /* force text mode - used by kernel modesetting */
 119 __setup("nomodeset", text_mode);
 120
 121 static int __init no_scroll(char *str)
 122 {
 123         /*
 124          * Disabling scrollback is required for the Braillex ib80-piezo
 125          * Braille reader made by F.H. Papenmeier (Germany).
 126          * Use the "no-scroll" bootflag.
 127          */
 128         vga_hardscroll_user_enable = vga_hardscroll_enabled = false;
 129         return 1;
 130 }
 131
 132 __setup("no-scroll", no_scroll);
 133
 134 /*
 135  * By replacing the four outb_p with two back to back outw, we can reduce
 136  * the window of opportunity to see text mislocated to the RHS of the
 137  * console during heavy scrolling activity. However there is the remote
 138  * possibility that some pre-dinosaur hardware won't like the back to back
 139  * I/O. Since the Xservers get away with it, we should be able to as well.
 140  */
 141 static inline void write_vga(unsigned char reg, unsigned int val)
 142 {
 143         unsigned int v1, v2;
 144         unsigned long flags;
 145
 146         /*
 147          * ddprintk might set the console position from interrupt
 148          * handlers, thus the write has to be IRQ-atomic.
 149          */
 150         raw_spin_lock_irqsave(&vga_lock, flags);
 151         v1 = reg + (val & 0xff00);
 152         v2 = reg + 1 + ((val << 8) & 0xff00);
 153         outw(v1, vga_video_port_reg);
 154         outw(v2, vga_video_port_reg);
 155         raw_spin_unlock_irqrestore(&vga_lock, flags);
 156 }
 157
 158 static inline void vga_set_mem_top(struct vc_data *c)
 159 {
 160         write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
 161 }
 162
 163 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
 164 /* software scrollback */
 165 static void *vgacon_scrollback;
 166 static int vgacon_scrollback_tail;
 167 static int vgacon_scrollback_size;
 168 static int vgacon_scrollback_rows;
 169 static int vgacon_scrollback_cnt;
 170 static int vgacon_scrollback_cur;
 171 static int vgacon_scrollback_save;
 172 static int vgacon_scrollback_restore;
 173
 174 static void vgacon_scrollback_init(int pitch)
 175 {
 176         int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
 177
 178         if (vgacon_scrollback) {
 179                 vgacon_scrollback_cnt  = 0;
 180                 vgacon_scrollback_tail = 0;
 181                 vgacon_scrollback_cur  = 0;
 182                 vgacon_scrollback_rows = rows - 1;
 183                 vgacon_scrollback_size = rows * pitch;
 184         }
 185 }
 186
 187 static void vgacon_scrollback_startup(void)
 188 {
 189         vgacon_scrollback = kcalloc(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE, 1024, GFP_NOWAIT);
 190         vgacon_scrollback_init(vga_video_num_columns * 2);
 191 }
 192
 193 static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
 194 {
 195         void *p;
 196
 197         if (!vgacon_scrollback_size || c->vc_num != fg_console)
 198                 return;
 199
 200         p = (void *) (c->vc_origin + t * c->vc_size_row);
 201
 202         while (count--) {
 203                 scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
 204                             p, c->vc_size_row);
 205                 vgacon_scrollback_cnt++;
 206                 p += c->vc_size_row;
 207                 vgacon_scrollback_tail += c->vc_size_row;
 208
 209                 if (vgacon_scrollback_tail >= vgacon_scrollback_size)
 210                         vgacon_scrollback_tail = 0;
 211
 212                 if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
 213                         vgacon_scrollback_cnt = vgacon_scrollback_rows;
 214
 215                 vgacon_scrollback_cur = vgacon_scrollback_cnt;
 216         }
 217 }
 218
 219 static void vgacon_restore_screen(struct vc_data *c)
 220 {
 221         vgacon_scrollback_save = 0;
 222
 223         if (!vga_is_gfx && !vgacon_scrollback_restore) {
 224                 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
 225                             c->vc_screenbuf_size > vga_vram_size ?
 226                             vga_vram_size : c->vc_screenbuf_size);
 227                 vgacon_scrollback_restore = 1;
 228                 vgacon_scrollback_cur = vgacon_scrollback_cnt;
 229         }
 230 }
 231
 232 static void vgacon_scrolldelta(struct vc_data *c, int lines)
 233 {
 234         int start, end, count, soff;
 235
 236         if (!lines) {
 237                 c->vc_visible_origin = c->vc_origin;
 238                 vga_set_mem_top(c);
 239                 return;
 240         }
 241
 242         if (!vgacon_scrollback)
 243                 return;
 244
 245         if (!vgacon_scrollback_save) {
 246                 vgacon_cursor(c, CM_ERASE);
 247                 vgacon_save_screen(c);
 248                 vgacon_scrollback_save = 1;
 249         }
 250
 251         vgacon_scrollback_restore = 0;
 252         start = vgacon_scrollback_cur + lines;
 253         end = start + abs(lines);
 254
 255         if (start < 0)
 256                 start = 0;
 257
 258         if (start > vgacon_scrollback_cnt)
 259                 start = vgacon_scrollback_cnt;
 260
 261         if (end < 0)
 262                 end = 0;
 263
 264         if (end > vgacon_scrollback_cnt)
 265                 end = vgacon_scrollback_cnt;
 266
 267         vgacon_scrollback_cur = start;
 268         count = end - start;
 269         soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
 270                                          c->vc_size_row);
 271         soff -= count * c->vc_size_row;
 272
 273         if (soff < 0)
 274                 soff += vgacon_scrollback_size;
 275
 276         count = vgacon_scrollback_cnt - start;
 277
 278         if (count > c->vc_rows)
 279                 count = c->vc_rows;
 280
 281         if (count) {
 282                 int copysize;
 283
 284                 int diff = c->vc_rows - count;
 285                 void *d = (void *) c->vc_origin;
 286                 void *s = (void *) c->vc_screenbuf;
 287
 288                 count *= c->vc_size_row;
 289                 /* how much memory to end of buffer left? */
 290                 copysize = min(count, vgacon_scrollback_size - soff);
 291                 scr_memcpyw(d, vgacon_scrollback + soff, copysize);
 292                 d += copysize;
 293                 count -= copysize;
 294
 295                 if (count) {
 296                         scr_memcpyw(d, vgacon_scrollback, count);
 297                         d += count;
 298                 }
 299
 300                 if (diff)
 301                         scr_memcpyw(d, s, diff * c->vc_size_row);
 302         } else
 303                 vgacon_cursor(c, CM_MOVE);
 304 }
 305 #else
 306 #define vgacon_scrollback_startup(...) do { } while (0)
 307 #define vgacon_scrollback_init(...)    do { } while (0)
 308 #define vgacon_scrollback_update(...)  do { } while (0)
 309
 310 static void vgacon_restore_screen(struct vc_data *c)
 311 {
 312         if (c->vc_origin != c->vc_visible_origin)
 313                 vgacon_scrolldelta(c, 0);
 314 }
 315
 316 static void vgacon_scrolldelta(struct vc_data *c, int lines)
 317 {
 318         vc_scrolldelta_helper(c, lines, vga_rolled_over, (void *)vga_vram_base,
 319                         vga_vram_size);
 320         vga_set_mem_top(c);
 321 }
 322 #endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
 323
 324 static const char *vgacon_startup(void)
 325 {
 326         const char *display_desc = NULL;
 327         u16 saved1, saved2;
 328         volatile u16 *p;
 329
 330         if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB ||
 331             screen_info.orig_video_isVGA == VIDEO_TYPE_EFI) {
 332               no_vga:
 333 #ifdef CONFIG_DUMMY_CONSOLE
 334                 conswitchp = &dummy_con;
 335                 return conswitchp->con_startup();
 336 #else
 337                 return NULL;
 338 #endif
 339         }
 340
 341         /* boot_params.screen_info initialized? */
 342         if ((screen_info.orig_video_mode  == 0) &&
 343             (screen_info.orig_video_lines == 0) &&
 344             (screen_info.orig_video_cols  == 0))
 345                 goto no_vga;
 346
 347         /* VGA16 modes are not handled by VGACON */
 348         if ((screen_info.orig_video_mode == 0x0D) ||    /* 320x200/4 */
 349             (screen_info.orig_video_mode == 0x0E) ||    /* 640x200/4 */
 350             (screen_info.orig_video_mode == 0x10) ||    /* 640x350/4 */
 351             (screen_info.orig_video_mode == 0x12) ||    /* 640x480/4 */
 352             (screen_info.orig_video_mode == 0x6A))      /* 800x600/4 (VESA) */
 353                 goto no_vga;
 354
 355         vga_video_num_lines = screen_info.orig_video_lines;
 356         vga_video_num_columns = screen_info.orig_video_cols;
 357         vgastate.vgabase = NULL;
 358
 359         if (screen_info.orig_video_mode == 7) {
 360                 /* Monochrome display */
 361                 vga_vram_base = 0xb0000;
 362                 vga_video_port_reg = VGA_CRT_IM;
 363                 vga_video_port_val = VGA_CRT_DM;
 364                 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
 365                         static struct resource ega_console_resource =
 366                             { .name = "ega", .start = 0x3B0, .end = 0x3BF };
 367                         vga_video_type = VIDEO_TYPE_EGAM;
 368                         vga_vram_size = 0x8000;
 369                         display_desc = "EGA+";
 370                         request_resource(&ioport_resource,
 371                                          &ega_console_resource);
 372                 } else {
 373                         static struct resource mda1_console_resource =
 374                             { .name = "mda", .start = 0x3B0, .end = 0x3BB };
 375                         static struct resource mda2_console_resource =
 376                             { .name = "mda", .start = 0x3BF, .end = 0x3BF };
 377                         vga_video_type = VIDEO_TYPE_MDA;
 378                         vga_vram_size = 0x2000;
 379                         display_desc = "*MDA";
 380                         request_resource(&ioport_resource,
 381                                          &mda1_console_resource);
 382                         request_resource(&ioport_resource,
 383                                          &mda2_console_resource);
 384                         vga_video_font_height = 14;
 385                 }
 386         } else {
 387                 /* If not, it is color. */
 388                 vga_can_do_color = true;
 389                 vga_vram_base = 0xb8000;
 390                 vga_video_port_reg = VGA_CRT_IC;
 391                 vga_video_port_val = VGA_CRT_DC;
 392                 if ((screen_info.orig_video_ega_bx & 0xff) != 0x10) {
 393                         int i;
 394
 395                         vga_vram_size = 0x8000;
 396
 397                         if (!screen_info.orig_video_isVGA) {
 398                                 static struct resource ega_console_resource
 399                                     = { .name = "ega", .start = 0x3C0, .end = 0x3DF };
 400                                 vga_video_type = VIDEO_TYPE_EGAC;
 401                                 display_desc = "EGA";
 402                                 request_resource(&ioport_resource,
 403                                                  &ega_console_resource);
 404                         } else {
 405                                 static struct resource vga_console_resource
 406                                     = { .name = "vga+", .start = 0x3C0, .end = 0x3DF };
 407                                 vga_video_type = VIDEO_TYPE_VGAC;
 408                                 display_desc = "VGA+";
 409                                 request_resource(&ioport_resource,
 410                                                  &vga_console_resource);
 411
 412                                 /*
 413                                  * Normalise the palette registers, to point
 414                                  * the 16 screen colours to the first 16
 415                                  * DAC entries.
 416                                  */
 417
 418                                 for (i = 0; i < 16; i++) {
 419                                         inb_p(VGA_IS1_RC);
 420                                         outb_p(i, VGA_ATT_W);
 421                                         outb_p(i, VGA_ATT_W);
 422                                 }
 423                                 outb_p(0x20, VGA_ATT_W);
 424
 425                                 /*
 426                                  * Now set the DAC registers back to their
 427                                  * default values
 428                                  */
 429                                 for (i = 0; i < 16; i++) {
 430                                         outb_p(color_table[i], VGA_PEL_IW);
 431                                         outb_p(default_red[i], VGA_PEL_D);
 432                                         outb_p(default_grn[i], VGA_PEL_D);
 433                                         outb_p(default_blu[i], VGA_PEL_D);
 434                                 }
 435                         }
 436                 } else {
 437                         static struct resource cga_console_resource =
 438                             { .name = "cga", .start = 0x3D4, .end = 0x3D5 };
 439                         vga_video_type = VIDEO_TYPE_CGA;
 440                         vga_vram_size = 0x2000;
 441                         display_desc = "*CGA";
 442                         request_resource(&ioport_resource,
 443                                          &cga_console_resource);
 444                         vga_video_font_height = 8;
 445                 }
 446         }
 447
 448         vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
 449         vga_vram_end = vga_vram_base + vga_vram_size;
 450
 451         /*
 452          *      Find out if there is a graphics card present.
 453          *      Are there smarter methods around?
 454          */
 455         p = (volatile u16 *) vga_vram_base;
 456         saved1 = scr_readw(p);
 457         saved2 = scr_readw(p + 1);
 458         scr_writew(0xAA55, p);
 459         scr_writew(0x55AA, p + 1);
 460         if (scr_readw(p) != 0xAA55 || scr_readw(p + 1) != 0x55AA) {
 461                 scr_writew(saved1, p);
 462                 scr_writew(saved2, p + 1);
 463                 goto no_vga;
 464         }
 465         scr_writew(0x55AA, p);
 466         scr_writew(0xAA55, p + 1);
 467         if (scr_readw(p) != 0x55AA || scr_readw(p + 1) != 0xAA55) {
 468                 scr_writew(saved1, p);
 469                 scr_writew(saved2, p + 1);
 470                 goto no_vga;
 471         }
 472         scr_writew(saved1, p);
 473         scr_writew(saved2, p + 1);
 474
 475         if (vga_video_type == VIDEO_TYPE_EGAC
 476             || vga_video_type == VIDEO_TYPE_VGAC
 477             || vga_video_type == VIDEO_TYPE_EGAM) {
 478                 vga_hardscroll_enabled = vga_hardscroll_user_enable;
 479                 vga_default_font_height = screen_info.orig_video_points;
 480                 vga_video_font_height = screen_info.orig_video_points;
 481                 /* This may be suboptimal but is a safe bet - go with it */
 482                 vga_scan_lines =
 483                     vga_video_font_height * vga_video_num_lines;
 484         }
 485
 486         vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
 487         vgacon_yres = vga_scan_lines;
 488
 489         if (!vga_init_done) {
 490                 vgacon_scrollback_startup();
 491                 vga_init_done = true;
 492         }
 493
 494         return display_desc;
 495 }
 496
 497 static void vgacon_init(struct vc_data *c, int init)
 498 {
 499         struct uni_pagedir *p;
 500
 501         /*
 502          * We cannot be loaded as a module, therefore init is always 1,
 503          * but vgacon_init can be called more than once, and init will
 504          * not be 1.
 505          */
 506         c->vc_can_do_color = vga_can_do_color;
 507
 508         /* set dimensions manually if init != 0 since vc_resize() will fail */
 509         if (init) {
 510                 c->vc_cols = vga_video_num_columns;
 511                 c->vc_rows = vga_video_num_lines;
 512         } else
 513                 vc_resize(c, vga_video_num_columns, vga_video_num_lines);
 514
 515         c->vc_scan_lines = vga_scan_lines;
 516         c->vc_font.height = vga_video_font_height;
 517         c->vc_complement_mask = 0x7700;
 518         if (vga_512_chars)
 519                 c->vc_hi_font_mask = 0x0800;
 520         p = *c->vc_uni_pagedir_loc;
 521         if (c->vc_uni_pagedir_loc != &vgacon_uni_pagedir) {
 522                 con_free_unimap(c);
 523                 c->vc_uni_pagedir_loc = &vgacon_uni_pagedir;
 524                 vgacon_refcount++;
 525         }
 526         if (!vgacon_uni_pagedir && p)
 527                 con_set_default_unimap(c);
 528
 529         /* Only set the default if the user didn't deliberately override it */
 530         if (global_cursor_default == -1)
 531                 global_cursor_default =
 532                         !(screen_info.flags & VIDEO_FLAGS_NOCURSOR);
 533 }
 534
 535 static void vgacon_deinit(struct vc_data *c)
 536 {
 537         /* When closing the active console, reset video origin */
 538         if (con_is_visible(c)) {
 539                 c->vc_visible_origin = vga_vram_base;
 540                 vga_set_mem_top(c);
 541         }
 542
 543         if (!--vgacon_refcount)
 544                 con_free_unimap(c);
 545         c->vc_uni_pagedir_loc = &c->vc_uni_pagedir;
 546         con_set_default_unimap(c);
 547 }
 548
 549 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
 550                             u8 blink, u8 underline, u8 reverse, u8 italic)
 551 {
 552         u8 attr = color;
 553
 554         if (vga_can_do_color) {
 555                 if (italic)
 556                         attr = (attr & 0xF0) | c->vc_itcolor;
 557                 else if (underline)
 558                         attr = (attr & 0xf0) | c->vc_ulcolor;
 559                 else if (intensity == 0)
 560                         attr = (attr & 0xf0) | c->vc_halfcolor;
 561         }
 562         if (reverse)
 563                 attr =
 564                     ((attr) & 0x88) | ((((attr) >> 4) | ((attr) << 4)) &
 565                                        0x77);
 566         if (blink)
 567                 attr ^= 0x80;
 568         if (intensity == 2)
 569                 attr ^= 0x08;
 570         if (!vga_can_do_color) {
 571                 if (italic)
 572                         attr = (attr & 0xF8) | 0x02;
 573                 else if (underline)
 574                         attr = (attr & 0xf8) | 0x01;
 575                 else if (intensity == 0)
 576                         attr = (attr & 0xf0) | 0x08;
 577         }
 578         return attr;
 579 }
 580
 581 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count)
 582 {
 583         const bool col = vga_can_do_color;
 584
 585         while (count--) {
 586                 u16 a = scr_readw(p);
 587                 if (col)
 588                         a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
 589                             (((a) & 0x0700) << 4);
 590                 else
 591                         a ^= ((a & 0x0700) == 0x0100) ? 0x7000 : 0x7700;
 592                 scr_writew(a, p++);
 593         }
 594 }
 595
 596 static void vgacon_set_cursor_size(int xpos, int from, int to)
 597 {
 598         unsigned long flags;
 599         int curs, cure;
 600
 601         if ((from == cursor_size_lastfrom) && (to == cursor_size_lastto))
 602                 return;
 603         cursor_size_lastfrom = from;
 604         cursor_size_lastto = to;
 605
 606         raw_spin_lock_irqsave(&vga_lock, flags);
 607         if (vga_video_type >= VIDEO_TYPE_VGAC) {
 608                 outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
 609                 curs = inb_p(vga_video_port_val);
 610                 outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
 611                 cure = inb_p(vga_video_port_val);
 612         } else {
 613                 curs = 0;
 614                 cure = 0;
 615         }
 616
 617         curs = (curs & 0xc0) | from;
 618         cure = (cure & 0xe0) | to;
 619
 620         outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
 621         outb_p(curs, vga_video_port_val);
 622         outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
 623         outb_p(cure, vga_video_port_val);
 624         raw_spin_unlock_irqrestore(&vga_lock, flags);
 625 }
 626
 627 static void vgacon_cursor(struct vc_data *c, int mode)
 628 {
 629         if (c->vc_mode != KD_TEXT)
 630                 return;
 631
 632         vgacon_restore_screen(c);
 633
 634         switch (mode) {
 635         case CM_ERASE:
 636                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
 637                 if (vga_video_type >= VIDEO_TYPE_VGAC)
 638                         vgacon_set_cursor_size(c->vc_x, 31, 30);
 639                 else
 640                         vgacon_set_cursor_size(c->vc_x, 31, 31);
 641                 break;
 642
 643         case CM_MOVE:
 644         case CM_DRAW:
 645                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
 646                 switch (c->vc_cursor_type & 0x0f) {
 647                 case CUR_UNDERLINE:
 648                         vgacon_set_cursor_size(c->vc_x,
 649                                                c->vc_font.height -
 650                                                (c->vc_font.height <
 651                                                 10 ? 2 : 3),
 652                                                c->vc_font.height -
 653                                                (c->vc_font.height <
 654                                                 10 ? 1 : 2));
 655                         break;
 656                 case CUR_TWO_THIRDS:
 657                         vgacon_set_cursor_size(c->vc_x,
 658                                                c->vc_font.height / 3,
 659                                                c->vc_font.height -
 660                                                (c->vc_font.height <
 661                                                 10 ? 1 : 2));
 662                         break;
 663                 case CUR_LOWER_THIRD:
 664                         vgacon_set_cursor_size(c->vc_x,
 665                                                (c->vc_font.height * 2) / 3,
 666                                                c->vc_font.height -
 667                                                (c->vc_font.height <
 668                                                 10 ? 1 : 2));
 669                         break;
 670                 case CUR_LOWER_HALF:
 671                         vgacon_set_cursor_size(c->vc_x,
 672                                                c->vc_font.height / 2,
 673                                                c->vc_font.height -
 674                                                (c->vc_font.height <
 675                                                 10 ? 1 : 2));
 676                         break;
 677                 case CUR_NONE:
 678                         if (vga_video_type >= VIDEO_TYPE_VGAC)
 679                                 vgacon_set_cursor_size(c->vc_x, 31, 30);
 680                         else
 681                                 vgacon_set_cursor_size(c->vc_x, 31, 31);
 682                         break;
 683                 default:
 684                         vgacon_set_cursor_size(c->vc_x, 1,
 685                                                c->vc_font.height);
 686                         break;
 687                 }
 688                 break;
 689         }
 690 }
 691
 692 static int vgacon_doresize(struct vc_data *c,
 693                 unsigned int width, unsigned int height)
 694 {
 695         unsigned long flags;
 696         unsigned int scanlines = height * c->vc_font.height;
 697         u8 scanlines_lo = 0, r7 = 0, vsync_end = 0, mode, max_scan;
 698
 699         raw_spin_lock_irqsave(&vga_lock, flags);
 700
 701         vgacon_xres = width * VGA_FONTWIDTH;
 702         vgacon_yres = height * c->vc_font.height;
 703         if (vga_video_type >= VIDEO_TYPE_VGAC) {
 704                 outb_p(VGA_CRTC_MAX_SCAN, vga_video_port_reg);
 705                 max_scan = inb_p(vga_video_port_val);
 706
 707                 if (max_scan & 0x80)
 708                         scanlines <<= 1;
 709
 710                 outb_p(VGA_CRTC_MODE, vga_video_port_reg);
 711                 mode = inb_p(vga_video_port_val);
 712
 713                 if (mode & 0x04)
 714                         scanlines >>= 1;
 715
 716                 scanlines -= 1;
 717                 scanlines_lo = scanlines & 0xff;
 718
 719                 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
 720                 r7 = inb_p(vga_video_port_val) & ~0x42;
 721
 722                 if (scanlines & 0x100)
 723                         r7 |= 0x02;
 724                 if (scanlines & 0x200)
 725                         r7 |= 0x40;
 726
 727                 /* deprotect registers */
 728                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
 729                 vsync_end = inb_p(vga_video_port_val);
 730                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
 731                 outb_p(vsync_end & ~0x80, vga_video_port_val);
 732         }
 733
 734         outb_p(VGA_CRTC_H_DISP, vga_video_port_reg);
 735         outb_p(width - 1, vga_video_port_val);
 736         outb_p(VGA_CRTC_OFFSET, vga_video_port_reg);
 737         outb_p(width >> 1, vga_video_port_val);
 738
 739         if (vga_video_type >= VIDEO_TYPE_VGAC) {
 740                 outb_p(VGA_CRTC_V_DISP_END, vga_video_port_reg);
 741                 outb_p(scanlines_lo, vga_video_port_val);
 742                 outb_p(VGA_CRTC_OVERFLOW, vga_video_port_reg);
 743                 outb_p(r7,vga_video_port_val);
 744
 745                 /* reprotect registers */
 746                 outb_p(VGA_CRTC_V_SYNC_END, vga_video_port_reg);
 747                 outb_p(vsync_end, vga_video_port_val);
 748         }
 749
 750         raw_spin_unlock_irqrestore(&vga_lock, flags);
 751         return 0;
 752 }
 753
 754 static int vgacon_switch(struct vc_data *c)
 755 {
 756         int x = c->vc_cols * VGA_FONTWIDTH;
 757         int y = c->vc_rows * c->vc_font.height;
 758         int rows = screen_info.orig_video_lines * vga_default_font_height/
 759                 c->vc_font.height;
 760         /*
 761          * We need to save screen size here as it's the only way
 762          * we can spot the screen has been resized and we need to
 763          * set size of freshly allocated screens ourselves.
 764          */
 765         vga_video_num_columns = c->vc_cols;
 766         vga_video_num_lines = c->vc_rows;
 767
 768         /* We can only copy out the size of the video buffer here,
 769          * otherwise we get into VGA BIOS */
 770
 771         if (!vga_is_gfx) {
 772                 scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
 773                             c->vc_screenbuf_size > vga_vram_size ?
 774                                 vga_vram_size : c->vc_screenbuf_size);
 775
 776                 if ((vgacon_xres != x || vgacon_yres != y) &&
 777                     (!(vga_video_num_columns % 2) &&
 778                      vga_video_num_columns <= screen_info.orig_video_cols &&
 779                      vga_video_num_lines <= rows))
 780                         vgacon_doresize(c, c->vc_cols, c->vc_rows);
 781         }
 782
 783         vgacon_scrollback_init(c->vc_size_row);
 784         return 0;               /* Redrawing not needed */
 785 }
 786
 787 static void vga_set_palette(struct vc_data *vc, const unsigned char *table)
 788 {
 789         int i, j;
 790
 791         vga_w(vgastate.vgabase, VGA_PEL_MSK, 0xff);
 792         for (i = j = 0; i < 16; i++) {
 793                 vga_w(vgastate.vgabase, VGA_PEL_IW, table[i]);
 794                 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
 795                 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
 796                 vga_w(vgastate.vgabase, VGA_PEL_D, vc->vc_palette[j++] >> 2);
 797         }
 798 }
 799
 800 static void vgacon_set_palette(struct vc_data *vc, const unsigned char *table)
 801 {
 802         if (vga_video_type != VIDEO_TYPE_VGAC || vga_palette_blanked
 803             || !con_is_visible(vc))
 804                 return;
 805         vga_set_palette(vc, table);
 806 }
 807
 808 /* structure holding original VGA register settings */
 809 static struct {
 810         unsigned char SeqCtrlIndex;     /* Sequencer Index reg.   */
 811         unsigned char CrtCtrlIndex;     /* CRT-Contr. Index reg.  */
 812         unsigned char CrtMiscIO;        /* Miscellaneous register */
 813         unsigned char HorizontalTotal;  /* CRT-Controller:00h */
 814         unsigned char HorizDisplayEnd;  /* CRT-Controller:01h */
 815         unsigned char StartHorizRetrace;        /* CRT-Controller:04h */
 816         unsigned char EndHorizRetrace;  /* CRT-Controller:05h */
 817         unsigned char Overflow; /* CRT-Controller:07h */
 818         unsigned char StartVertRetrace; /* CRT-Controller:10h */
 819         unsigned char EndVertRetrace;   /* CRT-Controller:11h */
 820         unsigned char ModeControl;      /* CRT-Controller:17h */
 821         unsigned char ClockingMode;     /* Seq-Controller:01h */
 822 } vga_state;
 823
 824 static void vga_vesa_blank(struct vgastate *state, int mode)
 825 {
 826         /* save original values of VGA controller registers */
 827         if (!vga_vesa_blanked) {
 828                 raw_spin_lock_irq(&vga_lock);
 829                 vga_state.SeqCtrlIndex = vga_r(state->vgabase, VGA_SEQ_I);
 830                 vga_state.CrtCtrlIndex = inb_p(vga_video_port_reg);
 831                 vga_state.CrtMiscIO = vga_r(state->vgabase, VGA_MIS_R);
 832                 raw_spin_unlock_irq(&vga_lock);
 833
 834                 outb_p(0x00, vga_video_port_reg);       /* HorizontalTotal */
 835                 vga_state.HorizontalTotal = inb_p(vga_video_port_val);
 836                 outb_p(0x01, vga_video_port_reg);       /* HorizDisplayEnd */
 837                 vga_state.HorizDisplayEnd = inb_p(vga_video_port_val);
 838                 outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
 839                 vga_state.StartHorizRetrace = inb_p(vga_video_port_val);
 840                 outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
 841                 vga_state.EndHorizRetrace = inb_p(vga_video_port_val);
 842                 outb_p(0x07, vga_video_port_reg);       /* Overflow */
 843                 vga_state.Overflow = inb_p(vga_video_port_val);
 844                 outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
 845                 vga_state.StartVertRetrace = inb_p(vga_video_port_val);
 846                 outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
 847                 vga_state.EndVertRetrace = inb_p(vga_video_port_val);
 848                 outb_p(0x17, vga_video_port_reg);       /* ModeControl */
 849                 vga_state.ModeControl = inb_p(vga_video_port_val);
 850                 vga_state.ClockingMode = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
 851         }
 852
 853         /* assure that video is enabled */
 854         /* "0x20" is VIDEO_ENABLE_bit in register 01 of sequencer */
 855         raw_spin_lock_irq(&vga_lock);
 856         vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode | 0x20);
 857
 858         /* test for vertical retrace in process.... */
 859         if ((vga_state.CrtMiscIO & 0x80) == 0x80)
 860                 vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO & 0xEF);
 861
 862         /*
 863          * Set <End of vertical retrace> to minimum (0) and
 864          * <Start of vertical Retrace> to maximum (incl. overflow)
 865          * Result: turn off vertical sync (VSync) pulse.
 866          */
 867         if (mode & VESA_VSYNC_SUSPEND) {
 868                 outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
 869                 outb_p(0xff, vga_video_port_val);       /* maximum value */
 870                 outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
 871                 outb_p(0x40, vga_video_port_val);       /* minimum (bits 0..3)  */
 872                 outb_p(0x07, vga_video_port_reg);       /* Overflow */
 873                 outb_p(vga_state.Overflow | 0x84, vga_video_port_val);  /* bits 9,10 of vert. retrace */
 874         }
 875
 876         if (mode & VESA_HSYNC_SUSPEND) {
 877                 /*
 878                  * Set <End of horizontal retrace> to minimum (0) and
 879                  *  <Start of horizontal Retrace> to maximum
 880                  * Result: turn off horizontal sync (HSync) pulse.
 881                  */
 882                 outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
 883                 outb_p(0xff, vga_video_port_val);       /* maximum */
 884                 outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
 885                 outb_p(0x00, vga_video_port_val);       /* minimum (0) */
 886         }
 887
 888         /* restore both index registers */
 889         vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
 890         outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
 891         raw_spin_unlock_irq(&vga_lock);
 892 }
 893
 894 static void vga_vesa_unblank(struct vgastate *state)
 895 {
 896         /* restore original values of VGA controller registers */
 897         raw_spin_lock_irq(&vga_lock);
 898         vga_w(state->vgabase, VGA_MIS_W, vga_state.CrtMiscIO);
 899
 900         outb_p(0x00, vga_video_port_reg);       /* HorizontalTotal */
 901         outb_p(vga_state.HorizontalTotal, vga_video_port_val);
 902         outb_p(0x01, vga_video_port_reg);       /* HorizDisplayEnd */
 903         outb_p(vga_state.HorizDisplayEnd, vga_video_port_val);
 904         outb_p(0x04, vga_video_port_reg);       /* StartHorizRetrace */
 905         outb_p(vga_state.StartHorizRetrace, vga_video_port_val);
 906         outb_p(0x05, vga_video_port_reg);       /* EndHorizRetrace */
 907         outb_p(vga_state.EndHorizRetrace, vga_video_port_val);
 908         outb_p(0x07, vga_video_port_reg);       /* Overflow */
 909         outb_p(vga_state.Overflow, vga_video_port_val);
 910         outb_p(0x10, vga_video_port_reg);       /* StartVertRetrace */
 911         outb_p(vga_state.StartVertRetrace, vga_video_port_val);
 912         outb_p(0x11, vga_video_port_reg);       /* EndVertRetrace */
 913         outb_p(vga_state.EndVertRetrace, vga_video_port_val);
 914         outb_p(0x17, vga_video_port_reg);       /* ModeControl */
 915         outb_p(vga_state.ModeControl, vga_video_port_val);
 916         /* ClockingMode */
 917         vga_wseq(state->vgabase, VGA_SEQ_CLOCK_MODE, vga_state.ClockingMode);
 918
 919         /* restore index/control registers */
 920         vga_w(state->vgabase, VGA_SEQ_I, vga_state.SeqCtrlIndex);
 921         outb_p(vga_state.CrtCtrlIndex, vga_video_port_reg);
 922         raw_spin_unlock_irq(&vga_lock);
 923 }
 924
 925 static void vga_pal_blank(struct vgastate *state)
 926 {
 927         int i;
 928
 929         vga_w(state->vgabase, VGA_PEL_MSK, 0xff);
 930         for (i = 0; i < 16; i++) {
 931                 vga_w(state->vgabase, VGA_PEL_IW, i);
 932                 vga_w(state->vgabase, VGA_PEL_D, 0);
 933                 vga_w(state->vgabase, VGA_PEL_D, 0);
 934                 vga_w(state->vgabase, VGA_PEL_D, 0);
 935         }
 936 }
 937
 938 static int vgacon_blank(struct vc_data *c, int blank, int mode_switch)
 939 {
 940         switch (blank) {
 941         case 0:         /* Unblank */
 942                 if (vga_vesa_blanked) {
 943                         vga_vesa_unblank(&vgastate);
 944                         vga_vesa_blanked = 0;
 945                 }
 946                 if (vga_palette_blanked) {
 947                         vga_set_palette(c, color_table);
 948                         vga_palette_blanked = false;
 949                         return 0;
 950                 }
 951                 vga_is_gfx = false;
 952                 /* Tell console.c that it has to restore the screen itself */
 953                 return 1;
 954         case 1:         /* Normal blanking */
 955         case -1:        /* Obsolete */
 956                 if (!mode_switch && vga_video_type == VIDEO_TYPE_VGAC) {
 957                         vga_pal_blank(&vgastate);
 958                         vga_palette_blanked = true;
 959                         return 0;
 960                 }
 961                 vgacon_set_origin(c);
 962                 scr_memsetw((void *) vga_vram_base, BLANK,
 963                             c->vc_screenbuf_size);
 964                 if (mode_switch)
 965                         vga_is_gfx = true;
 966                 return 1;
 967         default:                /* VESA blanking */
 968                 if (vga_video_type == VIDEO_TYPE_VGAC) {
 969                         vga_vesa_blank(&vgastate, blank - 1);
 970                         vga_vesa_blanked = blank;
 971                 }
 972                 return 0;
 973         }
 974 }
 975
 976 /*
 977  * PIO_FONT support.
 978  *
 979  * The font loading code goes back to the codepage package by
 980  * Joel Hoffman (joel@wam.umd.edu). (He reports that the original
 981  * reference is: "From: p. 307 of _Programmer's Guide to PC & PS/2
 982  * Video Systems_ by Richard Wilton. 1987.  Microsoft Press".)
 983  *
 984  * Change for certain monochrome monitors by Yury Shevchuck
 985  * (sizif@botik.yaroslavl.su).
 986  */
 987
 988 #define colourmap 0xa0000
 989 /* Pauline Middelink <middelin@polyware.iaf.nl> reports that we
 990    should use 0xA0000 for the bwmap as well.. */
 991 #define blackwmap 0xa0000
 992 #define cmapsz 8192
 993
 994 static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
 995                 bool ch512)
 996 {
 997         unsigned short video_port_status = vga_video_port_reg + 6;
 998         int font_select = 0x00, beg, i;
 999         char *charmap;
1000         bool clear_attribs = false;
1001         if (vga_video_type != VIDEO_TYPE_EGAM) {
1002                 charmap = (char *) VGA_MAP_MEM(colourmap, 0);
1003                 beg = 0x0e;
1004         } else {
1005                 charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
1006                 beg = 0x0a;
1007         }
1008
1009 #ifdef BROKEN_GRAPHICS_PROGRAMS
1010         /*
1011          * All fonts are loaded in slot 0 (0:1 for 512 ch)
1012          */
1013
1014         if (!arg)
1015                 return -EINVAL; /* Return to default font not supported */
1016
1017         vga_font_is_default = false;
1018         font_select = ch512 ? 0x04 : 0x00;
1019 #else
1020         /*
1021          * The default font is kept in slot 0 and is never touched.
1022          * A custom font is loaded in slot 2 (256 ch) or 2:3 (512 ch)
1023          */
1024
1025         if (set) {
1026                 vga_font_is_default = !arg;
1027                 if (!arg)
1028                         ch512 = false;  /* Default font is always 256 */
1029                 font_select = arg ? (ch512 ? 0x0e : 0x0a) : 0x00;
1030         }
1031
1032         if (!vga_font_is_default)
1033                 charmap += 4 * cmapsz;
1034 #endif
1035
1036         raw_spin_lock_irq(&vga_lock);
1037         /* First, the Sequencer */
1038         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
1039         /* CPU writes only to map 2 */
1040         vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
1041         /* Sequential addressing */
1042         vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
1043         /* Clear synchronous reset */
1044         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1045
1046         /* Now, the graphics controller, select map 2 */
1047         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
1048         /* disable odd-even addressing */
1049         vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
1050         /* map start at A000:0000 */
1051         vga_wgfx(state->vgabase, VGA_GFX_MISC, 0x00);
1052         raw_spin_unlock_irq(&vga_lock);
1053
1054         if (arg) {
1055                 if (set)
1056                         for (i = 0; i < cmapsz; i++) {
1057                                 vga_writeb(arg[i], charmap + i);
1058                                 cond_resched();
1059                         }
1060                 else
1061                         for (i = 0; i < cmapsz; i++) {
1062                                 arg[i] = vga_readb(charmap + i);
1063                                 cond_resched();
1064                         }
1065
1066                 /*
1067                  * In 512-character mode, the character map is not contiguous if
1068                  * we want to remain EGA compatible -- which we do
1069                  */
1070
1071                 if (ch512) {
1072                         charmap += 2 * cmapsz;
1073                         arg += cmapsz;
1074                         if (set)
1075                                 for (i = 0; i < cmapsz; i++) {
1076                                         vga_writeb(arg[i], charmap + i);
1077                                         cond_resched();
1078                                 }
1079                         else
1080                                 for (i = 0; i < cmapsz; i++) {
1081                                         arg[i] = vga_readb(charmap + i);
1082                                         cond_resched();
1083                                 }
1084                 }
1085         }
1086
1087         raw_spin_lock_irq(&vga_lock);
1088         /* First, the sequencer, Synchronous reset */
1089         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
1090         /* CPU writes to maps 0 and 1 */
1091         vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
1092         /* odd-even addressing */
1093         vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x03);
1094         /* Character Map Select */
1095         if (set)
1096                 vga_wseq(state->vgabase, VGA_SEQ_CHARACTER_MAP, font_select);
1097         /* clear synchronous reset */
1098         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
1099
1100         /* Now, the graphics controller, select map 0 for CPU */
1101         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x00);
1102         /* enable even-odd addressing */
1103         vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x10);
1104         /* map starts at b800:0 or b000:0 */
1105         vga_wgfx(state->vgabase, VGA_GFX_MISC, beg);
1106
1107         /* if 512 char mode is already enabled don't re-enable it. */
1108         if ((set) && (ch512 != vga_512_chars)) {
1109                 vga_512_chars = ch512;
1110                 /* 256-char: enable intensity bit
1111                    512-char: disable intensity bit */
1112                 inb_p(video_port_status);       /* clear address flip-flop */
1113                 /* color plane enable register */
1114                 vga_wattr(state->vgabase, VGA_ATC_PLANE_ENABLE, ch512 ? 0x07 : 0x0f);
1115                 /* Wilton (1987) mentions the following; I don't know what
1116                    it means, but it works, and it appears necessary */
1117                 inb_p(video_port_status);
1118                 vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
1119                 clear_attribs = true;
1120         }
1121         raw_spin_unlock_irq(&vga_lock);
1122
1123         if (clear_attribs) {
1124                 for (i = 0; i < MAX_NR_CONSOLES; i++) {
1125                         struct vc_data *c = vc_cons[i].d;
1126                         if (c && c->vc_sw == &vga_con) {
1127                                 /* force hi font mask to 0, so we always clear
1128                                    the bit on either transition */
1129                                 c->vc_hi_font_mask = 0x00;
1130                                 clear_buffer_attributes(c);
1131                                 c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
1132                         }
1133                 }
1134         }
1135         return 0;
1136 }
1137
1138 /*
1139  * Adjust the screen to fit a font of a certain height
1140  */
1141 static int vgacon_adjust_height(struct vc_data *vc, unsigned fontheight)
1142 {
1143         unsigned char ovr, vde, fsr;
1144         int rows, maxscan, i;
1145
1146         rows = vc->vc_scan_lines / fontheight;  /* Number of video rows we end up with */
1147         maxscan = rows * fontheight - 1;        /* Scan lines to actually display-1 */
1148
1149         /* Reprogram the CRTC for the new font size
1150            Note: the attempt to read the overflow register will fail
1151            on an EGA, but using 0xff for the previous value appears to
1152            be OK for EGA text modes in the range 257-512 scan lines, so I
1153            guess we don't need to worry about it.
1154
1155            The same applies for the spill bits in the font size and cursor
1156            registers; they are write-only on EGA, but it appears that they
1157            are all don't care bits on EGA, so I guess it doesn't matter. */
1158
1159         raw_spin_lock_irq(&vga_lock);
1160         outb_p(0x07, vga_video_port_reg);       /* CRTC overflow register */
1161         ovr = inb_p(vga_video_port_val);
1162         outb_p(0x09, vga_video_port_reg);       /* Font size register */
1163         fsr = inb_p(vga_video_port_val);
1164         raw_spin_unlock_irq(&vga_lock);
1165
1166         vde = maxscan & 0xff;   /* Vertical display end reg */
1167         ovr = (ovr & 0xbd) +    /* Overflow register */
1168             ((maxscan & 0x100) >> 7) + ((maxscan & 0x200) >> 3);
1169         fsr = (fsr & 0xe0) + (fontheight - 1);  /*  Font size register */
1170
1171         raw_spin_lock_irq(&vga_lock);
1172         outb_p(0x07, vga_video_port_reg);       /* CRTC overflow register */
1173         outb_p(ovr, vga_video_port_val);
1174         outb_p(0x09, vga_video_port_reg);       /* Font size */
1175         outb_p(fsr, vga_video_port_val);
1176         outb_p(0x12, vga_video_port_reg);       /* Vertical display limit */
1177         outb_p(vde, vga_video_port_val);
1178         raw_spin_unlock_irq(&vga_lock);
1179         vga_video_font_height = fontheight;
1180
1181         for (i = 0; i < MAX_NR_CONSOLES; i++) {
1182                 struct vc_data *c = vc_cons[i].d;
1183
1184                 if (c && c->vc_sw == &vga_con) {
1185                         if (con_is_visible(c)) {
1186                                 /* void size to cause regs to be rewritten */
1187                                 cursor_size_lastfrom = 0;
1188                                 cursor_size_lastto = 0;
1189                                 c->vc_sw->con_cursor(c, CM_DRAW);
1190                         }
1191                         c->vc_font.height = fontheight;
1192                         vc_resize(c, 0, rows);  /* Adjust console size */
1193                 }
1194         }
1195         return 0;
1196 }
1197
1198 static int vgacon_font_set(struct vc_data *c, struct console_font *font, unsigned flags)
1199 {
1200         unsigned charcount = font->charcount;
1201         int rc;
1202
1203         if (vga_video_type < VIDEO_TYPE_EGAM)
1204                 return -EINVAL;
1205
1206         if (font->width != VGA_FONTWIDTH ||
1207             (charcount != 256 && charcount != 512))
1208                 return -EINVAL;
1209
1210         rc = vgacon_do_font_op(&vgastate, font->data, 1, charcount == 512);
1211         if (rc)
1212                 return rc;
1213
1214         if (!(flags & KD_FONT_FLAG_DONT_RECALC))
1215                 rc = vgacon_adjust_height(c, font->height);
1216         return rc;
1217 }
1218
1219 static int vgacon_font_get(struct vc_data *c, struct console_font *font)
1220 {
1221         if (vga_video_type < VIDEO_TYPE_EGAM)
1222                 return -EINVAL;
1223
1224         font->width = VGA_FONTWIDTH;
1225         font->height = c->vc_font.height;
1226         font->charcount = vga_512_chars ? 512 : 256;
1227         if (!font->data)
1228                 return 0;
1229         return vgacon_do_font_op(&vgastate, font->data, 0, vga_512_chars);
1230 }
1231
1232 static int vgacon_resize(struct vc_data *c, unsigned int width,
1233                          unsigned int height, unsigned int user)
1234 {
1235         if (width % 2 || width > screen_info.orig_video_cols ||
1236             height > (screen_info.orig_video_lines * vga_default_font_height)/
1237             c->vc_font.height)
1238                 /* let svgatextmode tinker with video timings and
1239                    return success */
1240                 return (user) ? 0 : -EINVAL;
1241
1242         if (con_is_visible(c) && !vga_is_gfx) /* who knows */
1243                 vgacon_doresize(c, width, height);
1244         return 0;
1245 }
1246
1247 static int vgacon_set_origin(struct vc_data *c)
1248 {
1249         if (vga_is_gfx ||       /* We don't play origin tricks in graphic modes */
1250             (console_blanked && !vga_palette_blanked))  /* Nor we write to blanked screens */
1251                 return 0;
1252         c->vc_origin = c->vc_visible_origin = vga_vram_base;
1253         vga_set_mem_top(c);
1254         vga_rolled_over = 0;
1255         return 1;
1256 }
1257
1258 static void vgacon_save_screen(struct vc_data *c)
1259 {
1260         static int vga_bootup_console = 0;
1261
1262         if (!vga_bootup_console) {
1263                 /* This is a gross hack, but here is the only place we can
1264                  * set bootup console parameters without messing up generic
1265                  * console initialization routines.
1266                  */
1267                 vga_bootup_console = 1;
1268                 c->vc_x = screen_info.orig_x;
1269                 c->vc_y = screen_info.orig_y;
1270         }
1271
1272         /* We can't copy in more than the size of the video buffer,
1273          * or we'll be copying in VGA BIOS */
1274
1275         if (!vga_is_gfx)
1276                 scr_memcpyw((u16 *) c->vc_screenbuf, (u16 *) c->vc_origin,
1277                             c->vc_screenbuf_size > vga_vram_size ? vga_vram_size : c->vc_screenbuf_size);
1278 }
1279
1280 static bool vgacon_scroll(struct vc_data *c, unsigned int t, unsigned int b,
1281                 enum con_scroll dir, unsigned int lines)
1282 {
1283         unsigned long oldo;
1284         unsigned int delta;
1285
1286         if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
1287                 return false;
1288
1289         if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
1290                 return false;
1291
1292         vgacon_restore_screen(c);
1293         oldo = c->vc_origin;
1294         delta = lines * c->vc_size_row;
1295         if (dir == SM_UP) {
1296                 vgacon_scrollback_update(c, t, lines);
1297                 if (c->vc_scr_end + delta >= vga_vram_end) {
1298                         scr_memcpyw((u16 *) vga_vram_base,
1299                                     (u16 *) (oldo + delta),
1300                                     c->vc_screenbuf_size - delta);
1301                         c->vc_origin = vga_vram_base;
1302                         vga_rolled_over = oldo - vga_vram_base;
1303                 } else
1304                         c->vc_origin += delta;
1305                 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
1306                                      delta), c->vc_video_erase_char,
1307                             delta);
1308         } else {
1309                 if (oldo - delta < vga_vram_base) {
1310                         scr_memmovew((u16 *) (vga_vram_end -
1311                                               c->vc_screenbuf_size +
1312                                               delta), (u16 *) oldo,
1313                                      c->vc_screenbuf_size - delta);
1314                         c->vc_origin = vga_vram_end - c->vc_screenbuf_size;
1315                         vga_rolled_over = 0;
1316                 } else
1317                         c->vc_origin -= delta;
1318                 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1319                 scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
1320                             delta);
1321         }
1322         c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
1323         c->vc_visible_origin = c->vc_origin;
1324         vga_set_mem_top(c);
1325         c->vc_pos = (c->vc_pos - oldo) + c->vc_origin;
1326         return true;
1327 }
1328
1329
1330 /*
1331  *  The console `switch' structure for the VGA based console
1332  */
1333
1334 static int vgacon_dummy(struct vc_data *c)
1335 {
1336         return 0;
1337 }
1338
1339 #define DUMMY (void *) vgacon_dummy
1340
1341 const struct consw vga_con = {
1342         .owner = THIS_MODULE,
1343         .con_startup = vgacon_startup,
1344         .con_init = vgacon_init,
1345         .con_deinit = vgacon_deinit,
1346         .con_clear = DUMMY,
1347         .con_putc = DUMMY,
1348         .con_putcs = DUMMY,
1349         .con_cursor = vgacon_cursor,
1350         .con_scroll = vgacon_scroll,
1351         .con_switch = vgacon_switch,
1352         .con_blank = vgacon_blank,
1353         .con_font_set = vgacon_font_set,
1354         .con_font_get = vgacon_font_get,
1355         .con_resize = vgacon_resize,
1356         .con_set_palette = vgacon_set_palette,
1357         .con_scrolldelta = vgacon_scrolldelta,
1358         .con_set_origin = vgacon_set_origin,
1359         .con_save_screen = vgacon_save_screen,
1360         .con_build_attr = vgacon_build_attr,
1361         .con_invert_region = vgacon_invert_region,
1362 };
1363 EXPORT_SYMBOL(vga_con);
1364
1365 MODULE_LICENSE("GPL");