1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
; number of sectors to be read
; 3 * 512 for bootloader stage2 and the kernel code
; (note: the first sector gets loaded by the BIOS, so
; subtract 1 here!)
NOF_LOAD_SECTORS equ 38
; IN dx: hex value to print
print_hex:
push bx
push si
mov si, HEX_TEMPLATE
mov bx, dx
shr bx, 12
mov bx, [HEXABET+bx]
mov [HEX_TEMPLATE+2], bl
mov bx, dx
and bx, 0x0FFF
shr bx, 8
mov bx, [HEXABET+bx]
mov [HEX_TEMPLATE+3], bl
mov bx, dx
and bx, 0x00FF
shr bx, 4
mov bx, [HEXABET+bx]
mov [HEX_TEMPLATE+4], bl
mov bx, dx
and bx, 0x000F
mov bx, [HEXABET+bx]
mov [HEX_TEMPLATE+5], bl
call print_string
pop si
pop bx
ret
HEX_TEMPLATE:
db '0x???? ', 0
HEXABET:
db '0123456789ABCDEF'
print_newline:
push ax
mov al, 10
call print_char
mov al, 13
call print_char
pop ax
ret
; IN si
print_string:
push ax
.loop:
lodsb
cmp al, 0
je .fini
call print_char
jmp .loop
.fini:
pop ax
ret
; IN al: character to print
; MOD ah
print_char:
mov ah, 0x0e
int 0x10
ret
fat_cursor:
push ax
push cx
mov ah, 0x01
mov cx, 0x0007
int 0x10
pop cx
pop ax
ret
; OUT: current row
current_row:
push ax
push bx
push cx
mov ah, 0x03
mov bh, 0
int 0x10
pop cx
pop bx
pop ax
ret
; data sections used for reading from disk
SECTORS_TO_LOAD:
db NOF_LOAD_SECTORS ; load NOF_LOAD_SECTORS sectors in total
CURRENT_SECTOR:
db 2 ; second sector after boot sector
CURRENT_CYLINDER:
db 0
CURRENT_HEAD:
db 0
; read the whole stage2 and kernel from the disk
; IN dl: drive to read from
read_from_disk:
mov bx, 0 ; where to store the data
mov es, bx
mov bx, 0x7e00 ; 512 bytes after first sector
.read_next_sector:
call read_one_sector_from_disk
sub [SECTORS_TO_LOAD], BYTE 1 ; one less to load
cmp [SECTORS_TO_LOAD], BYTE 0 ; finished?
je .finished
add bx, 0x200 ; advance write buffer position
add [CURRENT_SECTOR], BYTE 1 ; next sector
cmp [CURRENT_SECTOR], BYTE 0x13 ; assuming 18 sectors per track for now
je .next_head
jmp .read_next_sector
.next_head:
mov [CURRENT_SECTOR], BYTE 1 ; start from first sector again
add [CURRENT_HEAD], BYTE 1 ; advance head
cmp [CURRENT_HEAD], BYTE 0x02 ; 2 heads on floppies
je .next_track
jmp .read_next_sector
.next_track:
mov [CURRENT_HEAD], BYTE 0 ; start from head 0 again
add [CURRENT_CYLINDER], BYTE 1 ; advance track
jmp .read_next_sector
.finished:
ret
; Read one sector after the other, if we get illegal parameter
; errors we assume we have gone over the limit of number of
; sectors per cylinder. This avoids to probe for this number with
; shacky BIOS functions or with probing (as LILO does). It's not
; very efficient though..
; IN dl: drive to read from
read_one_sector_from_disk:
mov ah, 0x02 ; read sectors from drive
mov al, 1 ; read 1 sector
mov ch, BYTE [CURRENT_CYLINDER]
mov dh, BYTE [CURRENT_HEAD]
mov cl, BYTE [CURRENT_SECTOR]
int 0x13
jc .read_error
cmp al, 1 ; 1 sector read?
jne .short_read ; if not, short read
mov al, '.'
call print_char
ret
.read_error:
mov si, DISK_ERROR
call print_string
mov dh, 0
mov dl, ah
call print_hex
jmp $
.short_read:
mov si, SHORT_READ
call print_string
jmp $
kill_motor:
mov dx, 0x3F2
mov al, 0x00
out dx, al
ret
|
