![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vbe.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / vgabios|
Return to vbe.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / vgabios |
1.1 ! root 1: // ============================================================================================ ! 2: // ! 3: // Copyright (C) 2002 Jeroen Janssen ! 4: // ! 5: // This library is free software; you can redistribute it and/or ! 6: // modify it under the terms of the GNU Lesser General Public ! 7: // License as published by the Free Software Foundation; either ! 8: // version 2 of the License, or (at your option) any later version. ! 9: // ! 10: // This library is distributed in the hope that it will be useful, ! 11: // but WITHOUT ANY WARRANTY; without even the implied warranty of ! 12: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 13: // Lesser General Public License for more details. ! 14: // ! 15: // You should have received a copy of the GNU Lesser General Public ! 16: // License along with this library; if not, write to the Free Software ! 17: // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ! 18: // ! 19: // ============================================================================================ ! 20: // ! 21: // This VBE is part of the VGA Bios specific to the plex86/bochs Emulated VGA card. ! 22: // You can NOT drive any physical vga card with it. ! 23: // ! 24: // ============================================================================================ ! 25: // ! 26: // This VBE Bios is based on information taken from : ! 27: // - VESA BIOS EXTENSION (VBE) Core Functions Standard Version 3.0 located at www.vesa.org ! 28: // ! 29: // ============================================================================================ ! 30: ! 31: ! 32: // defines available ! 33: ! 34: // disable VESA/VBE2 check in vbe info ! 35: //#define VBE2_NO_VESA_CHECK ! 36: ! 37: ! 38: #include "vbe.h" ! 39: #include "vbetables.h" ! 40: ! 41: #define VBE_TOTAL_VIDEO_MEMORY_DIV_64K (VBE_DISPI_TOTAL_VIDEO_MEMORY_MB*1024/64) ! 42: ! 43: // The current OEM Software Revision of this VBE Bios ! 44: #define VBE_OEM_SOFTWARE_REV 0x0002; ! 45: ! 46: extern char vbebios_copyright; ! 47: extern char vbebios_vendor_name; ! 48: extern char vbebios_product_name; ! 49: extern char vbebios_product_revision; ! 50: ! 51: ASM_START ! 52: // FIXME: 'merge' these (c) etc strings with the vgabios.c strings? ! 53: _vbebios_copyright: ! 54: .ascii "Bochs/Plex86 VBE(C) 2003 http://savannah.nongnu.org/projects/vgabios/" ! 55: .byte 0x00 ! 56: ! 57: _vbebios_vendor_name: ! 58: .ascii "Bochs/Plex86 Developers" ! 59: .byte 0x00 ! 60: ! 61: _vbebios_product_name: ! 62: .ascii "Bochs/Plex86 VBE Adapter" ! 63: .byte 0x00 ! 64: ! 65: _vbebios_product_revision: ! 66: .ascii "$Id$" ! 67: .byte 0x00 ! 68: ! 69: _vbebios_info_string: ! 70: .ascii "Bochs VBE Display Adapter enabled" ! 71: .byte 0x0a,0x0d ! 72: .byte 0x0a,0x0d ! 73: .byte 0x00 ! 74: ! 75: _no_vbebios_info_string: ! 76: .ascii "NO Bochs VBE Support available!" ! 77: .byte 0x0a,0x0d ! 78: .byte 0x0a,0x0d ! 79: .byte 0x00 ! 80: ! 81: #if defined(USE_BX_INFO) || defined(DEBUG) ! 82: msg_vbe_init: ! 83: .ascii "VBE Bios $Id$" ! 84: .byte 0x0a,0x0d, 0x00 ! 85: #endif ! 86: ! 87: .align 2 ! 88: vesa_pm_start: ! 89: dw vesa_pm_set_window - vesa_pm_start ! 90: dw vesa_pm_set_display_start - vesa_pm_start ! 91: dw vesa_pm_unimplemented - vesa_pm_start ! 92: dw vesa_pm_io_ports_table - vesa_pm_start ! 93: vesa_pm_io_ports_table: ! 94: dw VBE_DISPI_IOPORT_INDEX ! 95: dw VBE_DISPI_IOPORT_INDEX + 1 ! 96: dw VBE_DISPI_IOPORT_DATA ! 97: dw VBE_DISPI_IOPORT_DATA + 1 ! 98: dw 0xffff ! 99: dw 0xffff ! 100: ! 101: USE32 ! 102: vesa_pm_set_window: ! 103: cmp bx, #0x00 ! 104: je vesa_pm_set_display_window1 ! 105: mov ax, #0x0100 ! 106: ret ! 107: vesa_pm_set_display_window1: ! 108: mov ax, dx ! 109: push dx ! 110: push ax ! 111: mov dx, # VBE_DISPI_IOPORT_INDEX ! 112: mov ax, # VBE_DISPI_INDEX_BANK ! 113: out dx, ax ! 114: pop ax ! 115: mov dx, # VBE_DISPI_IOPORT_DATA ! 116: out dx, ax ! 117: in ax, dx ! 118: pop dx ! 119: cmp dx, ax ! 120: jne illegal_window ! 121: mov ax, #0x004f ! 122: ret ! 123: illegal_window: ! 124: mov ax, #0x014f ! 125: ret ! 126: ! 127: vesa_pm_set_display_start: ! 128: cmp bl, #0x80 ! 129: je vesa_pm_set_display_start1 ! 130: cmp bl, #0x00 ! 131: je vesa_pm_set_display_start1 ! 132: mov ax, #0x0100 ! 133: ret ! 134: vesa_pm_set_display_start1: ! 135: ; convert offset to (X, Y) coordinate ! 136: ; (would be simpler to change Bochs VBE API...) ! 137: push eax ! 138: push ecx ! 139: push edx ! 140: push esi ! 141: push edi ! 142: shl edx, #16 ! 143: and ecx, #0xffff ! 144: or ecx, edx ! 145: shl ecx, #2 ! 146: mov eax, ecx ! 147: ! 148: push eax ! 149: mov dx, # VBE_DISPI_IOPORT_INDEX ! 150: mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH ! 151: out dx, ax ! 152: mov dx, # VBE_DISPI_IOPORT_DATA ! 153: in ax, dx ! 154: movzx ecx, ax ! 155: ! 156: mov dx, # VBE_DISPI_IOPORT_INDEX ! 157: mov ax, # VBE_DISPI_INDEX_BPP ! 158: out dx, ax ! 159: mov dx, # VBE_DISPI_IOPORT_DATA ! 160: in ax, dx ! 161: movzx esi, ax ! 162: pop eax ! 163: ! 164: cmp esi, #4 ! 165: jz bpp4_mode ! 166: add esi, #7 ! 167: shr esi, #3 ! 168: imul ecx, esi ! 169: xor edx, edx ! 170: div ecx ! 171: mov edi, eax ! 172: mov eax, edx ! 173: xor edx, edx ! 174: div esi ! 175: jmp set_xy_regs ! 176: ! 177: bpp4_mode: ! 178: shr ecx, #1 ! 179: xor edx, edx ! 180: div ecx ! 181: mov edi, eax ! 182: mov eax, edx ! 183: shl eax, #1 ! 184: ! 185: set_xy_regs: ! 186: push dx ! 187: push ax ! 188: mov dx, # VBE_DISPI_IOPORT_INDEX ! 189: mov ax, # VBE_DISPI_INDEX_X_OFFSET ! 190: out dx, ax ! 191: pop ax ! 192: mov dx, # VBE_DISPI_IOPORT_DATA ! 193: out dx, ax ! 194: pop dx ! 195: ! 196: mov ax, di ! 197: push dx ! 198: push ax ! 199: mov dx, # VBE_DISPI_IOPORT_INDEX ! 200: mov ax, # VBE_DISPI_INDEX_Y_OFFSET ! 201: out dx, ax ! 202: pop ax ! 203: mov dx, # VBE_DISPI_IOPORT_DATA ! 204: out dx, ax ! 205: pop dx ! 206: ! 207: pop edi ! 208: pop esi ! 209: pop edx ! 210: pop ecx ! 211: pop eax ! 212: mov ax, #0x004f ! 213: ret ! 214: ! 215: vesa_pm_unimplemented: ! 216: mov ax, #0x014f ! 217: ret ! 218: USE16 ! 219: vesa_pm_end: ! 220: ! 221: ; DISPI ioport functions ! 222: ! 223: dispi_get_id: ! 224: push dx ! 225: mov dx, # VBE_DISPI_IOPORT_INDEX ! 226: mov ax, # VBE_DISPI_INDEX_ID ! 227: out dx, ax ! 228: mov dx, # VBE_DISPI_IOPORT_DATA ! 229: in ax, dx ! 230: pop dx ! 231: ret ! 232: ! 233: dispi_set_id: ! 234: push dx ! 235: push ax ! 236: mov dx, # VBE_DISPI_IOPORT_INDEX ! 237: mov ax, # VBE_DISPI_INDEX_ID ! 238: out dx, ax ! 239: pop ax ! 240: mov dx, # VBE_DISPI_IOPORT_DATA ! 241: out dx, ax ! 242: pop dx ! 243: ret ! 244: ASM_END ! 245: ! 246: static void dispi_set_xres(xres) ! 247: Bit16u xres; ! 248: { ! 249: ASM_START ! 250: push bp ! 251: mov bp, sp ! 252: push ax ! 253: push dx ! 254: ! 255: mov dx, # VBE_DISPI_IOPORT_INDEX ! 256: mov ax, # VBE_DISPI_INDEX_XRES ! 257: out dx, ax ! 258: mov dx, # VBE_DISPI_IOPORT_DATA ! 259: mov ax, 4[bp] ; xres ! 260: out dx, ax ! 261: ! 262: pop dx ! 263: pop ax ! 264: pop bp ! 265: ASM_END ! 266: } ! 267: ! 268: static void dispi_set_yres(yres) ! 269: Bit16u yres; ! 270: { ! 271: outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_YRES); ! 272: outw(VBE_DISPI_IOPORT_DATA,yres); ! 273: } ! 274: ! 275: static void dispi_set_bpp(bpp) ! 276: Bit16u bpp; ! 277: { ! 278: outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_BPP); ! 279: outw(VBE_DISPI_IOPORT_DATA,bpp); ! 280: } ! 281: ! 282: ASM_START ! 283: ; AL = bits per pixel / AH = bytes per pixel ! 284: dispi_get_bpp: ! 285: push dx ! 286: mov dx, # VBE_DISPI_IOPORT_INDEX ! 287: mov ax, # VBE_DISPI_INDEX_BPP ! 288: out dx, ax ! 289: mov dx, # VBE_DISPI_IOPORT_DATA ! 290: in ax, dx ! 291: mov ah, al ! 292: shr ah, 3 ! 293: test al, #0x07 ! 294: jz get_bpp_noinc ! 295: inc ah ! 296: get_bpp_noinc: ! 297: pop dx ! 298: ret ! 299: ! 300: ; get display capabilities ! 301: ! 302: _dispi_get_max_xres: ! 303: push dx ! 304: push bx ! 305: call dispi_get_enable ! 306: mov bx, ax ! 307: or ax, # VBE_DISPI_GETCAPS ! 308: call _dispi_set_enable ! 309: mov dx, # VBE_DISPI_IOPORT_INDEX ! 310: mov ax, # VBE_DISPI_INDEX_XRES ! 311: out dx, ax ! 312: mov dx, # VBE_DISPI_IOPORT_DATA ! 313: in ax, dx ! 314: push ax ! 315: mov ax, bx ! 316: call _dispi_set_enable ! 317: pop ax ! 318: pop bx ! 319: pop dx ! 320: ret ! 321: ! 322: _dispi_get_max_bpp: ! 323: push dx ! 324: push bx ! 325: call dispi_get_enable ! 326: mov bx, ax ! 327: or ax, # VBE_DISPI_GETCAPS ! 328: call _dispi_set_enable ! 329: mov dx, # VBE_DISPI_IOPORT_INDEX ! 330: mov ax, # VBE_DISPI_INDEX_BPP ! 331: out dx, ax ! 332: mov dx, # VBE_DISPI_IOPORT_DATA ! 333: in ax, dx ! 334: push ax ! 335: mov ax, bx ! 336: call _dispi_set_enable ! 337: pop ax ! 338: pop bx ! 339: pop dx ! 340: ret ! 341: ! 342: _dispi_set_enable: ! 343: push dx ! 344: push ax ! 345: mov dx, # VBE_DISPI_IOPORT_INDEX ! 346: mov ax, # VBE_DISPI_INDEX_ENABLE ! 347: out dx, ax ! 348: pop ax ! 349: mov dx, # VBE_DISPI_IOPORT_DATA ! 350: out dx, ax ! 351: pop dx ! 352: ret ! 353: ! 354: dispi_get_enable: ! 355: push dx ! 356: mov dx, # VBE_DISPI_IOPORT_INDEX ! 357: mov ax, # VBE_DISPI_INDEX_ENABLE ! 358: out dx, ax ! 359: mov dx, # VBE_DISPI_IOPORT_DATA ! 360: in ax, dx ! 361: pop dx ! 362: ret ! 363: ! 364: _dispi_set_bank: ! 365: push dx ! 366: push ax ! 367: mov dx, # VBE_DISPI_IOPORT_INDEX ! 368: mov ax, # VBE_DISPI_INDEX_BANK ! 369: out dx, ax ! 370: pop ax ! 371: mov dx, # VBE_DISPI_IOPORT_DATA ! 372: out dx, ax ! 373: pop dx ! 374: ret ! 375: ! 376: dispi_get_bank: ! 377: push dx ! 378: mov dx, # VBE_DISPI_IOPORT_INDEX ! 379: mov ax, # VBE_DISPI_INDEX_BANK ! 380: out dx, ax ! 381: mov dx, # VBE_DISPI_IOPORT_DATA ! 382: in ax, dx ! 383: pop dx ! 384: ret ! 385: ASM_END ! 386: ! 387: static void dispi_set_bank_farcall() ! 388: { ! 389: ASM_START ! 390: cmp bx,#0x0100 ! 391: je dispi_set_bank_farcall_get ! 392: or bx,bx ! 393: jnz dispi_set_bank_farcall_error ! 394: mov ax,dx ! 395: push dx ! 396: push ax ! 397: mov ax,# VBE_DISPI_INDEX_BANK ! 398: mov dx,# VBE_DISPI_IOPORT_INDEX ! 399: out dx,ax ! 400: pop ax ! 401: mov dx,# VBE_DISPI_IOPORT_DATA ! 402: out dx,ax ! 403: in ax,dx ! 404: pop dx ! 405: cmp dx,ax ! 406: jne dispi_set_bank_farcall_error ! 407: mov ax, #0x004f ! 408: retf ! 409: dispi_set_bank_farcall_get: ! 410: mov ax,# VBE_DISPI_INDEX_BANK ! 411: mov dx,# VBE_DISPI_IOPORT_INDEX ! 412: out dx,ax ! 413: mov dx,# VBE_DISPI_IOPORT_DATA ! 414: in ax,dx ! 415: mov dx,ax ! 416: retf ! 417: dispi_set_bank_farcall_error: ! 418: mov ax,#0x014F ! 419: retf ! 420: ASM_END ! 421: } ! 422: ! 423: ASM_START ! 424: dispi_set_x_offset: ! 425: push dx ! 426: push ax ! 427: mov dx, # VBE_DISPI_IOPORT_INDEX ! 428: mov ax, # VBE_DISPI_INDEX_X_OFFSET ! 429: out dx, ax ! 430: pop ax ! 431: mov dx, # VBE_DISPI_IOPORT_DATA ! 432: out dx, ax ! 433: pop dx ! 434: ret ! 435: ! 436: dispi_get_x_offset: ! 437: push dx ! 438: mov dx, # VBE_DISPI_IOPORT_INDEX ! 439: mov ax, # VBE_DISPI_INDEX_X_OFFSET ! 440: out dx, ax ! 441: mov dx, # VBE_DISPI_IOPORT_DATA ! 442: in ax, dx ! 443: pop dx ! 444: ret ! 445: ! 446: dispi_set_y_offset: ! 447: push dx ! 448: push ax ! 449: mov dx, # VBE_DISPI_IOPORT_INDEX ! 450: mov ax, # VBE_DISPI_INDEX_Y_OFFSET ! 451: out dx, ax ! 452: pop ax ! 453: mov dx, # VBE_DISPI_IOPORT_DATA ! 454: out dx, ax ! 455: pop dx ! 456: ret ! 457: ! 458: dispi_get_y_offset: ! 459: push dx ! 460: mov dx, # VBE_DISPI_IOPORT_INDEX ! 461: mov ax, # VBE_DISPI_INDEX_Y_OFFSET ! 462: out dx, ax ! 463: mov dx, # VBE_DISPI_IOPORT_DATA ! 464: in ax, dx ! 465: pop dx ! 466: ret ! 467: ! 468: vga_set_virt_width: ! 469: push ax ! 470: push bx ! 471: push dx ! 472: mov bx, ax ! 473: call dispi_get_bpp ! 474: cmp al, #0x04 ! 475: ja set_width_svga ! 476: shr bx, #1 ! 477: set_width_svga: ! 478: shr bx, #3 ! 479: mov dx, # VGAREG_VGA_CRTC_ADDRESS ! 480: mov ah, bl ! 481: mov al, #0x13 ! 482: out dx, ax ! 483: pop dx ! 484: pop bx ! 485: pop ax ! 486: ret ! 487: ! 488: dispi_set_virt_width: ! 489: call vga_set_virt_width ! 490: push dx ! 491: push ax ! 492: mov dx, # VBE_DISPI_IOPORT_INDEX ! 493: mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH ! 494: out dx, ax ! 495: pop ax ! 496: mov dx, # VBE_DISPI_IOPORT_DATA ! 497: out dx, ax ! 498: pop dx ! 499: ret ! 500: ! 501: dispi_get_virt_width: ! 502: push dx ! 503: mov dx, # VBE_DISPI_IOPORT_INDEX ! 504: mov ax, # VBE_DISPI_INDEX_VIRT_WIDTH ! 505: out dx, ax ! 506: mov dx, # VBE_DISPI_IOPORT_DATA ! 507: in ax, dx ! 508: pop dx ! 509: ret ! 510: ! 511: dispi_get_virt_height: ! 512: push dx ! 513: mov dx, # VBE_DISPI_IOPORT_INDEX ! 514: mov ax, # VBE_DISPI_INDEX_VIRT_HEIGHT ! 515: out dx, ax ! 516: mov dx, # VBE_DISPI_IOPORT_DATA ! 517: in ax, dx ! 518: pop dx ! 519: ret ! 520: ! 521: _vga_compat_setup: ! 522: push ax ! 523: push dx ! 524: ! 525: ; set CRT X resolution ! 526: mov dx, # VBE_DISPI_IOPORT_INDEX ! 527: mov ax, # VBE_DISPI_INDEX_XRES ! 528: out dx, ax ! 529: mov dx, # VBE_DISPI_IOPORT_DATA ! 530: in ax, dx ! 531: push ax ! 532: mov dx, # VGAREG_VGA_CRTC_ADDRESS ! 533: mov ax, #0x0011 ! 534: out dx, ax ! 535: pop ax ! 536: push ax ! 537: shr ax, #3 ! 538: dec ax ! 539: mov ah, al ! 540: mov al, #0x01 ! 541: out dx, ax ! 542: pop ax ! 543: call vga_set_virt_width ! 544: ! 545: ; set CRT Y resolution ! 546: mov dx, # VBE_DISPI_IOPORT_INDEX ! 547: mov ax, # VBE_DISPI_INDEX_YRES ! 548: out dx, ax ! 549: mov dx, # VBE_DISPI_IOPORT_DATA ! 550: in ax, dx ! 551: dec ax ! 552: push ax ! 553: mov dx, # VGAREG_VGA_CRTC_ADDRESS ! 554: mov ah, al ! 555: mov al, #0x12 ! 556: out dx, ax ! 557: pop ax ! 558: mov al, #0x07 ! 559: out dx, al ! 560: inc dx ! 561: in al, dx ! 562: and al, #0xbd ! 563: test ah, #0x01 ! 564: jz bit8_clear ! 565: or al, #0x02 ! 566: bit8_clear: ! 567: test ah, #0x02 ! 568: jz bit9_clear ! 569: or al, #0x40 ! 570: bit9_clear: ! 571: out dx, al ! 572: ! 573: ; other settings ! 574: mov dx, # VGAREG_VGA_CRTC_ADDRESS ! 575: mov ax, #0x0009 ! 576: out dx, ax ! 577: mov al, #0x17 ! 578: out dx, al ! 579: mov dx, # VGAREG_VGA_CRTC_DATA ! 580: in al, dx ! 581: or al, #0x03 ! 582: out dx, al ! 583: mov dx, # VGAREG_ACTL_RESET ! 584: in al, dx ! 585: mov dx, # VGAREG_ACTL_ADDRESS ! 586: mov al, #0x10 ! 587: out dx, al ! 588: mov dx, # VGAREG_ACTL_READ_DATA ! 589: in al, dx ! 590: or al, #0x01 ! 591: mov dx, # VGAREG_ACTL_ADDRESS ! 592: out dx, al ! 593: mov al, #0x20 ! 594: out dx, al ! 595: mov dx, # VGAREG_GRDC_ADDRESS ! 596: mov ax, #0x0506 ! 597: out dx, ax ! 598: mov dx, # VGAREG_SEQU_ADDRESS ! 599: mov ax, #0x0f02 ! 600: out dx, ax ! 601: ! 602: ; settings for >= 8bpp ! 603: mov dx, # VBE_DISPI_IOPORT_INDEX ! 604: mov ax, # VBE_DISPI_INDEX_BPP ! 605: out dx, ax ! 606: mov dx, # VBE_DISPI_IOPORT_DATA ! 607: in ax, dx ! 608: cmp al, #0x08 ! 609: jb vga_compat_end ! 610: mov dx, # VGAREG_VGA_CRTC_ADDRESS ! 611: mov al, #0x14 ! 612: out dx, al ! 613: mov dx, # VGAREG_VGA_CRTC_DATA ! 614: in al, dx ! 615: or al, #0x40 ! 616: out dx, al ! 617: mov dx, # VGAREG_ACTL_RESET ! 618: in al, dx ! 619: mov dx, # VGAREG_ACTL_ADDRESS ! 620: mov al, #0x10 ! 621: out dx, al ! 622: mov dx, # VGAREG_ACTL_READ_DATA ! 623: in al, dx ! 624: or al, #0x40 ! 625: mov dx, # VGAREG_ACTL_ADDRESS ! 626: out dx, al ! 627: mov al, #0x20 ! 628: out dx, al ! 629: mov dx, # VGAREG_SEQU_ADDRESS ! 630: mov al, #0x04 ! 631: out dx, al ! 632: mov dx, # VGAREG_SEQU_DATA ! 633: in al, dx ! 634: or al, #0x08 ! 635: out dx, al ! 636: mov dx, # VGAREG_GRDC_ADDRESS ! 637: mov al, #0x05 ! 638: out dx, al ! 639: mov dx, # VGAREG_GRDC_DATA ! 640: in al, dx ! 641: and al, #0x9f ! 642: or al, #0x40 ! 643: out dx, al ! 644: ! 645: vga_compat_end: ! 646: pop dx ! 647: pop ax ! 648: ASM_END ! 649: ! 650: ! 651: // ModeInfo helper function ! 652: static ModeInfoListItem* mode_info_find_mode(mode, using_lfb) ! 653: Bit16u mode; Boolean using_lfb; ! 654: { ! 655: ModeInfoListItem *cur_info=&mode_info_list; ! 656: ! 657: while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST) ! 658: { ! 659: if (cur_info->mode == mode) ! 660: { ! 661: if (!using_lfb) ! 662: { ! 663: return cur_info; ! 664: } ! 665: else if (cur_info->info.ModeAttributes & VBE_MODE_ATTRIBUTE_LINEAR_FRAME_BUFFER_MODE) ! 666: { ! 667: return cur_info; ! 668: } ! 669: else ! 670: { ! 671: cur_info++; ! 672: } ! 673: } ! 674: else ! 675: { ! 676: cur_info++; ! 677: } ! 678: } ! 679: ! 680: return 0; ! 681: } ! 682: ! 683: ASM_START ! 684: ! 685: ; Has VBE display - Returns true if VBE display detected ! 686: ! 687: _vbe_has_vbe_display: ! 688: push ds ! 689: push bx ! 690: mov ax, # BIOSMEM_SEG ! 691: mov ds, ax ! 692: mov bx, # BIOSMEM_VBE_FLAG ! 693: mov al, [bx] ! 694: and al, #0x01 ! 695: xor ah, ah ! 696: pop bx ! 697: pop ds ! 698: ret ! 699: ! 700: ; VBE Init - Initialise the Vesa Bios Extension Code ! 701: ; This function does a sanity check on the host side display code interface. ! 702: ! 703: vbe_init: ! 704: mov ax, # VBE_DISPI_ID0 ! 705: call dispi_set_id ! 706: call dispi_get_id ! 707: cmp ax, # VBE_DISPI_ID0 ! 708: jne no_vbe_interface ! 709: push ds ! 710: push bx ! 711: mov ax, # BIOSMEM_SEG ! 712: mov ds, ax ! 713: mov bx, # BIOSMEM_VBE_FLAG ! 714: mov al, #0x01 ! 715: mov [bx], al ! 716: pop bx ! 717: pop ds ! 718: mov ax, # VBE_DISPI_ID4 ! 719: call dispi_set_id ! 720: no_vbe_interface: ! 721: #if defined(USE_BX_INFO) || defined(DEBUG) ! 722: mov bx, #msg_vbe_init ! 723: push bx ! 724: call _printf ! 725: inc sp ! 726: inc sp ! 727: #endif ! 728: ret ! 729: ! 730: ; VBE Display Info - Display information on screen about the VBE ! 731: ! 732: vbe_display_info: ! 733: call _vbe_has_vbe_display ! 734: test ax, ax ! 735: jz no_vbe_flag ! 736: mov ax, #0xc000 ! 737: mov ds, ax ! 738: mov si, #_vbebios_info_string ! 739: jmp _display_string ! 740: no_vbe_flag: ! 741: mov ax, #0xc000 ! 742: mov ds, ax ! 743: mov si, #_no_vbebios_info_string ! 744: jmp _display_string ! 745: ASM_END ! 746: ! 747: /** Function 00h - Return VBE Controller Information ! 748: * ! 749: * Input: ! 750: * AX = 4F00h ! 751: * ES:DI = Pointer to buffer in which to place VbeInfoBlock structure ! 752: * (VbeSignature should be VBE2 when VBE 2.0 information is desired and ! 753: * the info block is 512 bytes in size) ! 754: * Output: ! 755: * AX = VBE Return Status ! 756: * ! 757: */ ! 758: void vbe_biosfn_return_controller_information(AX, ES, DI) ! 759: Bit16u *AX;Bit16u ES;Bit16u DI; ! 760: { ! 761: Bit16u ss=get_SS(); ! 762: VbeInfoBlock vbe_info_block; ! 763: Bit16u status; ! 764: Bit16u result; ! 765: Bit16u vbe2_info; ! 766: Bit16u cur_mode=0; ! 767: Bit16u cur_ptr=34; ! 768: ModeInfoListItem *cur_info=&mode_info_list; ! 769: ! 770: status = read_word(ss, AX); ! 771: ! 772: #ifdef DEBUG ! 773: printf("VBE vbe_biosfn_return_vbe_info ES%x DI%x AX%x\n",ES,DI,status); ! 774: #endif ! 775: ! 776: vbe2_info = 0; ! 777: #ifdef VBE2_NO_VESA_CHECK ! 778: #else ! 779: // get vbe_info_block into local variable ! 780: memcpyb(ss, &vbe_info_block, ES, DI, sizeof(vbe_info_block)); ! 781: ! 782: // check for VBE2 signature ! 783: if (((vbe_info_block.VbeSignature[0] == 'V') && ! 784: (vbe_info_block.VbeSignature[1] == 'B') && ! 785: (vbe_info_block.VbeSignature[2] == 'E') && ! 786: (vbe_info_block.VbeSignature[3] == '2')) || ! 787: ! 788: ((vbe_info_block.VbeSignature[0] == 'V') && ! 789: (vbe_info_block.VbeSignature[1] == 'E') && ! 790: (vbe_info_block.VbeSignature[2] == 'S') && ! 791: (vbe_info_block.VbeSignature[3] == 'A')) ) ! 792: { ! 793: vbe2_info = 1; ! 794: #ifdef DEBUG ! 795: printf("VBE correct VESA/VBE2 signature found\n"); ! 796: #endif ! 797: } ! 798: #endif ! 799: ! 800: // VBE Signature ! 801: vbe_info_block.VbeSignature[0] = 'V'; ! 802: vbe_info_block.VbeSignature[1] = 'E'; ! 803: vbe_info_block.VbeSignature[2] = 'S'; ! 804: vbe_info_block.VbeSignature[3] = 'A'; ! 805: ! 806: // VBE Version supported ! 807: vbe_info_block.VbeVersion = 0x0200; ! 808: ! 809: // OEM String ! 810: vbe_info_block.OemStringPtr_Seg = 0xc000; ! 811: vbe_info_block.OemStringPtr_Off = &vbebios_copyright; ! 812: ! 813: // Capabilities ! 814: vbe_info_block.Capabilities[0] = VBE_CAPABILITY_8BIT_DAC; ! 815: vbe_info_block.Capabilities[1] = 0; ! 816: vbe_info_block.Capabilities[2] = 0; ! 817: vbe_info_block.Capabilities[3] = 0; ! 818: ! 819: // VBE Video Mode Pointer (dynamicly generated from the mode_info_list) ! 820: vbe_info_block.VideoModePtr_Seg= ES ; ! 821: vbe_info_block.VideoModePtr_Off= DI + 34; ! 822: ! 823: // VBE Total Memory (in 64b blocks) ! 824: vbe_info_block.TotalMemory = VBE_TOTAL_VIDEO_MEMORY_DIV_64K; ! 825: ! 826: if (vbe2_info) ! 827: { ! 828: // OEM Stuff ! 829: vbe_info_block.OemSoftwareRev = VBE_OEM_SOFTWARE_REV; ! 830: vbe_info_block.OemVendorNamePtr_Seg = 0xc000; ! 831: vbe_info_block.OemVendorNamePtr_Off = &vbebios_vendor_name; ! 832: vbe_info_block.OemProductNamePtr_Seg = 0xc000; ! 833: vbe_info_block.OemProductNamePtr_Off = &vbebios_product_name; ! 834: vbe_info_block.OemProductRevPtr_Seg = 0xc000; ! 835: vbe_info_block.OemProductRevPtr_Off = &vbebios_product_revision; ! 836: ! 837: // copy updates in vbe_info_block back ! 838: memcpyb(ES, DI, ss, &vbe_info_block, sizeof(vbe_info_block)); ! 839: } ! 840: else ! 841: { ! 842: // copy updates in vbe_info_block back (VBE 1.x compatibility) ! 843: memcpyb(ES, DI, ss, &vbe_info_block, 256); ! 844: } ! 845: ! 846: do ! 847: { ! 848: if ((cur_info->info.XResolution <= dispi_get_max_xres()) && ! 849: (cur_info->info.BitsPerPixel <= dispi_get_max_bpp())) { ! 850: #ifdef DEBUG ! 851: printf("VBE found mode %x => %x\n", cur_info->mode,cur_mode); ! 852: #endif ! 853: write_word(ES, DI + cur_ptr, cur_info->mode); ! 854: cur_mode++; ! 855: cur_ptr+=2; ! 856: } else { ! 857: #ifdef DEBUG ! 858: printf("VBE mode %x (xres=%x / bpp=%02x) not supported by display\n", cur_info->mode,cur_info->info.XResolution,cur_info->info.BitsPerPixel); ! 859: #endif ! 860: } ! 861: cur_info++; ! 862: } while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST); ! 863: ! 864: // Add vesa mode list terminator ! 865: write_word(ES, DI + cur_ptr, cur_info->mode); ! 866: ! 867: result = 0x4f; ! 868: ! 869: write_word(ss, AX, result); ! 870: } ! 871: ! 872: ! 873: /** Function 01h - Return VBE Mode Information ! 874: * ! 875: * Input: ! 876: * AX = 4F01h ! 877: * CX = Mode Number ! 878: * ES:DI = Pointer to buffer in which to place ModeInfoBlock structure ! 879: * Output: ! 880: * AX = VBE Return Status ! 881: * ! 882: */ ! 883: void vbe_biosfn_return_mode_information(AX, CX, ES, DI) ! 884: Bit16u *AX;Bit16u CX; Bit16u ES;Bit16u DI; ! 885: { ! 886: Bit16u result=0x0100; ! 887: Bit16u ss=get_SS(); ! 888: ModeInfoBlock info; ! 889: ModeInfoListItem *cur_info; ! 890: Boolean using_lfb; ! 891: ! 892: #ifdef DEBUG ! 893: printf("VBE vbe_biosfn_return_mode_information ES%x DI%x CX%x\n",ES,DI,CX); ! 894: #endif ! 895: ! 896: using_lfb=((CX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER); ! 897: ! 898: CX = (CX & 0x1ff); ! 899: ! 900: cur_info = mode_info_find_mode(CX, using_lfb, &cur_info); ! 901: ! 902: if (cur_info != 0) ! 903: { ! 904: #ifdef DEBUG ! 905: printf("VBE found mode %x\n",CX); ! 906: #endif ! 907: memsetb(ss, &info, 0, sizeof(ModeInfoBlock)); ! 908: memcpyb(ss, &info, 0xc000, &(cur_info->info), sizeof(ModeInfoBlockCompact)); ! 909: if (using_lfb) { ! 910: info.NumberOfBanks = 1; ! 911: } ! 912: if (info.WinAAttributes & VBE_WINDOW_ATTRIBUTE_RELOCATABLE) { ! 913: info.WinFuncPtr = 0xC0000000UL; ! 914: *(Bit16u *)&(info.WinFuncPtr) = (Bit16u)(dispi_set_bank_farcall); ! 915: } ! 916: ! 917: result = 0x4f; ! 918: } ! 919: else ! 920: { ! 921: #ifdef DEBUG ! 922: printf("VBE *NOT* found mode %x\n",CX); ! 923: #endif ! 924: result = 0x100; ! 925: } ! 926: ! 927: if (result == 0x4f) ! 928: { ! 929: // copy updates in mode_info_block back ! 930: memcpyb(ES, DI, ss, &info, sizeof(info)); ! 931: } ! 932: ! 933: write_word(ss, AX, result); ! 934: } ! 935: ! 936: /** Function 02h - Set VBE Mode ! 937: * ! 938: * Input: ! 939: * AX = 4F02h ! 940: * BX = Desired Mode to set ! 941: * ES:DI = Pointer to CRTCInfoBlock structure ! 942: * Output: ! 943: * AX = VBE Return Status ! 944: * ! 945: */ ! 946: void vbe_biosfn_set_mode(AX, BX, ES, DI) ! 947: Bit16u *AX;Bit16u BX; Bit16u ES;Bit16u DI; ! 948: { ! 949: Bit16u ss = get_SS(); ! 950: Bit16u result; ! 951: ModeInfoListItem *cur_info; ! 952: Boolean using_lfb; ! 953: Bit8u no_clear; ! 954: Bit8u lfb_flag; ! 955: ! 956: using_lfb=((BX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER); ! 957: lfb_flag=using_lfb?VBE_DISPI_LFB_ENABLED:0; ! 958: no_clear=((BX & VBE_MODE_PRESERVE_DISPLAY_MEMORY) == VBE_MODE_PRESERVE_DISPLAY_MEMORY)?VBE_DISPI_NOCLEARMEM:0; ! 959: ! 960: BX = (BX & 0x1ff); ! 961: ! 962: //result=read_word(ss,AX); ! 963: ! 964: // check for non vesa mode ! 965: if (BX<VBE_MODE_VESA_DEFINED) ! 966: { ! 967: Bit8u mode; ! 968: ! 969: dispi_set_enable(VBE_DISPI_DISABLED); ! 970: // call the vgabios in order to set the video mode ! 971: // this allows for going back to textmode with a VBE call (some applications expect that to work) ! 972: ! 973: mode=(BX & 0xff); ! 974: biosfn_set_video_mode(mode); ! 975: result = 0x4f; ! 976: } ! 977: ! 978: cur_info = mode_info_find_mode(BX, using_lfb, &cur_info); ! 979: ! 980: if (cur_info != 0) ! 981: { ! 982: #ifdef DEBUG ! 983: printf("VBE found mode %x, setting:\n", BX); ! 984: printf("\txres%x yres%x bpp%x\n", ! 985: cur_info->info.XResolution, ! 986: cur_info->info.YResolution, ! 987: cur_info->info.BitsPerPixel); ! 988: #endif ! 989: ! 990: // first disable current mode (when switching between vesa modi) ! 991: dispi_set_enable(VBE_DISPI_DISABLED); ! 992: ! 993: if (cur_info->info.BitsPerPixel == 4) ! 994: { ! 995: biosfn_set_video_mode(0x6a); ! 996: } ! 997: ! 998: dispi_set_bpp(cur_info->info.BitsPerPixel); ! 999: dispi_set_xres(cur_info->info.XResolution); ! 1000: dispi_set_yres(cur_info->info.YResolution); ! 1001: dispi_set_bank(0); ! 1002: dispi_set_enable(VBE_DISPI_ENABLED | no_clear | lfb_flag); ! 1003: vga_compat_setup(); ! 1004: ! 1005: write_word(BIOSMEM_SEG,BIOSMEM_VBE_MODE,BX); ! 1006: write_byte(BIOSMEM_SEG,BIOSMEM_VIDEO_CTL,(0x60 | no_clear)); ! 1007: ! 1008: result = 0x4f; ! 1009: } ! 1010: else ! 1011: { ! 1012: #ifdef DEBUG ! 1013: printf("VBE *NOT* found mode %x\n" , BX); ! 1014: #endif ! 1015: result = 0x100; ! 1016: ! 1017: // FIXME: redirect non VBE modi to normal VGA bios operation ! 1018: // (switch back to VGA mode ! 1019: if (BX == 3) ! 1020: result = 0x4f; ! 1021: } ! 1022: ! 1023: write_word(ss, AX, result); ! 1024: } ! 1025: ! 1026: /** Function 03h - Return Current VBE Mode ! 1027: * ! 1028: * Input: ! 1029: * AX = 4F03h ! 1030: * Output: ! 1031: * AX = VBE Return Status ! 1032: * BX = Current VBE Mode ! 1033: * ! 1034: */ ! 1035: ASM_START ! 1036: vbe_biosfn_return_current_mode: ! 1037: push ds ! 1038: mov ax, # BIOSMEM_SEG ! 1039: mov ds, ax ! 1040: call dispi_get_enable ! 1041: and ax, # VBE_DISPI_ENABLED ! 1042: jz no_vbe_mode ! 1043: mov bx, # BIOSMEM_VBE_MODE ! 1044: mov ax, [bx] ! 1045: mov bx, ax ! 1046: jnz vbe_03_ok ! 1047: no_vbe_mode: ! 1048: mov bx, # BIOSMEM_CURRENT_MODE ! 1049: mov al, [bx] ! 1050: mov bl, al ! 1051: xor bh, bh ! 1052: vbe_03_ok: ! 1053: mov ax, #0x004f ! 1054: pop ds ! 1055: ret ! 1056: ASM_END ! 1057: ! 1058: ! 1059: Bit16u vbe_biosfn_read_video_state_size() ! 1060: { ! 1061: return 9 * 2; ! 1062: } ! 1063: ! 1064: void vbe_biosfn_save_video_state(ES, BX) ! 1065: Bit16u ES; Bit16u BX; ! 1066: { ! 1067: Bit16u enable, i; ! 1068: ! 1069: outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE); ! 1070: enable = inw(VBE_DISPI_IOPORT_DATA); ! 1071: write_word(ES, BX, enable); ! 1072: BX += 2; ! 1073: if (!(enable & VBE_DISPI_ENABLED)) ! 1074: return; ! 1075: for(i = VBE_DISPI_INDEX_XRES; i <= VBE_DISPI_INDEX_Y_OFFSET; i++) { ! 1076: if (i != VBE_DISPI_INDEX_ENABLE) { ! 1077: outw(VBE_DISPI_IOPORT_INDEX, i); ! 1078: write_word(ES, BX, inw(VBE_DISPI_IOPORT_DATA)); ! 1079: BX += 2; ! 1080: } ! 1081: } ! 1082: } ! 1083: ! 1084: ! 1085: void vbe_biosfn_restore_video_state(ES, BX) ! 1086: Bit16u ES; Bit16u BX; ! 1087: { ! 1088: Bit16u enable, i; ! 1089: ! 1090: enable = read_word(ES, BX); ! 1091: BX += 2; ! 1092: ! 1093: if (!(enable & VBE_DISPI_ENABLED)) { ! 1094: outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE); ! 1095: outw(VBE_DISPI_IOPORT_DATA, enable); ! 1096: } else { ! 1097: outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_XRES); ! 1098: outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX)); ! 1099: BX += 2; ! 1100: outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_YRES); ! 1101: outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX)); ! 1102: BX += 2; ! 1103: outw(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_BPP); ! 1104: outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX)); ! 1105: BX += 2; ! 1106: outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE); ! 1107: outw(VBE_DISPI_IOPORT_DATA, enable); ! 1108: ! 1109: for(i = VBE_DISPI_INDEX_BANK; i <= VBE_DISPI_INDEX_Y_OFFSET; i++) { ! 1110: outw(VBE_DISPI_IOPORT_INDEX, i); ! 1111: outw(VBE_DISPI_IOPORT_DATA, read_word(ES, BX)); ! 1112: BX += 2; ! 1113: } ! 1114: } ! 1115: } ! 1116: ! 1117: /** Function 04h - Save/Restore State ! 1118: * ! 1119: * Input: ! 1120: * AX = 4F04h ! 1121: * DL = 00h Return Save/Restore State buffer size ! 1122: * 01h Save State ! 1123: * 02h Restore State ! 1124: * CX = Requested states ! 1125: * ES:BX = Pointer to buffer (if DL <> 00h) ! 1126: * Output: ! 1127: * AX = VBE Return Status ! 1128: * BX = Number of 64-byte blocks to hold the state buffer (if DL=00h) ! 1129: * ! 1130: */ ! 1131: void vbe_biosfn_save_restore_state(AX, CX, DX, ES, BX) ! 1132: Bit16u *AX; Bit16u CX; Bit16u DX; Bit16u ES; Bit16u *BX; ! 1133: { ! 1134: Bit16u ss=get_SS(); ! 1135: Bit16u result, val; ! 1136: ! 1137: result = 0x4f; ! 1138: switch(GET_DL()) { ! 1139: case 0x00: ! 1140: val = biosfn_read_video_state_size2(CX); ! 1141: #ifdef DEBUG ! 1142: printf("VGA state size=%x\n", val); ! 1143: #endif ! 1144: if (CX & 8) ! 1145: val += vbe_biosfn_read_video_state_size(); ! 1146: write_word(ss, BX, val); ! 1147: break; ! 1148: case 0x01: ! 1149: val = read_word(ss, BX); ! 1150: val = biosfn_save_video_state(CX, ES, val); ! 1151: #ifdef DEBUG ! 1152: printf("VGA save_state offset=%x\n", val); ! 1153: #endif ! 1154: if (CX & 8) ! 1155: vbe_biosfn_save_video_state(ES, val); ! 1156: break; ! 1157: case 0x02: ! 1158: val = read_word(ss, BX); ! 1159: val = biosfn_restore_video_state(CX, ES, val); ! 1160: #ifdef DEBUG ! 1161: printf("VGA restore_state offset=%x\n", val); ! 1162: #endif ! 1163: if (CX & 8) ! 1164: vbe_biosfn_restore_video_state(ES, val); ! 1165: break; ! 1166: default: ! 1167: // function failed ! 1168: result = 0x100; ! 1169: break; ! 1170: } ! 1171: write_word(ss, AX, result); ! 1172: } ! 1173: ! 1174: /** Function 05h - Display Window Control ! 1175: * ! 1176: * Input: ! 1177: * AX = 4F05h ! 1178: * (16-bit) BH = 00h Set memory window ! 1179: * = 01h Get memory window ! 1180: * BL = Window number ! 1181: * = 00h Window A ! 1182: * = 01h Window B ! 1183: * DX = Window number in video memory in window ! 1184: * granularity units (Set Memory Window only) ! 1185: * Note: ! 1186: * If this function is called while in a linear frame buffer mode, ! 1187: * this function must fail with completion code AH=03h ! 1188: * ! 1189: * Output: ! 1190: * AX = VBE Return Status ! 1191: * DX = Window number in window granularity units ! 1192: * (Get Memory Window only) ! 1193: */ ! 1194: ASM_START ! 1195: vbe_biosfn_display_window_control: ! 1196: cmp bl, #0x00 ! 1197: jne vbe_05_failed ! 1198: cmp bh, #0x01 ! 1199: je get_display_window ! 1200: jb set_display_window ! 1201: mov ax, #0x0100 ! 1202: ret ! 1203: set_display_window: ! 1204: mov ax, dx ! 1205: call _dispi_set_bank ! 1206: call dispi_get_bank ! 1207: cmp ax, dx ! 1208: jne vbe_05_failed ! 1209: mov ax, #0x004f ! 1210: ret ! 1211: get_display_window: ! 1212: call dispi_get_bank ! 1213: mov dx, ax ! 1214: mov ax, #0x004f ! 1215: ret ! 1216: vbe_05_failed: ! 1217: mov ax, #0x014f ! 1218: ret ! 1219: ASM_END ! 1220: ! 1221: ! 1222: /** Function 06h - Set/Get Logical Scan Line Length ! 1223: * ! 1224: * Input: ! 1225: * AX = 4F06h ! 1226: * BL = 00h Set Scan Line Length in Pixels ! 1227: * = 01h Get Scan Line Length ! 1228: * = 02h Set Scan Line Length in Bytes ! 1229: * = 03h Get Maximum Scan Line Length ! 1230: * CX = If BL=00h Desired Width in Pixels ! 1231: * If BL=02h Desired Width in Bytes ! 1232: * (Ignored for Get Functions) ! 1233: * ! 1234: * Output: ! 1235: * AX = VBE Return Status ! 1236: * BX = Bytes Per Scan Line ! 1237: * CX = Actual Pixels Per Scan Line ! 1238: * (truncated to nearest complete pixel) ! 1239: * DX = Maximum Number of Scan Lines ! 1240: */ ! 1241: ASM_START ! 1242: vbe_biosfn_set_get_logical_scan_line_length: ! 1243: mov ax, cx ! 1244: cmp bl, #0x01 ! 1245: je get_logical_scan_line_length ! 1246: cmp bl, #0x02 ! 1247: je set_logical_scan_line_bytes ! 1248: jb set_logical_scan_line_pixels ! 1249: mov ax, #0x0100 ! 1250: ret ! 1251: set_logical_scan_line_bytes: ! 1252: push ax ! 1253: call dispi_get_bpp ! 1254: xor bh, bh ! 1255: mov bl, ah ! 1256: or bl, bl ! 1257: jnz no_4bpp_1 ! 1258: shl ax, #3 ! 1259: mov bl, #1 ! 1260: no_4bpp_1: ! 1261: xor dx, dx ! 1262: pop ax ! 1263: div bx ! 1264: set_logical_scan_line_pixels: ! 1265: call dispi_set_virt_width ! 1266: get_logical_scan_line_length: ! 1267: call dispi_get_bpp ! 1268: xor bh, bh ! 1269: mov bl, ah ! 1270: call dispi_get_virt_width ! 1271: mov cx, ax ! 1272: or bl, bl ! 1273: jnz no_4bpp_2 ! 1274: shr ax, #3 ! 1275: mov bl, #1 ! 1276: no_4bpp_2: ! 1277: mul bx ! 1278: mov bx, ax ! 1279: call dispi_get_virt_height ! 1280: mov dx, ax ! 1281: mov ax, #0x004f ! 1282: ret ! 1283: ASM_END ! 1284: ! 1285: ! 1286: /** Function 07h - Set/Get Display Start ! 1287: * ! 1288: * Input(16-bit): ! 1289: * AX = 4F07h ! 1290: * BH = 00h Reserved and must be 00h ! 1291: * BL = 00h Set Display Start ! 1292: * = 01h Get Display Start ! 1293: * = 02h Schedule Display Start (Alternate) ! 1294: * = 03h Schedule Stereoscopic Display Start ! 1295: * = 04h Get Scheduled Display Start Status ! 1296: * = 05h Enable Stereoscopic Mode ! 1297: * = 06h Disable Stereoscopic Mode ! 1298: * = 80h Set Display Start during Vertical Retrace ! 1299: * = 82h Set Display Start during Vertical Retrace (Alternate) ! 1300: * = 83h Set Stereoscopic Display Start during Vertical Retrace ! 1301: * ECX = If BL=02h/82h Display Start Address in bytes ! 1302: * If BL=03h/83h Left Image Start Address in bytes ! 1303: * EDX = If BL=03h/83h Right Image Start Address in bytes ! 1304: * CX = If BL=00h/80h First Displayed Pixel In Scan Line ! 1305: * DX = If BL=00h/80h First Displayed Scan Line ! 1306: * ! 1307: * Output: ! 1308: * AX = VBE Return Status ! 1309: * BH = If BL=01h Reserved and will be 0 ! 1310: * CX = If BL=01h First Displayed Pixel In Scan Line ! 1311: * If BL=04h 0 if flip has not occurred, not 0 if it has ! 1312: * DX = If BL=01h First Displayed Scan Line ! 1313: * ! 1314: * Input(32-bit): ! 1315: * BH = 00h Reserved and must be 00h ! 1316: * BL = 00h Set Display Start ! 1317: * = 80h Set Display Start during Vertical Retrace ! 1318: * CX = Bits 0-15 of display start address ! 1319: * DX = Bits 16-31 of display start address ! 1320: * ES = Selector for memory mapped registers ! 1321: */ ! 1322: ASM_START ! 1323: vbe_biosfn_set_get_display_start: ! 1324: cmp bl, #0x80 ! 1325: je set_display_start ! 1326: cmp bl, #0x01 ! 1327: je get_display_start ! 1328: jb set_display_start ! 1329: mov ax, #0x0100 ! 1330: ret ! 1331: set_display_start: ! 1332: mov ax, cx ! 1333: call dispi_set_x_offset ! 1334: mov ax, dx ! 1335: call dispi_set_y_offset ! 1336: mov ax, #0x004f ! 1337: ret ! 1338: get_display_start: ! 1339: call dispi_get_x_offset ! 1340: mov cx, ax ! 1341: call dispi_get_y_offset ! 1342: mov dx, ax ! 1343: xor bh, bh ! 1344: mov ax, #0x004f ! 1345: ret ! 1346: ASM_END ! 1347: ! 1348: ! 1349: /** Function 08h - Set/Get Dac Palette Format ! 1350: * ! 1351: * Input: ! 1352: * AX = 4F08h ! 1353: * BL = 00h set DAC palette width ! 1354: * = 01h get DAC palette width ! 1355: * BH = If BL=00h: desired number of bits per primary color ! 1356: * Output: ! 1357: * AX = VBE Return Status ! 1358: * BH = current number of bits per primary color (06h = standard VGA) ! 1359: */ ! 1360: ASM_START ! 1361: vbe_biosfn_set_get_dac_palette_format: ! 1362: cmp bl, #0x01 ! 1363: je get_dac_palette_format ! 1364: jb set_dac_palette_format ! 1365: mov ax, #0x0100 ! 1366: ret ! 1367: set_dac_palette_format: ! 1368: call dispi_get_enable ! 1369: cmp bh, #0x06 ! 1370: je set_normal_dac ! 1371: cmp bh, #0x08 ! 1372: jne vbe_08_unsupported ! 1373: or ax, # VBE_DISPI_8BIT_DAC ! 1374: jnz set_dac_mode ! 1375: set_normal_dac: ! 1376: and ax, #~ VBE_DISPI_8BIT_DAC ! 1377: set_dac_mode: ! 1378: call _dispi_set_enable ! 1379: get_dac_palette_format: ! 1380: mov bh, #0x06 ! 1381: call dispi_get_enable ! 1382: and ax, # VBE_DISPI_8BIT_DAC ! 1383: jz vbe_08_ok ! 1384: mov bh, #0x08 ! 1385: vbe_08_ok: ! 1386: mov ax, #0x004f ! 1387: ret ! 1388: vbe_08_unsupported: ! 1389: mov ax, #0x014f ! 1390: ret ! 1391: ASM_END ! 1392: ! 1393: ! 1394: /** Function 09h - Set/Get Palette Data ! 1395: * ! 1396: * Input: ! 1397: * AX = 4F09h ! 1398: * Output: ! 1399: * AX = VBE Return Status ! 1400: * ! 1401: * FIXME: incomplete API description, Input & Output ! 1402: */ ! 1403: void vbe_biosfn_set_get_palette_data(AX) ! 1404: { ! 1405: } ! 1406: ! 1407: /** Function 0Ah - Return VBE Protected Mode Interface ! 1408: * Input: AX = 4F0Ah VBE 2.0 Protected Mode Interface ! 1409: * BL = 00h Return protected mode table ! 1410: * ! 1411: * ! 1412: * Output: AX = Status ! 1413: * ES = Real Mode Segment of Table ! 1414: * DI = Offset of Table ! 1415: * CX = Length of Table including protected mode code ! 1416: * (for copying purposes) ! 1417: */ ! 1418: ASM_START ! 1419: vbe_biosfn_return_protected_mode_interface: ! 1420: test bl, bl ! 1421: jnz _fail ! 1422: mov di, #0xc000 ! 1423: mov es, di ! 1424: mov di, # vesa_pm_start ! 1425: mov cx, # vesa_pm_end ! 1426: sub cx, di ! 1427: mov ax, #0x004f ! 1428: ret ! 1429: _fail: ! 1430: mov ax, #0x014f ! 1431: ret ! 1432: ASM_END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.