factory.cpp

Go to the documentation of this file.

 
#include <block/cblock.h>
#include <block/ctrlblock.h>
#include <block/iblock.h>
#include <block/mblock.h>
#include <block/ublock.h>
#include <bus/bus.h>
#include <entity/base.h>
 
#include "teensy/cblock.h"
#include "teensy/ctrlblock.h"
#include "teensy/iblock.h"
#include "teensy/mblock_int.h"
#include "teensy/mblock_mul.h"
#include "teensy/shblock.h"
#include "teensy/ublock.h"
 
FLASHMEM
blocks::CBlock *blocks::CBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                       const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != TYPE)
    return nullptr;
 
  if (classifier.version < entities::Version(1, 0))
    return nullptr;
  if (classifier.version < entities::Version(1, 1))
    return new CBlock(new CBlockHAL_V_1_0_X(block_address));
  if (classifier.version < entities::Version(1, 2))
    return new CBlock(new CBlockHAL_V_1_1_X(block_address));
 
  // Any unknown versuin results in a nullptr here.
  return nullptr;
}
 
FLASHMEM blocks::CTRLBlock *blocks::CTRLBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                                      bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != TYPE)
    return nullptr;
 
  // Currently, there are no variants.
  // TODO: After adapting classifier to (major, minor, patch) version,
  //       fail on v1.0.1, which has missing hardware components and should not be used.
  return new CTRLBlock(new CTRLBlockHAL_V_1_0_2(block_address));
}
 
FLASHMEM blocks::IBlock *blocks::IBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                                bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_)
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  if (classifier.version < entities::Version(1, 2))
    return nullptr;
  if (classifier.version < entities::Version(1, 3))
    return new IBlock(new IBlockHAL_V_1_2_X(block_address));
  return nullptr;
}
 
FLASHMEM
blocks::MBlock *blocks::MBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                       const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != entities::EntityClass::M_BLOCK)
    return nullptr;
 
  auto type = classifier.type_as<TYPES>();
  switch (type) {
  case TYPES::UNKNOWN:
    // This is already checked by !classifier above
    return nullptr;
  case TYPES::M_MUL4_BLOCK:
    return MMulBlock::from_entity_classifier(classifier, block_address);
  case TYPES::M_INT8_BLOCK:
    return MIntBlock::from_entity_classifier(classifier, block_address);
  }
  // Any unknown value results in a nullptr here.
  // Adding default case to switch suppresses warnings about missing cases.
  return nullptr;
}
 
FLASHMEM blocks::MIntBlock *blocks::MIntBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                                      const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != static_cast<uint8_t>(TYPE))
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  SLOT slot = block_address % 8 == 4 ? SLOT::M0 : SLOT::M1;
  if (classifier.version < entities::Version(1))
    return nullptr;
  if (classifier.version < entities::Version(1, 1))
    return new MIntBlock(slot, new MIntBlockHAL_V_1_0_X(block_address));
  if (classifier.version < entities::Version(1, 2))
    return new MIntBlock(slot, new MIntBlockHAL_V_1_1_X(block_address));
  return nullptr;
}
 
FLASHMEM blocks::MMulBlock *blocks::MMulBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                                      const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != static_cast<uint8_t>(TYPE))
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  SLOT slot = block_address % 8 == 4 ? SLOT::M0 : SLOT::M1;
  // Return default implementation
  if (classifier.version < entities::Version(1))
    return nullptr;
  if (classifier.version < entities::Version(1, 1))
    return new MMulBlock(slot, new MMulBlockHAL_V_1_0_X(block_address));
  if (classifier.version == entities::Version(1, -1))
    return new MMulBlock_FullAutoCalibration(slot, new MMulBlockHAL_V_1_M1_X(block_address));
  return nullptr;
}
 
FLASHMEM
blocks::SHBlock *blocks::SHBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                         bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_)
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  // TODO fix versions of new sh hal class
  if (classifier.version < entities::Version(0, 1))
    return nullptr;
  if (classifier.version < entities::Version(0, 2))
    return new SHBlock(new SHBlockHAL_V_1_0_X(block_address));
  return nullptr;
}
 
FLASHMEM
blocks::UBlock *blocks::UBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                       bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != TYPE)
    return nullptr;
 
  if (classifier.version < entities::Version(1, 2))
    return nullptr;
  if (classifier.version < entities::Version(1, 3))
    return new UBlock(new UBlockHAL_V_1_2_X(block_address));
  return nullptr;
}