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