WebSVN – Kolibri OS – Diff – /kernel/trunk/boot/bootcode.inc

 ;;  KolibriOS 16-bit loader,                                    ;;
 ;;                        based on bootcode for MenuetOS        ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 749 $
+$Revision: 795 $
         jmp     $
 @@:
         pop     si
         ret
+; convert abs. sector number (AX) to BIOS T:H:S
+; sector number = (abs.sector%BPB_SecPerTrk)+1
+; pre.track number = (abs.sector/BPB_SecPerTrk)
+; head number = pre.track number%BPB_NumHeads
+; track number = pre.track number/BPB_NumHeads
+; Return: cl - sector number
+;         ch - track number
+;         dl - drive number (0 = a:)
+;         dh - head number
+conv_abs_to_THS:
+        push    bx
+        mov     bx,word [BPB_SecPerTrk]
+        xor     dx,dx
+        div     bx
+        inc     dx
+        mov     cl, dl                          ; cl = sector number
+        mov     bx,word [BPB_NumHeads]
+        xor     dx,dx
+        div     bx
+        ; !!!!!!! ax = track number, dx = head number
+        mov     ch,al                           ; ch=track number
+        xchg    dh,dl                           ; dh=head number
+        mov     dl,0                            ; dl=0 (drive 0 (a:))
+        pop     bx
+        retn
+; needed variables
+BPB_SecPerTrk	dw	0			; sectors per track
+BPB_NumHeads	dw	0			; number of heads
+BPB_FATSz16	dw	0			; size of FAT
+BPB_RootEntCnt	dw	0			; count of root dir. entries
+BPB_BytsPerSec	dw	0			; bytes per sector
+BPB_RsvdSecCnt	dw	0			; number of reserved sectors
+BPB_TotSec16	dw	0			; count of the sectors on the volume
+BPB_SecPerClus	db	0			; number of sectors per cluster
+BPB_NumFATs	db	0			; number of FAT tables
+abs_sector_adj	dw	0			; adjustment to make abs. sector number
+end_of_FAT	dw	0			; end of FAT table
+FirstDataSector	dw	0			; begin of data
 ;=========================================================================
+;
 ;                           16 BIT CODE
+;
         lds     si, [es:si+26]
         test    byte [ds:si+10], 40h
         pop     ds
         jz      .nocd
 ; yes - read all floppy by 18 sectors
+; TODO: !!!! read only first sector and set variables !!!!!
+; ...
+; TODO: !!! then read flippy image track by track
-        mov     cx, 0x0001      ; startcyl,startsector
+	mov     cx, 0x0001      ; startcyl,startsector
 .a1:
         push    cx dx
         mov     al, 18
         mov     bx, 0xa000
         jmp     .a1
 .nocd:
 ; no - read only used sectors from floppy
 ; now load floppy image to memory
 ; at first load boot sector and first FAT table
