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);
}
 
static inline ErrorCode MapHalStartFailure(const I2C_HandleTypeDef* hi2c,
                                           HAL_StatusTypeDef st)
{
  // Preserve HAL's immediate start-failure signal without forcing a full controller
  // reset.
#ifdef HAL_I2C_ERROR_NONE
  const uint32_t err = hi2c->ErrorCode;
#ifdef HAL_I2C_WRONG_START
  if ((err & (HAL_I2C_ERROR_TIMEOUT | HAL_I2C_WRONG_START)) != 0U)
#else
  if ((err & HAL_I2C_ERROR_TIMEOUT) != 0U)
#endif
  {
    return ErrorCode::TIMEOUT;
  }
  if (err != HAL_I2C_ERROR_NONE)
  {
    return ErrorCode::FAILED;
  }
#else
  UNUSED(hi2c);
#endif
  return (st == HAL_BUSY) ? ErrorCode::BUSY : ErrorCode::FAILED;
}
 
static void RecoverAfterBlockTimeout(STM32I2C* i2c)
{
  ASSERT(i2c != nullptr);
 
  auto* hi2c = i2c->i2c_handle_;
  i2c->recovering_ = true;
  if (hi2c->hdmarx != nullptr)
  {
    (void)HAL_DMA_Abort(hi2c->hdmarx);
  }
  if (hi2c->hdmatx != nullptr)
  {
    (void)HAL_DMA_Abort(hi2c->hdmatx);
  }
 
  // Re-open the HAL handle after a detached BLOCK timeout without touching
  // the larger software-side callback/semaphore semantics.
  (void)HAL_I2C_DeInit(hi2c);
  (void)HAL_I2C_Init(hi2c);
 
  i2c->read_ = false;
  i2c->read_op_ = {};
  i2c->write_op_ = {};
  i2c->read_buff_ = {nullptr, 0};
  i2c->recovering_ = false;
}
 
static inline ErrorCode WaitBlockResultAndRecoverTimeout(STM32I2C* i2c, uint32_t timeout)
{
  ASSERT(i2c != nullptr);
  const ErrorCode ans = i2c->block_wait_.Wait(timeout);
  if (ans == ErrorCode::TIMEOUT)
  {
    RecoverAfterBlockTimeout(i2c);
  }
  return ans;
}
 
}  // 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;
    read_buff_ = read_data;
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      // Arm the BLOCK waiter before HAL exposes completion to IRQ context.
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const HAL_StatusTypeDef st = HAL_I2C_Master_Receive_DMA(
        i2c_handle_, dev_addr, reinterpret_cast<uint8_t*>(dma_buff_.addr_),
        read_data.size_);
    if (st != HAL_OK)
    {
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
        return MapHalStartFailure(i2c_handle_, st);
      }
      return ErrorCode::BUSY;
    }
    op.MarkAsRunning();
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return WaitBlockResultAndRecoverTimeout(this, 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.
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ans);
    }
    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 (op.type == WriteOperation::OperationType::BLOCK)
    {
      // Arm the BLOCK waiter before HAL exposes completion to IRQ context.
      block_wait_.Start(*op.data.sem_info.sem);
    }
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(dma_buff_.addr_),
                            write_data.size_);
#endif
    const HAL_StatusTypeDef st = HAL_I2C_Master_Transmit_DMA(
        i2c_handle_, dev_addr, reinterpret_cast<uint8_t*>(dma_buff_.addr_),
        write_data.size_);
    if (st != HAL_OK)
    {
      if (op.type == WriteOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
        return MapHalStartFailure(i2c_handle_, st);
      }
      return ErrorCode::BUSY;
    }
    op.MarkAsRunning();
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return WaitBlockResultAndRecoverTimeout(this, 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;
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ans);
    }
    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;
    read_buff_ = read_data;
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      // Arm the BLOCK waiter before HAL exposes completion to IRQ context.
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const HAL_StatusTypeDef st = 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_);
    if (st != HAL_OK)
    {
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
        return MapHalStartFailure(i2c_handle_, st);
      }
      return ErrorCode::BUSY;
    }
    op.MarkAsRunning();
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      return WaitBlockResultAndRecoverTimeout(this, 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;
 
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ans);
    }
    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 (op.type == WriteOperation::OperationType::BLOCK)
    {
      // Arm the BLOCK waiter before HAL exposes completion to IRQ context.
      block_wait_.Start(*op.data.sem_info.sem);
    }
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_CleanDCache_by_Addr(reinterpret_cast<uint32_t*>(dma_buff_.addr_),
                            write_data.size_);
