vbe.c

   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 // enable LFB support (depends upon bochs-vbe-lfb patch)
  34 #define VBE_HAVE_LFB
  35
  36 // disable VESA/VBE2 check in vbe info
  37 //#define VBE2_NO_VESA_CHECK
  38
  39 // dynamicly generate a mode_info list
  40 //#define DYN_LIST
  41
  42 // enable unsupported modi in the mode_info list (ie >8bpp)
  43 //#define LIST_UNSUPPORTED_MODI
  44
  45
  46 #include "vbe.h"
  47 #include "vbetables.h"
  48
  49
  50 // The current OEM Software Revision of this VBE Bios
  51 #define VBE_OEM_SOFTWARE_REV 0x0002;
  52
  53 #define VBEInfoData ((VbeInfoBlock *) 0)
  54
  55 extern char vbebios_copyright;
  56 extern char vbebios_vendor_name;
  57 extern char vbebios_product_name;
  58 extern char vbebios_product_revision;
  59
  60 // FIXME: find out why we cannot use the dynamic list generation (due to a bug somewhere)
  61 //#define DYN_LIST
  62
  63 #ifndef DYN_LIST
  64 extern Bit16u vbebios_mode_list;
  65 #endif
  66
  67 ASM_START
  68 // FIXME: 'merge' these (c) etc strings with the vgabios.c strings?
  69 _vbebios_copyright:
  70 .ascii       "Bochs/Plex86 VBE(C) 2002 Jeroen Janssen <japj@darius.demon.nl>"
  71 .byte        0x00
  72
  73 _vbebios_vendor_name:
  74 .ascii       "Bochs/Plex86 Developers"
  75 .byte        0x00
  76
  77 _vbebios_product_name:
  78 .ascii       "Bochs/Plex86 VBE Adapter"
  79 .byte        0x00
  80
  81 _vbebios_product_revision:
  82 .ascii       "$Id$"
  83 .byte        0x00
  84
  85 _vbebios_info_string:
  86 .ascii      "Bochs VBE Display Adapter enabled"
  87 .byte   0x0a,0x0d
  88 .byte   0x0a,0x0d
  89 .byte   0x00
  90
  91 _no_vbebios_info_string:
  92 .ascii      "NO Bochs VBE Support available!"
  93 .byte   0x0a,0x0d
  94 .byte   0x0a,0x0d
  95 .byte 0x00
  96
  97
  98 #ifndef DYN_LIST
  99 // FIXME: for each new mode add a statement here
 100 //        at least until dynamic list creation is working
 101 _vbebios_mode_list:
 102
 103 #ifdef LIST_UNSUPPORTED_MODI
 104 .word VBE_VESA_MODE_640X480X565
 105 .word VBE_VESA_MODE_800X600X565
 106 .word VBE_VESA_MODE_640X480X888
 107 .word VBE_VESA_MODE_800X600X888
 108 .word VBE_OWN_MODE_800X600X8888
 109 .word VBE_OWN_MODE_1024X768X8888
 110 #endif
 111
 112 .word VBE_VESA_MODE_640X400X8
 113 .word VBE_VESA_MODE_640X480X8
 114 .word VBE_VESA_MODE_800X600X4
 115 .word VBE_VESA_MODE_800X600X8
 116 .word VBE_VESA_MODE_1024X768X8
 117 .word VBE_OWN_MODE_320X200X8
 118 .word VBE_VESA_MODE_END_OF_LIST
 119 #endif
 120
 121 ASM_END
 122
 123 // from rombios.c
 124 #define PANIC_PORT 0x501
 125
 126 ASM_START
 127 MACRO HALT
 128   ;; the HALT macro is called with the line number of the HALT call.
 129   ;; The line number is then sent to the PANIC_PORT, causing Bochs to
 130   ;; print a BX_PANIC message.  This will normally halt the simulation
 131   ;; with a message such as "BIOS panic at rombios.c, line 4091".
 132   ;; However, users can choose to make panics non-fatal and continue.
 133   mov dx,#PANIC_PORT
 134   mov ax,#?1
 135   out dx,ax
 136 MEND
 137 ASM_END
 138
 139 // DISPI ioport functions
 140 // FIXME: what if no VBE host side code?
 141 static Bit16u dispi_get_id()
 142 {
 143   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ID);
 144   return inw(VBE_DISPI_IOPORT_DATA);
 145 }
 146
 147 static void dispi_set_id(id)
 148   Bit16u id;
 149 {
 150   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ID);
 151   outw(VBE_DISPI_IOPORT_DATA,id);
 152 }
 153
 154 static void dispi_set_xres(xres)
 155   Bit16u xres;
 156 {
 157   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_XRES);
 158   outw(VBE_DISPI_IOPORT_DATA,xres);
 159 }
 160
 161 static void dispi_set_yres(yres)
 162   Bit16u yres;
 163 {
 164   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_YRES);
 165   outw(VBE_DISPI_IOPORT_DATA,yres);
 166 }
 167
 168 static void dispi_set_bpp(bpp)
 169   Bit16u bpp;
 170 {
 171   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_BPP);
 172   outw(VBE_DISPI_IOPORT_DATA,bpp);
 173 }
 174
 175 static Bit16u dispi_get_enable()
 176 {
 177   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE);
 178   return inw(VBE_DISPI_IOPORT_DATA);
 179 }
 180
 181 void dispi_set_enable(enable)
 182   Bit16u enable;
 183 {
 184   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ENABLE);
 185   outw(VBE_DISPI_IOPORT_DATA,enable);
 186 }
 187
 188 static void dispi_set_bank(bank)
 189   Bit16u bank;
 190 {
 191   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_BANK);
 192   outw(VBE_DISPI_IOPORT_DATA,bank);
 193 }
 194
 195 static void dispi_set_bank_farcall()
 196 {
 197 ASM_START
 198   cmp bx,#0x0100
 199   je dispi_set_bank_farcall_get
 200   or bx,bx
 201   jnz dispi_set_bank_farcall_error
 202   push dx
 203   mov ax,# VBE_DISPI_INDEX_BANK
 204   mov dx,# VBE_DISPI_IOPORT_INDEX
 205   out dx,ax
 206   pop ax
 207   mov dx,# VBE_DISPI_IOPORT_DATA
 208   out dx,ax
 209   retf
 210 dispi_set_bank_farcall_get:
 211   mov ax,# VBE_DISPI_INDEX_BANK
 212   mov dx,# VBE_DISPI_IOPORT_INDEX
 213   out dx,ax
 214   mov dx,# VBE_DISPI_IOPORT_DATA
 215   in ax,dx
 216   mov dx,ax
 217   retf
 218 dispi_set_bank_farcall_error:
 219   mov ax,#0x014F
 220   retf
 221 ASM_END
 222 }
 223
 224 static void dispi_set_x_offset(offset)
 225   Bit16u offset;
 226 {
 227   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_X_OFFSET);
 228   outw(VBE_DISPI_IOPORT_DATA,offset);
 229 }
 230
 231 static Bit16u dispi_get_x_offset()
 232 {
 233   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_X_OFFSET);
 234   return inw(VBE_DISPI_IOPORT_DATA);
 235 }
 236
 237 static void dispi_set_y_offset(offset)
 238   Bit16u offset;
 239 {
 240   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_Y_OFFSET);
 241   outw(VBE_DISPI_IOPORT_DATA,offset);
 242 }
 243
 244 static Bit16u dispi_get_y_offset()
 245 {
 246   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_Y_OFFSET);
 247   return inw(VBE_DISPI_IOPORT_DATA);
 248 }
 249
 250 static void dispi_set_virt_width(width)
 251   Bit16u width;
 252 {
 253   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_VIRT_WIDTH);
 254   outw(VBE_DISPI_IOPORT_DATA,width);
 255 }
 256
 257 static Bit16u dispi_get_virt_width()
 258 {
 259   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_VIRT_WIDTH);
 260   return inw(VBE_DISPI_IOPORT_DATA);
 261 }
 262 /*
 263 static void dispi_set_virt_height(height)
 264   Bit16u height;
 265 {
 266   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_VIRT_HEIGHT);
 267   outw(VBE_DISPI_IOPORT_DATA,height);
 268 }
 269 */
 270 static Bit16u dispi_get_virt_height()
 271 {
 272   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_VIRT_HEIGHT);
 273   return inw(VBE_DISPI_IOPORT_DATA);
 274 }
 275
 276
 277 // ModeInfo helper function
 278 static ModeInfoListItem* mode_info_find_mode(mode, using_lfb)
 279   Bit16u mode; Boolean using_lfb;
 280 {
 281   ModeInfoListItem  *cur_info=&mode_info_list;
 282
 283   while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST)
 284   {
 285     if (cur_info->mode == mode)
 286     {
 287       if (!using_lfb)
 288       {
 289         return cur_info;
 290       }
 291       else if (cur_info->info.ModeAttributes & VBE_MODE_ATTRIBUTE_LINEAR_FRAME_BUFFER_MODE)
 292       {
 293         return cur_info;
 294       }
 295       else
 296       {
 297         cur_info++;
 298       }
 299     }
 300     else
 301     {
 302       cur_info++;
 303     }
 304   }
 305
 306   return 0;
 307 }
 308
 309 /** Has VBE display - Returns true if VBE display detected
 310  *
 311  */
 312 Boolean vbe_has_vbe_display()
 313 {
 314   dispi_set_id(VBE_DISPI_ID1);
 315
 316   return (dispi_get_id()==VBE_DISPI_ID1);
 317 }
 318
 319 /** VBE Init - Initialise the Vesa Bios Extension Code
 320  *
 321  *  This function does a sanity check on the host side display code interface.
 322  */
 323 void vbe_init()
 324 {
 325   Bit16u dispi_id;
 326
 327   outw(VBE_DISPI_IOPORT_INDEX,VBE_DISPI_INDEX_ID);
 328   outw(VBE_DISPI_IOPORT_DATA,VBE_DISPI_ID0);
 329
 330   dispi_id=inw(VBE_DISPI_IOPORT_DATA);
 331
 332   if (dispi_id!=VBE_DISPI_ID0)
 333   {
 334 //FIXME this results in a 'rombios.c' line panic, but it's actually a 'vbe.c' panic
 335 ASM_START
 336     HALT(__LINE__)
 337 ASM_END
 338   }
 339 //#ifdef DEBUG
 340   printf("VBE Bios $Id$\n");
 341 //#endif
 342 }
 343
 344 /** VBE Display Info - Display information on screen about the VBE
 345  */
 346 void vbe_display_info()
 347 {
 348   // Check for VBE display extension in Bochs
 349   if (vbe_has_vbe_display())
 350   {
 351     ASM_START
 352      mov ax,#0xc000
 353      mov ds,ax
 354      mov si,#_vbebios_info_string
 355      call _display_string
 356     ASM_END
 357   }
 358   else
 359   {
 360     ASM_START
 361      mov ax,#0xc000
 362      mov ds,ax
 363      mov si,#_no_vbebios_info_string
 364      call _display_string
 365     ASM_END
 366
 367   }
 368 }
 369
 370 /** Function 00h - Return VBE Controller Information
 371  *
 372  * Input:
 373  *              AX      = 4F00h
 374  *              ES:DI   = Pointer to buffer in which to place VbeInfoBlock structure
 375  *                        (VbeSignature should be VBE2 when VBE 2.0 information is desired and
 376  *                        the info block is 512 bytes in size)
 377  * Output:
 378  *              AX      = VBE Return Status
 379  *
 380  */
 381 void vbe_biosfn_return_controller_information(AX, ES, DI)
 382 Bit16u *AX;Bit16u ES;Bit16u DI;
 383 {
 384         Bit16u            ss=get_SS();
 385         VbeInfoBlock      vbe_info_block;
 386         Bit16u            status;
 387         Bit16u            result;
 388         Bit16u            vbe2_info;
 389 #ifdef DYN_LIST
 390         Bit16u            *video_mode_list;
 391 #endif
 392         Bit16u            cur_mode=0;
 393         ModeInfoListItem  *cur_info=&mode_info_list;
 394
 395         status = read_word(ss, AX);
 396
 397 #ifdef DEBUG
 398         printf("VBE vbe_biosfn_return_vbe_info ES%x DI%x AX%x\n",ES,DI,status);
 399 #endif
 400
 401         vbe2_info = 0;
 402 #ifdef VBE2_NO_VESA_CHECK
 403 #else
 404         // get vbe_info_block into local variable
 405         memcpyb(ss, &vbe_info_block, ES, DI, sizeof(vbe_info_block));
 406
 407         // check for VBE2 signature
 408         if (((vbe_info_block.VbeSignature[0] == 'V') &&
 409              (vbe_info_block.VbeSignature[1] == 'B') &&
 410              (vbe_info_block.VbeSignature[2] == 'E') &&
 411              (vbe_info_block.VbeSignature[3] == '2')) ||
 412
 413             ((vbe_info_block.VbeSignature[0] == 'V') &&
 414              (vbe_info_block.VbeSignature[1] == 'E') &&
 415              (vbe_info_block.VbeSignature[2] == 'S') &&
 416              (vbe_info_block.VbeSignature[3] == 'A')) )
 417         {
 418                 vbe2_info = 1;
 419 #ifdef DEBUG
 420                 printf("VBE correct VESA/VBE2 signature found\n");
 421 #endif
 422         }
 423 #endif
 424
 425         // VBE Signature
 426         vbe_info_block.VbeSignature[0] = 'V';
 427         vbe_info_block.VbeSignature[1] = 'E';
 428         vbe_info_block.VbeSignature[2] = 'S';
 429         vbe_info_block.VbeSignature[3] = 'A';
 430
 431         // VBE Version supported
 432         vbe_info_block.VbeVersion = 0x0200;
 433
 434         // OEM String
 435         vbe_info_block.OemStringPtr_Seg = 0xc000;
 436         vbe_info_block.OemStringPtr_Off = &vbebios_copyright;
 437
 438         // Capabilities
 439         vbe_info_block.Capabilities[0] = 0;
 440         vbe_info_block.Capabilities[1] = 0;
 441         vbe_info_block.Capabilities[2] = 0;
 442         vbe_info_block.Capabilities[3] = 0;
 443
 444 #ifdef DYN_LIST
 445         // FIXME: This doesn't work correctly somehow?
 446         // VBE Video Mode Pointer (dynamicly generated from the mode_info_list)
 447         vbe_info_block.VideoModePtr_Seg= ES ;//0xc000;
 448         vbe_info_block.VideoModePtr_Off= DI + 34;//&(VBEInfoData->Reserved);//&vbebios_mode_list;
 449 #else
 450         // VBE Video Mode Pointer (staticly in rom)
 451         vbe_info_block.VideoModePtr_Seg = 0xc000;
 452         vbe_info_block.VideoModePtr_Off = &vbebios_mode_list;
 453
 454 #endif
 455
 456 #ifdef DYN_LIST
 457
 458 //      video_mode_list=(Bit16u*)&(vbe_info_block.Reserved);
 459
 460         do
 461         {
 462 #ifdef DEBUG
 463                 printf("VBE found mode %x => %x\n", cur_info->mode,cur_mode);
 464 #endif
 465 //              *video_mode_list=cur_info->mode;
 466                 vbe_info_block.Reserved[cur_mode] = cur_info->mode;
 467
 468                 cur_info++;
 469                 //video_mode_list++;
 470                 cur_mode++;
 471         } while (cur_info->mode != VBE_VESA_MODE_END_OF_LIST);
 472
 473         // Add vesa mode list terminator
 474         vbe_info_block.Reserved[cur_mode] = VBE_VESA_MODE_END_OF_LIST;
 475 #endif
 476
 477         if (vbe2_info)
 478         {
 479                 // VBE Total Memory (in 64b blocks)
 480                 vbe_info_block.TotalMemory = VBE_TOTAL_VIDEO_MEMORY_DIV_64K;
 481
 482                 // OEM Stuff
 483                 vbe_info_block.OemSoftwareRev = VBE_OEM_SOFTWARE_REV;
 484                 vbe_info_block.OemVendorNamePtr_Seg = 0xc000;
 485                 vbe_info_block.OemVendorNamePtr_Off = &vbebios_vendor_name;
 486                 vbe_info_block.OemProductNamePtr_Seg = 0xc000;
 487                 vbe_info_block.OemProductNamePtr_Off = &vbebios_product_name;
 488                 vbe_info_block.OemProductRevPtr_Seg = 0xc000;
 489                 vbe_info_block.OemProductRevPtr_Off = &vbebios_product_revision;
 490
 491                 // copy updates in vbe_info_block back
 492                 memcpyb(ES, DI, ss, &vbe_info_block, sizeof(vbe_info_block));
 493         }
 494         else
 495         {
 496                 // copy updates in vbe_info_block back (VBE 1.x compatibility)
 497                 memcpyb(ES, DI, ss, &vbe_info_block, 256);
 498         }
 499
 500         result = 0x4f;
 501
 502         write_word(ss, AX, result);
 503 }
 504
 505
 506 /** Function 01h - Return VBE Mode Information
 507  *
 508  * Input:
 509  *              AX      = 4F01h
 510  *              CX      = Mode Number
 511  *              ES:DI   = Pointer to buffer in which to place ModeInfoBlock structure
 512  * Output:
 513  *              AX      = VBE Return Status
 514  *
 515  */
 516 void vbe_biosfn_return_mode_information(AX, CX, ES, DI)
 517 Bit16u *AX;Bit16u CX; Bit16u ES;Bit16u DI;
 518 {
 519         Bit16u            result=0x0100;
 520         Bit16u            ss=get_SS();
 521         ModeInfoBlock     info;
 522         ModeInfoListItem  *cur_info;
 523         Boolean           using_lfb;
 524
 525 #ifdef DEBUG
 526         printf("VBE vbe_biosfn_return_mode_information ES%x DI%x CX%x\n",ES,DI,CX);
 527 #endif
 528
 529         using_lfb=((CX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER);
 530
 531         CX = (CX & 0x1ff);
 532
 533         cur_info = mode_info_find_mode(CX, using_lfb, &cur_info);
 534
 535         if (cur_info != 0)
 536         {
 537 #ifdef DEBUG
 538                 printf("VBE found mode %x\n",CX);
 539 #endif
 540                 memsetb(ss, &info, 0, sizeof(ModeInfoBlock));
 541                 memcpyb(ss, &info, 0xc000, &(cur_info->info), sizeof(ModeInfoBlockCompact));
 542                 if (info.WinAAttributes & VBE_WINDOW_ATTRIBUTE_RELOCATABLE) {
 543                   info.WinFuncPtr = 0xC0000000UL;
 544                   *(Bit16u *)&(info.WinFuncPtr) = (Bit16u)(dispi_set_bank_farcall);
 545                 }
 546
 547                 result = 0x4f;
 548         }
 549         else
 550         {
 551 #ifdef DEBUG
 552                 printf("VBE *NOT* found mode %x\n",CX);
 553 #endif
 554                 result = 0x100;
 555         }
 556
 557         if (result == 0x4f)
 558         {
 559                 // copy updates in mode_info_block back
 560                 memcpyb(ES, DI, ss, &info, sizeof(info));
 561         }
 562
 563         write_word(ss, AX, result);
 564 }
 565
 566 /** Function 02h - Set VBE Mode
 567  *
 568  * Input:
 569  *              AX      = 4F02h
 570  *              BX      = Desired Mode to set
 571  *              ES:DI   = Pointer to CRTCInfoBlock structure
 572  * Output:
 573  *              AX      = VBE Return Status
 574  *
 575  */
 576 void vbe_biosfn_set_mode(AX, BX, ES, DI)
 577 Bit16u *AX;Bit16u BX; Bit16u ES;Bit16u DI;
 578 {
 579         Bit16u            ss = get_SS();
 580         Bit16u            result;
 581         ModeInfoListItem  *cur_info;
 582         Boolean           using_lfb;
 583
 584         using_lfb=((BX & VBE_MODE_LINEAR_FRAME_BUFFER) == VBE_MODE_LINEAR_FRAME_BUFFER);
 585
 586         BX = (BX & 0x1ff);
 587
 588         //result=read_word(ss,AX);
 589
 590         // check for non vesa mode
 591         if (BX<VBE_MODE_VESA_DEFINED)
 592         {
 593                 Bit8u   mode;
 594
 595                 dispi_set_enable(VBE_DISPI_DISABLED);
 596                 // call the vgabios in order to set the video mode
 597                 // this allows for going back to textmode with a VBE call (some applications expect that to work)
 598
 599                 mode=(BX & 0xff);
 600                 biosfn_set_video_mode(mode);
 601                 result = 0x4f;
 602         }
 603
 604         cur_info = mode_info_find_mode(BX, using_lfb, &cur_info);
 605
 606         if (cur_info != 0)
 607         {
 608 #ifdef DEBUG
 609                 printf("VBE found mode %x, setting:\n", BX);
 610                 printf("\txres%x yres%x bpp%x\n",
 611                         cur_info->info.XResolution,
 612                         cur_info->info.YResolution,
 613                         cur_info->info.BitsPerPixel);
 614 #endif
 615                 // FIXME: this is here so we can do some testing
 616                 // at least until bochs host side display is up & running
 617                 // (we're using the 'standard' 320x200x256 vga mode as if it
 618                 //  were a vesa mode)
 619
 620                 if (cur_info->info.BitsPerPixel <= 8)
 621                 {
 622                   // we have a 4bpp or 8bpp mode, preparing to set it
 623
 624                   // first disable current mode (when switching between vesa modi)
 625                   dispi_set_enable(VBE_DISPI_DISABLED);
 626
 627                   if (cur_info->mode == VBE_VESA_MODE_800X600X4)
 628                   {
 629                     biosfn_set_video_mode(0x6a);
 630                   }
 631
 632                   dispi_set_xres(cur_info->info.XResolution);
 633                   dispi_set_yres(cur_info->info.YResolution);
 634                   dispi_set_bpp((cur_info->info.BitsPerPixel == 8)?VBE_DISPI_BPP_8:VBE_DISPI_BPP_4);
 635                   dispi_set_bank(0);
 636                   dispi_set_enable(VBE_DISPI_ENABLED);
 637
 638                   // FIXME: store current mode in BIOS data area
 639
 640                   result = 0x4f;
 641                 }
 642
 643                 //FIXME: new resolutions will need special code (per bpp)
 644         }
 645         else
 646         {
 647 #ifdef DEBUG
 648                 printf("VBE *NOT* found mode %x\n" , BX);
 649 #endif
 650                 result = 0x100;
 651
 652                 // FIXME: redirect non VBE modi to normal VGA bios operation
 653                 //        (switch back to VGA mode
 654                 if (BX == 3)
 655                         result = 0x4f;
 656         }
 657
 658         write_word(ss, AX, result);
 659 }
 660
 661 /** Function 03h - Return Current VBE Mode
 662  *
 663  * Input:
 664  *              AX      = 4F03h
 665  * Output:
 666  *              AX      = VBE Return Status
 667  *              BX      = Current VBE Mode
 668  *
 669  */
 670 void vbe_biosfn_return_current_mode(AX, BX)
 671 Bit16u *AX;Bit16u *BX;
 672 {
 673         Bit16u ss=get_SS();
 674         Bit16u mode=0xffff;
 675
 676 #ifdef DEBUG
 677         printf("VBE vbe_biosfn_return_current_mode\n");
 678 #endif
 679
 680         if(dispi_get_enable())
 681         {
 682                 // FIXME: get current mode from BIOS data area
 683         }
 684         else
 685         {
 686                 mode=read_byte(BIOSMEM_SEG,BIOSMEM_CURRENT_MODE);
 687         }
 688         write_word(ss, AX, 0x4f);
 689         write_word(ss, BX, mode);
 690 }
 691
 692
 693 /** Function 04h - Save/Restore State
 694  *
 695  * Input:
 696  *              AX      = 4F04h
 697  *              DL      = 00h Return Save/Restore State buffer size
 698  *                        01h Save State
 699  *                        02h Restore State
 700  *              CX      = Requested states
 701  *              ES:BX   = Pointer to buffer (if DL <> 00h)
 702  * Output:
 703  *              AX      = VBE Return Status
 704  *              BX      = Number of 64-byte blocks to hold the state buffer (if DL=00h)
 705  *
 706  */
 707 void vbe_biosfn_save_restore_state(AX, DL, CX, ES, BX)
 708 {
 709 }
 710
 711
 712 /** Function 05h - Display Window Control
 713  *
 714  * Input:
 715  *              AX      = 4F05h
 716  *     (16-bit) BH      = 00h Set memory window
 717  *                      = 01h Get memory window
 718  *              BL      = Window number
 719  *                      = 00h Window A
 720  *                      = 01h Window B
 721  *              DX      = Window number in video memory in window
 722  *                        granularity units (Set Memory Window only)
 723  * Note:
 724  *              If this function is called while in a linear frame buffer mode,
 725  *              this function must fail with completion code AH=03h
 726  *
 727  * Output:
 728  *              AX      = VBE Return Status
 729  *              DX      = Window number in window granularity units
 730  *                        (Get Memory Window only)
 731  */
 732 void vbe_biosfn_display_window_control(AX,BX,DX)
 733 Bit16u *AX;Bit16u BX;Bit16u *DX;
 734 {
 735         Bit16u            ss = get_SS();
 736         Bit16u            window = read_word(ss, DX);
 737
 738         if (BX==0x0000)
 739         {
 740                 dispi_set_bank(window);
 741         }
 742 }
 743
 744
 745 /** Function 06h - Set/Get Logical Scan Line Length
 746  *
 747  * Input:
 748  *              AX      = 4F06h
 749  *              BL      = 00h Set Scan Line Length in Pixels
 750  *                      = 01h Get Scan Line Length
 751  *                      = 02h Set Scan Line Length in Bytes
 752  *                      = 03h Get Maximum Scan Line Length
 753  *              CX      = If BL=00h Desired Width in Pixels
 754  *                        If BL=02h Desired Width in Bytes
 755  *                        (Ignored for Get Functions)
 756  *
 757  * Output:
 758  *              AX      = VBE Return Status
 759  *              BX      = Bytes Per Scan Line
 760  *              CX      = Actual Pixels Per Scan Line
 761  *                        (truncated to nearest complete pixel)
 762  *              DX      = Maximum Number of Scan Lines
 763  */
 764 void vbe_biosfn_set_get_logical_scan_line_length(AX,BX,CX,DX)
 765 Bit16u *AX;Bit16u *BX;Bit16u *DX;Bit16u *DX;
 766 {
 767         Bit16u ss=get_SS();
 768         Bit16u result=0x100;
 769         Bit16u width = read_word(ss, CX);
 770         Bit16u cmd = read_word(ss, BX);
 771
 772         // check bl
 773         if ( ((cmd & 0xff) == 0x00) || ((cmd & 0xff) == 0x02) )
 774         {
 775                 // set scan line lenght in pixels(0x00) or bytes (0x00)
 776                 Bit16u new_width;
 777                 Bit16u new_height;
 778
 779                 dispi_set_virt_width(width);
 780                 new_width=dispi_get_virt_width();
 781                 new_height=dispi_get_virt_height();
 782
 783                 if (new_width!=width)
 784                 {
 785 #ifdef DEBUG
 786                 printf("* VBE width adjusted\n");
 787 #endif
 788
 789                         // notify width adjusted
 790                         result=0x024f;
 791                 }
 792                 else
 793                 {
 794                         result=0x4f;
 795                 }
 796
 797                 // FIXME: adjust for higher bpp (in bytes)
 798                 write_word(ss,BX,new_width);
 799                 write_word(ss,CX,new_width);
 800                 write_word(ss,DX,new_height);
 801         }
 802
 803         write_word(ss, AX, result);
 804 }
 805
 806
 807 /** Function 07h - Set/Get Display Start
 808  *
 809  * Input(16-bit):
 810  *              AX      = 4F07h
 811  *              BH      = 00h Reserved and must be 00h
 812  *              BL      = 00h Set Display Start
 813  *                      = 01h Get Display Start
 814  *                      = 02h Schedule Display Start (Alternate)
 815  *                      = 03h Schedule Stereoscopic Display Start
 816  *                      = 04h Get Scheduled Display Start Status
 817  *                      = 05h Enable Stereoscopic Mode
 818  *                      = 06h Disable Stereoscopic Mode
 819  *                      = 80h Set Display Start during Vertical Retrace
 820  *                      = 82h Set Display Start during Vertical Retrace (Alternate)
 821  *                      = 83h Set Stereoscopic Display Start during Vertical Retrace
 822  *              ECX     = If BL=02h/82h Display Start Address in bytes
 823  *                        If BL=03h/83h Left Image Start Address in bytes
 824  *              EDX     = If BL=03h/83h Right Image Start Address in bytes
 825  *              CX      = If BL=00h/80h First Displayed Pixel In Scan Line
 826  *              DX      = If BL=00h/80h First Displayed Scan Line
 827  *
 828  * Output:
 829  *              AX      = VBE Return Status
 830  *              BH      = If BL=01h Reserved and will be 0
 831  *              CX      = If BL=01h First Displayed Pixel In Scan Line
 832  *                        If BL=04h 0 if flip has not occurred, not 0 if it has
 833  *              DX      = If BL=01h First Displayed Scan Line
 834  *
 835  * Input(32-bit):
 836  *              BH      = 00h Reserved and must be 00h
 837  *              BL      = 00h Set Display Start
 838  *                      = 80h Set Display Start during Vertical Retrace
 839  *              CX      = Bits 0-15 of display start address
 840  *              DX      = Bits 16-31 of display start address
 841  *              ES      = Selector for memory mapped registers
 842  */
 843 void vbe_biosfn_set_get_display_start(AX,BX,CX,DX)
 844 Bit16u *AX;Bit16u BX;Bit16u CX;Bit16u DX;
 845 {
 846         Bit16u ss=get_SS();
 847         Bit16u result=0x100;
 848 #ifdef DEBUG
 849  //       printf("VBE vbe_biosfn_set_get_display_start\n");
 850 #endif
 851
 852         // check for set display start
 853         if ((GET_BL()==0x00) || (GET_BL()==0x80))
 854         {
 855           // 0x80 is during vertical retrace - is also used by sdd vbetest during multibuffering
 856 #ifdef DEBUG
 857 //        printf("VBE vbe_biosfn_set_get_display_start CX%x DX%x\n",CX,DX);
 858 #endif
 859
 860                 dispi_set_x_offset(CX);
 861                 dispi_set_y_offset(DX);
 862                 result = 0x4f;
 863         }
 864
 865         write_word(ss, AX, result);
 866 }
 867
 868
 869 /** Function 08h - Set/Get Dac Palette Format
 870  *
 871  * Input:
 872  *              AX      = 4F08h
 873  * Output:
 874  *              AX      = VBE Return Status
 875  *
 876  * FIXME: incomplete API description, Input & Output
 877  */
 878 void vbe_biosfn_set_get_dac_palette_format(AX)
 879 {
 880 }
 881
 882
 883 /** Function 09h - Set/Get Palette Data
 884  *
 885  * Input:
 886  *              AX      = 4F09h
 887  * Output:
 888  *              AX      = VBE Return Status
 889  *
 890  * FIXME: incomplete API description, Input & Output
 891  */
 892 void vbe_biosfn_set_get_palette_data(AX)
 893 {
 894 }
 895
 896 /** Function 0Ah - Return VBE Protected Mode Interface
 897  *
 898  * Input:
 899  *              AX      = 4F0Ah
 900  * Output:
 901  *              AX      = VBE Return Status
 902  *
 903  * FIXME: incomplete API description, Input & Output
 904  */
 905 void vbe_biosfn_return_protected_mode_interface(AX)
 906 {
 907 }