+; read only first sector and fill variables
-        mov     cx, 0x0001      ; startcyl,startsector
+	mov	cx, 0x0001	; first logical sector
-        xor     dx, dx          ; starthead,drive
+	xor	dx, dx		; head = 0, drive = 0 (a:)
-        mov     al, 1+9         ; no of sectors to read
+	mov	al, 1		; read one sector
-        mov     bx, 0xB000      ; es:bx -> data area
+	mov	bx, 0xB000	; es:bx -> data area
-        call    boot_read_floppy
+	call	boot_read_floppy
+; fill the necessary parameters to work with a floppy
+	mov	ax, word [es:bx+24]
+	mov	word [BPB_SecPerTrk], ax
+	mov	ax, word [es:bx+26]
+	mov	word [BPB_NumHeads], ax
+	mov	ax, word [es:bx+22]
+	mov	word [BPB_FATSz16], ax
+	mov	ax, word [es:bx+17]
+	mov	word [BPB_RootEntCnt], ax
+	mov	ax, word [es:bx+11]
+	mov	word [BPB_BytsPerSec], ax
+	mov	ax, word [es:bx+14]
+	mov	word [BPB_RsvdSecCnt], ax
+	mov	ax, word [es:bx+19]
+	mov	word [BPB_TotSec16], ax
+	mov	al, byte [es:bx+13]
+	mov	byte [BPB_SecPerClus], al
+	mov	al, byte [es:bx+16]
+	mov	byte [BPB_NumFATs], al
+; count of clusters in FAT12 ((size_of_FAT*2)/3)
+	mov	ax, word [BPB_FATSz16]
+	mov	cx, word [BPB_BytsPerSec]
+	xor	dx, dx
+	mul	cx
+	shl	ax, 1
+	mov	cx, 3
+	div	cx		; now ax - number of clusters in FAT12
+	mov	word [end_of_FAT], ax
+; load first FAT table
+	mov     cx, 0x0002      ; startcyl,startsector		; TODO!!!!!
+        xor     dx, dx          ; starthead,drive
+        mov     al, byte [BPB_FATSz16]     ; no of sectors to read
+        add     bx, word [BPB_BytsPerSec]  ; es:bx -> data area
+        call    boot_read_floppy
+	mov	bx, 0xB000
 ; and copy them to extended memory
         mov     si, movedesc
-        mov     [si+8*2+3], bh
+        mov     [si+8*2+3], bh		; from
+	mov	ax, word [BPB_BytsPerSec]
+	shr	ax, 1			; words per sector
+	mov	cx, word [BPB_RsvdSecCnt]
+	add	cx, word [BPB_FATSz16]
+	mul	cx
+	push	ax			; save to stack count of words in boot+FAT
+	xchg	ax, cx
         push    es
         push    ds
         pop     es
-        mov     cx, 256*10
         mov     ah, 0x87
         int     0x15
+	pop	es
         test    ah, ah
         jz      @f
 sayerr_floppy:
         mov     dx, 0x3f2
         mov     al, 0
         out     dx, al
         mov     si, memmovefailed
         jmp     sayerr_plain
 @@:
+	pop	ax			; restore from stack count of words in boot+FAT
+	shl	ax, 1			; make bytes count from count of words
+	and	eax, 0ffffh
-        add     dword [si+8*3+2], 512*10
+        add     dword [si+8*3+2], eax
-; copy FAT to second copy
+; copy first FAT to second copy
+; TODO: BPB_NumFATs !!!!!
+	add	bx, word [BPB_BytsPerSec]	; !!! TODO: may be need multiply by BPB_RsvdSecCnt !!!
-        mov     byte [si+8*2+3], 0xB2
+        mov     byte [si+8*2+3], bh	; bx - begin of FAT
+	mov	ax, word [BPB_BytsPerSec]
+	shr	ax, 1			; words per sector
+	mov	cx, word [BPB_FATSz16]
+	mul	cx
+	mov	cx, ax			; cx - count of words in FAT
+        push    es
+        push    ds
-        mov     cx, 256*9
+        pop     es
         mov     ah, 0x87
         int     0x15
         pop     es
         test    ah, ah
         jnz     sayerr_floppy
