Subversion Repositories or1k

; loader_hybrid_com.asm

;

; This is a DOS command-line loader for RTEMS executables running on

; the Technologic Systems TS-1325 Embedded PC.

;

; It loads a DOS file given on the command line to the address `KernelBase',

; and then transfers control there. It uses DOS file I/O commands to read from

; the A: flash disk, and direct memory access to read from the C: ramdisk.

;

; Copying uses protected flat mode, so kernelbase could be above 1MB.

; It does not initialize protected mode before transferring control

; to the RTEMS executable image.

;

; Compile with: nasm -o loader.com loader_hybrid_com.asm

;

; Tony Ambardar (c) 1999

; E.C.E. Department

; University of British Columbia

%include "ts1325.inc"    ; Some useful LED and button macros

; IMPORTANT: [org xxx] MUST be the same as RelocAddr below.

[org E000h]

[bits 16]

; Only these three definitions may need to change

KernelBase equ  08000h   ; Where (32-bit) to locate and run RTEMS executable

RelocSeg   equ  9000h    ; Segment to relocate code.

RelocAddr  equ  0E000h   ; Address to relocate code, same as "org" above

; Next three used in GDT

RelocBase  equ  RelocSeg*16

Reloc15    equ  RelocBase & 0FFFFh

Reloc23    equ  RelocBase / 10000h

Buffer     equ  RelocAddr+400h   ; In same segment as RelocSeg

BuffSiz    equ  200h             ; Size of disk read + copy

StackSeg   equ  RelocSeg

StackSiz   equ  40h

StackAddr  equ  Buffer+BuffSiz+StackSiz

; Used to jump to kernel in real mode

KernelAddr equ  KernelBase & 0FFFFh

KernelSeg  equ  (KernelBase - KernelAddr) / 16

; Used to load from the ramdisk

Extended   equ  100000h  ; Start of extended memory / C: ramdisk

OffsetBPB  equ  0Bh      ; Start of BIOS param block in bootsector

; Command-line parameters

ParamLen   equ  80h      ; Byte length of command line params

ParamStr   equ  82h      ; Start of param string

; The ORG address above means pre-relocation addresses are wrong. The

; following macro fixes these up.

%define PRE_RELOC_ADDR(addr) (addr-CodeStart+100h)

CodeStart:

mov  dx, PRE_RELOC_ADDR(Greet)

mov  ah, 9h

int  21h

mov  ax, 0b021h       ; Exit to DOS if push-button switch pressed

int  15h

and  al, 01h          ; Bit 0 == 0 if button pressed

jz   ButtonExit

xor cx, cx

mov cl, [ParamLen]   ; See if there is a command line arg

jcxz NameError

dec  cx              ; Nix leading space. Is this standard?

cmp  cx, 12          ; Limit to 12 chars: e.g. ABCDEFGH.IJK

jg   NameError

                     ; Damn. Should make sure of no ':' or '\' chars too.

; Required by "relocated" [org] statement above

mov  di, PRE_RELOC_ADDR(FName)

mov  si, ParamStr

repne

movsb                ; Copy command line arg

; Make sure no ':' in filename. This forces using the default dir.

mov  di, PRE_RELOC_ADDR(FName)

mov  al, ':'

mov  cx, 12

repne

scasb

je   NameError

jmp  Relocate

ButtonExit:

mov  dx, PRE_RELOC_ADDR(Button)

jmp short  DosPrint

NameError:

mov  dx, PRE_RELOC_ADDR(FError)

jmp short  DosPrint

DosError:            ; Only call this AFTER relocation

mov  dx, RError

DosPrint:

mov  ah, 9h

int  21h

DosExit:

mov  ax, 04C00h      ; DOS Function: Exit program

int  21h             ; Call DOS. Terminate Program

Relocate:            ; Move this code down to RelocAddr

cld

mov  ax, RelocSeg

mov  es, ax           ; Set destination = RelocSeg:RelocAddr

mov  di, RelocAddr

mov  si, 100h         ; Source is ds:0100h i.e. a COM file

mov  cx, CodeEnd - CodeStart ; Size of all code

repne

movsb

; continue in copied code

jmp  RelocSeg:RelocAddr + (RelocStart - CodeStart)

RelocStart:

cli

mov  ax, StackSeg

mov  ss, ax

mov  sp, StackAddr

mov  ax, cs

mov  ds, ax

mov  es, ax          ; Setup segments and stack

sti

mov  ah, 19h

int  21h

mov  [DDrive], al    ; Save current default drive

mov  ax, 3d00h       ; DOS Function: Open the file for reading

mov  dx, FName       ; Presume DS points at filename segment

int  21h

jc   DosError

GoodOpen:

mov  [FHndl], ax     ; Save file handle

mov  al, [DDrive]    ; Check if loading from C: drive (ramdisk)

cmp  al, 2

je   LoadRamdisk

LoadDosdisk:

; Here we are loading from A: drive. Use DOS calls to load the file into

; extended memory. Then copy from extended memory to `KernelBase'. This way

