#include "os_config.h"

#include "c_def.h"
#include "debug.h"
#include "oem.h"

#ifdef SD_ENABLE
#include "regmap.h"

#include "mem_reloc.h"

#include "hw_timer.h"
#include "hw_pll.h"

#include "sdif.h"
#include "sd.h"



//U16 sdif_readBlocks( U8 *buf, U32 lba, U16 blkcnt )  __INTERNAL_RAM_TEXT;


#define	sddbg_assert        debug_assert


static SD_CARD_INFO	cardinfo;

#if 0
//#define BUS_CLKS            (SYSTEM_CLKS/2)
#else
//#define BUS_CLKS            (SystemClock/2)
#endif

#if 0
#define SDIF_WAIT_TIMEOUT   (6000 / OS_MSEC_PER_TICK + 1) //6s
#else
//#define SDIF_WAIT_TIMEOUT   (6000) //6s
#endif

int sdif_preinit( void )
{
	UINT ret;

	ret = sd_preinit();
	DBG_assert( ret );

	return ret;
}

BOOL sdif_init(void)
{	
	BOOL ret;

	DBG_Printf("sdif_init\n");
	
	memset( &cardinfo, 0, sizeof(cardinfo) );
	
	ret = sd_init( );
	sddbg_assert( ret );
	
	return ret;
}

BOOL sdif_open(void)
{
#define	SD_OPEN_MAX_TRY	3

	BOOL r;
	int i = 0;
	int ret;

	DBG_Printf("sdif_open\n");

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	while ( i ++ < SD_OPEN_MAX_TRY ) {
		r = sd_open();
		sddbg_assert( r );
		if( r ) {
			r = sd_getCardInfo( &cardinfo );
			sddbg_assert( r );
			break;
		}
	}

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return (r);
}

BOOL sdif_close(void)
{
	BOOL r;
	int ret;

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	r = sd_close();
	sddbg_assert( r );
	
	memset( &cardinfo, 0, sizeof(cardinfo) );

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );
}

BOOL sdif_fini(void)
{
	int r;
	int ret;

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	r = sd_fini();
	sddbg_assert( r );

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );
}

SD_CARD_INFO *sdif_getCardInfo(void)
{
	return &cardinfo;
}

int	sdif_isCardPresent( void )
{
	return sd_isCardPresent();
}

int sdif_isCardWP( int *wp )
{
	return sd_isCardWP( wp );
}

int	sdif_errRecover( void )
{
	int r;
	int ret;

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	r = sd_errRecover();
	DBG_assert( r );
	if( r ) {
		r = sd_getCardInfo( &cardinfo );
		DBG_assert( r );
	}

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return r;
}

int sdif_getSysClk( void )
{
#define SYS_DEFAULT_CLK	BUS_CLKS/1000
	
	//FIXME
	return	SYS_DEFAULT_CLK;
}

static int sdif_clkChange( U32 sysclkKhz )
{
	int ret, tmp;
	
	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	tmp	=	sd_clkChange( sysclkKhz );

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return	tmp;
}


extern void tsd_icardInsertCallback( void );
extern void tsd_icardRemoveCallback( void );

void sdif_icallback_cardInsert( void )
{
	//tsd_icardInsertCallback();
}
void sdif_icallback_cardRemove( void )
{
	//tsd_icardRemoveCallback();
}


extern int sdhcd_hcReset(void);

int sdrwCnt	=	0;

static int sdMonitor( int blkcnt )
{
#define	MAX_SIZE	(10*1024*1024)		//10MB

	int maxblks	=	MAX_SIZE / sdif_getSectorSize();

	sdrwCnt +=	blkcnt;
	if( sdrwCnt > maxblks ) {
		sdrwCnt	=	0;
	//	sdhcd_hcReset();
	}
	//	sdhcd_hcReset();	

	return TRUE;
}

int sdif_sdReset( void )
{
	UINT ret;

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	sdrwCnt	=	0;
	sdhcd_hcReset();
	timer_delayms(5);

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return TRUE;
}

U16	sdif_readBlocks( U8 *buf, U32 lba, U16 blkcnt )
{
	U16	tmp;
	UINT ret;
	
	if( blkcnt >= cardinfo.capacity )	return 0;

	//waiting for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	sdMonitor( blkcnt );

	tmp	=	sd_readBlocks( buf, lba, blkcnt );
	DBG_Assert( tmp == blkcnt );


	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return tmp;
}

U16	sdif_writeBlocks( U8 *buf, U32 lba, U16 blkcnt )
{
	U16	tmp;
	UINT ret;

	if( blkcnt >= cardinfo.capacity )	return 0;
	
	//waitint for SDIF_WAIT_TIMEOUT:6s
	ret = SD_MUTEX_TIMEOUT_LOCK;
	if( ret != TRUE )	return 0;

	sdMonitor( blkcnt );

	tmp	=	sd_writeBlocks( buf, lba, blkcnt );
	DBG_Assert( tmp == blkcnt );

	SD_MUTEX_UNLOCK;
	DBG_Assert( ret == TRUE );

	return tmp;
}

#define	SDMMC_DUMMY_CAP		0
U32 sdif_getCapacity (void)
{
	if(!sd_isCardPresent())	return SDMMC_DUMMY_CAP;

	return (cardinfo.capacity - 1);	//block unit
}

#define	SDMMC_DUMMY_SECTOR_SIZE		512
U16 sdif_getSectorSize(void)
{
	if(!sd_isCardPresent())	return SDMMC_DUMMY_SECTOR_SIZE;
	
	return cardinfo.blkSize;
}

WORD sdif_Get_Media (void)
{
	return TRUE;
}

BOOL sdif_Erase (DWORD sector_addr, DWORD len)
{
	return TRUE;
}

BOOL sdif_Format_Unit (void)
{
	return TRUE;
}

BOOL sdif_Get_Format_Propgress (BYTE *format_progress)
{
	return TRUE;
}


BOOL sdif_Media_Active (void)
{
	return TRUE;
}

#endif