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