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