mps.h

Go to the documentation of this file.

/*
 *  Copyright (C) 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_IA32_MPS_H_ 
#define ZYGOMA_IA32_MPS_H_ 

#include <arch/apic.h>
#include <config.h>
#include "arch/ioapic.h"
#include <iosfwd>
#include <iterator>
#include <memory.h>
#include <types.h>

namespace Zygoma
{
  namespace ia32
  {
    namespace MPS
    {

      class ConfigTableHeader;

      class FloatingPointer
      {
      public:
        static const int kSIGNATURE_LENGTH = 4;
        static const u08 kSIGNATURE[kSIGNATURE_LENGTH];

      public:
        static const FloatingPointer* kNOT_FOUND;

        static const FloatingPointer* locateMPFP();

        ConfigTableHeader*
        configTableHeader() const
        { return reinterpret_cast<ConfigTableHeader*>(m_configTableAddress); }

        u08
        configType() const
        { return m_features[0]; }

        bool
        imcrIsPresent() const
        { return ((m_features[1] & 0x80) != 0); }

      private:
        u08 m_signature[kSIGNATURE_LENGTH]; // should be '_MP_'
        u32 m_configTableAddress;
        u08 m_length; // length of this table in 16-byte units
        u08 m_revision; // should be 0x04
        u08 m_checksum; // all bytes checksum to zero
        u08 m_features[5];  // see spec
      } ZYGOMA_PACKED;


      class ConfigTableEntry;

      class ConfigTableIterator
      : public std::iterator<std::forward_iterator_tag, const ConfigTableEntry>
      {
      public:
        explicit ConfigTableIterator(ConfigTableHeader*);

        reference
        operator*() const;

        pointer
        operator->() const;

        ConfigTableIterator&
        operator++();

        ConfigTableIterator&
        operator++(int);

        bool
        equals(const ConfigTableIterator& rhs) const
        { return m_curEntryAddress == rhs.m_curEntryAddress; }

      private:
        const ConfigTableEntry* m_curEntryAddress;
      };


      inline bool
      operator==(const ConfigTableIterator& lhs, const ConfigTableIterator& rhs)
      { return lhs.equals(rhs); }


      inline bool
      operator!=(const ConfigTableIterator& lhs, const ConfigTableIterator& rhs)
      { return !lhs.equals(rhs); }


      class ConfigTableHeader
      {
        static const int kSIGNATURE_LENGTH = 4;
        static const int kOEM_ID_LENGTH = 8;
        static const int kPRODUCT_ID_LENGTH = 12;
      public:
        typedef ConfigTableIterator iterator;

        LocalApic*
        apicAddress() const
        { return reinterpret_cast<LocalApic*>(m_apicAddress); }

        iterator
        begin();

        iterator
        end();

        std::ostream&
        printStream(std::ostream& ostr) const;

      public:
        u08 m_signature[kSIGNATURE_LENGTH];
        u16 m_baseTableLength;
        u08 m_revision;
        u08 m_checksum;
        u08 m_oemId[kOEM_ID_LENGTH];
        u08 m_productId[kPRODUCT_ID_LENGTH];
        u32 m_oemTableAddress;
        u16 m_oemTableSize;
        u16 m_entryCount;
        u32 m_apicAddress;
        u16 m_extendedTableLength;
        u08 m_extendedTableChecksum;
        u08 m_reserved;
      } ZYGOMA_PACKED;


      inline std::ostream&
      operator<<(std::ostream& ostr, const ConfigTableHeader& table)
      {
        return table.printStream(ostr);
      }


      class ConfigTableEntry
      {
      public:
        enum EntryType
        {
          kCONFIG_TABLE_PROCESSOR = 0,
          kCONFIG_TABLE_BUS = 1,
          kCONFIG_TABLE_IO_APIC = 2,
          kCONFIG_TABLE_IO_INTERRUPT = 3,
          kCONFIG_TABLE_LOCAL_INTERRUPT = 4,
        };

      public:
        EntryType
        entryType() const
        {
          return static_cast<EntryType>(m_entryType&0xff);
        }

      private:
        u08 m_entryType; // kCONFIG_TABLE_PROCESSOR
      } ZYGOMA_PACKED;


      class ProcessorEntry
      : public ConfigTableEntry
      {
      public:
        int
        id() const
        { return m_localApicId & 0xff; }

        bool
        isEnabled() const
        { return m_isEnabled; }

        bool
        isBootstrapProcessor() const
        { return m_isBootstrap; }

        int
        family() const
        { return m_family & 0xff; }

        int
        model() const
        { return m_model & 0xff; }

        int
        stepping() const
        { return m_stepping & 0xff; }

        std::ostream&
        printStream(std::ostream& ostr) const;

      private:
        u08 m_localApicId;
        u08 m_localApicVersion;
        u08 m_isEnabled:1;
        u08 m_isBootstrap:1;
        u08 m_reserved:2;
        u08 m_stepping:4;
        u08 m_model:4;
        u08 m_family:4;
        u32 m_onChipFpu:1;  // has 387-style on-chip FPU
        u32 m_reserved1:6;
        u32 m_machineCheckException:1;
        u32 m_cmpxchg8b:1; // CPU supports 64-bit cmpxch instruction
        u32 m_onChipApic:1; // CPU has on-chip APIC
      } ZYGOMA_PACKED;


      inline std::ostream&
      operator<<(std::ostream& ostr, const ProcessorEntry& p)
      { return p.printStream(ostr); }

      class BusEntry
      : public ConfigTableEntry
      {
      public:
        static const int kBUS_TYPE_LENGTH = 4;

      public:
        int
        id() const
        { return m_id; }

      public:
        u08 m_id;
        u08 m_type[kBUS_TYPE_LENGTH];
      } ZYGOMA_PACKED;


      class IOApicEntry
      : public ConfigTableEntry
      {
      public:
        int
        id() const
        { return m_id; }

        u08
        version() const
        { return m_version; }

        bool
        isEnabled() const
        { return m_isUsable; }

        IOApic*
        address() const
        { return reinterpret_cast<IOApic*>(m_address); }

      private:
        u08 m_id;
        u08 m_version;
        u08 m_isUsable:1;
        u32 m_address;
      } ZYGOMA_PACKED;


      class IOInterruptEntry
      : public ConfigTableEntry
      {
      public:
        enum InterruptType
        {
          kINTERRUPT_TYPE_INT = 0,
          kINTERRUPT_TYPE_NMI = 1,
          kINTERRUPT_TYPE_SMI = 2,
          kINTERRUPT_EXT_INT = 3
        };

        enum Polarity
        {
          kPOLARITY_BUS_SPEC = 0,
          kPOLARITY_ACTIVE_HIGH = 1,
          kPOLARITY_ACTIVE_LOW = 3
        };

        enum TriggerMode
        {
          kTRIGGER_MODE_BUS_SPEC = 0,
          kTRIGGER_EDGE_TRIGGERED = 1,
          kTRIGGER_LEVEL_TRIGGERED = 3
        };

      public:
        InterruptType
        interruptType() const
        {
          return static_cast<InterruptType>(m_type&0xff);
        }

        Polarity
        polarity() const
        {
          return static_cast<Polarity>(m_polarity&0xff);
        }

        TriggerMode
        triggerMode() const
        {
          return static_cast<TriggerMode>(m_triggerMode&0xff);
        }

        int
        sourceBusId() const
        { return m_sourceBus & 0xff; }

        int
        sourceBusIrq() const
        { return m_sourceBusIrq & 0xff; }

        int
        destinationApicId() const
        { return m_destinationApicId & 0xff; }

        int
        destinationApicInt() const
        { return m_destinationApicInt & 0xff; }

      private:
        u08 m_type;
        u08 m_polarity:2;
        u08 m_triggerMode:2;
        u08 m_reserved;
        u08 m_sourceBus;
        u08 m_sourceBusIrq;
        u08 m_destinationApicId;
        u08 m_destinationApicInt;
      } ZYGOMA_PACKED;


      class LocalInterruptEntry
      : public ConfigTableEntry
      {
      public:
        enum InterruptType
        {
          kINTERRUPT_TYPE_INT = 0,
          kINTERRUPT_TYPE_NMI = 1,
          kINTERRUPT_TYPE_SMI = 2,
          kINTERRUPT_EXT_INT = 3
        };

        enum Polarity
        {
          kPOLARITY_BUS_SPEC = 0,
          kPOLARITY_ACTIVE_HIGH = 1,
          kPOLARITY_ACTIVE_LOW = 3
        };

        enum TriggerMode
        {
          kTRIGGER_MODE_BUS_SPEC = 0,
          kTRIGGER_EDGE_TRIGGERED = 1,
          kTRIGGER_LEVEL_TRIGGERED = 3
        };

      public:
        InterruptType
        interruptType() const
        {
          return static_cast<InterruptType>(m_type&0xff);
        }

        Polarity
        polarity() const
        {
          return static_cast<Polarity>(m_polarity&0xff);
        }

        TriggerMode
        triggerMode() const
        {
          return static_cast<TriggerMode>(m_triggerMode&0xff);
        }

        int
        sourceBusId()
        { return m_sourceBus & 0xff; }

        int
        sourceBusIrq()
        { return m_sourceBusIrq & 0xff; }

        int
        destinationApicId()
        { return m_destinationApicId & 0xff; }

        int
        destinationApicInt()
        { return m_destinationApicInt & 0xff; }

      private:
        u08 m_type;
        u08 m_polarity:2;
        u08 m_triggerMode:2;
        u08 m_reserved;
        u08 m_sourceBus;
        u08 m_sourceBusIrq;
        u08 m_destinationApicId;
        u08 m_destinationApicInt;
      } ZYGOMA_PACKED;

      // Plenty more, folks...

    } // namespace MPS
  } // namespace ia32
} // namespace Zygoma

#endif // ZYGOMA_IA32_MPS_H_ 

---