LibXR::MSPM0SPI Class Reference

Inheritance diagram for LibXR::MSPM0SPI:

Collaboration diagram for LibXR::MSPM0SPI:

Data Structures
struct	Resources

Public Member Functions
	MSPM0SPI (Resources res, RawData dma_rx_buffer, RawData dma_tx_buffer, uint32_t dma_enable_min_size=3, SPI::Configuration config={SPI::ClockPolarity::LOW, SPI::ClockPhase::EDGE_1, SPI::Prescaler::DIV_4, false})
ErrorCode	ReadAndWrite (RawData read_data, ConstRawData write_data, OperationRW &op, bool in_isr=false) override
	进行 SPI 读写操作。Performs SPI read and write operations.
ErrorCode	SetConfig (SPI::Configuration config) override
	设置 SPI 配置参数。Sets SPI configuration parameters.
ErrorCode	MemRead (uint16_t reg, RawData read_data, OperationRW &op, bool in_isr=false) override
	从 SPI 设备的寄存器读取数据。 Reads data from a specific register of the SPI device.
ErrorCode	MemWrite (uint16_t reg, ConstRawData write_data, OperationRW &op, bool in_isr=false) override
	向 SPI 设备的寄存器写入数据。 Writes data to a specific register of the SPI device.
uint32_t	GetMaxBusSpeed () const override
	获取 SPI 设备的最大时钟速度。Gets the maximum clock speed of the SPI device.
Prescaler	GetMaxPrescaler () const override
	获取 SPI 设备的最大分频系数。Gets the maximum prescaler of the SPI device.
ErrorCode	Transfer (size_t size, OperationRW &op, bool in_isr=false) override
	进行一次SPI传输（使用当前缓冲区数据，零拷贝，支持双缓冲）。 Performs a SPI transfer (zero-copy, supports double buffering).
Public Member Functions inherited from LibXR::SPI
	SPI (RawData rx_buffer, RawData tx_buffer)
	构造函数。Constructor.
virtual ErrorCode	Read (RawData read_data, OperationRW &op, bool in_isr=false)
	进行 SPI 读取操作。Performs SPI read operation.
virtual ErrorCode	Write (ConstRawData write_data, OperationRW &op, bool in_isr=false)
	进行 SPI 写入操作。Performs SPI write operation.
uint32_t	GetBusSpeed () const
	获取 SPI 设备的当前总线速度。Gets the current bus speed of the SPI device.
Prescaler	CalcPrescaler (uint32_t target_max_bus_speed, uint32_t target_min_bus_speed, bool increase)
	计算 SPI 分频系数。Calculates the SPI prescaler.
RawData	GetRxBuffer ()
	获取接收数据的缓冲区。Gets the buffer for storing received data.
RawData	GetTxBuffer ()
	获取发送数据的缓冲区。Gets the buffer for storing data to be sent.
void	SwitchBuffer ()
	切换缓冲区。Switches the buffer.
void	SetActiveLength (size_t len)
	设置缓冲区的有效数据长度。Sets the length of valid data in the buffer.
size_t	GetActiveLength () const
	获取缓冲区的有效数据长度。Gets the length of valid data in the buffer.
Configuration &	GetConfig ()
	获取 SPI 配置参数。Gets the SPI configuration parameters.
bool	IsDoubleBuffer () const
	检查是否使用双缓冲区。Checks if double buffering is enabled.

Static Public Member Functions
static void	OnInterrupt (uint8_t index)
static constexpr uint8_t	ResolveIndex (IRQn_Type irqn)
Static Public Member Functions inherited from LibXR::SPI
static constexpr uint32_t	PrescalerToDiv (Prescaler prescaler)
	将分频系数转换为除数。Converts a prescaler to a divisor.

Private Types
enum class	DmaMode : uint8_t { DUPLEX , RX_ONLY , TX_ONLY }

Private Member Functions
ErrorCode	PollingTransfer (uint8_t *rx, const uint8_t *tx, uint32_t len)
ErrorCode	CompleteDmaOperation (OperationRW &op, bool in_isr)
void	StartDmaDuplex (uint32_t count)
void	StartDmaRxOnly (uint32_t offset, uint32_t count)
void	StartDmaTxOnly (uint32_t count)
void	StopDma ()
void	HandleInterrupt ()
bool	DmaBusy () const

Private Attributes
Resources	res_
uint32_t	dma_enable_min_size_
OperationRW	rw_op_
volatile ErrorCode	dma_result_ = ErrorCode::OK
RawData	read_buff_
bool	mem_read_ = false
DmaMode	dma_mode_ = DmaMode::DUPLEX
uint32_t	masked_interrupts_for_tx_only_ = 0
uint32_t	rx_only_offset_ = 0
uint32_t	rx_only_remaining_ = 0
volatile bool	busy_ = false

