mirror of
https://github.com/gbowne1/ClassicOS.git
synced 2025-04-04 21:14:58 -07:00
132 lines
5.2 KiB
NASM
132 lines
5.2 KiB
NASM
[BITS 16]
|
|
[ORG 0x7c00]
|
|
|
|
start:
|
|
; Processor initialization (only stack segment register needed)
|
|
mov ss, 0x1000 ; Set stack segment register
|
|
mov sp, 0x7C00 ; Set stack pointer (SP)
|
|
mov ds, ss ; Set data segment register (DS)
|
|
|
|
; Identify boot device using BIOS calls
|
|
identify_drive:
|
|
mov ah, 0x0E ; Get Interrupt Vector for INT 13h (Disk Services)
|
|
int 0x80
|
|
cmp cl, 0x41 ; Check for floppy drive interrupt vector (example)
|
|
je is_floppy
|
|
cmp cl, 0x80 ; Check for hard disk interrupt vector (example)
|
|
je is_harddrive
|
|
; Handle invalid drive type (error handling)
|
|
...
|
|
|
|
is_floppy:
|
|
Perform floppy disk access (assuming AH=0x02 for read sectors)
|
|
mov ah, 0x02 ; Read sectors
|
|
mov al, 1 ; Number of sectors to read (1)
|
|
|
|
; Set CH, CL, DH, DL for floppy based on your system configuration
|
|
; (Replace these values with appropriate settings for your floppy drive)
|
|
mov ch, 0 ; Cylinder (example, adjust based on your floppy)
|
|
mov cl, 1 ; Sector number (example, adjust based on boot sector location)
|
|
mov dh, 0 ; Head number (example, typically 0 for single-sided floppies)
|
|
mov dl, 0x00 ; Drive number (0x00 for floppy drive A)
|
|
|
|
; Set ES:BX to the memory address where you want to store the read data
|
|
mov es, 0x1000 ; Example segment (adjust as needed)
|
|
mov bx, 0x0 ; Memory offset within the segment (example)
|
|
|
|
int 0x13
|
|
jc error_floppy
|
|
|
|
; Implement error handling (omitted here for brevity)
|
|
; Process the read data from the floppy sector (load second stage bootloader, etc.)
|
|
|
|
is_harddrive:
|
|
|
|
; Sample code (not guaranteed to work universally)
|
|
mov ah, 0x02 ; Set function for read sectors
|
|
mov al, 0x01 ; Read one sector
|
|
; Set CH, CL, DH for desired sector location (e.g., first sector)
|
|
mov dl, 0x80 ; Drive number (assuming drive A is boot device)
|
|
mov es, segment_address ; Set ES for buffer to store read data
|
|
mov bx, buffer_offset ; Set BX for offset within the buffer
|
|
|
|
int 13h ; Raise BIOS interrupt for disk read
|
|
|
|
; Check Carry flag for error handling
|
|
jc harddrive_not_found ; Jump if Carry flag is set (potential error)
|
|
|
|
; Hard drive likely present (further processing can occur)
|
|
|
|
; ... (rest of your bootloader code)
|
|
|
|
harddrive_not_found:
|
|
; Handle error condition (missing drive or other issue)
|
|
|
|
; ... (error handling logic)
|
|
|
|
memory_error:
|
|
; ... (error handling or continue with limited memory)
|
|
|
|
; Second stage loading (simplified example)
|
|
Here's an improved version of the load_second_stage section with the placeholder jump replaced by actual loading logic:
|
|
Code snippet
|
|
|
|
load_second_stage:
|
|
; Calculate address of second stage bootloader (assuming offset from boot sector)
|
|
mov dx, 0x0000 ; Clear DX register for better calculation
|
|
add dx, sector_count ; Add number of sectors to skip (adjust as needed)
|
|
shl dx, 5 ; Multiply by sector size (512 bytes)
|
|
add dx, 0x7C00 ; Add boot sector address offset
|
|
|
|
; Read second stage bootloader from calculated address
|
|
mov ah, 0x02 ; Function for reading sectors
|
|
mov al, 1 ; Number of sectors to read (1 for second stage)
|
|
mov es, dx ; Set ES segment register to calculated address
|
|
mov bx, 0x0000 ; Set BX offset within the segment (example)
|
|
|
|
int 13h ; Raise BIOS interrupt for disk read
|
|
|
|
; Check Carry flag for error handling
|
|
jc memory_error ; Jump if Carry flag is set (potential error)
|
|
|
|
; Second stage likely loaded successfully, jump to it
|
|
jmp second_stage_address ; Direct jump to the defined address
|
|
|
|
error_floppy:
|
|
; Display a basic error message (optional)
|
|
mov ah, 0x0E ; BIOS video call for displaying text (educational purposes)
|
|
mov bh, 0x00 ; Set background color (black)
|
|
mov bl, 0x07 ; Set text color (white)
|
|
mov dx, error_floppy_message ; Address of error message string
|
|
int 0x10 ; BIOS video interrupt
|
|
|
|
; Halt the boot process (replace with a retry or more advanced error handling)
|
|
hlt ; Halt instruction
|
|
|
|
error_floppy_message db 'Floppy disk read error!', 0x0
|
|
|
|
memory_error:
|
|
; Check for available memory (replace with actual method)
|
|
; ... (e.g., call BIOS service for memory size or use a constant value)
|
|
cmp available_memory, memory_threshold ; Compare with minimum required memory
|
|
jb limited_memory_boot ; Jump if below threshold
|
|
|
|
; ... (standard error handling for other scenarios)
|
|
|
|
limited_memory_boot:
|
|
; Perform minimal setup for limited memory boot
|
|
; ... (disable non-essential features, adjust kernel parameters)
|
|
|
|
; Load and jump to second stage bootloader (potentially with adjustments)
|
|
; ... (modify loading logic if necessary)
|
|
|
|
; Define variables used for calculation (adjust as needed)
|
|
sector_count db 1 ; Number of sectors to skip before second stage (change if needed)
|
|
second_stage_address equ 0x8000 ; Replace with actual address of your second stage bootloader
|
|
available_memory equ 0x100000 ; Replace with actual memory size detection (1MB in this example)
|
|
memory_threshold equ 0x0A0000 ; Example minimum memory required (adjust based on needs)
|
|
|
|
; Padding and magic number (standard practice)
|
|
times 510-($-$$) db 0
|
|
dw 0xaa55
|