DuetPkg/BootSector/start.asm

   1 ;------------------------------------------------------------------------------
   2 ;*
   3 ;*   Copyright 2006 - 2007, Intel Corporation
   4 ;*   All rights reserved. This program and the accompanying materials
   5 ;*   are licensed and made available under the terms and conditions of the BSD License
   6 ;*   which accompanies this distribution.  The full text of the license may be found at
   7 ;*   http://opensource.org/licenses/bsd-license.php
   8 ;*
   9 ;*   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 ;*   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11 ;*
  12 ;*    start.asm
  13 ;*
  14 ;*   Abstract:
  15 ;*
  16 ;------------------------------------------------------------------------------
  17
  18         .model  small
  19         .stack
  20         .486p
  21         .code
  22
  23 FAT_DIRECTORY_ENTRY_SIZE    EQU     020h
  24 FAT_DIRECTORY_ENTRY_SHIFT   EQU     5
  25 BLOCK_SIZE                  EQU     0200h
  26 BLOCK_MASK                  EQU     01ffh
  27 BLOCK_SHIFT                 EQU     9
  28
  29         org 0h
  30 Ia32Jump:
  31   jmp   BootSectorEntryPoint  ; JMP inst    - 3 bytes
  32   nop
  33
  34 OemId             db  "INTEL   "    ; OemId               - 8 bytes
  35
  36 SectorSize        dw  0             ; Sector Size         - 16 bits
  37 SectorsPerCluster db  0             ; Sector Per Cluster  - 8 bits
  38 ReservedSectors   dw  0             ; Reserved Sectors    - 16 bits
  39 NoFats            db  0             ; Number of FATs      - 8 bits
  40 RootEntries       dw  0             ; Root Entries        - 16 bits
  41 Sectors           dw  0             ; Number of Sectors   - 16 bits
  42 Media             db  0             ; Media               - 8 bits  - ignored
  43 SectorsPerFat     dw  0             ; Sectors Per FAT     - 16 bits
  44 SectorsPerTrack   dw  0             ; Sectors Per Track   - 16 bits - ignored
  45 Heads             dw  0             ; Heads               - 16 bits - ignored
  46 HiddenSectors     dd  0             ; Hidden Sectors      - 32 bits - ignored
  47 LargeSectors      dd  0             ; Large Sectors       - 32 bits
  48 PhysicalDrive     db  0             ; PhysicalDriveNumber - 8 bits  - ignored
  49 CurrentHead       db  0             ; Current Head        - 8 bits
  50 Signature         db  0             ; Signature           - 8 bits  - ignored
  51 VolId             db  "    "        ; Volume Serial Number- 4 bytes
  52 FatLabel          db  "           " ; Label               - 11 bytes
  53 SystemId          db  "FAT12   "    ; SystemId            - 8 bytes
  54
  55 BootSectorEntryPoint:
  56         ASSUME  ds:@code
  57         ASSUME  ss:@code
  58       ; ds = 1000, es = 2000 + x (size of first cluster >> 4)
  59       ; cx = Start Cluster of EfiLdr
  60       ; dx = Start Cluster of Efivar.bin
  61
  62 ; Re use the BPB data stored in Boot Sector
  63         mov     bp,07c00h
  64
  65         push    cx
  66 ; Read Efivar.bin
  67 ;       1000:dx    = DirectoryEntry of Efivar.bin -> BS.com has filled already
  68         mov     ax,01900h
  69         mov     es,ax
  70         test    dx,dx
  71         jnz     CheckVarStoreSize
  72
  73         mov     al,1
  74 NoVarStore:
  75         push    es
  76 ; Set the 5th byte start @ 0:19000 to non-zero indicating we should init var store header in DxeIpl
  77         mov     byte ptr es:[4],al
  78         jmp     SaveVolumeId
  79
  80 CheckVarStoreSize:
  81         mov     di,dx
  82         cmp     dword ptr ds:[di+2], 04000h
  83         mov     al,2
  84         jne     NoVarStore
  85
  86 LoadVarStore:
  87         mov     al,0
  88         mov     byte ptr es:[4],al
  89         mov     cx,word ptr[di]
  90 ;       ES:DI = 1500:0
  91         xor     di,di
  92         push    es
  93         mov     ax,01500h
  94         mov     es,ax
  95         call    ReadFile
  96 SaveVolumeId:
  97         pop     es
  98         mov     ax,word ptr [bp+VolId]
  99         mov     word ptr es:[0],ax                  ; Save Volume Id to 0:19000. we will find the correct volume according to this VolumeId
 100         mov     ax,word ptr [bp+VolId+2]
 101         mov     word ptr es:[2],ax
 102
 103 ; Read Efildr
 104         pop     cx
 105 ;       cx    = Start Cluster of Efildr -> BS.com has filled already
 106 ;       ES:DI = 2000:0, first cluster will be read again
 107         xor     di,di                               ; di = 0
 108         mov     ax,02000h
 109         mov     es,ax
 110         call    ReadFile
 111         mov     ax,cs
 112         mov     word ptr cs:[JumpSegment],ax
 113
 114 JumpFarInstruction:
 115         db      0eah
 116 JumpOffset:
 117         dw      0200h
 118 JumpSegment:
 119         dw      2000h
 120
 121
 122
 123 ; ****************************************************************************
 124 ; ReadFile
 125 ;
 126 ; Arguments:
 127 ;   CX    = Start Cluster of File
 128 ;   ES:DI = Buffer to store file content read from disk
 129 ;
 130 ; Return:
 131 ;   (ES << 4 + DI) = end of file content Buffer
 132 ;
 133 ; ****************************************************************************
 134 ReadFile:
 135 ; si      = NumberOfClusters
 136 ; cx      = ClusterNumber
 137 ; dx      = CachedFatSectorNumber
 138 ; ds:0000 = CacheFatSectorBuffer
 139 ; es:di   = Buffer to load file
 140 ; bx      = NextClusterNumber
 141         pusha
 142         mov     si,1                                ; NumberOfClusters = 1
 143         push    cx                                  ; Push Start Cluster onto stack
 144         mov     dx,0fffh                            ; CachedFatSectorNumber = 0xfff
 145 FatChainLoop:
 146         mov     ax,cx                               ; ax = ClusterNumber
 147         and     ax,0ff8h                            ; ax = ax & 0xff8
 148         cmp     ax,0ff8h                            ; See if this is the last cluster
 149         je      FoundLastCluster                    ; Jump if last cluster found
 150         mov     ax,cx                               ; ax = ClusterNumber
 151         shl     ax,1                                ; ax = ClusterNumber * 2
 152         add     ax,cx                               ; ax = ClusterNumber * 2 + ClusterNumber = ClusterNumber * 3
 153         shr     ax,1                                ; FatOffset = ClusterNumber*3 / 2
 154         push    si                                  ; Save si
 155         mov     si,ax                               ; si = FatOffset
 156         shr     ax,BLOCK_SHIFT                      ; ax = FatOffset >> BLOCK_SHIFT
 157         add     ax,word ptr [bp+ReservedSectors]    ; ax = FatSectorNumber = ReservedSectors + (FatOffset >> BLOCK_OFFSET)
 158         and     si,BLOCK_MASK                       ; si = FatOffset & BLOCK_MASK
 159         cmp     ax,dx                               ; Compare FatSectorNumber to CachedFatSectorNumber
 160         je      SkipFatRead
 161         mov     bx,2
 162         push    es
 163         push    ds
 164         pop     es
 165         call    ReadBlocks                          ; Read 2 blocks starting at AX storing at ES:DI
 166         pop     es
 167         mov     dx,ax                               ; CachedFatSectorNumber = FatSectorNumber
 168 SkipFatRead:
 169         mov     bx,word ptr [si]                    ; bx = NextClusterNumber
 170         mov     ax,cx                               ; ax = ClusterNumber
 171         and     ax,1                                ; See if this is an odd cluster number
 172         je      EvenFatEntry
 173         shr     bx,4                                ; NextClusterNumber = NextClusterNumber >> 4
 174 EvenFatEntry:
 175         and     bx,0fffh                            ; Strip upper 4 bits of NextClusterNumber
 176         pop     si                                  ; Restore si
 177         dec     bx                                  ; bx = NextClusterNumber - 1
 178         cmp     bx,cx                               ; See if (NextClusterNumber-1)==ClusterNumber
 179         jne     ReadClusters
 180         inc     bx                                  ; bx = NextClusterNumber
 181         inc     si                                  ; NumberOfClusters++
 182         mov     cx,bx                               ; ClusterNumber = NextClusterNumber
 183         jmp     FatChainLoop
 184 ReadClusters:
 185         inc     bx
 186         pop     ax                                  ; ax = StartCluster
 187         push    bx                                  ; StartCluster = NextClusterNumber
 188         mov     cx,bx                               ; ClusterNumber = NextClusterNumber
 189         sub     ax,2                                ; ax = StartCluster - 2
 190         xor     bh,bh
 191         mov     bl,byte ptr [bp+SectorsPerCluster]  ; bx = SectorsPerCluster
 192         mul     bx                                  ; ax = (StartCluster - 2) * SectorsPerCluster
 193         add     ax, word ptr [bp]                   ; ax = FirstClusterLBA + (StartCluster-2)*SectorsPerCluster
 194         push    ax                                  ; save start sector
 195         mov     ax,si                               ; ax = NumberOfClusters
 196         mul     bx                                  ; ax = NumberOfClusters * SectorsPerCluster
 197         mov     bx,ax                               ; bx = Number of Sectors
 198         pop     ax                                  ; ax = Start Sector
 199         call    ReadBlocks
 200         mov     si,1                                ; NumberOfClusters = 1
 201         jmp     FatChainLoop
 202 FoundLastCluster:
 203         pop     cx
 204         popa
 205         ret
 206
 207
 208 ; ****************************************************************************
 209 ; ReadBlocks - Reads a set of blocks from a block device
 210 ;
 211 ; AX    = Start LBA
 212 ; BX    = Number of Blocks to Read
 213 ; ES:DI = Buffer to store sectors read from disk
 214 ; ****************************************************************************
 215
 216 ; cx = Blocks
 217 ; bx = NumberOfBlocks
 218 ; si = StartLBA
 219
 220 ReadBlocks:
 221         pusha
 222         add     eax,dword ptr [bp+LBAOffsetForBootSector]    ; Add LBAOffsetForBootSector to Start LBA
 223         add     eax,dword ptr [bp+HiddenSectors]    ; Add HiddenSectors to Start LBA
 224         mov     esi,eax                             ; esi = Start LBA
 225         mov     cx,bx                               ; cx = Number of blocks to read
 226 ReadCylinderLoop:
 227         mov     bp,07bfch                           ; bp = 0x7bfc
 228         mov     eax,esi                             ; eax = Start LBA
 229         xor     edx,edx                             ; edx = 0
 230         movzx   ebx,word ptr [bp]                   ; bx = MaxSector
 231         div     ebx                                 ; ax = StartLBA / MaxSector
 232         inc     dx                                  ; dx = (StartLBA % MaxSector) + 1
 233
 234         mov     bx,word ptr [bp]                    ; bx = MaxSector
 235         sub     bx,dx                               ; bx = MaxSector - Sector
 236         inc     bx                                  ; bx = MaxSector - Sector + 1
 237         cmp     cx,bx                               ; Compare (Blocks) to (MaxSector - Sector + 1)
 238         jg      LimitTransfer
 239         mov     bx,cx                               ; bx = Blocks
 240 LimitTransfer:
 241         push    ax                                  ; save ax
 242         mov     ax,es                               ; ax = es
 243         shr     ax,(BLOCK_SHIFT-4)                  ; ax = Number of blocks into mem system
 244         and     ax,07fh                             ; ax = Number of blocks into current seg
 245         add     ax,bx                               ; ax = End Block number of transfer
 246         cmp     ax,080h                             ; See if it crosses a 64K boundry
 247         jle     NotCrossing64KBoundry               ; Branch if not crossing 64K boundry
 248         sub     ax,080h                             ; ax = Number of blocks past 64K boundry
 249         sub     bx,ax                               ; Decrease transfer size by block overage
 250 NotCrossing64KBoundry:
 251         pop     ax                                  ; restore ax
 252
 253         push    cx
 254         mov     cl,dl                               ; cl = (StartLBA % MaxSector) + 1 = Sector
 255         xor     dx,dx                               ; dx = 0
 256         div     word ptr [bp+2]                     ; ax = ax / (MaxHead + 1) = Cylinder
 257                                                     ; dx = ax % (MaxHead + 1) = Head
 258
 259         push    bx                                  ; Save number of blocks to transfer
 260         mov     dh,dl                               ; dh = Head
 261         mov     bp,07c00h                           ; bp = 0x7c00
 262         mov     dl,byte ptr [bp+PhysicalDrive]      ; dl = Drive Number
 263         mov     ch,al                               ; ch = Cylinder
 264         mov     al,bl                               ; al = Blocks
 265         mov     ah,2                                ; ah = Function 2
 266         mov     bx,di                               ; es:bx = Buffer address
 267         int     013h
 268         jc      DiskError
 269         pop     bx
 270         pop     cx
 271         movzx   ebx,bx
 272         add     esi,ebx                             ; StartLBA = StartLBA + NumberOfBlocks
 273         sub     cx,bx                               ; Blocks = Blocks - NumberOfBlocks
 274         mov     ax,es
 275         shl     bx,(BLOCK_SHIFT-4)
 276         add     ax,bx
 277         mov     es,ax                               ; es:di = es:di + NumberOfBlocks*BLOCK_SIZE
 278         cmp     cx,0
 279         jne     ReadCylinderLoop
 280         popa
 281         ret
 282
 283 DiskError:
 284         push cs
 285         pop  ds
 286         lea  si, [ErrorString]
 287         mov  cx, 7
 288         jmp  PrintStringAndHalt
 289
 290 PrintStringAndHalt:
 291         mov  ax,0b800h
 292         mov  es,ax
 293         mov  di,160
 294         rep  movsw
 295 Halt:
 296         jmp   Halt
 297
 298 ErrorString:
 299         db 'S', 0ch, 'E', 0ch, 'r', 0ch, 'r', 0ch, 'o', 0ch, 'r', 0ch, '!', 0ch
 300
 301         org     01fah
 302 LBAOffsetForBootSector:
 303         dd      0h
 304
 305         org     01feh
 306         dw      0aa55h
 307
 308 ;******************************************************************************
 309 ;******************************************************************************
 310 ;******************************************************************************
 311
 312 DELAY_PORT           equ     0edh    ; Port to use for 1uS delay
 313 KBD_CONTROL_PORT     equ     060h    ; 8042 control port
 314 KBD_STATUS_PORT      equ     064h    ; 8042 status port
 315 WRITE_DATA_PORT_CMD  equ     0d1h    ; 8042 command to write the data port
 316 ENABLE_A20_CMD       equ     0dfh    ; 8042 command to enable A20
 317
 318         org     200h
 319         jmp start
 320 Em64String:
 321         db 'E', 0ch, 'm', 0ch, '6', 0ch, '4', 0ch, 'T', 0ch, ' ', 0ch, 'U', 0ch, 'n', 0ch, 's', 0ch, 'u', 0ch, 'p', 0ch, 'p', 0ch, 'o', 0ch, 'r', 0ch, 't', 0ch, 'e', 0ch, 'd', 0ch, '!', 0ch
 322
 323 start:
 324         mov ax,cs
 325         mov ds,ax
 326         mov es,ax
 327         mov ss,ax
 328         mov sp,MyStack
 329
 330 ;        mov ax,0b800h
 331 ;        mov es,ax
 332 ;        mov byte ptr es:[160],'a'
 333 ;        mov ax,cs
 334 ;        mov es,ax
 335
 336         mov ebx,0
 337         lea edi,MemoryMap
 338 MemMapLoop:
 339         mov eax,0e820h
 340         mov ecx,20
 341         mov edx,'SMAP'
 342         int 15h
 343         jc  MemMapDone
 344         add edi,20
 345         cmp ebx,0
 346         je  MemMapDone
 347         jmp MemMapLoop
 348 MemMapDone:
 349         lea eax,MemoryMap
 350         sub edi,eax                         ; Get the address of the memory map
 351         mov dword ptr [MemoryMapSize],edi   ; Save the size of the memory map
 352
 353         xor     ebx,ebx
 354         mov     bx,cs                       ; BX=segment
 355         shl     ebx,4                       ; BX="linear" address of segment base
 356         lea     eax,[GDT_BASE + ebx]        ; EAX=PHYSICAL address of gdt
 357         mov     dword ptr [gdtr + 2],eax    ; Put address of gdt into the gdtr
 358         lea     eax,[IDT_BASE + ebx]        ; EAX=PHYSICAL address of idt
 359         mov     dword ptr [idtr + 2],eax    ; Put address of idt into the idtr
 360         lea     edx,[MemoryMapSize + ebx]   ; Physical base address of the memory map
 361
 362         add ebx,01000h                      ; Source of EFI32
 363         mov dword ptr [JUMP+2],ebx
 364         add ebx,01000h
 365         mov esi,ebx                         ; Source of EFILDR32
 366
 367 ;        mov ax,0b800h
 368 ;        mov es,ax
 369 ;        mov byte ptr es:[162],'b'
 370 ;        mov ax,cs
 371 ;        mov es,ax
 372
 373 ;
 374 ; Enable A20 Gate
 375 ;
 376
 377         mov ax,2401h                        ; Enable A20 Gate
 378         int 15h
 379         jnc A20GateEnabled                  ; Jump if it suceeded
 380
 381 ;
 382 ; If INT 15 Function 2401 is not supported, then attempt to Enable A20 manually.
 383 ;
 384
 385         call    Empty8042InputBuffer        ; Empty the Input Buffer on the 8042 controller
 386         jnz     Timeout8042                 ; Jump if the 8042 timed out
 387         out     DELAY_PORT,ax               ; Delay 1 uS
 388         mov     al,WRITE_DATA_PORT_CMD      ; 8042 cmd to write output port
 389         out     KBD_STATUS_PORT,al          ; Send command to the 8042
 390         call    Empty8042InputBuffer        ; Empty the Input Buffer on the 8042 controller
 391         jnz     Timeout8042                 ; Jump if the 8042 timed out
 392         mov     al,ENABLE_A20_CMD           ; gate address bit 20 on
 393         out     KBD_CONTROL_PORT,al         ; Send command to thre 8042
 394         call    Empty8042InputBuffer        ; Empty the Input Buffer on the 8042 controller
 395         mov     cx,25                       ; Delay 25 uS for the command to complete on the 8042
 396 Delay25uS:
 397         out     DELAY_PORT,ax               ; Delay 1 uS
 398         loop    Delay25uS
 399 Timeout8042:
 400
 401
 402 A20GateEnabled:
 403
 404 ;
 405 ; DISABLE INTERRUPTS - Entering Protected Mode
 406 ;
 407
 408         cli
 409
 410 ;        mov ax,0b800h
 411 ;        mov es,ax
 412 ;        mov byte ptr es:[164],'c'
 413 ;        mov ax,cs
 414 ;        mov es,ax
 415
 416         db      66h
 417         lgdt    fword ptr [gdtr]
 418         db      66h
 419         lidt    fword ptr [idtr]
 420
 421         mov     eax,cr0
 422         or      al,1
 423         mov     cr0,eax
 424
 425         mov eax,0008h                       ; Flat data descriptor
 426         mov ebp,000400000h                  ; Destination of EFILDR32
 427         mov ebx,000070000h                  ; Length of copy
 428
 429 JUMP:
 430 ; jmp far 0010:00020000
 431         db  066h
 432         db  0eah
 433         dd  000020000h
 434         dw  00010h
 435
 436 Empty8042InputBuffer:
 437         mov cx,0
 438 Empty8042Loop:
 439         out     DELAY_PORT,ax               ; Delay 1us
 440         in      al,KBD_STATUS_PORT          ; Read the 8042 Status Port
 441         and     al,02h                      ; Check the Input Buffer Full Flag
 442         loopnz  Empty8042Loop               ; Loop until the input buffer is empty or a timout of 65536 uS
 443         ret
 444
 445 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 446 ; data
 447 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 448
 449         align 02h
 450
 451 gdtr    dw GDT_END - GDT_BASE - 1   ; GDT limit
 452         dd 0                        ; (GDT base gets set above)
 453 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 454 ;   global descriptor table (GDT)
 455 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 456
 457         align 02h
 458
 459 public GDT_BASE
 460 GDT_BASE:
 461 ; null descriptor
 462 NULL_SEL            equ $-GDT_BASE
 463         dw 0            ; limit 15:0
 464         dw 0            ; base 15:0
 465         db 0            ; base 23:16
 466         db 0            ; type
 467         db 0            ; limit 19:16, flags
 468         db 0            ; base 31:24
 469
 470 ; linear data segment descriptor
 471 LINEAR_SEL      equ $-GDT_BASE
 472         dw 0FFFFh       ; limit 0xFFFFF
 473         dw 0            ; base 0
 474         db 0
 475         db 092h         ; present, ring 0, data, expand-up, writable
 476         db 0CFh                 ; page-granular, 32-bit
 477         db 0
 478
 479 ; linear code segment descriptor
 480 LINEAR_CODE_SEL equ $-GDT_BASE
 481         dw 0FFFFh       ; limit 0xFFFFF
 482         dw 0            ; base 0
 483         db 0
 484         db 09Ah         ; present, ring 0, data, expand-up, writable
 485         db 0CFh                 ; page-granular, 32-bit
 486         db 0
 487
 488 ; system data segment descriptor
 489 SYS_DATA_SEL    equ $-GDT_BASE
 490         dw 0FFFFh       ; limit 0xFFFFF
 491         dw 0            ; base 0
 492         db 0
 493         db 092h         ; present, ring 0, data, expand-up, writable
 494         db 0CFh                 ; page-granular, 32-bit
 495         db 0
 496
 497 ; system code segment descriptor
 498 SYS_CODE_SEL    equ $-GDT_BASE
 499         dw 0FFFFh       ; limit 0xFFFFF
 500         dw 0            ; base 0
 501         db 0
 502         db 09Ah         ; present, ring 0, data, expand-up, writable
 503         db 0CFh                 ; page-granular, 32-bit
 504         db 0
 505
 506 ; spare segment descriptor
 507 SPARE3_SEL  equ $-GDT_BASE
 508         dw 0            ; limit 0xFFFFF
 509         dw 0            ; base 0
 510         db 0
 511         db 0            ; present, ring 0, data, expand-up, writable
 512         db 0            ; page-granular, 32-bit
 513         db 0
 514
 515 ; spare segment descriptor
 516 SPARE4_SEL  equ $-GDT_BASE
 517         dw 0            ; limit 0xFFFFF
 518         dw 0            ; base 0
 519         db 0
 520         db 0            ; present, ring 0, data, expand-up, writable
 521         db 0            ; page-granular, 32-bit
 522         db 0
 523
 524 ; spare segment descriptor
 525 SPARE5_SEL  equ $-GDT_BASE
 526         dw 0            ; limit 0xFFFFF
 527         dw 0            ; base 0
 528         db 0
 529         db 0            ; present, ring 0, data, expand-up, writable
 530         db 0            ; page-granular, 32-bit
 531         db 0
 532
 533 GDT_END:
 534
 535         align 02h
 536
 537
 538
 539 idtr            dw IDT_END - IDT_BASE - 1   ; IDT limit
 540         dd 0                        ; (IDT base gets set above)
 541 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 542 ;   interrupt descriptor table (IDT)
 543 ;
 544 ;   Note: The hardware IRQ's specified in this table are the normal PC/AT IRQ
 545 ;       mappings.  This implementation only uses the system timer and all other
 546 ;       IRQs will remain masked.  The descriptors for vectors 33+ are provided
 547 ;       for convenience.
 548 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 549
 550 ;idt_tag db "IDT",0
 551         align 02h
 552
 553 public IDT_BASE
 554 IDT_BASE:
 555 ; divide by zero (INT 0)
 556 DIV_ZERO_SEL        equ $-IDT_BASE
 557         dw 0            ; offset 15:0
 558         dw SYS_CODE_SEL ; selector 15:0
 559         db 0            ; 0 for interrupt gate
 560         db 0eh OR 80h   ; type = 386 interrupt gate, present
 561         dw 0            ; offset 31:16
 562
 563 ; debug exception (INT 1)
 564 DEBUG_EXCEPT_SEL    equ $-IDT_BASE
 565         dw 0            ; offset 15:0
 566         dw SYS_CODE_SEL ; selector 15:0
 567         db 0            ; 0 for interrupt gate
 568         db 0eh OR 80h   ; type = 386 interrupt gate, present
 569         dw 0            ; offset 31:16
 570
 571 ; NMI (INT 2)
 572 NMI_SEL             equ $-IDT_BASE
 573         dw 0            ; offset 15:0
 574         dw SYS_CODE_SEL ; selector 15:0
 575         db 0            ; 0 for interrupt gate
 576         db 0eh OR 80h   ; type = 386 interrupt gate, present
 577         dw 0            ; offset 31:16
 578
 579 ; soft breakpoint (INT 3)
 580 BREAKPOINT_SEL      equ $-IDT_BASE
 581         dw 0            ; offset 15:0
 582         dw SYS_CODE_SEL ; selector 15:0
 583         db 0            ; 0 for interrupt gate
 584         db 0eh OR 80h   ; type = 386 interrupt gate, present
 585         dw 0            ; offset 31:16
 586
 587 ; overflow (INT 4)
 588 OVERFLOW_SEL        equ $-IDT_BASE
 589         dw 0            ; offset 15:0
 590         dw SYS_CODE_SEL ; selector 15:0
 591         db 0            ; 0 for interrupt gate
 592         db 0eh OR 80h   ; type = 386 interrupt gate, present
 593         dw 0            ; offset 31:16
 594
 595 ; bounds check (INT 5)
 596 BOUNDS_CHECK_SEL    equ $-IDT_BASE
 597         dw 0            ; offset 15:0
 598         dw SYS_CODE_SEL ; selector 15:0
 599         db 0            ; 0 for interrupt gate
 600         db 0eh OR 80h   ; type = 386 interrupt gate, present
 601         dw 0            ; offset 31:16
 602
 603 ; invalid opcode (INT 6)
 604 INVALID_OPCODE_SEL  equ $-IDT_BASE
 605         dw 0            ; offset 15:0
 606         dw SYS_CODE_SEL ; selector 15:0
 607         db 0            ; 0 for interrupt gate
 608         db 0eh OR 80h   ; type = 386 interrupt gate, present
 609         dw 0            ; offset 31:16
 610
 611 ; device not available (INT 7)
 612 DEV_NOT_AVAIL_SEL   equ $-IDT_BASE
 613         dw 0            ; offset 15:0
 614         dw SYS_CODE_SEL ; selector 15:0
 615         db 0            ; 0 for interrupt gate
 616         db 0eh OR 80h   ; type = 386 interrupt gate, present
 617         dw 0            ; offset 31:16
 618
 619 ; double fault (INT 8)
 620 DOUBLE_FAULT_SEL    equ $-IDT_BASE
 621         dw 0            ; offset 15:0
 622         dw SYS_CODE_SEL ; selector 15:0
 623         db 0            ; 0 for interrupt gate
 624         db 0eh OR 80h   ; type = 386 interrupt gate, present
 625         dw 0            ; offset 31:16
 626
 627 ; Coprocessor segment overrun - reserved (INT 9)
 628 RSVD_INTR_SEL1      equ $-IDT_BASE
 629         dw 0            ; offset 15:0
 630         dw SYS_CODE_SEL ; selector 15:0
 631         db 0            ; 0 for interrupt gate
 632         db 0eh OR 80h   ; type = 386 interrupt gate, present
 633         dw 0            ; offset 31:16
 634
 635 ; invalid TSS (INT 0ah)
 636 INVALID_TSS_SEL     equ $-IDT_BASE
 637         dw 0            ; offset 15:0
 638         dw SYS_CODE_SEL ; selector 15:0
 639         db 0            ; 0 for interrupt gate
 640         db 0eh OR 80h   ; type = 386 interrupt gate, present
 641         dw 0            ; offset 31:16
 642
 643 ; segment not present (INT 0bh)
 644 SEG_NOT_PRESENT_SEL equ $-IDT_BASE
 645         dw 0            ; offset 15:0
 646         dw SYS_CODE_SEL ; selector 15:0
 647         db 0            ; 0 for interrupt gate
 648         db 0eh OR 80h   ; type = 386 interrupt gate, present
 649         dw 0            ; offset 31:16
 650
 651 ; stack fault (INT 0ch)
 652 STACK_FAULT_SEL     equ $-IDT_BASE
 653         dw 0            ; offset 15:0
 654         dw SYS_CODE_SEL ; selector 15:0
 655         db 0            ; 0 for interrupt gate
 656         db 0eh OR 80h   ; type = 386 interrupt gate, present
 657         dw 0            ; offset 31:16
 658
 659 ; general protection (INT 0dh)
 660 GP_FAULT_SEL        equ $-IDT_BASE
 661         dw 0            ; offset 15:0
 662         dw SYS_CODE_SEL ; selector 15:0
 663         db 0            ; 0 for interrupt gate
 664         db 0eh OR 80h   ; type = 386 interrupt gate, present
 665         dw 0            ; offset 31:16
 666
 667 ; page fault (INT 0eh)
 668 PAGE_FAULT_SEL      equ $-IDT_BASE
 669         dw 0            ; offset 15:0
 670         dw SYS_CODE_SEL ; selector 15:0
 671         db 0            ; 0 for interrupt gate
 672         db 0eh OR 80h   ; type = 386 interrupt gate, present
 673         dw 0            ; offset 31:16
 674
 675 ; Intel reserved - do not use (INT 0fh)
 676 RSVD_INTR_SEL2      equ $-IDT_BASE
 677         dw 0            ; offset 15:0
 678         dw SYS_CODE_SEL ; selector 15:0
 679         db 0            ; 0 for interrupt gate
 680         db 0eh OR 80h   ; type = 386 interrupt gate, present
 681         dw 0            ; offset 31:16
 682
 683 ; floating point error (INT 10h)
 684 FLT_POINT_ERR_SEL   equ $-IDT_BASE
 685         dw 0            ; offset 15:0
 686         dw SYS_CODE_SEL ; selector 15:0
 687         db 0            ; 0 for interrupt gate
 688         db 0eh OR 80h   ; type = 386 interrupt gate, present
 689         dw 0            ; offset 31:16
 690
 691 ; alignment check (INT 11h)
 692 ALIGNMENT_CHECK_SEL equ $-IDT_BASE
 693         dw 0            ; offset 15:0
 694         dw SYS_CODE_SEL ; selector 15:0
 695         db 0            ; 0 for interrupt gate
 696         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 697         dw 0            ; offset 31:16
 698
 699 ; machine check (INT 12h)
 700 MACHINE_CHECK_SEL   equ $-IDT_BASE
 701         dw 0            ; offset 15:0
 702         dw SYS_CODE_SEL ; selector 15:0
 703         db 0            ; 0 for interrupt gate
 704         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 705         dw 0            ; offset 31:16
 706
 707 ; SIMD floating-point exception (INT 13h)
 708 SIMD_EXCEPTION_SEL  equ $-IDT_BASE
 709         dw 0            ; offset 15:0
 710         dw SYS_CODE_SEL ; selector 15:0
 711         db 0            ; 0 for interrupt gate
 712         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 713         dw 0            ; offset 31:16
 714
 715 ; 85 unspecified descriptors, First 12 of them are reserved, the rest are avail
 716         db (85 * 8) dup(0)
 717
 718 ; IRQ 0 (System timer) - (INT 68h)
 719 IRQ0_SEL            equ $-IDT_BASE
 720         dw 0            ; offset 15:0
 721         dw SYS_CODE_SEL ; selector 15:0
 722         db 0            ; 0 for interrupt gate
 723         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 724         dw 0            ; offset 31:16
 725
 726 ; IRQ 1 (8042 Keyboard controller) - (INT 69h)
 727 IRQ1_SEL            equ $-IDT_BASE
 728         dw 0            ; offset 15:0
 729         dw SYS_CODE_SEL ; selector 15:0
 730         db 0            ; 0 for interrupt gate
 731         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 732         dw 0            ; offset 31:16
 733
 734 ; Reserved - IRQ 2 redirect (IRQ 2) - DO NOT USE!!! - (INT 6ah)
 735 IRQ2_SEL            equ $-IDT_BASE
 736         dw 0            ; offset 15:0
 737         dw SYS_CODE_SEL ; selector 15:0
 738         db 0            ; 0 for interrupt gate
 739         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 740         dw 0            ; offset 31:16
 741
 742 ; IRQ 3 (COM 2) - (INT 6bh)
 743 IRQ3_SEL            equ $-IDT_BASE
 744         dw 0            ; offset 15:0
 745         dw SYS_CODE_SEL ; selector 15:0
 746         db 0            ; 0 for interrupt gate
 747         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 748         dw 0            ; offset 31:16
 749
 750 ; IRQ 4 (COM 1) - (INT 6ch)
 751 IRQ4_SEL            equ $-IDT_BASE
 752         dw 0            ; offset 15:0
 753         dw SYS_CODE_SEL ; selector 15:0
 754         db 0            ; 0 for interrupt gate
 755         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 756         dw 0            ; offset 31:16
 757
 758 ; IRQ 5 (LPT 2) - (INT 6dh)
 759 IRQ5_SEL            equ $-IDT_BASE
 760         dw 0            ; offset 15:0
 761         dw SYS_CODE_SEL ; selector 15:0
 762         db 0            ; 0 for interrupt gate
 763         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 764         dw 0            ; offset 31:16
 765
 766 ; IRQ 6 (Floppy controller) - (INT 6eh)
 767 IRQ6_SEL            equ $-IDT_BASE
 768         dw 0            ; offset 15:0
 769         dw SYS_CODE_SEL ; selector 15:0
 770         db 0            ; 0 for interrupt gate
 771         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 772         dw 0            ; offset 31:16
 773
 774 ; IRQ 7 (LPT 1) - (INT 6fh)
 775 IRQ7_SEL            equ $-IDT_BASE
 776         dw 0            ; offset 15:0
 777         dw SYS_CODE_SEL ; selector 15:0
 778         db 0            ; 0 for interrupt gate
 779         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 780         dw 0            ; offset 31:16
 781
 782 ; IRQ 8 (RTC Alarm) - (INT 70h)
 783 IRQ8_SEL            equ $-IDT_BASE
 784         dw 0            ; offset 15:0
 785         dw SYS_CODE_SEL ; selector 15:0
 786         db 0            ; 0 for interrupt gate
 787         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 788         dw 0            ; offset 31:16
 789
 790 ; IRQ 9 - (INT 71h)
 791 IRQ9_SEL            equ $-IDT_BASE
 792         dw 0            ; offset 15:0
 793         dw SYS_CODE_SEL ; selector 15:0
 794         db 0            ; 0 for interrupt gate
 795         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 796         dw 0            ; offset 31:16
 797
 798 ; IRQ 10 - (INT 72h)
 799 IRQ10_SEL            equ $-IDT_BASE
 800         dw 0            ; offset 15:0
 801         dw SYS_CODE_SEL ; selector 15:0
 802         db 0            ; 0 for interrupt gate
 803         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 804         dw 0            ; offset 31:16
 805
 806 ; IRQ 11 - (INT 73h)
 807 IRQ11_SEL            equ $-IDT_BASE
 808         dw 0            ; offset 15:0
 809         dw SYS_CODE_SEL ; selector 15:0
 810         db 0            ; 0 for interrupt gate
 811         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 812         dw 0            ; offset 31:16
 813
 814 ; IRQ 12 (PS/2 mouse) - (INT 74h)
 815 IRQ12_SEL            equ $-IDT_BASE
 816         dw 0            ; offset 15:0
 817         dw SYS_CODE_SEL ; selector 15:0
 818         db 0            ; 0 for interrupt gate
 819         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 820         dw 0            ; offset 31:16
 821
 822 ; IRQ 13 (Floating point error) - (INT 75h)
 823 IRQ13_SEL            equ $-IDT_BASE
 824         dw 0            ; offset 15:0
 825         dw SYS_CODE_SEL ; selector 15:0
 826         db 0            ; 0 for interrupt gate
 827         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 828         dw 0            ; offset 31:16
 829
 830 ; IRQ 14 (Secondary IDE) - (INT 76h)
 831 IRQ14_SEL            equ $-IDT_BASE
 832         dw 0            ; offset 15:0
 833         dw SYS_CODE_SEL ; selector 15:0
 834         db 0            ; 0 for interrupt gate
 835         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 836         dw 0            ; offset 31:16
 837
 838 ; IRQ 15 (Primary IDE) - (INT 77h)
 839 IRQ15_SEL            equ $-IDT_BASE
 840         dw 0            ; offset 15:0
 841         dw SYS_CODE_SEL ; selector 15:0
 842         db 0            ; 0 for interrupt gate
 843         db 0eh OR 80h   ; (10001110)type = 386 interrupt gate, present
 844         dw 0            ; offset 31:16
 845
 846 IDT_END:
 847
 848         align 02h
 849
 850 MemoryMapSize   dd  0
 851 MemoryMap   dd  0,0,0,0,0,0,0,0
 852         dd  0,0,0,0,0,0,0,0
 853         dd  0,0,0,0,0,0,0,0
 854         dd  0,0,0,0,0,0,0,0
 855         dd  0,0,0,0,0,0,0,0
 856         dd  0,0,0,0,0,0,0,0
 857         dd  0,0,0,0,0,0,0,0
 858         dd  0,0,0,0,0,0,0,0
 859         dd  0,0,0,0,0,0,0,0
 860         dd  0,0,0,0,0,0,0,0
 861         dd  0,0,0,0,0,0,0,0
 862         dd  0,0,0,0,0,0,0,0
 863         dd  0,0,0,0,0,0,0,0
 864         dd  0,0,0,0,0,0,0,0
 865         dd  0,0,0,0,0,0,0,0
 866         dd  0,0,0,0,0,0,0,0
 867         dd  0,0,0,0,0,0,0,0
 868         dd  0,0,0,0,0,0,0,0
 869         dd  0,0,0,0,0,0,0,0
 870         dd  0,0,0,0,0,0,0,0
 871         dd  0,0,0,0,0,0,0,0
 872         dd  0,0,0,0,0,0,0,0
 873         dd  0,0,0,0,0,0,0,0
 874         dd  0,0,0,0,0,0,0,0
 875         dd  0,0,0,0,0,0,0,0
 876         dd  0,0,0,0,0,0,0,0
 877         dd  0,0,0,0,0,0,0,0
 878         dd  0,0,0,0,0,0,0,0
 879         dd  0,0,0,0,0,0,0,0
 880         dd  0,0,0,0,0,0,0,0
 881
 882         dd  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 883         dd  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 884
 885         org 0fe0h
 886 MyStack:
 887         ; below is the pieces of the IVT that is used to redirect INT 68h - 6fh
 888         ;    back to INT 08h - 0fh  when in real mode...  It is 'org'ed to a
 889         ;    known low address (20f00) so it can be set up by PlMapIrqToVect in
 890         ;    8259.c
 891
 892         int 8
 893         iret
 894
 895         int 9
 896         iret
 897
 898         int 10
 899         iret
 900
 901         int 11
 902         iret
 903
 904         int 12
 905         iret
 906
 907         int 13
 908         iret
 909
 910         int 14
 911         iret
 912
 913         int 15
 914         iret
 915
 916
 917         org 0ffeh
 918 BlockSignature:
 919         dw  0aa55h
 920
 921         end