Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/boot/head.S | |
3 | * | |
4 | * Copyright (C) 1991, 1992, 1993 Linus Torvalds | |
1da177e4 LT |
5 | */ |
6 | ||
7 | /* | |
8 | * head.S contains the 32-bit startup code. | |
9 | * | |
10 | * NOTE!!! Startup happens at absolute address 0x00001000, which is also where | |
11 | * the page directory will exist. The startup code will be overwritten by | |
12 | * the page directory. [According to comments etc elsewhere on a compressed | |
13 | * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC] | |
14 | * | |
15 | * Page 0 is deliberately kept safe, since System Management Mode code in | |
16 | * laptops may need to access the BIOS data stored there. This is also | |
17 | * useful for future device drivers that either access the BIOS via VM86 | |
18 | * mode. | |
19 | */ | |
20 | ||
21 | /* | |
f4549448 | 22 | * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996 |
1da177e4 | 23 | */ |
b40d68d5 PA |
24 | .code32 |
25 | .text | |
1da177e4 | 26 | |
1dc818c1 | 27 | #include <linux/init.h> |
1da177e4 LT |
28 | #include <linux/linkage.h> |
29 | #include <asm/segment.h> | |
0341c14d JF |
30 | #include <asm/pgtable_types.h> |
31 | #include <asm/page_types.h> | |
7c539764 | 32 | #include <asm/boot.h> |
1ab60e0f | 33 | #include <asm/msr.h> |
e83e31f4 | 34 | #include <asm/processor-flags.h> |
bd53147d | 35 | #include <asm/asm-offsets.h> |
1da177e4 | 36 | |
1dc818c1 | 37 | __HEAD |
1da177e4 | 38 | .code32 |
2d4eeecb | 39 | ENTRY(startup_32) |
1da177e4 | 40 | cld |
b40d68d5 PA |
41 | /* |
42 | * Test KEEP_SEGMENTS flag to see if the bootloader is asking | |
43 | * us to not reload segments | |
44 | */ | |
bd53147d EB |
45 | testb $(1<<6), BP_loadflags(%esi) |
46 | jnz 1f | |
47 | ||
1da177e4 | 48 | cli |
1ab60e0f VG |
49 | movl $(__KERNEL_DS), %eax |
50 | movl %eax, %ds | |
51 | movl %eax, %es | |
52 | movl %eax, %ss | |
bd53147d | 53 | 1: |
1ab60e0f | 54 | |
b40d68d5 PA |
55 | /* |
56 | * Calculate the delta between where we were compiled to run | |
1ab60e0f VG |
57 | * at and where we were actually loaded at. This can only be done |
58 | * with a short local call on x86. Nothing else will tell us what | |
59 | * address we are running at. The reserved chunk of the real-mode | |
85414b69 PA |
60 | * data at 0x1e4 (defined as a scratch field) are used as the stack |
61 | * for this calculation. Only 4 bytes are needed. | |
1ab60e0f | 62 | */ |
bd2a3698 | 63 | leal (BP_scratch+4)(%esi), %esp |
1ab60e0f VG |
64 | call 1f |
65 | 1: popl %ebp | |
66 | subl $1b, %ebp | |
67 | ||
a4831e08 | 68 | /* setup a stack and make sure cpu supports long mode. */ |
7c539764 | 69 | movl $boot_stack_end, %eax |
a4831e08 VG |
70 | addl %ebp, %eax |
71 | movl %eax, %esp | |
72 | ||
73 | call verify_cpu | |
74 | testl %eax, %eax | |
75 | jnz no_longmode | |
76 | ||
b40d68d5 PA |
77 | /* |
78 | * Compute the delta between where we were compiled to run at | |
1ab60e0f | 79 | * and where the code will actually run at. |
b40d68d5 PA |
80 | * |
81 | * %ebp contains the address we are loaded at by the boot loader and %ebx | |
1ab60e0f VG |
82 | * contains the address where we should move the kernel image temporarily |
83 | * for safe in-place decompression. | |
84 | */ | |
85 | ||
86 | #ifdef CONFIG_RELOCATABLE | |
87 | movl %ebp, %ebx | |
37ba7ab5 PA |
88 | movl BP_kernel_alignment(%esi), %eax |
89 | decl %eax | |
90 | addl %eax, %ebx | |
91 | notl %eax | |
92 | andl %eax, %ebx | |
1ab60e0f | 93 | #else |
40b387a8 | 94 | movl $LOAD_PHYSICAL_ADDR, %ebx |
1ab60e0f VG |
95 | #endif |
96 | ||
02a884c0 PA |
97 | /* Target address to relocate to for decompression */ |
98 | addl $z_extract_offset, %ebx | |
1da177e4 LT |
99 | |
100 | /* | |
1ab60e0f | 101 | * Prepare for entering 64 bit mode |
1da177e4 | 102 | */ |
1ab60e0f VG |
103 | |
104 | /* Load new GDT with the 64bit segments using 32bit descriptor */ | |
105 | leal gdt(%ebp), %eax | |
106 | movl %eax, gdt+2(%ebp) | |
107 | lgdt gdt(%ebp) | |
108 | ||
109 | /* Enable PAE mode */ | |
4868402d | 110 | movl $(X86_CR4_PAE), %eax |
1ab60e0f VG |
111 | movl %eax, %cr4 |
112 | ||
113 | /* | |
114 | * Build early 4G boot pagetable | |
115 | */ | |
b40d68d5 | 116 | /* Initialize Page tables to 0 */ |
1ab60e0f VG |
117 | leal pgtable(%ebx), %edi |
118 | xorl %eax, %eax | |
119 | movl $((4096*6)/4), %ecx | |
120 | rep stosl | |
121 | ||
122 | /* Build Level 4 */ | |
123 | leal pgtable + 0(%ebx), %edi | |
124 | leal 0x1007 (%edi), %eax | |
125 | movl %eax, 0(%edi) | |
126 | ||
127 | /* Build Level 3 */ | |
128 | leal pgtable + 0x1000(%ebx), %edi | |
129 | leal 0x1007(%edi), %eax | |
130 | movl $4, %ecx | |
131 | 1: movl %eax, 0x00(%edi) | |
132 | addl $0x00001000, %eax | |
133 | addl $8, %edi | |
134 | decl %ecx | |
135 | jnz 1b | |
136 | ||
137 | /* Build Level 2 */ | |
138 | leal pgtable + 0x2000(%ebx), %edi | |
139 | movl $0x00000183, %eax | |
140 | movl $2048, %ecx | |
141 | 1: movl %eax, 0(%edi) | |
142 | addl $0x00200000, %eax | |
143 | addl $8, %edi | |
144 | decl %ecx | |
145 | jnz 1b | |
146 | ||
147 | /* Enable the boot page tables */ | |
148 | leal pgtable(%ebx), %eax | |
149 | movl %eax, %cr3 | |
150 | ||
151 | /* Enable Long mode in EFER (Extended Feature Enable Register) */ | |
152 | movl $MSR_EFER, %ecx | |
153 | rdmsr | |
154 | btsl $_EFER_LME, %eax | |
155 | wrmsr | |
156 | ||
b40d68d5 PA |
157 | /* |
158 | * Setup for the jump to 64bit mode | |
1ab60e0f VG |
159 | * |
160 | * When the jump is performend we will be in long mode but | |
161 | * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1 | |
162 | * (and in turn EFER.LMA = 1). To jump into 64bit mode we use | |
163 | * the new gdt/idt that has __KERNEL_CS with CS.L = 1. | |
164 | * We place all of the values on our mini stack so lret can | |
165 | * used to perform that far jump. | |
166 | */ | |
167 | pushl $__KERNEL_CS | |
168 | leal startup_64(%ebp), %eax | |
169 | pushl %eax | |
170 | ||
171 | /* Enter paged protected Mode, activating Long Mode */ | |
e83e31f4 | 172 | movl $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */ |
1ab60e0f VG |
173 | movl %eax, %cr0 |
174 | ||
175 | /* Jump from 32bit compatibility mode into 64bit mode. */ | |
176 | lret | |
2d4eeecb | 177 | ENDPROC(startup_32) |
1ab60e0f | 178 | |
a4831e08 VG |
179 | no_longmode: |
180 | /* This isn't an x86-64 CPU so hang */ | |
181 | 1: | |
182 | hlt | |
183 | jmp 1b | |
184 | ||
c5cbac69 | 185 | #include "../../kernel/verify_cpu.S" |
a4831e08 | 186 | |
b40d68d5 PA |
187 | /* |
188 | * Be careful here startup_64 needs to be at a predictable | |
1ab60e0f VG |
189 | * address so I can export it in an ELF header. Bootloaders |
190 | * should look at the ELF header to find this address, as | |
191 | * it may change in the future. | |
192 | */ | |
193 | .code64 | |
a4831e08 | 194 | .org 0x200 |
1ab60e0f | 195 | ENTRY(startup_64) |
b40d68d5 PA |
196 | /* |
197 | * We come here either from startup_32 or directly from a | |
1ab60e0f VG |
198 | * 64bit bootloader. If we come here from a bootloader we depend on |
199 | * an identity mapped page table being provied that maps our | |
200 | * entire text+data+bss and hopefully all of memory. | |
201 | */ | |
291f3632 | 202 | #ifdef CONFIG_EFI_STUB |
b1994304 | 203 | /* |
99f857db DW |
204 | * The entry point for the PE/COFF executable is efi_pe_entry, so |
205 | * only legacy boot loaders will execute this jmp. | |
b1994304 MF |
206 | */ |
207 | jmp preferred_addr | |
208 | ||
99f857db | 209 | ENTRY(efi_pe_entry) |
291f3632 MF |
210 | mov %rcx, %rdi |
211 | mov %rdx, %rsi | |
9ca8f72a MF |
212 | pushq %rdi |
213 | pushq %rsi | |
214 | call make_boot_params | |
215 | cmpq $0,%rax | |
216 | je 1f | |
217 | mov %rax, %rdx | |
218 | popq %rsi | |
219 | popq %rdi | |
220 | ||
99f857db | 221 | ENTRY(efi_stub_entry) |
291f3632 | 222 | call efi_main |
291f3632 | 223 | movq %rax,%rsi |
b1994304 MF |
224 | cmpq $0,%rax |
225 | jne 2f | |
291f3632 | 226 | 1: |
b1994304 MF |
227 | /* EFI init failed, so hang. */ |
228 | hlt | |
229 | jmp 1b | |
230 | 2: | |
231 | call 3f | |
232 | 3: | |
291f3632 | 233 | popq %rax |
b1994304 | 234 | subq $3b, %rax |
291f3632 MF |
235 | subq BP_pref_address(%rsi), %rax |
236 | add BP_code32_start(%esi), %eax | |
237 | leaq preferred_addr(%rax), %rax | |
238 | jmp *%rax | |
239 | ||
240 | preferred_addr: | |
241 | #endif | |
1ab60e0f VG |
242 | |
243 | /* Setup data segments. */ | |
244 | xorl %eax, %eax | |
245 | movl %eax, %ds | |
246 | movl %eax, %es | |
247 | movl %eax, %ss | |
08da5a2c ZA |
248 | movl %eax, %fs |
249 | movl %eax, %gs | |
250 | lldt %ax | |
251 | movl $0x20, %eax | |
252 | ltr %ax | |
1ab60e0f | 253 | |
b40d68d5 PA |
254 | /* |
255 | * Compute the decompressed kernel start address. It is where | |
1ab60e0f VG |
256 | * we were loaded at aligned to a 2M boundary. %rbp contains the |
257 | * decompressed kernel start address. | |
258 | * | |
259 | * If it is a relocatable kernel then decompress and run the kernel | |
260 | * from load address aligned to 2MB addr, otherwise decompress and | |
40b387a8 | 261 | * run the kernel from LOAD_PHYSICAL_ADDR |
02a884c0 PA |
262 | * |
263 | * We cannot rely on the calculation done in 32-bit mode, since we | |
264 | * may have been invoked via the 64-bit entry point. | |
1ab60e0f VG |
265 | */ |
266 | ||
267 | /* Start with the delta to where the kernel will run at. */ | |
268 | #ifdef CONFIG_RELOCATABLE | |
269 | leaq startup_32(%rip) /* - $startup_32 */, %rbp | |
37ba7ab5 PA |
270 | movl BP_kernel_alignment(%rsi), %eax |
271 | decl %eax | |
272 | addq %rax, %rbp | |
273 | notq %rax | |
274 | andq %rax, %rbp | |
1ab60e0f | 275 | #else |
40b387a8 | 276 | movq $LOAD_PHYSICAL_ADDR, %rbp |
1ab60e0f VG |
277 | #endif |
278 | ||
02a884c0 PA |
279 | /* Target address to relocate to for decompression */ |
280 | leaq z_extract_offset(%rbp), %rbx | |
1ab60e0f | 281 | |
0a137736 PA |
282 | /* Set up the stack */ |
283 | leaq boot_stack_end(%rbx), %rsp | |
284 | ||
285 | /* Zero EFLAGS */ | |
286 | pushq $0 | |
287 | popfq | |
288 | ||
b40d68d5 PA |
289 | /* |
290 | * Copy the compressed kernel to the end of our buffer | |
1ab60e0f VG |
291 | * where decompression in place becomes safe. |
292 | */ | |
36d3793c PA |
293 | pushq %rsi |
294 | leaq (_bss-8)(%rip), %rsi | |
295 | leaq (_bss-8)(%rbx), %rdi | |
5b11f1ce | 296 | movq $_bss /* - $startup_32 */, %rcx |
36d3793c PA |
297 | shrq $3, %rcx |
298 | std | |
299 | rep movsq | |
300 | cld | |
301 | popq %rsi | |
1ab60e0f VG |
302 | |
303 | /* | |
304 | * Jump to the relocated address. | |
305 | */ | |
306 | leaq relocated(%rbx), %rax | |
307 | jmp *%rax | |
308 | ||
b40d68d5 | 309 | .text |
1ab60e0f VG |
310 | relocated: |
311 | ||
1da177e4 | 312 | /* |
0a137736 | 313 | * Clear BSS (stack is currently empty) |
1da177e4 | 314 | */ |
36d3793c PA |
315 | xorl %eax, %eax |
316 | leaq _bss(%rip), %rdi | |
317 | leaq _ebss(%rip), %rcx | |
1ab60e0f | 318 | subq %rdi, %rcx |
36d3793c PA |
319 | shrq $3, %rcx |
320 | rep stosq | |
1ab60e0f | 321 | |
22a57f58 PA |
322 | /* |
323 | * Adjust our own GOT | |
324 | */ | |
325 | leaq _got(%rip), %rdx | |
326 | leaq _egot(%rip), %rcx | |
327 | 1: | |
328 | cmpq %rcx, %rdx | |
329 | jae 2f | |
330 | addq %rbx, (%rdx) | |
331 | addq $8, %rdx | |
332 | jmp 1b | |
333 | 2: | |
334 | ||
1da177e4 LT |
335 | /* |
336 | * Do the decompression, and jump to the new kernel.. | |
337 | */ | |
02a884c0 PA |
338 | pushq %rsi /* Save the real mode argument */ |
339 | movq %rsi, %rdi /* real mode address */ | |
340 | leaq boot_heap(%rip), %rsi /* malloc area for uncompression */ | |
341 | leaq input_data(%rip), %rdx /* input_data */ | |
342 | movl $z_input_len, %ecx /* input_len */ | |
343 | movq %rbp, %r8 /* output target address */ | |
1ab60e0f VG |
344 | call decompress_kernel |
345 | popq %rsi | |
1da177e4 | 346 | |
1da177e4 | 347 | /* |
1ab60e0f | 348 | * Jump to the decompressed kernel. |
1da177e4 | 349 | */ |
1ab60e0f | 350 | jmp *%rbp |
1da177e4 | 351 | |
1ab60e0f VG |
352 | .data |
353 | gdt: | |
354 | .word gdt_end - gdt | |
355 | .long gdt | |
356 | .word 0 | |
357 | .quad 0x0000000000000000 /* NULL descriptor */ | |
358 | .quad 0x00af9a000000ffff /* __KERNEL_CS */ | |
359 | .quad 0x00cf92000000ffff /* __KERNEL_DS */ | |
08da5a2c ZA |
360 | .quad 0x0080890000000000 /* TS descriptor */ |
361 | .quad 0x0000000000000000 /* TS continued */ | |
1ab60e0f | 362 | gdt_end: |
7c539764 | 363 | |
b40d68d5 PA |
364 | /* |
365 | * Stack and heap for uncompression | |
366 | */ | |
367 | .bss | |
368 | .balign 4 | |
7c539764 AH |
369 | boot_heap: |
370 | .fill BOOT_HEAP_SIZE, 1, 0 | |
371 | boot_stack: | |
372 | .fill BOOT_STACK_SIZE, 1, 0 | |
373 | boot_stack_end: | |
5b11f1ce PA |
374 | |
375 | /* | |
376 | * Space for page tables (not in .bss so not zeroed) | |
377 | */ | |
378 | .section ".pgtable","a",@nobits | |
379 | .balign 4096 | |
380 | pgtable: | |
381 | .fill 6*4096, 1, 0 |