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