migration: rename unix.c to socket.c
[qemu.git] / pc-bios / optionrom / linuxboot.S
1 /*
2  * Linux Boot Option ROM
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
16  *
17  * Copyright Novell Inc, 2009
18  *   Authors: Alexander Graf <agraf@suse.de>
19  *
20  * Based on code in hw/pc.c.
21  */
22
23 #include "optionrom.h"
24
25 #define BOOT_ROM_PRODUCT "Linux loader"
26
27 BOOT_ROM_START
28
29 run_linuxboot:
30
31         cli
32         cld
33
34         jmp             copy_kernel
35 boot_kernel:
36
37         read_fw         FW_CFG_SETUP_ADDR
38
39         mov             %eax, %ebx
40         shr             $4, %ebx
41
42         /* All segments contain real_addr */
43         mov             %bx, %ds
44         mov             %bx, %es
45         mov             %bx, %fs
46         mov             %bx, %gs
47         mov             %bx, %ss
48
49         /* CX = CS we want to jump to */
50         add             $0x20, %bx
51         mov             %bx, %cx
52
53         /* SP = cmdline_addr-real_addr-16 */
54         read_fw         FW_CFG_CMDLINE_ADDR
55         mov             %eax, %ebx
56         read_fw         FW_CFG_SETUP_ADDR
57         sub             %eax, %ebx
58         sub             $16, %ebx
59         mov             %ebx, %esp
60
61         /* Build indirect lret descriptor */
62         pushw           %cx             /* CS */
63         xor             %ax, %ax
64         pushw           %ax             /* IP = 0 */
65
66         /* Clear registers */
67         xor             %eax, %eax
68         xor             %ebx, %ebx
69         xor             %ecx, %ecx
70         xor             %edx, %edx
71         xor             %edi, %edi
72         xor             %ebp, %ebp
73
74         /* Jump to Linux */
75         lret
76
77
78 copy_kernel:
79         /* Read info block in low memory (0x10000 or 0x90000) */
80         read_fw         FW_CFG_SETUP_ADDR
81         shr             $4, %eax
82         mov             %eax, %es
83         xor             %edi, %edi
84         read_fw_blob_addr32_edi(FW_CFG_SETUP)
85
86         cmpw            $0x203, %es:0x206      // if protocol >= 0x203
87         jae             1f                     // have initrd_max
88         movl            $0x37ffffff, %es:0x22c // else assume 0x37ffffff
89 1:
90
91         /* Check if using kernel-specified initrd address */
92         read_fw         FW_CFG_INITRD_ADDR
93         mov             %eax, %edi             // (load_kernel wants it in %edi)
94         read_fw         FW_CFG_INITRD_SIZE     // find end of initrd
95         add             %edi, %eax
96         xor             %es:0x22c, %eax        // if it matches es:0x22c
97         and             $-4096, %eax           // (apart from padding for page)
98         jz              load_kernel            // then initrd is not at top
99                                                // of memory
100
101         /* pc.c placed the initrd at end of memory.  Compute a better
102          * initrd address based on e801 data.
103          */
104         mov             $0xe801, %ax
105         xor             %cx, %cx
106         xor             %dx, %dx
107         int             $0x15
108
109         /* Output could be in AX/BX or CX/DX */
110         or              %cx, %cx
111         jnz             1f
112         or              %dx, %dx
113         jnz             1f
114         mov             %ax, %cx
115         mov             %bx, %dx
116 1:
117
118         or              %dx, %dx
119         jnz             2f
120         addw            $1024, %cx            /* add 1 MB */
121         movzwl          %cx, %edi
122         shll            $10, %edi             /* convert to bytes */
123         jmp             3f
124
125 2:
126         addw            $16777216 >> 16, %dx  /* add 16 MB */
127         movzwl          %dx, %edi
128         shll            $16, %edi             /* convert to bytes */
129
130 3:
131         read_fw         FW_CFG_INITRD_SIZE
132         subl            %eax, %edi
133         andl            $-4096, %edi          /* EDI = start of initrd */
134         movl            %edi, %es:0x218       /* put it in the header */
135
136 load_kernel:
137         /* We need to load the kernel into memory we can't access in 16 bit
138            mode, so let's get into 32 bit mode, write the kernel and jump
139            back again. */
140
141         /* Reserve space on the stack for our GDT descriptor. */
142         mov             %esp, %ebp
143         sub             $16, %esp
144
145         /* Now create the GDT descriptor */
146         movw            $((3 * 8) - 1), -16(%bp)
147         mov             %cs, %eax
148         movzwl          %ax, %eax
149         shl             $4, %eax
150         addl            $gdt, %eax
151         movl            %eax, -14(%bp)
152
153         /* And load the GDT */
154         data32 lgdt     -16(%bp)
155         mov             %ebp, %esp
156
157         /* Get us to protected mode now */
158         mov             $1, %eax
159         mov             %eax, %cr0
160
161         /* So we can set ES to a 32-bit segment */
162         mov             $0x10, %eax
163         mov             %eax, %es
164
165         /* We're now running in 16-bit CS, but 32-bit ES! */
166
167         /* Load kernel and initrd */
168         read_fw_blob_addr32_edi(FW_CFG_INITRD)
169         read_fw_blob_addr32(FW_CFG_KERNEL)
170         read_fw_blob_addr32(FW_CFG_CMDLINE)
171
172         /* And now jump into Linux! */
173         mov             $0, %eax
174         mov             %eax, %cr0
175
176         /* ES = CS */
177         mov             %cs, %ax
178         mov             %ax, %es
179
180         jmp             boot_kernel
181
182 /* Variables */
183
184 .align 4, 0
185 gdt:
186         /* 0x00 */
187 .byte   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
188
189         /* 0x08: code segment (base=0, limit=0xfffff, type=32bit code exec/read, DPL=0, 4k) */
190 .byte   0xff, 0xff, 0x00, 0x00, 0x00, 0x9a, 0xcf, 0x00
191
192         /* 0x10: data segment (base=0, limit=0xfffff, type=32bit data read/write, DPL=0, 4k) */
193 .byte   0xff, 0xff, 0x00, 0x00, 0x00, 0x92, 0xcf, 0x00
194
195 BOOT_ROM_END