vgasrc/stdvga.c

   1 // VGA io port access
   2 //
   3 // Copyright (C) 2009  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2001-2008 the LGPL VGABios developers Team
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "stdvga.h" // stdvga_init
   9 #include "ioport.h" // outb
  10 #include "farptr.h" // SET_FARVAR
  11 #include "biosvar.h" // GET_GLOBAL
  12 #include "util.h" // memcpy_far
  13 #include "vbe.h" // VBE_RETURN_STATUS_FAILED
  14
  15 // TODO
  16 //  * replace direct in/out calls with wrapper functions
  17
  18
  19 /****************************************************************
  20  * Attribute control
  21  ****************************************************************/
  22
  23 static void
  24 stdvga_screen_disable(void)
  25 {
  26     inb(VGAREG_ACTL_RESET);
  27     outb(0x00, VGAREG_ACTL_ADDRESS);
  28 }
  29
  30 static void
  31 stdvga_screen_enable(void)
  32 {
  33     inb(VGAREG_ACTL_RESET);
  34     outb(0x20, VGAREG_ACTL_ADDRESS);
  35 }
  36
  37 void
  38 stdvga_set_border_color(u8 color)
  39 {
  40     inb(VGAREG_ACTL_RESET);
  41     outb(0x00, VGAREG_ACTL_ADDRESS);
  42     u8 v1 = color & 0x0f;
  43     if (v1 & 0x08)
  44         v1 += 0x08;
  45     outb(v1, VGAREG_ACTL_WRITE_DATA);
  46
  47     u8 v2 = color & 0x10;
  48     int i;
  49     for (i = 1; i < 4; i++) {
  50         outb(i, VGAREG_ACTL_ADDRESS);
  51
  52         u8 cur = inb(VGAREG_ACTL_READ_DATA);
  53         cur &= 0xef;
  54         cur |= v2;
  55         outb(cur, VGAREG_ACTL_WRITE_DATA);
  56     }
  57     outb(0x20, VGAREG_ACTL_ADDRESS);
  58 }
  59
  60 void
  61 stdvga_set_overscan_border_color(u8 color)
  62 {
  63     inb(VGAREG_ACTL_RESET);
  64     outb(0x11, VGAREG_ACTL_ADDRESS);
  65     outb(color, VGAREG_ACTL_WRITE_DATA);
  66     outb(0x20, VGAREG_ACTL_ADDRESS);
  67 }
  68
  69 u8
  70 stdvga_get_overscan_border_color(void)
  71 {
  72     inb(VGAREG_ACTL_RESET);
  73     outb(0x11, VGAREG_ACTL_ADDRESS);
  74     u8 v = inb(VGAREG_ACTL_READ_DATA);
  75     inb(VGAREG_ACTL_RESET);
  76     outb(0x20, VGAREG_ACTL_ADDRESS);
  77     return v;
  78 }
  79
  80 void
  81 stdvga_set_palette(u8 palid)
  82 {
  83     inb(VGAREG_ACTL_RESET);
  84     palid &= 0x01;
  85     int i;
  86     for (i = 1; i < 4; i++) {
  87         outb(i, VGAREG_ACTL_ADDRESS);
  88
  89         u8 v = inb(VGAREG_ACTL_READ_DATA);
  90         v &= 0xfe;
  91         v |= palid;
  92         outb(v, VGAREG_ACTL_WRITE_DATA);
  93     }
  94     outb(0x20, VGAREG_ACTL_ADDRESS);
  95 }
  96
  97 void
  98 stdvga_set_single_palette_reg(u8 reg, u8 val)
  99 {
 100     inb(VGAREG_ACTL_RESET);
 101     outb(reg, VGAREG_ACTL_ADDRESS);
 102     outb(val, VGAREG_ACTL_WRITE_DATA);
 103     outb(0x20, VGAREG_ACTL_ADDRESS);
 104 }
 105
 106 u8
 107 stdvga_get_single_palette_reg(u8 reg)
 108 {
 109     inb(VGAREG_ACTL_RESET);
 110     outb(reg, VGAREG_ACTL_ADDRESS);
 111     u8 v = inb(VGAREG_ACTL_READ_DATA);
 112     inb(VGAREG_ACTL_RESET);
 113     outb(0x20, VGAREG_ACTL_ADDRESS);
 114     return v;
 115 }
 116
 117 void
 118 stdvga_set_all_palette_reg(u16 seg, u8 *data_far)
 119 {
 120     inb(VGAREG_ACTL_RESET);
 121     int i;
 122     for (i = 0; i < 0x10; i++) {
 123         outb(i, VGAREG_ACTL_ADDRESS);
 124         u8 val = GET_FARVAR(seg, *data_far);
 125         outb(val, VGAREG_ACTL_WRITE_DATA);
 126         data_far++;
 127     }
 128     outb(0x11, VGAREG_ACTL_ADDRESS);
 129     outb(GET_FARVAR(seg, *data_far), VGAREG_ACTL_WRITE_DATA);
 130     outb(0x20, VGAREG_ACTL_ADDRESS);
 131 }
 132
 133 void
 134 stdvga_get_all_palette_reg(u16 seg, u8 *data_far)
 135 {
 136     int i;
 137     for (i = 0; i < 0x10; i++) {
 138         inb(VGAREG_ACTL_RESET);
 139         outb(i, VGAREG_ACTL_ADDRESS);
 140         SET_FARVAR(seg, *data_far, inb(VGAREG_ACTL_READ_DATA));
 141         data_far++;
 142     }
 143     inb(VGAREG_ACTL_RESET);
 144     outb(0x11, VGAREG_ACTL_ADDRESS);
 145     SET_FARVAR(seg, *data_far, inb(VGAREG_ACTL_READ_DATA));
 146     inb(VGAREG_ACTL_RESET);
 147     outb(0x20, VGAREG_ACTL_ADDRESS);
 148 }
 149
 150 void
 151 stdvga_toggle_intensity(u8 flag)
 152 {
 153     inb(VGAREG_ACTL_RESET);
 154     outb(0x10, VGAREG_ACTL_ADDRESS);
 155     u8 val = (inb(VGAREG_ACTL_READ_DATA) & 0xf7) | ((flag & 0x01) << 3);
 156     outb(val, VGAREG_ACTL_WRITE_DATA);
 157     outb(0x20, VGAREG_ACTL_ADDRESS);
 158 }
 159
 160 void
 161 stdvga_select_video_dac_color_page(u8 flag, u8 data)
 162 {
 163     inb(VGAREG_ACTL_RESET);
 164     outb(0x10, VGAREG_ACTL_ADDRESS);
 165     u8 val = inb(VGAREG_ACTL_READ_DATA);
 166     if (!(flag & 0x01)) {
 167         // select paging mode
 168         val = (val & 0x7f) | (data << 7);
 169         outb(val, VGAREG_ACTL_WRITE_DATA);
 170         outb(0x20, VGAREG_ACTL_ADDRESS);
 171         return;
 172     }
 173     // select page
 174     inb(VGAREG_ACTL_RESET);
 175     outb(0x14, VGAREG_ACTL_ADDRESS);
 176     if (!(val & 0x80))
 177         data <<= 2;
 178     data &= 0x0f;
 179     outb(data, VGAREG_ACTL_WRITE_DATA);
 180     outb(0x20, VGAREG_ACTL_ADDRESS);
 181 }
 182
 183 void
 184 stdvga_read_video_dac_state(u8 *pmode, u8 *curpage)
 185 {
 186     inb(VGAREG_ACTL_RESET);
 187     outb(0x10, VGAREG_ACTL_ADDRESS);
 188     u8 val1 = inb(VGAREG_ACTL_READ_DATA) >> 7;
 189
 190     inb(VGAREG_ACTL_RESET);
 191     outb(0x14, VGAREG_ACTL_ADDRESS);
 192     u8 val2 = inb(VGAREG_ACTL_READ_DATA) & 0x0f;
 193     if (!(val1 & 0x01))
 194         val2 >>= 2;
 195
 196     inb(VGAREG_ACTL_RESET);
 197     outb(0x20, VGAREG_ACTL_ADDRESS);
 198
 199     *pmode = val1;
 200     *curpage = val2;
 201 }
 202
 203
 204 /****************************************************************
 205  * DAC control
 206  ****************************************************************/
 207
 208 void
 209 stdvga_set_dac_regs(u16 seg, u8 *data_far, u8 start, int count)
 210 {
 211     outb(start, VGAREG_DAC_WRITE_ADDRESS);
 212     while (count) {
 213         outb(GET_FARVAR(seg, *data_far), VGAREG_DAC_DATA);
 214         data_far++;
 215         outb(GET_FARVAR(seg, *data_far), VGAREG_DAC_DATA);
 216         data_far++;
 217         outb(GET_FARVAR(seg, *data_far), VGAREG_DAC_DATA);
 218         data_far++;
 219         count--;
 220     }
 221 }
 222
 223 void
 224 stdvga_get_dac_regs(u16 seg, u8 *data_far, u8 start, int count)
 225 {
 226     outb(start, VGAREG_DAC_READ_ADDRESS);
 227     while (count) {
 228         SET_FARVAR(seg, *data_far, inb(VGAREG_DAC_DATA));
 229         data_far++;
 230         SET_FARVAR(seg, *data_far, inb(VGAREG_DAC_DATA));
 231         data_far++;
 232         SET_FARVAR(seg, *data_far, inb(VGAREG_DAC_DATA));
 233         data_far++;
 234         count--;
 235     }
 236 }
 237
 238 void
 239 stdvga_set_pel_mask(u8 val)
 240 {
 241     outb(val, VGAREG_PEL_MASK);
 242 }
 243
 244 u8
 245 stdvga_get_pel_mask(void)
 246 {
 247     return inb(VGAREG_PEL_MASK);
 248 }
 249
 250 void
 251 stdvga_save_dac_state(u16 seg, struct saveDACcolors *info)
 252 {
 253     /* XXX: check this */
 254     SET_FARVAR(seg, info->rwmode, inb(VGAREG_DAC_STATE));
 255     SET_FARVAR(seg, info->peladdr, inb(VGAREG_DAC_WRITE_ADDRESS));
 256     SET_FARVAR(seg, info->pelmask, inb(VGAREG_PEL_MASK));
 257     stdvga_get_dac_regs(seg, info->dac, 0, 256);
 258     SET_FARVAR(seg, info->color_select, 0);
 259 }
 260
 261 void
 262 stdvga_restore_dac_state(u16 seg, struct saveDACcolors *info)
 263 {
 264     outb(GET_FARVAR(seg, info->pelmask), VGAREG_PEL_MASK);
 265     stdvga_set_dac_regs(seg, info->dac, 0, 256);
 266     outb(GET_FARVAR(seg, info->peladdr), VGAREG_DAC_WRITE_ADDRESS);
 267 }
 268
 269 void
 270 stdvga_perform_gray_scale_summing(u16 start, u16 count)
 271 {
 272     stdvga_screen_disable();
 273     int i;
 274     for (i = start; i < start+count; i++) {
 275         u8 rgb[3];
 276         stdvga_get_dac_regs(GET_SEG(SS), rgb, i, 1);
 277
 278         // intensity = ( 0.3 * Red ) + ( 0.59 * Green ) + ( 0.11 * Blue )
 279         u16 intensity = ((77 * rgb[0] + 151 * rgb[1] + 28 * rgb[2]) + 0x80) >> 8;
 280         if (intensity > 0x3f)
 281             intensity = 0x3f;
 282
 283         stdvga_set_dac_regs(GET_SEG(SS), rgb, i, 1);
 284     }
 285     stdvga_screen_enable();
 286 }
 287
 288
 289 /****************************************************************
 290  * Memory control
 291  ****************************************************************/
 292
 293 void
 294 stdvga_sequ_write(u8 index, u8 value)
 295 {
 296     outw((value<<8) | index, VGAREG_SEQU_ADDRESS);
 297 }
 298
 299 void
 300 stdvga_grdc_write(u8 index, u8 value)
 301 {
 302     outw((value<<8) | index, VGAREG_GRDC_ADDRESS);
 303 }
 304
 305 void
 306 stdvga_set_text_block_specifier(u8 spec)
 307 {
 308     outw((spec << 8) | 0x03, VGAREG_SEQU_ADDRESS);
 309 }
 310
 311
 312 /****************************************************************
 313  * Font loading
 314  ****************************************************************/
 315
 316 static void
 317 get_font_access(void)
 318 {
 319     outw(0x0100, VGAREG_SEQU_ADDRESS);
 320     outw(0x0402, VGAREG_SEQU_ADDRESS);
 321     outw(0x0704, VGAREG_SEQU_ADDRESS);
 322     outw(0x0300, VGAREG_SEQU_ADDRESS);
 323     outw(0x0204, VGAREG_GRDC_ADDRESS);
 324     outw(0x0005, VGAREG_GRDC_ADDRESS);
 325     outw(0x0406, VGAREG_GRDC_ADDRESS);
 326 }
 327
 328 static void
 329 release_font_access(void)
 330 {
 331     outw(0x0100, VGAREG_SEQU_ADDRESS);
 332     outw(0x0302, VGAREG_SEQU_ADDRESS);
 333     outw(0x0304, VGAREG_SEQU_ADDRESS);
 334     outw(0x0300, VGAREG_SEQU_ADDRESS);
 335     u16 v = (inb(VGAREG_READ_MISC_OUTPUT) & 0x01) ? 0x0e : 0x0a;
 336     outw((v << 8) | 0x06, VGAREG_GRDC_ADDRESS);
 337     outw(0x0004, VGAREG_GRDC_ADDRESS);
 338     outw(0x1005, VGAREG_GRDC_ADDRESS);
 339 }
 340
 341 void
 342 stdvga_load_font(u16 seg, void *src_far, u16 count
 343                  , u16 start, u8 destflags, u8 fontsize)
 344 {
 345     get_font_access();
 346     u16 blockaddr = ((destflags & 0x03) << 14) + ((destflags & 0x04) << 11);
 347     void *dest_far = (void*)(blockaddr + start*32);
 348     u16 i;
 349     for (i = 0; i < count; i++)
 350         memcpy_far(SEG_GRAPH, dest_far + i*32
 351                    , seg, src_far + i*fontsize, fontsize);
 352     release_font_access();
 353 }
 354
 355
 356 /****************************************************************
 357  * CRTC registers
 358  ****************************************************************/
 359
 360 u16
 361 stdvga_get_crtc(void)
 362 {
 363     if (inb(VGAREG_READ_MISC_OUTPUT) & 1)
 364         return VGAREG_VGA_CRTC_ADDRESS;
 365     return VGAREG_MDA_CRTC_ADDRESS;
 366 }
 367
 368 void
 369 stdvga_set_cursor_shape(u8 start, u8 end)
 370 {
 371     u16 crtc_addr = stdvga_get_crtc();
 372     outb(0x0a, crtc_addr);
 373     outb(start, crtc_addr + 1);
 374     outb(0x0b, crtc_addr);
 375     outb(end, crtc_addr + 1);
 376 }
 377
 378 void
 379 stdvga_set_active_page(u16 address)
 380 {
 381     u16 crtc_addr = stdvga_get_crtc();
 382     outb(0x0c, crtc_addr);
 383     outb((address & 0xff00) >> 8, crtc_addr + 1);
 384     outb(0x0d, crtc_addr);
 385     outb(address & 0x00ff, crtc_addr + 1);
 386 }
 387
 388 void
 389 stdvga_set_cursor_pos(u16 address)
 390 {
 391     u16 crtc_addr = stdvga_get_crtc();
 392     outb(0x0e, crtc_addr);
 393     outb((address & 0xff00) >> 8, crtc_addr + 1);
 394     outb(0x0f, crtc_addr);
 395     outb(address & 0x00ff, crtc_addr + 1);
 396 }
 397
 398 void
 399 stdvga_set_scan_lines(u8 lines)
 400 {
 401     u16 crtc_addr = stdvga_get_crtc();
 402     outb(0x09, crtc_addr);
 403     u8 crtc_r9 = inb(crtc_addr + 1);
 404     crtc_r9 = (crtc_r9 & 0xe0) | (lines - 1);
 405     outb(crtc_r9, crtc_addr + 1);
 406 }
 407
 408 // Get vertical display end
 409 u16
 410 stdvga_get_vde(void)
 411 {
 412     u16 crtc_addr = stdvga_get_crtc();
 413     outb(0x12, crtc_addr);
 414     u16 vde = inb(crtc_addr + 1);
 415     outb(0x07, crtc_addr);
 416     u8 ovl = inb(crtc_addr + 1);
 417     vde += (((ovl & 0x02) << 7) + ((ovl & 0x40) << 3) + 1);
 418     return vde;
 419 }
 420
 421
 422 /****************************************************************
 423  * Save/Restore/Set state
 424  ****************************************************************/
 425
 426 void
 427 stdvga_save_state(u16 seg, struct saveVideoHardware *info)
 428 {
 429     u16 crtc_addr = stdvga_get_crtc();
 430     SET_FARVAR(seg, info->sequ_index, inb(VGAREG_SEQU_ADDRESS));
 431     SET_FARVAR(seg, info->crtc_index, inb(crtc_addr));
 432     SET_FARVAR(seg, info->grdc_index, inb(VGAREG_GRDC_ADDRESS));
 433     inb(VGAREG_ACTL_RESET);
 434     u16 ar_index = inb(VGAREG_ACTL_ADDRESS);
 435     SET_FARVAR(seg, info->actl_index, ar_index);
 436     SET_FARVAR(seg, info->feature, inb(VGAREG_READ_FEATURE_CTL));
 437
 438     u16 i;
 439     for (i=0; i<4; i++) {
 440         outb(i+1, VGAREG_SEQU_ADDRESS);
 441         SET_FARVAR(seg, info->sequ_regs[i], inb(VGAREG_SEQU_DATA));
 442     }
 443     outb(0, VGAREG_SEQU_ADDRESS);
 444     SET_FARVAR(seg, info->sequ0, inb(VGAREG_SEQU_DATA));
 445
 446     for (i=0; i<25; i++) {
 447         outb(i, crtc_addr);
 448         SET_FARVAR(seg, info->crtc_regs[i], inb(crtc_addr + 1));
 449     }
 450
 451     for (i=0; i<20; i++) {
 452         inb(VGAREG_ACTL_RESET);
 453         outb(i | (ar_index & 0x20), VGAREG_ACTL_ADDRESS);
 454         SET_FARVAR(seg, info->actl_regs[i], inb(VGAREG_ACTL_READ_DATA));
 455     }
 456     inb(VGAREG_ACTL_RESET);
 457
 458     for (i=0; i<9; i++) {
 459         outb(i, VGAREG_GRDC_ADDRESS);
 460         SET_FARVAR(seg, info->grdc_regs[i], inb(VGAREG_GRDC_DATA));
 461     }
 462
 463     SET_FARVAR(seg, info->crtc_addr, crtc_addr);
 464
 465     /* XXX: read plane latches */
 466     for (i=0; i<4; i++)
 467         SET_FARVAR(seg, info->plane_latch[i], 0);
 468 }
 469
 470 void
 471 stdvga_restore_state(u16 seg, struct saveVideoHardware *info)
 472 {
 473     // Reset Attribute Ctl flip-flop
 474     inb(VGAREG_ACTL_RESET);
 475
 476     u16 crtc_addr = GET_FARVAR(seg, info->crtc_addr);
 477
 478     u16 i;
 479     for (i=0; i<4; i++) {
 480         outb(i+1, VGAREG_SEQU_ADDRESS);
 481         outb(GET_FARVAR(seg, info->sequ_regs[i]), VGAREG_SEQU_DATA);
 482     }
 483     outb(0, VGAREG_SEQU_ADDRESS);
 484     outb(GET_FARVAR(seg, info->sequ0), VGAREG_SEQU_DATA);
 485
 486     // Disable CRTC write protection
 487     outw(0x0011, crtc_addr);
 488     // Set CRTC regs
 489     for (i=0; i<25; i++)
 490         if (i != 0x11) {
 491             outb(i, crtc_addr);
 492             outb(GET_FARVAR(seg, info->crtc_regs[i]), crtc_addr + 1);
 493         }
 494     // select crtc base address
 495     u16 v = inb(VGAREG_READ_MISC_OUTPUT) & ~0x01;
 496     if (crtc_addr == VGAREG_VGA_CRTC_ADDRESS)
 497         v |= 0x01;
 498     outb(v, VGAREG_WRITE_MISC_OUTPUT);
 499
 500     // enable write protection if needed
 501     outb(0x11, crtc_addr);
 502     outb(GET_FARVAR(seg, info->crtc_regs[0x11]), crtc_addr + 1);
 503
 504     // Set Attribute Ctl
 505     u16 ar_index = GET_FARVAR(seg, info->actl_index);
 506     inb(VGAREG_ACTL_RESET);
 507     for (i=0; i<20; i++) {
 508         outb(i | (ar_index & 0x20), VGAREG_ACTL_ADDRESS);
 509         outb(GET_FARVAR(seg, info->actl_regs[i]), VGAREG_ACTL_WRITE_DATA);
 510     }
 511     outb(ar_index, VGAREG_ACTL_ADDRESS);
 512     inb(VGAREG_ACTL_RESET);
 513
 514     for (i=0; i<9; i++) {
 515         outb(i, VGAREG_GRDC_ADDRESS);
 516         outb(GET_FARVAR(seg, info->grdc_regs[i]), VGAREG_GRDC_DATA);
 517     }
 518
 519     outb(GET_FARVAR(seg, info->sequ_index), VGAREG_SEQU_ADDRESS);
 520     outb(GET_FARVAR(seg, info->crtc_index), crtc_addr);
 521     outb(GET_FARVAR(seg, info->grdc_index), VGAREG_GRDC_ADDRESS);
 522     outb(GET_FARVAR(seg, info->feature), crtc_addr - 0x4 + 0xa);
 523 }
 524
 525 static void
 526 clear_screen(struct vgamode_s *vmode_g)
 527 {
 528     switch (GET_GLOBAL(vmode_g->memmodel)) {
 529     case MM_TEXT:
 530         memset16_far(GET_GLOBAL(vmode_g->sstart), 0, 0x0720, 32*1024);
 531         break;
 532     case MM_CGA:
 533         memset16_far(GET_GLOBAL(vmode_g->sstart), 0, 0x0000, 32*1024);
 534         break;
 535     default:
 536         // XXX - old code gets/sets/restores sequ register 2 to 0xf -
 537         // but it should always be 0xf anyway.
 538         memset16_far(GET_GLOBAL(vmode_g->sstart), 0, 0x0000, 64*1024);
 539     }
 540 }
 541
 542 int
 543 stdvga_set_mode(int mode, int flags)
 544 {
 545     // find the entry in the video modes
 546     struct vgamode_s *vmode_g = stdvga_find_mode(mode);
 547     dprintf(1, "mode search %02x found %p\n", mode, vmode_g);
 548     if (!vmode_g)
 549         return VBE_RETURN_STATUS_FAILED;
 550     struct stdvga_mode_s *stdmode_g = container_of(
 551         vmode_g, struct stdvga_mode_s, info);
 552
 553     // if palette loading (bit 3 of modeset ctl = 0)
 554     if (!(flags & MF_NOPALETTE)) {    // Set the PEL mask
 555         stdvga_set_pel_mask(GET_GLOBAL(stdmode_g->pelmask));
 556
 557         // From which palette
 558         u8 *palette_g = GET_GLOBAL(stdmode_g->dac);
 559         u16 palsize = GET_GLOBAL(stdmode_g->dacsize) / 3;
 560
 561         // Always 256*3 values
 562         stdvga_set_dac_regs(get_global_seg(), palette_g, 0, palsize);
 563         u16 i;
 564         for (i = palsize; i < 0x0100; i++) {
 565             static u8 rgb[3] VAR16;
 566             stdvga_set_dac_regs(get_global_seg(), rgb, i, 1);
 567         }
 568
 569         if (flags & MF_GRAYSUM)
 570             stdvga_perform_gray_scale_summing(0x00, 0x100);
 571     }
 572
 573     // Reset Attribute Ctl flip-flop
 574     inb(VGAREG_ACTL_RESET);
 575
 576     // Set Attribute Ctl
 577     u8 *regs = GET_GLOBAL(stdmode_g->actl_regs);
 578     u16 i;
 579     for (i = 0; i <= 0x13; i++) {
 580         outb(i, VGAREG_ACTL_ADDRESS);
 581         outb(GET_GLOBAL(regs[i]), VGAREG_ACTL_WRITE_DATA);
 582     }
 583     outb(0x14, VGAREG_ACTL_ADDRESS);
 584     outb(0x00, VGAREG_ACTL_WRITE_DATA);
 585
 586     // Set Sequencer Ctl
 587     outb(0, VGAREG_SEQU_ADDRESS);
 588     outb(0x03, VGAREG_SEQU_DATA);
 589     regs = GET_GLOBAL(stdmode_g->sequ_regs);
 590     for (i = 1; i <= 4; i++) {
 591         outb(i, VGAREG_SEQU_ADDRESS);
 592         outb(GET_GLOBAL(regs[i - 1]), VGAREG_SEQU_DATA);
 593     }
 594
 595     // Set Grafx Ctl
 596     regs = GET_GLOBAL(stdmode_g->grdc_regs);
 597     for (i = 0; i <= 8; i++) {
 598         outb(i, VGAREG_GRDC_ADDRESS);
 599         outb(GET_GLOBAL(regs[i]), VGAREG_GRDC_DATA);
 600     }
 601
 602     // Set CRTC address VGA or MDA
 603     u8 miscreg = GET_GLOBAL(stdmode_g->miscreg);
 604     u16 crtc_addr = VGAREG_VGA_CRTC_ADDRESS;
 605     if (!(miscreg & 1))
 606         crtc_addr = VGAREG_MDA_CRTC_ADDRESS;
 607
 608     // Disable CRTC write protection
 609     outw(0x0011, crtc_addr);
 610     // Set CRTC regs
 611     regs = GET_GLOBAL(stdmode_g->crtc_regs);
 612     for (i = 0; i <= 0x18; i++) {
 613         outb(i, crtc_addr);
 614         outb(GET_GLOBAL(regs[i]), crtc_addr + 1);
 615     }
 616
 617     // Set the misc register
 618     outb(miscreg, VGAREG_WRITE_MISC_OUTPUT);
 619
 620     // Enable video
 621     outb(0x20, VGAREG_ACTL_ADDRESS);
 622     inb(VGAREG_ACTL_RESET);
 623
 624     // Clear screen
 625     if (!(flags & MF_NOCLEARMEM))
 626         clear_screen(vmode_g);
 627
 628     // Write the fonts in memory
 629     u8 memmodel = GET_GLOBAL(vmode_g->memmodel);
 630     if (memmodel == MM_TEXT)
 631         stdvga_load_font(get_global_seg(), vgafont16, 0x100, 0, 0, 16);
 632
 633     // Setup BDA variables
 634     modeswitch_set_bda(mode, flags, vmode_g);
 635
 636     return 0;
 637 }
 638
 639
 640 /****************************************************************
 641  * Misc
 642  ****************************************************************/
 643
 644 void
 645 stdvga_list_modes(u16 seg, u16 *dest, u16 *last)
 646 {
 647     SET_FARVAR(seg, *dest, 0xffff);
 648 }
 649
 650 void
 651 stdvga_enable_video_addressing(u8 disable)
 652 {
 653     u8 v = (disable & 1) ? 0x00 : 0x02;
 654     u8 v2 = inb(VGAREG_READ_MISC_OUTPUT) & ~0x02;
 655     outb(v | v2, VGAREG_WRITE_MISC_OUTPUT);
 656 }
 657
 658 int
 659 stdvga_init(void)
 660 {
 661     // switch to color mode and enable CPU access 480 lines
 662     outb(0xc3, VGAREG_WRITE_MISC_OUTPUT);
 663     // more than 64k 3C4/04
 664     outb(0x04, VGAREG_SEQU_ADDRESS);
 665     outb(0x02, VGAREG_SEQU_DATA);
 666
 667     return 0;
 668 }