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/boot.h>
31#include <asm/msr.h>
32#include <asm/processor-flags.h>
33#include <asm/asm-offsets.h>
34
35	__HEAD
36	.code32
37ENTRY(startup_32)
38	/*
39	 * 32bit entry is 0 and it is ABI so immutable!
40	 * If we come here directly from a bootloader,
41	 * kernel(text+data+bss+brk) ramdisk, zero_page, command line
42	 * all need to be under the 4G limit.
43	 */
44	cld
45	/*
46	 * Test KEEP_SEGMENTS flag to see if the bootloader is asking
47	 * us to not reload segments
48	 */
49	testb $(1<<6), BP_loadflags(%esi)
50	jnz 1f
51
52	cli
53	movl	$(__BOOT_DS), %eax
54	movl	%eax, %ds
55	movl	%eax, %es
56	movl	%eax, %ss
571:
58
59/*
60 * Calculate the delta between where we were compiled to run
61 * at and where we were actually loaded at.  This can only be done
62 * with a short local call on x86.  Nothing  else will tell us what
63 * address we are running at.  The reserved chunk of the real-mode
64 * data at 0x1e4 (defined as a scratch field) are used as the stack
65 * for this calculation. Only 4 bytes are needed.
66 */
67	leal	(BP_scratch+4)(%esi), %esp
68	call	1f
691:	popl	%ebp
70	subl	$1b, %ebp
71
72/* setup a stack and make sure cpu supports long mode. */
73	movl	$boot_stack_end, %eax
74	addl	%ebp, %eax
75	movl	%eax, %esp
76
77	call	verify_cpu
78	testl	%eax, %eax
79	jnz	no_longmode
80
81/*
82 * Compute the delta between where we were compiled to run at
83 * and where the code will actually run at.
84 *
85 * %ebp contains the address we are loaded at by the boot loader and %ebx
86 * contains the address where we should move the kernel image temporarily
87 * for safe in-place decompression.
88 */
89
90#ifdef CONFIG_RELOCATABLE
91	movl	%ebp, %ebx
92	movl	BP_kernel_alignment(%esi), %eax
93	decl	%eax
94	addl	%eax, %ebx
95	notl	%eax
96	andl	%eax, %ebx
97	cmpl	$LOAD_PHYSICAL_ADDR, %ebx
98	jge	1f
99#endif
100	movl	$LOAD_PHYSICAL_ADDR, %ebx
1011:
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	%cr4, %eax
117	orl	$X86_CR4_PAE, %eax
118	movl	%eax, %cr4
119
120 /*
121  * Build early 4G boot pagetable
122  */
123	/* Initialize Page tables to 0 */
124	leal	pgtable(%ebx), %edi
125	xorl	%eax, %eax
126	movl	$((4096*6)/4), %ecx
127	rep	stosl
128
129	/* Build Level 4 */
130	leal	pgtable + 0(%ebx), %edi
131	leal	0x1007 (%edi), %eax
132	movl	%eax, 0(%edi)
133
134	/* Build Level 3 */
135	leal	pgtable + 0x1000(%ebx), %edi
136	leal	0x1007(%edi), %eax
137	movl	$4, %ecx
1381:	movl	%eax, 0x00(%edi)
139	addl	$0x00001000, %eax
140	addl	$8, %edi
141	decl	%ecx
142	jnz	1b
143
144	/* Build Level 2 */
145	leal	pgtable + 0x2000(%ebx), %edi
146	movl	$0x00000183, %eax
147	movl	$2048, %ecx
1481:	movl	%eax, 0(%edi)
149	addl	$0x00200000, %eax
150	addl	$8, %edi
151	decl	%ecx
152	jnz	1b
153
154	/* Enable the boot page tables */
155	leal	pgtable(%ebx), %eax
156	movl	%eax, %cr3
157
158	/* Enable Long mode in EFER (Extended Feature Enable Register) */
159	movl	$MSR_EFER, %ecx
160	rdmsr
161	btsl	$_EFER_LME, %eax
162	wrmsr
163
164	/* After gdt is loaded */
165	xorl	%eax, %eax
166	lldt	%ax
167	movl    $0x20, %eax
168	ltr	%ax
169
170	/*
171	 * Setup for the jump to 64bit mode
172	 *
173	 * When the jump is performend we will be in long mode but
174	 * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
175	 * (and in turn EFER.LMA = 1).	To jump into 64bit mode we use
176	 * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
177	 * We place all of the values on our mini stack so lret can
178	 * used to perform that far jump.
179	 */
180	pushl	$__KERNEL_CS
181	leal	startup_64(%ebp), %eax
182#ifdef CONFIG_EFI_MIXED
183	movl	efi32_config(%ebp), %ebx
184	cmp	$0, %ebx
185	jz	1f
186	leal	handover_entry(%ebp), %eax
1871:
188#endif
189	pushl	%eax
190
191	/* Enter paged protected Mode, activating Long Mode */
192	movl	$(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
193	movl	%eax, %cr0
194
195	/* Jump from 32bit compatibility mode into 64bit mode. */
196	lret
197ENDPROC(startup_32)
198
199#ifdef CONFIG_EFI_MIXED
200	.org 0x190
201ENTRY(efi32_stub_entry)
202	add	$0x4, %esp		/* Discard return address */
203	popl	%ecx
204	popl	%edx
205	popl	%esi
206
207	leal	(BP_scratch+4)(%esi), %esp
208	call	1f
2091:	pop	%ebp
210	subl	$1b, %ebp
211
212	movl	%ecx, efi32_config(%ebp)
213	movl	%edx, efi32_config+8(%ebp)
214	sgdtl	efi32_boot_gdt(%ebp)
215
216	leal	efi32_config(%ebp), %eax
217	movl	%eax, efi_config(%ebp)
218
219	jmp	startup_32
220ENDPROC(efi32_stub_entry)
221#endif
222
223	.code64
224	.org 0x200
225ENTRY(startup_64)
226	/*
227	 * 64bit entry is 0x200 and it is ABI so immutable!
228	 * We come here either from startup_32 or directly from a
229	 * 64bit bootloader.
230	 * If we come here from a bootloader, kernel(text+data+bss+brk),
231	 * ramdisk, zero_page, command line could be above 4G.
232	 * We depend on an identity mapped page table being provided
233	 * that maps our entire kernel(text+data+bss+brk), zero page
234	 * and command line.
235	 */
236#ifdef CONFIG_EFI_STUB
237	/*
238	 * The entry point for the PE/COFF executable is efi_pe_entry, so
239	 * only legacy boot loaders will execute this jmp.
240	 */
241	jmp	preferred_addr
242
243ENTRY(efi_pe_entry)
244	movq	%rcx, efi64_config(%rip)	/* Handle */
245	movq	%rdx, efi64_config+8(%rip) /* EFI System table pointer */
246
247	leaq	efi64_config(%rip), %rax
248	movq	%rax, efi_config(%rip)
249
250	call	1f
2511:	popq	%rbp
252	subq	$1b, %rbp
253
254	/*
255	 * Relocate efi_config->call().
256	 */
257	addq	%rbp, efi64_config+88(%rip)
258
259	movq	%rax, %rdi
260	call	make_boot_params
261	cmpq	$0,%rax
262	je	fail
263	mov	%rax, %rsi
264	leaq	startup_32(%rip), %rax
265	movl	%eax, BP_code32_start(%rsi)
266	jmp	2f		/* Skip the relocation */
267
268handover_entry:
269	call	1f
2701:	popq	%rbp
271	subq	$1b, %rbp
272
273	/*
274	 * Relocate efi_config->call().
275	 */
276	movq	efi_config(%rip), %rax
277	addq	%rbp, 88(%rax)
2782:
279	movq	efi_config(%rip), %rdi
280	call	efi_main
281	movq	%rax,%rsi
282	cmpq	$0,%rax
283	jne	2f
284fail:
285	/* EFI init failed, so hang. */
286	hlt
287	jmp	fail
2882:
289	movl	BP_code32_start(%esi), %eax
290	leaq	preferred_addr(%rax), %rax
291	jmp	*%rax
292
293preferred_addr:
294#endif
295
296	/* Setup data segments. */
297	xorl	%eax, %eax
298	movl	%eax, %ds
299	movl	%eax, %es
300	movl	%eax, %ss
301	movl	%eax, %fs
302	movl	%eax, %gs
303
304	/*
305	 * Compute the decompressed kernel start address.  It is where
306	 * we were loaded at aligned to a 2M boundary. %rbp contains the
307	 * decompressed kernel start address.
308	 *
309	 * If it is a relocatable kernel then decompress and run the kernel
310	 * from load address aligned to 2MB addr, otherwise decompress and
311	 * run the kernel from LOAD_PHYSICAL_ADDR
312	 *
313	 * We cannot rely on the calculation done in 32-bit mode, since we
314	 * may have been invoked via the 64-bit entry point.
315	 */
316
317	/* Start with the delta to where the kernel will run at. */
318#ifdef CONFIG_RELOCATABLE
319	leaq	startup_32(%rip) /* - $startup_32 */, %rbp
320	movl	BP_kernel_alignment(%rsi), %eax
321	decl	%eax
322	addq	%rax, %rbp
323	notq	%rax
324	andq	%rax, %rbp
325	cmpq	$LOAD_PHYSICAL_ADDR, %rbp
326	jge	1f
327#endif
328	movq	$LOAD_PHYSICAL_ADDR, %rbp
3291:
330
331	/* Target address to relocate to for decompression */
332	leaq	z_extract_offset(%rbp), %rbx
333
334	/* Set up the stack */
335	leaq	boot_stack_end(%rbx), %rsp
336
337	/* Zero EFLAGS */
338	pushq	$0
339	popfq
340
341/*
342 * Copy the compressed kernel to the end of our buffer
343 * where decompression in place becomes safe.
344 */
345	pushq	%rsi
346	leaq	(_bss-8)(%rip), %rsi
347	leaq	(_bss-8)(%rbx), %rdi
348	movq	$_bss /* - $startup_32 */, %rcx
349	shrq	$3, %rcx
350	std
351	rep	movsq
352	cld
353	popq	%rsi
354
355/*
356 * Jump to the relocated address.
357 */
358	leaq	relocated(%rbx), %rax
359	jmp	*%rax
360
361#ifdef CONFIG_EFI_STUB
362	.org 0x390
363ENTRY(efi64_stub_entry)
364	movq	%rdi, efi64_config(%rip)	/* Handle */
365	movq	%rsi, efi64_config+8(%rip) /* EFI System table pointer */
366
367	leaq	efi64_config(%rip), %rax
368	movq	%rax, efi_config(%rip)
369
370	movq	%rdx, %rsi
371	jmp	handover_entry
372ENDPROC(efi64_stub_entry)
373#endif
374
375	.text
376relocated:
377
378/*
379 * Clear BSS (stack is currently empty)
380 */
381	xorl	%eax, %eax
382	leaq    _bss(%rip), %rdi
383	leaq    _ebss(%rip), %rcx
384	subq	%rdi, %rcx
385	shrq	$3, %rcx
386	rep	stosq
387
388/*
389 * Adjust our own GOT
390 */
391	leaq	_got(%rip), %rdx
392	leaq	_egot(%rip), %rcx
3931:
394	cmpq	%rcx, %rdx
395	jae	2f
396	addq	%rbx, (%rdx)
397	addq	$8, %rdx
398	jmp	1b
3992:
400
401/*
402 * Do the decompression, and jump to the new kernel..
403 */
404	pushq	%rsi			/* Save the real mode argument */
405	movq	$z_run_size, %r9	/* size of kernel with .bss and .brk */
406	pushq	%r9
407	movq	%rsi, %rdi		/* real mode address */
408	leaq	boot_heap(%rip), %rsi	/* malloc area for uncompression */
409	leaq	input_data(%rip), %rdx  /* input_data */
410	movl	$z_input_len, %ecx	/* input_len */
411	movq	%rbp, %r8		/* output target address */
412	movq	$z_output_len, %r9	/* decompressed length, end of relocs */
413	call	decompress_kernel	/* returns kernel location in %rax */
414	popq	%r9
415	popq	%rsi
416
417/*
418 * Jump to the decompressed kernel.
419 */
420	jmp	*%rax
421
422	.code32
423no_longmode:
424	/* This isn't an x86-64 CPU so hang */
4251:
426	hlt
427	jmp     1b
428
429#include "../../kernel/verify_cpu.S"
430
431	.data
432gdt:
433	.word	gdt_end - gdt
434	.long	gdt
435	.word	0
436	.quad	0x0000000000000000	/* NULL descriptor */
437	.quad	0x00af9a000000ffff	/* __KERNEL_CS */
438	.quad	0x00cf92000000ffff	/* __KERNEL_DS */
439	.quad	0x0080890000000000	/* TS descriptor */
440	.quad   0x0000000000000000	/* TS continued */
441gdt_end:
442
443#ifdef CONFIG_EFI_STUB
444efi_config:
445	.quad	0
446
447#ifdef CONFIG_EFI_MIXED
448	.global efi32_config
449efi32_config:
450	.fill	11,8,0
451	.quad	efi64_thunk
452	.byte	0
453#endif
454
455	.global efi64_config
456efi64_config:
457	.fill	11,8,0
458	.quad	efi_call
459	.byte	1
460#endif /* CONFIG_EFI_STUB */
461
462/*
463 * Stack and heap for uncompression
464 */
465	.bss
466	.balign 4
467boot_heap:
468	.fill BOOT_HEAP_SIZE, 1, 0
469boot_stack:
470	.fill BOOT_STACK_SIZE, 1, 0
471boot_stack_end:
472
473/*
474 * Space for page tables (not in .bss so not zeroed)
475 */
476	.section ".pgtable","a",@nobits
477	.balign 4096
478pgtable:
479	.fill 6*4096, 1, 0
480