HWDriverMap.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HWDRIVERMAP_H_
#define INCLUDE_HWDRIVERMAP_H_
 
 
#include "drivers/IDriver.h"
#include "drivers/IDriver_vtbl.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define HDM_NULL_KEY    (0U)  
#define HDME_IS_EMPTY(p_element)  (((p_element)->value.p_driver_obj == NULL) && ((p_element)->key == HDM_NULL_KEY))
 
 
typedef struct _HWDriverMapValue
{
  IDriver *p_driver_obj;
 
  void *p_static_param;
} HWDriverMapValue_t;
 
typedef struct _HWDriverMapElement
{
  uint32_t key;
 
  HWDriverMapValue_t value;
 
} HWDriverMapElement_t;
 
typedef struct _HWDriverMap
{
  HWDriverMapElement_t *p_elements;
 
  uint16_t size;
 
  uint16_t element_count;
} HWDriverMap_t;
 
static inline
sys_error_code_t HWDriverMap_Init(HWDriverMap_t *_this, HWDriverMapElement_t *p_elements, uint16_t size)
{
  assert_param(_this != NULL);
  assert_param(p_elements != NULL);
  uint32_t i = 0U;
 
  _this->p_elements = p_elements;
  _this->size = size;
  _this->element_count = 0;
 
  /* initialize all elements to NULL */
  for(i = 0; i < size; i++)
  {
    p_elements[i].key = HDM_NULL_KEY;
    p_elements[i].value.p_driver_obj = NULL;
    p_elements[i].value.p_static_param = NULL;
  }
 
  return SYS_NO_ERROR_CODE;
}
 
static inline
HWDriverMapValue_t *HWDriverMap_FindByKey(HWDriverMap_t *_this, uint32_t key)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
 
  while(_this->p_elements[i].key != key)
  {
    i++;
    if(i >= _this->size)
    {
      return NULL;
    }
  }
  return &_this->p_elements[i].value;
}
 
static inline
HWDriverMapElement_t *HWDriverMap_AddElement(HWDriverMap_t *_this, uint32_t key, IDriver *p_instance)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
  HWDriverMapElement_t *p_free_element = NULL;
 
  while((_this->p_elements[i].key != key) && (i < _this->size))
  {
    if ((p_free_element == NULL) && HDME_IS_EMPTY(&_this->p_elements[i]))
    {
      /* we found a free element in the map.*/
      p_free_element = &_this->p_elements[i];
    }
 
    i++;
  }
 
  if (i < _this->size)
  {
    /* the key is already present in the map*/
    if (_this->p_elements[i].value.p_driver_obj == p_instance)
    {
      /* the element is present in the map, so we return it.*/
      p_free_element = &_this->p_elements[i];
    }
    else
    {
      /* the key is already present in the map, but it is mapped to a different IDriver instance, so we cannot add the new element.*/
      p_free_element = NULL;
    }
  }
  else
  {
    /* the key is not present in the map, so we try to add the new element*/
    if (p_free_element != NULL)
    {
      /* add the new element in the free position*/
      p_free_element->key = key;
      p_free_element->value.p_driver_obj = p_instance;
      _this->element_count++;
    }
  }
 
  return p_free_element;
}
 
static inline
bool HWDriverMap_RemoveElement(HWDriverMap_t *_this, uint32_t key)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
  bool res = true;
 
  while(res && (_this->p_elements[i].key != key))
  {
    if(++i >= _this->size)
    {
      res = false;
    }
  }
 
  if (res)
  {
    _this->p_elements[i].key = HDM_NULL_KEY;
    _this->p_elements[i].value.p_driver_obj = NULL;
    _this->p_elements[i].value.p_static_param = NULL;
    _this->element_count--;
  }
 
  return res;
}
 
static inline
bool HWDriverMap_IsInitialized(HWDriverMap_t *_this)
{
  assert_param(_this != NULL);
 
  return _this->size != 0;
}
 
static inline
bool HWDriverMap_GetElementCount(const HWDriverMap_t * const _this)
{
  assert_param(_this != NULL);
 
  return _this->element_count;
}
 
 
/* HWDriverMapValue public API */
/*******************************/
 
static inline
void HWDriverMapValue_SetStaticParam(HWDriverMapValue_t *_this, void *p_static_param)
{
  assert_param(_this != NULL);
 
  _this->p_static_param = p_static_param;
}
 
static inline
void* HWDriverMapValue_GetStaticParam(const HWDriverMapValue_t * const _this)
{
  assert_param(_this != NULL);
 
  return _this->p_static_param;
}
 
 
/* Utility functions */
/*********************/
 
static inline
uint32_t HWDriverMap_GetKeyForGPIO(GPIO_TypeDef *p_port, uint32_t pin)
{
  uint32_t port = (uint32_t)p_port;
  uint32_t position = 0U;
  uint32_t key = HDM_NULL_KEY;
 
  /*find the pin position*/
  uint32_t iocurrent = 0U;
  while ((iocurrent == 0U) && (position < 16))
  {
    iocurrent = (pin) & (1UL << position++);
  }
 
  if (iocurrent != 0)
  {
    key = port + position;
  }
 
  return key;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* INCLUDE_HWDRIVERMAP_H_ */