pc-bios/optionrom/linuxboot_dma.c

   1 /*
   2  * Linux Boot Option ROM for fw_cfg DMA
   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 (c) 2015-2016 Red Hat Inc.
  18  *   Authors:
  19  *     Marc Marí <marc.mari.barcelo@gmail.com>
  20  *     Richard W.M. Jones <rjones@redhat.com>
  21  */
  22
  23 asm(
  24 ".text\n"
  25 ".global _start\n"
  26 "_start:\n"
  27 "   .short 0xaa55\n"
  28 "   .byte 3\n" /* desired size in 512 units; signrom.py adds padding */
  29 "   .byte 0xcb\n" /* far return without prefix */
  30 "   .org 0x18\n"
  31 "   .short 0\n"
  32 "   .short _pnph\n"
  33 "_pnph:\n"
  34 "   .ascii \"$PnP\"\n"
  35 "   .byte 0x01\n"
  36 "   .byte (_pnph_len / 16)\n"
  37 "   .short 0x0000\n"
  38 "   .byte 0x00\n"
  39 "   .byte 0x00\n"
  40 "   .long 0x00000000\n"
  41 "   .short _manufacturer\n"
  42 "   .short _product\n"
  43 "   .long 0x00000000\n"
  44 "   .short 0x0000\n"
  45 "   .short 0x0000\n"
  46 "   .short _bev\n"
  47 "   .short 0x0000\n"
  48 "   .short 0x0000\n"
  49 "   .equ _pnph_len, . - _pnph\n"
  50 "_manufacturer:\n"
  51 "   .asciz \"QEMU\"\n"
  52 "_product:\n"
  53 "   .asciz \"Linux loader DMA\"\n"
  54 "   .align 4, 0\n"
  55 "_bev:\n"
  56 "   cli\n"
  57 "   cld\n"
  58 "   jmp load_kernel\n"
  59 );
  60
  61 /*
  62  * The includes of C headers must be after the asm block to avoid compiler
  63  * errors.
  64  */
  65 #include <stdint.h>
  66 #include "optrom.h"
  67 #include "optrom_fw_cfg.h"
  68
  69 static inline void set_es(void *addr)
  70 {
  71     uint32_t seg = (uint32_t)addr >> 4;
  72     asm("movl %0, %%es" : : "r"(seg));
  73 }
  74
  75 static inline uint16_t readw_es(uint16_t offset)
  76 {
  77     uint16_t val;
  78     asm(ADDR32 "movw %%es:(%1), %0" : "=r"(val) : "r"((uint32_t)offset));
  79     barrier();
  80     return val;
  81 }
  82
  83 static inline uint32_t readl_es(uint16_t offset)
  84 {
  85     uint32_t val;
  86     asm(ADDR32 "movl %%es:(%1), %0" : "=r"(val) : "r"((uint32_t)offset));
  87     barrier();
  88     return val;
  89 }
  90
  91 static inline void writel_es(uint16_t offset, uint32_t val)
  92 {
  93     barrier();
  94     asm(ADDR32 "movl %0, %%es:(%1)" : : "r"(val), "r"((uint32_t)offset));
  95 }
  96
  97 /* Return top of memory using BIOS function E801. */
  98 static uint32_t get_e801_addr(void)
  99 {
 100     uint16_t ax, bx, cx, dx;
 101     uint32_t ret;
 102
 103     asm("int $0x15\n"
 104         : "=a"(ax), "=b"(bx), "=c"(cx), "=d"(dx)
 105         : "a"(0xe801), "b"(0), "c"(0), "d"(0));
 106
 107     /* Not SeaBIOS, but in theory a BIOS could return CX=DX=0 in which
 108      * case we need to use the result from AX & BX instead.
 109      */
 110     if (cx == 0 && dx == 0) {
 111         cx = ax;
 112         dx = bx;
 113     }
 114
 115     if (dx) {
 116         /* DX = extended memory above 16M, in 64K units.
 117          * Convert it to bytes and return.
 118          */
 119         ret = ((uint32_t)dx + 256 /* 16M in 64K units */) << 16;
 120     } else {
 121         /* This is a fallback path for machines with <= 16MB of RAM,
 122          * which probably would never be the case, but deal with it
 123          * anyway.
 124          *
 125          * CX = extended memory between 1M and 16M, in kilobytes
 126          * Convert it to bytes and return.
 127          */
 128         ret = ((uint32_t)cx + 1024 /* 1M in K */) << 10;
 129     }
 130
 131     return ret;
 132 }
 133
 134 /* Force the asm name without leading underscore, even on Win32. */
 135 extern void load_kernel(void) asm("load_kernel");
 136
 137 void load_kernel(void)
 138 {
 139     void *setup_addr;
 140     void *initrd_addr;
 141     void *kernel_addr;
 142     void *cmdline_addr;
 143     uint32_t setup_size;
 144     uint32_t initrd_size;
 145     uint32_t kernel_size;
 146     uint32_t cmdline_size;
 147     uint32_t initrd_end_page, max_allowed_page;
 148     uint32_t segment_addr, stack_addr;
 149
 150     bios_cfg_read_entry_dma(&setup_addr, FW_CFG_SETUP_ADDR, 4);
 151     bios_cfg_read_entry_dma(&setup_size, FW_CFG_SETUP_SIZE, 4);
 152     bios_cfg_read_entry_dma(setup_addr, FW_CFG_SETUP_DATA, setup_size);
 153
 154     set_es(setup_addr);
 155
 156     /* For protocol < 0x203 we don't have initrd_max ... */
 157     if (readw_es(0x206) < 0x203) {
 158         /* ... so we assume initrd_max = 0x37ffffff. */
 159         writel_es(0x22c, 0x37ffffff);
 160     }
 161
 162     bios_cfg_read_entry_dma(&initrd_addr, FW_CFG_INITRD_ADDR, 4);
 163     bios_cfg_read_entry_dma(&initrd_size, FW_CFG_INITRD_SIZE, 4);
 164
 165     initrd_end_page = ((uint32_t)(initrd_addr + initrd_size) & -4096);
 166     max_allowed_page = (readl_es(0x22c) & -4096);
 167
 168     if (initrd_end_page != 0 && max_allowed_page != 0 &&
 169         initrd_end_page != max_allowed_page) {
 170         /* Initrd at the end of memory. Compute better initrd address
 171          * based on e801 data
 172          */
 173         initrd_addr = (void *)((get_e801_addr() - initrd_size) & -4096);
 174         writel_es(0x218, (uint32_t)initrd_addr);
 175
 176     }
 177
 178     bios_cfg_read_entry_dma(initrd_addr, FW_CFG_INITRD_DATA, initrd_size);
 179
 180     bios_cfg_read_entry_dma(&kernel_addr, FW_CFG_KERNEL_ADDR, 4);
 181     bios_cfg_read_entry_dma(&kernel_size, FW_CFG_KERNEL_SIZE, 4);
 182     bios_cfg_read_entry_dma(kernel_addr, FW_CFG_KERNEL_DATA, kernel_size);
 183
 184     bios_cfg_read_entry_dma(&cmdline_addr, FW_CFG_CMDLINE_ADDR, 4);
 185     bios_cfg_read_entry_dma(&cmdline_size, FW_CFG_CMDLINE_SIZE, 4);
 186     bios_cfg_read_entry_dma(cmdline_addr, FW_CFG_CMDLINE_DATA, cmdline_size);
 187
 188     /* Boot linux */
 189     segment_addr = ((uint32_t)setup_addr >> 4);
 190     stack_addr = (uint32_t)(cmdline_addr - setup_addr - 16);
 191
 192     /* As we are changing critical registers, we cannot leave freedom to the
 193      * compiler.
 194      */
 195     asm("movw %%ax, %%ds\n"
 196         "movw %%ax, %%es\n"
 197         "movw %%ax, %%fs\n"
 198         "movw %%ax, %%gs\n"
 199         "movw %%ax, %%ss\n"
 200         "movl %%ebx, %%esp\n"
 201         "addw $0x20, %%ax\n"
 202         "pushw %%ax\n" /* CS */
 203         "pushw $0\n" /* IP */
 204         /* Clear registers and jump to Linux */
 205         "xor %%ebx, %%ebx\n"
 206         "xor %%ecx, %%ecx\n"
 207         "xor %%edx, %%edx\n"
 208         "xor %%edi, %%edi\n"
 209         "xor %%ebp, %%ebp\n"
 210         "lretw\n"
 211         : : "a"(segment_addr), "b"(stack_addr));
 212 }