Esp32SdmmcIO.h

Go to the documentation of this file.

 
#pragma once
 
#include "BaseIO.h"
 
#if defined(ESP32) || defined(ESP_PLATFORM)
 
#include <driver/sdmmc_host.h>
#include <driver/sdmmc_defs.h>
#include <sdmmc_cmd.h>
#include "sdcommon.h"
 
namespace fatfs {
 
class Esp32SdmmcIO : public BaseIO {
 public:
  Esp32SdmmcIO() : card(nullptr), auto_init(false) {
    memset(&host_config, 0, sizeof(host_config));
    memset(&slot_config, 0, sizeof(slot_config));
  }
  
  Esp32SdmmcIO(bool mode1bit, int max_freq_khz = SDMMC_FREQ_DEFAULT) 
      : card(nullptr), auto_init(true), init_mode1bit(mode1bit), 
        init_max_freq_khz(max_freq_khz) {
    memset(&host_config, 0, sizeof(host_config));
    memset(&slot_config, 0, sizeof(slot_config));
  }
  
  Esp32SdmmcIO(bool mode1bit, int max_freq_khz,
                 const sdmmc_host_t& host_cfg, 
                 const sdmmc_slot_config_t& slot_cfg)
      : card(nullptr), auto_init(true), init_mode1bit(mode1bit), 
        init_max_freq_khz(max_freq_khz), host_config(host_cfg), 
        slot_config(slot_cfg) {
  }
  
  ~Esp32SdmmcIO() {
    end();
  }
 
  bool begin(bool mode1bit = false, int max_freq_khz = SDMMC_FREQ_DEFAULT) {
    return begin(mode1bit, max_freq_khz, 
                 SDMMC_HOST_DEFAULT(), 
                 SDMMC_SLOT_CONFIG_DEFAULT());
  }
  
  bool begin(bool mode1bit, int max_freq_khz,
             sdmmc_host_t host_cfg, sdmmc_slot_config_t slot_cfg) {
    
    // Store configurations
    host_config = host_cfg;
    slot_config = slot_cfg;
    
    // Set bus width
    if (mode1bit) {
      slot_config.width = 1;
    } else {
      slot_config.width = 4;
    }
    
    // Set maximum frequency
    host_config.max_freq_khz = max_freq_khz;
    
    // Initialize host
    esp_err_t err = sdmmc_host_init();
    if (err != ESP_OK) {
      stat = STA_NOINIT;
      return false;
    }
    
    // Initialize slot
    err = sdmmc_host_init_slot(SDMMC_HOST_SLOT_1, &slot_config);
    if (err != ESP_OK) {
      sdmmc_host_deinit();
      stat = STA_NOINIT;
      return false;
    }
    
    // Allocate card structure
    if (card == nullptr) {
      card = (sdmmc_card_t*)malloc(sizeof(sdmmc_card_t));
      if (card == nullptr) {
        sdmmc_host_deinit();
        stat = STA_NOINIT;
        return false;
      }
    }
    memset(card, 0, sizeof(sdmmc_card_t));
    
    // Probe and initialize card
    card->host = host_config;
    err = sdmmc_card_init(&host_config, card);
    if (err != ESP_OK) {
      free(card);
      card = nullptr;
      sdmmc_host_deinit();
      stat = STA_NODISK;
      return false;
    }
    
    // Determine card type flags
    CardType = 0;
    if (card->is_mmc) {
      CardType = CT_MMC;
    } else {
      // SD card
      if (card->ocr & SD_OCR_SDHC_CAP) {
        CardType = CT_SD2 | CT_BLOCK;  // SDHC/SDXC
      } else {
        CardType = CT_SD2;  // SDSC
      }
    }
    
    stat = STA_CLEAR;
    return true;
  }
 
  void end() {
    if (card != nullptr) {
      free(card);
      card = nullptr;
    }
    sdmmc_host_deinit();
    stat = STA_NOINIT;
  }
 
  DSTATUS disk_initialize(BYTE drv) override {
    if (drv != 0) return STA_NOINIT;
    
    // If already initialized, return current status
    if (stat == STA_CLEAR) return stat;
    
    // Try to initialize with stored settings or defaults
    if (auto_init && host_config.flags == 0) {
      // Constructor with mode1bit and freq was used
      if (begin(init_mode1bit, init_max_freq_khz)) {
        return STA_CLEAR;
      }
    } else if (auto_init && host_config.flags != 0) {
      // Constructor with full config was used
      if (begin(init_mode1bit, init_max_freq_khz, host_config, slot_config)) {
        return STA_CLEAR;
      }
    } else {
      // Default constructor was used, try with defaults
      if (begin()) {
        return STA_CLEAR;
      }
    }
    
    return stat;
  }
 
  DSTATUS disk_status(BYTE drv) override {
    if (drv != 0) return STA_NOINIT;
    return stat;
  }
 
