Foro de elhacker.net

//This function makes the VGA card enter in
//standard 320x200 256-color MCGA mode,
//without using the BIOS.
//
//It follows the following sequence:
//
// 1. Turns off monitor output to completely avoid flicker,
//    frequency/synchrony issues while setting the video mode,
//    and apparently making the video mode switching much faster
//    from text to graphics.
//
// 2. Configures the Miscellaneous Output Register.
//
// 3. Configures the Feature Control Register.
//
// 4. Write the 5 Sequencer registers.
//
// 5. Unprotect CRTC registers 0-7.
//
// 6. Writes the 25 CRTC registers.
//
// 7. Protects CRTC registers 0-7.
//
// 8. Writes the 9 Graphics Controller Registers.
//
// 9. Writes the Attribute Controller Registers.
//    Here's an optimization: From its 21 registers, only
//    registers 16 to 20 are written. Registers 0 to 15
//    are left unchanged because those palette registers are
//    not useful for MCGA 320x200x256, so we skip writing those.
//
//10. Enable reads to the palette by setting bit 5 of the
//    Attribute Controller Index Register at 0x3C0, to 1.
//
//11. Turn back on monitor output to make use of the graphics mode.
//
//This sequence takes the best from all of the other programming sequences floating around
//for manually entering mode 13h, and thus has original-research optimizations
//from me (skipping configuration the 16-color palette of the Attribute Controller),
//and avoiding inferior ways of doing things (wait for vertical retrace, instead of
//doing it much better by disabling hardware video output, while reconfiguring
//the registers), etc. And it is much, much more documented and easy to read/understand,
//with nice and elegant public domain low level standard VGA "API" functions.
//
//This program does NOT reconfigure BIOS video mode metrics in the BDA, nor clears
//the screen after setting the video mode, just because those tasks are entirely
//apart from the low level hardware programming shown here. That would just add to the
//bulk of this demo program, and it will be programmed by me, but in a different, yet
//equally reusable/combinable "API" package.
///
function set_mode_MCGA_320x200x256()
{
 push $WIDEAX;
 push $WIDEBX;
 push $WIDECX;
 push $WIDESI;

 //Write to Color register address in all cases
 //that apply to our interfacing functions:
 ///
  $BX=0000000001000000b;


 //Turn monitor output off to be nicer with older
 //and delicate monitors while fiddling with the configuration:
 ///
  stdVGA_Sequencer_Monitor_Off();


 //We want to set this register to clear its bit 0,
 //to enforce activating I/O register addresses for
 //color video modes, and the rest of its configurations:
 ///
  $AL=[CGA_320x200x256Gen__MiscOutputReg];
  stdVGA_set_Miscellaneous_Output_Register();


 //Write the Feature Control Register:
 ///
  $AL=[CGA_320x200x256Gen__FeatureControlReg];
  //$BX=0000000001000000b;  //Write to Color register address
  stdVGA_set_Feature_Control_Register();


 //Write the Sequencer registers:
 ///
  $CH=0;  //Index of first register to write
  $CL=5;  //Number of registers to write
  $WIDESI=CGA_320x200x256SequencerRegs;
  stdVGA_set_Sequencer_regs();


 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers
 ///INIT: Write the CRTC registers

  //First unprotect registers 0-7:
  ///
   $CL=00000000b;          //Do Unprotect
   //$BX=0000000001000000b;  //Use Color I/O port address
   stdVGA_protect_unprotect_CRTC_regs();



  //Write the CRTC registers:
  ///
   $CH=0;   //Index of first register to write
   $CL=25;  //Number of registers to write
   //$BX=0000000001000000b;  //Use Color I/O port address
   $WIDESI=CGA_320x200x256CRTCRegs;
   stdVGA_set_CRTC_regs();



  //Finally, protect registers 0-7 again:
  ///
   $CL=10000000b;          //Do Protect
   //$BX=0000000001000000b;  //Use Color I/O port address
   stdVGA_protect_unprotect_CRTC_regs();


 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers
 ///END:  Write the CRTC registers



 //Write the Graphics Controller registers:
 ///
  $CH=0;  //Index of first register to write
  $CL=9;  //Number of registers to write
  $WIDESI=CGA_320x200x256GraphicsRegs;
  stdVGA_set_Graphics_regs();



 //Write the Attribute Controller registers. We will
 //try skipping the 16-color palette registers here,
 //since MCGA 320x200@256 colors uses the DAC instead
 //of those registers, and these registers don't care
 //in this mode:
 ///
  //Address bits of attribute flip/flop to reset it by reading it
  ///
   //$BX=0000000001000000b;
   $CH=16;     //Index of first register to write
   $CL=21-16;  //Number of registers to write
   $WIDESI=CGA_320x200x256AttributeRegs+16;
   stdVGA_set_Attribute_regs();



  //Enable the capability of reading the palette.
  //Otherwise, the screen will stay absolutely black!:
  ///
   stdVGA_set_Attribute_regs__EnablePalette();


 //Turn monitor output on (this assumes that the register
 //set values we are using keep the Sequencer's Screen Off bit
 //off at all times, to not defeat the very purpose of this
 //"protection"):
 ///
  stdVGA_Sequencer_Monitor_On();


 pop $WIDESI;
 pop $WIDECX;
 pop $WIDEBX;
 pop $WIDEAX;
}

