v86 0.3.6 → 0.4.0

package/bios/seabios/src/bootsplash.c

@@ -0,0 +1,255 @@
+// Initialize the VGA console and possibly show a boot splash image.
+//
+// Copyright (C) 2009-2010  coresystems GmbH
+// Copyright (C) 2010  Kevin O'Connor <kevin@koconnor.net>
+//
+// This file may be distributed under the terms of the GNU LGPLv3 license.
+
+#include "bregs.h" // struct bregs
+#include "config.h" // CONFIG_*
+#include "farptr.h" // FLATPTR_TO_SEG
+#include "malloc.h" // free
+#include "output.h" // dprintf
+#include "romfile.h" // romfile_loadfile
+#include "stacks.h" // call16_int
+#include "std/vbe.h" // struct vbe_info
+#include "string.h" // memset
+#include "util.h" // enable_bootsplash
+
+
+/****************************************************************
+ * Helper functions
+ ****************************************************************/
+
+// Call int10 vga handler.
+static void
+call16_int10(struct bregs *br)
+{
+    br->flags = F_IF;
+    start_preempt();
+    call16_int(0x10, br);
+    finish_preempt();
+}
+
+
+/****************************************************************
+ * VGA text / graphics console
+ ****************************************************************/
+
+void
+enable_vga_console(void)
+{
+    dprintf(1, "Turning on vga text mode console\n");
+    struct bregs br;
+
+    /* Enable VGA text mode */
+    memset(&br, 0, sizeof(br));
+    br.ax = 0x0003;
+    call16_int10(&br);
+
+    // Write to screen.
+    printf("SeaBIOS (version %s)\n", VERSION);
+    display_uuid();
+}
+
+static int
+find_videomode(struct vbe_info *vesa_info, struct vbe_mode_info *mode_info
+               , int width, int height, int bpp_req)
+{
+    dprintf(3, "Finding vesa mode with dimensions %d/%d\n", width, height);
+    u16 *videomodes = SEGOFF_TO_FLATPTR(vesa_info->video_mode);
+    for (;; videomodes++) {
+        u16 videomode = *videomodes;
+        if (videomode == 0xffff) {
+            dprintf(1, "Unable to find vesa video mode dimensions %d/%d\n"
+                    , width, height);
+            return -1;
+        }
+        struct bregs br;
+        memset(&br, 0, sizeof(br));
+        br.ax = 0x4f01;
+        br.cx = videomode;
+        br.di = FLATPTR_TO_OFFSET(mode_info);
+        br.es = FLATPTR_TO_SEG(mode_info);
+        call16_int10(&br);
+        if (br.ax != 0x4f) {
+            dprintf(1, "get_mode failed.\n");
+            continue;
+        }
+        if (mode_info->xres != width
+            || mode_info->yres != height)
+            continue;
+        u8 depth = mode_info->bits_per_pixel;
+        if (bpp_req == 0) {
+            if ((depth != 16 && depth != 24 && depth != 32)
+                || mode_info->green_size == 5)
+                continue;
+        } else {
+            if (depth != bpp_req)
+                continue;
+        }
+        return videomode;
+    }
+}
+
+static int BootsplashActive;
+
+void
+enable_bootsplash(void)
+{
+    if (!CONFIG_BOOTSPLASH)
+        return;
+    /* splash picture can be bmp or jpeg file */
+    dprintf(3, "Checking for bootsplash\n");
+    u8 type = 0; /* 0 means jpg, 1 means bmp, default is 0=jpg */
+    int filesize;
+    u8 *filedata = romfile_loadfile("bootsplash.jpg", &filesize);
+    if (!filedata) {
+        filedata = romfile_loadfile("bootsplash.bmp", &filesize);
+        if (!filedata)
+            return;
+        type = 1;
+    }
+    dprintf(3, "start showing bootsplash\n");
+
+    u8 *picture = NULL; /* data buff used to be flushed to the video buf */
+    struct jpeg_decdata *jpeg = NULL;
+    struct bmp_decdata *bmp = NULL;
+    struct vbe_info *vesa_info = malloc_tmplow(sizeof(*vesa_info));
+    struct vbe_mode_info *mode_info = malloc_tmplow(sizeof(*mode_info));
+    if (!vesa_info || !mode_info) {
+        warn_noalloc();
+        goto done;
+    }
+
+    /* Check whether we have a VESA 2.0 compliant BIOS */
+    memset(vesa_info, 0, sizeof(struct vbe_info));
+    vesa_info->signature = VBE2_SIGNATURE;
+    struct bregs br;
+    memset(&br, 0, sizeof(br));
+    br.ax = 0x4f00;
+    br.di = FLATPTR_TO_OFFSET(vesa_info);
+    br.es = FLATPTR_TO_SEG(vesa_info);
+    call16_int10(&br);
+    if (vesa_info->signature != VESA_SIGNATURE) {
+        dprintf(1,"No VBE2 found.\n");
+        goto done;
+    }
+
+    /* Print some debugging information about our card. */
+    char *vendor = SEGOFF_TO_FLATPTR(vesa_info->oem_vendor_string);
+    char *product = SEGOFF_TO_FLATPTR(vesa_info->oem_product_string);
+    dprintf(3, "VESA %d.%d\nVENDOR: %s\nPRODUCT: %s\n",
+            vesa_info->version>>8, vesa_info->version&0xff,
+            vendor, product);
+
+    int ret, width, height;
+    int bpp_require = 0;
+    if (type == 0) {
+        jpeg = jpeg_alloc();
+        if (!jpeg) {
+            warn_noalloc();
+            goto done;
+        }
+        /* Parse jpeg and get image size. */
+        dprintf(5, "Decoding bootsplash.jpg\n");
+        ret = jpeg_decode(jpeg, filedata);
+        if (ret) {
+            dprintf(1, "jpeg_decode failed with return code %d...\n", ret);
+            goto done;
+        }
+        jpeg_get_size(jpeg, &width, &height);
+    } else {
+        bmp = bmp_alloc();
+        if (!bmp) {
+            warn_noalloc();
+            goto done;
+        }
+        /* Parse bmp and get image size. */
+        dprintf(5, "Decoding bootsplash.bmp\n");
+        ret = bmp_decode(bmp, filedata, filesize);
+        if (ret) {
+            dprintf(1, "bmp_decode failed with return code %d...\n", ret);
+            goto done;
+        }
+        bmp_get_size(bmp, &width, &height);
+        bpp_require = 24;
+    }
+    /* jpeg would use 16 or 24 bpp video mode, BMP use 24bpp mode only */
+
+    // Try to find a graphics mode with the corresponding dimensions.
+    int videomode = find_videomode(vesa_info, mode_info, width, height,
+                                       bpp_require);
+    if (videomode < 0) {
+        dprintf(1, "failed to find a videomode with %dx%d %dbpp (0=any).\n",
+                    width, height, bpp_require);
+        goto done;
+    }
+    void *framebuffer = (void *)mode_info->phys_base;
+    int depth = mode_info->bits_per_pixel;
+    dprintf(3, "mode: %04x\n", videomode);
+    dprintf(3, "framebuffer: %p\n", framebuffer);
+    dprintf(3, "bytes per scanline: %d\n", mode_info->bytes_per_scanline);
+    dprintf(3, "bits per pixel: %d\n", depth);
+
+    // Allocate space for image and decompress it.
+    int imagesize = height * mode_info->bytes_per_scanline;
+    picture = malloc_tmphigh(imagesize);
+    if (!picture) {
+        warn_noalloc();
+        goto done;
+    }
+
+    if (type == 0) {
+        dprintf(5, "Decompressing bootsplash.jpg\n");
+        ret = jpeg_show(jpeg, picture, width, height, depth,
+                            mode_info->bytes_per_scanline);
+        if (ret) {
+            dprintf(1, "jpeg_show failed with return code %d...\n", ret);
+            goto done;
+        }
+    } else {
+        dprintf(5, "Decompressing bootsplash.bmp\n");
+        ret = bmp_show(bmp, picture, width, height, depth,
+                           mode_info->bytes_per_scanline);
+        if (ret) {
+            dprintf(1, "bmp_show failed with return code %d...\n", ret);
+            goto done;
+        }
+    }
+
+    /* Switch to graphics mode */
+    dprintf(5, "Switching to graphics mode\n");
+    memset(&br, 0, sizeof(br));
+    br.ax = 0x4f02;
+    br.bx = videomode | VBE_MODE_LINEAR_FRAME_BUFFER;
+    call16_int10(&br);
+    if (br.ax != 0x4f) {
+        dprintf(1, "set_mode failed.\n");
+        goto done;
+    }
+
+    /* Show the picture */
+    dprintf(5, "Showing bootsplash picture\n");
+    iomemcpy(framebuffer, picture, imagesize);
+    dprintf(5, "Bootsplash copy complete\n");
+    BootsplashActive = 1;
+
+done:
+    free(filedata);
+    free(picture);
+    free(vesa_info);
+    free(mode_info);
+    free(jpeg);
+    free(bmp);
+    return;
+}
+
+void
+disable_bootsplash(void)
+{
+    if (!CONFIG_BOOTSPLASH || !BootsplashActive)
+        return;
+    BootsplashActive = 0;
+    enable_vga_console();
+}

