stm32_i2c.cpp

#include "stm32_i2c.hpp"
 
#ifdef HAL_I2C_MODULE_ENABLED
 
using namespace LibXR;
 
STM32I2C* STM32I2C::map[STM32_I2C_NUMBER] = {nullptr};
 
stm32_i2c_id_t STM32_I2C_GetID(I2C_TypeDef* hi2c)
{  // NOLINT
  if (hi2c == nullptr)
  {
    return stm32_i2c_id_t::STM32_I2C_ID_ERROR;
  }
#ifdef I2C1
  else if (hi2c == I2C1)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C1;
  }
#endif
#ifdef I2C2
  else if (hi2c == I2C2)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C2;
  }
#endif
#ifdef I2C3
  else if (hi2c == I2C3)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C3;
  }
#endif
#ifdef I2C4
  else if (hi2c == I2C4)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C4;
  }
#endif
#ifdef I2C5
  else if (hi2c == I2C5)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C5;
  }
#endif
#ifdef I2C6
  else if (hi2c == I2C6)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C6;
  }
#endif
#ifdef I2C7
  else if (hi2c == I2C7)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C7;
  }
#endif
#ifdef I2C8
  else if (hi2c == I2C8)
  {  // NOLINT
    return stm32_i2c_id_t::STM32_I2C8;
  }
#endif
  return stm32_i2c_id_t::STM32_I2C_ID_ERROR;
}
 
namespace
{
 
// 统一输入：
// - 7-bit 模式：传 0x00~0x7F（不带 R/W 位），内部左移 1 给 HAL
// - 10-bit 模式：传 0x000~0x3FF（不带 R/W 位），内部直接给 HAL
static inline uint16_t EncodeHalDevAddress(const I2C_HandleTypeDef* hi2c,
                                           uint16_t slave_addr)
{
  ASSERT(hi2c != nullptr);
 
#if defined(I2C_ADDRESSINGMODE_10BIT)
  if (hi2c->Init.AddressingMode == I2C_ADDRESSINGMODE_10BIT)
  {
    ASSERT(slave_addr <= 0x03FF);
    return static_cast<uint16_t>(slave_addr & 0x03FF);
  }
#endif
 
  // 默认按 7-bit
  ASSERT(slave_addr <= 0x007F);
  return static_cast<uint16_t>((slave_addr & 0x007F) << 1);
}
 
}  // namespace
 
STM32I2C::STM32I2C(I2C_HandleTypeDef* hi2c, RawData dma_buff,
                   uint32_t dma_enable_min_size)
    : I2C(),
      id_(STM32_I2C_GetID(hi2c->Instance)),
      i2c_handle_(hi2c),
      dma_enable_min_size_(dma_enable_min_size),
      dma_buff_(dma_buff)
{
  map[id_] = this;
}
 
