Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


*** empty log message ***
[palacios.git] / palacios / src / geekos / setup.asm
1 ; -*- fundamental -*-
2 ; GeekOS setup code
3 ; Copyright (c) 2001,2004 David H. Hovemeyer <daveho@cs.umd.edu>
4 ; $Revision: 1.3 $
5
6 ; This is free software.  You are permitted to use,
7 ; redistribute, and modify it as specified in the file "COPYING".
8
9 ; A lot of this code is adapted from Kernel Toolkit 0.2
10 ; and Linux version 2.2.x, so the following copyrights apply:
11
12 ; Copyright (C) 1991, 1992 Linus Torvalds
13 ; modified by Drew Eckhardt
14 ; modified by Bruce Evans (bde)
15 ; adapted for Kernel Toolkit by Luigi Sgro
16
17 %include "defs.asm"
18
19 [BITS 16]
20 [ORG 0x0]
21
22 start_setup:
23
24         ; Redefine the data segment so we can access variables
25         ; declared in this file.
26         mov     ax, SETUPSEG
27         mov     ds, ax
28
29         ; Use int 15h to find out size of extended memory in KB.
30         ; Extended memory is the memory above 1MB.  So by
31         ; adding 1MB to this amount, we get the total amount
32         ; of system memory.  We can only detect 64MB this way,
33         ; but that's OK for now.
34         ;mov    ah, 0x88
35         ;int    0x15
36         ;add    ax, 1024        ; 1024 KB == 1 MB
37         mov     ax, 0xe801
38         int     0x15
39         add     ax, 1024        ; 1024 KB == 1 MB
40         mov     [mem_size_kbytes], ax
41         mov     [mem_size_eblocks], bx
42
43         ; Kill the floppy motor.
44         call    Kill_Motor
45
46         ; Block interrupts, since we can't meaningfully handle them yet
47         ; and we no longer need BIOS services.
48         cli
49
50         ; Set up IDT and GDT registers
51         lidt    [IDT_Pointer]
52         lgdt    [GDT_Pointer]
53
54         ; Initialize the interrupt controllers, and enable the
55         ; A20 address line
56         call    Init_PIC
57         call    Enable_A20
58
59         ; Switch to protected mode!
60         mov     ax, 0x01
61         lmsw    ax
62
63         ; Jump to 32 bit code.
64         jmp     dword KERNEL_CS:(SETUPSEG << 4) + setup_32
65
66 [BITS 32]
67 setup_32:
68
69         ; set up data segment registers
70         mov     ax, KERNEL_DS
71         mov     ds, ax
72         mov     es, ax
73         mov     fs, ax
74         mov     gs, ax
75         mov     ss, ax
76
77         ; Create the stack for the initial kernel thread.
78         mov     esp, KERN_STACK + 4096
79
80         ; Build Boot_Info struct on stack.
81         ; Note that we push the fields on in reverse order,
82         ; since the stack grows downwards.
83         xor     eax, eax
84         mov     ax, [(SETUPSEG<<4)+mem_size_kbytes]
85         xor     ebx, ebx
86         mov     bx, [(SETUPSEG<<4)+mem_size_eblocks]
87         shl     ebx, 6
88         add     eax, ebx
89         push    eax             ; memSizeKB
90         
91         mov     eax, GUEST_SIZE 
92         shl     eax, 9          ; Multiply the guest size by 512 to get byte size
93         push    eax             ; Size of the guest kernel
94
95         mov     eax, 0x100000
96         push    eax             ; Load address of the guest
97         
98         mov     eax, VMM_SIZE
99         shl     eax, 9          ; Multiply the vmm size by 512 to get byte size
100         push    eax             ; size of the VMM
101
102         push    dword 8         ; bootInfoSize
103
104         ; Pass pointer to Boot_Info struct as argument to kernel
105         ; entry point.
106         push    esp
107
108         ; Push return address to make this look like a call
109         ; XXX - untested
110         push    dword (SETUPSEG<<4)+.returnAddr
111
112
113         ; Far jump into kernel
114         jmp     KERNEL_CS:ENTRY_POINT
115
116 .returnAddr:
117         ; We shouldn't return here.
118 .here:  jmp .here
119
120
121
122
123 [BITS 16]
124
125 ; Kill the floppy motor.
126 ; This code was shamelessly stolen from Linux.
127 Kill_Motor:
128         mov     dx, 0x3f2
129         xor     al, al
130         out     dx, al
131         ret
132
133 Init_PIC:
134         ; Initialize master and slave PIC!
135         mov     al, ICW1
136         out     0x20, al                ; ICW1 to master
137         call    Delay
138         out     0xA0, al                ; ICW1 to slave
139         call    Delay
140         mov     al, ICW2_MASTER
141         out     0x21, al                ; ICW2 to master
142         call    Delay
143         mov     al, ICW2_SLAVE
144         out     0xA1, al                ; ICW2 to slave
145         call    Delay
146         mov     al, ICW3_MASTER
147         out     0x21, al                ; ICW3 to master
148         call    Delay
149         mov     al, ICW3_SLAVE
150         out     0xA1, al                ; ICW3 to slave
151         call    Delay
152         mov     al, ICW4
153         out     0x21, al                ; ICW4 to master
154         call    Delay
155         out     0xA1, al                ; ICW4 to slave
156         call    Delay
157         mov     al, 0xff                ; mask all ints in slave
158         out     0xA1, al                ; OCW1 to slave
159         call    Delay
160         mov     al, 0xfb                ; mask all ints but 2 in master
161         out     0x21, al                ; OCW1 to master
162         call    Delay
163         ret
164
165 ; Linux uses this code.
166 ; The idea is that some systems issue port I/O instructions
167 ; faster than the device hardware can deal with them.
168 Delay:
169         jmp     .done
170 .done:  ret
171
172 ; Enable the A20 address line, so we can correctly address
173 ; memory above 1MB.
174 Enable_A20:
175         mov     al, 0xD1
176         out     0x64, al
177         call    Delay
178         mov     al, 0xDF
179         out     0x60, al
180         call    Delay
181         ret
182
183
184 ; ----------------------------------------------------------------------
185 ; Setup data
186 ; ----------------------------------------------------------------------
187
188 mem_size_kbytes: dw 0
189 mem_size_eblocks: dw 0
190
191 ; ----------------------------------------------------------------------
192 ; The GDT.  Creates flat 32-bit address space for the kernel
193 ; code, data, and stack.  Note that this GDT is just used
194 ; to create an environment where we can start running 32 bit
195 ; code.  The kernel will create and manage its own GDT.
196 ; ----------------------------------------------------------------------
197
198 ; GDT initialization stuff
199 NUM_GDT_ENTRIES equ 3           ; number of entries in GDT
200 GDT_ENTRY_SZ equ 8              ; size of a single GDT entry
201
202 align 8, db 0
203 GDT:
204         ; Descriptor 0 is not used
205         dw 0
206         dw 0
207         dw 0
208         dw 0
209
210         ; Descriptor 1: kernel code segment
211         dw 0xFFFF       ; bytes 0 and 1 of segment size
212         dw 0x0000       ; bytes 0 and 1 of segment base address
213         db 0x00         ; byte 2 of segment base address
214         db 0x9A         ; present, DPL=0, non-system, code, non-conforming,
215                         ;   readable, not accessed
216         db 0xCF         ; granularity=page, 32 bit code, upper nibble of size
217         db 0x00         ; byte 3 of segment base address
218
219         ; Descriptor 2: kernel data and stack segment
220         ; NOTE: what Intel calls an "expand-up" segment
221         ; actually means that the stack will grow DOWN,
222         ; towards lower memory.  So, we can use this descriptor
223         ; for both data and stack references.
224         dw 0xFFFF       ; bytes 0 and 1 of segment size
225         dw 0x0000       ; bytes 0 and 1 of segment base address
226         db 0x00         ; byte 2 of segment base address
227         db 0x92         ; present, DPL=0, non-system, data, expand-up,
228                         ;   writable, not accessed
229         db 0xCF         ; granularity=page, big, upper nibble of size
230         db 0x00         ; byte 3 of segment base address
231
232 GDT_Pointer:
233         dw NUM_GDT_ENTRIES*GDT_ENTRY_SZ ; limit
234         dd (SETUPSEG<<4) + GDT          ; base address
235
236 IDT_Pointer:
237         dw 0
238         dd 00