+	mov	ax, cx
+	shl	ax, 1
+	and	eax, 0ffffh		; ax - count of bytes in FAT
-        add     dword [si+8*3+2], 512*9
+        add     dword [si+8*3+2], eax
+; reading RootDir
+; TODO: BPB_NumFATs
+	add	bx, ax
+	add	bx, 100h
-; calculate total number of sectors to read
+	and	bx, 0ff00h			; bx - place in buffer to write RootDir
+	push	bx
-        mov     ax, 1+9+14      ; boot+FAT+root
+	mov	bx, word [BPB_BytsPerSec]
-        mov     di, 0xB203
+	shr	bx, 5				; divide bx by 32
+	mov	ax, word [BPB_RootEntCnt]
-.calc_loop:
+	xor	dx, dx
+	div	bx
-        test    word [es:di], 0xFFF
+	push	ax				; ax - count of RootDir sectors
-        jz      @f
+	mov	ax, word [BPB_FATSz16]
-        inc     ax
+	xor	cx, cx
+	mov	cl, byte [BPB_NumFATs]
+	mul	cx
+	add	ax, word [BPB_RsvdSecCnt]	; ax - first sector of RootDir
-@@:
-        test    word [es:di+1], 0xFFF0
+	mov	word [FirstDataSector], ax
-        jz      @f
+	pop	bx
-        inc     ax
+	push	bx
+	add	word [FirstDataSector], bx	; Begin of data region of floppy
-@@:
-        add     di, 3
+; read RootDir
-        cmp     di, 0xB200+1440*3
+	call	conv_abs_to_THS
+	pop	ax
-        jb      .calc_loop
+	pop	bx				; place in buffer to write
-        push    ax
+	push	ax
-        mov     bp, 1+9         ; already read sectors
+        call    boot_read_floppy		; read RootDir into buffer
-; now read rest
+; copy RootDir
+	mov	byte [si+8*2+3], bh		; from buffer
+	pop	ax				; ax = count of RootDir sectors
+	mov	cx, word [BPB_BytsPerSec]
+	mul	cx
+	shr	ax, 1
+	mov	cx, ax				; count of words to copy
+	push	es
+	push	ds
+	pop	es
-        mov     byte [si+8*2+3], 0xA0
+        mov     ah, 0x87
+        int     0x15
+	pop	es
+	mov	ax, cx
+	shl	ax, 1
-        mov     di, 2-14        ; absolute sector-31
+	and	eax, 0ffffh		; ax - count of bytes in RootDir
-        mov     cx, 0x0002      ; cylinder=0, sector=2
+        add     dword [si+8*3+2], eax	; add count of bytes copied
+; Reading data clusters from floppy
+	mov	byte [si+8*2+3], bh
+	push	bx
-        mov     dx, 0x0100      ; head=1, disk=0
+	mov	di, 2			; First data cluster
 .read_loop:
-; determine whether sector must be read
-        cmp     di, 2
-        jl      .read
-        mov     bx, di
+	mov	bx, di
-        shr     bx, 1
+	shr	bx, 1			; bx+di = di*1.5
-        jnc     .even
+	jnc	.even
-        test    word [es:bx+di+0xB200], 0xFFF0
+	test	word [es:bx+di+0xB200], 0xFFF0	; TODO: may not be 0xB200 !!!
-        jmp     @f
+	jmp	@f
 .even:
-        test    word [es:bx+di+0xB200], 0xFFF
+	test	word [es:bx+di+0xB200], 0xFFF	; TODO: may not be 0xB200 !!!
 @@:
-        jz      .skip
+	jz	.skip
+; read cluster di
-.read:
+;.read:
-        mov     bx, 0xA000
+	;conv cluster di to abs. sector ax
-        mov     al, 1           ; 1 sector
+	; ax = (N-2) * BPB_SecPerClus + FirstDataSector
+	mov	ax, di
+	sub	ax, 2
+	xor	bx, bx
+	mov	bl, byte [BPB_SecPerClus]
+	mul	bx
+	add	ax, word [FirstDataSector]
+	call	conv_abs_to_THS
+	pop	bx
+	push	bx
+	mov	al, byte [BPB_SecPerClus]	; number of sectors in cluster
-        call    boot_read_floppy
+	call	boot_read_floppy
-        inc     bp
         push    es
         push    ds
         pop     es
         pusha
