Linux 0.11/boot/setup.s

  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 video-card data:
50
51         mov     ah,#0x0f
52         int     0x10
53         mov     [4],bx          ! bh = display page
54         mov     [6],ax          ! al = video mode, ah = window width
55
56 ! check for EGA/VGA and some config parameters
57
58         mov     ah,#0x12
59         mov     bl,#0x10
60         int     0x10
61         mov     [8],ax
62         mov     [10],bx
63         mov     [12],cx
64
65 ! Get hd0 data
66
67         mov     ax,#0x0000
68         mov     ds,ax
69         lds     si,[4*0x41]
70         mov     ax,#INITSEG
71         mov     es,ax
72         mov     di,#0x0080
73         mov     cx,#0x10
74         rep
75         movsb
76
77 ! Get hd1 data
78
79         mov     ax,#0x0000
80         mov     ds,ax
81         lds     si,[4*0x46]
82         mov     ax,#INITSEG
83         mov     es,ax
84         mov     di,#0x0090
85         mov     cx,#0x10
86         rep
87         movsb
88
89 ! Check that there IS a hd1 :-)
90
91         mov     ax,#0x01500
92         mov     dl,#0x81
93         int     0x13
94         jc      no_disk1
95         cmp     ah,#3
96         je      is_disk1
97 no_disk1:
98         mov     ax,#INITSEG
99         mov     es,ax
100         mov     di,#0x0090
101         mov     cx,#0x10
102         mov     ax,#0x00
103         rep
104         stosb
105 is_disk1:
106
107 ! now we want to move to protected mode ...
108
109         cli                     ! no interrupts allowed !
110
111 ! first we move the system to it's rightful place
112
113         mov     ax,#0x0000
114         cld                     ! 'direction'=0, movs moves forward
115 do_move:
116         mov     es,ax           ! destination segment
117         add     ax,#0x1000
118         cmp     ax,#0x9000
119         jz      end_move
120         mov     ds,ax           ! source segment
121         sub     di,di
122         sub     si,si
123         mov     cx,#0x8000
124         rep
125         movsw
126         jmp     do_move
127
128 ! then we load the segment descriptors
129
130 end_move:
131         mov     ax,#SETUPSEG    ! right, forgot this at first. didn't work :-)
132         mov     ds,ax
133         lidt    idt_48          ! load idt with 0,0
134         lgdt    gdt_48          ! load gdt with whatever appropriate
135
136 ! that was painless, now we enable A20
137
138         call    empty_8042
139         mov     al,#0xD1                ! command write
140         out     #0x64,al
141         call    empty_8042
142         mov     al,#0xDF                ! A20 on
143         out     #0x60,al
144         call    empty_8042
145
146 ! well, that went ok, I hope. Now we have to reprogram the interrupts :-(
147 ! we put them right after the intel-reserved hardware interrupts, at
148 ! int 0x20-0x2F. There they won't mess up anything. Sadly IBM really
149 ! messed this up with the original PC, and they haven't been able to
150 ! rectify it afterwards. Thus the bios puts interrupts at 0x08-0x0f,
151 ! which is used for the internal hardware interrupts as well. We just
152 ! have to reprogram the 8259's, and it isn't fun.
153
154         mov     al,#0x11                ! initialization sequence
155         out     #0x20,al                ! send it to 8259A-1
156         .word   0x00eb,0x00eb           ! jmp $+2, jmp $+2
157         out     #0xA0,al                ! and to 8259A-2
158         .word   0x00eb,0x00eb
159         mov     al,#0x20                ! start of hardware int's (0x20)
160         out     #0x21,al
161         .word   0x00eb,0x00eb
162         mov     al,#0x28                ! start of hardware int's 2 (0x28)
163         out     #0xA1,al
164         .word   0x00eb,0x00eb
165         mov     al,#0x04                ! 8259-1 is master
166         out     #0x21,al
167         .word   0x00eb,0x00eb
168         mov     al,#0x02                ! 8259-2 is slave
169         out     #0xA1,al
170         .word   0x00eb,0x00eb
171         mov     al,#0x01                ! 8086 mode for both
172         out     #0x21,al
173         .word   0x00eb,0x00eb
174         out     #0xA1,al
175         .word   0x00eb,0x00eb
176         mov     al,#0xFF                ! mask off all interrupts for now
177         out     #0x21,al
178         .word   0x00eb,0x00eb
179         out     #0xA1,al
180
181 ! well, that certainly wasn't fun :-(. Hopefully it works, and we don't
182 ! need no steenking BIOS anyway (except for the initial loading :-).
183 ! The BIOS-routine wants lots of unnecessary data, and it's less
184 ! "interesting" anyway. This is how REAL programmers do it.
185 !
186 ! Well, now's the time to actually move into protected mode. To make
187 ! things as simple as possible, we do no register set-up or anything,
188 ! we let the gnu-compiled 32-bit programs do that. We just jump to
189 ! absolute address 0x00000, in 32-bit protected mode.
190
191         mov     ax,#0x0001      ! protected mode (PE) bit
192         lmsw    ax              ! This is it!
193         jmpi    0,8             ! jmp offset 0 of segment 8 (cs)
194
195 ! This routine checks that the keyboard command queue is empty
196 ! No timeout is used - if this hangs there is something wrong with
197 ! the machine, and we probably couldn't proceed anyway.
198 empty_8042:
199         .word   0x00eb,0x00eb
200         in      al,#0x64        ! 8042 status port
201         test    al,#2           ! is input buffer full?
202         jnz     empty_8042      ! yes - loop
203         ret
204
205 gdt:
206         .word   0,0,0,0         ! dummy
207
208         .word   0x07FF          ! 8Mb - limit=2047 (2048*4096=8Mb)
209         .word   0x0000          ! base address=0
210         .word   0x9A00          ! code read/exec
211         .word   0x00C0          ! granularity=4096, 386
212
213         .word   0x07FF          ! 8Mb - limit=2047 (2048*4096=8Mb)
214         .word   0x0000          ! base address=0
215         .word   0x9200          ! data read/write
216         .word   0x00C0          ! granularity=4096, 386
217
218 idt_48:
219         .word   0                       ! idt limit=0
220         .word   0,0                     ! idt base=0L
221
222 gdt_48:
223         .word   0x800           ! gdt limit=2048, 256 GDT entries
224         .word   512+gdt,0x9     ! gdt base = 0X9xxxx
225        
226 .text
227 endtext:
228 .data
229 enddata:
230 .bss
231 endbss: