| /* |
| * Copyright (c) 2016, Freescale Semiconductor, Inc. |
| * Copyright 2016-2017 NXP |
| * All rights reserved. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| |
| #include "fsl_usdhc.h" |
| #if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL |
| #include "fsl_cache.h" |
| #endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ |
| |
| /******************************************************************************* |
| * Definitions |
| ******************************************************************************/ |
| |
| /* Component ID definition, used by tools. */ |
| #ifndef FSL_COMPONENT_ID |
| #define FSL_COMPONENT_ID "platform.drivers.usdhc" |
| #endif |
| |
| /*! @brief Clock setting */ |
| /* Max SD clock divisor from base clock */ |
| #define USDHC_MAX_DVS ((USDHC_SYS_CTRL_DVS_MASK >> USDHC_SYS_CTRL_DVS_SHIFT) + 1U) |
| #define USDHC_MAX_CLKFS ((USDHC_SYS_CTRL_SDCLKFS_MASK >> USDHC_SYS_CTRL_SDCLKFS_SHIFT) + 1U) |
| #define USDHC_PREV_DVS(x) ((x) -= 1U) |
| #define USDHC_PREV_CLKFS(x, y) ((x) >>= (y)) |
| |
| /* Typedef for interrupt handler. */ |
| typedef void (*usdhc_isr_t)(USDHC_Type *base, usdhc_handle_t *handle); |
| /*! @brief Dummy data buffer for mmc boot mode */ |
| AT_NONCACHEABLE_SECTION_ALIGN(uint32_t s_usdhcBootDummy, USDHC_ADMA2_ADDRESS_ALIGN); |
| /******************************************************************************* |
| * Prototypes |
| ******************************************************************************/ |
| /*! |
| * @brief Get the instance. |
| * |
| * @param base USDHC peripheral base address. |
| * @return Instance number. |
| */ |
| static uint32_t USDHC_GetInstance(USDHC_Type *base); |
| |
| /*! |
| * @brief Set transfer interrupt. |
| * |
| * @param base USDHC peripheral base address. |
| * @param usingInterruptSignal True to use IRQ signal. |
| */ |
| static void USDHC_SetTransferInterrupt(USDHC_Type *base, bool usingInterruptSignal); |
| |
| /*! |
| * @brief Start transfer according to current transfer state |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be transferred. |
| * @param flag data present flag |
| * @param enDMA DMA enable flag |
| */ |
| static status_t USDHC_SetDataTransferConfig(USDHC_Type *base, |
| usdhc_data_t *data, |
| uint32_t *dataPresentFlag, |
| bool enDMA); |
| |
| /*! |
| * @brief Receive command response |
| * |
| * @param base USDHC peripheral base address. |
| * @param command Command to be sent. |
| */ |
| static status_t USDHC_ReceiveCommandResponse(USDHC_Type *base, usdhc_command_t *command); |
| |
| /*! |
| * @brief Read DATAPORT when buffer enable bit is set. |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be read. |
| * @param transferredWords The number of data words have been transferred last time transaction. |
| * @return The number of total data words have been transferred after this time transaction. |
| */ |
| static uint32_t USDHC_ReadDataPort(USDHC_Type *base, usdhc_data_t *data, uint32_t transferredWords); |
| |
| /*! |
| * @brief Read data by using DATAPORT polling way. |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be read. |
| * @retval kStatus_Fail Read DATAPORT failed. |
| * @retval kStatus_Success Operate successfully. |
| */ |
| static status_t USDHC_ReadByDataPortBlocking(USDHC_Type *base, usdhc_data_t *data); |
| |
| /*! |
| * @brief Write DATAPORT when buffer enable bit is set. |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be read. |
| * @param transferredWords The number of data words have been transferred last time. |
| * @return The number of total data words have been transferred after this time transaction. |
| */ |
| static uint32_t USDHC_WriteDataPort(USDHC_Type *base, usdhc_data_t *data, uint32_t transferredWords); |
| |
| /*! |
| * @brief Write data by using DATAPORT polling way. |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be transferred. |
| * @retval kStatus_Fail Write DATAPORT failed. |
| * @retval kStatus_Success Operate successfully. |
| */ |
| static status_t USDHC_WriteByDataPortBlocking(USDHC_Type *base, usdhc_data_t *data); |
| |
| /*! |
| * @brief Transfer data by polling way. |
| * |
| * @param base USDHC peripheral base address. |
| * @param data Data to be transferred. |
| * @param use DMA flag. |
| * @retval kStatus_Fail Transfer data failed. |
| * @retval kStatus_InvalidArgument Argument is invalid. |
| * @retval kStatus_Success Operate successfully. |
| */ |
| static status_t USDHC_TransferDataBlocking(USDHC_Type *base, usdhc_data_t *data, bool enDMA); |
| |
| /*! |
| * @brief Handle card detect interrupt. |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| * @param interruptFlags Card detect related interrupt flags. |
| */ |
| static void USDHC_TransferHandleCardDetect(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags); |
| |
| /*! |
| * @brief Handle command interrupt. |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| * @param interruptFlags Command related interrupt flags. |
| */ |
| static void USDHC_TransferHandleCommand(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags); |
| |
| /*! |
| * @brief Handle data interrupt. |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| * @param interruptFlags Data related interrupt flags. |
| */ |
| static void USDHC_TransferHandleData(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags); |
| |
| /*! |
| * @brief Handle SDIO card interrupt signal. |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| */ |
| static void USDHC_TransferHandleSdioInterrupt(USDHC_Type *base, usdhc_handle_t *handle); |
| |
| /*! |
| * @brief Handle SDIO block gap event. |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| */ |
| static void USDHC_TransferHandleBlockGap(USDHC_Type *base, usdhc_handle_t *handle); |
| |
| /*! |
| * @brief Handle retuning |
| * |
| * @param base USDHC peripheral base address. |
| * @param handle USDHC handle. |
| * @param interrupt flags |
| */ |
| static void USDHC_TransferHandleReTuning(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags); |
| |
| /*! |
| * @brief wait command done |
| * |
| * @param base USDHC peripheral base address. |
| * @param command configuration |
| * @param pollingCmdDone polling command done flag |
| */ |
| static status_t USDHC_WaitCommandDone(USDHC_Type *base, usdhc_command_t *command, bool pollingCmdDone); |
| |
| /******************************************************************************* |
| * Variables |
| ******************************************************************************/ |
| /*! @brief USDHC base pointer array */ |
| static USDHC_Type *const s_usdhcBase[] = USDHC_BASE_PTRS; |
| |
| /*! @brief USDHC internal handle pointer array */ |
| static usdhc_handle_t *s_usdhcHandle[ARRAY_SIZE(s_usdhcBase)] = {NULL}; |
| |
| /*! @brief USDHC IRQ name array */ |
| static const IRQn_Type s_usdhcIRQ[] = USDHC_IRQS; |
| |
| #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) |
| /*! @brief USDHC clock array name */ |
| static const clock_ip_name_t s_usdhcClock[] = USDHC_CLOCKS; |
| #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ |
| |
| /* USDHC ISR for transactional APIs. */ |
| static usdhc_isr_t s_usdhcIsr; |
| |
| /******************************************************************************* |
| * Code |
| ******************************************************************************/ |
| static uint32_t USDHC_GetInstance(USDHC_Type *base) |
| { |
| uint8_t instance = 0; |
| |
| while ((instance < ARRAY_SIZE(s_usdhcBase)) && (s_usdhcBase[instance] != base)) |
| { |
| instance++; |
| } |
| |
| assert(instance < ARRAY_SIZE(s_usdhcBase)); |
| |
| return instance; |
| } |
| |
| static void USDHC_SetTransferInterrupt(USDHC_Type *base, bool usingInterruptSignal) |
| { |
| uint32_t interruptEnabled; /* The Interrupt status flags to be enabled */ |
| |
| /* Disable all interrupts */ |
| USDHC_DisableInterruptStatus(base, (uint32_t)kUSDHC_AllInterruptFlags); |
| USDHC_DisableInterruptSignal(base, (uint32_t)kUSDHC_AllInterruptFlags); |
| DisableIRQ(s_usdhcIRQ[USDHC_GetInstance(base)]); |
| |
| interruptEnabled = (kUSDHC_CommandFlag | kUSDHC_CardInsertionFlag | kUSDHC_DataFlag | kUSDHC_CardRemovalFlag | |
| kUSDHC_SDR104TuningFlag | kUSDHC_BlockGapEventFlag); |
| |
| USDHC_EnableInterruptStatus(base, interruptEnabled); |
| |
| if (usingInterruptSignal) |
| { |
| USDHC_EnableInterruptSignal(base, interruptEnabled); |
| } |
| } |
| |
| static status_t USDHC_SetDataTransferConfig(USDHC_Type *base, usdhc_data_t *data, uint32_t *dataPresentFlag, bool enDMA) |
| { |
| uint32_t mixCtrl = base->MIX_CTRL; |
| |
| if (data != NULL) |
| { |
| /* if transfer boot continous, only need set the CREQ bit, leave others as it is */ |
| if (data->dataType == kUSDHC_TransferDataBootcontinous) |
| { |
| /* clear stop at block gap request */ |
| base->PROT_CTRL &= ~USDHC_PROT_CTRL_SABGREQ_MASK; |
| /* continous transfer data */ |
| base->PROT_CTRL |= USDHC_PROT_CTRL_CREQ_MASK; |
| return kStatus_Success; |
| } |
| |
| /* check data inhibit flag */ |
| if (base->PRES_STATE & kUSDHC_DataInhibitFlag) |
| { |
| return kStatus_USDHC_BusyTransferring; |
| } |
| /* check transfer block count */ |
| if ((data->blockCount > USDHC_MAX_BLOCK_COUNT) || ((data->txData == NULL) && (data->rxData == NULL))) |
| { |
| return kStatus_InvalidArgument; |
| } |
| |
| /* config mix parameter */ |
| mixCtrl &= ~(USDHC_MIX_CTRL_MSBSEL_MASK | USDHC_MIX_CTRL_BCEN_MASK | USDHC_MIX_CTRL_DTDSEL_MASK | |
| USDHC_MIX_CTRL_AC12EN_MASK); |
| |
| if (data->rxData) |
| { |
| mixCtrl |= USDHC_MIX_CTRL_DTDSEL_MASK; |
| } |
| if (data->blockCount > 1U) |
| { |
| mixCtrl |= USDHC_MIX_CTRL_MSBSEL_MASK | USDHC_MIX_CTRL_BCEN_MASK; |
| /* auto command 12 */ |
| if (data->enableAutoCommand12) |
| { |
| mixCtrl |= USDHC_MIX_CTRL_AC12EN_MASK; |
| } |
| } |
| |
| /* auto command 23, auto send set block count cmd before multiple read/write */ |
| if ((data->enableAutoCommand23)) |
| { |
| mixCtrl |= USDHC_MIX_CTRL_AC23EN_MASK; |
| base->VEND_SPEC2 |= USDHC_VEND_SPEC2_ACMD23_ARGU2_EN_MASK; |
| /* config the block count to DS_ADDR */ |
| base->DS_ADDR = data->blockCount; |
| } |
| else |
| { |
| mixCtrl &= ~USDHC_MIX_CTRL_AC23EN_MASK; |
| base->VEND_SPEC2 &= ~USDHC_VEND_SPEC2_ACMD23_ARGU2_EN_MASK; |
| } |
| |
| /* if transfer boot data, leave the block count to USDHC_SetMmcBootConfig function */ |
| if (data->dataType != kUSDHC_TransferDataBoot) |
| { |
| /* config data block size/block count */ |
| base->BLK_ATT = ((base->BLK_ATT & ~(USDHC_BLK_ATT_BLKSIZE_MASK | USDHC_BLK_ATT_BLKCNT_MASK)) | |
| (USDHC_BLK_ATT_BLKSIZE(data->blockSize) | USDHC_BLK_ATT_BLKCNT(data->blockCount))); |
| } |
| else |
| { |
| mixCtrl |= USDHC_MIX_CTRL_MSBSEL_MASK | USDHC_MIX_CTRL_BCEN_MASK; |
| base->PROT_CTRL |= USDHC_PROT_CTRL_RD_DONE_NO_8CLK_MASK; |
| } |
| |
| /* data present flag */ |
| *dataPresentFlag |= kUSDHC_DataPresentFlag; |
| /* Disable useless interrupt */ |
| if (enDMA) |
| { |
| base->INT_SIGNAL_EN &= ~(kUSDHC_BufferWriteReadyFlag | kUSDHC_BufferReadReadyFlag | kUSDHC_DmaCompleteFlag); |
| base->INT_STATUS_EN &= ~(kUSDHC_BufferWriteReadyFlag | kUSDHC_BufferReadReadyFlag | kUSDHC_DmaCompleteFlag); |
| } |
| else |
| { |
| base->INT_SIGNAL_EN |= kUSDHC_BufferWriteReadyFlag | kUSDHC_BufferReadReadyFlag; |
| base->INT_STATUS_EN |= kUSDHC_BufferWriteReadyFlag | kUSDHC_BufferReadReadyFlag; |
| } |
| } |
| else |
| { |
| /* clear data flags */ |
| mixCtrl &= ~(USDHC_MIX_CTRL_MSBSEL_MASK | USDHC_MIX_CTRL_BCEN_MASK | USDHC_MIX_CTRL_DTDSEL_MASK | |
| USDHC_MIX_CTRL_AC12EN_MASK | USDHC_MIX_CTRL_AC23EN_MASK); |
| |
| if (base->PRES_STATE & kUSDHC_CommandInhibitFlag) |
| { |
| return kStatus_USDHC_BusyTransferring; |
| } |
| } |
| |
| /* config the mix parameter */ |
| base->MIX_CTRL = mixCtrl; |
| |
| return kStatus_Success; |
| } |
| |
| static status_t USDHC_ReceiveCommandResponse(USDHC_Type *base, usdhc_command_t *command) |
| { |
| uint32_t i; |
| |
| if (command->responseType != kCARD_ResponseTypeNone) |
| { |
| command->response[0U] = base->CMD_RSP0; |
| if (command->responseType == kCARD_ResponseTypeR2) |
| { |
| command->response[1U] = base->CMD_RSP1; |
| command->response[2U] = base->CMD_RSP2; |
| command->response[3U] = base->CMD_RSP3; |
| |
| i = 4U; |
| /* R3-R2-R1-R0(lowest 8 bit is invalid bit) has the same format as R2 format in SD specification document |
| after removed internal CRC7 and end bit. */ |
| do |
| { |
| command->response[i - 1U] <<= 8U; |
| if (i > 1U) |
| { |
| command->response[i - 1U] |= ((command->response[i - 2U] & 0xFF000000U) >> 24U); |
| } |
| } while (i--); |
| } |
| } |
| /* check response error flag */ |
| if ((command->responseErrorFlags != 0U) && |
| ((command->responseType == kCARD_ResponseTypeR1) || (command->responseType == kCARD_ResponseTypeR1b) || |
| (command->responseType == kCARD_ResponseTypeR6) || (command->responseType == kCARD_ResponseTypeR5))) |
| { |
| if (((command->responseErrorFlags) & (command->response[0U])) != 0U) |
| { |
| return kStatus_USDHC_SendCommandFailed; |
| } |
| } |
| |
| return kStatus_Success; |
| } |
| |
| static uint32_t USDHC_ReadDataPort(USDHC_Type *base, usdhc_data_t *data, uint32_t transferredWords) |
| { |
| uint32_t i; |
| uint32_t totalWords; |
| uint32_t wordsCanBeRead; /* The words can be read at this time. */ |
| uint32_t readWatermark = ((base->WTMK_LVL & USDHC_WTMK_LVL_RD_WML_MASK) >> USDHC_WTMK_LVL_RD_WML_SHIFT); |
| |
| /* If DMA is enable, do not need to polling data port */ |
| if ((base->MIX_CTRL & USDHC_MIX_CTRL_DMAEN_MASK) == 0U) |
| { |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (data->blockSize % sizeof(uint32_t) != 0U) |
| { |
| data->blockSize += |
| sizeof(uint32_t) - (data->blockSize % sizeof(uint32_t)); /* make the block size as word-aligned */ |
| } |
| |
| totalWords = ((data->blockCount * data->blockSize) / sizeof(uint32_t)); |
| |
| /* If watermark level is equal or bigger than totalWords, transfers totalWords data. */ |
| if (readWatermark >= totalWords) |
| { |
| wordsCanBeRead = totalWords; |
| } |
| /* If watermark level is less than totalWords and left words to be sent is equal or bigger than readWatermark, |
| transfers watermark level words. */ |
| else if ((readWatermark < totalWords) && ((totalWords - transferredWords) >= readWatermark)) |
| { |
| wordsCanBeRead = readWatermark; |
| } |
| /* If watermark level is less than totalWords and left words to be sent is less than readWatermark, transfers |
| left |
| words. */ |
| else |
| { |
| wordsCanBeRead = (totalWords - transferredWords); |
| } |
| |
| i = 0U; |
| while (i < wordsCanBeRead) |
| { |
| data->rxData[transferredWords++] = USDHC_ReadData(base); |
| i++; |
| } |
| } |
| |
| return transferredWords; |
| } |
| |
| static status_t USDHC_ReadByDataPortBlocking(USDHC_Type *base, usdhc_data_t *data) |
| { |
| uint32_t totalWords; |
| uint32_t transferredWords = 0U, interruptStatus = 0U; |
| status_t error = kStatus_Success; |
| |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (data->blockSize % sizeof(uint32_t) != 0U) |
| { |
| data->blockSize += |
| sizeof(uint32_t) - (data->blockSize % sizeof(uint32_t)); /* make the block size as word-aligned */ |
| } |
| |
| totalWords = ((data->blockCount * data->blockSize) / sizeof(uint32_t)); |
| |
| while ((error == kStatus_Success) && (transferredWords < totalWords)) |
| { |
| while (!(interruptStatus & (kUSDHC_BufferReadReadyFlag | kUSDHC_DataErrorFlag | kUSDHC_TuningErrorFlag))) |
| { |
| interruptStatus = USDHC_GetInterruptStatusFlags(base); |
| } |
| |
| /* during std tuning process, software do not need to read data, but wait BRR is enough */ |
| if ((data->dataType == kUSDHC_TransferDataTuning) && (interruptStatus & kUSDHC_BufferReadReadyFlag)) |
| { |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_BufferReadReadyFlag | kUSDHC_TuningPassFlag); |
| |
| return kStatus_Success; |
| } |
| else if ((interruptStatus & kUSDHC_TuningErrorFlag) != 0U) |
| { |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_TuningErrorFlag); |
| /* if tuning error occur ,return directly */ |
| error = kStatus_USDHC_TuningError; |
| } |
| else if ((interruptStatus & kUSDHC_DataErrorFlag) != 0U) |
| { |
| if (!(data->enableIgnoreError)) |
| { |
| error = kStatus_Fail; |
| } |
| /* clear data error flag */ |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_DataErrorFlag); |
| } |
| else |
| { |
| } |
| |
| if (error == kStatus_Success) |
| { |
| transferredWords = USDHC_ReadDataPort(base, data, transferredWords); |
| /* clear buffer read ready */ |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_BufferReadReadyFlag); |
| interruptStatus = 0U; |
| } |
| } |
| |
| /* Clear data complete flag after the last read operation. */ |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_DataCompleteFlag); |
| |
| return error; |
| } |
| |
| static uint32_t USDHC_WriteDataPort(USDHC_Type *base, usdhc_data_t *data, uint32_t transferredWords) |
| { |
| uint32_t i; |
| uint32_t totalWords; |
| uint32_t wordsCanBeWrote; /* Words can be wrote at this time. */ |
| uint32_t writeWatermark = ((base->WTMK_LVL & USDHC_WTMK_LVL_WR_WML_MASK) >> USDHC_WTMK_LVL_WR_WML_SHIFT); |
| |
| /* If DMA is enable, do not need to polling data port */ |
| if ((base->MIX_CTRL & USDHC_MIX_CTRL_DMAEN_MASK) == 0U) |
| { |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (data->blockSize % sizeof(uint32_t) != 0U) |
| { |
| data->blockSize += |
| sizeof(uint32_t) - (data->blockSize % sizeof(uint32_t)); /* make the block size as word-aligned */ |
| } |
| |
| totalWords = ((data->blockCount * data->blockSize) / sizeof(uint32_t)); |
| |
| /* If watermark level is equal or bigger than totalWords, transfers totalWords data.*/ |
| if (writeWatermark >= totalWords) |
| { |
| wordsCanBeWrote = totalWords; |
| } |
| /* If watermark level is less than totalWords and left words to be sent is equal or bigger than watermark, |
| transfers watermark level words. */ |
| else if ((writeWatermark < totalWords) && ((totalWords - transferredWords) >= writeWatermark)) |
| { |
| wordsCanBeWrote = writeWatermark; |
| } |
| /* If watermark level is less than totalWords and left words to be sent is less than watermark, transfers left |
| words. */ |
| else |
| { |
| wordsCanBeWrote = (totalWords - transferredWords); |
| } |
| |
| i = 0U; |
| while (i < wordsCanBeWrote) |
| { |
| USDHC_WriteData(base, data->txData[transferredWords++]); |
| i++; |
| } |
| } |
| |
| return transferredWords; |
| } |
| |
| static status_t USDHC_WriteByDataPortBlocking(USDHC_Type *base, usdhc_data_t *data) |
| { |
| uint32_t totalWords; |
| |
| uint32_t transferredWords = 0U, interruptStatus = 0U; |
| status_t error = kStatus_Success; |
| |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (data->blockSize % sizeof(uint32_t) != 0U) |
| { |
| data->blockSize += |
| sizeof(uint32_t) - (data->blockSize % sizeof(uint32_t)); /* make the block size as word-aligned */ |
| } |
| |
| totalWords = (data->blockCount * data->blockSize) / sizeof(uint32_t); |
| |
| while ((error == kStatus_Success) && (transferredWords < totalWords)) |
| { |
| while (!(interruptStatus & (kUSDHC_BufferWriteReadyFlag | kUSDHC_DataErrorFlag | kUSDHC_TuningErrorFlag))) |
| { |
| interruptStatus = USDHC_GetInterruptStatusFlags(base); |
| } |
| |
| if ((interruptStatus & kUSDHC_TuningErrorFlag) != 0U) |
| { |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_TuningErrorFlag); |
| /* if tuning error occur ,return directly */ |
| return kStatus_USDHC_TuningError; |
| } |
| else if ((interruptStatus & kUSDHC_DataErrorFlag) != 0U) |
| { |
| if (!(data->enableIgnoreError)) |
| { |
| error = kStatus_Fail; |
| } |
| /* clear data error flag */ |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_DataErrorFlag); |
| } |
| else |
| { |
| } |
| |
| if (error == kStatus_Success) |
| { |
| transferredWords = USDHC_WriteDataPort(base, data, transferredWords); |
| /* clear buffer write ready */ |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_BufferWriteReadyFlag); |
| interruptStatus = 0U; |
| } |
| } |
| |
| /* Wait write data complete or data transfer error after the last writing operation. */ |
| while (!(interruptStatus & (kUSDHC_DataCompleteFlag | kUSDHC_DataErrorFlag))) |
| { |
| interruptStatus = USDHC_GetInterruptStatusFlags(base); |
| } |
| |
| if ((interruptStatus & kUSDHC_DataErrorFlag) != 0U) |
| { |
| if (!(data->enableIgnoreError)) |
| { |
| error = kStatus_Fail; |
| } |
| } |
| USDHC_ClearInterruptStatusFlags(base, (kUSDHC_DataCompleteFlag | kUSDHC_DataErrorFlag)); |
| |
| return error; |
| } |
| |
| /*! |
| * brief send command function |
| * |
| * param base USDHC peripheral base address. |
| * param command configuration |
| */ |
| void USDHC_SendCommand(USDHC_Type *base, usdhc_command_t *command) |
| { |
| assert(NULL != command); |
| |
| uint32_t xferType = base->CMD_XFR_TYP, flags = command->flags; |
| |
| if (((base->PRES_STATE & kUSDHC_CommandInhibitFlag) == 0U) && (command->type != kCARD_CommandTypeEmpty)) |
| { |
| /* Define the flag corresponding to each response type. */ |
| switch (command->responseType) |
| { |
| case kCARD_ResponseTypeNone: |
| break; |
| case kCARD_ResponseTypeR1: /* Response 1 */ |
| case kCARD_ResponseTypeR5: /* Response 5 */ |
| case kCARD_ResponseTypeR6: /* Response 6 */ |
| case kCARD_ResponseTypeR7: /* Response 7 */ |
| flags |= (kUSDHC_ResponseLength48Flag | kUSDHC_EnableCrcCheckFlag | kUSDHC_EnableIndexCheckFlag); |
| break; |
| |
| case kCARD_ResponseTypeR1b: /* Response 1 with busy */ |
| case kCARD_ResponseTypeR5b: /* Response 5 with busy */ |
| flags |= (kUSDHC_ResponseLength48BusyFlag | kUSDHC_EnableCrcCheckFlag | kUSDHC_EnableIndexCheckFlag); |
| break; |
| |
| case kCARD_ResponseTypeR2: /* Response 2 */ |
| flags |= (kUSDHC_ResponseLength136Flag | kUSDHC_EnableCrcCheckFlag); |
| break; |
| |
| case kCARD_ResponseTypeR3: /* Response 3 */ |
| case kCARD_ResponseTypeR4: /* Response 4 */ |
| flags |= (kUSDHC_ResponseLength48Flag); |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (command->type == kCARD_CommandTypeAbort) |
| { |
| flags |= kUSDHC_CommandTypeAbortFlag; |
| } |
| |
| /* config cmd index */ |
| xferType &= ~(USDHC_CMD_XFR_TYP_CMDINX_MASK | USDHC_CMD_XFR_TYP_CMDTYP_MASK | USDHC_CMD_XFR_TYP_CICEN_MASK | |
| USDHC_CMD_XFR_TYP_CCCEN_MASK | USDHC_CMD_XFR_TYP_RSPTYP_MASK | USDHC_CMD_XFR_TYP_DPSEL_MASK); |
| |
| xferType |= |
| (((command->index << USDHC_CMD_XFR_TYP_CMDINX_SHIFT) & USDHC_CMD_XFR_TYP_CMDINX_MASK) | |
| ((flags) & (USDHC_CMD_XFR_TYP_CMDTYP_MASK | USDHC_CMD_XFR_TYP_CICEN_MASK | USDHC_CMD_XFR_TYP_CCCEN_MASK | |
| USDHC_CMD_XFR_TYP_RSPTYP_MASK | USDHC_CMD_XFR_TYP_DPSEL_MASK))); |
| |
| /* config the command xfertype and argument */ |
| base->CMD_ARG = command->argument; |
| base->CMD_XFR_TYP = xferType; |
| } |
| |
| if (command->type == kCARD_CommandTypeEmpty) |
| { |
| /* disable CMD done interrupt for empty command */ |
| base->INT_SIGNAL_EN &= ~USDHC_INT_SIGNAL_EN_CCIEN_MASK; |
| } |
| } |
| |
| static status_t USDHC_WaitCommandDone(USDHC_Type *base, usdhc_command_t *command, bool pollingCmdDone) |
| { |
| assert(NULL != command); |
| |
| status_t error = kStatus_Success; |
| uint32_t interruptStatus = 0U; |
| /* check if need polling command done or not */ |
| if (pollingCmdDone) |
| { |
| /* Wait command complete or USDHC encounters error. */ |
| while (!(interruptStatus & (kUSDHC_CommandCompleteFlag | kUSDHC_CommandErrorFlag))) |
| { |
| interruptStatus = USDHC_GetInterruptStatusFlags(base); |
| } |
| |
| if ((interruptStatus & kUSDHC_TuningErrorFlag) != 0U) |
| { |
| error = kStatus_USDHC_TuningError; |
| } |
| else if ((interruptStatus & kUSDHC_CommandErrorFlag) != 0U) |
| { |
| error = kStatus_Fail; |
| } |
| else |
| { |
| } |
| /* Receive response when command completes successfully. */ |
| if (error == kStatus_Success) |
| { |
| error = USDHC_ReceiveCommandResponse(base, command); |
| } |
| |
| USDHC_ClearInterruptStatusFlags( |
| base, (kUSDHC_CommandCompleteFlag | kUSDHC_CommandErrorFlag | kUSDHC_TuningErrorFlag)); |
| } |
| |
| return error; |
| } |
| |
| static status_t USDHC_TransferDataBlocking(USDHC_Type *base, usdhc_data_t *data, bool enDMA) |
| { |
| status_t error = kStatus_Success; |
| uint32_t interruptStatus = 0U; |
| |
| if (enDMA) |
| { |
| /* Wait data complete or USDHC encounters error. */ |
| while (!((interruptStatus & |
| (kUSDHC_DataCompleteFlag | kUSDHC_DataErrorFlag | kUSDHC_DmaErrorFlag | kUSDHC_TuningErrorFlag)))) |
| { |
| interruptStatus = USDHC_GetInterruptStatusFlags(base); |
| } |
| |
| if ((interruptStatus & kUSDHC_TuningErrorFlag) != 0U) |
| { |
| error = kStatus_USDHC_TuningError; |
| } |
| else if (((interruptStatus & (kUSDHC_DataErrorFlag | kUSDHC_DmaErrorFlag)) != 0U)) |
| { |
| if ((!(data->enableIgnoreError)) || (interruptStatus & kUSDHC_DataTimeoutFlag)) |
| { |
| error = kStatus_Fail; |
| } |
| } |
| else |
| { |
| } |
| /* load dummy data */ |
| if ((data->dataType == kUSDHC_TransferDataBootcontinous) && (error == kStatus_Success)) |
| { |
| *(data->rxData) = s_usdhcBootDummy; |
| } |
| |
| USDHC_ClearInterruptStatusFlags(base, (kUSDHC_DataCompleteFlag | kUSDHC_DataErrorFlag | kUSDHC_DmaErrorFlag | |
| kUSDHC_TuningPassFlag | kUSDHC_TuningErrorFlag)); |
| } |
| else |
| { |
| if (data->rxData) |
| { |
| error = USDHC_ReadByDataPortBlocking(base, data); |
| } |
| else |
| { |
| error = USDHC_WriteByDataPortBlocking(base, data); |
| } |
| } |
| |
| return error; |
| } |
| |
| /*! |
| * 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) |
| { |
| assert(config); |
| assert((config->writeWatermarkLevel >= 1U) && (config->writeWatermarkLevel <= 128U)); |
| assert((config->readWatermarkLevel >= 1U) && (config->readWatermarkLevel <= 128U)); |
| assert(config->writeBurstLen <= 16U); |
| |
| uint32_t proctl, sysctl, wml; |
| |
| #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) |
| /* Enable USDHC clock. */ |
| CLOCK_EnableClock(s_usdhcClock[USDHC_GetInstance(base)]); |
| #endif |
| |
| /* Reset USDHC. */ |
| USDHC_Reset(base, kUSDHC_ResetAll, 100U); |
| |
| proctl = base->PROT_CTRL; |
| wml = base->WTMK_LVL; |
| sysctl = base->SYS_CTRL; |
| |
| proctl &= ~(USDHC_PROT_CTRL_EMODE_MASK | USDHC_PROT_CTRL_DMASEL_MASK); |
| /* Endian mode*/ |
| proctl |= USDHC_PROT_CTRL_EMODE(config->endianMode); |
| |
| /* Watermark level */ |
| wml &= ~(USDHC_WTMK_LVL_RD_WML_MASK | USDHC_WTMK_LVL_WR_WML_MASK | USDHC_WTMK_LVL_RD_BRST_LEN_MASK | |
| USDHC_WTMK_LVL_WR_BRST_LEN_MASK); |
| wml |= (USDHC_WTMK_LVL_RD_WML(config->readWatermarkLevel) | USDHC_WTMK_LVL_WR_WML(config->writeWatermarkLevel) | |
| USDHC_WTMK_LVL_RD_BRST_LEN(config->readBurstLen) | USDHC_WTMK_LVL_WR_BRST_LEN(config->writeBurstLen)); |
| |
| /* config the data timeout value */ |
| sysctl &= ~USDHC_SYS_CTRL_DTOCV_MASK; |
| sysctl |= USDHC_SYS_CTRL_DTOCV(config->dataTimeout); |
| |
| base->SYS_CTRL = sysctl; |
| base->WTMK_LVL = wml; |
| base->PROT_CTRL = proctl; |
| |
| #if FSL_FEATURE_USDHC_HAS_EXT_DMA |
| /* disable external DMA */ |
| base->VEND_SPEC &= ~USDHC_VEND_SPEC_EXT_DMA_EN_MASK; |
| #endif |
| /* disable internal DMA and DDR mode */ |
| base->MIX_CTRL &= ~(USDHC_MIX_CTRL_DMAEN_MASK | USDHC_MIX_CTRL_DDR_EN_MASK); |
| /* Enable interrupt status but doesn't enable interrupt signal. */ |
| USDHC_SetTransferInterrupt(base, false); |
| } |
| |
| /*! |
| * brief Deinitializes the USDHC. |
| * |
| * param base USDHC peripheral base address. |
| */ |
| void USDHC_Deinit(USDHC_Type *base) |
| { |
| #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) |
| /* Disable clock. */ |
| CLOCK_DisableClock(s_usdhcClock[USDHC_GetInstance(base)]); |
| #endif |
| } |
| |
| /*! |
| * brief Resets the USDHC. |
| * |
| * param base USDHC peripheral base address. |
| * param mask The reset type mask(_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) |
| { |
| base->SYS_CTRL |= (mask & (USDHC_SYS_CTRL_RSTA_MASK | USDHC_SYS_CTRL_RSTC_MASK | USDHC_SYS_CTRL_RSTD_MASK)); |
| /* Delay some time to wait reset success. */ |
| while ((base->SYS_CTRL & mask) != 0U) |
| { |
| if (timeout == 0U) |
| { |
| break; |
| } |
| timeout--; |
| } |
| |
| return ((!timeout) ? false : true); |
| } |
| |
| /*! |
| * 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) |
| { |
| assert(capability); |
| |
| uint32_t htCapability; |
| uint32_t maxBlockLength; |
| |
| htCapability = base->HOST_CTRL_CAP; |
| |
| /* Get the capability of USDHC. */ |
| maxBlockLength = ((htCapability & USDHC_HOST_CTRL_CAP_MBL_MASK) >> USDHC_HOST_CTRL_CAP_MBL_SHIFT); |
| capability->maxBlockLength = (512U << maxBlockLength); |
| /* Other attributes not in HTCAPBLT register. */ |
| capability->maxBlockCount = USDHC_MAX_BLOCK_COUNT; |
| capability->flags = (htCapability & (kUSDHC_SupportAdmaFlag | kUSDHC_SupportHighSpeedFlag | kUSDHC_SupportDmaFlag | |
| kUSDHC_SupportSuspendResumeFlag | kUSDHC_SupportV330Flag)); |
| capability->flags |= (htCapability & kUSDHC_SupportV300Flag); |
| capability->flags |= (htCapability & kUSDHC_SupportV180Flag); |
| capability->flags |= |
| (htCapability & (kUSDHC_SupportDDR50Flag | kUSDHC_SupportSDR104Flag | kUSDHC_SupportSDR50Flag)); |
| /* USDHC support 4/8 bit data bus width. */ |
| capability->flags |= (kUSDHC_Support4BitFlag | kUSDHC_Support8BitFlag); |
| } |
| |
| /*! |
| * 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 to SD bus. |
| */ |
| uint32_t USDHC_SetSdClock(USDHC_Type *base, uint32_t srcClock_Hz, uint32_t busClock_Hz) |
| { |
| assert(srcClock_Hz != 0U); |
| assert((busClock_Hz != 0U) && (busClock_Hz <= srcClock_Hz)); |
| |
| uint32_t totalDiv = 0U; |
| uint32_t divisor = 0U; |
| uint32_t prescaler = 0U; |
| uint32_t sysctl = 0U; |
| uint32_t nearestFrequency = 0U; |
| |
| /* calucate total divisor first */ |
| if ((totalDiv = srcClock_Hz / busClock_Hz) > (USDHC_MAX_CLKFS * USDHC_MAX_DVS)) |
| { |
| return 0U; |
| } |
| |
| if (totalDiv != 0U) |
| { |
| /* calucate the divisor (srcClock_Hz / divisor) <= busClock_Hz */ |
| if ((srcClock_Hz / totalDiv) > busClock_Hz) |
| { |
| totalDiv++; |
| } |
| |
| /* divide the total divisor to div and prescaler */ |
| if (totalDiv > USDHC_MAX_DVS) |
| { |
| prescaler = totalDiv / USDHC_MAX_DVS; |
| /* prescaler must be a value which equal 2^n and smaller than SDHC_MAX_CLKFS */ |
| while (((USDHC_MAX_CLKFS % prescaler) != 0U) || (prescaler == 1U)) |
| { |
| prescaler++; |
| } |
| /* calucate the divisor */ |
| divisor = totalDiv / prescaler; |
| /* fine tuning the divisor until divisor * prescaler >= totalDiv */ |
| while ((divisor * prescaler) < totalDiv) |
| { |
| divisor++; |
| if (divisor > USDHC_MAX_DVS) |
| { |
| if ((prescaler <<= 1U) > USDHC_MAX_CLKFS) |
| { |
| return 0; |
| } |
| divisor = totalDiv / prescaler; |
| } |
| } |
| } |
| else |
| { |
| /* in this situation , divsior and SDCLKFS can generate same clock |
| use SDCLKFS*/ |
| if (((totalDiv % 2U) != 0U) & (totalDiv != 1U)) |
| { |
| divisor = totalDiv; |
| prescaler = 1U; |
| } |
| else |
| { |
| divisor = 1U; |
| prescaler = totalDiv; |
| } |
| } |
| nearestFrequency = srcClock_Hz / (divisor == 0U ? 1U : divisor) / prescaler; |
| } |
| /* in this condition , srcClock_Hz = busClock_Hz, */ |
| else |
| { |
| /* in DDR mode , set SDCLKFS to 0, divisor = 0, actually the |
| totoal divider = 2U */ |
| divisor = 0U; |
| prescaler = 0U; |
| nearestFrequency = srcClock_Hz; |
| } |
| |
| /* calucate the value write to register */ |
| if (divisor != 0U) |
| { |
| USDHC_PREV_DVS(divisor); |
| } |
| /* calucate the value write to register */ |
| if (prescaler != 0U) |
| { |
| USDHC_PREV_CLKFS(prescaler, 1U); |
| } |
| |
| /* Set the SD clock frequency divisor, SD clock frequency select, data timeout counter value. */ |
| sysctl = base->SYS_CTRL; |
| sysctl &= ~(USDHC_SYS_CTRL_DVS_MASK | USDHC_SYS_CTRL_SDCLKFS_MASK); |
| sysctl |= (USDHC_SYS_CTRL_DVS(divisor) | USDHC_SYS_CTRL_SDCLKFS(prescaler)); |
| base->SYS_CTRL = sysctl; |
| |
| /* Wait until the SD clock is stable. */ |
| while (!(base->PRES_STATE & USDHC_PRES_STATE_SDSTB_MASK)) |
| { |
| } |
| |
| return nearestFrequency; |
| } |
| |
| /*! |
| * 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) |
| { |
| base->SYS_CTRL |= USDHC_SYS_CTRL_INITA_MASK; |
| /* Delay some time to wait card become active state. */ |
| while ((base->SYS_CTRL & USDHC_SYS_CTRL_INITA_MASK) == USDHC_SYS_CTRL_INITA_MASK) |
| { |
| if (!timeout) |
| { |
| break; |
| } |
| timeout--; |
| } |
| |
| return ((!timeout) ? false : true); |
| } |
| |
| /*! |
| * brief the enable/disable DDR mode |
| * |
| * param base USDHC peripheral base address. |
| * param enable/disable flag |
| * param nibble position |
| */ |
| void USDHC_EnableDDRMode(USDHC_Type *base, bool enable, uint32_t nibblePos) |
| { |
| uint32_t prescaler = (base->SYS_CTRL & USDHC_SYS_CTRL_SDCLKFS_MASK) >> USDHC_SYS_CTRL_SDCLKFS_SHIFT; |
| |
| if (enable) |
| { |
| base->MIX_CTRL &= ~USDHC_MIX_CTRL_NIBBLE_POS_MASK; |
| base->MIX_CTRL |= (USDHC_MIX_CTRL_DDR_EN_MASK | USDHC_MIX_CTRL_NIBBLE_POS(nibblePos)); |
| prescaler >>= 1U; |
| } |
| else |
| { |
| base->MIX_CTRL &= ~USDHC_MIX_CTRL_DDR_EN_MASK; |
| |
| if (prescaler == 0U) |
| { |
| prescaler += 1U; |
| } |
| else |
| { |
| prescaler <<= 1U; |
| } |
| } |
| |
| base->SYS_CTRL = (base->SYS_CTRL & (~USDHC_SYS_CTRL_SDCLKFS_MASK)) | USDHC_SYS_CTRL_SDCLKFS(prescaler); |
| } |
| |
| /*! |
| * 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) |
| { |
| assert(config); |
| assert(config->ackTimeoutCount <= (USDHC_MMC_BOOT_DTOCV_ACK_MASK >> USDHC_MMC_BOOT_DTOCV_ACK_SHIFT)); |
| assert(config->blockCount <= (USDHC_MMC_BOOT_BOOT_BLK_CNT_MASK >> USDHC_MMC_BOOT_BOOT_BLK_CNT_SHIFT)); |
| |
| uint32_t mmcboot = base->MMC_BOOT; |
| |
| mmcboot &= ~(USDHC_MMC_BOOT_DTOCV_ACK_MASK | USDHC_MMC_BOOT_BOOT_MODE_MASK | USDHC_MMC_BOOT_BOOT_BLK_CNT_MASK); |
| mmcboot |= USDHC_MMC_BOOT_DTOCV_ACK(config->ackTimeoutCount) | USDHC_MMC_BOOT_BOOT_MODE(config->bootMode); |
| |
| if (config->enableBootAck) |
| { |
| mmcboot |= USDHC_MMC_BOOT_BOOT_ACK_MASK; |
| } |
| if (config->enableAutoStopAtBlockGap) |
| { |
| mmcboot |= |
| USDHC_MMC_BOOT_AUTO_SABG_EN_MASK | USDHC_MMC_BOOT_BOOT_BLK_CNT(USDHC_MAX_BLOCK_COUNT - config->blockCount); |
| /* always set the block count to USDHC_MAX_BLOCK_COUNT to use auto stop at block gap feature */ |
| base->BLK_ATT = ((base->BLK_ATT & ~(USDHC_BLK_ATT_BLKSIZE_MASK | USDHC_BLK_ATT_BLKCNT_MASK)) | |
| (USDHC_BLK_ATT_BLKSIZE(config->blockSize) | USDHC_BLK_ATT_BLKCNT(USDHC_MAX_BLOCK_COUNT))); |
| } |
| else |
| { |
| base->BLK_ATT = ((base->BLK_ATT & ~(USDHC_BLK_ATT_BLKSIZE_MASK | USDHC_BLK_ATT_BLKCNT_MASK)) | |
| (USDHC_BLK_ATT_BLKSIZE(config->blockSize) | USDHC_BLK_ATT_BLKCNT(config->blockCount))); |
| } |
| |
| base->MMC_BOOT = mmcboot; |
| } |
| |
| /*! |
| * 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 |
| * reference _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) |
| { |
| assert(NULL != admaTable); |
| assert(NULL != dataBufferAddr); |
| |
| uint32_t miniEntries, startEntries = 0U, |
| maxEntries = (admaTableWords * sizeof(uint32_t)) / sizeof(usdhc_adma1_descriptor_t); |
| usdhc_adma1_descriptor_t *adma1EntryAddress = (usdhc_adma1_descriptor_t *)(admaTable); |
| uint32_t i, dmaBufferLen = 0U; |
| const uint32_t *data = dataBufferAddr; |
| |
| if (((uint32_t)data % USDHC_ADMA1_ADDRESS_ALIGN) != 0U) |
| { |
| return kStatus_USDHC_DMADataAddrNotAlign; |
| } |
| |
| if (flags == kUSDHC_AdmaDescriptorMultipleFlag) |
| { |
| return kStatus_USDHC_NotSupport; |
| } |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (dataBytes % sizeof(uint32_t) != 0U) |
| { |
| /* make the data length as word-aligned */ |
| dataBytes += sizeof(uint32_t) - (dataBytes % sizeof(uint32_t)); |
| } |
| |
| /* Check if ADMA descriptor's number is enough. */ |
| if ((dataBytes % USDHC_ADMA1_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) == 0U) |
| { |
| miniEntries = dataBytes / USDHC_ADMA1_DESCRIPTOR_MAX_LENGTH_PER_ENTRY; |
| } |
| else |
| { |
| miniEntries = ((dataBytes / USDHC_ADMA1_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) + 1U); |
| } |
| |
| /* ADMA1 needs two descriptors to finish a transfer */ |
| miniEntries <<= 1U; |
| |
| if (miniEntries + startEntries > maxEntries) |
| { |
| return kStatus_OutOfRange; |
| } |
| |
| for (i = startEntries; i < (miniEntries + startEntries); i += 2U) |
| { |
| if (dataBytes > USDHC_ADMA1_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) |
| { |
| dmaBufferLen = USDHC_ADMA1_DESCRIPTOR_MAX_LENGTH_PER_ENTRY; |
| } |
| else |
| { |
| dmaBufferLen = dataBytes; |
| } |
| |
| adma1EntryAddress[i] = (dmaBufferLen << USDHC_ADMA1_DESCRIPTOR_LENGTH_SHIFT); |
| adma1EntryAddress[i] |= kUSDHC_Adma1DescriptorTypeSetLength; |
| adma1EntryAddress[i + 1U] = (uint32_t)(data); |
| adma1EntryAddress[i + 1U] |= kUSDHC_Adma1DescriptorTypeTransfer; |
| data += dmaBufferLen / sizeof(uint32_t); |
| dataBytes -= dmaBufferLen; |
| } |
| /* the end of the descriptor */ |
| adma1EntryAddress[i - 1U] |= kUSDHC_Adma1DescriptorEndFlag; |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * 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 |
| * reference _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) |
| { |
| assert(NULL != admaTable); |
| assert(NULL != dataBufferAddr); |
| |
| uint32_t miniEntries, startEntries = 0U, |
| maxEntries = (admaTableWords * sizeof(uint32_t)) / sizeof(usdhc_adma2_descriptor_t); |
| usdhc_adma2_descriptor_t *adma2EntryAddress = (usdhc_adma2_descriptor_t *)(admaTable); |
| uint32_t i, dmaBufferLen = 0U; |
| const uint32_t *data = dataBufferAddr; |
| |
| if (((uint32_t)data % USDHC_ADMA2_ADDRESS_ALIGN) != 0U) |
| { |
| return kStatus_USDHC_DMADataAddrNotAlign; |
| } |
| /* |
| * Add non aligned access support ,user need make sure your buffer size is big |
| * enough to hold the data,in other words,user need make sure the buffer size |
| * is 4 byte aligned |
| */ |
| if (dataBytes % sizeof(uint32_t) != 0U) |
| { |
| /* make the data length as word-aligned */ |
| dataBytes += sizeof(uint32_t) - (dataBytes % sizeof(uint32_t)); |
| } |
| |
| /* Check if ADMA descriptor's number is enough. */ |
| if ((dataBytes % USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) == 0U) |
| { |
| miniEntries = dataBytes / USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY; |
| } |
| else |
| { |
| miniEntries = ((dataBytes / USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) + 1U); |
| } |
| /* calucate the start entry for multiple descriptor mode, ADMA engine is not stop, so update the descriptor |
| data adress and data size is enough */ |
| if (flags == kUSDHC_AdmaDescriptorMultipleFlag) |
| { |
| for (i = 0U; i < maxEntries; i++) |
| { |
| if ((adma2EntryAddress[i].attribute & kUSDHC_Adma2DescriptorValidFlag) == 0U) |
| { |
| break; |
| } |
| } |
| startEntries = i; |
| /* add one entry for dummy entry */ |
| miniEntries += 1U; |
| } |
| |
| if ((miniEntries + startEntries) > maxEntries) |
| { |
| return kStatus_OutOfRange; |
| } |
| |
| for (i = startEntries; i < (miniEntries + startEntries); i++) |
| { |
| if (dataBytes > USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY) |
| { |
| dmaBufferLen = USDHC_ADMA2_DESCRIPTOR_MAX_LENGTH_PER_ENTRY; |
| } |
| else |
| { |
| dmaBufferLen = (dataBytes == 0U ? sizeof(uint32_t) : |
| dataBytes); /* adma don't support 0 data length transfer descriptor */ |
| } |
| |
| /* Each descriptor for ADMA2 is 64-bit in length */ |
| adma2EntryAddress[i].address = (dataBytes == 0U) ? &s_usdhcBootDummy : data; |
| adma2EntryAddress[i].attribute = (dmaBufferLen << USDHC_ADMA2_DESCRIPTOR_LENGTH_SHIFT); |
| adma2EntryAddress[i].attribute |= |
| (dataBytes == 0U) ? 0U : (kUSDHC_Adma2DescriptorTypeTransfer | kUSDHC_Adma2DescriptorInterruptFlag); |
| data += (dmaBufferLen / sizeof(uint32_t)); |
| |
| if (dataBytes != 0U) |
| { |
| dataBytes -= dmaBufferLen; |
| } |
| } |
| |
| /* add a dummy valid ADMA descriptor for multiple descriptor mode, this is useful when transfer boot data, the ADMA |
| engine |
| will not stop at block gap */ |
| if (flags == kUSDHC_AdmaDescriptorMultipleFlag) |
| { |
| adma2EntryAddress[startEntries + 1U].attribute |= kUSDHC_Adma2DescriptorTypeTransfer; |
| } |
| else |
| { |
| /* set the end bit */ |
| adma2EntryAddress[i - 1U].attribute |= kUSDHC_Adma2DescriptorEndFlag; |
| } |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief Internal DMA configuration. |
| * This function is used to config the USDHC DMA related registers. |
| * param base USDHC peripheral base address. |
| * param adma configuration |
| * param dataAddr tranfer 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) |
| { |
| assert(dmaConfig); |
| assert(dataAddr); |
| |
| #if FSL_FEATURE_USDHC_HAS_EXT_DMA |
| /* disable the external DMA if support */ |
| base->VEND_SPEC &= ~USDHC_VEND_SPEC_EXT_DMA_EN_MASK; |
| #endif |
| |
| if (dmaConfig->dmaMode == kUSDHC_DmaModeSimple) |
| { |
| /* check DMA data buffer address align or not */ |
| if (((uint32_t)dataAddr % USDHC_ADMA2_ADDRESS_ALIGN) != 0U) |
| { |
| return kStatus_USDHC_DMADataAddrNotAlign; |
| } |
| /* in simple DMA mode if use auto CMD23, address should load to ADMA addr, |
| and block count should load to DS_ADDR*/ |
| if (enAutoCmd23) |
| { |
| base->ADMA_SYS_ADDR = (uint32_t)dataAddr; |
| } |
| else |
| { |
| base->DS_ADDR = (uint32_t)dataAddr; |
| } |
| } |
| else |
| { |
| /* When use ADMA, disable simple DMA */ |
| base->DS_ADDR = 0U; |
| base->ADMA_SYS_ADDR = (uint32_t)(dmaConfig->admaTable); |
| } |
| |
| /* select DMA mode and config the burst length */ |
| base->PROT_CTRL &= ~(USDHC_PROT_CTRL_DMASEL_MASK | USDHC_PROT_CTRL_BURST_LEN_EN_MASK); |
| base->PROT_CTRL |= USDHC_PROT_CTRL_DMASEL(dmaConfig->dmaMode) | USDHC_PROT_CTRL_BURST_LEN_EN(dmaConfig->burstLen); |
| /* enable DMA */ |
| base->MIX_CTRL |= USDHC_MIX_CTRL_DMAEN_MASK; |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief Sets the DMA descriptor table configuration. |
| * A high level DMA descriptor configuration function. |
| * param base USDHC peripheral base address. |
| * param adma configuration |
| * param data Data descriptor |
| * param flags ADAM descriptor flag, used to indicate to create multiple or single descriptor, please |
| * reference _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) |
| { |
| assert(NULL != dmaConfig); |
| assert(NULL != dmaConfig->admaTable); |
| assert(NULL != dataConfig); |
| |
| status_t error = kStatus_Fail; |
| uint32_t bootDummyOffset = dataConfig->dataType == kUSDHC_TransferDataBootcontinous ? sizeof(uint32_t) : 0U; |
| const uint32_t *data = |
| (const uint32_t *)((uint32_t)((dataConfig->rxData == NULL) ? dataConfig->txData : dataConfig->rxData) + |
| bootDummyOffset); |
| uint32_t blockSize = dataConfig->blockSize * dataConfig->blockCount - bootDummyOffset; |
| |
| switch (dmaConfig->dmaMode) |
| { |
| #if FSL_FEATURE_USDHC_HAS_EXT_DMA |
| case kUSDHC_ExternalDMA: |
| /* enable the external DMA */ |
| base->VEND_SPEC |= USDHC_VEND_SPEC_EXT_DMA_EN_MASK; |
| break; |
| #endif |
| case kUSDHC_DmaModeSimple: |
| error = kStatus_Success; |
| break; |
| |
| case kUSDHC_DmaModeAdma1: |
| error = USDHC_SetADMA1Descriptor(dmaConfig->admaTable, dmaConfig->admaTableWords, data, blockSize, flags); |
| break; |
| |
| case kUSDHC_DmaModeAdma2: |
| error = USDHC_SetADMA2Descriptor(dmaConfig->admaTable, dmaConfig->admaTableWords, data, blockSize, flags); |
| break; |
| default: |
| return kStatus_USDHC_PrepareAdmaDescriptorFailed; |
| } |
| |
| /* for internal dma, internal DMA configurations should not update the configurations when continous transfer the |
| * boot data, only the DMA descriptor need update */ |
| if ((dmaConfig->dmaMode != kUSDHC_ExternalDMA) && (error == kStatus_Success) && |
| (dataConfig->dataType != kUSDHC_TransferDataBootcontinous)) |
| { |
| error = USDHC_SetInternalDmaConfig(base, dmaConfig, data, dataConfig->enableAutoCommand23); |
| } |
| |
| return error; |
| } |
| |
| /*! |
| * brief Transfers the command/data using a blocking method. |
| * |
| * This function waits until the command response/data is received or the USDHC encounters an error by polling the |
| * status |
| * flag. |
| * The application must not call this API in multiple threads at the same time. Because of that this API doesn't support |
| * the re-entry mechanism. |
| * |
| * note There is no need to call the API 'USDHC_TransferCreateHandle' when calling this API. |
| * |
| * param base USDHC peripheral base address. |
| * param adma configuration |
| * param transfer Transfer content. |
| * retval kStatus_InvalidArgument Argument is invalid. |
| * retval kStatus_USDHC_PrepareAdmaDescriptorFailed Prepare ADMA descriptor failed. |
| * retval kStatus_USDHC_SendCommandFailed Send command failed. |
| * retval kStatus_USDHC_TransferDataFailed Transfer data failed. |
| * retval kStatus_Success Operate successfully. |
| */ |
| status_t USDHC_TransferBlocking(USDHC_Type *base, usdhc_adma_config_t *dmaConfig, usdhc_transfer_t *transfer) |
| { |
| assert(transfer); |
| |
| status_t error = kStatus_Fail; |
| usdhc_command_t *command = transfer->command; |
| usdhc_data_t *data = transfer->data; |
| bool enDMA = true; |
| bool executeTuning = ((data == NULL) ? false : data->dataType == kUSDHC_TransferDataTuning); |
| |
| /*check re-tuning request*/ |
| if ((USDHC_GetInterruptStatusFlags(base) & kUSDHC_ReTuningEventFlag) != 0U) |
| { |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_ReTuningEventFlag); |
| return kStatus_USDHC_ReTuningRequest; |
| } |
| |
| /* Update ADMA descriptor table according to different DMA mode(no DMA, ADMA1, ADMA2).*/ |
| if ((data != NULL) && (dmaConfig != NULL) && (!executeTuning)) |
| { |
| error = USDHC_SetAdmaTableConfig(base, dmaConfig, data, (data->dataType & kUSDHC_TransferDataBoot) ? |
| kUSDHC_AdmaDescriptorMultipleFlag : |
| kUSDHC_AdmaDescriptorSingleFlag); |
| } |
| |
| /* if the DMA desciptor configure fail or not needed , disable it */ |
| if (error != kStatus_Success) |
| { |
| enDMA = false; |
| /* disable DMA, using polling mode in this situation */ |
| USDHC_EnableInternalDMA(base, false); |
| } |
| #if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL |
| else |
| { |
| if (data->txData != NULL) |
| { |
| /* clear the DCACHE */ |
| DCACHE_CleanByRange((uint32_t)data->txData, (data->blockSize) * (data->blockCount)); |
| } |
| else |
| { |
| /* clear the DCACHE */ |
| DCACHE_CleanInvalidateByRange((uint32_t)data->rxData, (data->blockSize) * (data->blockCount)); |
| } |
| } |
| #endif |
| |
| /* config the data transfer parameter */ |
| error = USDHC_SetDataTransferConfig(base, data, &(command->flags), enDMA); |
| if (kStatus_Success != error) |
| { |
| return error; |
| } |
| /* send command first */ |
| USDHC_SendCommand(base, command); |
| /* wait command done */ |
| error = USDHC_WaitCommandDone(base, command, (data == NULL) || (data->dataType == kUSDHC_TransferDataNormal)); |
| |
| /* wait transfer data finsih */ |
| if ((data != NULL) && (error == kStatus_Success)) |
| { |
| return USDHC_TransferDataBlocking(base, data, enDMA); |
| } |
| |
| return error; |
| } |
| |
| /*! |
| * brief Transfers the command/data using an interrupt and an asynchronous method. |
| * |
| * This function sends a command and data and returns immediately. It doesn't wait the transfer complete or encounter an |
| * error. |
| * The application must not call this API in multiple threads at the same time. Because of that this API doesn't support |
| * the re-entry mechanism. |
| * |
| * note Call the API 'USDHC_TransferCreateHandle' when calling this API. |
| * |
| * param base USDHC peripheral base address. |
| * param handle USDHC handle. |
| * param adma configuration. |
| * param transfer Transfer content. |
| * retval kStatus_InvalidArgument Argument is invalid. |
| * retval kStatus_USDHC_BusyTransferring Busy transferring. |
| * retval kStatus_USDHC_PrepareAdmaDescriptorFailed Prepare ADMA descriptor failed. |
| * retval kStatus_Success Operate successfully. |
| */ |
| status_t USDHC_TransferNonBlocking(USDHC_Type *base, |
| usdhc_handle_t *handle, |
| usdhc_adma_config_t *dmaConfig, |
| usdhc_transfer_t *transfer) |
| { |
| assert(handle); |
| assert(transfer); |
| |
| status_t error = kStatus_Fail; |
| usdhc_command_t *command = transfer->command; |
| usdhc_data_t *data = transfer->data; |
| bool executeTuning = ((data == NULL) ? false : data->dataType == kUSDHC_TransferDataTuning); |
| bool enDMA = true; |
| |
| /*check re-tuning request*/ |
| if ((USDHC_GetInterruptStatusFlags(base) & (kUSDHC_ReTuningEventFlag)) != 0U) |
| { |
| USDHC_ClearInterruptStatusFlags(base, kUSDHC_ReTuningEventFlag); |
| return kStatus_USDHC_ReTuningRequest; |
| } |
| |
| /* Save command and data into handle before transferring. */ |
| handle->command = command; |
| handle->data = data; |
| handle->interruptFlags = 0U; |
| /* transferredWords will only be updated in ISR when transfer way is DATAPORT. */ |
| handle->transferredWords = 0U; |
| |
| /* Update ADMA descriptor table according to different DMA mode(no DMA, ADMA1, ADMA2).*/ |
| if ((data != NULL) && (dmaConfig != NULL) && (!executeTuning)) |
| { |
| error = USDHC_SetAdmaTableConfig(base, dmaConfig, data, (data->dataType & kUSDHC_TransferDataBoot) ? |
| kUSDHC_AdmaDescriptorMultipleFlag : |
| kUSDHC_AdmaDescriptorSingleFlag); |
| } |
| |
| /* if the DMA desciptor configure fail or not needed , disable it */ |
| if (error != kStatus_Success) |
| { |
| /* disable DMA, using polling mode in this situation */ |
| USDHC_EnableInternalDMA(base, false); |
| enDMA = false; |
| } |
| #if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL |
| else |
| { |
| if (data->txData != NULL) |
| { |
| /* clear the DCACHE */ |
| DCACHE_CleanByRange((uint32_t)data->txData, (data->blockSize) * (data->blockCount)); |
| } |
| else |
| { |
| /* clear the DCACHE */ |
| DCACHE_CleanInvalidateByRange((uint32_t)data->rxData, (data->blockSize) * (data->blockCount)); |
| } |
| } |
| #endif |
| |
| error = USDHC_SetDataTransferConfig(base, data, &(command->flags), enDMA); |
| if (kStatus_Success != error) |
| { |
| return error; |
| } |
| |
| /* send command first */ |
| USDHC_SendCommand(base, command); |
| |
| return kStatus_Success; |
| } |
| |
| #if defined(FSL_FEATURE_USDHC_HAS_SDR50_MODE) && (FSL_FEATURE_USDHC_HAS_SDR50_MODE) |
| /*! |
| * 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 config to the CLK_TUNE_CTRL_STATUS |
| * This function should called before USDHC_AdjustDelayforSDR104 function |
| * param base USDHC peripheral base address. |
| * param tuning enable flag |
| */ |
| void USDHC_EnableManualTuning(USDHC_Type *base, bool enable) |
| { |
| if (enable) |
| { |
| /* make sure std_tun_en bit is clear */ |
| base->TUNING_CTRL &= ~USDHC_TUNING_CTRL_STD_TUNING_EN_MASK; |
| /* disable auto tuning here */ |
| base->MIX_CTRL &= ~USDHC_MIX_CTRL_AUTO_TUNE_EN_MASK; |
| /* execute tuning for SDR104 mode */ |
| base->MIX_CTRL |= |
| USDHC_MIX_CTRL_EXE_TUNE_MASK | USDHC_MIX_CTRL_SMP_CLK_SEL_MASK | USDHC_MIX_CTRL_FBCLK_SEL_MASK; |
| } |
| else |
| { /* abort the tuning */ |
| base->MIX_CTRL &= ~(USDHC_MIX_CTRL_EXE_TUNE_MASK | USDHC_MIX_CTRL_SMP_CLK_SEL_MASK); |
| } |
| } |
| |
| /*! |
| * brief the SDR104 mode delay setting adjust |
| * This function should called after USDHC_ManualTuningForSDR104 |
| * param base USDHC peripheral base address. |
| * param delay setting configuration |
| * retval kStatus_Fail config the delay setting fail |
| * retval kStatus_Success config the delay setting success |
| */ |
| status_t USDHC_AdjustDelayForManualTuning(USDHC_Type *base, uint32_t delay) |
| { |
| uint32_t clkTuneCtrl = 0U; |
| |
| clkTuneCtrl = base->CLK_TUNE_CTRL_STATUS; |
| |
| clkTuneCtrl &= ~USDHC_CLK_TUNE_CTRL_STATUS_DLY_CELL_SET_PRE_MASK; |
| |
| clkTuneCtrl |= USDHC_CLK_TUNE_CTRL_STATUS_DLY_CELL_SET_PRE(delay); |
| |
| /* load the delay setting */ |
| base->CLK_TUNE_CTRL_STATUS = clkTuneCtrl; |
| /* check delat setting error */ |
| if (base->CLK_TUNE_CTRL_STATUS & |
| (USDHC_CLK_TUNE_CTRL_STATUS_PRE_ERR_MASK | USDHC_CLK_TUNE_CTRL_STATUS_NXT_ERR_MASK)) |
| { |
| return kStatus_Fail; |
| } |
| |
| return kStatus_Success; |
| } |
| |
| /*! |
| * brief the enable standard tuning function |
| * The standard tuning window and tuning counter use the default config |
| * tuning cmd is send by the software, user need to check the tuning result |
| * can be used for SDR50,SDR104,HS200 mode tuning |
| * param base USDHC peripheral base address. |
| * param tuning start tap |
| * param tuning step |
| * param enable/disable flag |
| */ |
| void USDHC_EnableStandardTuning(USDHC_Type *base, uint32_t tuningStartTap, uint32_t step, bool enable) |
| { |
| uint32_t tuningCtrl = 0U; |
| |
| if (enable) |
| { |
| /* feedback clock */ |
| base->MIX_CTRL |= USDHC_MIX_CTRL_FBCLK_SEL_MASK; |
| /* config tuning start and step */ |
| tuningCtrl = base->TUNING_CTRL; |
| tuningCtrl &= ~(USDHC_TUNING_CTRL_TUNING_START_TAP_MASK | USDHC_TUNING_CTRL_TUNING_STEP_MASK); |
| tuningCtrl |= (USDHC_TUNING_CTRL_TUNING_START_TAP(tuningStartTap) | USDHC_TUNING_CTRL_TUNING_STEP(step) | |
| USDHC_TUNING_CTRL_STD_TUNING_EN_MASK); |
| base->TUNING_CTRL = tuningCtrl; |
| |
| /* excute tuning */ |
| base->AUTOCMD12_ERR_STATUS |= |
| (USDHC_AUTOCMD12_ERR_STATUS_EXECUTE_TUNING_MASK | USDHC_AUTOCMD12_ERR_STATUS_SMP_CLK_SEL_MASK); |
| } |
| else |
| { |
| /* disable the standard tuning */ |
| base->TUNING_CTRL &= ~USDHC_TUNING_CTRL_STD_TUNING_EN_MASK; |
| /* clear excute tuning */ |
| base->AUTOCMD12_ERR_STATUS &= |
| ~(USDHC_AUTOCMD12_ERR_STATUS_EXECUTE_TUNING_MASK | USDHC_AUTOCMD12_ERR_STATUS_SMP_CLK_SEL_MASK); |
| } |
| } |
| |
| /*! |
| * brief the auto tuning enbale for CMD/DATA line |
| * |
| * param base USDHC peripheral base address. |
| */ |
| void USDHC_EnableAutoTuningForCmdAndData(USDHC_Type *base) |
| { |
| uint32_t busWidth = 0U; |
| |
| base->VEND_SPEC2 |= USDHC_VEND_SPEC2_TUNING_CMD_EN_MASK; |
| busWidth = (base->PROT_CTRL & USDHC_PROT_CTRL_DTW_MASK) >> USDHC_PROT_CTRL_DTW_SHIFT; |
| if (busWidth == kUSDHC_DataBusWidth1Bit) |
| { |
| base->VEND_SPEC2 &= ~USDHC_VEND_SPEC2_TUNING_8bit_EN_MASK; |
| base->VEND_SPEC2 |= USDHC_VEND_SPEC2_TUNING_1bit_EN_MASK; |
| } |
| else if (busWidth == kUSDHC_DataBusWidth4Bit) |
| { |
| base->VEND_SPEC2 &= ~USDHC_VEND_SPEC2_TUNING_8bit_EN_MASK; |
| base->VEND_SPEC2 &= ~USDHC_VEND_SPEC2_TUNING_1bit_EN_MASK; |
| } |
| else if (busWidth == kUSDHC_DataBusWidth8Bit) |
| { |
| base->VEND_SPEC2 |= USDHC_VEND_SPEC2_TUNING_8bit_EN_MASK; |
| base->VEND_SPEC2 &= ~USDHC_VEND_SPEC2_TUNING_1bit_EN_MASK; |
| } |
| else |
| { |
| } |
| } |
| #endif /* FSL_FEATURE_USDHC_HAS_SDR50_MODE */ |
| |
| static void USDHC_TransferHandleCardDetect(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags) |
| { |
| if (interruptFlags & kUSDHC_CardInsertionFlag) |
| { |
| if (handle->callback.CardInserted) |
| { |
| handle->callback.CardInserted(base, handle->userData); |
| } |
| } |
| else |
| { |
| if (handle->callback.CardRemoved) |
| { |
| handle->callback.CardRemoved(base, handle->userData); |
| } |
| } |
| } |
| |
| static void USDHC_TransferHandleCommand(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags) |
| { |
| assert(handle->command); |
| |
| if (interruptFlags & kUSDHC_CommandErrorFlag) |
| { |
| if (handle->callback.TransferComplete) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_USDHC_SendCommandFailed, handle->userData); |
| } |
| } |
| else |
| { |
| /* Receive response */ |
| if (kStatus_Success != USDHC_ReceiveCommandResponse(base, handle->command)) |
| { |
| if (handle->callback.TransferComplete) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_USDHC_SendCommandFailed, handle->userData); |
| } |
| } |
| else if ((!(handle->data)) && (handle->callback.TransferComplete)) |
| { |
| if (handle->callback.TransferComplete) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_Success, handle->userData); |
| } |
| } |
| else |
| { |
| } |
| } |
| } |
| |
| static void USDHC_TransferHandleData(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags) |
| { |
| assert(handle->data); |
| |
| if ((!(handle->data->enableIgnoreError)) && ((interruptFlags & (kUSDHC_DataErrorFlag | kUSDHC_DmaErrorFlag)))) |
| { |
| if (handle->callback.TransferComplete) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_USDHC_TransferDataFailed, handle->userData); |
| } |
| } |
| else |
| { |
| if (interruptFlags & kUSDHC_BufferReadReadyFlag) |
| { |
| /* std tuning process only need to wait BRR */ |
| if (handle->data->dataType == kUSDHC_TransferDataTuning) |
| { |
| if (handle->callback.TransferComplete) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_Success, handle->userData); |
| } |
| } |
| else |
| { |
| handle->transferredWords = USDHC_ReadDataPort(base, handle->data, handle->transferredWords); |
| } |
| } |
| else if (interruptFlags & kUSDHC_BufferWriteReadyFlag) |
| { |
| handle->transferredWords = USDHC_WriteDataPort(base, handle->data, handle->transferredWords); |
| } |
| else |
| { |
| if ((interruptFlags & kUSDHC_DmaCompleteFlag) && |
| (handle->data->dataType == kUSDHC_TransferDataBootcontinous)) |
| { |
| *(handle->data->rxData) = s_usdhcBootDummy; |
| } |
| |
| if ((handle->callback.TransferComplete) && (interruptFlags & kUSDHC_DataCompleteFlag)) |
| { |
| handle->callback.TransferComplete(base, handle, kStatus_Success, handle->userData); |
| } |
| } |
| } |
| } |
| |
| static void USDHC_TransferHandleSdioInterrupt(USDHC_Type *base, usdhc_handle_t *handle) |
| { |
| if (handle->callback.SdioInterrupt) |
| { |
| handle->callback.SdioInterrupt(base, handle->userData); |
| } |
| } |
| |
| static void USDHC_TransferHandleReTuning(USDHC_Type *base, usdhc_handle_t *handle, uint32_t interruptFlags) |
| { |
| assert(handle->callback.ReTuning); |
| /* retuning request */ |
| if ((interruptFlags & kUSDHC_TuningErrorFlag) == kUSDHC_TuningErrorFlag) |
| { |
| handle->callback.ReTuning(base, handle->userData); /* retuning fail */ |
| } |
| } |
| |
| static void USDHC_TransferHandleBlockGap(USDHC_Type *base, usdhc_handle_t *handle) |
| { |
| if (handle->callback.BlockGap) |
| { |
| handle->callback.BlockGap(base, handle->userData); |
| } |
| } |
| |
| /*! |
| * brief Creates the USDHC handle. |
| * |
| * param base USDHC peripheral base address. |
| * param handle USDHC handle pointer. |
| * param callback Structure pointer to contain all callback functions. |
| * param userData Callback function parameter. |
| */ |
| void USDHC_TransferCreateHandle(USDHC_Type *base, |
| usdhc_handle_t *handle, |
| const usdhc_transfer_callback_t *callback, |
| void *userData) |
| { |
| assert(handle); |
| assert(callback); |
| |
| /* Zero the handle. */ |
| memset(handle, 0, sizeof(*handle)); |
| |
| /* Set the callback. */ |
| handle->callback.CardInserted = callback->CardInserted; |
| handle->callback.CardRemoved = callback->CardRemoved; |
| handle->callback.SdioInterrupt = callback->SdioInterrupt; |
| handle->callback.BlockGap = callback->BlockGap; |
| handle->callback.TransferComplete = callback->TransferComplete; |
| handle->callback.ReTuning = callback->ReTuning; |
| handle->userData = userData; |
| |
| /* Save the handle in global variables to support the double weak mechanism. */ |
| s_usdhcHandle[USDHC_GetInstance(base)] = handle; |
| |
| /* Enable interrupt in NVIC. */ |
| USDHC_SetTransferInterrupt(base, true); |
| /* save IRQ handler */ |
| s_usdhcIsr = USDHC_TransferHandleIRQ; |
| |
| EnableIRQ(s_usdhcIRQ[USDHC_GetInstance(base)]); |
| } |
| |
| /*! |
| * brief IRQ handler for the USDHC. |
| * |
| * This function deals with the IRQs on the given host controller. |
| * |
| * param base USDHC peripheral base address. |
| * param handle USDHC handle. |
| */ |
| void USDHC_TransferHandleIRQ(USDHC_Type *base, usdhc_handle_t *handle) |
| { |
| assert(handle); |
| |
| uint32_t interruptFlags; |
| |
| interruptFlags = USDHC_GetInterruptStatusFlags(base); |
| handle->interruptFlags = interruptFlags; |
| |
| if (interruptFlags & kUSDHC_CardDetectFlag) |
| { |
| USDHC_TransferHandleCardDetect(base, handle, (interruptFlags & kUSDHC_CardDetectFlag)); |
| } |
| if (interruptFlags & kUSDHC_CommandFlag) |
| { |
| USDHC_TransferHandleCommand(base, handle, (interruptFlags & kUSDHC_CommandFlag)); |
| } |
| if (interruptFlags & kUSDHC_DataFlag) |
| { |
| USDHC_TransferHandleData(base, handle, (interruptFlags & kUSDHC_DataFlag)); |
| } |
| if (interruptFlags & kUSDHC_CardInterruptFlag) |
| { |
| USDHC_TransferHandleSdioInterrupt(base, handle); |
| } |
| if (interruptFlags & kUSDHC_BlockGapEventFlag) |
| { |
| USDHC_TransferHandleBlockGap(base, handle); |
| } |
| if (interruptFlags & kUSDHC_SDR104TuningFlag) |
| { |
| USDHC_TransferHandleReTuning(base, handle, (interruptFlags & kUSDHC_SDR104TuningFlag)); |
| } |
| USDHC_ClearInterruptStatusFlags(base, interruptFlags); |
| } |
| |
| #ifdef USDHC0 |
| void USDHC0_DriverIRQHandler(void) |
| { |
| s_usdhcIsr(s_usdhcBase[0U], s_usdhcHandle[0U]); |
| /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping |
| exception return operation might vector to incorrect interrupt */ |
| #if defined __CORTEX_M && (__CORTEX_M == 4U) |
| __DSB(); |
| #endif |
| } |
| #endif |
| |
| #ifdef USDHC1 |
| void USDHC1_DriverIRQHandler(void) |
| { |
| s_usdhcIsr(s_usdhcBase[1U], s_usdhcHandle[1U]); |
| /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping |
| exception return operation might vector to incorrect interrupt */ |
| #if defined __CORTEX_M && (__CORTEX_M == 4U) |
| __DSB(); |
| #endif |
| } |
| #endif |
| |
| #ifdef USDHC2 |
| void USDHC2_DriverIRQHandler(void) |
| { |
| s_usdhcIsr(s_usdhcBase[2U], s_usdhcHandle[2U]); |
| /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping |
| exception return operation might vector to incorrect interrupt */ |
| #if defined __CORTEX_M && (__CORTEX_M == 4U) |
| __DSB(); |
| #endif |
| } |
| |
| #endif |