Книги по Assembler

mov edx, 0x01F6 
shr eax, 24 
or al, 11100000b 
out dx, al
 
mov edx, 0x01F2 
mov al, 100 
out dx, al
 
mov edx, 0x1F3 
mov eax, ebx 
out dx, al
 
mov edx, 0x1F4 
mov eax, ebx 
shr eax, 8
out dx, al
 
 
mov edx, 0x1F5 
mov eax, ebx 
shr eax, 16 
out dx, al

section .text
    use16
    org  0x7C00       ; Boot Loader starts at 0:0x7c00
start:
  jmp boot_code
  db 0x90
BS_OEMName:
  times 8 db ' ' 
BPB_BytsPerSec:     ; 0x0b Bytes per sector 512,1024,2048 or 4096
  dw 0x200
BPB_SecPerClus:     ; 0x0d Sectors per Cluster
  db 0
BPB_RsvdSecCnt:     ; 0x0e Reserved sectors count
  dw 0
BPB_NumFATs:       ; 0x10 FATs number
  db 0
BPB_RootEntCnt:      ; 0x11 (not used for FAT32)
    dw 0
BPB_TotSec16:        ; 0x13 (not used for FAT32)
    dw 0
BPB_Media:           ; 0x15 (not used)
    db 0
BPB_FATSz16:        ; 0x16 (not used for FAT32)
    dw 0
BPB_SecPerTrk:       ; 0x18 (SPT geometry for CHS)
  dw 0
BPB_NumHeads:       ; 0x1a (HPC geometry for CHS)
  dw 0
BPB_HiddSec:         ; 0x1c (Sectors before this partition)
  dd 0
BPB_TotSec32:        ; 0x20 (Total sectors must be !=0 for FAT32)
    dd 0
BPB_FATSz32:        ; 0x24 Sectors count in one FAT
  dd 0
BPB_ExtFlags:         ; 0x28 See Microsoft document
  dw 0
BPB_FSVer:           ; 0x2a Version of FAT32 filesystem
  dw 0
BPB_RootClus:         ; 0x2c Root Directory cluster number
  dd 0
BPB_FSInfo:           ; 0x30 Reserved = 1 usially see doc...
  dw 0
BPB_BkBootSec:       ; 0x32 Sector in reserve area with Boot Sect Copy
  dw 0
BPB_Reserved:
  times 12 db 0
BS_DrvNum:           ; 0x40 Drive number for int 0x13
  db 0
BS_Reserved1:         ; 0x41
  db 0
BS_BootSig:            ; 0x42 0x29 means that next fields present
  db 0
BS_VolID:              ; 0x43 Volume ID 32 bit value
  dd 0
BS_VolLab:             ; 0x47
  times 11 db ' '
BS_FilSysType:         ; 0x52 "FAT32   " 
  db 'FAT32   '
 
; parameter block for read sector
read_sector_data:       ; 0x5a
  dw 0x10
sectors_count:
  dw 0x01
read_offset:
  dw 0x00
read_segment:
  dw 0x80
lba_lo:
  dw 0x00
lba_hi:
  dw 0x00
lba_hihi:
  dw 0x00
  dw 0x00
 
; kernel file name
kernel:
  db 'KERNEL     '
 
boot_code:             ; 0x5a boot code start
  cli
  xor ax, ax
  mov ss, ax
  mov sp, start        ; set stack pointer and segments
  mov bp,sp
  mov ds, ax
  mov es, ax
  sub sp,0x80         ; reserve 0x80 byte for local variables
  sti
; get cluster chain starting from specified
  push dx                ; [ bp - 82 ] BIOS disk number
get_first_data_sector:
  mov eax, [ bp + BPB_FATSz32 - start ]
  movzx ecx, byte [ bp + BPB_NumFATs - start ]
  mul ecx
  movzx ecx, word [ bp + BPB_RsvdSecCnt - start ]
  add ecx, [ bp + BPB_HiddSec - start ]
  push ecx            ; [ bp - 86 ] reserved + hidden
  add eax, ecx
; here 0x2fc0
  push eax            ; [ bp - 8a ] first data sector
calc_sector_size:
    movzx ax, byte [ bp + BPB_SecPerClus - start ]
    push ax             ; [ bp - 0x8c ]  sectors per cluster
    mul word [ bp + BPB_BytsPerSec - start ]
    shr ax, 4
; here 0x400
    push ax             ; [ bp - 0x8e ] segment increment for cluster
;   mov bx,ax
;   shr eax,16
;   call print_regs
;   jmp $
  mov bx, search_kernel_file
  call read_cluster_chain
  jc error
; we have the kernel here
; initialize segment where to write kernel data
; kernel will be loaded to position 0:0x10000
; (just after the bool sector)
  mov word [ bp + read_segment - start ], 0x1000 ; kernel start segment
  mov al, [ bp + BPB_SecPerClus - start ]
  mov [ bp + sectors_count - start ], al ; number of sectors to read
  ; only one iteration is required ( reading whole cluster by one operation)
  mov byte [ bp - 0x8c ], 0x1 ; number of iterations in read_cluster_chain
  mov bx, read_kernel_file