package/bios/seabios/src/bregs.h

@@ -0,0 +1,80 @@
+// Structure layout of cpu registers that the bios uses.
+//
+// Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
+//
+// This file may be distributed under the terms of the GNU LGPLv3 license.
+
+#ifndef __BREGS_H
+#define __BREGS_H
+
+#include "types.h" // u16
+#include "x86.h" // F_CF
+
+
+/****************************************************************
+ * Registers saved/restored in romlayout.S
+ ****************************************************************/
+
+#define UREG(ER, R, RH, RL) union { u32 ER; struct { u16 R; u16 R ## _hi; }; struct { u8 RL; u8 RH; u8 R ## _hilo; u8 R ## _hihi; }; }
+
+// Layout of registers passed in to irq handlers.  Note that this
+// layout corresponds to code in romlayout.S - don't change it here
+// without also updating the assembler code.
+struct bregs {
+    u16 ds;
+    u16 es;
+    UREG(edi, di, di8u, di8l);
+    UREG(esi, si, si8u, si8l);
+    UREG(ebp, bp, bp8u, bp8l);
+    UREG(ebx, bx, bh, bl);
+    UREG(edx, dx, dh, dl);
+    UREG(ecx, cx, ch, cl);
+    UREG(eax, ax, ah, al);
+    struct segoff_s code;
+    u16 flags;
+} PACKED;
+
+
+/****************************************************************
+ * Helper functions
+ ****************************************************************/
+
+static inline void
+set_cf(struct bregs *regs, int cond)
+{
+    if (cond)
+        regs->flags |= F_CF;
+    else
+        regs->flags &= ~F_CF;
+}
+
+// Frequently used return codes
+#define RET_EUNSUPPORTED 0x86
+
+static inline void
+set_success(struct bregs *regs)
+{
+    set_cf(regs, 0);
+}
+
+static inline void
+set_code_success(struct bregs *regs)
+{
+    regs->ah = 0;
+    set_cf(regs, 0);
+}
+
+static inline void
+set_invalid_silent(struct bregs *regs)
+{
+    set_cf(regs, 1);
+}
+
+static inline void
+set_code_invalid_silent(struct bregs *regs, u8 code)
+{
+    regs->ah = code;
+    set_cf(regs, 1);
+}
+
+#endif // bregs.h

