drivers/video/console/vgacon.c

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