diff --git a/prototypes/video/Makefile b/prototypes/video/Makefile new file mode 100644 index 0000000..ca509cb --- /dev/null +++ b/prototypes/video/Makefile @@ -0,0 +1,72 @@ + +AS=gcc +CC=gcc +CXX=g++ +LD=ld + +LIBGCC = $(shell gcc -m32 -print-libgcc-file-name) +INCLUDE_DIRS = + +FLAGS = -mno-sse -ffreestanding -m32 -Werror -Wall -iquote include -iquote lists $(addprefix -I, $(INCLUDE_DIRS)) -O3 -g +ASFLAGS = $(FLAGS) +CFLAGS = $(FLAGS) +CXXFLAGS = $(FLAGS) -std=c++14 -fno-rtti -fno-exceptions -fno-leading-underscore -fno-use-cxa-atexit -nostdlib -fno-builtin + +SRCS = $(shell find -regextype egrep -regex '.*/.*\.(cpp|S|c)') +OBJS = $(addsuffix .o, $(notdir $(basename $(SRCS)))) +LIBS = $(LIBGCC) $(LIBSTD) $(LIBVM) + +all: build-dirs video.ker + +build-dirs: + mkdir -p obj + +video.ker: $(OBJS) + $(LD) -melf_i386 -Tlinker.ld -o $@ $(addprefix obj/, $^) $(LIBS) + +%.o: %.cpp + $(CXX) $(CXXFLAGS) -c -o obj/$@ $< + +%.o: %.c + $(CC) $(ASFLAGS) -c -o obj/$@ $< + +%.o: %.S + $(AS) $(CFLAGS) -c -o obj/$@ $< + +%.o: src/%.cpp + $(CXX) $(CXXFLAGS) -c -o obj/$@ $< + +%.o: src/%.c + $(CC) $(ASFLAGS) -c -o obj/$@ $< + +%.o: src/%.S + $(AS) $(CFLAGS) -c -o obj/$@ $< + +# Linux/Multiboot boot specific: +# -kernel bzImage use 'bzImage' as kernel image +# -append cmdline use 'cmdline' as kernel command line +# -initrd file use 'file' as initial ram disk +# -dtb file use 'file' as device tree image + +boot: image + qemu-system-i386 \ + -fda boot.img \ + -m 64 \ + -d cpu_reset,int \ + -serial stdio +# -no-reboot \ +# -no-shutdown \ + +insight: + objdump -d kernel-base.ker | c++filt | less + +bnr: video.ker run + +deploy: video.ker + cp video.ker /srv/tftp/video.ker + +image: video.ker + mformat -C -f 1440 -v VIDEO -i boot.img :: + mcopy -i boot.img video.ker syslinux.cfg /boot/syslinux/libcom32.c32 /boot/syslinux/mboot.c32 :: + syslinux boot.img + mdir -i boot.img :: \ No newline at end of file diff --git a/prototypes/video/boot.img b/prototypes/video/boot.img new file mode 100644 index 0000000..55bc203 Binary files /dev/null and b/prototypes/video/boot.img differ diff --git a/prototypes/video/compat.c b/prototypes/video/compat.c new file mode 100644 index 0000000..1af8b91 --- /dev/null +++ b/prototypes/video/compat.c @@ -0,0 +1,17 @@ +#include "compat.h" + +typedef void (*constructor)(); + +constructor start_ctors; +constructor end_ctors; + +void compat_call_ctors() +{ + for (constructor* i = &start_ctors;i != &end_ctors;++i) + (*i)(); +} + +void compat_call_dtors() +{ + +} \ No newline at end of file diff --git a/prototypes/video/entrypoint.S b/prototypes/video/entrypoint.S new file mode 100644 index 0000000..ba94dae --- /dev/null +++ b/prototypes/video/entrypoint.S @@ -0,0 +1,23 @@ +.section .text + +.extern init +.extern compat_call_ctors +.extern compat_call_dtors + +.global _start +_start: + mov $kernel_stack, %esp + + push %ebx + call compat_call_ctors + call init + call compat_call_dtors + +_stop: + cli + hlt + jmp _stop + +.section .bss +.space 8192 +kernel_stack: \ No newline at end of file diff --git a/prototypes/video/include/compat.h b/prototypes/video/include/compat.h new file mode 100644 index 0000000..747de12 --- /dev/null +++ b/prototypes/video/include/compat.h @@ -0,0 +1,13 @@ +#pragma once + +#if defined(__cplusplus) +extern "C" { +#endif + +void compat_call_ctors(); + +void compat_call_dtors(); + +#if defined(__cplusplus) +} +#endif \ No newline at end of file diff --git a/prototypes/video/include/multiboot.h b/prototypes/video/include/multiboot.h new file mode 100644 index 0000000..83aec61 --- /dev/null +++ b/prototypes/video/include/multiboot.h @@ -0,0 +1,309 @@ +/* multiboot.h - Multiboot header file. */ +/* Copyright (C) 1999,2003,2007,2008,2009,2010 Free Software Foundation, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ANY + * DEVELOPER OR DISTRIBUTOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef MULTIBOOT_HEADER +#define MULTIBOOT_HEADER 1 + +/* How many bytes from the start of the file we search for the header. */ +#define MULTIBOOT_SEARCH 8192 +#define MULTIBOOT_HEADER_ALIGN 4 + +/* The magic field should contain this. */ +#define MULTIBOOT_HEADER_MAGIC 0x1BADB002 + +/* This should be in %eax. */ +#define MULTIBOOT_BOOTLOADER_MAGIC 0x2BADB002 + +/* Alignment of multiboot modules. */ +#define MULTIBOOT_MOD_ALIGN 0x00001000 + +/* Alignment of the multiboot info structure. */ +#define MULTIBOOT_INFO_ALIGN 0x00000004 + +/* Flags set in the 'flags' member of the multiboot header. */ + +/* Align all boot modules on i386 page (4KB) boundaries. */ +#define MULTIBOOT_PAGE_ALIGN 0x00000001 + +/* Must pass memory information to OS. */ +#define MULTIBOOT_MEMORY_INFO 0x00000002 + +/* Must pass video information to OS. */ +#define MULTIBOOT_VIDEO_MODE 0x00000004 + +/* This flag indicates the use of the address fields in the header. */ +#define MULTIBOOT_AOUT_KLUDGE 0x00010000 + +/* Flags to be set in the 'flags' member of the multiboot info structure. */ + +/* is there basic lower/upper memory information? */ +#define MULTIBOOT_INFO_MEMORY 0x00000001 +/* is there a boot device set? */ +#define MULTIBOOT_INFO_BOOTDEV 0x00000002 +/* is the command-line defined? */ +#define MULTIBOOT_INFO_CMDLINE 0x00000004 +/* are there modules to do something with? */ +#define MULTIBOOT_INFO_MODS 0x00000008 + +/* These next two are mutually exclusive */ + +/* is there a symbol table loaded? */ +#define MULTIBOOT_INFO_AOUT_SYMS 0x00000010 +/* is there an ELF section header table? */ +#define MULTIBOOT_INFO_ELF_SHDR 0X00000020 + +/* is there a full memory map? */ +#define MULTIBOOT_INFO_MEM_MAP 0x00000040 + +/* Is there drive info? */ +#define MULTIBOOT_INFO_DRIVE_INFO 0x00000080 + +/* Is there a config table? */ +#define MULTIBOOT_INFO_CONFIG_TABLE 0x00000100 + +/* Is there a boot loader name? */ +#define MULTIBOOT_INFO_BOOT_LOADER_NAME 0x00000200 + +/* Is there a APM table? */ +#define MULTIBOOT_INFO_APM_TABLE 0x00000400 + +/* Is there video information? */ +#define MULTIBOOT_INFO_VBE_INFO 0x00000800 +#define MULTIBOOT_INFO_FRAMEBUFFER_INFO 0x00001000 + +#ifndef ASM_FILE + +typedef unsigned char multiboot_uint8_t; +typedef unsigned short multiboot_uint16_t; +typedef unsigned int multiboot_uint32_t; +typedef unsigned long long multiboot_uint64_t; + +struct multiboot_header +{ + /* Must be MULTIBOOT_MAGIC - see above. */ + multiboot_uint32_t magic; + + /* Feature flags. */ + multiboot_uint32_t flags; + + /* The above fields plus this one must equal 0 mod 2^32. */ + multiboot_uint32_t checksum; + + /* These are only valid if MULTIBOOT_AOUT_KLUDGE is set. */ + multiboot_uint32_t header_addr; + multiboot_uint32_t load_addr; + multiboot_uint32_t load_end_addr; + multiboot_uint32_t bss_end_addr; + multiboot_uint32_t entry_addr; + + /* These are only valid if MULTIBOOT_VIDEO_MODE is set. */ + multiboot_uint32_t mode_type; + multiboot_uint32_t width; + multiboot_uint32_t height; + multiboot_uint32_t depth; +}; + +/* The symbol table for a.out. */ +struct multiboot_aout_symbol_table +{ + multiboot_uint32_t tabsize; + multiboot_uint32_t strsize; + multiboot_uint32_t addr; + multiboot_uint32_t reserved; +}; +typedef struct multiboot_aout_symbol_table multiboot_aout_symbol_table_t; + +/* The section header table for ELF. */ +struct multiboot_elf_section_header_table +{ + multiboot_uint32_t num; + multiboot_uint32_t size; + multiboot_uint32_t addr; + multiboot_uint32_t shndx; +}; +typedef struct multiboot_elf_section_header_table multiboot_elf_section_header_table_t; + +struct multiboot_info +{ + /* Multiboot info version number */ + multiboot_uint32_t flags; + + /* Available memory from BIOS */ + multiboot_uint32_t mem_lower; + multiboot_uint32_t mem_upper; + + /* "root" partition */ + multiboot_uint32_t boot_device; + + /* Kernel command line */ + multiboot_uint32_t cmdline; + + /* Boot-Module list */ + multiboot_uint32_t mods_count; + multiboot_uint32_t mods_addr; + + union + { + multiboot_aout_symbol_table_t aout_sym; + multiboot_elf_section_header_table_t elf_sec; + } u; + + /* Memory Mapping buffer */ + multiboot_uint32_t mmap_length; + multiboot_uint32_t mmap_addr; + + /* Drive Info buffer */ + multiboot_uint32_t drives_length; + multiboot_uint32_t drives_addr; + + /* ROM configuration table */ + multiboot_uint32_t config_table; + + /* Boot Loader Name */ + multiboot_uint32_t boot_loader_name; + + /* APM table */ + multiboot_uint32_t apm_table; + + /* Video */ + multiboot_uint32_t vbe_control_info; + multiboot_uint32_t vbe_mode_info; + multiboot_uint16_t vbe_mode; + multiboot_uint16_t vbe_interface_seg; + multiboot_uint16_t vbe_interface_off; + multiboot_uint16_t vbe_interface_len; + + multiboot_uint64_t framebuffer_addr; + multiboot_uint32_t framebuffer_pitch; + multiboot_uint32_t framebuffer_width; + multiboot_uint32_t framebuffer_height; + multiboot_uint8_t framebuffer_bpp; +#define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0 +#define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1 +#define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2 + multiboot_uint8_t framebuffer_type; + union + { + struct + { + multiboot_uint32_t framebuffer_palette_addr; + multiboot_uint16_t framebuffer_palette_num_colors; + }; + struct + { + multiboot_uint8_t framebuffer_red_field_position; + multiboot_uint8_t framebuffer_red_mask_size; + multiboot_uint8_t framebuffer_green_field_position; + multiboot_uint8_t framebuffer_green_mask_size; + multiboot_uint8_t framebuffer_blue_field_position; + multiboot_uint8_t framebuffer_blue_mask_size; + }; + }; +}; +typedef struct multiboot_info multiboot_info_t; + +struct multiboot_color +{ + multiboot_uint8_t red; + multiboot_uint8_t green; + multiboot_uint8_t blue; +}; + +struct multiboot_mmap_entry +{ + multiboot_uint32_t size; + multiboot_uint64_t addr; + multiboot_uint64_t len; +#define MULTIBOOT_MEMORY_AVAILABLE 1 +#define MULTIBOOT_MEMORY_RESERVED 2 +#define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE 3 +#define MULTIBOOT_MEMORY_NVS 4 +#define MULTIBOOT_MEMORY_BADRAM 5 + multiboot_uint32_t type; +} __attribute__((packed)); +typedef struct multiboot_mmap_entry multiboot_memory_map_t; + +struct multiboot_mod_list +{ + /* the memory used goes from bytes 'mod_start' to 'mod_end-1' inclusive */ + multiboot_uint32_t mod_start; + multiboot_uint32_t mod_end; + + /* Module command line */ + multiboot_uint32_t cmdline; + + /* padding to take it to 16 bytes (must be zero) */ + multiboot_uint32_t pad; +}; +typedef struct multiboot_mod_list multiboot_module_t; + +/* APM BIOS info. */ +struct multiboot_apm_info +{ + multiboot_uint16_t version; + multiboot_uint16_t cseg; + multiboot_uint32_t offset; + multiboot_uint16_t cseg_16; + multiboot_uint16_t dseg; + multiboot_uint16_t flags; + multiboot_uint16_t cseg_len; + multiboot_uint16_t cseg_16_len; + multiboot_uint16_t dseg_len; +}; +struct MODE_INFO +{ + unsigned short ModeAttributes ; + unsigned char WinAAttributes ; + unsigned char WinBAttributes ; + unsigned short WinGranularity ; + unsigned short WinSize ; + unsigned short WinASegment ; + unsigned short WinBSegment ; + unsigned int WinFuncPtr ; + unsigned short BytesPerScanLine ; + unsigned short XResolution ; + unsigned short YResolution ; + unsigned char XCharSize ; + unsigned char YCharSize ; + unsigned char NumberOfPlanes ; + unsigned char BitsPerPixel ; + unsigned char NumberOfBanks ; + unsigned char MemoryModel ; + unsigned char BankSize ; + unsigned char NumberOfImagePages ; + unsigned char Reserved_page ; + unsigned char RedMaskSize ; + unsigned char RedMaskPos ; + unsigned char GreenMaskSize ; + unsigned char GreenMaskPos ; + unsigned char BlueMaskSize ; + unsigned char BlueMaskPos ; + unsigned char ReservedMaskSize ; + unsigned char ReservedMaskPos ; + unsigned char DirectColorModeInfo ; + unsigned int PhysBasePtr ; + unsigned int OffScreenMemOffset ; + unsigned short OffScreenMemSize ; + unsigned char Reserved[206] ; +}__attribute__ ((packed)); +#endif /* ! ASM_FILE */ + +#endif /* ! MULTIBOOT_HEADER */ \ No newline at end of file diff --git a/prototypes/video/include/multiboot.hpp b/prototypes/video/include/multiboot.hpp new file mode 100644 index 0000000..ffd392d --- /dev/null +++ b/prototypes/video/include/multiboot.hpp @@ -0,0 +1,169 @@ +#pragma once + +#include +#include +#include "pointer.hpp" + +#define MB_MEMSIZE (1<<0) +#define MB_BOOTDEVICE (1<<1) +#define MB_COMMANDLINE (1<<2) +#define MB_MODULES (1<<3) +#define MB_SYMS_AOUT (1<<4) +#define MB_SYMS_ELF (1<<5) +#define MB_MEMORYMAP (1<<6) +#define MB_DRIVES (1<<7) +#define MB_CONFIG_TABLE (1<<8) +#define MB_BOOTLOADER_NAME (1<<9) +#define MB_APS_TABLE (1<<10) +#define MB_VBE (1<<11) + +#define MB_ASSERT_SIZE(type, len) static_assert(sizeof(type) == len, "multiboot::" #type " must be " #len " bytes large.") + +namespace multiboot +{ + template + class mbarray + { + public: + const uint32_t length; + private: + T *data; + + mbarray() = delete; + public: + T const & operator [](size_t idx) const { + return this->data[idx]; + } + + const T *begin() const { + return &data[0]; + } + const T *end() const { + return &data[length]; + } + } __attribute__((packed)); + + // Make sure the size is not dependend on the template parameter + MB_ASSERT_SIZE(mbarray, 8); + MB_ASSERT_SIZE(mbarray, 8); + + struct MemoryMap + { + uint32_t entry_size; + uint64_t base; + uint64_t length; + uint32_t type; + + + bool isFree() const { + return this->type == 1; + } + + } __attribute__((packed)); + + MB_ASSERT_SIZE(MemoryMap, 24); + + struct Module + { + physical_t start; + physical_t end; + const char * name; + uint32_t reserved; + + uint32_t size() const { + return this->end.numeric() - this->start.numeric(); + } + + } __attribute__((packed)); + + MB_ASSERT_SIZE(Module, 16); + + struct Drive + { + uint32_t size; + uint8_t number; + uint8_t mode; + uint16_t cylinders; + uint8_t heads; + uint8_t sectors; + + // 0x10 size-0x10 drive_ports I/O-Ports, die von diesem Gerät benutzt werden + // uint16_t ports[0]; + + /** + * Gets the number of ports used by this drive. + */ + uint32_t portCount() const { + return (this->size - 0x10) / sizeof(uint16_t); + } + + /** + * Gets the given port. + * @return The port #idx or 0 if out of range. + */ + uint16_t port(size_t idx) const { + uint16_t const * ports = reinterpret_cast(reinterpret_cast(this) + 0x10); + if(idx >= this->portCount()) { + return 0; + } + return ports[idx]; + } + } __attribute__((packed)); + + static_assert(sizeof(Drive) >= 10, "multiboot::Drive must be at least 12 bytes large."); + + struct APMTable + { + uint16_t version; + uint16_t cseg; + uint32_t offset; + uint16_t cseg_16; + uint16_t dseg; + uint16_t flags; + uint16_t cseg_len; + uint16_t cseg_16_len; + uint16_t dseg_len; + } __attribute__((packed)); + + MB_ASSERT_SIZE(APMTable, 20); + + struct Structure + { + uint32_t flags; + physical_t memLower; + physical_t memUpper; + uint32_t bootDevice; + const char * commandline; + mbarray modules; + union { + struct { + uint32_t tabsize; + uint32_t strsize; + uint32_t addr; + uint32_t reserved; + } __attribute__((packed)) symsAssemblerOut; + struct { + uint32_t num; + uint32_t size; + uintptr_t addr; + uintptr_t shndx; + } __attribute__((packed)) symsELF; + }; + mbarray memoryMaps; + mbarray drives; + physical_t configTable; + const char * bootLoaderName; + const APMTable * apmTable; + struct { + uint32_t controlInfo; + uint32_t modeInfo; + uint16_t mode; + uint16_t interfaceSegment; + uint16_t interfaceOffset; + uint16_t interfaceLength; + } __attribute__((packed)) vbe; + } __attribute__((packed)); + + // MB_ASSERT_SIZE(Structure, 88); + +} \ No newline at end of file diff --git a/prototypes/video/include/pointer.hpp b/prototypes/video/include/pointer.hpp new file mode 100644 index 0000000..8f93c00 --- /dev/null +++ b/prototypes/video/include/pointer.hpp @@ -0,0 +1,116 @@ +#pragma once + +#include + +/** + * Provides a strong pointer wrapper which can be used to address + * different memory types (physical, virtual, ...) and preventing + * a wrong assignment. + * @remarks The pointer size is fixed to 32 bits. + */ +template +class pointer +{ +public: + /** + * A value that declares the pointer invalid. + */ + static pointer invalid; +private: + uint32_t ptr; +public: + /** + * Creates the pointer by giving a raw pointer. + */ + explicit pointer(void *ptr) : + ptr(reinterpret_cast(ptr)) + { + + } + + /** + * Creates the pointer by giving an integer value. + */ + explicit pointer(uint32_t value) : + ptr(value) + { + + } + + pointer(const pointer &) = default; + pointer(pointer &&) = default; + ~pointer() = default; + + pointer & operator = (const pointer & other) { + this->ptr = other.ptr; + return *this; + } + + /** + * Returns the numeric integer value of the pointer. + */ + uint32_t numeric() const { + return this->ptr; + } + + /** + * Returns the pointer as a raw pointer. + */ + void * data() const { + return reinterpret_cast(this->ptr); + } + + /** + * Returns the pointer as a raw typed pointer. + */ + template + T * data () const { + return reinterpret_cast(this->ptr); + } + + /** + * Allow explicit conversion to a raw pointer. + */ + explicit operator void * () const { + return this->data(); + } + + /** + * Returns an aligned version of the pointer. + * Rounds the pointer to the memory bottom. + */ + pointer alignLower(uint32_t alignment) { + if(alignment == 0) return pointer::invalid; + return pointer(this->ptr & ~(alignment - 1)); + } + + /** + * Returns an aligned version of the pointer. + * Rounds the pointer to the memory top. + */ + pointer alignUpper(uint32_t alignment) { + if(alignment == 0) return pointer::invalid; + return pointer((this->ptr + (alignment - 1)) & ~(alignment - 1)); + } +} __attribute__((packed)); + +template +pointer pointer::invalid(uint32_t(0xFFFFFFFF)); + +struct physical_t_ident; +struct virtual_t_ident; + +// Add different memory pointer types here.... + +/** + * A pointer pointing to physical memory. + */ +using physical_t = pointer; + +/** + * A pointer pointing to virtual memory. + */ +using virtual_t = pointer; + + +static_assert(sizeof(physical_t) == 4, "pointer is not 4 byte wide."); \ No newline at end of file diff --git a/prototypes/video/init.cpp b/prototypes/video/init.cpp new file mode 100644 index 0000000..e4e3a0e --- /dev/null +++ b/prototypes/video/init.cpp @@ -0,0 +1,84 @@ +#include + +#include "multiboot.h" + +#include "../base/include/io.hpp" + +struct dummy; + +// Symbols generated by linker, no useful content in there... +extern dummy kernelStartMarker; +extern dummy kernelEndMarker; + +uint16_t * video = (uint16_t*)0xB8000; + +// Prüft, ob man bereits schreiben kann +static uint8_t is_transmit_empty(uint16_t base) { + return inb(base+5) & 0x20; +} + + // Byte senden +static void write_com(uint16_t base, uint8_t chr) { + while (is_transmit_empty(base)==0); + outb(base,chr); +} + +#define VBE_FAR(name) uint32_t name; + +struct ModeInfoBlock { + uint16_t attributes; + uint8_t winA,winB; + uint16_t granularity; + uint16_t winsize; + uint16_t segmentA, segmentB; + VBE_FAR(realFctPtr); + uint16_t pitch; // bytes per scanline + + uint16_t Xres, Yres; + uint8_t Wchar, Ychar, planes, bpp, banks; + uint8_t memory_model, bank_size, image_pages; + uint8_t reserved0; + + uint8_t red_mask, red_position; + uint8_t green_mask, green_position; + uint8_t blue_mask, blue_position; + uint8_t rsv_mask, rsv_position; + uint8_t directcolor_attributes; + + uint32_t physbase; // your LFB (Linear Framebuffer) address ;) + uint32_t reserved1; + uint16_t reserved2; +} __attribute__((packed)); + +extern "C" void init(multiboot_info_t const & data) +{ + const char *msg = "You should not see this."; + while(*msg) + { + *(video++) = *msg++ | 0x0700; + } + + ModeInfoBlock *modeInfo = (ModeInfoBlock*)data.vbe_mode_info; + + uint8_t *fb = (uint8_t*)modeInfo->physbase; + + for(int y = 0; y < modeInfo->Yres; y++) + { + for(int x = 0; x < modeInfo->Xres; x++) + { + uint32_t r = (x * 384 / modeInfo->Xres); + uint32_t g = (y * 384 / modeInfo->Yres); + uint32_t b = 0x00; + + fb[modeInfo->pitch * y + 4 * x + 2] = r; + fb[modeInfo->pitch * y + 4 * x + 1] = g; + fb[modeInfo->pitch * y + 4 * x + 0] = b; + } + } + + write_com(0x3F8, 'H'); + write_com(0x3F8, 'i'); + write_com(0x3F8, '\n'); + + while(true); +} diff --git a/prototypes/video/linker.ld b/prototypes/video/linker.ld new file mode 100644 index 0000000..ed97bd5 --- /dev/null +++ b/prototypes/video/linker.ld @@ -0,0 +1,37 @@ +ENTRY(_start) +OUTPUT_FORMAT(elf32-i386) +OUTPUT_ARCH(i386:i386) + +SECTIONS +{ + . = 0x100000; + + kernelStartMarker = .; + + .text : { + *(multiboot) + *(.text) + } + .data ALIGN(4096) : { + start_ctors = .; + KEEP(*( .init_array )); + KEEP(*(SORT_BY_INIT_PRIORITY( .init_array.* ))); + end_ctors = .; + + start_dtors = .; + KEEP(*( .fini_array )); + end_dtors = .; + + *(.data) + } + .rodata ALIGN(4096) : { + *(.rodata) + } + .bss ALIGN(4096) : { + *(.bss) + } + + /* Align the end of the kernel to the page size */ + . = ALIGN(4096); + kernelEndMarker = .; +} \ No newline at end of file diff --git a/prototypes/video/multiboot.S b/prototypes/video/multiboot.S new file mode 100644 index 0000000..f5af759 --- /dev/null +++ b/prototypes/video/multiboot.S @@ -0,0 +1,28 @@ +.section multiboot + +#define MB_MAGIC 0x1badb002 +#define MB_FLAGS 0x07 +#define MB_CHECKSUM -(MB_MAGIC + MB_FLAGS) + +.align 4 + +// Offset Type Field Name Note +// 0 u32 magic required +// 4 u32 flags required +// 8 u32 checksum required +.int MB_MAGIC +.int MB_FLAGS +.int MB_CHECKSUM + +// 12 u32 header_addr if flags[16] is set +// 16 u32 load_addr if flags[16] is set +// 20 u32 load_end_addr if flags[16] is set +// 24 u32 bss_end_addr if flags[16] is set +// 28 u32 entry_addr if flags[16] is set +.int 0, 0, 0, 0, 0 + +// 32 u32 mode_type if flags[2] is set +// 36 u32 width if flags[2] is set +// 40 u32 height if flags[2] is set +// 44 u32 depth if flags[2] is set +.int 0, 640, 480, 32 \ No newline at end of file diff --git a/prototypes/video/syslinux.cfg b/prototypes/video/syslinux.cfg new file mode 100644 index 0000000..0c8c2d5 --- /dev/null +++ b/prototypes/video/syslinux.cfg @@ -0,0 +1,6 @@ +DEFAULT video + +LABEL video + SAY Now booting video demo. + KERNEL mboot.c32 + APPEND video.ker \ No newline at end of file