read_cluster_chain:
   mov eax, [ bp + BPB_RootClus - start ]   ; current cluster to read
   cmp eax, 0xffffff7
   jl rcc_continue
;;;;
;;;; kernel is loaded if bx == read_kernel_file  
   cmp bx, read_kernel_file
   jne error
;   mov ax, 0xCAFE
;   call print_regs
; switch to protected mode
; and jump to kernel
 
 lgdt  [ gdtr ]
   
  in al, 0x92
  or al, 2
  out 0x92, al
 
  mov eax, cr0
  or al, 1 
  mov cr0, eax
     
  jmp 0x8: _protected 
 
  use32
_protected:
  ; jump to kernel
  jmp 0x8:0x10000
 
  use16
 
   rcc_continue:
    call get_sector_by_cluster
    ; number of iterations
    ; for reading sectors one by one
    movzx cx, byte [ bp - 0x8c ]     ; sectors to read
    
rcc_read_next:
    call read_sector
; registrers don't restored if error is happen
; we don't need them just show error message
; sorry saving 1 byte <img src="http://s0.wp.com/wp-includes/images/smilies/icon_smile.gif?m=1129645325g" alt=":)" class="wp-smiley">
 
    pusha
        call bx            ; process sector data
    popa
    jc rcc_to_next_sector
; processing function finished it's work
; actually it happens only for search directory
; this return can be changed later
    ret
 
error:
  int 0x18
     
rcc_to_next_sector:
    inc eax
    loop rcc_read_next
     
; get next data cluster
; calculate  FAT sector to read
; read FAT
; get cluster from FAT
    mov eax, [ bp + BPB_RootClus - start ]
    shl eax, 2   ; cluster << 2
    mov dx, ax ; lo word
    shr eax, 16 ; hi word
    xchg ax, dx ; lo <-> hi
    mov cx, word [ bp + BPB_BytsPerSec - start ]
    div cx
    add eax,  [ bp - 0x86 ]  ; reserved + hidden
    push word [ bp + sectors_count - start ] ; sectors to read
   push word [ bp + read_segment - start ] ; where to read
   mov word [ bp + read_segment - start ] , 0x80
   mov byte [ bp + sectors_count - start ], 0x1
   call read_sector
   pop word [ bp + read_segment - start ]
   pop word [ bp + sectors_count - start ]
   mov si , dx
   mov eax, [ si + 0x800 ]
   and eax, 0xfffffff
   mov [ bp + BPB_RootClus - start ], eax
   jmp read_cluster_chain
   
; read sector
; input: read_sector_data area
; output: carry flag (if error happen)
read_sector:                             ; read sector lba mode
  pusha
      mov [ bp + lba_lo - start ] , eax      ; pass LBA address
        mov si, read_sector_data              ; function parameters
        mov ah, 0x42                         ; function number
        mov dl, 0x80                          ; disk number
        int 0x13
    popa
        jc error     ; error happend   
    ret
   
; search file in directory
search_kernel_file:
    mov di, 0x800 ; [ bp + read_offset - start ]
skf_compare_name:
    mov si, kernel
    mov cx, 11
    push di
    repe cmpsb
    pop di
    jne skf_continue
    mov cx, [ di + 26 ]
    mov [ bp + BPB_RootClus - start ], cx
    mov cx, [ di + 20 ]
    mov [ bp + BPB_RootClus + 2 - start ], cx
    clc
    ret
skf_continue:
  add di, 32
  cmp di, 0xa00
  jl skf_compare_name
  stc
  ret
; calculate sector number by cluster number
; input:   eax - cluster number
; output: eax - cluster number
get_sector_by_cluster:
  dec eax
  dec eax
  movzx ecx, byte [ bp + BPB_SecPerClus - start ] 
  mul ecx
  add eax, [ bp - 0x8a ]                ; first data sector
  ret
 
; This function is called each time when kernel file cluster
; has been read. This function just need to increment the
; memory position (where to read next cluster)
read_kernel_file:
  mov ax, [ bp + read_segment - start ]
  add ax, [ bp - 0x8e ]  ; [ bp - 0x8e ] segment increment for cluster
  mov [ bp + read_segment - start ], ax
  stc
  ret
 
  ; alignment
  times 3 db 0x90
   
  gdt:                    ; Address for the GDT
gdt_null:               ; Null Segment
  dd 0
  dd 0
     
gdt_code:               ; Code segment, read/execute, nonconforming
  dw 0FFFFh
  dw 0
  db 0
  db 0x9a
  db 0xcf
  db 0
 
gdt_data:               ; Data segment, read/write, expand down
  dw 0FFFFh
  dw 0
  db 0
  db 0x92
  db 0xcf
  db 0
   
gdt_code16:
  dw 0FFFFh
  dw 0
  db 0
  db 0x9e
  db 0
  db 0
 
gdt_data16:
  dw 0FFFFh
  dw 0
  db 0
  db 0x92
  db 0
  db 0   
         
gdtr:
  dw gdtr-gdt-1
  dd gdt
  
finish:
  times 0x1FE-finish+start db 0
  db   0x55, 0xAA         ; Boot Sector signature