![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to setup.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / boot|
Return to setup.s CVS log | Up to [Early Linux] / linux / boot |
1.1 root 1: |
2: | setup.s (C) 1991 Linus Torvalds
3: |
4: | setup.s is responsible for getting the system data from the BIOS,
5: | and putting them into the appropriate places in system memory.
6: | both setup.s and system has been loaded by the bootblock.
7: |
8: | This code asks the bios for memory/disk/other parameters, and
9: | puts them in a "safe" place: 0x90000-0x901FF, ie where the
10: | boot-block used to be. It is then up to the protected mode
11: | system to read them from there before the area is overwritten
12: | for buffer-blocks.
13: |
14:
15: | NOTE! These had better be the same as in bootsect.s!
16:
17: INITSEG = 0x9000 | we move boot here - out of the way
18: SYSSEG = 0x1000 | system loaded at 0x10000 (65536).
19: SETUPSEG = 0x9020 | this is the current segment
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: entry start
31: start:
32:
33: | ok, the read went well so we get current cursor position and save it for
34: | posterity.
35:
36: mov ax,#INITSEG | this is done in bootsect already, but...
37: mov ds,ax
38: mov ah,#0x03 | read cursor pos
39: xor bh,bh
40: int 0x10 | save it in known place, con_init fetches
41: mov [0],dx | it from 0x90000.
42:
43: | Get memory size (extended mem, kB)
44:
45: mov ah,#0x88
46: int 0x15
47: mov [2],ax
48:
49: | Get hd0 data
50:
51: mov ax,#0x0000
52: mov ds,ax
53: lds si,[4*0x41]
54: mov ax,#INITSEG
55: mov es,ax
56: mov di,#0x0080
57: mov cx,#0x10
58: rep
59: movsb
60:
61: | Get hd1 data
62:
63: mov ax,#0x0000
64: mov ds,ax
65: lds si,[4*0x46]
66: mov ax,#INITSEG
67: mov es,ax
68: mov di,#0x0090
69: mov cx,#0x10
70: rep
71: movsb
72:
73: | Check that there IS a hd1 :-)
74:
75: mov ax,#0x01500
76: mov dl,#0x81
77: int 0x13
78: jc no_disk1
79: cmp ah,#3
80: je is_disk1
81: no_disk1:
82: mov ax,#INITSEG
83: mov es,ax
84: mov di,#0x0090
85: mov cx,#0x10
86: mov ax,#0x00
87: rep
88: stosb
89: is_disk1:
90:
91: | now we want to move to protected mode ...
92:
93: cli | no interrupts allowed !
94:
95: | first we move the system to it's rightful place
96:
97: mov ax,#0x0000
98: cld | 'direction'=0, movs moves forward
99: do_move:
100: mov es,ax | destination segment
101: add ax,#0x1000
102: cmp ax,#0x9000
103: jz end_move
104: mov ds,ax | source segment
105: sub di,di
106: sub si,si
107: mov cx,#0x8000
108: rep
109: movsw
110: jmp do_move
111:
112: | then we load the segment descriptors
113:
114: end_move:
115: mov ax,#SETUPSEG | right, forgot this at first. didn't work :-)
116: mov ds,ax
117: lidt idt_48 | load idt with 0,0
118: lgdt gdt_48 | load gdt with whatever appropriate
119:
120: | that was painless, now we enable A20
121:
122: call empty_8042
123: mov al,#0xD1 | command write
124: out #0x64,al
125: call empty_8042
126: mov al,#0xDF | A20 on
127: out #0x60,al
128: call empty_8042
129:
130: | well, that went ok, I hope. Now we have to reprogram the interrupts :-(
131: | we put them right after the intel-reserved hardware interrupts, at
132: | int 0x20-0x2F. There they won't mess up anything. Sadly IBM really
133: | messed this up with the original PC, and they haven't been able to
134: | rectify it afterwards. Thus the bios puts interrupts at 0x08-0x0f,
135: | which is used for the internal hardware interrupts as well. We just
136: | have to reprogram the 8259's, and it isn't fun.
137:
138: mov al,#0x11 | initialization sequence
139: out #0x20,al | send it to 8259A-1
140: .word 0x00eb,0x00eb | jmp $+2, jmp $+2
141: out #0xA0,al | and to 8259A-2
142: .word 0x00eb,0x00eb
143: mov al,#0x20 | start of hardware int's (0x20)
144: out #0x21,al
145: .word 0x00eb,0x00eb
146: mov al,#0x28 | start of hardware int's 2 (0x28)
147: out #0xA1,al
148: .word 0x00eb,0x00eb
149: mov al,#0x04 | 8259-1 is master
150: out #0x21,al
151: .word 0x00eb,0x00eb
152: mov al,#0x02 | 8259-2 is slave
153: out #0xA1,al
154: .word 0x00eb,0x00eb
155: mov al,#0x01 | 8086 mode for both
156: out #0x21,al
157: .word 0x00eb,0x00eb
158: out #0xA1,al
159: .word 0x00eb,0x00eb
160: mov al,#0xFF | mask off all interrupts for now
161: out #0x21,al
162: .word 0x00eb,0x00eb
163: out #0xA1,al
164:
165: | well, that certainly wasn't fun :-(. Hopefully it works, and we don't
166: | need no steenking BIOS anyway (except for the initial loading :-).
167: | The BIOS-routine wants lots of unnecessary data, and it's less
168: | "interesting" anyway. This is how REAL programmers do it.
169: |
170: | Well, now's the time to actually move into protected mode. To make
171: | things as simple as possible, we do no register set-up or anything,
172: | we let the gnu-compiled 32-bit programs do that. We just jump to
173: | absolute address 0x00000, in 32-bit protected mode.
174:
175: mov ax,#0x0001 | protected mode (PE) bit
176: lmsw ax | This is it!
177: jmpi 0,8 | jmp offset 0 of segment 8 (cs)
178:
179: | This routine checks that the keyboard command queue is empty
180: | No timeout is used - if this hangs there is something wrong with
181: | the machine, and we probably couldn't proceed anyway.
182: empty_8042:
183: .word 0x00eb,0x00eb
184: in al,#0x64 | 8042 status port
185: test al,#2 | is input buffer full?
186: jnz empty_8042 | yes - loop
187: ret
188:
189: gdt:
190: .word 0,0,0,0 | dummy
191:
192: .word 0x07FF | 8Mb - limit=2047 (2048*4096=8Mb)
193: .word 0x0000 | base address=0
194: .word 0x9A00 | code read/exec
195: .word 0x00C0 | granularity=4096, 386
196:
197: .word 0x07FF | 8Mb - limit=2047 (2048*4096=8Mb)
198: .word 0x0000 | base address=0
199: .word 0x9200 | data read/write
200: .word 0x00C0 | granularity=4096, 386
201:
202: idt_48:
203: .word 0 | idt limit=0
204: .word 0,0 | idt base=0L
205:
206: gdt_48:
207: .word 0x800 | gdt limit=2048, 256 GDT entries
208: .word 512+gdt,0x9 | gdt base = 0X9xxxx
209:
210: .text
211: endtext:
212: .data
213: enddata:
214: .bss
215: endbss:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.