acpi.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_ACPI_H_ 
#define ZYGOMA_IA32_ACPI_H_ 

#include <config.h>
#include <iterator>
#include <types.h>

namespace Zygoma
{
  namespace ia32
  {
    namespace Acpi
    {
      class RootSystemDescriptionTable;

      class RootSystemDescriptionPointer
      {
      public:
        static const RootSystemDescriptionPointer*
        locateRSDT();

        RootSystemDescriptionTable*
        rsdtAddress() const
        { return reinterpret_cast<RootSystemDescriptionTable*>(m_rsdtAddress); }

        static const int kSIGNATURE_LENGTH = 8;
        static const u08 kSIGNATURE[kSIGNATURE_LENGTH];

      public:
        u08 m_signature[kSIGNATURE_LENGTH];
        u08 m_checksum;
        u08 m_oemId[6];
        u08 m_revision;
        u32 m_rsdtAddress;
        u08 m_length[4];
        u08 m_xsdtAddress[8];
        u08 m_extendedChecksum;
        u08 m_reserved[3];
      } ZYGOMA_PACKED;


      struct SystemDescriptionTableHeader
      {
        static const int kSIGNATURE_LENGTH = 4;

        u08 m_signature[kSIGNATURE_LENGTH];
        u32 m_length;
        u08 m_revision;
        u08 m_checksum;
        u08 m_oemId[6];
        u08 m_oemTableId[8];
        u32 m_oemRevision;
        u32 m_creatorId;
        u32 m_creatorRevision;
      } ZYGOMA_PACKED;


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

        reference
        operator*() const;

        pointer
        operator->() const;

        ConfigTableIterator&
        operator++();

        ConfigTableIterator&
        operator++(int);

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

      private:
        SystemDescriptionTableHeader** m_curEntry;
      };


      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 RootSystemDescriptionTable : public SystemDescriptionTableHeader {
        static const u08 kSIGNATURE[kSIGNATURE_LENGTH];

      public:
        typedef SystemDescriptionTableHeader*        value_type;
        typedef SystemDescriptionTableHeader**       pointer;
        typedef SystemDescriptionTableHeader*&       reference;
        typedef const SystemDescriptionTableHeader*& const_reference;
        typedef ConfigTableIterator                  iterator;
        typedef std::ptrdiff_t                       difference_type;
        typedef std::size_t                          size_type;

      public:
        iterator
        begin()
        { return iterator(reinterpret_cast<pointer>(&m_entry[0])); }

        iterator
        end()
        { return iterator(reinterpret_cast<pointer>(&m_entry[size()])); }

        size_type
        size() const
        {
          return (m_length - sizeof(SystemDescriptionTableHeader))
                  / sizeof(value_type);
        }

        bool
        empty() const
        { return size() == 0; }

      private:
        u32 m_entry[1];
      } ZYGOMA_PACKED;

      class DifferentiatedSystemDescriptionTable;


      class FixedAcpiDescriptionTable
      : public SystemDescriptionTableHeader
      {
      public:
        u32 m_firmwareControl;
        u32 m_dsdt;
        u08 m_reserved1;
        u08 m_preferredPowerProfile;
        u16 m_sciInterrupt;
        u32 m_smiCommand;
        u08 m_acpiEnable;
        u08 m_acpiDisable;
        u08 m_s4biosRequest;
        u08 m_pstateControl;
        u32 m_PM1aEventBlock;
        u32 m_PM1bEventBlock;
        u32 m_PM1aControlBlock;
        u32 m_PM1bControlBlock;
        u32 m_PM2ControlBlock;
        u32 m_PMTimerBlock;
        u32 m_GPE0Block;
        u32 m_GPE1Block;
        u08 m_pm1EventLength;
        u08 m_pm1CountLength;
        u08 m_pm2CountLength;
        u08 m_pmTimerLength;
        u08 m_GPE0BlockLength;
        u08 m_GPE1BlockLength;
        u08 m_GPE1BaseOffset;
        u08 m_CstCnt;
        u16 m_level2Latency;
        u16 m_level3Latency;
        u16 m_flushSize;
        u16 m_flushStride;
        u08 m_dutyOffset;
        u08 m_dutyWidth;
        u08 m_dayAlarm;
        u08 m_monthAlarm;
        u08 m_century;
        u16 m_hasLegacyDevices:1;
        u16 m_has842keyboard:1;
        u16 m_reserved110:14;
        u08 m_reserved111;
        u32 m_flags;
        u08 m_resetRegister[12];
        u08 m_resetValue;
        u08 m_reserved129[3];
        u08 m_xFirmwareControl[8];
        u08 m_xDsdt[8];
        u08 m_xPM1aEventBlock[12];
        u08 m_xPM1bEventBlock[12];
        u08 m_xPM1aControlBlock[12];
        u08 m_xPM1bControlBlock[12];
        u08 m_xPM2ControlBlock[12];
        u08 m_xPMTimerBlock[12];
        u08 m_xGPE0Block[12];
        u08 m_xGPE1Block[12];
      } ZYGOMA_PACKED;


      class DifferentiatedSystemDescriptionTable
      : public SystemDescriptionTableHeader
      {
      public:
        typedef u08            value_type;
        typedef u08*           pointer;
        typedef u08&           reference;
        typedef const u08&     const_reference;
        typedef u08*           iterator;
        typedef std::ptrdiff_t difference_type;
        typedef std::size_t    size_type;

      public:
        iterator
        begin()
        { return m_aml; }

        iterator
        end()
        { return m_aml + size(); }

        size_type
        size() const
        {
          return m_length - sizeof(SystemDescriptionTableHeader);
        }

        bool
        empty() const
        { return size() == 0; }

      private:
        value_type m_aml[1];
      } ZYGOMA_PACKED;


    } // namespace Acpi
  } // namespace ia32
} // namespace Zygoma

#endif // ZYGOMA_IA32_ACPI_H

---