set_mode_MCGA_320x200x256:
push eax
push ebx
push ecx
push esi



mov bx,0000000001000000b;



call stdVGA_Sequencer_Monitor_Off;


mov al,[CGA_320x200x256Gen__MiscOutputReg];
call stdVGA_set_Miscellaneous_Output_Register;


mov al,[CGA_320x200x256Gen__FeatureControlReg];
call stdVGA_set_Feature_Control_Register;



mov ch,0;
mov cl,5;
mov esi,CGA_320x200x256SequencerRegs
call stdVGA_set_Sequencer_regs;



mov cl,00000000b;
call stdVGA_protect_unprotect_CRTC_regs;


mov ch,0;
mov cl,25;
mov esi,CGA_320x200x256CRTCRegs
call stdVGA_set_CRTC_regs;



mov cl,10000000b;
call stdVGA_protect_unprotect_CRTC_regs;



mov ch,0;
mov cl,9;
mov esi,CGA_320x200x256GraphicsRegs
call stdVGA_set_Graphics_regs;



mov ch,16;
mov cl,5;
mov esi,CGA_320x200x256AttributeRegs+16;
call stdVGA_set_Attribute_regs;


call stdVGA_set_Attribute_regs__EnablePalette;



call stdVGA_Sequencer_Monitor_On;



pop esi
pop ecx
pop ebx
pop eax
ret

function sys_get_args()
{
 asm pushad

  $ESI = 0x81;       ;//Start of command-line string
  $EDI = sys_argv;
  $CL  = byte[0x80]; ;//Size of command-line string


  while($CL != 0)
  {
    if( byte[$ESI]!=0x20 && byte[$EDI]!=0x0D )
    {
     dword[sys_argc]++;

     dword[$EDI]=$ESI;
     $EDI+=4;

     sys_args_last_arg_char();
     dword[$EDI]  = $EAX;
     dword[$EDI] -= $ESI;
     $CL-=[$EDI];


     $ESI=$EAX;
     $EDI+=4;
     continue;
    }


   ;//These 2 instructions are only in case
   ;//the characters are 0x20 or 0x0D, and the
   ;//"continue" just above avoids it from being
   ;//run if we processed actual characters in this
   ;//iteration:
   ;;
    $ESI++;
    $CL--;
  }

 asm popad
}



align 16                               ;//DEBUG STRING
db "int argc void *argv             "  ;//DEBUG STRING
 sys_argc dd 0
 sys_argv times 128 dd 0

align 16                               ;//DEBUG STRING
db "       int argc void *argv {END}"  ;//DEBUG STRING




