git.oblomov.eu Git - linux-2.6/blob - drivers/video/console/vgacon.c

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