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