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_BDA
  12 #include "vgabios.h" // VGAREG_*
  13 #include "util.h" // memcpy_far
  14
  15 // TODO
  16 //  * replace direct in/out calls with wrapper functions
  17
  18
  19 /****************************************************************
  20  * Attribute control
  21  ****************************************************************/
  22
  23 void
  24 stdvga_screen_disable(void)
  25 {
  26     inb(VGAREG_ACTL_RESET);
  27     outb(0x00, VGAREG_ACTL_ADDRESS);
  28 }
  29
  30 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
 270 /****************************************************************
 271  * Memory control
 272  ****************************************************************/
 273
 274 void
 275 stdvga_sequ_write(u8 index, u8 value)
 276 {
 277     outw((value<<8) | index, VGAREG_SEQU_ADDRESS);
 278 }
 279
 280 void
 281 stdvga_grdc_write(u8 index, u8 value)
 282 {
 283     outw((value<<8) | index, VGAREG_GRDC_ADDRESS);
 284 }
 285
 286 void
 287 stdvga_set_text_block_specifier(u8 spec)
 288 {
 289     outw((spec << 8) | 0x03, VGAREG_SEQU_ADDRESS);
 290 }
 291
 292
 293 /****************************************************************
 294  * Font loading
 295  ****************************************************************/
 296
 297 static void
 298 get_font_access(void)
 299 {
 300     outw(0x0100, VGAREG_SEQU_ADDRESS);
 301     outw(0x0402, VGAREG_SEQU_ADDRESS);
 302     outw(0x0704, VGAREG_SEQU_ADDRESS);
 303     outw(0x0300, VGAREG_SEQU_ADDRESS);
 304     outw(0x0204, VGAREG_GRDC_ADDRESS);
 305     outw(0x0005, VGAREG_GRDC_ADDRESS);
 306     outw(0x0406, VGAREG_GRDC_ADDRESS);
 307 }
 308
 309 static void
 310 release_font_access(void)
 311 {
 312     outw(0x0100, VGAREG_SEQU_ADDRESS);
 313     outw(0x0302, VGAREG_SEQU_ADDRESS);
 314     outw(0x0304, VGAREG_SEQU_ADDRESS);
 315     outw(0x0300, VGAREG_SEQU_ADDRESS);
 316     u16 v = (inb(VGAREG_READ_MISC_OUTPUT) & 0x01) ? 0x0e : 0x0a;
 317     outw((v << 8) | 0x06, VGAREG_GRDC_ADDRESS);
 318     outw(0x0004, VGAREG_GRDC_ADDRESS);
 319     outw(0x1005, VGAREG_GRDC_ADDRESS);
 320 }
 321
 322 void
 323 stdvga_load_font(u16 seg, void *src_far, u16 count
 324                  , u16 start, u8 destflags, u8 fontsize)
 325 {
 326     get_font_access();
 327     u16 blockaddr = ((destflags & 0x03) << 14) + ((destflags & 0x04) << 11);
 328     void *dest_far = (void*)(blockaddr + start*32);
 329     u16 i;
 330     for (i = 0; i < count; i++)
 331         memcpy_far(SEG_GRAPH, dest_far + i*32
 332                    , seg, src_far + i*fontsize, fontsize);
 333     release_font_access();
 334 }
 335
 336
 337 /****************************************************************
 338  * CRTC registers
 339  ****************************************************************/
 340
 341 static u16
 342 get_crtc(void)
 343 {
 344     return GET_BDA(crtc_address);
 345 }
 346
 347 void
 348 stdvga_set_cursor_shape(u8 start, u8 end)
 349 {
 350     u16 crtc_addr = get_crtc();
 351     outb(0x0a, crtc_addr);
 352     outb(start, crtc_addr + 1);
 353     outb(0x0b, crtc_addr);
 354     outb(end, crtc_addr + 1);
 355 }
 356
 357 void
 358 stdvga_set_active_page(u16 address)
 359 {
 360     u16 crtc_addr = get_crtc();
 361     outb(0x0c, crtc_addr);
 362     outb((address & 0xff00) >> 8, crtc_addr + 1);
 363     outb(0x0d, crtc_addr);
 364     outb(address & 0x00ff, crtc_addr + 1);
 365 }
 366
 367 void
 368 stdvga_set_cursor_pos(u16 address)
 369 {
 370     u16 crtc_addr = get_crtc();
 371     outb(0x0e, crtc_addr);
 372     outb((address & 0xff00) >> 8, crtc_addr + 1);
 373     outb(0x0f, crtc_addr);
 374     outb(address & 0x00ff, crtc_addr + 1);
 375 }
 376
 377 void
 378 stdvga_set_scan_lines(u8 lines)
 379 {
 380     u16 crtc_addr = get_crtc();
 381     outb(0x09, crtc_addr);
 382     u8 crtc_r9 = inb(crtc_addr + 1);
 383     crtc_r9 = (crtc_r9 & 0xe0) | (lines - 1);
 384     outb(crtc_r9, crtc_addr + 1);
 385 }
 386
 387 // Get vertical display end
 388 u16
 389 stdvga_get_vde(void)
 390 {
 391     u16 crtc_addr = get_crtc();
 392     outb(0x12, crtc_addr);
 393     u16 vde = inb(crtc_addr + 1);
 394     outb(0x07, crtc_addr);
 395     u8 ovl = inb(crtc_addr + 1);
 396     vde += (((ovl & 0x02) << 7) + ((ovl & 0x40) << 3) + 1);
 397     return vde;
 398 }
 399
 400
 401 /****************************************************************
 402  * Save/Restore/Set state
 403  ****************************************************************/
 404
 405 void
 406 stdvga_save_state(u16 seg, struct saveVideoHardware *info)
 407 {
 408     u16 crtc_addr = get_crtc();
 409     SET_FARVAR(seg, info->sequ_index, inb(VGAREG_SEQU_ADDRESS));
 410     SET_FARVAR(seg, info->crtc_index, inb(crtc_addr));
 411     SET_FARVAR(seg, info->grdc_index, inb(VGAREG_GRDC_ADDRESS));
 412     inb(VGAREG_ACTL_RESET);
 413     u16 ar_index = inb(VGAREG_ACTL_ADDRESS);
 414     SET_FARVAR(seg, info->actl_index, ar_index);
 415     SET_FARVAR(seg, info->feature, inb(VGAREG_READ_FEATURE_CTL));
 416
 417     u16 i;
 418     for (i=0; i<4; i++) {
 419         outb(i+1, VGAREG_SEQU_ADDRESS);
 420         SET_FARVAR(seg, info->sequ_regs[i], inb(VGAREG_SEQU_DATA));
 421     }
 422     outb(0, VGAREG_SEQU_ADDRESS);
 423     SET_FARVAR(seg, info->sequ0, inb(VGAREG_SEQU_DATA));
 424
 425     for (i=0; i<25; i++) {
 426         outb(i, crtc_addr);
 427         SET_FARVAR(seg, info->crtc_regs[i], inb(crtc_addr + 1));
 428     }
 429
 430     for (i=0; i<20; i++) {
 431         inb(VGAREG_ACTL_RESET);
 432         outb(i | (ar_index & 0x20), VGAREG_ACTL_ADDRESS);
 433         SET_FARVAR(seg, info->actl_regs[i], inb(VGAREG_ACTL_READ_DATA));
 434     }
 435     inb(VGAREG_ACTL_RESET);
 436
 437     for (i=0; i<9; i++) {
 438         outb(i, VGAREG_GRDC_ADDRESS);
 439         SET_FARVAR(seg, info->grdc_regs[i], inb(VGAREG_GRDC_DATA));
 440     }
 441
 442     SET_FARVAR(seg, info->crtc_addr, crtc_addr);
 443
 444     /* XXX: read plane latches */
 445     for (i=0; i<4; i++)
 446         SET_FARVAR(seg, info->plane_latch[i], 0);
 447 }
 448
 449 void
 450 stdvga_restore_state(u16 seg, struct saveVideoHardware *info)
 451 {
 452     // Reset Attribute Ctl flip-flop
 453     inb(VGAREG_ACTL_RESET);
 454
 455     u16 crtc_addr = GET_FARVAR(seg, info->crtc_addr);
 456
 457     u16 i;
 458     for (i=0; i<4; i++) {
 459         outb(i+1, VGAREG_SEQU_ADDRESS);
 460         outb(GET_FARVAR(seg, info->sequ_regs[i]), VGAREG_SEQU_DATA);
 461     }
 462     outb(0, VGAREG_SEQU_ADDRESS);
 463     outb(GET_FARVAR(seg, info->sequ0), VGAREG_SEQU_DATA);
 464
 465     // Disable CRTC write protection
 466     outw(0x0011, crtc_addr);
 467     // Set CRTC regs
 468     for (i=0; i<25; i++)
 469         if (i != 0x11) {
 470             outb(i, crtc_addr);
 471             outb(GET_FARVAR(seg, info->crtc_regs[i]), crtc_addr + 1);
 472         }
 473     // select crtc base address
 474     u16 v = inb(VGAREG_READ_MISC_OUTPUT) & ~0x01;
 475     if (crtc_addr == VGAREG_VGA_CRTC_ADDRESS)
 476         v |= 0x01;
 477     outb(v, VGAREG_WRITE_MISC_OUTPUT);
 478
 479     // enable write protection if needed
 480     outb(0x11, crtc_addr);
 481     outb(GET_FARVAR(seg, info->crtc_regs[0x11]), crtc_addr + 1);
 482
 483     // Set Attribute Ctl
 484     u16 ar_index = GET_FARVAR(seg, info->actl_index);
 485     inb(VGAREG_ACTL_RESET);
 486     for (i=0; i<20; i++) {
 487         outb(i | (ar_index & 0x20), VGAREG_ACTL_ADDRESS);
 488         outb(GET_FARVAR(seg, info->actl_regs[i]), VGAREG_ACTL_WRITE_DATA);
 489     }
 490     outb(ar_index, VGAREG_ACTL_ADDRESS);
 491     inb(VGAREG_ACTL_RESET);
 492
 493     for (i=0; i<9; i++) {
 494         outb(i, VGAREG_GRDC_ADDRESS);
 495         outb(GET_FARVAR(seg, info->grdc_regs[i]), VGAREG_GRDC_DATA);
 496     }
 497
 498     outb(GET_FARVAR(seg, info->sequ_index), VGAREG_SEQU_ADDRESS);
 499     outb(GET_FARVAR(seg, info->crtc_index), crtc_addr);
 500     outb(GET_FARVAR(seg, info->grdc_index), VGAREG_GRDC_ADDRESS);
 501     outb(GET_FARVAR(seg, info->feature), crtc_addr - 0x4 + 0xa);
 502 }
 503
 504 void
 505 stdvga_set_mode(struct vgamode_s *vmode_g)
 506 {
 507     // Reset Attribute Ctl flip-flop
 508     inb(VGAREG_ACTL_RESET);
 509
 510     // Set Attribute Ctl
 511     u8 *regs = GET_GLOBAL(vmode_g->actl_regs);
 512     u16 i;
 513     for (i = 0; i <= 0x13; i++) {
 514         outb(i, VGAREG_ACTL_ADDRESS);
 515         outb(GET_GLOBAL(regs[i]), VGAREG_ACTL_WRITE_DATA);
 516     }
 517     outb(0x14, VGAREG_ACTL_ADDRESS);
 518     outb(0x00, VGAREG_ACTL_WRITE_DATA);
 519
 520     // Set Sequencer Ctl
 521     outb(0, VGAREG_SEQU_ADDRESS);
 522     outb(0x03, VGAREG_SEQU_DATA);
 523     regs = GET_GLOBAL(vmode_g->sequ_regs);
 524     for (i = 1; i <= 4; i++) {
 525         outb(i, VGAREG_SEQU_ADDRESS);
 526         outb(GET_GLOBAL(regs[i - 1]), VGAREG_SEQU_DATA);
 527     }
 528
 529     // Set Grafx Ctl
 530     regs = GET_GLOBAL(vmode_g->grdc_regs);
 531     for (i = 0; i <= 8; i++) {
 532         outb(i, VGAREG_GRDC_ADDRESS);
 533         outb(GET_GLOBAL(regs[i]), VGAREG_GRDC_DATA);
 534     }
 535
 536     // Set CRTC address VGA or MDA
 537     u8 miscreg = GET_GLOBAL(vmode_g->miscreg);
 538     u16 crtc_addr = VGAREG_VGA_CRTC_ADDRESS;
 539     if (!(miscreg & 1))
 540         crtc_addr = VGAREG_MDA_CRTC_ADDRESS;
 541
 542     // Disable CRTC write protection
 543     outw(0x0011, crtc_addr);
 544     // Set CRTC regs
 545     regs = GET_GLOBAL(vmode_g->crtc_regs);
 546     for (i = 0; i <= 0x18; i++) {
 547         outb(i, crtc_addr);
 548         outb(GET_GLOBAL(regs[i]), crtc_addr + 1);
 549     }
 550
 551     // Set the misc register
 552     outb(miscreg, VGAREG_WRITE_MISC_OUTPUT);
 553
 554     // Enable video
 555     outb(0x20, VGAREG_ACTL_ADDRESS);
 556     inb(VGAREG_ACTL_RESET);
 557 }
 558
 559
 560 /****************************************************************
 561  * Misc
 562  ****************************************************************/
 563
 564 void
 565 stdvga_enable_video_addressing(u8 disable)
 566 {
 567     u8 v = (disable & 1) ? 0x00 : 0x02;
 568     u8 v2 = inb(VGAREG_READ_MISC_OUTPUT) & ~0x02;
 569     outb(v | v2, VGAREG_WRITE_MISC_OUTPUT);
 570 }
 571
 572 void
 573 stdvga_init(void)
 574 {
 575     // switch to color mode and enable CPU access 480 lines
 576     outb(0xc3, VGAREG_WRITE_MISC_OUTPUT);
 577     // more than 64k 3C4/04
 578     outb(0x04, VGAREG_SEQU_ADDRESS);
 579     outb(0x02, VGAREG_SEQU_DATA);
 580 }