; we avoid overwriting DOS file I/O structures if reading directly into

; conventional (<640K) memory.

mov  edi, Extended   ; Destination for code read @ 1 Meg

ReadLoop:

mov  ah,3fh          ; DOS Function: Read data from the file

mov  bx, [FHndl]

mov  dx, Buffer      ; Address of data buffer

mov  cx, BuffSiz     ; Request BuffSiz bytes

int  21h

jc   DosError

GoodRead:

cmp  ax, cx          ; EOF reached? AX = # bytes read

pushf

add  ax, 3

shr  ax, 2           ; Copy buffer by dwords, # = (ax + 3)/4

movzx  ecx, ax

mov  esi, RelocBase + Buffer     ; Source for copy, destination is in edi

call CopyData32      ; Do protected-mode copy

popf

je   ReadLoop        ; Still data left, so read next chunk

mov  esi, Extended   ; Source for copy @ 1 Meg

mov  ecx, edi        ; Make count in dwords

sub  ecx, esi

add  ecx, 3

shr  ecx, 2

mov  edi, KernelBase ; Destination copy

call CopyData32      ; Move code into conventional memory

jmp  RunKernel

LoadRamdisk:

; Here we are loading from C: drive. Use protected mode to directly access

; the virtual disk sectors in extended memory and copy to `KernelBase'.

; This way we avoid using DOS file I/O calls, except for an `open' earlier

; which tells us the file exists.

; Copy C: "bootsector" to buffer and save the BIOS parameter block

mov  esi, Extended

mov  edi, RelocBase + Buffer     ; Must be a 32-but address...

mov  ecx, 80h

call CopyData32

mov  si, Buffer + OffsetBPB

mov  di, SavBPB

mov  cx, EndBPB - SavBPB

repne

movsb

; Calculate  FAT, root dir, and data start addresses for the ramdisk

xor  eax, eax

mov  ebx, eax

mov  ecx, ebx

mov  ax, [ResSec]

mov  bl, [NumFAT]

imul bx, [SecFAT]

mov  cx, [NRoot]

shr  cx, 4           ; 10h directory entries per sector

add  bx, ax

add  cx, bx

mov  dx, [BpSect]

imul ax, dx

imul bx, dx

imul cx, dx

add  eax, Extended

add  ebx, Extended

add  ecx, Extended

mov  [BegFAT], eax

mov  [BegRoot], ebx

mov  [BegData], ecx

; Convert the saved filename to format used in directory entry. Assume

; there's a `.' in it. Hopefully this won't haunt us later...

