Diff: SDFileSystem.cpp

Revision:

0:225138ac03fd

Child:

1:99666dacaae6

diff -r 000000000000 -r 225138ac03fd SDFileSystem.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.cpp	Sat Apr 16 03:56:15 2016 +0000
@@ -0,0 +1,371 @@
+//-----------------------------------------------------------------------
+//  Fixed version not to produce warning message by N.Mikami
+//      April 16, 2016
+//-----------------------------------------------------------------------
+
+/* SD/MMC File System Library
+ * Copyright (c) 2016 Neil Thiessen
+ * Modified for the use with STM32F746 Discovery (C) 2016 Dieter Greaf
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "SDFileSystem.h"
+#include "diskio.h"
+#include "SDCRC.h"
+//for cache flush function
+#include "SD_Helper.h"
+
+SDFileSystem::SDFileSystem( const char* name)
+    : FATFileSystem(name), m_Cd(PC_13)
+{
+    //Initialize the member variables
+    uint8_t initstat;
+
+// Commented out in modified versin
+//    void* h;
+
+    m_CardType = CARD_NONE;
+    m_Crc = true;
+    m_LargeFrames = false;
+    m_WriteValidation = true;
+    m_Status = STA_NOINIT;
+    m_Cd.mode(PullUp);
+    m_CdAssert = 0;
+    m_Cd.rise(this, &SDFileSystem::onCardRemoval);
+
+// Followings are original
+//    h=(void*)&SDFileSystem::DMA2_Stream3_IRQHandler;
+//    NVIC_SetVector(DMA2_Stream3_IRQn,(uint32_t)h);
+//    h=(void*)&SDFileSystem::DMA2_Stream6_IRQHandler;
+//    NVIC_SetVector(DMA2_Stream6_IRQn,(uint32_t)h);
+//    h=(void*)&SDFileSystem::SDMMC1_IRQHandler;
+//    NVIC_SetVector(SDMMC1_IRQn,(uint32_t)h);
+
+// Modified
+    NVIC_SetVector(DMA2_Stream3_IRQn,
+                   (uint32_t)(&SDFileSystem::DMA2_Stream3_IRQHandler));
+    NVIC_SetVector(DMA2_Stream6_IRQn,
+                   (uint32_t)(&SDFileSystem::DMA2_Stream6_IRQHandler));
+    NVIC_SetVector(SDMMC1_IRQn,
+                   (uint32_t)(&SDFileSystem::SDMMC1_IRQHandler));
+
+    BSP_SD_Clear_Busy();
+    initstat=BSP_SD_Init();
+   if (initstat!=MSD_OK)
+   {
+       m_Status |= STA_NOINIT;
+   }
+   else
+   {
+        m_Status &= ~STA_NOINIT;
+   }
+}
+
+bool SDFileSystem::card_present()
+{
+    //Check the card socket
+    checkSocket();
+
+    //Return whether or not a card is present
+    return !(m_Status & STA_NODISK);
+}
+
+SDFileSystem::CardType SDFileSystem::card_type()
+{
+    //Check the card socket
+    checkSocket();
+
+    //Return the card type
+    return m_CardType;
+}
+
+bool SDFileSystem::crc()
+{
+    //Return whether or not CRC is enabled
+    return m_Crc;
+}
+
+void SDFileSystem::crc(bool enabled)
+{
+    //Check the card socket
+    checkSocket();
+
+    //Just update the member variable if the card isn't initialized
+    if (m_Status & STA_NOINIT) {
+        m_Crc = enabled;
+        return;
+    }
+
+    //Enable or disable CRC
+    if (enabled && !m_Crc) {
+        //Send CMD59(0x00000001) to enable CRC
+        m_Crc = true;
+        BSP_SD_CommandTransaction(CMD59, 0x00000001);
+    } else if (!enabled && m_Crc) {
+        //Send CMD59(0x00000000) to disableAPP/MBED/targets/hal/TARGET_STM/TARGET_STM32F7/TARGET_DISCO_F746NG CRC
+        BSP_SD_CommandTransaction(CMD59, 0x00000000);
+        m_Crc = false;
+    }
+}
+
+bool SDFileSystem::large_frames()
+{
+    //Return whether or not 16-bit frames are enabled
+    return m_LargeFrames;
+}
+
+void SDFileSystem::large_frames(bool enabled)
+{
+    //Set whether or not 16-bit frames are enabled
+    m_LargeFrames = enabled;
+}
+
+bool SDFileSystem::write_validation()
+{
+    //Return whether or not write validation is enabled
+    return m_WriteValidation;
+}
+
+void SDFileSystem::write_validation(bool enabled)
+{
+    //Set whether or not write validation is enabled
+    m_WriteValidation = enabled;
+}
+
+int SDFileSystem::unmount()
+{
+    //Unmount the filesystem
+    FATFileSystem::unmount();
+
+    //Change the status to not initialized, and the card type to unknown
+    m_Status |= STA_NOINIT;
+    m_CardType = CARD_UNKNOWN;
+
+    //Always succeeds
+    return 0;
+}
+
+int SDFileSystem::disk_initialize()
+{
+
+    //Make sure there's a card in the socket before proceeding
+    checkSocket();
+    if (m_Status & STA_NODISK)
+        return m_Status;
+   BSP_SD_GetCardInfo(&m_CardInfo);
+
+   switch(m_CardInfo.CardType)
+   {
+   case STD_CAPACITY_SD_CARD_V1_1:
+       { m_CardType =  CARD_SD;
+         break; }
+    case STD_CAPACITY_SD_CARD_V2_0:
+       { m_CardType =  CARD_SD;
+         break; }
+    case HIGH_CAPACITY_SD_CARD:
+       { m_CardType =  CARD_SDHC;
+         break; }
+    case MULTIMEDIA_CARD:
+       { m_CardType =  CARD_MMC;
+         break; }
+    case SECURE_DIGITAL_IO_CARD:
+       { m_CardType =  CARD_SD;
+         break; }
+    case HIGH_SPEED_MULTIMEDIA_CARD:
+       { m_CardType =  CARD_MMC;
+         break; }
+    case SECURE_DIGITAL_IO_COMBO_CARD:
+       { m_CardType =  CARD_SD;
+         break; }
+    case HIGH_CAPACITY_MMC_CARD:
+       { m_CardType =  CARD_MMC;
+         break; }
+    default:
+       {m_CardType = CARD_UNKNOWN;
+       return m_Status;}
+   }
+    //The card is now initialized
+    m_Status &= ~STA_NOINIT;
+
+    //Return the disk status
+    return m_Status;
+}
+
+int SDFileSystem::disk_status()
+{
+    //Check the card socket
+    checkSocket();
+
+    //Return the disk status
+    return m_Status;
+}
+
+int SDFileSystem::disk_read(uint8_t* buffer, uint32_t sector, uint32_t count)
+{
+    int retval;
+    //Make sure the card is initialized before proceeding
+    if (m_Status & STA_NOINIT)
+        return RES_NOTRDY;
+    __DSB();
+    __ISB();
+    while(BSP_SD_Get_Busy()==1){;}
+    BSP_SD_Set_Busy();
+    //Read a single block, or multiple blocks
+    if (count > 1) {
+        BSP_SD_Set_RX_Busy();
+        SCB_InvalidateDCache_by_Addr((uint32_t *)buffer,(512*count));
+        retval=BSP_SD_ReadBlocks_DMA((uint32_t *)buffer, (uint64_t) (sector * 512),512, count);
+        while((BSP_SD_Get_RX_Busy()==1)&&(retval==MSD_OK)){;}
+        CPU_CACHE_Flush((uint32_t *)buffer,(512*count));
+        BSP_SD_Clear_Busy();
+        return (retval ? RES_ERROR : RES_OK);
+    } else {
+        BSP_SD_Set_RX_Busy();
+        SCB_InvalidateDCache_by_Addr((uint32_t *)buffer,(512));
+        retval= BSP_SD_ReadBlocks_DMA((uint32_t *)buffer, (uint64_t) (sector * 512), 512, 1);
+        while((BSP_SD_Get_RX_Busy()==1)&&(retval==MSD_OK)){;}
+        CPU_CACHE_Flush((uint32_t *)buffer,(512));
+        BSP_SD_Clear_Busy();
+        return (retval ? RES_ERROR : RES_OK);
+    }
+}
+
+int SDFileSystem::disk_write(const uint8_t* buffer, uint32_t sector, uint32_t count)
+{
+    int retval;
+    //Make sure the card is initialized before proceeding
+    if (m_Status & STA_NOINIT)
+        return RES_NOTRDY;
+    __DSB();
+    __ISB();
+    while(BSP_SD_Get_Busy()==1){;}
+    BSP_SD_Set_Busy();
+    //Make sure the card isn't write protected before proceeding
+    if (m_Status & STA_PROTECT)
+    {
+    BSP_SD_Clear_Busy();
+    return RES_WRPRT;
+    }
+    //Write a single block, or multiple blocks
+    if (count > 1) {
+        CPU_CACHE_Flush((uint32_t *)buffer,(512*count));
+        BSP_SD_Set_TX_Busy();
+        retval= BSP_SD_WriteBlocks_DMA((uint32_t *)buffer, (uint64_t) (sector * 512), 512, count);
+         while((BSP_SD_Get_TX_Busy()==1)&&(retval==MSD_OK)){;}
+         BSP_SD_Clear_Busy();
+         return (retval? RES_ERROR : RES_OK);
+    } else {
+        CPU_CACHE_Flush((uint32_t *)buffer,(512));
+        BSP_SD_Set_TX_Busy();
+        retval= BSP_SD_WriteBlocks_DMA((uint32_t *)buffer, (uint64_t) (sector * 512), 512, 1);
+         while((BSP_SD_Get_TX_Busy()==1)&&(retval==MSD_OK)){;}
+         BSP_SD_Clear_Busy();
+         return (retval? RES_ERROR : RES_OK);
+
+    }
+}
+
+int SDFileSystem::disk_sync()
+{
+    //Select the card so we're forced to wait for the end of any internal write processes
+    __DSB();
+    __ISB();
+    while(BSP_SD_Get_Busy()==1){;}
+    BSP_SD_Set_Busy();
+    while(BSP_SD_GetStatus()==SD_TRANSFER_BUSY){;}
+    if(BSP_SD_GetStatus()==SD_TRANSFER_OK)
+    {
+        BSP_SD_Clear_Busy();
+        return RES_OK;
+    } else {
+        BSP_SD_Clear_Busy();
+        return RES_ERROR;
+    }
+}
+
+uint32_t SDFileSystem::disk_sectors()
+{
+    uint32_t sectors=0;
+    //Make sure the card is initialized before proceeding
+    if (m_Status & STA_NOINIT)
+        return 0;
+    __DSB();
+    __ISB();
+    while(BSP_SD_Get_Busy()==1){;}
+    BSP_SD_Set_Busy();
+    BSP_SD_GetCardInfo(&m_CardInfo);
+    sectors=m_CardInfo.CardCapacity>>9;
+    BSP_SD_Clear_Busy();
+    return sectors;
+}
+
+void SDFileSystem::onCardRemoval()
+{
+    //Check the card socket
+    checkSocket();
+}
+
+inline void SDFileSystem::checkSocket()
+{
+    //Use the card detect switch (if available) to determine if the socket is occupied
+    if (m_CdAssert != -1) {
+        if (m_Status & STA_NODISK) {
+            if (m_Cd == m_CdAssert) {
+                //The socket is now occupied
+                m_Status &= ~STA_NODISK;
+                m_CardType = CARD_UNKNOWN;
+            }
+        } else {
+            if (m_Cd != m_CdAssert) {
+                //The socket is now empty
+                m_Status |= (STA_NODISK | STA_NOINIT);
+                m_CardType = CARD_NONE;
+            }
+        }
+    }
+}
+
+
+/*interrupthandlers */
+/**
+  * @brief  This function handles DMA2 Stream 3 interrupt request.
+  * @param  None
+  * @retval None
+  */
+void SDFileSystem::DMA2_Stream3_IRQHandler(void)
+{
+  BSP_SD_DMA_Rx_IRQHandler();
+  BSP_SD_Clear_RX_Busy();
+}
+
+/**
+  * @brief  This function handles DMA2 Stream 6 interrupt request.
+  * @param  None
+  * @retval None
+  */
+void SDFileSystem::DMA2_Stream6_IRQHandler(void)
+{
+  BSP_SD_DMA_Tx_IRQHandler();
+  BSP_SD_Clear_TX_Busy();
+}
+
+/**
+  * @brief  This function handles SDIO interrupt request.
+  * @param  None
+  * @retval None
+  */
+void SDFileSystem::SDMMC1_IRQHandler(void)
+{
+  BSP_SD_IRQHandler();
+}
+