/*
 * 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 */

	/* Load initrd using the "DMA" interface.
	   TODO(vtl): Should really detect whether DMA is supported. */
	/* Get stack space for a FWCfgDmaAccess struct:
	     typedef struct FWCfgDmaAccess {
	         uint32_t control;
	         uint32_t length;
	         uint64_t address;
	     } FWCfgDmaAccess;
	*/
	mov             %esp, %ebp
	sub             $16, %esp
	/* Set dma.control (big-endian):
	     high (16-bit) word is FW_CFG_INITRD_DATA
	     low (16-bit) word is FW_CFG_DMA_CTL_READ (0x02) |
	                          FW_CFG_DMA_CTL_SELECT (0x08)
	*/
	movl		$(FW_CFG_INITRD_DATA << 16 | 0x02 | 0x08), %eax
	bswap		%eax
	mov		%eax, -16(%bp)
	/* Get the initrd's length and set dma.length. */
	read_fw(FW_CFG_INITRD_SIZE)
	bswap		%eax
	movl		%eax, -12(%bp)
	/* Set dma.address (the address is already in EDI). */
	movl		$0, -8(%bp)
	mov		%edi, %eax
	bswap		%eax
	mov		%eax, -4(%bp)
	/* Kick off the DMA by outputting the physical address of dma to 0x514
	   (as two 32-bit values). */
	/* The top value is always 0. */
	xor		%eax, %eax
	mov		$0x514, %dx
	out		%eax, (%dx)
	/* Calculate the physical address of ESP, and send it to 0x514+4. */
	mov		%ss, %eax
	movzwl		%ax, %eax
	shl		$4, %eax
	addl		%esp, %eax
	bswap		%eax
	add		$4, %dx
	out		%eax, (%dx)
.Lwait_for_dma:
	mov -16(%bp), %eax
	bswap %eax
	test $~1, %eax
	jnz .Lwait_for_dma

	mov		%ebp, %esp

	/* The code for reading the initrd using an I/O port was just:
	     read_fw_blob_addr32_edi(FW_CFG_INITRD)
	   We could also use DMA for the kernel, but we assume it's relatively
	   small.
	*/
	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