package/bios/seabios/src/byteorder.h

@@ -0,0 +1,71 @@
+#ifndef __BYTEORDER_H
+#define __BYTEORDER_H
+
+#include "types.h" // u32
+
+static inline u16 __swab16_constant(u16 val) {
+    return (val<<8) | (val>>8);
+}
+static inline u32 __swab32_constant(u32 val) {
+    return (val<<24) | ((val&0xff00)<<8) | ((val&0xff0000)>>8) | (val>>24);
+}
+static inline u64 __swab64_constant(u64 val) {
+    return ((u64)__swab32_constant(val) << 32) | __swab32_constant(val>>32);
+}
+static inline u32 __swab32(u32 val) {
+    asm("bswapl %0" : "+r"(val));
+    return val;
+}
+static inline u64 __swab64(u64 val) {
+    union u64_u32_u i, o;
+    i.val = val;
+    o.lo = __swab32(i.hi);
+    o.hi = __swab32(i.lo);
+    return o.val;
+}
+
+#define swab16(x) __swab16_constant(x)
+#define swab32(x) (__builtin_constant_p((u32)(x)) \
+                   ? __swab32_constant(x) : __swab32(x))
+#define swab64(x) (__builtin_constant_p((u64)(x)) \
+                   ? __swab64_constant(x) : __swab64(x))
+
+static inline u16 cpu_to_le16(u16 x) {
+    return x;
+}
+static inline u32 cpu_to_le32(u32 x) {
+    return x;
+}
+static inline u64 cpu_to_le64(u64 x) {
+    return x;
+}
+static inline u16 le16_to_cpu(u16 x) {
+    return x;
+}
+static inline u32 le32_to_cpu(u32 x) {
+    return x;
+}
+static inline u64 le64_to_cpu(u64 x) {
+    return x;
+}
+
+static inline u16 cpu_to_be16(u16 x) {
+    return swab16(x);
+}
+static inline u32 cpu_to_be32(u32 x) {
+    return swab32(x);
+}
+static inline u64 cpu_to_be64(u64 x) {
+    return swab64(x);
+}
+static inline u16 be16_to_cpu(u16 x) {
+    return swab16(x);
+}
+static inline u32 be32_to_cpu(u32 x) {
+    return swab32(x);
+}
+static inline u64 be64_to_cpu(u64 x) {
+    return swab64(x);
+}
+
+#endif // byteorder.h