mmc_hal.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#ifdef AVR
#include <stdlib.h>
#endif
 
#include "mathio.h"
 
#include "time.h"
#include "timer.h"
 
#ifdef ESP8266
#include "hspi.h"
#endif
 
#include "fatfs.h"
 
extern DSTATUS Stat;
 
uint16_t _mmc_timeout = 0;
 
uint32_t _mmc_clock = 0;
 
// @brief MMC media status prescaler
uint16_t _mmc_pre = 0;
 
static void mmc_task(void)
{
    if(_mmc_timeout)
        _mmc_timeout--;
 
// 100HZ
    if(_mmc_pre++  < 10)
        return;
 
    _mmc_pre = 0;
 
    if(!mmc_ins_status())
        set_error(1);
 
    mmc_disk_timerproc();
}
 
 
MEMSPACE
void mmc_install_timer( void )
{
    _mmc_timeout = 0;
    if(set_timers(mmc_task,1) == -1)
        printf("MMC Clock task init failed\n");
}
 
 
void mmc_spi_init()
{
    chip_select_init(MMC_CS);
    mmc_slow();
}
 
 
void mmc_spi_begin()
{
    spi_begin(_mmc_clock,MMC_CS);
}
 
 
void mmc_spi_end()
{
    spi_end(MMC_CS);
}
 
 
void mmc_slow()
{
    _mmc_clock = MMC_SLOW;
}
 
 
void mmc_fast()
{
    _mmc_clock = MMC_FAST;
}
 
 
void mmc_spi_TX_buffer(const uint8_t *data, int count)
{
    spi_TX_buffer((uint8_t *) data,count);
}
 
 
void mmc_spi_RX_buffer(const uint8_t *data, int count)
{
    spi_RX_buffer((uint8_t *) data,count);
}
 
 
uint8_t mmc_spi_TXRX(uint8_t data)
{
    return( spi_TXRX(data) );
}
 
 
MEMSPACE
void mmc_set_ms_timeout(uint16_t ms)
{
    mmc_cli();
    _mmc_timeout = ms;
    mmc_sei();
}
 
 
MEMSPACE
int  mmc_test_timeout()
{
 
    if( Stat & STA_NODISK )
        return(1);
 
#ifdef ESP8266
    optimistic_yield(1000);
    wdt_reset();
#endif
    if(!_mmc_timeout)
    {
        printf("MMC TIMEOUT\n");
        Stat |= (STA_NODISK | STA_NOINIT);
        return(1);
    }
    return(0);
}
 
 
MEMSPACE
void mmc_ms_wait(int ms)
{
    mmc_set_ms_timeout(ms);
    while(!mmc_test_timeout())
        ;
}
 
 
static int mmc_init_flag = 0;
MEMSPACE
int mmc_init(int verbose)
{
    int rc;
 
    char buff[MAX_NAME_LEN+1];
 
    Stat = 0;
    clear_error();
 
    // Card Detect
    GPIO_PIN_LATCH_LOW(GPIO_C7);
    GPIO_PIN_DIR_IN(GPIO_C7);
 
    mmc_spi_init();
 
    if( verbose)
    {
        printf("START MMC INIT\n");
    }
// we only install timers once!
    if(!mmc_init_flag)
        mmc_install_timer();
 
    if(!mmc_ins_status())
    {
        printf("*** MMC Card NOT Inserted! ***\n");
        return(RES_NOTRDY); 
    }
 
 
    if( verbose)
    {
        printf("MMC Card Inserted\n");
 
#if defined (FF_USE_LFN)
        printf("LFN Enabled");
#else
        printf("LFN Disabled");
#endif
        printf(", Code page: %u\n", FF_CODE_PAGE);
    }
 
    rc = disk_initialize(DEV_MMC);                // aliased to mmc_disk_initialize()
 
    if( rc != RES_OK  )
        put_rc(rc);
 
    if( rc == RES_OK)
        rc = f_mount(&Fatfs[0],"/", 0);
 
    if( rc != RES_OK || verbose)
        put_rc( rc );
 
    if (verbose )
    {
        DWORD blksize = 0;
        if(rc == RES_OK)
        {
            rc = disk_ioctl ( DEV_MMC, GET_BLOCK_SIZE, (void *) &blksize);
            if( rc != RES_OK)
            {
                put_rc( rc );
                printf("MMC Block Size - read failed\n");
            }
            else
            {
                printf("MMC Block Size: %ld\n", blksize);
            }
            if( rc == RES_OK)
            {
                strcpy(buff,"/");
                fatfs_status(buff);
            }
        }
        printf("END MMC INIT\n");
    }
    mmc_init_flag = 1;
 
    if(rc != RES_OK)
        set_error(1);
 
    return( rc ) ;
}
 
 
MEMSPACE
void mmc_power_on()
{
}
 
 
MEMSPACE
void mmc_power_off()
{
}
 
 
 
MEMSPACE
int mmc_ins_status()
{
    // HI when card is NOT inserted
    if( GPIO_PIN_RD(GPIO_C7) )
        return (0);
    else
        return(1);; 
}
 
 
 
MEMSPACE
int mmc_wp_status()
{
    return (0);
}