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