memdisk/memdisk.inc

   1 ; -*- fundamental -*- (asm-mode sucks)
   2 ; ****************************************************************************
   3 ;
   4 ;  memdisk.inc
   5 ;
   6 ;  A program to emulate an INT 13h disk BIOS from a "disk" in extended
   7 ;  memory.
   8 ;
   9 ;   Copyright 2001-2009 H. Peter Anvin - All Rights Reserved
  10 ;   Copyright 2009 Intel Corporation; author: H. Peter Anvin
  11 ;
  12 ;  This program is free software; you can redistribute it and/or modify
  13 ;  it under the terms of the GNU General Public License as published by
  14 ;  the Free Software Foundation, Inc., 53 Temple Place Ste 330,
  15 ;  Boston MA 02111-1307, USA; either version 2 of the License, or
  16 ;  (at your option) any later version; incorporated herein by reference.
  17 ;
  18 ; ****************************************************************************
  19
  20 %include "../version.gen"
  21
  22 ; %define DEBUG_TRACERS                 ; Uncomment to get debugging tracers
  23
  24 %ifdef DEBUG_TRACERS
  25
  26 %macro TRACER   1
  27         call debug_tracer
  28         db %1
  29 %endmacro
  30 %macro WRITEHEX2 0-1 al
  31 %ifnidni %1,al
  32         push ax
  33         mov al,%1
  34         call writehex2
  35         pop ax
  36 %else
  37         call writehex2
  38 %endif
  39 %endmacro
  40 %macro WRITEHEX4 0-1 ax
  41 %ifnidni %1,ax
  42         push ax
  43         mov ax,%1
  44         call writehex4
  45         pop ax
  46 %else
  47         call writehex4
  48 %endif
  49 %endmacro
  50 %macro WRITEHEX8 0-1 eax
  51 %ifnidni %1,eax
  52         push eax
  53         mov eax,%1
  54         call writehex8
  55         pop eax
  56 %else
  57         call writehex8
  58 %endif
  59 %endmacro
  60
  61 %else   ; DEBUG_TRACERS
  62
  63 %macro  TRACER  1
  64 %endmacro
  65 %macro WRITEHEX2 0-1
  66 %endmacro
  67 %macro WRITEHEX4 0-1
  68 %endmacro
  69 %macro WRITEHEX8 0-1
  70 %endmacro
  71
  72 %endif  ; DEBUG_TRACERS
  73
  74 ; Flags we test our configuration against
  75 %define CONFIG_READONLY 0x01
  76 %define CONFIG_RAW      0x02
  77 %define CONFIG_SAFEINT  0x04
  78 %define CONFIG_BIGRAW   0x08            ; MUST be 8!
  79
  80                 org 0h
  81
  82 %define SECTORSIZE_LG2  9               ; log2(sector size)
  83 %define SECTORSIZE      (1 << SECTORSIZE_LG2)
  84
  85                 ; Parameter registers definition; this is the definition
  86                 ; of the stack frame.
  87 %define         P_DS            word [bp+34]
  88 %define         P_ES            word [bp+32]
  89 %define         P_EAX           dword [bp+28]
  90 %define         P_HAX           word [bp+30]
  91 %define         P_AX            word [bp+28]
  92 %define         P_AL            byte [bp+28]
  93 %define         P_AH            byte [bp+29]
  94 %define         P_ECX           dword [bp+24]
  95 %define         P_HCX           word [bp+26]
  96 %define         P_CX            word [bp+24]
  97 %define         P_CL            byte [bp+24]
  98 %define         P_CH            byte [bp+25]
  99 %define         P_EDX           dword [bp+20]
 100 %define         P_HDX           word [bp+22]
 101 %define         P_DX            word [bp+20]
 102 %define         P_DL            byte [bp+20]
 103 %define         P_DH            byte [bp+21]
 104 %define         P_EBX           dword [bp+16]
 105 %define         P_HBX           word [bp+18]
 106 %define         P_HBXL          byte [bp+18]
 107 %define         P_BX            word [bp+16]
 108 %define         P_BL            byte [bp+16]
 109 %define         P_BH            byte [bp+17]
 110 %define         P_EBP           dword [bp+8]
 111 %define         P_BP            word [bp+8]
 112 %define         P_ESI           dword [bp+4]
 113 %define         P_SI            word [bp+4]
 114 %define         P_EDI           dword [bp]
 115 %define         P_DI            word [bp]
 116
 117                 section .text
 118                 ; These pointers are used by the installer and
 119                 ; must be first in the binary
 120 Pointers:       dw Int13Start
 121                 dw Int15Start
 122                 dw PatchArea
 123                 dw TotalSize
 124                 dw IretPtr
 125
 126 IretPtr         equ Int13Start.iret
 127 Int13Start:
 128                 cmp word [cs:Recursive],0
 129                 jne recursive
 130
 131                 ; Swap stack
 132                 mov [cs:Stack],esp
 133                 mov [cs:Stack+4],ss
 134                 mov [cs:SavedAX],ax
 135                 mov ax,cs
 136                 mov ss,ax
 137                 mov sp,[cs:MyStack]
 138
 139                 ; See if DL points to our class of device (FD, HD)
 140                 push dx
 141                 push dx
 142                 xor dl,[cs:DriveNo]
 143                 pop dx
 144                 js .nomatch             ; If SF=0, we have a class match here
 145                                         ; 0x00 the sign bit for FD
 146                                         ; 0x80 the sign bit for HD
 147                 jz our_drive            ; If ZF=1, we have an exact match
 148                 cmp dl,[cs:DriveNo]
 149                 jb .nomatch             ; Drive < Our drive
 150                 dec dl                  ; Drive > Our drive, adjust drive #
 151 .nomatch:
 152 %ifdef DEBUG_TRACERS
 153                 TRACER '!'
 154                 WRITEHEX2 dl
 155                 TRACER ','
 156                 mov ax,[cs:SavedAX]
 157                 WRITEHEX4
 158 %else
 159                 mov ax,[cs:SavedAX]
 160 %endif
 161                 inc word [cs:Recursive]
 162                 pushf
 163                 call far [cs:OldInt13]
 164                 pushf
 165                 dec word [cs:Recursive]
 166                 push bp
 167                 mov bp,sp
 168                 cmp byte [cs:SavedAX+1],08h     ; Get drive params function?
 169                 je .norestoredl                 ; DL = number of drives
 170                 cmp byte [cs:SavedAX+1],15h     ; Get disk type function?
 171                 je .norestoredl                 ; CX:DX = size of device
 172 .restoredl:
 173                 mov dl,[bp+4]
 174 .norestoredl:
 175                 push ax
 176                 push ebx
 177                 push ds
 178                 mov ax,[bp+2]           ; Flags
 179                 lds ebx,[cs:Stack]
 180                 mov [bx+4],al           ; Arithmetic flags
 181                 pop ds
 182                 pop ebx
 183                 pop ax
 184                 pop bp
 185                 lss esp,[cs:Stack]
 186 .iret:          iret
 187
 188 recursive:
 189                 TRACER '@'
 190 jmp_oldint13:
 191                 jmp far [cs:OldInt13]
 192
 193 our_drive:
 194                 ; Set up standard entry frame
 195                 push ds
 196                 push es
 197                 mov ds,ax
 198                 mov es,ax
 199                 mov ax,[SavedAX]
 200                 pushad
 201                 mov bp,sp               ; Point BP to the entry stack frame
 202                 TRACER 'F'
 203                 WRITEHEX4
 204                 ; Note: AX == P_AX here
 205                 cmp ah,Int13FuncsCnt-1
 206                 ja Invalid_jump
 207                 xor al,al               ; AL = 0 is standard entry condition
 208                 mov di,ax
 209                 shr di,7                ; Convert AH to an offset in DI
 210                 call [Int13Funcs+di]
 211
 212 Done:           ; Standard routine for return
 213                 mov P_AX,ax
 214 DoneWeird:
 215                 TRACER 'D'
 216                 xor bx,bx
 217                 mov es,bx
 218                 mov bx,[StatusPtr]
 219                 mov [es:bx],ah          ; Save status
 220                 and ah,ah
 221
 222                 lds ebx,[Stack]
 223                 ; This sets the low byte (the arithmetic flags) of the
 224                 ; FLAGS on stack to either 00h (no flags) or 01h (CF)
 225                 ; depending on if AH was zero or not.
 226                 setnz [bx+4]            ; Set CF iff error
 227                 popad
 228                 pop es
 229                 pop ds
 230                 lss esp,[cs:Stack]
 231                 iret
 232
 233 Reset:
 234                 ; Reset affects multiple drives, so we need to pass it on
 235                 TRACER 'R'
 236                 xor ax,ax               ; Bottom of memory
 237                 mov es,ax
 238                 test dl,dl              ; Always pass it on if we are
 239                                         ; resetting HD
 240                 js .hard_disk           ; Bit 7 set
 241                 ; Some BIOSes get very unhappy if we pass a reset floppy
 242                 ; command to them and don't actually have any floppies.
 243                 ; This is a bug, but we have to deal with it nontheless.
 244                 ; Therefore, if we are the *ONLY* floppy drive, and the
 245                 ; user didn't request HD reset, then just drop the command.
 246                 ; BIOS equipment byte, top two bits + 1 == total # of floppies
 247                 test byte [es:0x410],0C0h
 248                 jz success
 249                 jmp .pass_on            ; ... otherwise pass it to the BIOS
 250 .hard_disk:
 251                 ; ... same thing for hard disks, sigh ...
 252                 cmp byte [es:0x475],1   ; BIOS variable for number of hard
 253                                         ; disks
 254                 jbe success
 255
 256 .pass_on:
 257                 pop ax                  ; Drop return address
 258                 popad                   ; Restore all registers
 259                 pop es
 260                 pop ds
 261                 lss esp,[cs:Stack]      ; Restore the stack
 262                 and dl,80h              ; Clear all but the type bit
 263                 jmp jmp_oldint13
 264
 265
 266 Invalid:
 267                 pop dx                  ; Drop return address
 268 Invalid_jump:
 269                 TRACER 'I'
 270                 mov ah,01h              ; Unsupported function
 271                 jmp short Done
 272
 273 GetDriveType:
 274                 test byte [DriveNo],80h
 275                 mov bl,02h              ; Type 02h = floppy with changeline
 276                 jz .floppy
 277                 ; Hard disks only!  DO NOT set CX:DX for floppies...
 278                 ; it apparently causes Win98SE DOS to go into an loop
 279                 ; resetting the drive over and over.  Sigh.
 280                 inc bx                  ; Type = 03h
 281                 mov dx,[DiskSize]       ; Return the disk size in sectors
 282                 mov P_DX,dx
 283                 mov cx,[DiskSize+2]
 284                 mov P_CX,cx
 285 .floppy:
 286                 mov P_AH,bl             ; 02h floppy, 03h hard disk
 287                 pop ax                  ; Drop return address
 288                 xor ax,ax               ; Success...
 289                 jmp DoneWeird           ; But don't stick it into P_AX
 290
 291 GetStatus:
 292                 xor ax,ax
 293                 mov es,ax
 294                 mov bx,[StatusPtr]
 295                 mov ah,[bx]             ; Copy last status
 296                 ret
 297
 298 ReadMult:
 299                 TRACER 'm'
 300 Read:
 301                 TRACER 'R'
 302                 call setup_regs
 303 do_copy:
 304                 TRACER '<'
 305                 call bcopy
 306                 TRACER '>'
 307                 movzx ax,P_AL           ; AH = 0, AL = transfer count
 308                 ret
 309
 310 WriteMult:
 311                 TRACER 'M'
 312 Write:
 313                 TRACER 'W'
 314                 test byte [ConfigFlags],CONFIG_READONLY
 315                 jnz .readonly
 316                 call setup_regs
 317                 xchg esi,edi            ; Opposite direction of a Read!
 318                 jmp short do_copy
 319 .readonly:      mov ah,03h              ; Write protected medium
 320                 ret
 321
 322                 ; Verify integrity; just bounds-check
 323 Seek:
 324 Verify:
 325                 call setup_regs         ; Returns error if appropriate
 326                 ; And fall through to success
 327
 328 CheckIfReady:                           ; These are always-successful noop functions
 329 Recalibrate:
 330 InitWithParms:
 331 DetectChange:
 332 EDDDetectChange:
 333 EDDLock:
 334 SetMode:
 335 success:
 336                 xor ax,ax               ; Always successful
 337                 ret
 338
 339 GetParms:
 340                 TRACER 'G'
 341                 mov dl,[DriveCnt]       ; Cached data
 342                 mov P_DL,dl
 343                 test byte [DriveNo],80h
 344                 jnz .hd
 345                 mov P_DI,DPT
 346                 mov P_ES,cs
 347                 mov bl,[DriveType]
 348                 mov P_BL,bl
 349 .hd:
 350                 mov ax,[Cylinders]
 351                 dec ax                  ; We report the highest #, not the count
 352                 xchg al,ah
 353                 shl al,6
 354                 or al,[Sectors]
 355                 mov P_CX,ax
 356                 mov ax,[Heads]
 357                 dec ax
 358                 mov P_DH,al
 359
 360                 ;
 361                 ; Is this MEMDISK installation check?
 362                 ;
 363                 cmp P_HAX,'ME'
 364                 jne .notic
 365                 cmp P_HCX,'MD'
 366                 jne .notic
 367                 cmp P_HDX,'IS'
 368                 jne .notic
 369                 cmp P_HBX,'K?'
 370                 jne .notic
 371
 372                 ; MEMDISK installation check...
 373                 mov P_HAX,'!M'
 374                 mov P_HCX,'EM'
 375                 mov P_HDX,'DI'
 376                 mov P_HBX,'SK'
 377                 mov P_ES,cs
 378                 mov P_DI,MemDisk_Info
 379
 380 .notic:
 381                 xor ax,ax
 382                 ret
 383 ;
 384 ; EDD functions -- only if enabled
 385 ;
 386 %if EDD
 387 EDDPresence:
 388                 TRACER 'E'
 389                 TRACER 'c'
 390
 391                 cmp P_BX,55AAh
 392                 jne Invalid
 393                 mov P_BX,0AA55h         ; EDD signature
 394                 mov P_AX,03000h         ; EDD 3.0
 395                 mov P_CX,0003h          ; Bit 0 - Fixed disk access subset
 396                                         ; Bit 1 - Locking and ejecting subset
 397                 pop ax                  ; Drop return address
 398                 xor ax,ax               ; Success
 399                 jmp DoneWeird           ; Success, but AH != 0, sigh...
 400
 401 EDDRead:
 402                 TRACER 'E'
 403                 TRACER 'r'
 404
 405                 call edd_setup_regs
 406                 call bcopy
 407                 xor ax,ax
 408                 ret
 409
 410 EDDWrite:
 411                 TRACER 'E'
 412                 TRACER 'w'
 413
 414                 call edd_setup_regs
 415                 xchg esi,edi            ; Opposite direction of a Read!
 416                 call bcopy
 417                 xor ax,ax
 418                 ret
 419
 420 EDDVerify:
 421 EDDSeek:
 422                 call edd_setup_regs     ; Just bounds checking
 423                 xor ax,ax
 424                 ret
 425
 426 EDDGetParms:
 427                 TRACER 'E'
 428                 TRACER 'p'
 429
 430                 mov es,P_DS
 431                 mov di,P_SI
 432                 mov si,EDD_DPT
 433
 434                 lodsw                   ; Length of our DPT
 435                 mov cx,[es:di]
 436                 cmp cx,26               ; Minimum size
 437                 jb .overrun
 438
 439                 cmp cx,ax
 440                 jb .oksize
 441                 mov cx,ax
 442
 443 .oksize:
 444                 mov ax,cx
 445                 stosw
 446                 dec cx
 447                 dec cx
 448                 rep movsb
 449
 450                 xor ax,ax
 451                 ret
 452
 453 .overrun:
 454                 mov ax,0100h
 455                 ret
 456 %endif ; EDD
 457
 458                 ; Set up registers as for a "Read", and compares against disk
 459                 ; size.
 460                 ; WARNING: This fails immediately, even if we can transfer some
 461                 ; sectors.  This isn't really the correct behaviour.
 462 setup_regs:
 463
 464                 ; Convert a CHS address in P_CX/P_DH into an LBA in eax
 465                 ; CH = cyl[7:0]
 466                 ; CL[0:5] = sector (1-based)  CL[7:6] = cyl[9:8]
 467                 ; DH = head
 468                 movzx ecx,P_CX
 469                 movzx ebx,cl            ; Sector number
 470                 and bl,3Fh
 471                 dec ebx                 ; Sector number is 1-based
 472                 cmp bx,[Sectors]
 473                 jae .overrun
 474                 movzx edi,P_DH          ; Head number
 475                 movzx eax,word [Heads]
 476                 cmp di,ax
 477                 jae .overrun
 478                 shr cl,6
 479                 xchg cl,ch              ; Now (E)CX <- cylinder number
 480                 mul ecx                 ; eax <- Heads*cyl# (edx <- 0)
 481                 add eax,edi
 482                 mul dword [Sectors]
 483                 add eax,ebx
 484                 ; Now eax = LBA, edx = 0
 485
 486                 ;
 487                 ; setup_regs continues...
 488                 ;
 489                 ; Note: edi[31:16] and ecx[31:16] = 0 already
 490                 mov di,P_BX             ; Get linear address of target buffer
 491                 mov cx,P_ES
 492                 shl ecx,4
 493                 add edi,ecx             ; EDI = address to fetch to
 494                 movzx ecx,P_AL          ; Sector count
 495                 mov esi,eax
 496                 add eax,ecx             ; LBA of final sector + 1
 497                 shl esi,SECTORSIZE_LG2  ; LBA -> byte offset
 498                 add esi,[DiskBuf]       ; Get address in high memory
 499                 cmp eax,[DiskSize]      ; Check the high mark against limit
 500                 ja .overrun
 501                 shl ecx,SECTORSIZE_LG2-2 ; Convert count to dwords
 502                 ret
 503
 504 .overrun:       pop ax                  ; Drop setup_regs return address
 505                 mov ax,0200h            ; Missing address mark
 506                 ret                     ; Return to Done
 507
 508                 ; Set up registers as for an EDD Read, and compares against disk size.
 509 %if EDD
 510 edd_setup_regs:
 511                 push es
 512                 mov si,P_SI             ; DS:SI -> DAPA
 513                 mov es,P_DS
 514
 515                 mov dx,[es:si]
 516                 cmp dx,16
 517                 jb .baddapa
 518
 519                 cmp dword [es:si+4],-1
 520                 je .linear_address
 521
 522                 movzx ebx,word [es:si+4]        ; Offset
 523                 movzx edi,word [es:si+6]        ; Segment
 524                 shl edi,4
 525                 add ebx,edi
 526                 jmp .got_address
 527
 528 .linear_address:
 529                 cmp dx,24               ; Must be large enough to hold
 530                                         ; linear address
 531                 jb .baddapa
 532
 533                 cmp dword [es:si+20],0  ; > 4 GB addresses not supported
 534                 mov ax,0900h            ; "Data boundary error" - bogus, but
 535                                         ; no really better code available
 536                 jne .error
 537
 538                 mov ebx,[es:si+16]
 539
 540 .got_address:
 541                 cmp dword [es:si+12],0          ; LBA too large?
 542                 jne .overrun
 543
 544                 movzx ecx, word [es:si+2]       ; Sectors to transfer
 545                 mov esi,[es:si+8]               ; Starting sector
 546                 mov eax,esi
 547                 add eax,ecx
 548                 jc .overrun
 549                 cmp eax,[DiskSize]
 550                 ja .overrun
 551
 552                 shl ecx,SECTORSIZE_LG2-2        ; Convert to dwords
 553                 shl esi,SECTORSIZE_LG2          ; Convert to an offset
 554                 add esi,[DiskBuf]
 555                 mov edi,ebx
 556                 pop es
 557                 ret
 558
 559 .baddapa:
 560                 mov ax,0100h            ; Invalid command
 561                 pop es
 562                 pop ax                  ; Drop setup_regs return address
 563                 ret
 564
 565 .overrun:
 566                 mov ax,0200h            ; "Address mark not found" =
 567                                         ; LBA beyond end of disk
 568 .error:
 569                 and word [es:si+2],0    ; No sectors transferred
 570                 pop es
 571                 pop ax
 572                 ret
 573
 574 EDDEject:
 575                 mov ax,0B200h           ; Volume Not Removable
 576                 ret
 577
 578 %endif ; EDD
 579
 580
 581 ;
 582 ; INT 15h intercept routines
 583 ;
 584 int15_e820:
 585                 cmp edx,534D4150h       ; "SMAP"
 586                 jne oldint15
 587                 cmp ecx,20              ; Need 20 bytes
 588                 jb err86
 589                 push ds
 590                 push cs
 591                 pop ds
 592                 push edx                ; "SMAP"
 593                 and ebx,ebx
 594                 jne .renew
 595                 mov ebx,E820Table
 596 .renew:
 597                 add bx,12               ; Advance to next
 598                 mov eax,[bx-4]          ; Type
 599                 and eax,eax             ; Null type?
 600                 jz .renew               ; If so advance to next
 601                 mov [es:di+16],eax
 602                 mov eax,[bx-12]         ; Start addr (low)
 603                 mov edx,[bx-8]          ; Start addr (high)
 604                 mov [es:di],eax
 605                 mov [es:di+4],edx
 606                 mov eax,[bx]            ; End addr (low)
 607                 mov edx,[bx+4]          ; End addr (high)
 608                 sub eax,[bx-12]         ; Derive the length
 609                 sbb edx,[bx-8]
 610                 mov [es:di+8],eax       ; Length (low)
 611                 mov [es:di+12],edx      ; Length (high)
 612                 cmp dword [bx+8],-1     ; Type of next = end?
 613                 jne .notdone
 614                 xor ebx,ebx             ; Done with table
 615 .notdone:
 616                 pop eax                 ; "SMAP"
 617                 mov edx,eax             ; Some systems expect eax = edx = SMAP
 618                 mov ecx,20              ; Bytes loaded
 619                 pop ds
 620 int15_success:
 621                 mov byte [bp+6], 02h    ; Clear CF
 622                 pop bp
 623                 iret
 624
 625 err86:
 626                 mov byte [bp+6], 03h    ; Set CF
 627                 mov ah,86h
 628                 pop bp
 629                 iret
 630
 631 Int15Start:
 632                 push bp
 633                 mov bp,sp
 634                 cmp ax,0E820h
 635                 je near int15_e820
 636                 cmp ax,0E801h
 637                 je int15_e801
 638                 cmp ax,0E881h
 639                 je int15_e881
 640                 cmp ah,88h
 641                 je int15_88
 642 oldint15:       pop bp
 643                 jmp far [cs:OldInt15]
 644
 645 int15_e801:                             ; Get mem size for > 64 MB config
 646                 mov ax,[cs:Mem1MB]
 647                 mov cx,ax
 648                 mov bx,[cs:Mem16MB]
 649                 mov dx,bx
 650                 jmp short int15_success
 651
 652 int15_e881:                             ; Get mem size for > 64 MB config
 653                                         ; 32-bit code
 654                 mov eax,[cs:Mem1MB]
 655                 mov ecx,eax
 656                 mov ebx,[cs:Mem16MB]
 657                 mov edx,ebx
 658                 jmp short int15_success
 659
 660 int15_88:                               ; Get extended mem size
 661                 mov ax,[cs:MemInt1588]
 662                 jmp short int15_success
 663
 664 ;
 665 ; Routine to copy in/out of high memory
 666 ; esi = linear source address
 667 ; edi = linear target address
 668 ; ecx = 32-bit word count
 669 ;
 670 ; Assumes cs = ds = es
 671 ;
 672 bcopy:
 673                 push eax
 674                 push ebx
 675                 push edx
 676                 push ebp
 677
 678                 mov bx, real_int15_stub
 679
 680                 test byte [ConfigFlags], CONFIG_RAW|CONFIG_SAFEINT
 681                 jz .anymode             ; Always do the real INT 15h
 682
 683                 smsw ax                 ; Unprivileged!
 684                 test al,01h
 685                 jnz .protmode           ; Protmode -> do real INT 15h
 686
 687 .realmode:
 688                 ; Raw or Safeint mode, and we're in real mode...
 689
 690                 test byte [ConfigFlags], CONFIG_SAFEINT
 691                 jnz .fakeint15
 692
 693 .raw:
 694                 TRACER 'r'
 695                 ; We're in real mode, do it outselves
 696
 697                 pushfd                  ; <A>
 698                 push ds                 ; <B>
 699                 push es                 ; <C>
 700
 701                 cli
 702                 cld
 703
 704                 xor ebx,ebx
 705                 mov bx,cs
 706                 shl ebx,4
 707                 lea edx,[Shaker+ebx]
 708                 mov [Shaker+2],edx
 709
 710                 ; Test to see if A20 is enabled or not
 711                 xor ax,ax
 712                 mov ds,ax
 713                 dec ax
 714                 mov es,ax
 715
 716                 mov ax,[0]
 717                 mov bx,ax
 718                 xor bx,[es:10h]
 719                 not ax
 720                 mov [0],ax
 721                 mov dx,ax
 722                 xor dx,[es:10h]
 723                 not ax
 724                 mov [0],ax
 725
 726                 or dx,bx
 727                 push dx                 ; <D> Save A20 status
 728                 jnz .skip_a20e
 729
 730                 mov ax,2401h            ; Enable A20
 731                 int 15h
 732 .skip_a20e:
 733                 mov dl,[ConfigFlags]
 734                 and dx,CONFIG_BIGRAW
 735                 add dx,8
 736                 ; DX = 16 for BIGRAW, 8 for RAW
 737                 ;  8 is selector for a 64K flat segment,
 738                 ; 16 is selector for a 4GB flat segment.
 739
 740                 lgdt [cs:Shaker]
 741                 mov eax,cr0
 742                 or al,01h
 743                 mov cr0,eax
 744
 745                 mov bx,16               ; Large flat segment
 746                 mov ds,bx
 747                 mov es,bx
 748
 749                 a32 rep movsd
 750
 751                 ; DX has the appropriate value to put in
 752                 ; the registers on return
 753                 mov ds,dx
 754                 mov es,dx
 755
 756                 and al,~01h
 757                 mov cr0,eax
 758
 759                 pop dx                  ; <D> A20 status
 760                 pop es                  ; <C>
 761                 pop ds                  ; <B>
 762
 763                 and dx,dx
 764                 jnz .skip_a20d
 765                 mov ax,2400h            ; Disable A20
 766                 int 15h
 767 .skip_a20d:
 768                 popfd                   ; <A>
 769                 jmp .done
 770
 771 .fakeint15:
 772                 ; We're in real mode with CONFIG_SAFEINT, invoke the
 773                 ; original INT 15h vector.  We used to test for the
 774                 ; INT 15h vector being unchanged here, but that is
 775                 ; *us*; however, the test was wrong for years (always
 776                 ; negative) so instead of fixing the test do what we
 777                 ; tested and don't bother probing.
 778                 mov bx, fake_int15_stub
 779
 780 .protmode:
 781                 TRACER 'p'
 782 .anymode:
 783
 784 .copy_loop:
 785                 push esi
 786                 push edi
 787                 push ecx
 788                 cmp ecx,4000h
 789                 jna .safe_size
 790                 mov ecx,4000h
 791 .safe_size:
 792                 push ecx        ; Transfer size this cycle
 793                 mov eax, esi
 794                 mov [Mover_src1], si
 795                 shr eax, 16
 796                 mov [Mover_src1+2], al
 797                 mov [Mover_src2], ah
 798                 mov eax, edi
 799                 mov [Mover_dst1], di
 800                 shr eax, 16
 801                 mov [Mover_dst1+2], al
 802                 mov [Mover_dst2], ah
 803                 mov si,Mover
 804                 mov ah, 87h
 805                 shl cx,1        ; Convert to 16-bit words
 806                 call bx         ; INT 15h stub
 807                 pop eax         ; Transfer size this cycle
 808                 pop ecx
 809                 pop edi
 810                 pop esi
 811                 jc .error
 812                 lea esi,[esi+4*eax]
 813                 lea edi,[edi+4*eax]
 814                 sub ecx, eax
 815                 jnz .copy_loop
 816                 ; CF = 0
 817 .error:
 818 .done:
 819                 pop ebp
 820                 pop edx
 821                 pop ebx
 822                 pop eax
 823                 ret
 824
 825 real_int15_stub:
 826                 int 15h
 827                 cli             ; Some BIOSes enable interrupts on INT 15h
 828                 ret
 829
 830 fake_int15_stub:
 831                 pushf
 832                 call far [OldInt15]
 833                 cli
 834                 ret
 835
 836 %ifdef DEBUG_TRACERS
 837 debug_tracer:   pushad
 838                 pushfd
 839                 mov bp,sp
 840                 mov bx,[bp+9*4]
 841                 mov al,[cs:bx]
 842                 inc word [bp+9*4]
 843                 mov ah,0Eh
 844                 mov bx,7
 845                 int 10h
 846                 popfd
 847                 popad
 848                 ret
 849
 850 writehex2:      pushad
 851                 pushfd
 852                 mov cx,2
 853                 ror eax,4
 854                 jmp writehex_common
 855 writehex4:      pushad
 856                 pushfd
 857                 mov cx,4
 858                 ror eax,12
 859                 jmp writehex_common
 860 writehex8:      pushad
 861                 pushfd
 862                 mov cx,8
 863                 ror eax,28
 864 writehex_common:
 865 .loop:          push cx
 866                 push eax
 867                 and al,0Fh
 868                 cmp al,10
 869                 jb .isdec
 870                 add al,'a'-'0'-10
 871 .isdec:         add al,'0'
 872                 mov ah,0Eh
 873                 mov bx,7
 874                 int 10h
 875                 pop eax
 876                 rol eax,4
 877                 pop cx
 878                 loop .loop
 879                 popfd
 880                 popad
 881                 ret
 882 %endif
 883
 884                 section .data
 885                 alignb 2
 886 Int13Funcs      dw Reset                ; 00h - RESET
 887                 dw GetStatus            ; 01h - GET STATUS
 888                 dw Read                 ; 02h - READ
 889                 dw Write                ; 03h - WRITE
 890                 dw Verify               ; 04h - VERIFY
 891                 dw Invalid              ; 05h - FORMAT TRACK
 892                 dw Invalid              ; 06h - FORMAT TRACK AND SET BAD FLAGS
 893                 dw Invalid              ; 07h - FORMAT DRIVE AT TRACK
 894                 dw GetParms             ; 08h - GET PARAMETERS
 895                 dw InitWithParms        ; 09h - INITIALIZE CONTROLLER WITH
 896                                         ;       DRIVE PARAMETERS
 897                 dw Invalid              ; 0Ah
 898                 dw Invalid              ; 0Bh
 899                 dw Seek                 ; 0Ch - SEEK TO CYLINDER
 900                 dw Reset                ; 0Dh - RESET HARD DISKS
 901                 dw Invalid              ; 0Eh
 902                 dw Invalid              ; 0Fh
 903                 dw CheckIfReady         ; 10h - CHECK IF READY
 904                 dw Recalibrate          ; 11h - RECALIBRATE
 905                 dw Invalid              ; 12h
 906                 dw Invalid              ; 13h
 907                 dw Invalid              ; 14h
 908                 dw GetDriveType         ; 15h - GET DRIVE TYPE
 909                 dw DetectChange         ; 16h - DETECT DRIVE CHANGE
 910 %if EDD
 911                 dw Invalid              ; 17h
 912                 dw Invalid              ; 18h
 913                 dw Invalid              ; 19h
 914                 dw Invalid              ; 1Ah
 915                 dw Invalid              ; 1Bh
 916                 dw Invalid              ; 1Ch
 917                 dw Invalid              ; 1Dh
 918                 dw Invalid              ; 1Eh
 919                 dw Invalid              ; 1Fh
 920                 dw Invalid              ; 20h
 921                 dw ReadMult             ; 21h - READ MULTIPLE
 922                 dw WriteMult            ; 22h - WRITE MULTIPLE
 923                 dw SetMode              ; 23h - SET CONTROLLER FEATURES
 924                 dw SetMode              ; 24h - SET MULTIPLE MODE
 925                 dw Invalid              ; 25h - IDENTIFY DRIVE
 926                 dw Invalid              ; 26h
 927                 dw Invalid              ; 27h
 928                 dw Invalid              ; 28h
 929                 dw Invalid              ; 29h
 930                 dw Invalid              ; 2Ah
 931                 dw Invalid              ; 2Bh
 932                 dw Invalid              ; 2Ch
 933                 dw Invalid              ; 2Dh
 934                 dw Invalid              ; 2Eh
 935                 dw Invalid              ; 2Fh
 936                 dw Invalid              ; 30h
 937                 dw Invalid              ; 31h
 938                 dw Invalid              ; 32h
 939                 dw Invalid              ; 33h
 940                 dw Invalid              ; 34h
 941                 dw Invalid              ; 35h
 942                 dw Invalid              ; 36h
 943                 dw Invalid              ; 37h
 944                 dw Invalid              ; 38h
 945                 dw Invalid              ; 39h
 946                 dw Invalid              ; 3Ah
 947                 dw Invalid              ; 3Bh
 948                 dw Invalid              ; 3Ch
 949                 dw Invalid              ; 3Dh
 950                 dw Invalid              ; 3Eh
 951                 dw Invalid              ; 3Fh
 952                 dw Invalid              ; 40h
 953                 dw EDDPresence          ; 41h - EDD PRESENCE DETECT
 954                 dw EDDRead              ; 42h - EDD READ
 955                 dw EDDWrite             ; 43h - EDD WRITE
 956                 dw EDDVerify            ; 44h - EDD VERIFY
 957                 dw EDDLock              ; 45h - EDD LOCK/UNLOCK MEDIA
 958                 dw EDDEject             ; 46h - EDD EJECT
 959                 dw EDDSeek              ; 47h - EDD SEEK
 960                 dw EDDGetParms          ; 48h - EDD GET PARAMETERS
 961                 dw EDDDetectChange      ; 49h - EDD MEDIA CHANGE STATUS
 962 %endif
 963
 964 Int13FuncsEnd   equ $
 965 Int13FuncsCnt   equ (Int13FuncsEnd-Int13Funcs) >> 1
 966
 967
 968                 alignb 8, db 0
 969 Shaker          dw ShakerEnd-$-1        ; Descriptor table limit
 970                 dd 0                    ; Pointer to self
 971                 dw 0
 972
 973 Shaker_RMDS:    dd 0x0000ffff           ; 64K data segment
 974                 dd 0x00009300
 975
 976 Shaker_DS:      dd 0x0000ffff           ; 4GB data segment
 977                 dd 0x008f9300
 978
 979 ShakerEnd       equ $
 980
 981                 alignb 8, db 0
 982
 983 Mover           dd 0, 0, 0, 0           ; Must be zero
 984                 dw 0ffffh               ; 64 K segment size
 985 Mover_src1:     db 0, 0, 0              ; Low 24 bits of source addy
 986                 db 93h                  ; Access rights
 987                 db 00h                  ; Extended access rights
 988 Mover_src2:     db 0                    ; High 8 bits of source addy
 989                 dw 0ffffh               ; 64 K segment size
 990 Mover_dst1:     db 0, 0, 0              ; Low 24 bits of target addy
 991                 db 93h                  ; Access rights
 992                 db 00h                  ; Extended access rights
 993 Mover_dst2:     db 0                    ; High 8 bits of source addy
 994 Mover_dummy2:   dd 0, 0, 0, 0           ; More space for the BIOS
 995
 996                 alignb 4, db 0
 997 MemDisk_Info    equ $                   ; Pointed to by installation check
 998 MDI_Bytes       dw MDI_Len              ; Total bytes in MDI structure
 999 MDI_Version     db VERSION_MINOR, VERSION_MAJOR ; MEMDISK version
