4 * Copyright (C) 1991, 1992, 1993 Linus Torvalds
8 * head.S contains the 32-bit startup code.
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]
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
22 * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
27 #include <lwk/linkage.h>
28 #include <arch/segment.h>
29 #include <arch/pgtable.h>
30 #include <arch/page.h>
40 movl $(__KERNEL_DS), %eax
45 /* Calculate the delta between where we were compiled to run
46 * at and where we were actually loaded at. This can only be done
47 * with a short local call on x86. Nothing else will tell us what
48 * address we are running at. The reserved chunk of the real-mode
49 * data at 0x34-0x3f are used as the stack for this calculation.
50 * Only 4 bytes are needed.
57 /* setup a stack and make sure cpu supports long mode. */
58 movl $user_stack_end, %eax
66 /* Compute the delta between where we were compiled to run at
67 * and where the code will actually run at.
69 /* %ebp contains the address we are loaded at by the boot loader and %ebx
70 * contains the address where we should move the kernel image temporarily
71 * for safe in-place decompression.
74 #ifdef CONFIG_RELOCATABLE
76 addl $(LARGE_PAGE_SIZE -1), %ebx
77 andl $LARGE_PAGE_MASK, %ebx
79 movl $CONFIG_PHYSICAL_START, %ebx
82 /* Replace the compressed data size with the uncompressed size */
83 subl input_len(%ebp), %ebx
84 movl output_len(%ebp), %eax
86 /* Add 8 bytes for every 32K input block */
89 /* Add 32K + 18 bytes of extra slack and align on a 4K boundary */
90 addl $(32768 + 18 + 4095), %ebx
94 * Prepare for entering 64 bit mode
97 /* Load new GDT with the 64bit segments using 32bit descriptor */
99 movl %eax, gdt+2(%ebp)
102 /* Enable PAE mode */
108 * Build early 4G boot pagetable
110 /* Initialize Page tables to 0*/
111 leal pgtable(%ebx), %edi
113 movl $((4096*6)/4), %ecx
117 leal pgtable + 0(%ebx), %edi
118 leal 0x1007 (%edi), %eax
122 leal pgtable + 0x1000(%ebx), %edi
123 leal 0x1007(%edi), %eax
125 1: movl %eax, 0x00(%edi)
126 addl $0x00001000, %eax
132 leal pgtable + 0x2000(%ebx), %edi
133 movl $0x00000183, %eax
135 1: movl %eax, 0(%edi)
136 addl $0x00200000, %eax
141 /* Enable the boot page tables */
142 leal pgtable(%ebx), %eax
145 /* Enable Long mode in EFER (Extended Feature Enable Register) */
148 btsl $_EFER_LME, %eax
151 /* Setup for the jump to 64bit mode
153 * When the jump is performend we will be in long mode but
154 * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
155 * (and in turn EFER.LMA = 1). To jump into 64bit mode we use
156 * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
157 * We place all of the values on our mini stack so lret can
158 * used to perform that far jump.
161 leal startup_64(%ebp), %eax
164 /* Enter paged protected Mode, activating Long Mode */
165 movl $0x80000001, %eax /* Enable Paging and Protected mode */
168 /* Jump from 32bit compatibility mode into 64bit mode. */
172 /* This isn't an x86-64 CPU so hang */
177 #include "../../kernel/verify_cpu.S"
179 /* Be careful here startup_64 needs to be at a predictable
180 * address so I can export it in an ELF header. Bootloaders
181 * should look at the ELF header to find this address, as
182 * it may change in the future.
187 /* We come here either from startup_32 or directly from a
188 * 64bit bootloader. If we come here from a bootloader we depend on
189 * an identity mapped page table being provied that maps our
190 * entire text+data+bss and hopefully all of memory.
193 /* Setup data segments. */
199 /* Compute the decompressed kernel start address. It is where
200 * we were loaded at aligned to a 2M boundary. %rbp contains the
201 * decompressed kernel start address.
203 * If it is a relocatable kernel then decompress and run the kernel
204 * from load address aligned to 2MB addr, otherwise decompress and
205 * run the kernel from CONFIG_PHYSICAL_START
208 /* Start with the delta to where the kernel will run at. */
209 #ifdef CONFIG_RELOCATABLE
210 leaq startup_32(%rip) /* - $startup_32 */, %rbp
211 addq $(LARGE_PAGE_SIZE - 1), %rbp
212 andq $LARGE_PAGE_MASK, %rbp
215 movq $CONFIG_PHYSICAL_START, %rbp
219 /* Replace the compressed data size with the uncompressed size */
220 movl input_len(%rip), %eax
222 movl output_len(%rip), %eax
224 /* Add 8 bytes for every 32K input block */
227 /* Add 32K + 18 bytes of extra slack and align on a 4K boundary */
228 addq $(32768 + 18 + 4095), %rbx
231 /* Copy the compressed kernel to the end of our buffer
232 * where decompression in place becomes safe.
236 movq $_end /* - $startup_32 */, %rcx
245 * Jump to the relocated address.
247 leaq relocated(%rbx), %rax
257 leaq _edata(%rbx), %rdi
258 leaq _end(%rbx), %rcx
264 /* Setup the stack */
265 leaq user_stack_end(%rip), %rsp
267 /* zero EFLAGS after setting rsp */
272 * Do the decompression, and jump to the new kernel..
274 pushq %rsi # Save the real mode argument
275 movq %rsi, %rdi # real mode address
276 leaq _heap(%rip), %rsi # _heap
277 leaq input_data(%rip), %rdx # input_data
278 movl input_len(%rip), %eax
279 movq %rax, %rcx # input_len
280 movq %rbp, %r8 # output
281 call decompress_kernel
286 * Jump to the decompressed kernel.
295 .quad 0x0000000000000000 /* NULL descriptor */
296 .quad 0x00af9a000000ffff /* __KERNEL_CS */
297 .quad 0x00cf92000000ffff /* __KERNEL_DS */
300 /* Stack for uncompression */