Static Private Attributes
static constexpr uint8_t	MAX_SPI_INSTANCES = 2
static constexpr uint8_t	INVALID_INSTANCE_INDEX = 0xFF
static constexpr uint32_t	RX_ONLY_REPEAT_TX_MAX_FRAMES = 256U
static MSPM0SPI *	instance_map_ [MAX_SPI_INSTANCES] = {nullptr}

Additional Inherited Members
Public Types inherited from LibXR::SPI
enum class	ClockPolarity : uint8_t { LOW = 0 , HIGH = 1 }
	定义 SPI 时钟极性。Defines the SPI clock polarity. More...
enum class	ClockPhase : uint8_t { EDGE_1 = 0 , EDGE_2 = 1 }
	定义 SPI 时钟相位。Defines the SPI clock phase. More...
enum class	Prescaler : uint8_t {   DIV_1 = 0 , DIV_2 = 1 , DIV_4 = 2 , DIV_8 = 3 ,   DIV_16 = 4 , DIV_32 = 5 , DIV_64 = 6 , DIV_128 = 7 ,   DIV_256 = 8 , DIV_512 = 9 , DIV_1024 = 10 , DIV_2048 = 11 ,   DIV_4096 = 12 , DIV_8192 = 13 , DIV_16384 = 14 , DIV_32768 = 15 ,   DIV_65536 = 16 , UNKNOWN = 0xFF }
using	OperationRW = WriteOperation
	定义读写操作类型的别名。Defines an alias for the read/write operation type.

Detailed Description

Definition at line 11 of file mspm0_spi.hpp.

Member Enumeration Documentation

DmaMode

enum class LibXR::MSPM0SPI::DmaMode : uint8_t

strongprivate

Definition at line 66 of file mspm0_spi.hpp.

  {
    DUPLEX,
    RX_ONLY,
    TX_ONLY
  };

Constructor & Destructor Documentation

MSPM0SPI()

MSPM0SPI::MSPM0SPI	(	Resources	res,
		RawData	dma_rx_buffer,
		RawData	dma_tx_buffer,
		uint32_t	dma_enable_min_size = 3,
		SPI::Configuration	config = {SPI::ClockPolarity::LOW, SPI::ClockPhase::EDGE_1, SPI::Prescaler::DIV_4, false} )

Definition at line 19 of file mspm0_spi.cpp.

    : SPI(dma_rx_buffer, dma_tx_buffer),
      res_(res),
      dma_enable_min_size_(dma_enable_min_size)
{
  ASSERT(res_.instance != nullptr);
  ASSERT(res_.clock_freq > 0);
  ASSERT(res_.index < MAX_SPI_INSTANCES);
  ASSERT(instance_map_[res_.index] == nullptr);
  ASSERT(dma_rx_buffer.addr_ != nullptr);
  ASSERT(dma_tx_buffer.addr_ != nullptr);
  ASSERT(dma_rx_buffer.size_ > 0);
  ASSERT(dma_tx_buffer.size_ > 0);
 
  instance_map_[res_.index] = this;
 
  NVIC_ClearPendingIRQ(res_.irqn);
  NVIC_EnableIRQ(res_.irqn);
 
  const ErrorCode SET_CFG_ANS = SetConfig(config);
  ASSERT(SET_CFG_ANS == ErrorCode::OK);
}

Member Function Documentation

CompleteDmaOperation()

ErrorCode MSPM0SPI::CompleteDmaOperation ( OperationRW & op, bool in_isr )

private

Definition at line 254 of file mspm0_spi.cpp.

{
  op.MarkAsRunning();
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    return ErrorCode::OK;
  }
 
  ASSERT(!in_isr);
  const ErrorCode WAIT_ANS = op.data.sem_info.sem->Wait(op.data.sem_info.timeout);
  if (WAIT_ANS == ErrorCode::TIMEOUT)
  {
    const bool IRQ_WAS_ENABLED = (NVIC_GetEnableIRQ(res_.irqn) != 0U);
    if (IRQ_WAS_ENABLED)
    {
      NVIC_DisableIRQ(res_.irqn);
    }
 
    StopDma();
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    NVIC_ClearPendingIRQ(res_.irqn);
 
    busy_ = false;
    dma_mode_ = DmaMode::DUPLEX;
    dma_result_ = ErrorCode::TIMEOUT;
    rw_op_ = OperationRW();
    // Drain any timeout-race semaphore credits posted right before IRQ disable,
    // so the next BLOCK transfer cannot consume a stale completion signal.
    while (op.data.sem_info.sem->Wait(0U) == ErrorCode::OK)
    {
    }
 
    if (IRQ_WAS_ENABLED)
    {
      NVIC_EnableIRQ(res_.irqn);
    }
    return ErrorCode::TIMEOUT;
  }
 
  if (WAIT_ANS != ErrorCode::OK)
  {
    return WAIT_ANS;
  }
 
  return dma_result_;
}

