LibXR::MSPM0SPI Class Reference

MSPM0 SPI 控制器 / MSPM0 SPI controller. More...

#include <mspm0_spi.hpp>

Inheritance diagram for LibXR::MSPM0SPI:

Collaboration diagram for LibXR::MSPM0SPI:

Classes
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.

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

MSPM0 SPI 控制器 / MSPM0 SPI controller.

Note

构造时开启 DMA 收发完成中断，并把 SPI 中断设为优先级 1；SysConfig 中该实例的 中断和优先级设置会被覆盖。 The constructor enables the DMA RX/TX done interrupts and sets the SPI interrupt to priority 1, replacing the interrupt and priority settings SysConfig made for the instance.

Definition at line 21 of file mspm0_spi.hpp.

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;
 
  // 中断源和优先级由驱动设置，不依赖 SysConfig 的中断配置；优先级低于 SysTick 时基。
  // The driver sets the interrupt sources and priority instead of relying on the
  // SysConfig interrupt settings; the priority stays below the SysTick timebase.
  DL_SPI_disableInterrupt(res_.instance, 0xFFFFFFFFU);
  DL_SPI_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
  DL_SPI_enableInterrupt(res_.instance,
                         DL_SPI_INTERRUPT_DMA_DONE_RX | DL_SPI_INTERRUPT_DMA_DONE_TX);
  NVIC_SetPriority(res_.irqn, 1U);
  NVIC_ClearPendingIRQ(res_.irqn);
  NVIC_EnableIRQ(res_.irqn);
 
  const ErrorCode SET_CFG_ANS = SetConfig(config);
  ASSERT(SET_CFG_ANS == ErrorCode::OK);
}

Member Function Documentation

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 84 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 86 of file mspm0_spi.cpp.

{ return SPI::Prescaler::DIV_512; }

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 446 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 509 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 565 of file mspm0_spi.cpp.

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

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 304 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;
  }
 
  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 58 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
#if defined(SPI2_BASE)
      case SPI2_INT_IRQn:
        return 2;
#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 51 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;
}

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 394 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;
}

---

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

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