multiboot.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2003,2004 Bregmasoft
 * 
 * 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, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA
 */
#ifndef ZYGOMA_X86_MULTIBOOT_H_ 
#define ZYGOMA_X86_MULTIBOOT_H_ 

#include <arch/types.h>

namespace Zygoma
{
  namespace ia32
  {
    struct MultibootHeader
    {
      /* @{ */
      u32 m_magic;

      static const u32 kMAGIC = 0x1BADB002;

      u32 m_flags;
      static const u32 kFLAGS_ALIGN_ON_4K             = (1 << 0);
      static const u32 kFLAGS_INCLUDE_MEM_FIELDS      = (1 << 1);
      static const u32 kFLAGS_VIDEO_FIELDS_INCLUDED   = (1 << 2);
      static const u32 kFLAGS_ADDRESS_FIELDS_INCLUDED = (1 << 16);

      u32 m_checksum;

      /* @} */

      /* @{ */

      u32 m_header_addr;

      u32 m_load_addr;

      u32 m_load_end_addr;

      u32 m_bss_end_addr;

      u32 m_entry_addr;

      /* @} */

      /* @{ */

      u32 m_mode_type;
      enum GraphicsMode
      {
        kGRAPHMODE_GRAPHICS = 0,  
        kGRAPHMODE_TEXT = 1       
      };

      u32 m_width;

      u32 m_height;

      u32 m_depth;

      /* @} */
    };


    struct LoadModuleDescriptor
    {
      u32 m_mod_start;
      u32 m_mod_end;
      u32 m_string;
      u32 m_reserved;
    };

    struct MemoryMapDescriptor
    {
      u32 m_size;
      u32 m_base_addr_low;
      u32 m_base_addr_high;
      u32 m_length_low;
      u32 m_length_high;
      u32 m_type; /* 1=available RAM, otherwise=other */
    };

    struct DiskDriveMapDescriptor
    {
      u32 m_size;
      u08 m_drive_number;
      u08 m_drive_mode; /* 0 = CHS, 1 = LBA */
      u16 m_drive_cylenders;
      u08 m_drive_heads;
      u08 m_drive_sectors;
      u16 m_drive_ports[1];
    } ZYGOMA_PACKED;


    struct MultibootInfo
    {
    public:
      static const u32 kMAGIC = 0x2BADB002;

      u32 m_flags;
      static const u32 kFLAG_MEM_FIELDS_VALID         = (1 << 0);
      static const u32 kFLAG_BOOT_DEVICE_FIELDS_VALID = (1 << 1);
      static const u32 kFLAG_CMDLINE_FIELDS_VALID     = (1 << 2);
      static const u32 kFLAG_MODULES_FIELDS_VALID     = (1 << 3);
      static const u32 kFLAG_AOUT_FIELDS_VALID        = (1 << 4);
      static const u32 kFLAG_ELF_FIELDS_VALID         = (1 << 5);
      static const u32 kFLAG_MMAP_FIELDS_VALID        = (1 << 6);
      static const u32 kFLAG_DRIVES_FIELDS_VALID      = (1 << 7);
      static const u32 kFLAG_CONFIG_FIELDS_VALID      = (1 << 8);
      static const u32 kFLAG_LOADER_NAME_FIELDS_VALID = (1 << 9);
      static const u32 kFLAG_APM_FIELDS_VALID         = (1 << 10);
      static const u32 kFLAG_GRAPHICS_FIELDS_VALID    = (1 << 11);

      /* @{ */
    private:
      u32 m_mem_lower;

    public:
      u32
      mem_lower() const
      {
        if (m_flags & kFLAG_MEM_FIELDS_VALID)
        {
          return m_mem_lower;
        }
        else
        {
          return 0;
        }
      }

    private:
      u32 m_mem_upper;


    public:
      u32
      mem_upper() const
      {
        if (m_flags & kFLAG_MEM_FIELDS_VALID)
        {
          return m_mem_upper;
        }
        else
        {
          return 0;
        }
      }
      /* @{ */
    private:
      u32 m_boot_device;

    public:
      u32
      boot_device() const
      {
        if (m_flags & kFLAG_BOOT_DEVICE_FIELDS_VALID)
        {
          return m_boot_device;
        }
        else
        {
          return 0xffffffff;
        }
      }

      /* @{ */
    private:
      u32 m_cmdline;

    public:
      const char*
      cmdline() const
      {
        if ((m_flags & kFLAG_CMDLINE_FIELDS_VALID) && (m_cmdline != 0))
        {
          return reinterpret_cast<const char*>(m_cmdline);
        }
        else
        {
          return "";
        }
      }

      /* @} */

      /* @{ */
    public:
      u32 m_mods_count;

      u32 m_mods_addr;

      /* @} */

      /* @{ */
    public:
      u32 m_syms[4];
      /* @} */

      /* @{ */
    private:
      u32 m_mmap_length;
      u32 m_mmap_addr;

    public:
      MemoryMapDescriptor*
      memoryMapBase()
      {
        if (m_flags & kFLAG_MMAP_FIELDS_VALID)
        {
          return reinterpret_cast<MemoryMapDescriptor*>(m_mmap_addr);
        }
        else
        {
          return 0;
        }
      }

      u32
      memoryMapLength()
      {
        if (m_flags & kFLAG_MMAP_FIELDS_VALID)
        {
          return m_mmap_length
                 / (sizeof(MemoryMapDescriptor) - sizeof(u32));
        }
        else
        {
          return 0;
        }
      }

      /* @} */

      /* @{ */
    public:
      u32 m_drives_length;
      u32 m_drives_addr;

      /* @} */

      /* @{ */
    public:
      u32 m_config_table;

      /* @} */

      /* @{ */
    private:
      u32 m_boot_loader_name;

    public:
      const char*
      boot_loader_name() const
      {
        if ((m_flags & kFLAG_LOADER_NAME_FIELDS_VALID) && (m_boot_loader_name != 0))
        {
          return reinterpret_cast<const char*>(m_boot_loader_name);
        }
        else
        {
          return "unknown";
        }
      }

      /* @} */

      /* @{ */
    public:
      u32 m_apm_table;

      /* @} */

      /* @{ */
    public:
      u32 m_vbe_control_info;
      u32 m_vbe_mode_info;
      u32 m_vbe_mode;
      u16 m_vbe_interface_seg;
      u16 m_vbe_interface_of;
      u16 m_vbe_interface_len;
      /* @} */
    };
    inline u32
    endOfMemory(MultibootInfo* mbinfo)
    {
      u32 ramEnd = 0;
      MemoryMapDescriptor* mmd = mbinfo->memoryMapBase();
      for (unsigned int i = 0; i < mbinfo->memoryMapLength(); ++i)
      {
        if (mmd[i].m_type == 1)
        {
          u32 mend = mmd[i].m_base_addr_low + mmd[i].m_length_low;
          if (mend > ramEnd)
          {
            ramEnd = mend;
          }
        }
      }
      return ramEnd;
    }

    extern MultibootInfo* g_multibootInfo;
  } // namespace ia32
} // namespace Zygoma

#endif // ZYGOMA_X86_MULTIBOOT_H_ 

---