1000
1001 PatchArea       equ $                   ; This gets filled in by the installer
1002
1003 DiskBuf         dd 0                    ; Linear address of high memory disk
1004 DiskSize        dd 0                    ; Size of disk in blocks
1005 CommandLine     dw 0, 0                 ; Far pointer to saved command line
1006
1007 OldInt13        dd 0                    ; INT 13h in chain
1008 OldInt15        dd 0                    ; INT 15h in chain
1009
1010 OldDosMem       dw 0                    ; Old position of DOS mem end
1011 BootLoaderID    db 0                    ; Boot loader ID from header
1012                 db 0                    ; pad
1013
1014 DPT_ptr         dw 0                    ; If nonzero, pointer to DPT
1015                                         ; Original DPT pointer follows
1016
1017 MDI_Len         equ $-MemDisk_Info
1018
1019 ; ---- MDI structure ends here ---
1020 MemInt1588      dw 0                    ; 1MB-65MB memory amount (1K)
1021
1022 Cylinders       dw 0                    ; Cylinder count
1023 Heads           dw 0                    ; Head count
1024 Sectors         dd 0                    ; Sector count (zero-extended)
1025
1026 Mem1MB          dd 0                    ; 1MB-16MB memory amount (1K)
1027 Mem16MB         dd 0                    ; 16MB-4G memory amount (64K)
1028
1029 DriveNo         db 0                    ; Our drive number
1030 DriveType       db 0                    ; Our drive type (floppies)
1031 DriveCnt        db 0                    ; Drive count (from the BIOS)
1032
1033 ConfigFlags     db 0                    ; Bit 0 - readonly
1034
1035 MyStack         dw 0                    ; Offset of stack
1036 StatusPtr       dw 0                    ; Where to save status (zeroseg ptr)
1037
1038 DPT             times 16 db 0           ; BIOS parameter table pointer (floppies)
1039 OldInt1E        dd 0                    ; Previous INT 1E pointer (DPT)
1040
1041 %if EDD
1042 EDD_DPT:
1043 .length         dw 30
1044 .info           dw 0029h
1045                 ; Bit 0 - DMA boundaries handled transparently
1046                 ; Bit 3 - Device supports write verify
1047                 ; Bit 5 - Media is lockable
1048 .cylinders      dd 0                    ; Filled in by installer
1049 .heads          dd 0                    ; Filled in by installer
1050 .sectors        dd 0                    ; Filled in by installer
1051 .totalsize      dd 0, 0                 ; Filled in by installer
1052 .bytespersec    dw SECTORSIZE
1053 .eddtable       dw -1, -1               ; Invalid DPTE pointer
1054 .dpikey         dw 0BEDDh               ; Device Path Info magic
1055 .dpilen         db 2ch                  ; DPI len
1056 .res1           db 0                    ; Reserved
1057 .res2           dw 0                    ; Reserved
1058 .bustype        dd 'MEM '               ; Host bus type (4 bytes, space padded)
1059 .inttype        dd 'MEMORY  '           ; Interface type (8 bytes, spc. padded)
1060 .intpath        dd 0, 0                 ; Interface path
1061 .devpath        dd 0, 0, 0, 0           ; Device path
1062 .res3           db 0                    ; Reserved
1063 .chksum         db 0                    ; DPI checksum
1064
1065 %endif
1066
1067                 ; End patch area
1068                 alignb 4, db 0
1069 Stack           dd 0                    ; Saved SS:ESP on invocation
1070                 dw 0
1071 SavedAX         dw 0                    ; AX saved on invocation
1072 Recursive       dw 0                    ; Recursion counter
1073
1074                 alignb 4, db 0          ; We *MUST* end on a dword boundary
1075
1076 E820Table       equ $                   ; The installer loads the E820 table here
1077 TotalSize       equ $                   ; End pointer