mmc_hal.c

Go to the documentation of this file.

#include "user_config.h"

#ifdef AVR
#include <stdlib.h>
#endif

#include "printf/mathio.h"

#include "lib/time.h"
#include "lib/timer.h"

#ifdef ESP8266
#include "esp8266/hspi.h"
#endif

#include "fatfs.sup/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;

    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;

    Stat = 0;

    mmc_spi_init();

    if( verbose)
    {
        printf("START MMC INIT\n");
    }
    // we only install timers once!
    if(!mmc_init_flag)
        mmc_install_timer();

    if( verbose)
    {
#if defined (_USE_LFN)
        printf("LFN Enabled");
#else
        printf("LFN Disabled");
#endif
        printf(", Code page: %u\n", _CODE_PAGE);
    }

    rc = disk_initialize(0);    // aliased to mmc_disk_initialize()

    if( rc != RES_OK  || verbose )
    {
        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 ( 0, 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)
            {
                fatfs_status("/");
            }
        }
        printf("END MMC INIT\n");
    }
    mmc_init_flag = 1;

    return( rc ) ;
}

MEMSPACE
void mmc_power_on()
{
}

MEMSPACE
void mmc_power_off()
{
}


MEMSPACE
int mmc_ins_status()
{
    return (1);
}




MEMSPACE
int mmc_wp_status()
{
    return (0);
}