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
39ENTRY(startup_32)
40	cld
41	/*
42	 * Test KEEP_SEGMENTS flag to see if the bootloader is asking
43	 * us to not reload segments
44	 */
45	testb $(1<<6), BP_loadflags(%esi)
46	jnz 1f
47
48	cli
49	movl	$(__KERNEL_DS), %eax
50	movl	%eax, %ds
51	movl	%eax, %es
52	movl	%eax, %ss
531:
54
55/*
56 * Calculate the delta between where we were compiled to run
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
60 * data at 0x1e4 (defined as a scratch field) are used as the stack
61 * for this calculation. Only 4 bytes are needed.
62 */
63	leal	(BP_scratch+4)(%esi), %esp
64	call	1f
651:	popl	%ebp
66	subl	$1b, %ebp
67
68/* setup a stack and make sure cpu supports long mode. */
69	movl	$boot_stack_end, %eax
70	addl	%ebp, %eax
71	movl	%eax, %esp
72
73	call	verify_cpu
74	testl	%eax, %eax
75	jnz	no_longmode
76
77/*
78 * Compute the delta between where we were compiled to run at
79 * and where the code will actually run at.
80 *
81 * %ebp contains the address we are loaded at by the boot loader and %ebx
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
88	movl	BP_kernel_alignment(%esi), %eax
89	decl	%eax
90	addl	%eax, %ebx
91	notl	%eax
92	andl	%eax, %ebx
93#else
94	movl	$LOAD_PHYSICAL_ADDR, %ebx
95#endif
96
97	/* Target address to relocate to for decompression */
98	addl	$z_extract_offset, %ebx
99
100/*
101 * Prepare for entering 64 bit mode
102 */
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 */
110	movl	$(X86_CR4_PAE), %eax
111	movl	%eax, %cr4
112
113 /*
114  * Build early 4G boot pagetable
115  */
116	/* Initialize Page tables to 0 */
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
1311:	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
1411:	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
157	/*
158	 * Setup for the jump to 64bit mode
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 */
172	movl	$(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
173	movl	%eax, %cr0
174
175	/* Jump from 32bit compatibility mode into 64bit mode. */
176	lret
177ENDPROC(startup_32)
178
179no_longmode:
180	/* This isn't an x86-64 CPU so hang */
1811:
182	hlt
183	jmp     1b
184
185#include "../../kernel/verify_cpu.S"
186
187	/*
188	 * Be careful here startup_64 needs to be at a predictable
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
194	.org 0x200
195ENTRY(startup_64)
196	/*
197	 * We come here either from startup_32 or directly from a
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	 */
202#ifdef CONFIG_EFI_STUB
203	pushq	%rsi
204	mov	%rcx, %rdi
205	mov	%rdx, %rsi
206	call	efi_main
207	popq	%rsi
208	cmpq	$0,%rax
209	je	preferred_addr
210	movq	%rax,%rsi
211	call	1f
2121:
213	popq	%rax
214	subq	$1b, %rax
215	subq	BP_pref_address(%rsi), %rax
216	add	BP_code32_start(%esi), %eax
217	leaq	preferred_addr(%rax), %rax
218	jmp	*%rax
219
220preferred_addr:
221#endif
222
223	/* Setup data segments. */
224	xorl	%eax, %eax
225	movl	%eax, %ds
226	movl	%eax, %es
227	movl	%eax, %ss
228	movl	%eax, %fs
229	movl	%eax, %gs
230	lldt	%ax
231	movl    $0x20, %eax
232	ltr	%ax
233
234	/*
235	 * Compute the decompressed kernel start address.  It is where
236	 * we were loaded at aligned to a 2M boundary. %rbp contains the
237	 * decompressed kernel start address.
238	 *
239	 * If it is a relocatable kernel then decompress and run the kernel
240	 * from load address aligned to 2MB addr, otherwise decompress and
241	 * run the kernel from LOAD_PHYSICAL_ADDR
242	 *
243	 * We cannot rely on the calculation done in 32-bit mode, since we
244	 * may have been invoked via the 64-bit entry point.
245	 */
246
247	/* Start with the delta to where the kernel will run at. */
248#ifdef CONFIG_RELOCATABLE
249	leaq	startup_32(%rip) /* - $startup_32 */, %rbp
250	movl	BP_kernel_alignment(%rsi), %eax
251	decl	%eax
252	addq	%rax, %rbp
253	notq	%rax
254	andq	%rax, %rbp
255#else
256	movq	$LOAD_PHYSICAL_ADDR, %rbp
257#endif
258
259	/* Target address to relocate to for decompression */
260	leaq	z_extract_offset(%rbp), %rbx
261
262	/* Set up the stack */
263	leaq	boot_stack_end(%rbx), %rsp
264
265	/* Zero EFLAGS */
266	pushq	$0
267	popfq
268
269/*
270 * Copy the compressed kernel to the end of our buffer
271 * where decompression in place becomes safe.
272 */
273	pushq	%rsi
274	leaq	(_bss-8)(%rip), %rsi
275	leaq	(_bss-8)(%rbx), %rdi
276	movq	$_bss /* - $startup_32 */, %rcx
277	shrq	$3, %rcx
278	std
279	rep	movsq
280	cld
281	popq	%rsi
282
283/*
284 * Jump to the relocated address.
285 */
286	leaq	relocated(%rbx), %rax
287	jmp	*%rax
288
289	.text
290relocated:
291
292/*
293 * Clear BSS (stack is currently empty)
294 */
295	xorl	%eax, %eax
296	leaq    _bss(%rip), %rdi
297	leaq    _ebss(%rip), %rcx
298	subq	%rdi, %rcx
299	shrq	$3, %rcx
300	rep	stosq
301
302/*
303 * Adjust our own GOT
304 */
305	leaq	_got(%rip), %rdx
306	leaq	_egot(%rip), %rcx
3071:
308	cmpq	%rcx, %rdx
309	jae	2f
310	addq	%rbx, (%rdx)
311	addq	$8, %rdx
312	jmp	1b
3132:
314
315/*
316 * Do the decompression, and jump to the new kernel..
317 */
318	pushq	%rsi			/* Save the real mode argument */
319	movq	%rsi, %rdi		/* real mode address */
320	leaq	boot_heap(%rip), %rsi	/* malloc area for uncompression */
321	leaq	input_data(%rip), %rdx  /* input_data */
322	movl	$z_input_len, %ecx	/* input_len */
323	movq	%rbp, %r8		/* output target address */
324	call	decompress_kernel
325	popq	%rsi
326
327/*
328 * Jump to the decompressed kernel.
329 */
330	jmp	*%rbp
331
332	.data
333gdt:
334	.word	gdt_end - gdt
335	.long	gdt
336	.word	0
337	.quad	0x0000000000000000	/* NULL descriptor */
338	.quad	0x00af9a000000ffff	/* __KERNEL_CS */
339	.quad	0x00cf92000000ffff	/* __KERNEL_DS */
340	.quad	0x0080890000000000	/* TS descriptor */
341	.quad   0x0000000000000000	/* TS continued */
342gdt_end:
343
344/*
345 * Stack and heap for uncompression
346 */
347	.bss
348	.balign 4
349boot_heap:
350	.fill BOOT_HEAP_SIZE, 1, 0
351boot_stack:
352	.fill BOOT_STACK_SIZE, 1, 0
353boot_stack_end:
354
355/*
356 * Space for page tables (not in .bss so not zeroed)
357 */
358	.section ".pgtable","a",@nobits
359	.balign 4096
360pgtable:
361	.fill 6*4096, 1, 0
362