mov  di, FName       ; Find the `.'

mov  al, '.'

mov  cx, 12

repne

scasb

mov  bx, di          ; di points to filename extension

mov  di, DirName

mov  si, FName

mov  cx, bx          ; Make count

sub  cx, si

dec cx

repne                ; Copy initial part of filename

movsb

mov  di, bx          ; Find the terminating zero

xor  al,al

mov  cx, 4

repne

scasb

mov  cx, di          ; Make count

sub  cx, bx

dec  cx

mov  si, bx

mov  di, DirName + 8

repne                ; Copy filename extension

movsb

mov  si, DirName     ; Convert the stupid thing to upper case

mov  di, si

mov  cx, 11

Cvt2Upper:

lodsb

cmp  al, 'a'

jb   NotLow

cmp  al, 'z'

ja   NotLow

xor  al, 20h

NotLow:

stosb

loop Cvt2Upper

; Now load in the root directory (temporarily) to find the first cluster

; of our file. Use KernelSeg:KernelAddr as temporary storage.

mov  esi, [BegRoot]

mov  edi, KernelBase

xor  ecx, ecx

mov  cx, [NRoot]

shl  cx, 3           ; Each root entry is 8 dwords

call CopyData32

mov  dx, [NRoot]     ; Max # of dir entries

mov  cx, KernelSeg   ; Setup segment selector for comparison

mov  es, cx

mov  di, KernelAddr

FindEntry:

mov  cx, 11

mov  si, DirName

push di

rep  cmpsb

pop  di

je   GotEntry

add  di, 20h         ; Point to next dir entry

dec  dx

jnz  FindEntry

int  3h              ; Should never get here...

GotEntry:

mov  eax, KernelBase ; Setup initial address for copy

mov  [CurrDst], eax

add  di, 32 - 6      ; Load first cluster number

mov  ax, [es:di]

mov  cx, ds          ; Fix `es' selector just in case

mov  es, cx

LoadKernel:

call LoadCluster     ; Load cluster `ax' to [CurrDst], update [CurrDst]

call NextCluster     ; Get next cluster number in ax

cmp  ax, 0FF8h       ; Repeat until EOF

jb   LoadKernel

RunKernel:

mov  ax, KernelSeg   ; Setup data segment and transfer control

mov  ds, ax

jmp  KernelSeg:KernelAddr  ; Huzzah!!

; Load cluster `ax' to [CurrDst], update [CurrDst]

LoadCluster:

push ax

sub  ax, 2           ; Cluster numbers start at 2

movzx eax, ax

xor  ecx, ecx        ; Calculate bytes in a cluster

mov  cl, [SpClst]

imul cx, [BpSect]

imul eax, ecx

add  eax, [BegData]  ; Start of cluster

shr  ecx, 2          ; Cluster size in dwords

mov  esi, eax        ; Copy source

mov  edi, [CurrDst]  ; Copy destination

call CopyData32

mov  [CurrDst], edi  ; Update dest

pop  ax              ; Restore cluster number

ret