function /*$EAX */sys_args_last_arg_char()
{
 asm push ecx


  $EAX=$ESI;

  while($CL != 0)
  {
    if( byte[$EAX]==0x20 || byte[$EAX]==0x0D )
    break;

    $EAX++;
    $CL--;
  }

 asm pop ecx
}

sys_get_args:
  pushad
    mov esi,0x81
    mov edi,sys_argv
    mov cl,[0x80]




   .while_ln28:
   cmp cl,0
   jz .while_ln28_end
       cmp byte[esi],0x20
       je .not_if_ln28
       cmp byte[esi],0x0D
       je .not_if_ln28

       inc dword[sys_argc]

       mov dword[edi],esi
       add edi,4


       call sys_args_last_arg_char

       mov dword[edi],eax
       sub dword[edi],esi
       sub cl,[edi]

        mov esi,eax
        add edi,4

       jmp .while_ln28

     .not_if_ln28:

   ;//These 2 instructions are only in case
   ;//the characters are 0x20 or 0x0D, and the
   ;//"continue" just above avoids it from being
   ;//run if we processed actual characters in this
   ;//iteration:
   ;;
    inc esi
    dec cl

   jmp .while_ln28
   .while_ln28_end:

  popad
ret



align 16
db "int argc void *argv             "
 sys_argc dd 0
 sys_argv times 128 dd 0

align 16
db "       int argc void *argv {END}"



sys_args_last_arg_char:
  push ecx
    mov eax,esi

   .while_ln74:
   cmp cl,0
   jz .while_ln74_end
      cmp byte[eax],0x20
      je .while_ln74_end
      cmp byte[eax],0x0D
      je .while_ln74_end


      inc eax
      dec cl

   jmp .while_ln74
   .while_ln74_end:

  pop ecx
ret

;NOTA: Ensamblar con el comando:
;
;        NASM pehead.asm -o pehead.exe


EXE_start:

bits 32

alig equ 16


%define round(n, r) (((n+(r-1))/r)*r)



DOS_stub_start:
  db 'MZ'


  times 0x3A db 0


  dd PEhead


DOS_stub_end:
DOS_stub_SZ equ (DOS_stub_end-DOS_stub_start)


PE_head_start:
  PEhead:

  PEhead.Signature            db 'P','E',0,0

  PEhead.Machine              dw 0x14C

  PEhead.NumberOfSections     dw 1

  PEhead.TimeDateStamp        dd 0

  PEhead.PointerToSymbolTable dd 0

  PEhead.NumberOfSymbols      dd 0

  PEhead.SizeOfOptionalHeader dw 4

  PEhead.Characteristics      dw 0x0103

PE_head_end:
PE_head_SZ equ (PE_head_end-PE_head_start)



Opt_Head_start:
  OptHead:

  OptHead.Magic                   dw 0x10B
  OptHead.MajorLinkerVersion      db 8
  OptHead.MinorLinkerVersion      db 0
  OptHead.SizeOfCode              dd round(codesize,alig) ;1024 ;Code_SZ
  OptHead.SizeOfInitializedData   dd 0
  OptHead.SizeOfUninitializedData dd codesize ;1024
  OptHead.AddressOfEntryPoint     dd PrgEntry
  OptHead.BaseOfCode              dd codesize ;1024
  OptHead.BaseOfData              dd PrgEntry
  OptHead.ImageBase               dd 0x400000
  OptHead.SectionAlignment        dd alig
  OptHead.FileAlignment           dd alig
  OptHead.MajorOSVersion          dw 4
  OptHead.MinorOSVersion          dw 0
  OptHead.MajorImageVersion       dw 0
  OptHead.MinorImageVersion       dw 0
  OptHead.MajorSubsystemVersion   dw 4
  OptHead.MinorSubsystemVersion   dw 0
  OptHead.Win32VersionValue       dd 0
  OptHead.SizeOfImage             dd round(hdrsize,alig)+round(codesize,alig) ;1024 ;EXE_SZ
  OptHead.SizeOfHeaders           dd round(hdrsize,alig) ;Headers_SZ
  OptHead.Checksum                dd 0
  OptHead.Subsystem               dw 2
  OptHead.DllCharacteristics      dw 0
  OptHead.SizeOfStackReserve      dd 0
  OptHead.SizeOfStackCommit       dd 0
  OptHead.SizeOfHeapReserve       dd 0
  OptHead.SizeOfHeapCommit        dd 0
  OptHead.LoaderFlags             dd 0
  OptHead.NumberOfRvaAndSizes     dd 3
    OptHead.ExportTable.VirtualAddress dd 0
    OptHead.ExportTable.Size           dd 0

    OptHead.ImportTable.VirtualAddress dd ImportDirectoryTable
    OptHead.ImportTable.Size           dd ImportDirectoryTable_SZ

    OptHead.ResourceTable.VirtualAddress dd ResourceTable
    OptHead.ResourceTable.Size           dd 4096 ;ResourceTable_SZ

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0

    dd 0
    dd 0