#endif
    const HAL_StatusTypeDef st = 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_);
    if (st != HAL_OK)
    {
      if (op.type == WriteOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
        return MapHalStartFailure(i2c_handle_, st);
      }
      return ErrorCode::BUSY;
    }
    op.MarkAsRunning();
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      return WaitBlockResultAndRecoverTimeout(this, 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;
 
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ans);
    }
    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 && !i2c->recovering_ &&
      (i2c->read_op_.type != ReadOperation::OperationType::NONE))
  {
    ErrorCode ec = ErrorCode::OK;
#ifdef HAL_I2C_ERROR_NONE
    ec = (hi2c->ErrorCode == HAL_I2C_ERROR_NONE) ? ErrorCode::OK : ErrorCode::FAILED;
#endif
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_InvalidateDCache_by_Addr(i2c->dma_buff_.addr_, i2c->read_buff_.size_);
#endif
    if (ec == ErrorCode::OK)
    {
      Memory::FastCopy(i2c->read_buff_.addr_, i2c->dma_buff_.addr_,
                       i2c->read_buff_.size_);
    }
    if (i2c->read_op_.type == ReadOperation::OperationType::BLOCK)
    {
      (void)i2c->block_wait_.TryPost(true, ec);
    }
    else
    {
      i2c->read_op_.UpdateStatus(true, ec);
    }
  }
}
 
extern "C" void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c && !i2c->recovering_ &&
      (i2c->write_op_.type != WriteOperation::OperationType::NONE))
  {
    ErrorCode ec = ErrorCode::OK;
#ifdef HAL_I2C_ERROR_NONE
    ec = (hi2c->ErrorCode == HAL_I2C_ERROR_NONE) ? ErrorCode::OK : ErrorCode::FAILED;
#endif
    if (i2c->write_op_.type == WriteOperation::OperationType::BLOCK)
    {
      (void)i2c->block_wait_.TryPost(true, ec);
    }
    else
    {
      i2c->write_op_.UpdateStatus(true, ec);
    }
  }
}
 
extern "C" void HAL_I2C_MemTxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c && !i2c->recovering_ &&
      (i2c->write_op_.type != WriteOperation::OperationType::NONE))
  {
    ErrorCode ec = ErrorCode::OK;
#ifdef HAL_I2C_ERROR_NONE
    ec = (hi2c->ErrorCode == HAL_I2C_ERROR_NONE) ? ErrorCode::OK : ErrorCode::FAILED;
#endif
    if (i2c->write_op_.type == WriteOperation::OperationType::BLOCK)
    {
      (void)i2c->block_wait_.TryPost(true, ec);
    }
    else
    {
      i2c->write_op_.UpdateStatus(true, ec);
    }
  }
}
 
extern "C" void HAL_I2C_MemRxCpltCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
  if (i2c && !i2c->recovering_ &&
      (i2c->read_op_.type != ReadOperation::OperationType::NONE))
  {
    ErrorCode ec = ErrorCode::OK;
#ifdef HAL_I2C_ERROR_NONE
    ec = (hi2c->ErrorCode == HAL_I2C_ERROR_NONE) ? ErrorCode::OK : ErrorCode::FAILED;
#endif
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
    SCB_InvalidateDCache_by_Addr(i2c->dma_buff_.addr_, i2c->read_buff_.size_);
#endif
    if (ec == ErrorCode::OK)
    {
      Memory::FastCopy(i2c->read_buff_.addr_, i2c->dma_buff_.addr_,
                       i2c->read_buff_.size_);
    }
    if (i2c->read_op_.type == ReadOperation::OperationType::BLOCK)
    {
      (void)i2c->block_wait_.TryPost(true, ec);
    }
    else
    {
      i2c->read_op_.UpdateStatus(true, ec);
    }
  }
}
 
extern "C" void HAL_I2C_ErrorCallback(I2C_HandleTypeDef* hi2c)
{
  STM32I2C* i2c = STM32I2C::map[STM32_I2C_GetID(hi2c->Instance)];
 
  if (i2c && !i2c->recovering_)
  {
    if (i2c->read_)
    {
      if (i2c->read_op_.type == ReadOperation::OperationType::BLOCK)
      {
        (void)i2c->block_wait_.TryPost(true, ErrorCode::FAILED);
      }
      else
      {
        i2c->read_op_.UpdateStatus(true, ErrorCode::FAILED);
      }
    }
    else
    {
      if (i2c->write_op_.type == WriteOperation::OperationType::BLOCK)
      {
        (void)i2c->block_wait_.TryPost(true, ErrorCode::FAILED);
      }
      else
      {
        i2c->write_op_.UpdateStatus(true, ErrorCode::FAILED);
      }
    }
  }
}
 
#endif