qemu

linuxboot_dma.c (6171B)

---

 /*
  * Linux Boot Option ROM for fw_cfg DMA
  *
  * 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 (c) 2015-2016 Red Hat Inc.
  *   Authors:
  *     Marc Marí <marc.mari.barcelo@gmail.com>
  *     Richard W.M. Jones <rjones@redhat.com>
  */
 
 asm(
 ".text\n"
 ".global _start\n"
 "_start:\n"
 "   .short 0xaa55\n"
 "   .byte 3\n" /* desired size in 512 units; signrom.py adds padding */
 "   .byte 0xcb\n" /* far return without prefix */
 "   .org 0x18\n"
 "   .short 0\n"
 "   .short _pnph\n"
 "_pnph:\n"
 "   .ascii \"$PnP\"\n"
 "   .byte 0x01\n"
 "   .byte (_pnph_len / 16)\n"
 "   .short 0x0000\n"
 "   .byte 0x00\n"
 "   .byte 0x00\n"
 "   .long 0x00000000\n"
 "   .short _manufacturer\n"
 "   .short _product\n"
 "   .long 0x00000000\n"
 "   .short 0x0000\n"
 "   .short 0x0000\n"
 "   .short _bev\n"
 "   .short 0x0000\n"
 "   .short 0x0000\n"
 "   .equ _pnph_len, . - _pnph\n"
 "_manufacturer:\n"
 "   .asciz \"QEMU\"\n"
 "_product:\n"
 "   .asciz \"Linux loader DMA\"\n"
 "   .align 4, 0\n"
 "_bev:\n"
 "   cli\n"
 "   cld\n"
 "   jmp load_kernel\n"
 );
 
 /*
  * The includes of C headers must be after the asm block to avoid compiler
  * errors.
  */
 #include <stdint.h>
 #include "optrom.h"
 #include "optrom_fw_cfg.h"
 
 static inline void set_es(void *addr)
 {
     uint32_t seg = (uint32_t)addr >> 4;
     asm("movl %0, %%es" : : "r"(seg));
 }
 
 static inline uint16_t readw_es(uint16_t offset)
 {
     uint16_t val;
     asm(ADDR32 "movw %%es:(%1), %0" : "=r"(val) : "r"((uint32_t)offset));
     barrier();
     return val;
 }
 
 static inline uint32_t readl_es(uint16_t offset)
 {
     uint32_t val;
     asm(ADDR32 "movl %%es:(%1), %0" : "=r"(val) : "r"((uint32_t)offset));
     barrier();
     return val;
 }
 
 static inline void writel_es(uint16_t offset, uint32_t val)
 {
     barrier();
     asm(ADDR32 "movl %0, %%es:(%1)" : : "r"(val), "r"((uint32_t)offset));
 }
 
 /* Return top of memory using BIOS function E801. */
 static uint32_t get_e801_addr(void)
 {
     uint16_t ax, bx, cx, dx;
     uint32_t ret;
 
     asm("int $0x15\n"
         : "=a"(ax), "=b"(bx), "=c"(cx), "=d"(dx)
         : "a"(0xe801), "b"(0), "c"(0), "d"(0));
 
     /* Not SeaBIOS, but in theory a BIOS could return CX=DX=0 in which
      * case we need to use the result from AX & BX instead.
      */
     if (cx == 0 && dx == 0) {
         cx = ax;
         dx = bx;
     }
 
     if (dx) {
         /* DX = extended memory above 16M, in 64K units.
          * Convert it to bytes and return.
          */
         ret = ((uint32_t)dx + 256 /* 16M in 64K units */) << 16;
     } else {
         /* This is a fallback path for machines with <= 16MB of RAM,
          * which probably would never be the case, but deal with it
          * anyway.
          *
          * CX = extended memory between 1M and 16M, in kilobytes
          * Convert it to bytes and return.
          */
         ret = ((uint32_t)cx + 1024 /* 1M in K */) << 10;
     }
 
     return ret;
 }
 
 /* Force the asm name without leading underscore, even on Win32. */
 extern void load_kernel(void) asm("load_kernel");
 
 void load_kernel(void)
 {
     void *setup_addr;
     void *initrd_addr;
     void *kernel_addr;
     void *cmdline_addr;
     uint32_t setup_size;
     uint32_t initrd_size;
     uint32_t kernel_size;
     uint32_t cmdline_size;
     uint32_t initrd_end_page, max_allowed_page;
     uint32_t segment_addr, stack_addr;
 
     bios_cfg_read_entry_dma(&setup_addr, FW_CFG_SETUP_ADDR, 4);
     bios_cfg_read_entry_dma(&setup_size, FW_CFG_SETUP_SIZE, 4);
     bios_cfg_read_entry_dma(setup_addr, FW_CFG_SETUP_DATA, setup_size);
 
     set_es(setup_addr);
 
     /* For protocol < 0x203 we don't have initrd_max ... */
     if (readw_es(0x206) < 0x203) {
         /* ... so we assume initrd_max = 0x37ffffff. */
         writel_es(0x22c, 0x37ffffff);
     }
 
     bios_cfg_read_entry_dma(&initrd_addr, FW_CFG_INITRD_ADDR, 4);
     bios_cfg_read_entry_dma(&initrd_size, FW_CFG_INITRD_SIZE, 4);
 
     initrd_end_page = ((uint32_t)(initrd_addr + initrd_size) & -4096);
     max_allowed_page = (readl_es(0x22c) & -4096);
 
     if (initrd_end_page != 0 && max_allowed_page != 0 &&
         initrd_end_page != max_allowed_page) {
         /* Initrd at the end of memory. Compute better initrd address
          * based on e801 data
          */
         initrd_addr = (void *)((get_e801_addr() - initrd_size) & -4096);
         writel_es(0x218, (uint32_t)initrd_addr);
 
     }
 
     bios_cfg_read_entry_dma(initrd_addr, FW_CFG_INITRD_DATA, initrd_size);
 
     bios_cfg_read_entry_dma(&kernel_addr, FW_CFG_KERNEL_ADDR, 4);
     bios_cfg_read_entry_dma(&kernel_size, FW_CFG_KERNEL_SIZE, 4);
     bios_cfg_read_entry_dma(kernel_addr, FW_CFG_KERNEL_DATA, kernel_size);
 
     bios_cfg_read_entry_dma(&cmdline_addr, FW_CFG_CMDLINE_ADDR, 4);
     bios_cfg_read_entry_dma(&cmdline_size, FW_CFG_CMDLINE_SIZE, 4);
     bios_cfg_read_entry_dma(cmdline_addr, FW_CFG_CMDLINE_DATA, cmdline_size);
 
     /* Boot linux */
     segment_addr = ((uint32_t)setup_addr >> 4);
     stack_addr = (uint32_t)(cmdline_addr - setup_addr - 16);
 
     /* As we are changing critical registers, we cannot leave freedom to the
      * compiler.
      */
     asm("movw %%ax, %%ds\n"
         "movw %%ax, %%es\n"
         "movw %%ax, %%fs\n"
         "movw %%ax, %%gs\n"
         "movw %%ax, %%ss\n"
         "movl %%ebx, %%esp\n"
         "addw $0x20, %%ax\n"
         "pushw %%ax\n" /* CS */
         "pushw $0\n" /* IP */
         /* Clear registers and jump to Linux */
         "xor %%ebx, %%ebx\n"
         "xor %%ecx, %%ecx\n"
         "xor %%edx, %%edx\n"
         "xor %%edi, %%edi\n"
         "xor %%ebp, %%ebp\n"
         "lretw\n"
         : : "a"(segment_addr), "b"(stack_addr));
 }