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