DmaBusy()

bool MSPM0SPI::DmaBusy ( ) const

private

Definition at line 150 of file mspm0_spi.cpp.

{
  if (busy_)
  {
    return true;
  }
 
  return DL_DMA_isChannelEnabled(DMA, res_.dma_rx_channel) ||
         DL_DMA_isChannelEnabled(DMA, res_.dma_tx_channel);
}

GetMaxBusSpeed()

uint32_t MSPM0SPI::GetMaxBusSpeed ( ) const

overridevirtual

获取 SPI 设备的最大时钟速度。Gets the maximum clock speed of the SPI device.

Returns

SPI 设备的最大时钟速度（单位：Hz）。The maximum clock speed of the SPI device (in Hz).

Implements LibXR::SPI.

Definition at line 76 of file mspm0_spi.cpp.

{ return res_.clock_freq; }

GetMaxPrescaler()

SPI::Prescaler MSPM0SPI::GetMaxPrescaler ( ) const

overridevirtual

获取 SPI 设备的最大分频系数。Gets the maximum prescaler of the SPI device.

Returns

SPI 设备的最大分频系数。The maximum prescaler of the SPI device.

Implements LibXR::SPI.

Definition at line 78 of file mspm0_spi.cpp.

{ return SPI::Prescaler::DIV_512; }

HandleInterrupt()

void MSPM0SPI::HandleInterrupt ( )

private

Definition at line 584 of file mspm0_spi.cpp.

{
  if (!busy_)
  {
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    return;
  }
 
  auto drain_rx_fifo = [this]() -> bool
  {
    constexpr uint32_t RX_FIFO_DRAIN_MAX_ITERATIONS = 1024U;
    uint32_t remaining = RX_FIFO_DRAIN_MAX_ITERATIONS;
    uint8_t discard = 0U;
    while (remaining > 0U && DL_SPI_receiveDataCheck8(res_.instance, &discard))
    {
      --remaining;
    }
 
    return (remaining > 0U);
  };
 
  auto complete_dma_ok = [this]()
  {
    if (read_buff_.size_ > 0)
    {
      RawData rx = GetRxBuffer();
      auto* rx_bytes = static_cast<uint8_t*>(rx.addr_);
      if (mem_read_)
      {
        Memory::FastCopy(read_buff_.addr_, rx_bytes + 1, read_buff_.size_);
      }
      else
      {
        Memory::FastCopy(read_buff_.addr_, rx_bytes, read_buff_.size_);
      }
      read_buff_.size_ = 0;
    }
 
    SwitchBuffer();
    busy_ = false;
    dma_mode_ = DmaMode::DUPLEX;
    dma_result_ = ErrorCode::OK;
    rw_op_.UpdateStatus(true, dma_result_);
  };
 
  switch (DL_SPI_getPendingInterrupt(res_.instance))
  {
    case DL_SPI_IIDX_DMA_DONE_RX:
    {
      if (dma_mode_ == DmaMode::TX_ONLY)
      {
        break;
      }
 
      if (dma_mode_ == DmaMode::RX_ONLY && rx_only_remaining_ > 0U)
      {
        const uint32_t NEXT_CHUNK = min(rx_only_remaining_, RX_ONLY_REPEAT_TX_MAX_FRAMES);
        const uint32_t NEXT_OFFSET = rx_only_offset_;
        rx_only_offset_ += NEXT_CHUNK;
        rx_only_remaining_ -= NEXT_CHUNK;
        StartDmaRxOnly(NEXT_OFFSET, NEXT_CHUNK);
        break;
      }
 
      StopDma();
      complete_dma_ok();
      break;
    }
 
    case DL_SPI_IIDX_DMA_DONE_TX:
      if (dma_mode_ == DmaMode::TX_ONLY)
      {
        StopDma();
        const bool DRAIN_DONE = drain_rx_fifo();
        DL_SPI_clearInterruptStatus(
            res_.instance, DL_SPI_INTERRUPT_RX_OVERFLOW | DL_SPI_INTERRUPT_RX_TIMEOUT);
 
        if (!DRAIN_DONE)
        {
          busy_ = false;
          dma_mode_ = DmaMode::DUPLEX;
          dma_result_ = ErrorCode::FAILED;
          rw_op_.UpdateStatus(true, dma_result_);
          break;
        }
 
        complete_dma_ok();
      }
      break;
 
    case DL_SPI_IIDX_TX_UNDERFLOW:
    case DL_SPI_IIDX_PARITY_ERROR:
      StopDma();
      busy_ = false;
      dma_mode_ = DmaMode::DUPLEX;
      dma_result_ = ErrorCode::FAILED;
      rw_op_.UpdateStatus(true, dma_result_);
      break;
 
    case DL_SPI_IIDX_RX_OVERFLOW:
      if (dma_mode_ == DmaMode::TX_ONLY)
      {
        (void)drain_rx_fifo();
        DL_SPI_clearInterruptStatus(res_.instance, DL_SPI_INTERRUPT_RX_OVERFLOW);
        break;
      }
 
      StopDma();
      busy_ = false;
      dma_mode_ = DmaMode::DUPLEX;
      dma_result_ = ErrorCode::FAILED;
      rw_op_.UpdateStatus(true, dma_result_);
      break;
 
    case DL_SPI_IIDX_RX_TIMEOUT:
      if (dma_mode_ == DmaMode::TX_ONLY)
      {
        DL_SPI_clearInterruptStatus(res_.instance, DL_SPI_INTERRUPT_RX_TIMEOUT);
        break;
      }
 
      StopDma();
      busy_ = false;
      dma_mode_ = DmaMode::DUPLEX;
      dma_result_ = ErrorCode::TIMEOUT;
      rw_op_.UpdateStatus(true, dma_result_);
      break;
 
    default:
      break;
  }
}

