![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bootsect.sg CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / boot|
Return to bootsect.sg CVS log | Up to [Early Linux] / linux / boot |
1.1 root 1: /*
2: *
3: * bootsect.s (C) 1991 Linus Torvalds
4: *
5: * bootsect.s is loaded at 0x7c00 by the bios-startup routines, and moves
6: * iself out of the way to address 0x90000, and jumps there.
7: *
8: * It then loads 'setup' directly after itself (0x90200), and the system
9: * at 0x10000, using BIOS interrupts.
10: *
11: * NOTE! currently system is at most 8*65536 bytes long. This should be no
12: * problem, even in the future. I want to keep it simple. This 512 kB
13: * kernel size should be enough, especially as this doesn't contain the
14: * buffer cache as in minix
15: *
16: * The loader has been made as simple as possible, and continuos
17: * read errors will result in a unbreakable loop. Reboot by hand. It
18: * loads pretty fast by getting whole sectors at a time whenever possible.
19: */
20:
21: .globl begtext, begdata, begbss, endtext, enddata, endbss
22: .text
23: begtext:
24: .data
25: begdata:
26: .bss
27: begbss:
28: .text
29:
30: SETUPLEN = 4 # nr of setup-sectors
31: BOOTSEG = 0x07c0 # original address of boot-sector
32: INITSEG = 0x9000 # we move boot here - out of the way
33: SETUPSEG = 0x9020 # setup starts here
34: SYSSEG = 0x1000 # system loaded at 0x10000 (65536).
35: ENDSEG = SYSSEG + SYSSIZE # where to stop loading
36:
37: /*
38: * ROOT_DEV: 0x000 - same type of floppy as boot.
39: * 0x301 - first partition on first drive etc
40: */
41: ROOT_DEV = 0 # 0x306
42:
43: entry start
44: start:
45: mov $BOOTSEG,%ax
46: mov %ax,%ds
47: mov $INITSEG,%ax
48: mov %ax,%es
49: mov $256,%cx
50: sub %si,%si
51: sub %di,%di
52: rep
53: movw
54: jmpi go,INITSEG
55: go: mov %cs,%ax
56: mov %ax,%ds
57: mov %ax,%es
58: /*
59: * put stack at 0x9ff00.
60: */
61: mov %ax,%ss
62: mov $0xFF00,%sp # arbitrary value >>512
63:
64: /*
65: * load the setup-sectors directly after the bootblock.
66: * Note that 'es' is already set up.
67: */
68:
69: load_setup:
70: mov $0x0000,%dx # drive 0, head 0
71: mov $0x0002,%cx # sector 2, track 0
72: mov $0x0200,%bx # address = 512, in INITSEG
73: mov $0x0200,%ax+SETUPLEN # service 2, nr of sectors
74: int 0x13 # read it
75: jnc ok_load_setup # ok - continue
76: mov $0x0000,%dx
77: mov $0x0000,%ax # reset the diskette
78: int 0x13
79: j load_setup
80:
81: ok_load_setup:
82:
83: /*
84: * Get disk drive parameters, specifically nr of sectors/track
85: */
86:
87: mov $0x00,%dl
88: mov $0x0800,%ax # AH=8 is get drive parameters
89: int 0x13
90: mov $0x00,%ch
91: seg %cs
92: mov %cx,sectors
93: mov $INITSEG,%ax
94: mov %ax,%es
95:
96: /*
97: * Print some inane message
98: */
99:
100: mov $0x03,%ah # read cursor pos
101: xor %bh,%bh
102: int 0x10
103:
104: mov $24,%cx
105: mov $0x0007,%bx # page 0, attribute 7 (normal)
106: mov $msg1,%bp
107: mov $0x1301,%ax # write string, move cursor
108: int 0x10
109:
110: /*
111: * ok, we've written the message, now
112: * we want to load the system (at 0x10000)
113: */
114:
115: mov $SYSSEG,%ax
116: mov %ax,%es # segment of 0x010000
117: call read_it
118: call kill_motor
119:
120: /*
121: * After that we check which root-device to use. If the device is
122: * defined (!= 0), nothing is done and the given device is used.
123: * Otherwise, either /dev/PS0 (2,28) or /dev/at0 (2,8), depending
124: * on the number of sectors that the BIOS reports currently.
125: */
126:
127: seg %cs
128: mov root,%ax_dev
129: cmp %ax,$0
130: jne root_defined
131: seg %cs
132: mov sectors,%bx
133: mov $0x0208,%ax # /dev/ps0 - 1.2Mb
134: cmp %bx,$15
135: je root_defined
136: mov $0x021c,%ax # /dev/PS0 - 1.44Mb
137: cmp %bx,$18
138: je root_defined
139: undef_root:
140: jmp undef_root
141: root_defined:
142: seg %cs
143: mov root_%ax,dev
144:
145: /*
146: * after that (everyting loaded), we jump to
147: * the setup-routine loaded directly after
148: * the bootblock:
149: */
150:
151: jmpi 0,SETUPSEG
152:
153: /*
154: * This routine loads the system at address 0x10000, making sure
155: * no 64kB boundaries are crossed. We try to load it as fast as
156: * possible, loading whole tracks whenever we can.
157: *
158: * in: es - starting address segment (normally 0x1000)
159: *
160: */
161: sread: .word 1+SETUPLEN # sectors read of current track
162: head: .word 0 # current head
163: track: .word 0 # current track
164:
165: read_it:
166: mov %es,%ax
167: test %ax,$0x0fff
168: die: jne die # %es must be at 64kB boundary
169: xor %bx,%bx # %bx is starting address within segment
170: rp_read:
171: mov %es,%ax
172: cmp %ax,$ENDSEG # have we loaded all yet?
173: jb ok1_read
174: ret
175: ok1_read:
176: seg %cs
177: mov sectors,%ax
178: sub sread,%ax
179: mov %ax,%cx
180: shl $9,%cx
181: add %bx,%cx
182: jnc ok2_read
183: je ok2_read
184: xor %ax,%ax
185: sub %bx,%ax
186: shr $9,%ax
187: ok2_read:
188: call read_track
189: mov %ax,%cx
190: add sread,%ax
191: seg %cs
192: cmp %ax,sectors
193: jne ok3_read
194: mov $1,%ax
195: sub head,%ax
196: jne ok4_read
197: inc track
198: ok4_read:
199: mov %ax,head
200: xor %ax,%ax
201: ok3_read:
202: mov %ax,sread
203: shl $9,%cx
204: add %cx,%bx
205: jnc rp_read
206: mov %es,%ax
207: add $0x1000,%ax
208: mov %ax,%es
209: xor %bx,%bx
210: jmp rp_read
211:
212: read_track:
213: push %ax
214: push %bx
215: push %cx
216: push %dx
217: mov track,%dx
218: mov sread,%cx
219: inc %cx
220: mov %dl,%ch
221: mov head,%dx
222: mov %dl,%dh
223: mov $0,%dl
224: and $0x0100,%dx
225: mov $2,%ah
226: int 0x13
227: jc bad_rt
228: pop %dx
229: pop %cx
230: pop %bx
231: pop %ax
232: ret
233: bad_rt: mov %ax,$0
234: mov $0,%dx
235: int 0x13
236: pop %dx
237: pop %cx
238: pop %bx
239: pop %ax
240: jmp read_track
241:
242: /*
243: * This procedure turns off the floppy drive motor, so
244: * that we enter the kernel in a known state, and
245: * don't have to worry about it later.
246: */
247: kill_motor:
248: push %dx
249: mov $0x3f2,%dx
250: mov $0,%al
251: outb
252: pop %dx
253: ret
254:
255: sectors:
256: .word 0
257:
258: msg1:
259: .byte 13,10
260: .ascii "Loading system ..."
261: .byte 13,10,13,10
262:
263: .org 508
264: root_dev:
265: .word ROOT_DEV
266: boot_flag:
267: .word 0xAA55
268:
269: .text
270: endtext:
271: .data
272: enddata:
273: .bss
274: endbss:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.