  DRESULT disk_read(BYTE drv, BYTE* buff, LBA_t sector, UINT count) override {
    if (drv != 0 || !count) return RES_PARERR;
    if (stat & STA_NOINIT) return RES_NOTRDY;
    if (card == nullptr) return RES_NOTRDY;
 
    // Use low-level API to read sectors
    esp_err_t err = sdmmc_read_sectors(card, buff, sector, count);
    
    return (err == ESP_OK) ? RES_OK : RES_ERROR;
  }
 
#if FF_IO_USE_WRITE
  DRESULT disk_write(BYTE drv, const BYTE* buff, LBA_t sector,
                     UINT count) override {
    if (drv != 0 || !count) return RES_PARERR;
    if (stat & STA_NOINIT) return RES_NOTRDY;
    if (stat & STA_PROTECT) return RES_WRPRT;
    if (card == nullptr) return RES_NOTRDY;
 
    // Use low-level API to write sectors
    esp_err_t err = sdmmc_write_sectors(card, buff, sector, count);
    
    return (err == ESP_OK) ? RES_OK : RES_ERROR;
  }
#endif
 
#if FF_IO_USE_IOCTL
  DRESULT disk_ioctl(BYTE drv, ioctl_cmd_t cmd, void* buff) override {
    if (drv != 0) return RES_PARERR;
    if (stat & STA_NOINIT) return RES_NOTRDY;
 
    DRESULT res = RES_ERROR;
 
    switch (cmd) {
      case CTRL_SYNC:
        // SD_MMC handles synchronization internally
        res = RES_OK;
        break;
 
      case GET_SECTOR_COUNT:
        if (buff && card) {
          // Get total sectors from card capacity
          uint64_t capacity = ((uint64_t)card->csd.capacity) * card->csd.sector_size;
          *(DWORD*)buff = (DWORD)(capacity / 512);
          res = RES_OK;
        }
        break;
 
      case GET_SECTOR_SIZE:
        if (buff) {
          // SD cards use 512-byte sectors for compatibility
          *(WORD*)buff = 512;
          res = RES_OK;
        }
        break;
 
      case GET_BLOCK_SIZE:
        if (buff && card) {
          // Return erase block size in sectors
          // Use the card's erase sector size if available
          uint32_t erase_size = card->csd.sector_size;
          if (erase_size < 512) erase_size = 512;
          *(DWORD*)buff = erase_size / 512;
          if (*(DWORD*)buff == 0) *(DWORD*)buff = 1;
          res = RES_OK;
        }
        break;
 
      case CTRL_TRIM:
        // TRIM/ERASE not implemented via SD_MMC library
        res = RES_OK;  // Return OK but don't actually trim
        break;
 
      case MMC_GET_TYPE:
        if (buff) {
          *(BYTE*)buff = CardType;
          res = RES_OK;
        }
        break;
 
      case MMC_GET_CSD:
        if (buff && card) {
          // Copy CSD register data
          memcpy(buff, &card->csd, sizeof(card->csd));
          res = RES_OK;
        }
        break;
 
      case MMC_GET_CID:
        if (buff && card) {
          // Copy CID register data
          memcpy(buff, &card->cid, sizeof(card->cid));
          res = RES_OK;
        }
        break;
 
      case MMC_GET_OCR:
        if (buff && card) {
          // Copy OCR register
          *(DWORD*)buff = card->ocr;
          res = RES_OK;
        }
        break;
 
      case MMC_GET_SDSTAT:
        if (buff && card) {
          // Get SD status - this requires reading from the card
          // For simplicity, return not implemented
          res = RES_PARERR;
        }
        break;
 
      default:
        res = RES_PARERR;
        break;
    }
 
    return res;
  }
#endif
 
  uint64_t cardSize() const {
    if (card == nullptr) return 0;
    return ((uint64_t)card->csd.capacity) * card->csd.sector_size;
  }
 
  uint8_t cardType() const {
    return CardType;
  }
 
  uint64_t totalSectors() const {
    if (stat & STA_NOINIT || card == nullptr) return 0;
    return cardSize() / 512;
  }
  
  sdmmc_card_t* getCard() {
    return card;
  }
  
  bool isMMC() const {
    return card ? card->is_mmc : false;
  }
  
  uint32_t getFreqKHz() const {
    return card ? card->max_freq_khz : 0;
  }
 
 protected:
  volatile DSTATUS stat = STA_NOINIT;  
  BYTE CardType = 0;                    
  sdmmc_card_t* card;                   
  sdmmc_host_t host_config;             
  sdmmc_slot_config_t slot_config;      
  
  // Auto-initialization parameters (for constructor-based config)
  bool auto_init;                       
  bool init_mode1bit;                   
  int init_max_freq_khz;                
};
 
}  // namespace fatfs
 
#endif  // ESP32 || ESP_PLATFORM