ErrorCode STM32I2C::Read(uint16_t slave_addr, RawData read_data, ReadOperation& op,
                         bool in_isr)
{
  if (i2c_handle_->State != HAL_I2C_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  read_ = true;
 
  const uint16_t dev_addr = EncodeHalDevAddress(i2c_handle_, slave_addr);
 
  if (read_data.size_ > dma_enable_min_size_)
  {
    read_op_ = op;
    HAL_I2C_Master_Receive_DMA(i2c_handle_, dev_addr,
                               reinterpret_cast<uint8_t*>(dma_buff_.addr_),
                               read_data.size_);
    read_buff_ = read_data;
    op.MarkAsRunning();
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    auto ans = HAL_I2C_Master_Receive(i2c_handle_, dev_addr,
                                      reinterpret_cast<uint8_t*>(read_data.addr_),
                                      read_data.size_, 20) == HAL_OK
                   ? ErrorCode::OK
                   : ErrorCode::BUSY;
    // BLOCK 模式下沿用统一状态更新路径。
    // Reuse the same status update path for BLOCK mode.
    op.UpdateStatus(in_isr, ans);
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ans;
  }
}
 
ErrorCode STM32I2C::Write(uint16_t slave_addr, ConstRawData write_data,
                          WriteOperation& op, bool in_isr)
{
  if (i2c_handle_->State != HAL_I2C_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  read_ = false;
 
  const uint16_t dev_addr = EncodeHalDevAddress(i2c_handle_, slave_addr);
 
  Memory::FastCopy(dma_buff_.addr_, write_data.addr_, write_data.size_);
 
  if (write_data.size_ > dma_enable_min_size_)
  {
    write_op_ = op;
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(dma_buff_.addr_),
                            write_data.size_);
#endif
    HAL_I2C_Master_Transmit_DMA(i2c_handle_, dev_addr,
                                reinterpret_cast<uint8_t*>(dma_buff_.addr_),
                                write_data.size_);
    op.MarkAsRunning();
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    auto ans = HAL_I2C_Master_Transmit(i2c_handle_, dev_addr,
                                       reinterpret_cast<uint8_t*>(dma_buff_.addr_),
                                       write_data.size_, 20) == HAL_OK
                   ? ErrorCode::OK
                   : ErrorCode::BUSY;
    op.UpdateStatus(in_isr, ans);
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ans;
  }
}
 
ErrorCode STM32I2C::MemRead(uint16_t slave_addr, uint16_t mem_addr, RawData read_data,
                            ReadOperation& op, MemAddrLength mem_addr_size, bool in_isr)
{
  ASSERT(read_data.size_ <= dma_buff_.size_);
 
  if (i2c_handle_->State != HAL_I2C_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  read_ = true;
 
  const uint16_t dev_addr = EncodeHalDevAddress(i2c_handle_, slave_addr);
 
  if (read_data.size_ > dma_enable_min_size_)
  {
    read_op_ = op;
    HAL_I2C_Mem_Read_DMA(i2c_handle_, dev_addr, mem_addr,
                         mem_addr_size == MemAddrLength::BYTE_8 ? I2C_MEMADD_SIZE_8BIT
                                                                : I2C_MEMADD_SIZE_16BIT,
                         reinterpret_cast<uint8_t*>(dma_buff_.addr_), read_data.size_);
    read_buff_ = read_data;
    op.MarkAsRunning();
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    auto ans =
        HAL_I2C_Mem_Read(i2c_handle_, dev_addr, mem_addr,
                         mem_addr_size == MemAddrLength::BYTE_8 ? I2C_MEMADD_SIZE_8BIT
                                                                : I2C_MEMADD_SIZE_16BIT,
                         reinterpret_cast<uint8_t*>(read_data.addr_), read_data.size_,
                         20) == HAL_OK
            ? ErrorCode::OK
            : ErrorCode::BUSY;
 
    op.UpdateStatus(in_isr, ans);
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ans;
  }
}
 
ErrorCode STM32I2C::MemWrite(uint16_t slave_addr, uint16_t mem_addr,
                             ConstRawData write_data, WriteOperation& op,
                             MemAddrLength mem_addr_size, bool in_isr)
{
  ASSERT(write_data.size_ <= dma_buff_.size_);
 
  if (i2c_handle_->State != HAL_I2C_STATE_READY)
  {
    return ErrorCode::BUSY;
  }
 
  read_ = false;
 
  const uint16_t dev_addr = EncodeHalDevAddress(i2c_handle_, slave_addr);
 
  Memory::FastCopy(dma_buff_.addr_, write_data.addr_, write_data.size_);
 
  if (write_data.size_ > dma_enable_min_size_)
  {
    write_op_ = op;
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(dma_buff_.addr_),
                            write_data.size_);
#endif
    HAL_I2C_Mem_Write_DMA(i2c_handle_, dev_addr, mem_addr,
                          mem_addr_size == MemAddrLength::BYTE_8 ? I2C_MEMADD_SIZE_8BIT
                                                                 : I2C_MEMADD_SIZE_16BIT,
                          reinterpret_cast<uint8_t*>(dma_buff_.addr_), write_data.size_);
    op.MarkAsRunning();
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
  else
  {
    auto ans =
        HAL_I2C_Mem_Write(i2c_handle_, dev_addr, mem_addr,
                          mem_addr_size == MemAddrLength::BYTE_8 ? I2C_MEMADD_SIZE_8BIT
                                                                 : I2C_MEMADD_SIZE_16BIT,
                          reinterpret_cast<uint8_t*>(dma_buff_.addr_), write_data.size_,
                          20) == HAL_OK
            ? ErrorCode::OK
            : ErrorCode::BUSY;
 
    op.UpdateStatus(in_isr, ans);
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
    }
    return ans;
  }
}
 
ErrorCode STM32I2C::SetConfig(Configuration config)
{
  if (HasClockSpeed<decltype(i2c_handle_)>::value)
  {
    SetClockSpeed<decltype(i2c_handle_)>(i2c_handle_, config);
  }
  else
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  if (HAL_I2C_Init(i2c_handle_) != HAL_OK)
  {
    return ErrorCode::INIT_ERR;
  }
  return ErrorCode::OK;
}
 
extern "C" void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c)
  {
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_InvalidateDCache_by_Addr(i2c->dma_buff_.addr_, i2c->read_buff_.size_);
#endif
    Memory::FastCopy(i2c->read_buff_.addr_, i2c->dma_buff_.addr_, i2c->read_buff_.size_);
    i2c->read_op_.UpdateStatus(true, ErrorCode::OK);
  }
}
 
extern "C" void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c)
  {
    i2c->write_op_.UpdateStatus(true, ErrorCode::OK);
  }
}
 
extern "C" void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c)
  {
    i2c->write_op_.UpdateStatus(true, ErrorCode::OK);
  }
}
 
extern "C" void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c)
  {
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_InvalidateDCache_by_Addr(i2c->dma_buff_.addr_, i2c->read_buff_.size_);
#endif
    Memory::FastCopy(i2c->read_buff_.addr_, i2c->dma_buff_.addr_, i2c->read_buff_.size_);
    i2c->read_op_.UpdateStatus(true, ErrorCode::OK);
  }
}
 
extern "C" void HAL_I2C_ErrorCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
 
  if (i2c)
  {
    if (i2c->read_)
    {
      i2c->read_op_.UpdateStatus(true, ErrorCode::FAILED);
    }
    else
    {
      i2c->write_op_.UpdateStatus(true, ErrorCode::FAILED);
    }
  }
}
 
#endif