Return to multiboot.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / arch / x86

Annotation of qemu/roms/openbios/arch/x86/multiboot.c, revision 1.1

1.1     ! root        1: /* Support for Multiboot */
        !             2: 
        !             3: #include "config.h"
        !             4: #include "asm/io.h"
        !             5: #include "libopenbios/sys_info.h"
        !             6: #include "multiboot.h"
        !             7: 
        !             8: #ifdef CONFIG_DEBUG_BOOT
        !             9: #define debug printk
        !            10: #else
        !            11: #define debug(x...)
        !            12: #endif
        !            13: 
        !            14: struct mbheader {
        !            15:     unsigned int magic, flags, checksum;
        !            16: };
        !            17: 
        !            18: static const struct mbheader multiboot_header
        !            19:        __attribute__((section (".hdr"))) =
        !            20: {
        !            21:     MULTIBOOT_HEADER_MAGIC,
        !            22:     MULTIBOOT_HEADER_FLAGS,
        !            23:     -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS)
        !            24: };
        !            25: 
        !            26: /* Multiboot information structure, provided by loader to us */
        !            27: 
        !            28: struct multiboot_mmap {
        !            29:        unsigned entry_size;
        !            30:        unsigned base_lo, base_hi;
        !            31:        unsigned size_lo, size_hi;
        !            32:        unsigned type;
        !            33: };
        !            34: 
        !            35: #define MULTIBOOT_MEM_VALID       0x01
        !            36: #define MULTIBOOT_BOOT_DEV_VALID  0x02
        !            37: #define MULTIBOOT_CMDLINE_VALID   0x04
        !            38: #define MULTIBOOT_MODS_VALID      0x08
        !            39: #define MULTIBOOT_AOUT_SYMS_VALID 0x10
        !            40: #define MULTIBOOT_ELF_SYMS_VALID  0x20
        !            41: #define MULTIBOOT_MMAP_VALID      0x40
        !            42: 
        !            43: void collect_multiboot_info(struct sys_info *info);
        !            44: void collect_multiboot_info(struct sys_info *info)
        !            45: {
        !            46:     struct multiboot_info *mbinfo;
        !            47:     struct multiboot_mmap *mbmem;
        !            48:     unsigned mbcount, mbaddr;
        !            49:     int i;
        !            50:     struct memrange *mmap;
        !            51:     int mmap_count;
        !            52:     module_t *mod;
        !            53: 
        !            54:     if (info->boot_type != 0x2BADB002)
        !            55:        return;
        !            56: 
        !            57:     debug("Using Multiboot information at %#lx\n", info->boot_data);
        !            58: 
        !            59:     mbinfo = phys_to_virt(info->boot_data);
        !            60: 
        !            61:     if (mbinfo->mods_count != 1) {
        !            62:            printk("multiboot: no dictionary\n");
        !            63:            return;
        !            64:     }
        !            65: 
        !            66:     mod = (module_t *) mbinfo->mods_addr;
        !            67:     info->dict_start=(unsigned long *)mod->mod_start;
        !            68:     info->dict_end=(unsigned long *)mod->mod_end;
        !            69:     debug("multiboot: dictionary at %p-%p\n",
        !            70:                    info->dict_start, info->dict_end);
        !            71: 
        !            72:     if (mbinfo->flags & MULTIBOOT_MMAP_VALID) {
        !            73:        /* convert mmap records */
        !            74:        mbmem = phys_to_virt(mbinfo->mmap_addr);
        !            75:        mbcount = mbinfo->mmap_length / (mbmem->entry_size + 4);
        !            76:        mmap = malloc(mbcount * sizeof(struct memrange));
        !            77:        mmap_count = 0;
        !            78:        mbaddr = mbinfo->mmap_addr;
        !            79:        for (i = 0; i < mbcount; i++) {
        !            80:            mbmem = phys_to_virt(mbaddr);
        !            81:            debug("%08x%08x %08x%08x (%d)\n",
        !            82:                    mbmem->base_hi,
        !            83:                    mbmem->base_lo,
        !            84:                    mbmem->size_hi,
        !            85:                    mbmem->size_lo,
        !            86:                    mbmem->type);
        !            87:            if (mbmem->type == 1) { /* Only normal RAM */
        !            88:                mmap[mmap_count].base = mbmem->base_lo
        !            89:                    + (((unsigned long long) mbmem->base_hi) << 32);
        !            90:                mmap[mmap_count].size = mbmem->size_lo
        !            91:                    + (((unsigned long long) mbmem->size_hi) << 32);
        !            92:                mmap_count++;
        !            93:            }
        !            94:            mbaddr += mbmem->entry_size + 4;
        !            95:            if (mbaddr >= mbinfo->mmap_addr + mbinfo->mmap_length)
        !            96:                break;
        !            97:        }
        !            98:        /* simple sanity check - there should be at least 2 RAM segments
        !            99:         * (base 640k and extended) */
        !           100:        if (mmap_count >= 2)
        !           101:            goto got_it;
        !           102: 
        !           103:        printk("Multiboot mmap is broken\n");
        !           104:        free(mmap);
        !           105:        /* fall back to mem_lower/mem_upper */
        !           106:     }
        !           107: 
        !           108:     if (mbinfo->flags & MULTIBOOT_MEM_VALID) {
        !           109:        /* use mem_lower and mem_upper */
        !           110:        mmap_count = 2;
        !           111:        mmap = malloc(2 * sizeof(*mmap));
        !           112:        mmap[0].base = 0;
        !           113:        mmap[0].size = mbinfo->mem_lower << 10;
        !           114:        mmap[1].base = 1 << 20; /* 1MB */
        !           115:        mmap[1].size = mbinfo->mem_upper << 10;
        !           116:        goto got_it;
        !           117:     }
        !           118: 
        !           119:     printk("Can't get memory information from Multiboot\n");
        !           120:     return;
        !           121: 
        !           122: got_it:
        !           123:     info->memrange = mmap;
        !           124:     info->n_memranges = mmap_count;
        !           125: 
        !           126:     return;
        !           127: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.