* ADMA2 action
* | Act2 | Act1 | Comment | Operation
* |
|---|
| 0 | 0 | No op | Don't care
* |
| 0 | 1 | Reserved | Read this line and go to next one
* |
| 1 | 0 | Transfer data | Transfer data with address and length set in this descriptor line
* |
| 1 | 1 | Link descriptor | Link to another descriptor
* |
*/
#define USDHC_ADMA2_DESCRIPTOR_LENGTH_SHIFT (16U)
/*! @brief The bit mask for LENGTH field in ADMA2's descriptor. */
#define USDHC_ADMA2_DESCRIPTOR_LENGTH_MASK (0xFFFFU)
/*! @brief The maximum value of LENGTH field in ADMA2's descriptor. */
#define USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY (USDHC_ADMA2_DESCRIPTOR_LENGTH_MASK - 3U)
/*! @brief Enum _usdhc_adma2_descriptor_flag. ADMA1 descriptor control and status mask. */
enum
{
kUSDHC_Adma2DescriptorValidFlag = (1U << 0U), /*!< Valid flag. */
kUSDHC_Adma2DescriptorEndFlag = (1U << 1U), /*!< End flag. */
kUSDHC_Adma2DescriptorInterruptFlag = (1U << 2U), /*!< Interrupt flag. */
kUSDHC_Adma2DescriptorActivity1Flag = (1U << 4U), /*!< Activity 1 mask. */
kUSDHC_Adma2DescriptorActivity2Flag = (1U << 5U), /*!< Activity 2 mask. */
kUSDHC_Adma2DescriptorTypeNop = (kUSDHC_Adma2DescriptorValidFlag), /*!< No operation. */
kUSDHC_Adma2DescriptorTypeReserved = (kUSDHC_Adma2DescriptorActivity1Flag | kUSDHC_Adma2DescriptorValidFlag),
/*!< Reserved. */
kUSDHC_Adma2DescriptorTypeTransfer = (kUSDHC_Adma2DescriptorActivity2Flag | kUSDHC_Adma2DescriptorValidFlag),
/*!< Transfer type. */
kUSDHC_Adma2DescriptorTypeLink = (kUSDHC_Adma2DescriptorActivity1Flag | kUSDHC_Adma2DescriptorActivity2Flag |
kUSDHC_Adma2DescriptorValidFlag), /*!< Link type. */
};
/*! @brief Enum _usdhc_adma_flag. ADMA descriptor configuration flag.
* @anchor _usdhc_adma_flag
*/
enum
{
kUSDHC_AdmaDescriptorSingleFlag = 0U,
/*!< Try to finish the transfer in a single ADMA descriptor. If transfer size is bigger than one
ADMA descriptor's ability, new another descriptor for data transfer. */
kUSDHC_AdmaDescriptorMultipleFlag = 1U,
/*!< Create multiple ADMA descriptors within the ADMA table, this is used for mmc boot mode
specifically, which need to modify the ADMA descriptor on the fly, so the flag should be used
combining with stop at block gap feature. */
};
/*! @brief DMA transfer burst len config. */
typedef enum _usdhc_burst_len
{
kUSDHC_EnBurstLenForINCR = 0x01U, /*!< Enable burst len for INCR. */
kUSDHC_EnBurstLenForINCR4816 = 0x02U, /*!< Enable burst len for INCR4/INCR8/INCR16. */
kUSDHC_EnBurstLenForINCR4816WRAP = 0x04U, /*!< Enable burst len for INCR4/8/16 WRAP. */
} usdhc_burst_len_t;
/*! @brief Enum _usdhc_transfer_data_type. Tansfer data type definition. */
enum
{
kUSDHC_TransferDataNormal = 0U, /*!< Transfer normal read/write data. */
kUSDHC_TransferDataTuning = 1U, /*!< Transfer tuning data. */
kUSDHC_TransferDataBoot = 2U, /*!< Transfer boot data. */
kUSDHC_TransferDataBootcontinous = 3U, /*!< Transfer boot data continuously. */
};
/*! @brief Defines the ADMA1 descriptor structure. */
typedef uint32_t usdhc_adma1_descriptor_t;
/*! @brief Defines the ADMA2 descriptor structure. */
typedef struct _usdhc_adma2_descriptor
{
uint32_t attribute; /*!< The control and status field. */
const uint32_t *address; /*!< The address field. */
} usdhc_adma2_descriptor_t;
/*!
* @brief USDHC capability information.
*
* Defines a structure to save the capability information of USDHC.
*/
typedef struct _usdhc_capability
{
uint32_t sdVersion; /*!< Support SD card/sdio version. */
uint32_t mmcVersion; /*!< Support EMMC card version. */
uint32_t maxBlockLength; /*!< Maximum block length united as byte. */
uint32_t maxBlockCount; /*!< Maximum block count can be set one time. */
uint32_t flags; /*!< Capability flags to indicate the support information(@ref _usdhc_capability_flag). */
} usdhc_capability_t;
/*! @brief Data structure to configure the MMC boot feature. */
typedef struct _usdhc_boot_config
{
uint32_t ackTimeoutCount; /*!< Timeout value for the boot ACK. The available range is 0 ~ 15. */
usdhc_boot_mode_t bootMode; /*!< Boot mode selection. */
uint32_t blockCount; /*!< Stop at block gap value of automatic mode. Available range is 0 ~ 65535. */
size_t blockSize; /*!< Block size. */
bool enableBootAck; /*!< Enable or disable boot ACK. */
bool enableAutoStopAtBlockGap; /*!< Enable or disable auto stop at block gap function in boot period. */
} usdhc_boot_config_t;
/*! @brief Data structure to initialize the USDHC. */
typedef struct _usdhc_config
{
uint32_t dataTimeout; /*!< Data timeout value. */
usdhc_endian_mode_t endianMode; /*!< Endian mode. */
uint8_t readWatermarkLevel; /*!< Watermark level for DMA read operation. Available range is 1 ~ 128. */
uint8_t writeWatermarkLevel; /*!< Watermark level for DMA write operation. Available range is 1 ~ 128. */
#if !(defined(FSL_FEATURE_USDHC_HAS_NO_RW_BURST_LEN) && FSL_FEATURE_USDHC_HAS_NO_RW_BURST_LEN)
uint8_t readBurstLen; /*!< Read burst len. */
uint8_t writeBurstLen; /*!< Write burst len. */
#endif
} usdhc_config_t;
/*!
* @brief Card data descriptor.
*
* Defines a structure to contain data-related attribute. The 'enableIgnoreError' is used when upper card
* driver wants to ignore the error event to read/write all the data and not to stop read/write immediately when an
* error event happens. For example, bus testing procedure for MMC card.
*/
typedef struct _usdhc_data
{
bool enableAutoCommand12; /*!< Enable auto CMD12. */
bool enableAutoCommand23; /*!< Enable auto CMD23. */
bool enableIgnoreError; /*!< Enable to ignore error event to read/write all the data. */
uint8_t dataType; /*!< this is used to distinguish the normal/tuning/boot data. */
size_t blockSize; /*!< Block size. */
uint32_t blockCount; /*!< Block count. */
uint32_t *rxData; /*!< Buffer to save data read. */
const uint32_t *txData; /*!< Data buffer to write. */
} usdhc_data_t;
/*!
* @brief Card command descriptor.
*
* Defines card command-related attribute.
*/
typedef struct _usdhc_command
{
uint32_t index; /*!< Command index. */
uint32_t argument; /*!< Command argument. */
usdhc_card_command_type_t type; /*!< Command type. */
usdhc_card_response_type_t responseType; /*!< Command response type. */
uint32_t response[4U]; /*!< Response for this command. */
uint32_t responseErrorFlags; /*!< Response error flag, which need to check
the command reponse. */
uint32_t flags; /*!< Cmd flags. */
} usdhc_command_t;
/*! @brief ADMA configuration. */
typedef struct _usdhc_adma_config
{
usdhc_dma_mode_t dmaMode; /*!< DMA mode. */
#if !(defined(FSL_FEATURE_USDHC_HAS_NO_RW_BURST_LEN) && FSL_FEATURE_USDHC_HAS_NO_RW_BURST_LEN)
usdhc_burst_len_t burstLen; /*!< Burst len config. */
#endif
uint32_t *admaTable; /*!< ADMA table address, can't be null if transfer way is ADMA1/ADMA2. */
uint32_t admaTableWords; /*!< ADMA table length united as words, can't be 0 if transfer way is ADMA1/ADMA2. */
} usdhc_adma_config_t;
/*! @brief Transfer state. */
typedef struct _usdhc_transfer
{
usdhc_data_t *data; /*!< Data to transfer. */
usdhc_command_t *command; /*!< Command to send. */
} usdhc_transfer_t;
/*! @brief USDHC handle typedef. */
typedef struct _usdhc_handle usdhc_handle_t;
/*! @brief USDHC callback functions. */
typedef struct _usdhc_transfer_callback
{
void (*CardInserted)(USDHC_Type *base,
void *userData); /*!< Card inserted occurs when DAT3/CD pin is for card detect */
void (*CardRemoved)(USDHC_Type *base, void *userData); /*!< Card removed occurs */
void (*SdioInterrupt)(USDHC_Type *base, void *userData); /*!< SDIO card interrupt occurs */
void (*BlockGap)(USDHC_Type *base, void *userData); /*!< stopped at block gap event */
void (*TransferComplete)(USDHC_Type *base,
usdhc_handle_t *handle,
status_t status,
void *userData); /*!< Transfer complete callback. */
void (*ReTuning)(USDHC_Type *base, void *userData); /*!< Handle the re-tuning. */
} usdhc_transfer_callback_t;
/*!
* @brief USDHC handle.
*
* Defines the structure to save the USDHC state information and callback function.
*
* @note All the fields except interruptFlags and transferredWords must be allocated by the user.
*/
struct _usdhc_handle
{
usdhc_data_t *volatile data; /*!< Transfer parameter. Data to transfer. */
usdhc_command_t *volatile command; /*!< Transfer parameter. Command to send. */
volatile uint32_t transferredWords; /*!< Transfer status. Words transferred by DATAPORT way. */
usdhc_transfer_callback_t callback; /*!< Callback function. */
void *userData; /*!< Parameter for transfer complete callback. */
};
/*! @brief USDHC transfer function. */
typedef status_t (*usdhc_transfer_function_t)(USDHC_Type *base, usdhc_transfer_t *content);
/*! @brief USDHC host descriptor. */
typedef struct _usdhc_host
{
USDHC_Type *base; /*!< USDHC peripheral base address. */
uint32_t sourceClock_Hz; /*!< USDHC source clock frequency united in Hz. */
usdhc_config_t config; /*!< USDHC configuration. */
usdhc_capability_t capability; /*!< USDHC capability information. */
usdhc_transfer_function_t transfer; /*!< USDHC transfer function. */
} usdhc_host_t;
/*************************************************************************************************
* API
************************************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*!
* @name Initialization and deinitialization
* @{
*/
/*!
* @brief USDHC module initialization function.
*
* Configures the USDHC according to the user configuration.
*
* Example:
@code
usdhc_config_t config;
config.cardDetectDat3 = false;
config.endianMode = kUSDHC_EndianModeLittle;
config.dmaMode = kUSDHC_DmaModeAdma2;
config.readWatermarkLevel = 128U;
config.writeWatermarkLevel = 128U;
USDHC_Init(USDHC, &config);
@endcode
*
* @param base USDHC peripheral base address.
* @param config USDHC configuration information.
* @retval #kStatus_Success Operate successfully.
*/
void USDHC_Init(USDHC_Type *base, const usdhc_config_t *config);
/*!
* @brief Deinitializes the USDHC.
*
* @param base USDHC peripheral base address.
*/
void USDHC_Deinit(USDHC_Type *base);
/*!
* @brief Resets the USDHC.
*
* @param base USDHC peripheral base address.
* @param mask The reset type mask(@ref _usdhc_reset).
* @param timeout Timeout for reset.
* @retval true Reset successfully.
* @retval false Reset failed.
*/
bool USDHC_Reset(USDHC_Type *base, uint32_t mask, uint32_t timeout);
/* @} */
/*!
* @name DMA Control
* @{
*/
/*!
* @brief Sets the DMA descriptor table configuration.
* A high level DMA descriptor configuration function.
* @param base USDHC peripheral base address.
* @param dmaConfig ADMA configuration
* @param dataConfig Data descriptor
* @param flags ADAM descriptor flag, used to indicate to create multiple or single descriptor, please
* refer to enum @ref _usdhc_adma_flag.
* @retval #kStatus_OutOfRange ADMA descriptor table length isn't enough to describe data.
* @retval #kStatus_Success Operate successfully.
*/
status_t USDHC_SetAdmaTableConfig(USDHC_Type *base,
usdhc_adma_config_t *dmaConfig,
usdhc_data_t *dataConfig,
uint32_t flags);
/*!
* @brief Internal DMA configuration.
* This function is used to config the USDHC DMA related registers.
* @param base USDHC peripheral base address.
* @param dmaConfig ADMA configuration.
* @param dataAddr Transfer data address, a simple DMA parameter, if ADMA is used, leave it to NULL.
* @param enAutoCmd23 Flag to indicate Auto CMD23 is enable or not, a simple DMA parameter, if ADMA is used, leave it
* to false.
* @retval #kStatus_OutOfRange ADMA descriptor table length isn't enough to describe data.
* @retval #kStatus_Success Operate successfully.
*/
status_t USDHC_SetInternalDmaConfig(USDHC_Type *base,
usdhc_adma_config_t *dmaConfig,
const uint32_t *dataAddr,
bool enAutoCmd23);
/*!
* @brief Sets the ADMA2 descriptor table configuration.
*
* @param admaTable ADMA table address.
* @param admaTableWords ADMA table length.
* @param dataBufferAddr Data buffer address.
* @param dataBytes Data Data length.
* @param flags ADAM descriptor flag, used to indicate to create multiple or single descriptor, please
* refer to enum @ref _usdhc_adma_flag.
* @retval #kStatus_OutOfRange ADMA descriptor table length isn't enough to describe data.
* @retval #kStatus_Success Operate successfully.
*/
status_t USDHC_SetADMA2Descriptor(
uint32_t *admaTable, uint32_t admaTableWords, const uint32_t *dataBufferAddr, uint32_t dataBytes, uint32_t flags);
/*!
* @brief Sets the ADMA1 descriptor table configuration.
*
* @param admaTable ADMA table address.
* @param admaTableWords ADMA table length.
* @param dataBufferAddr Data buffer address.
* @param dataBytes Data length.
* @param flags ADAM descriptor flag, used to indicate to create multiple or single descriptor, please
* refer to enum @ref _usdhc_adma_flag.
* @retval #kStatus_OutOfRange ADMA descriptor table length isn't enough to describe data.
* @retval #kStatus_Success Operate successfully.
*/
status_t USDHC_SetADMA1Descriptor(
uint32_t *admaTable, uint32_t admaTableWords, const uint32_t *dataBufferAddr, uint32_t dataBytes, uint32_t flags);
/*!
* @brief Enables internal DMA.
*
* @param base USDHC peripheral base address.
* @param enable enable or disable flag
*/
static inline void USDHC_EnableInternalDMA(USDHC_Type *base, bool enable)
{
if (enable)
{
base->MIX_CTRL |= USDHC_MIX_CTRL_DMAEN_MASK;
}
else
{
base->MIX_CTRL &= ~USDHC_MIX_CTRL_DMAEN_MASK;
base->PROT_CTRL &= ~USDHC_PROT_CTRL_DMASEL_MASK;
}
}
/* @} */
/*!
* @name Interrupts
* @{
*/
/*!
* @brief Enables the interrupt status.
*
* @param base USDHC peripheral base address.
* @param mask Interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline void USDHC_EnableInterruptStatus(USDHC_Type *base, uint32_t mask)
{
base->INT_STATUS_EN |= mask;
}
/*!
* @brief Disables the interrupt status.
*
* @param base USDHC peripheral base address.
* @param mask The interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline void USDHC_DisableInterruptStatus(USDHC_Type *base, uint32_t mask)
{
base->INT_STATUS_EN &= ~mask;
}
/*!
* @brief Enables the interrupt signal corresponding to the interrupt status flag.
*
* @param base USDHC peripheral base address.
* @param mask The interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline void USDHC_EnableInterruptSignal(USDHC_Type *base, uint32_t mask)
{
base->INT_SIGNAL_EN |= mask;
}
/*!
* @brief Disables the interrupt signal corresponding to the interrupt status flag.
*
* @param base USDHC peripheral base address.
* @param mask The interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline void USDHC_DisableInterruptSignal(USDHC_Type *base, uint32_t mask)
{
base->INT_SIGNAL_EN &= ~mask;
}
/* @} */
/*!
* @name Status
* @{
*/
/*!
* @brief Gets the enabled interrupt status.
*
* @param base USDHC peripheral base address.
* @return Current interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline uint32_t USDHC_GetEnabledInterruptStatusFlags(USDHC_Type *base)
{
uint32_t intStatus = base->INT_STATUS;
return intStatus & base->INT_SIGNAL_EN;
}
/*!
* @brief Gets the current interrupt status.
*
* @param base USDHC peripheral base address.
* @return Current interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline uint32_t USDHC_GetInterruptStatusFlags(USDHC_Type *base)
{
return base->INT_STATUS;
}
/*!
* @brief Clears a specified interrupt status.
* write 1 clears
* @param base USDHC peripheral base address.
* @param mask The interrupt status flags mask(@ref _usdhc_interrupt_status_flag).
*/
static inline void USDHC_ClearInterruptStatusFlags(USDHC_Type *base, uint32_t mask)
{
base->INT_STATUS = mask;
}
/*!
* @brief Gets the status of auto command 12 error.
*
* @param base USDHC peripheral base address.
* @return Auto command 12 error status flags mask(@ref _usdhc_auto_command12_error_status_flag).
*/
static inline uint32_t USDHC_GetAutoCommand12ErrorStatusFlags(USDHC_Type *base)
{
return base->AUTOCMD12_ERR_STATUS;
}
/*!
* @brief Gets the status of the ADMA error.
*
* @param base USDHC peripheral base address.
* @return ADMA error status flags mask(@ref _usdhc_adma_error_status_flag).
*/
static inline uint32_t USDHC_GetAdmaErrorStatusFlags(USDHC_Type *base)
{
return base->ADMA_ERR_STATUS & 0xFUL;
}
/*!
* @brief Gets a present status.
*
* This function gets the present USDHC's status except for an interrupt status and an error status.
*
* @param base USDHC peripheral base address.
* @return Present USDHC's status flags mask(@ref _usdhc_present_status_flag).
*/
static inline uint32_t USDHC_GetPresentStatusFlags(USDHC_Type *base)
{
return base->PRES_STATE;
}
/* @} */
/*!
* @name Bus Operations
* @{
*/
/*!
* @brief Gets the capability information.
*
* @param base USDHC peripheral base address.
* @param capability Structure to save capability information.
*/
void USDHC_GetCapability(USDHC_Type *base, usdhc_capability_t *capability);
/*!
* @brief Forces the card clock on.
*
* @param base USDHC peripheral base address.
* @param enable enable/disable flag
*/
static inline void USDHC_ForceClockOn(USDHC_Type *base, bool enable)
{
if (enable)
{
base->VEND_SPEC |= USDHC_VEND_SPEC_FRC_SDCLK_ON_MASK;
}
else
{
base->VEND_SPEC &= ~USDHC_VEND_SPEC_FRC_SDCLK_ON_MASK;
}
}
/*!
* @brief Sets the SD bus clock frequency.
*
* @param base USDHC peripheral base address.
* @param srcClock_Hz USDHC source clock frequency united in Hz.
* @param busClock_Hz SD bus clock frequency united in Hz.
*
* @return The nearest frequency of busClock_Hz configured for SD bus.
*/
uint32_t USDHC_SetSdClock(USDHC_Type *base, uint32_t srcClock_Hz, uint32_t busClock_Hz);
/*!
* @brief Sends 80 clocks to the card to set it to the active state.
*
* This function must be called each time the card is inserted to ensure that the card can receive the command
* correctly.
*
* @param base USDHC peripheral base address.
* @param timeout Timeout to initialize card.
* @retval true Set card active successfully.
* @retval false Set card active failed.
*/
bool USDHC_SetCardActive(USDHC_Type *base, uint32_t timeout);
/*!
* @brief Triggers a hardware reset.
*
* @param base USDHC peripheral base address.
* @param high 1 or 0 level
*/
static inline void USDHC_AssertHardwareReset(USDHC_Type *base, bool high)
{
if (high)
{
base->SYS_CTRL |= USDHC_SYS_CTRL_IPP_RST_N_MASK;
}
else
{
base->SYS_CTRL &= ~USDHC_SYS_CTRL_IPP_RST_N_MASK;
}
}
/*!
* @brief Sets the data transfer width.
*
* @param base USDHC peripheral base address.
* @param width Data transfer width.
*/
static inline void USDHC_SetDataBusWidth(USDHC_Type *base, usdhc_data_bus_width_t width)
{
base->PROT_CTRL = ((base->PROT_CTRL & ~USDHC_PROT_CTRL_DTW_MASK) | USDHC_PROT_CTRL_DTW(width));
}
/*!
* @brief Fills the data port.
*
* This function is used to implement the data transfer by Data Port instead of DMA.
*
* @param base USDHC peripheral base address.
* @param data The data about to be sent.
*/
static inline void USDHC_WriteData(USDHC_Type *base, uint32_t data)
{
base->DATA_BUFF_ACC_PORT = data;
}
/*!
* @brief Retrieves the data from the data port.
*
* This function is used to implement the data transfer by Data Port instead of DMA.
*
* @param base USDHC peripheral base address.
* @return The data has been read.
*/
static inline uint32_t USDHC_ReadData(USDHC_Type *base)
{
return base->DATA_BUFF_ACC_PORT;
}
/*!
* @brief Sends command function.
*
* @param base USDHC peripheral base address.
* @param command configuration
*/
void USDHC_SendCommand(USDHC_Type *base, usdhc_command_t *command);
/*!
* @brief Enables or disables a wakeup event in low-power mode.
*
* @param base USDHC peripheral base address.
* @param mask Wakeup events mask(@ref _usdhc_wakeup_event).
* @param enable True to enable, false to disable.
*/
static inline void USDHC_EnableWakeupEvent(USDHC_Type *base, uint32_t mask, bool enable)
{
if (enable)
{
base->PROT_CTRL |= mask;
}
else
{
base->PROT_CTRL &= ~mask;
}
}
/*!
* @brief Detects card insert status.
*
* @param base USDHC peripheral base address.
* @param enable enable/disable flag
*/
static inline void USDHC_CardDetectByData3(USDHC_Type *base, bool enable)
{
if (enable)
{
base->PROT_CTRL |= USDHC_PROT_CTRL_D3CD_MASK;
}
else
{
base->PROT_CTRL &= ~USDHC_PROT_CTRL_D3CD_MASK;
}
}
/*!
* @brief Detects card insert status.
*
* @param base USDHC peripheral base address.
*/
static inline bool USDHC_DetectCardInsert(USDHC_Type *base)
{
return ((base->PRES_STATE & (uint32_t)kUSDHC_CardInsertedFlag) != 0UL) ? true : false;
}
/*!
* @brief Enables or disables the SDIO card control.
*
* @param base USDHC peripheral base address.
* @param mask SDIO card control flags mask(@ref _usdhc_sdio_control_flag).
* @param enable True to enable, false to disable.
*/
static inline void USDHC_EnableSdioControl(USDHC_Type *base, uint32_t mask, bool enable)
{
if (enable)
{
base->PROT_CTRL |= mask;
}
else
{
base->PROT_CTRL &= ~mask;
}
}
/*!
* @brief Restarts a transaction which has stopped at the block GAP for the SDIO card.
*
* @param base USDHC peripheral base address.
*/
static inline void USDHC_SetContinueRequest(USDHC_Type *base)
{
base->PROT_CTRL |= USDHC_PROT_CTRL_CREQ_MASK;
}
/*!
* @brief Request stop at block gap function.
*
* @param base USDHC peripheral base address.
* @param enable True to stop at block gap, false to normal transfer.
*/
static inline void USDHC_RequestStopAtBlockGap(USDHC_Type *base, bool enable)
{
if (enable)
{
base->PROT_CTRL |= USDHC_PROT_CTRL_SABGREQ_MASK;
}
else
{
base->PROT_CTRL &= ~USDHC_PROT_CTRL_SABGREQ_MASK;
}
}
/*!
* @brief Configures the MMC boot feature.
*
* Example:
@code
usdhc_boot_config_t config;
config.ackTimeoutCount = 4;
config.bootMode = kUSDHC_BootModeNormal;
config.blockCount = 5;
config.enableBootAck = true;
config.enableBoot = true;
config.enableAutoStopAtBlockGap = true;
USDHC_SetMmcBootConfig(USDHC, &config);
@endcode
*
* @param base USDHC peripheral base address.
* @param config The MMC boot configuration information.
*/
void USDHC_SetMmcBootConfig(USDHC_Type *base, const usdhc_boot_config_t *config);
/*!
* @brief Enables or disables the mmc boot mode.
*
* @param base USDHC peripheral base address.
* @param enable True to enable, false to disable.
*/
static inline void USDHC_EnableMmcBoot(USDHC_Type *base, bool enable)
{
if (enable)
{
base->MMC_BOOT |= USDHC_MMC_BOOT_BOOT_EN_MASK;
}
else
{
base->MMC_BOOT &= ~USDHC_MMC_BOOT_BOOT_EN_MASK;
}
}
/*!
* @brief Forces generating events according to the given mask.
*
* @param base USDHC peripheral base address.
* @param mask The force events bit posistion (_usdhc_force_event).
*/
static inline void USDHC_SetForceEvent(USDHC_Type *base, uint32_t mask)
{
base->FORCE_EVENT = mask;
}
/*!
* @brief Selects the USDHC output voltage.
*
* @param base USDHC peripheral base address.
* @param en18v True means 1.8V, false means 3.0V.
*/
static inline void UDSHC_SelectVoltage(USDHC_Type *base, bool en18v)
{
if (en18v)
{
base->VEND_SPEC |= USDHC_VEND_SPEC_VSELECT_MASK;
}
else
{
base->VEND_SPEC &= ~USDHC_VEND_SPEC_VSELECT_MASK;
}
}
#if defined(FSL_FEATURE_USDHC_HAS_SDR50_MODE) && (FSL_FEATURE_USDHC_HAS_SDR50_MODE)
/*!
* @brief Checks the SDR50 mode request tuning bit.
* When this bit set, application shall perform tuning for SDR50 mode.
* @param base USDHC peripheral base address.
*/
static inline bool USDHC_RequestTuningForSDR50(USDHC_Type *base)
{
return ((base->HOST_CTRL_CAP & USDHC_HOST_CTRL_CAP_USE_TUNING_SDR50_MASK) != 0UL) ? true : false;
}
/*!
* @brief Checks the request re-tuning bit.
* When this bit is set, user should do manual tuning or standard tuning function.
* @param base USDHC peripheral base address.
*/
static inline bool USDHC_RequestReTuning(USDHC_Type *base)
{
return ((base->PRES_STATE & USDHC_PRES_STATE_RTR_MASK) != 0UL) ? true : false;
}
/*!
* @brief The SDR104 mode auto tuning enable and disable.
* This function should be called after tuning function execute pass, auto tuning will handle
* by hardware.
* @param base USDHC peripheral base address.
* @param enable enable/disable flag
*/
static inline void USDHC_EnableAutoTuning(USDHC_Type *base, bool enable)
{
if (enable)
{
base->MIX_CTRL |= USDHC_MIX_CTRL_AUTO_TUNE_EN_MASK;
}
else
{
base->MIX_CTRL &= ~USDHC_MIX_CTRL_AUTO_TUNE_EN_MASK;
}
}
/*!
* @brief Configs the re-tuning timer for mode 1 and mode 3.
* This timer is used for standard tuning auto re-tuning,
* @param base USDHC peripheral base address.
* @param counter timer counter value
*/
static inline void USDHC_SetRetuningTimer(USDHC_Type *base, uint32_t counter)
{
base->HOST_CTRL_CAP &= ~USDHC_HOST_CTRL_CAP_TIME_COUNT_RETUNING_MASK;
base->HOST_CTRL_CAP |= USDHC_HOST_CTRL_CAP_TIME_COUNT_RETUNING(counter);
}
/*!
* @brief The auto tuning enbale for CMD/DATA line.
*
* @param base USDHC peripheral base address.
*/
void USDHC_EnableAutoTuningForCmdAndData(USDHC_Type *base);
/*!
* @brief Manual tuning trigger or abort.
* User should handle the tuning cmd and find the boundary of the delay
* then calucate a average value which will be configured to the