Cpu.hpp

Go to the documentation of this file.

/*
 * These codes are licensed under CC0.
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
#ifndef __NODAMUSHI_SVD_NORMALIZED_CPU_HPP__
#define __NODAMUSHI_SVD_NORMALIZED_CPU_HPP__

# include <cstdint>
# include "nodamushi/svd/Endian.hpp"
# include "nodamushi/svd/SAURegionConfigProtect.hpp"
# include "nodamushi/svd/ARMCPU.hpp"
# include "nodamushi/svd/normalized/node_container.hpp"

namespace nodamushi{
namespace svd{
namespace normalized{


template<typename STRREF>struct SAURegionsConfigRegion
{
  bool enabled;
  STRREF name;
  uint64_t base;
  uint64_t limit;
  SAURegionConfigProtect access;

  template<typename T>  SAURegionsConfigRegion(const T& s)
      :enabled(s.enabled.get(true)),
       name(s.name.get("")),
       base(s.base.get(0)),
       limit(s.limit.get(0)),
       access(s.access.get(SAURegionConfigProtect{}))
  {}
};

template<typename STRREF>struct SAURegionsConfig
{
  bool enabled;
  SAURegionConfigProtect protectionWhenDisabled;
  std::vector<SAURegionsConfigRegion<STRREF>> region;
  
  SAURegionsConfig():
      enabled(false),
      protectionWhenDisabled(SAURegionConfigProtect{}),
      region{}
  {}
  
 private:
  template<typename X>friend class Cpu;
  template<typename V> void init(const V& v){
    if(v){
      enabled = v->enabled.get(true);
      protectionWhenDisabled=
          v->protectionWhenDisabled.get(SAURegionConfigProtect{});
      region.reserve(v->region.size());
      for(const auto& ss:v->region)
        region.emplace_back(ss);
    }
  }

};

template<typename STRREF>struct Cpu
{
  STRREF name; 
  STRREF revision;
  Endian endian;
  bool mpuPresent;
  bool fpuPresent;
  bool fpuDP;
  bool dspPresent;
  bool icachePresent;
  bool dcachePresent;
  bool itcmPresent;
  bool dtcmPresent;
  bool vtorPresent;
  uint32_t nvicPrioBits;
  bool vendorSystickConfig;
  uint32_t deviceNumInterrupts;
  uint32_t sauNumRegions;
  SAURegionsConfig<STRREF> sauRegionsConfig;

  ARMCPU get_armcpu()const noexcept{return ::nodamushi::svd::get_cpu_type(name);}
  
  template<typename V>//V = value
  Cpu(const V& v):
      name(""),
      revision(""),
      endian(static_cast<Endian>(0)),
      mpuPresent(false),
      fpuPresent(false),
      fpuDP(false),
      dspPresent(false),
      icachePresent(false),
      dcachePresent(false),
      itcmPresent(false),
      dtcmPresent(false),
      nvicPrioBits(0),
      vendorSystickConfig(false),
      deviceNumInterrupts(0),
      sauNumRegions(0),
      sauRegionsConfig()
  {
    if(v){
      name = v->name.get("");
      revision = v->revision.get("");
      endian = v->endian.get(static_cast<Endian>(0));
      mpuPresent = v->mpuPresent.get(false);
      fpuPresent = v->fpuPresent.get(false);
      fpuDP = v->fpuDP.get(false);
      dspPresent = v->dspPresent.get(false);
      icachePresent = v->icachePresent.get(false);
      dcachePresent = v->dcachePresent.get(false);
      itcmPresent = v->itcmPresent.get(false);
      dtcmPresent = v->dtcmPresent.get(false);
      nvicPrioBits = v->nvicPrioBits.get(0);
      vendorSystickConfig = v->vendorSystickConfig.get(false);
      deviceNumInterrupts = v->deviceNumInterrupts.get(0);
      sauNumRegions = v->sauNumRegions.get(0);
      sauRegionsConfig.init(v->sauRegionsConfig);
    }
  }
};



}}} // end namespace svd

#endif // __NODAMUSHI_SVD_NORMALIZED_CPU_HPP__