MemRead()

ErrorCode MSPM0SPI::MemRead ( uint16_t reg, RawData read_data, OperationRW & op, bool in_isr = false )

overridevirtual

从 SPI 设备的寄存器读取数据。 Reads data from a specific register of the SPI device.

Parameters

reg	寄存器地址。Register address.
read_data	读取的数据缓冲区。Buffer to store read data.
op	操作类型（同步/异步）。Operation mode (sync/async).
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

操作结果的错误码。Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 449 of file mspm0_spi.cpp.

{
  const uint32_t NEED_READ = static_cast<uint32_t>(read_data.size_);
  if (NEED_READ == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  ASSERT(rx.size_ >= (NEED_READ + 1));
  ASSERT(tx.size_ >= (NEED_READ + 1));
 
  auto* tx_bytes = static_cast<uint8_t*>(tx.addr_);
  tx_bytes[0] = static_cast<uint8_t>(reg | 0x80);
  Memory::FastSet(tx_bytes + 1, 0, NEED_READ);
 
  const uint32_t TOTAL = NEED_READ + 1;
 
  if (TOTAL > dma_enable_min_size_)
  {
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    NVIC_ClearPendingIRQ(res_.irqn);
 
    mem_read_ = true;
    dma_mode_ = DmaMode::DUPLEX;
    read_buff_ = read_data;
    rw_op_ = op;
    dma_result_ = ErrorCode::PENDING;
    busy_ = true;
 
    StartDmaDuplex(TOTAL);
    return CompleteDmaOperation(op, in_isr);
  }
 
  ErrorCode ans = PollingTransfer(static_cast<uint8_t*>(rx.addr_), tx_bytes, TOTAL);
 
  if (ans == ErrorCode::OK)
  {
    auto* rx_bytes = static_cast<uint8_t*>(rx.addr_);
    Memory::FastCopy(read_data.addr_, rx_bytes + 1, NEED_READ);
  }
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
 
  return ans;
}

MemWrite()

ErrorCode MSPM0SPI::MemWrite ( uint16_t reg, ConstRawData write_data, OperationRW & op, bool in_isr = false )

overridevirtual

向 SPI 设备的寄存器写入数据。 Writes data to a specific register of the SPI device.

Parameters

reg	寄存器地址。Register address.
write_data	写入的数据缓冲区。Buffer containing data to write.
op	操作类型（同步/异步）。Operation mode (sync/async).
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

操作结果的错误码。Error code indicating success or failure.

Implements LibXR::SPI.

Definition at line 512 of file mspm0_spi.cpp.

{
  const uint32_t NEED_WRITE = static_cast<uint32_t>(write_data.size_);
  if (NEED_WRITE == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  RawData tx = GetTxBuffer();
  ASSERT(tx.size_ >= (NEED_WRITE + 1));
 
  auto* tx_bytes = static_cast<uint8_t*>(tx.addr_);
  tx_bytes[0] = static_cast<uint8_t>(reg & 0x7F);
  Memory::FastCopy(tx_bytes + 1, write_data.addr_, NEED_WRITE);
 
  const uint32_t TOTAL = NEED_WRITE + 1;
 
  if (TOTAL > dma_enable_min_size_)
  {
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    NVIC_ClearPendingIRQ(res_.irqn);
 
    mem_read_ = false;
    dma_mode_ = DmaMode::TX_ONLY;
    read_buff_ = {nullptr, 0};
    rw_op_ = op;
    dma_result_ = ErrorCode::PENDING;
    busy_ = true;
 
    StartDmaTxOnly(TOTAL);
    return CompleteDmaOperation(op, in_isr);
  }
 
  RawData rx = GetRxBuffer();
  ErrorCode ans = PollingTransfer(static_cast<uint8_t*>(rx.addr_), tx_bytes, TOTAL);
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
 
  return ans;
}

OnInterrupt()

void MSPM0SPI::OnInterrupt ( uint8_t index )

static

Definition at line 568 of file mspm0_spi.cpp.

{
  if (index >= MAX_SPI_INSTANCES)
  {
    return;
  }
 
  MSPM0SPI* spi = instance_map_[index];
  if (spi == nullptr)
  {
    return;
  }
 
  spi->HandleInterrupt();
}

PollingTransfer()

ErrorCode MSPM0SPI::PollingTransfer ( uint8_t * rx, const uint8_t * tx, uint32_t len )

private

Definition at line 80 of file mspm0_spi.cpp.

{
  constexpr uint32_t POLLING_TIMEOUT_US = 20000U;
  constexpr uint32_t POLLING_FALLBACK_SPIN_BUDGET = 1000000U;
 
  if (len == 0)
  {
    return ErrorCode::OK;
  }
 
  const bool HAS_TIMEBASE = (Timebase::timebase != nullptr);
  const uint64_t START_US =
      HAS_TIMEBASE ? static_cast<uint64_t>(Timebase::GetMicroseconds()) : 0ULL;
 
  uint32_t spin_budget = POLLING_FALLBACK_SPIN_BUDGET;
  auto polling_timed_out = [&]() -> bool
  {
    if (HAS_TIMEBASE)
    {
      const uint64_t NOW_US = static_cast<uint64_t>(Timebase::GetMicroseconds());
      return (NOW_US - START_US) >= POLLING_TIMEOUT_US;
    }
    // timebase 未就绪时的最后兜底策略 / Last-resort fallback when timebase is
    // not ready yet.
    if (spin_budget == 0U)
    {
      return true;
    }
    --spin_budget;
    return false;
  };
 
  for (uint32_t i = 0; i < len; ++i)
  {
    while (DL_SPI_isTXFIFOFull(res_.instance))
    {
      if (polling_timed_out())
      {
        return ErrorCode::TIMEOUT;
      }
    }
    const uint8_t TX_BYTE = (tx == nullptr) ? 0 : tx[i];
    DL_SPI_transmitData8(res_.instance, TX_BYTE);
 
    uint8_t rx_byte = 0;
    while (!DL_SPI_receiveDataCheck8(res_.instance, &rx_byte))
    {
      if (polling_timed_out())
      {
        return ErrorCode::TIMEOUT;
      }
    }
 
    if (rx != nullptr)
    {
      rx[i] = rx_byte;
    }
  }
 
  while (DL_SPI_isBusy(res_.instance))
  {
    if (polling_timed_out())
    {
      return ErrorCode::TIMEOUT;
    }
  }
 
  return ErrorCode::OK;
}

ReadAndWrite()

ErrorCode MSPM0SPI::ReadAndWrite ( RawData read_data, ConstRawData write_data, OperationRW & op, bool in_isr = false )

overridevirtual

进行 SPI 读写操作。Performs SPI read and write operations.

Parameters

read_data	存储读取数据的缓冲区。Buffer to store the read data.
write_data	需要写入的数据缓冲区。Buffer containing the data to be written.
op	读写操作类型。Type of read/write operation.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 301 of file mspm0_spi.cpp.

{
  const uint32_t NEED = static_cast<uint32_t>(max(read_data.size_, write_data.size_));
  const bool IS_READ_ONLY = (write_data.size_ == 0U) && (read_data.size_ > 0U);
 
  if (NEED == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  if (rx.size_ < NEED)
  {
    return ErrorCode::SIZE_ERR;
  }
  if (!IS_READ_ONLY && tx.size_ < NEED)
  {
    return ErrorCode::SIZE_ERR;
  }
 
  ASSERT(rx.size_ >= NEED);
  if (!IS_READ_ONLY)
  {
    ASSERT(tx.size_ >= NEED);
  }
 
  uint8_t* tx_bytes = nullptr;
  if (!IS_READ_ONLY)
  {
    tx_bytes = static_cast<uint8_t*>(tx.addr_);
    if (write_data.size_ > 0)
    {
      Memory::FastCopy(tx_bytes, write_data.addr_, write_data.size_);
    }
    if (write_data.size_ < NEED)
    {
      Memory::FastSet(tx_bytes + write_data.size_, 0, NEED - write_data.size_);
    }
  }
 
  if (NEED > dma_enable_min_size_)
  {
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    NVIC_ClearPendingIRQ(res_.irqn);
 
    mem_read_ = false;
    read_buff_ = read_data;
    rw_op_ = op;
    dma_result_ = ErrorCode::PENDING;
    busy_ = true;
 
    if (IS_READ_ONLY)
    {
      dma_mode_ = DmaMode::RX_ONLY;
      const uint32_t FIRST_CHUNK = min(NEED, RX_ONLY_REPEAT_TX_MAX_FRAMES);
      rx_only_offset_ = FIRST_CHUNK;
      rx_only_remaining_ = NEED - FIRST_CHUNK;
      StartDmaRxOnly(0U, FIRST_CHUNK);
    }
    else
    {
      dma_mode_ = DmaMode::DUPLEX;
      StartDmaDuplex(NEED);
    }
    return CompleteDmaOperation(op, in_isr);
  }
 
  ErrorCode ans = PollingTransfer(static_cast<uint8_t*>(rx.addr_), tx_bytes, NEED);
 
  if (ans == ErrorCode::OK && read_data.size_ > 0)
  {
    Memory::FastCopy(read_data.addr_, rx.addr_, read_data.size_);
  }
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
 
  return ans;
}

ResolveIndex()

static constexpr uint8_t LibXR::MSPM0SPI::ResolveIndex ( IRQn_Type irqn )

inlinestaticconstexpr

Definition at line 48 of file mspm0_spi.hpp.

  {
    switch (irqn)
    {
#if defined(SPI0_BASE)
      case SPI0_INT_IRQn:
        return 0;
#endif
#if defined(SPI1_BASE)
      case SPI1_INT_IRQn:
        return 1;
#endif
      default:
        return INVALID_INSTANCE_INDEX;
    }
  }

SetConfig()

ErrorCode MSPM0SPI::SetConfig ( SPI::Configuration config )

overridevirtual

设置 SPI 配置参数。Sets SPI configuration parameters.

Parameters

config

需要应用的 SPI 配置。The SPI configuration to apply.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 43 of file mspm0_spi.cpp.

{
  DL_SPI_FRAME_FORMAT frame_format = DL_SPI_FRAME_FORMAT_MOTO4_POL0_PHA0;
  if (config.clock_polarity == ClockPolarity::LOW)
  {
    frame_format = (config.clock_phase == ClockPhase::EDGE_1)
                       ? DL_SPI_FRAME_FORMAT_MOTO4_POL0_PHA0
                       : DL_SPI_FRAME_FORMAT_MOTO4_POL0_PHA1;
  }
  else
  {
    frame_format = (config.clock_phase == ClockPhase::EDGE_1)
                       ? DL_SPI_FRAME_FORMAT_MOTO4_POL1_PHA0
                       : DL_SPI_FRAME_FORMAT_MOTO4_POL1_PHA1;
  }
 
  const uint32_t DIV = SPI::PrescalerToDiv(config.prescaler);
  if (DIV < 2 || DIV > 512 || (DIV & 0x1) != 0)
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  const uint32_t SCR = (DIV >> 1) - 1;
 
  DL_SPI_disable(res_.instance);
  DL_SPI_setFrameFormat(res_.instance, frame_format);
  DL_SPI_setBitRateSerialClockDivider(res_.instance, SCR);
  DL_SPI_enable(res_.instance);
 
  GetConfig() = config;
  return ErrorCode::OK;
}

StartDmaDuplex()

void MSPM0SPI::StartDmaDuplex ( uint32_t count )

private

Definition at line 161 of file mspm0_spi.cpp.

{
  masked_interrupts_for_tx_only_ = 0;
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  DL_DMA_setSrcAddr(DMA, res_.dma_rx_channel,
                    reinterpret_cast<uint32_t>(&res_.instance->RXDATA));
  DL_DMA_setDestAddr(DMA, res_.dma_rx_channel, reinterpret_cast<uint32_t>(rx.addr_));
  DL_DMA_setTransferSize(DMA, res_.dma_rx_channel, count);
 
  DL_DMA_setSrcAddr(DMA, res_.dma_tx_channel, reinterpret_cast<uint32_t>(tx.addr_));
  DL_DMA_setDestAddr(DMA, res_.dma_tx_channel,
                     reinterpret_cast<uint32_t>(&res_.instance->TXDATA));
  DL_DMA_setTransferSize(DMA, res_.dma_tx_channel, count);
 
  DL_DMA_enableChannel(DMA, res_.dma_rx_channel);
  DL_DMA_enableChannel(DMA, res_.dma_tx_channel);
}

StartDmaRxOnly()

void MSPM0SPI::StartDmaRxOnly ( uint32_t offset, uint32_t count )

private

Definition at line 182 of file mspm0_spi.cpp.

{
  RawData rx = GetRxBuffer();
 
  ASSERT(offset < rx.size_);
  ASSERT(count > 0U);
  ASSERT(count <= RX_ONLY_REPEAT_TX_MAX_FRAMES);
  ASSERT((offset + count) <= rx.size_);
 
  masked_interrupts_for_tx_only_ = 0;
 
  auto* rx_bytes = static_cast<uint8_t*>(rx.addr_);
 
  DL_DMA_disableChannel(DMA, res_.dma_tx_channel);
  DL_DMA_disableChannel(DMA, res_.dma_rx_channel);
  DL_DMA_setSrcAddr(DMA, res_.dma_rx_channel,
                    reinterpret_cast<uint32_t>(&res_.instance->RXDATA));
  DL_DMA_setDestAddr(DMA, res_.dma_rx_channel,
                     reinterpret_cast<uint32_t>(rx_bytes + offset));
  DL_DMA_setTransferSize(DMA, res_.dma_rx_channel, count);
  DL_DMA_enableChannel(DMA, res_.dma_rx_channel);
 
  // RX-only DMA 仍需要主机时钟，使用硬件重复 dummy TX 提供时钟 / RX-only DMA
  // still needs controller clocks; use repeated dummy TX in hardware so read-only
  // transfers can avoid occupying the TX DMA channel.
  DL_SPI_setRepeatTransmit(res_.instance, static_cast<uint8_t>(count - 1U));
  DL_SPI_transmitData8(res_.instance, 0U);
}

StartDmaTxOnly()

void MSPM0SPI::StartDmaTxOnly ( uint32_t count )

private

Definition at line 211 of file mspm0_spi.cpp.

{
  constexpr uint32_t TX_ONLY_MASKED_INTERRUPTS = DL_SPI_INTERRUPT_DMA_DONE_RX |
                                                 DL_SPI_INTERRUPT_RX_OVERFLOW |
                                                 DL_SPI_INTERRUPT_RX_TIMEOUT;
 
  masked_interrupts_for_tx_only_ =
      DL_SPI_getEnabledInterrupts(res_.instance, TX_ONLY_MASKED_INTERRUPTS);
  if (masked_interrupts_for_tx_only_ != 0U)
  {
    DL_SPI_disableInterrupt(res_.instance, masked_interrupts_for_tx_only_);
  }
 
  RawData tx = GetTxBuffer();
 
  DL_DMA_disableChannel(DMA, res_.dma_rx_channel);
  DL_DMA_setSrcAddr(DMA, res_.dma_tx_channel, reinterpret_cast<uint32_t>(tx.addr_));
  DL_DMA_setDestAddr(DMA, res_.dma_tx_channel,
                     reinterpret_cast<uint32_t>(&res_.instance->TXDATA));
  DL_DMA_setTransferSize(DMA, res_.dma_tx_channel, count);
  DL_DMA_enableChannel(DMA, res_.dma_tx_channel);
}

StopDma()

void MSPM0SPI::StopDma ( )

private

Definition at line 234 of file mspm0_spi.cpp.

{
  DL_DMA_disableChannel(DMA, res_.dma_tx_channel);
  DL_DMA_disableChannel(DMA, res_.dma_rx_channel);
 
  if (dma_mode_ == DmaMode::RX_ONLY)
  {
    DL_SPI_setRepeatTransmit(res_.instance, 0U);
  }
 
  rx_only_offset_ = 0U;
  rx_only_remaining_ = 0U;
 
  if (masked_interrupts_for_tx_only_ != 0U)
  {
    DL_SPI_enableInterrupt(res_.instance, masked_interrupts_for_tx_only_);
    masked_interrupts_for_tx_only_ = 0U;
  }
}

Transfer()

ErrorCode MSPM0SPI::Transfer ( size_t size, OperationRW & op, bool in_isr = false )

overridevirtual

进行一次SPI传输（使用当前缓冲区数据，零拷贝，支持双缓冲）。 Performs a SPI transfer (zero-copy, supports double buffering).

Parameters

size	需要传输的数据大小。The size of the data to be transferred.
op	读写操作类型。Type of read/write operation.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::SPI.

Definition at line 397 of file mspm0_spi.cpp.

{
  if (size == 0)
  {
    if (op.type != OperationRW::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  RawData rx = GetRxBuffer();
  RawData tx = GetTxBuffer();
 
  ASSERT(rx.size_ >= size);
  ASSERT(tx.size_ >= size);
 
  if (size > dma_enable_min_size_)
  {
    DL_SPI_clearInterruptStatus(res_.instance, MSPM0_SPI_DMA_INTERRUPT_MASK);
    NVIC_ClearPendingIRQ(res_.irqn);
 
    mem_read_ = false;
    dma_mode_ = DmaMode::DUPLEX;
    read_buff_ = {nullptr, 0};
    rw_op_ = op;
    dma_result_ = ErrorCode::PENDING;
    busy_ = true;
 
    StartDmaDuplex(static_cast<uint32_t>(size));
    return CompleteDmaOperation(op, in_isr);
  }
 
  ErrorCode ans =
      PollingTransfer(static_cast<uint8_t*>(rx.addr_),
                      static_cast<const uint8_t*>(tx.addr_), static_cast<uint32_t>(size));
 
  SwitchBuffer();
 
  if (op.type != OperationRW::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
 
  return ans;
}

Field Documentation

busy_

volatile bool LibXR::MSPM0SPI::busy_ = false

private

Definition at line 103 of file mspm0_spi.hpp.

dma_enable_min_size_

uint32_t LibXR::MSPM0SPI::dma_enable_min_size_

private

Definition at line 94 of file mspm0_spi.hpp.

dma_mode_

DmaMode LibXR::MSPM0SPI::dma_mode_ = DmaMode::DUPLEX

private

Definition at line 99 of file mspm0_spi.hpp.

dma_result_

volatile ErrorCode LibXR::MSPM0SPI::dma_result_ = ErrorCode::OK

private

Definition at line 96 of file mspm0_spi.hpp.

instance_map_

MSPM0SPI * MSPM0SPI::instance_map_ = {nullptr}

staticprivate

Definition at line 105 of file mspm0_spi.hpp.

INVALID_INSTANCE_INDEX

uint8_t LibXR::MSPM0SPI::INVALID_INSTANCE_INDEX = 0xFF

staticconstexprprivate

Definition at line 74 of file mspm0_spi.hpp.

masked_interrupts_for_tx_only_

uint32_t LibXR::MSPM0SPI::masked_interrupts_for_tx_only_ = 0

private

Definition at line 100 of file mspm0_spi.hpp.

MAX_SPI_INSTANCES

uint8_t LibXR::MSPM0SPI::MAX_SPI_INSTANCES = 2

staticconstexprprivate

Definition at line 73 of file mspm0_spi.hpp.

mem_read_

bool LibXR::MSPM0SPI::mem_read_ = false

private

Definition at line 98 of file mspm0_spi.hpp.

read_buff_

RawData LibXR::MSPM0SPI::read_buff_

private

Definition at line 97 of file mspm0_spi.hpp.

res_

Resources LibXR::MSPM0SPI::res_

private

Definition at line 93 of file mspm0_spi.hpp.

rw_op_

OperationRW LibXR::MSPM0SPI::rw_op_

private

Definition at line 95 of file mspm0_spi.hpp.

rx_only_offset_

uint32_t LibXR::MSPM0SPI::rx_only_offset_ = 0

private

Definition at line 101 of file mspm0_spi.hpp.

rx_only_remaining_

uint32_t LibXR::MSPM0SPI::rx_only_remaining_ = 0

private

Definition at line 102 of file mspm0_spi.hpp.

RX_ONLY_REPEAT_TX_MAX_FRAMES

uint32_t LibXR::MSPM0SPI::RX_ONLY_REPEAT_TX_MAX_FRAMES = 256U

staticconstexprprivate

Definition at line 75 of file mspm0_spi.hpp.

---

The documentation for this class was generated from the following files:

• driver/mspm0/mspm0_spi.hpp
• driver/mspm0/mspm0_spi.cpp