summaryrefslogtreecommitdiffstats
path: root/qemu/pc-bios/optionrom/linuxboot.S
blob: ba821ab922dac42b96a384acc8960abe04f49ce5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
/*
 * Linux Boot Option ROM
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Copyright Novell Inc, 2009
 *   Authors: Alexander Graf <agraf@suse.de>
 *
 * Based on code in hw/pc.c.
 */

#include "optionrom.h"

#define BOOT_ROM_PRODUCT "Linux loader"

BOOT_ROM_START

run_linuxboot:

	cli
	cld

	jmp		copy_kernel
boot_kernel:

	read_fw		FW_CFG_SETUP_ADDR

	mov		%eax, %ebx
	shr		$4, %ebx

	/* All segments contain real_addr */
	mov		%bx, %ds
	mov		%bx, %es
	mov		%bx, %fs
	mov		%bx, %gs
	mov		%bx, %ss

	/* CX = CS we want to jump to */
	add		$0x20, %bx
	mov		%bx, %cx

	/* SP = cmdline_addr-real_addr-16 */
	read_fw		FW_CFG_CMDLINE_ADDR
	mov		%eax, %ebx
	read_fw		FW_CFG_SETUP_ADDR
	sub		%eax, %ebx
	sub		$16, %ebx
	mov		%ebx, %esp

	/* Build indirect lret descriptor */
	pushw		%cx		/* CS */
	xor		%ax, %ax
	pushw		%ax		/* IP = 0 */

	/* Clear registers */
	xor		%eax, %eax
	xor		%ebx, %ebx
	xor		%ecx, %ecx
	xor		%edx, %edx
	xor		%edi, %edi
	xor		%ebp, %ebp

	/* Jump to Linux */
	lret


copy_kernel:
	/* Read info block in low memory (0x10000 or 0x90000) */
	read_fw		FW_CFG_SETUP_ADDR
	shr		$4, %eax
	mov		%eax, %es
	xor		%edi, %edi
	read_fw_blob_addr32_edi(FW_CFG_SETUP)

	cmpw            $0x203, %es:0x206      // if protocol >= 0x203
	jae             1f                     // have initrd_max
	movl            $0x37ffffff, %es:0x22c // else assume 0x37ffffff
1:

	/* Check if using kernel-specified initrd address */
	read_fw		FW_CFG_INITRD_ADDR
	mov		%eax, %edi             // (load_kernel wants it in %edi)
	read_fw		FW_CFG_INITRD_SIZE     // find end of initrd
	add		%edi, %eax
	xor		%es:0x22c, %eax        // if it matches es:0x22c
	and		$-4096, %eax           // (apart from padding for page)
	jz		load_kernel            // then initrd is not at top
					       // of memory

	/* pc.c placed the initrd at end of memory.  Compute a better
	 * initrd address based on e801 data.
	 */
	mov		$0xe801, %ax
	xor		%cx, %cx
	xor		%dx, %dx
	int		$0x15

	/* Output could be in AX/BX or CX/DX */
	or		%cx, %cx
	jnz		1f
	or		%dx, %dx
	jnz		1f
	mov		%ax, %cx
	mov		%bx, %dx
1:

	or		%dx, %dx
	jnz		2f
	addw		$1024, %cx            /* add 1 MB */
	movzwl		%cx, %edi
	shll		$10, %edi             /* convert to bytes */
	jmp		3f

2:
	addw		$16777216 >> 16, %dx  /* add 16 MB */
	movzwl		%dx, %edi
	shll		$16, %edi             /* convert to bytes */

3:
	read_fw         FW_CFG_INITRD_SIZE
	subl            %eax, %edi
	andl            $-4096, %edi          /* EDI = start of initrd */
	movl		%edi, %es:0x218       /* put it in the header */

load_kernel:
	/* We need to load the kernel into memory we can't access in 16 bit
	   mode, so let's get into 32 bit mode, write the kernel and jump
	   back again. */

	/* Reserve space on the stack for our GDT descriptor. */
	mov             %esp, %ebp
	sub             $16, %esp

	/* Now create the GDT descriptor */
	movw		$((3 * 8) - 1), -16(%bp)
	mov		%cs, %eax
	movzwl		%ax, %eax
	shl		$4, %eax
	addl		$gdt, %eax
	movl		%eax, -14(%bp)

	/* And load the GDT */
	data32 lgdt	-16(%bp)
	mov		%ebp, %esp

	/* Get us to protected mode now */
	mov		$1, %eax
	mov		%eax, %cr0

	/* So we can set ES to a 32-bit segment */
	mov		$0x10, %eax
	mov		%eax, %es

	/* We're now running in 16-bit CS, but 32-bit ES! */

	/* Load kernel and initrd */
	read_fw_blob_addr32_edi(FW_CFG_INITRD)
	read_fw_blob_addr32(FW_CFG_KERNEL)
	read_fw_blob_addr32(FW_CFG_CMDLINE)

	/* And now jump into Linux! */
	mov		$0, %eax
	mov		%eax, %cr0

	/* ES = CS */
	mov		%cs, %ax
	mov		%ax, %es

	jmp		boot_kernel

/* Variables */

.align 4, 0
gdt:
	/* 0x00 */
.byte	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

	/* 0x08: code segment (base=0, limit=0xfffff, type=32bit code exec/read, DPL=0, 4k) */
.byte	0xff, 0xff, 0x00, 0x00, 0x00, 0x9a, 0xcf, 0x00

	/* 0x10: data segment (base=0, limit=0xfffff, type=32bit data read/write, DPL=0, 4k) */
.byte	0xff, 0xff, 0x00, 0x00, 0x00, 0x92, 0xcf, 0x00

BOOT_ROM_END