x86: coreboot: make it possible to process unhandled tags
[oweals/u-boot.git] / arch / x86 / cpu / start.S
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3  *  U-Boot - x86 Startup Code
4  *
5  * (C) Copyright 2008-2011
6  * Graeme Russ, <graeme.russ@gmail.com>
7  *
8  * (C) Copyright 2002
9  * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
10  */
11
12 #include <config.h>
13 #include <asm/global_data.h>
14 #include <asm/post.h>
15 #include <asm/processor.h>
16 #include <asm/processor-flags.h>
17 #include <generated/generic-asm-offsets.h>
18 #include <generated/asm-offsets.h>
19 #include <linux/linkage.h>
20
21 .section .text.start
22 .code32
23 .globl _start
24 .type _start, @function
25 .globl _x86boot_start
26 _x86boot_start:
27         /*
28          * This is the fail-safe 32-bit bootstrap entry point.
29          *
30          * This code is used when booting from another boot loader like
31          * coreboot or EFI. So we repeat some of the same init found in
32          * start16.
33          */
34         cli
35         cld
36
37         /* Turn off cache (this might require a 486-class CPU) */
38         movl    %cr0, %eax
39         orl     $(X86_CR0_NW | X86_CR0_CD), %eax
40         movl    %eax, %cr0
41         wbinvd
42
43         /* Tell 32-bit code it is being entered from an in-RAM copy */
44         movl    $GD_FLG_WARM_BOOT, %ebx
45
46         /*
47          * Zero the BIST (Built-In Self Test) value since we don't have it.
48          * It must be 0 or the previous loader would have reported an error.
49          */
50         movl    $0, %ebp
51
52         jmp     1f
53
54         /* Add a way for tools to discover the _start entry point */
55         .align  4
56         .long   0x12345678
57 _start:
58         /*
59          * This is the 32-bit cold-reset entry point, coming from start16.
60          * Set %ebx to GD_FLG_COLD_BOOT to indicate this.
61          */
62         movl    $GD_FLG_COLD_BOOT, %ebx
63
64         /* Save BIST */
65         movl    %eax, %ebp
66 1:
67
68         /* Save table pointer */
69         movl    %ecx, %esi
70
71 #ifdef CONFIG_X86_LOAD_FROM_32_BIT
72         lgdt    gdt_ptr2
73 #endif
74
75         /* Load the segement registers to match the GDT loaded in start16.S */
76         movl    $(X86_GDT_ENTRY_32BIT_DS * X86_GDT_ENTRY_SIZE), %eax
77         movw    %ax, %fs
78         movw    %ax, %ds
79         movw    %ax, %gs
80         movw    %ax, %es
81         movw    %ax, %ss
82
83         /* Clear the interrupt vectors */
84         lidt    blank_idt_ptr
85
86         /*
87          * Critical early platform init - generally not used, we prefer init
88          * to happen later when we have a console, in case something goes
89          * wrong.
90          */
91         jmp     early_board_init
92 .globl early_board_init_ret
93 early_board_init_ret:
94         post_code(POST_START)
95
96         /* Initialise Cache-As-RAM */
97         jmp     car_init
98 .globl car_init_ret
99 car_init_ret:
100 #ifndef CONFIG_HAVE_FSP
101         /*
102          * We now have CONFIG_SYS_CAR_SIZE bytes of Cache-As-RAM (or SRAM,
103          * or fully initialised SDRAM - we really don't care which)
104          * starting at CONFIG_SYS_CAR_ADDR to be used as a temporary stack
105          * and early malloc() area. The MRC requires some space at the top.
106          *
107          * Stack grows down from top of CAR. We have:
108          *
109          * top-> CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE
110          *      MRC area
111          *      global_data with x86 global descriptor table
112          *      early malloc area
113          *      stack
114          * bottom-> CONFIG_SYS_CAR_ADDR
115          */
116         movl    $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %esp
117 #ifdef CONFIG_DCACHE_RAM_MRC_VAR_SIZE
118         subl    $CONFIG_DCACHE_RAM_MRC_VAR_SIZE, %esp
119 #endif
120 #else
121         /*
122          * U-Boot enters here twice. For the first time it comes from
123          * car_init_done() with esp points to a temporary stack and esi
124          * set to zero. For the second time it comes from fsp_init_done()
125          * with esi holding the HOB list address returned by the FSP.
126          */
127 #endif
128         /* Set up global data */
129         mov     %esp, %eax
130         call    board_init_f_alloc_reserve
131         mov     %eax, %esp
132         call    board_init_f_init_reserve
133
134 #ifdef CONFIG_DEBUG_UART
135         call    debug_uart_init
136 #endif
137
138         /* Get address of global_data */
139         mov     %fs:0, %edx
140 #ifdef CONFIG_HAVE_FSP
141         /* Store the HOB list if we have one */
142         test    %esi, %esi
143         jz      skip_hob
144         movl    %esi, GD_HOB_LIST(%edx)
145
146         /*
147          * After fsp_init() returns, the stack has already been switched to a
148          * place within system memory as defined by CONFIG_FSP_TEMP_RAM_ADDR.
149          * Enlarge the size of malloc() pool before relocation since we have
150          * plenty of memory now.
151          */
152         subl    $CONFIG_FSP_SYS_MALLOC_F_LEN, %esp
153         movl    %esp, GD_MALLOC_BASE(%edx)
154 skip_hob:
155 #else
156         /* Store table pointer */
157         movl    %esi, GD_TABLE(%edx)
158 #endif
159         /* Store BIST */
160         movl    %ebp, GD_BIST(%edx)
161
162         /* Set parameter to board_init_f() to boot flags */
163         post_code(POST_START_DONE)
164         xorl    %eax, %eax
165
166         /* Enter, U-Boot! */
167         call    board_init_f
168
169         /* indicate (lack of) progress */
170         movw    $0x85, %ax
171         jmp     die
172
173 .globl board_init_f_r_trampoline
174 .type board_init_f_r_trampoline, @function
175 board_init_f_r_trampoline:
176         /*
177          * SDRAM has been initialised, U-Boot code has been copied into
178          * RAM, BSS has been cleared and relocation adjustments have been
179          * made. It is now time to jump into the in-RAM copy of U-Boot
180          *
181          * %eax = Address of top of new stack
182          */
183
184         /* Stack grows down from top of SDRAM */
185         movl    %eax, %esp
186
187         /* See if we need to disable CAR */
188         call    car_uninit
189
190         /* Re-enter U-Boot by calling board_init_f_r() */
191         call    board_init_f_r
192
193 #ifdef CONFIG_TPL
194 .globl jump_to_spl
195 .type jump_to_spl, @function
196 jump_to_spl:
197         /* Reset stack to the top of CAR space */
198         movl    $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %esp
199 #ifdef CONFIG_DCACHE_RAM_MRC_VAR_SIZE
200         subl    $CONFIG_DCACHE_RAM_MRC_VAR_SIZE, %esp
201 #endif
202
203         jmp     *%eax
204 #endif
205
206 die:
207         hlt
208         jmp     die
209         hlt
210
211 WEAK(car_uninit)
212         ret
213 ENDPROC(car_uninit)
214
215 blank_idt_ptr:
216         .word   0               /* limit */
217         .long   0               /* base */
218
219         .p2align        2       /* force 4-byte alignment */
220
221         /* Add a multiboot header so U-Boot can be loaded by GRUB2 */
222 multiboot_header:
223         /* magic */
224         .long   0x1badb002
225         /* flags */
226         .long   (1 << 16)
227         /* checksum */
228         .long   -0x1BADB002 - (1 << 16)
229         /* header addr */
230         .long   multiboot_header - _x86boot_start + CONFIG_SYS_TEXT_BASE
231         /* load addr */
232         .long   CONFIG_SYS_TEXT_BASE
233         /* load end addr */
234         .long   0
235         /* bss end addr */
236         .long   0
237         /* entry addr */
238         .long   CONFIG_SYS_TEXT_BASE
239
240 #ifdef CONFIG_X86_LOAD_FROM_32_BIT
241         /*
242          * The following Global Descriptor Table is just enough to get us into
243          * 'Flat Protected Mode' - It will be discarded as soon as the final
244          * GDT is setup in a safe location in RAM
245          */
246 gdt_ptr2:
247         .word   0x1f            /* limit (31 bytes = 4 GDT entries - 1) */
248         .long   gdt_rom2        /* base */
249
250         /* Some CPUs are picky about GDT alignment... */
251         .align  16
252 .globl gdt_rom2
253 gdt_rom2:
254         /*
255          * The GDT table ...
256          *
257          *       Selector       Type
258          *       0x00           NULL
259          *       0x08           Unused
260          *       0x10           32bit code
261          *       0x18           32bit data/stack
262          */
263         /* The NULL Desciptor - Mandatory */
264         .word   0x0000          /* limit_low */
265         .word   0x0000          /* base_low */
266         .byte   0x00            /* base_middle */
267         .byte   0x00            /* access */
268         .byte   0x00            /* flags + limit_high */
269         .byte   0x00            /* base_high */
270
271         /* Unused Desciptor - (matches Linux) */
272         .word   0x0000          /* limit_low */
273         .word   0x0000          /* base_low */
274         .byte   0x00            /* base_middle */
275         .byte   0x00            /* access */
276         .byte   0x00            /* flags + limit_high */
277         .byte   0x00            /* base_high */
278
279         /*
280          * The Code Segment Descriptor:
281          * - Base   = 0x00000000
282          * - Size   = 4GB
283          * - Access = Present, Ring 0, Exec (Code), Readable
284          * - Flags  = 4kB Granularity, 32-bit
285          */
286         .word   0xffff          /* limit_low */
287         .word   0x0000          /* base_low */
288         .byte   0x00            /* base_middle */
289         .byte   0x9b            /* access */
290         .byte   0xcf            /* flags + limit_high */
291         .byte   0x00            /* base_high */
292
293         /*
294          * The Data Segment Descriptor:
295          * - Base   = 0x00000000
296          * - Size   = 4GB
297          * - Access = Present, Ring 0, Non-Exec (Data), Writable
298          * - Flags  = 4kB Granularity, 32-bit
299          */
300         .word   0xffff          /* limit_low */
301         .word   0x0000          /* base_low */
302         .byte   0x00            /* base_middle */
303         .byte   0x93            /* access */
304         .byte   0xcf            /* flags + limit_high */
305         .byte   0x00            /* base_high */
306 #endif