+;
+	mov	ax, word [BPB_BytsPerSec]
+	xor	cx, cx
-        mov     cx, 256
+	mov	cl, byte [BPB_SecPerClus]
+	mul	cx
+	shr	ax, 1				; ax = (BPB_BytsPerSec * BPB_SecPerClus)/2
+	mov	cx, ax				; number of words to copy (count words in cluster)
+;
-        mov     ah, 0x87
+	mov     ah, 0x87
-        int     0x15
+        int     0x15				; copy data
         test    ah, ah
         popa
         pop     es
         jnz     sayerr_floppy
+; skip cluster di
 .skip:
-        add     dword [si+8*3+2], 512
+	mov	ax, word [BPB_BytsPerSec]
-        inc     cx
+	xor	cx, cx
-        cmp     cl, 19
-        jnz     @f
-        mov     cl, 1
+	mov	cl, byte [BPB_SecPerClus]
-        inc     dh
+	mul	cx
-        cmp     dh, 2
+	and	eax, 0ffffh		; ax - count of bytes in cluster
-        jnz     @f
-        mov     dh, 0
+	add	dword [si+8*3+2], eax
-        inc     ch
-@@:
-        pop     ax
-        push    ax
+	mov	ax, word [end_of_FAT]	; max cluster number
         pusha
 ; draw percentage
-; total sectors: ax
+; total clusters: ax
-; read sectors: bp
+; read clusters: di
-        xchg    ax, bp
+	xchg	ax, di
         mov     cx, 100
         mul     cx
-        div     bp
+	div	di
         aam
         xchg    al, ah
         add     ax, '00'
         mov     si, pros
         cmp     [si], ax
         mov     [si], ax
         call    printplain
 @@:
         popa
         inc     di
-        cmp     di, 2880-31
+	cmp	di, word [end_of_FAT]	; max number of cluster
         jnz     .read_loop
-;        mov     cx, 0x0001      ; startcyl,startsector
-;        xor     dx, dx          ; starthead,drive
-;        push    word 80*2               ; read no of sect
-;       reads:
-;        pusha
-;        xor     si,si
-;       newread:
-;        mov     bx,0xa000               ; es:bx -> data area
-;        mov     ax,0x0200+18            ; read, no of sectors to read
-;        int     0x13
-;        test    ah, ah
-;        jz      goodread
-;        inc    si
-;        cmp     si,10
-;        jnz     newread
-;        mov     si,badsect-0x10000
-;sayerr_plain:
-;        call    printplain
-;        jmp     $
-;       goodread:
-;        ; move -> 1mb
-;        mov     si,movedesc-0x10000
-;        push    es
-;        push    ds
-;        pop     es
-;        mov     cx,256*18
-;        mov     ah,0x87
-;        int     0x15
-;        pop    es
-;
-;        test    ah,ah                  ; was the move successfull ?
-;        je      goodmove
-;        mov     dx,0x3f2              ; floppy motor off
-;        mov     al,0
-;        out     dx,al
-;        mov     si,memmovefailed-0x10000
-;        jmp    sayerr_plain
-;      goodmove:
-;
-;    add    dword [movedesc-0x10000+0x18+2], 512*18
-;        popa
-;        inc     dh
-;        cmp     dh,2
-;        jnz     bb2
-;        mov     dh,0
-;        inc     ch
-;        pusha                        ; print prosentage
-;        mov     si,pros-0x10000
-;    shr    ch, 2
-;    mov    al, '5'
-;    test    ch, 1
-;    jnz    @f
-;    mov    al, '0'
-;@@:
-;    mov    [si+1], al
-;    shr    ch, 1
-;    add    ch, '0'
-;    mov    [si], ch
+	pop	bx			; clear stack
-;        call    printplain
-;        popa
-;       bb2:
-;        pop     ax
-;        dec     ax
-;        push    ax
-;        jnz     reads
-;       readdone:
-;        pop     ax
 ok_sys_on_floppy:
         mov     si, backspace2
         call    printplain

Subversion Repositories Kolibri OS

(root)/kernel/trunk/boot/bootcode.inc @ 7586 – Rev 749 → 795