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