Opt_Head_end:
Opt_Head_SZ equ (Opt_Head_end-Opt_Head_start)



hdrsize equ $ - $$



Headers_SZ equ $-$$ ;(Opt_Head_SZ+PE_head_SZ+DOS_stub_SZ)






db ".code"
times 3 db 0

_virtualsize dd 2048
_virtualaddress dd PrgEntry
_sizeofrawdata dd 2048
_pointertorawdata dd PrgEntry
_pointertorelocations dd 0
_pointertolinenumbers dd 0
_numberofrelocations dw 0
_numberoflinenumbers dw 0
_characteristics dd 0x60000020



db ".rsrc"
times 3 db 0

virtualsize dd 2048
virtualaddress dd ResourceTable
sizeofrawdata dd 2048
pointertorawdata dd ResourceDirectoryEntry
pointertorelocations dd 0
pointertolinenumbers dd 0
numberofrelocations dw 0
numberoflinenumbers dw 0
characteristics dd 0x50000040





align 16
PrgEntry:
align 16
    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]

    push dword 0x20
    push dword str1+0x400000
    push dword str2+0x400000
    push dword 0
    call dword[ImportAddressTable.1_array0+0x400000]
ret


align 4
str1 db "Stringz 1",0
align 4
str2 db "Srins 2",0
align 4
str3 db "Strins a3",0


;align 1048576



align 16
db "[EOF]",0










align 16
ResourceTable:




;align 8
;






ResourceDirectoryEntry:


ResourceDirectoryTable0:
  ResourceDirectoryTable0.Characteristics     dd 0
  ResourceDirectoryTable0.Time_DateStamp      dd 0x49DDFF5E
  ResourceDirectoryTable0.MajorVersion        dw 0
  ResourceDirectoryTable0.MinorVersion        dw 0
  ResourceDirectoryTable0.NumberOfNameEntries dw 0
  ResourceDirectoryTable0.NumberOfIDEntries   dw 1

    ResourceDirectoryEntry1:
      ResourceDirectoryEntry1.IntegerID           dd 3
      ResourceDirectoryEntry1.EntryRVA            dd 0x80000000+ResourceDirectoryTable2 ;(ResourceDirectoryTable2-ResourceTable)

        ResourceDirectoryTable2:
          ResourceDirectoryTable2.Characteristics     dd 0
          ResourceDirectoryTable2.Time_DateStamp      dd 0x49DDFF5E
          ResourceDirectoryTable2.MajorVersion        dw 0
          ResourceDirectoryTable2.MinorVersion        dw 0
          ResourceDirectoryTable2.NumberOfNameEntries dw 0
          ResourceDirectoryTable2.NumberOfIDEntries   dw 1


            ResourceDirectoryEntry3:
              ResourceDirectoryEntry3.IntegerID           dd 1
              ResourceDirectoryEntry3.EntryRVA            dd ResourceDirectoryTable4 ;(ResourceDirectoryTable4-ResourceTable)


                ResourceDirectoryTable4:
                  ResourceDirectoryTable4.Characteristics     dd 0
                  ResourceDirectoryTable4.Time_DateStamp      dd 0x49DDFF5E
                  ResourceDirectoryTable4.MajorVersion        dw 0
                  ResourceDirectoryTable4.MinorVersion        dw 0
                  ResourceDirectoryTable4.NumberOfNameEntries dw 0
                  ResourceDirectoryTable4.NumberOfIDEntries   dw 1

                    ResourceDirectoryEntry5:
                      ResourceDirectoryEntry5.IntegerID           dd 0
                      ResourceDirectoryEntry5.EntryRVA            dd ResourceDataEntry6 ;(ResourceDataEntry6-ResourceTable)


                        ResourceDataEntry6:
                          ResourceDataEntry6.DataRVA                  dd vsico
                          ResourceDataEntry6.Size                     dd 1024 ;vsico_SZ
                          ResourceDataEntry6.CodePage                 dd 0
                          ResourceDataEntry6.Reserved                 dd 0