; Search FAT (FAT12 format) for next cluster in file after `ax'.

NextCluster:

movzx ecx, ax        ; Calculate offset into FAT

shr  ax, 1

pushf

add  cx, ax

mov  esi, [BegFAT]   ; Copy word containing next cluster to buffer

add  esi, ecx

mov  edi, RelocBase + Buffer

xor  ecx, ecx

inc  ecx

call CopyData32

mov  ax, [Buffer]    ; Handle odd/even cluster numbers

popf

jnc  EvenCluster

shr  ax, 4

EvenCluster:

and  ax, 0FFFh

ret

; Enable the A20 line for accesses to extended memory.

EnableA20:

        in al,92h

        or al,2

        jmp short $+2

        jmp short $+2

        jmp short $+2

        out 92h,al

        ret

; The CopyData32 routine copies ecx dwords from esi to edi. Both esi

; and edi hold 32-bit values. CopyData32 runs in 32-bit protected mode.

CopyData32:

        cli

        call EnableA20   ; Put here in case file I/O screws with this

                         ; or with the GDTR

        lgdt [GDTStart]  ; Initialize GDTR for 32-bit protected mode

        mov eax, cr0

        or al, 1

        mov cr0, eax     ;go to real flat mode

;       LED_GRN

;       PSW_WAIT

        jmp  dword 8h : RelocBase+ProtJmp

[bits 32]

ProtJmp:

;       LED_YEL

;       PSW_WAIT

        mov ax, 10h

        mov ds, ax

        mov es, ax

        mov ss, ax

        rep movsd       ;copy the sector to where it should be

        mov ax, 20h

        mov ds, ax

        mov es, ax

        mov ss, ax

;       LED_RED

;       PSW_WAIT

        jmp 18h : RealJmp1  ;use code segment with 64K limit

[bits 16]

RealJmp1:

;       LED_OFF

;       PSW_WAIT

        mov eax, cr0      ;back to real segmented mode

        and eax, 0fffffffeh

        mov cr0, eax

        jmp  RelocSeg : RealJmp2

RealJmp2:

;       LED_GRN

;       PSW_WAIT

        mov ax, cs

        mov es, ax

        mov ds, ax

        mov ss, ax

        sti

ret

; Storage for a Dos 3+ BIOS Parameter Block (for the C: ramdisk)

SavBPB:

BpSect  dw  0h       ; Bytes per sector, always 512

SpClst  db  0h       ; Sectors per cluster

ResSec  dw  0h       ; Num of reserved sectors

NumFAT  db  0h       ; Num of FATs

NRoot   dw  0h       ; Num of root directory entries

TotSec  dw  0h       ; Total sectors

Media   db  0h       ; Media descriptor byte

SecFAT  dw  0h       ; Sectors per FAT

EndBPB:

CurrDst dd  0h       ; Current destination address for copying RTEMS exec

; Important (32-bit) address for the C: ramdisk

BegFAT  dd  0h       ; Start of the FAT

BegRoot dd  0h       ; Start of root directory

BegData dd  0h       ; Start of data clusters

DDrive  db  0h       ; Default drive: 0h = A:, 2h = C:

DirName times 11 db 32 ; Room for 8.3 directory entry name

FName   times 13 db 0  ; Room for a 12 character null-terminated string

FHndl   dw  0000h

Greet   db  "RTEMS DOS Loader (c) 1999 Tony R. Ambardar",13,10,"$"

Button  db  "Button pressed -- Aborting.",13,10,"$"

FError  db  "Missing or incorrect file name.",13,10,"$"

RError  db  "Error opening or reading file.",13,10,"$"

; Global Descriptor Table used for protectd mode.

; Store the GDTR in the first null GDT entry

GDTStart:

dw GDTEnd - GDTStart - 1

dd RelocBase + GDTStart

dw 0

; base=0h, limit=4Gb, present, code, exec/read, conform, 32-bit

dw 0ffffh   ;seg. lim. [15:0]

dw 0        ;base[15:0]

db 0        ;base[23:16]

db 9eh      ;p=1,dpl=0,s=1 ; code: execute/read, conforming

db 0cfh     ;c: gran=4K, D/B=1(32-bit) ; f: seg. lim. [19:16]

db 0        ;base[31:24]

; base=0h, limit=4Gb, present, data, read/write exp. up, 32-bit SP

dw 0ffffh   ;seg. lim. [15:0]

dw 0        ;base[15:0]

db 0        ;base[23:16]

db 92h      ;p=1,dpl=0,s=1 ; data: read/write expand-up

db 0cfh     ;c: gran=4K, D/B=1(32-bit) ; f: seg. lim. [19:16]

db 0        ;base[31:24]

; base=0h, limit=ffffh, present, code, exec/read, conform, 16-bit

; NOTE: this descriptor is used to change back to real mode.

dw 0ffffh   ;seg. lim. [15:0]

dw Reloc15  ;base[15:0]

db Reloc23  ;base[23:16]

db 9eh      ;p=1,dpl=0,s=1 ; code: execute/read, conforming

db 000h     ;4: gran=1 byte, D/B=0(16-bit) ; 0: seg. lim. [19:16]

db 0        ;base[31:24]

; base=0h, limit=ffffh, present, data, read/write exp. up, 16-bit SP

; NOTE: this descriptor is used to change back to real mode.

dw 0ffffh   ;seg. lim. [15:0]

dw Reloc15  ;base[15:0]

db Reloc23  ;base[23:16]

db 92h      ;p=1,dpl=0,s=1 ; data: read/write expand-up

db 000h     ;0: gran=1 byte, D/B=0(16-bit) ; 0: seg. lim. [19:16]

db 0        ;base[31:24]

GDTEnd:

CodeEnd:                    ; end-of-code marker for copy