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