;ResourceDirectoryEntry:
;  ResourceDirectoryEntry.NameRVA             dd namerva
;  ResourceDirectoryEntry.IntegerID           dd 3
;  ResourceDirectoryEntry.DataEntryRVA        dd ResourceDirectoryTable
;  ResourceDirectoryEntry.SubdirectoryRVA     dd 0
;
;
;
;ResourceDirectoryTable:
;  ResourceDirectoryTable.Characteristics     dd 0
;  ResourceDirectoryTable.Time_DateStamp      dd 0
;  ResourceDirectoryTable.MajorVersion        dw 8
;  ResourceDirectoryTable.MinorVersion        dw 0
;  ResourceDirectoryTable.NumberOfNameEntries dw 1
;  ResourceDirectoryTable.NumberOfIDEntries   dw 1
;
;
;
;ResourceDataEntry:
;  ResourceDataEntry.DataRVA                  dd vsico
;  ResourceDataEntry.Size                     dd vsico_SZ
;  ResourceDataEntry.CodePage                 dd 0
;  ResourceDataEntry.Reserved                 dd 0



align 16
vsico:
;incbin "bc.ico"

vsico_SZ equ $-vsico


ResourceTable_SZ equ $-ResourceTable

















ImportDirectoryTable:
ImportDirectoryTable_start:
   ImportTable.ImportLookupTableRVA_array0  dd ImportLookupTable_array0
   ImportTable.Time_DateStamp_array0        dd 0
   ImportTable.ForwarderChain_array0        dd 0
   ImportTable.NameRVA_array0               dd DLL_name_array0
   ImportTable.ImportAddressTableRVA_array0 dd ImportAddressTable_array0

   ImportTable.ImportLookupTableRVA_array1  dd 0
   ImportTable.TimeDateStamp_array1         dd 0
   ImportTable.ForwarderChain_array1        dd 0
   ImportTable.NameRVA_array1               dd 0
   ImportTable.ImportAddressTableRVA_array1 dd 0





ImportDirectoryTable_end:
ImportDirectoryTable_SZ equ (ImportDirectoryTable_end-ImportDirectoryTable_start)
	

ImportAddressTable_array0:
   ImportAddressTable.1_array0 dd Hint_NameTable_array0 ;0x80000000+477
   ImportAddressTable.2_array0 dd 0


ImportLookupTable_array0:
   ImportLookupTable.Ordinal_Name_OrdinalNum_array0 dd Hint_NameTable_array0 ;0x80000000+477
   ImportLookupTable.Hint_NameTableRVA_array0       dd 0




Hint_NameTable_array0:
   dw 0x1DC
   db "MessageBoxA",0



DLL_name_array0:
db "USER32.dll",0



codesize equ $ - PrgEntry


namerva db "ICON",0


EXE_end:
EXE_SZ equ round((EXE_end-EXE_start),alig)

Code_SZ equ round(($-PrgEntry),alig)