/*-----------------------------------------------------------------------*/
/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2016        */
/*-----------------------------------------------------------------------*/
/* If a working storage control module is available, it should be        */
/* attached to the FatFs via a glue function rather than modifying it.   */
/* This is an example of glue functions to attach various exsisting      */
/* storage control modules to the FatFs module with a defined API.       */
/*-----------------------------------------------------------------------*/

#include "ff.h"			/* Obtains integer types */
#include "diskio.h"		/* Declarations of disk functions */
#include "sdio.h"
//#include "pmic_rtc.h"
#define fatal_printf uart_printf

/* Definitions of physical drive number for each drive */
#define DEV_RAM		0	/* Example: Map Ramdisk to physical drive 0 */
#define DEV_MMC		1	/* Example: Map MMC/SD card to physical drive 1 */
#define DEV_USB		2	/* Example: Map USB MSD to physical drive 2 */
#define DEV_FLASH		3	/* Example: Map FLASH MSD to physical drive 3 */


/*-----------------------------------------------------------------------*/
/* Get Drive Status                                                      */
/*-----------------------------------------------------------------------*/

DSTATUS disk_status (
	BYTE pdrv		/* Physical drive nmuber to identify the drive */
)
{
	DSTATUS stat;
	int result;
    //uart_printf("%s %d\r\n", __func__, pdrv);
	switch (pdrv) {
	case DEV_RAM :
		//result = RAM_disk_status();

		// translate the reslut code here

		return stat;

	case DEV_MMC :
		if (sdcard_is_ready() == TRUE)
			return 0;

		return STA_NODISK;

	case DEV_USB :
		//result = USB_disk_status();

		// translate the reslut code here

		return stat;
	case DEV_FLASH :
		return 0;
		
	}
	return STA_NOINIT;
}



/*-----------------------------------------------------------------------*/
/* Inidialize a Drive                                                    */
/*-----------------------------------------------------------------------*/

DSTATUS disk_initialize (
	BYTE pdrv				/* Physical drive nmuber to identify the drive */
)
{
	DSTATUS stat = 0;
	int result;
    //uart_printf("%s %d\r\n", __func__, pdrv);
	switch (pdrv) {
	case DEV_RAM :
		//result = RAM_disk_initialize();

		// translate the reslut code here

		return stat;

	case DEV_MMC :
		//result = MMC_disk_initialize();

		// translate the reslut code here

		return stat;

	case DEV_USB :
		//result = USB_disk_initialize();

		// translate the reslut code here

		return stat;
	case DEV_FLASH:
		return stat;
		
	}
	return STA_NOINIT;
}

#pragma arm section rwdata="SDBuf", zidata="SDBuf"
//UINT8 __align(8) back_buf[SINGLE_BLOCK_SIZE];
UINT8 __align(8) align_buf[64*1024];
#pragma arm section rwdata, zidata
static UINT8 sd_full_status = 0;


int MMC_disk_read(char *buff, DWORD sector, UINT count)
{
    UINT base = SD1_HOST_CTRL_ADDR;
	UINT ret = 0;
    if (count == 0)
		return 0;
    if (sector > sdcard_get_blknum() || (sector + count) > sdcard_get_blknum()) {
		fatal_printf("sdcard read err\r\n");
		sd_full_status = 1;
		return -1;
    }
	if(eeGetSystemAssertFlag()==TRUE)
	{
			if(count == 1)
				ret = sdcard_read_singleblk(base, align_buf, sector);
			else
				ret = sdcard_read_multiblks(base, align_buf, sector, count);
			memcpy(buff, align_buf, SINGLE_BLOCK_SIZE*count);
	}else
	{
			if(count == 1)
				ret = sdcard_read_singleblk(base, buff,sector);
			else
				ret = sdcard_read_multiblks(base, buff, sector, count);
	}
	return ret;
}
#if 0
extern unsigned int qspi_nvm_start_block; //16*5 16K*64=1024K
extern unsigned int qspi_nvm_total_size;
extern unsigned int qspi_nvm_block_size;

int flash_disk_read(char *buff, DWORD sector, UINT count)
{
    unsigned int start_address = qspi_nvm_start_block * qspi_nvm_block_size + qspi_nvm_total_size;
    unsigned int addr = sector * 512 + start_address;
    //int ret = spi_nor_do_erase_4k(addr,count * 512);
	int ret  = spi_nor_do_read(addr, buff,count * 512);
    return ret;
}
#endif

/*-----------------------------------------------------------------------*/
/* Read Sector(s)                                                        */
/*-----------------------------------------------------------------------*/

DRESULT disk_read (
	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
	BYTE *buff,		/* Data buffer to store read data */
	DWORD sector,	/* Start sector in LBA */
	UINT count		/* Number of sectors to read */
)
{
	DRESULT res;
	int result;
    UINT base = SD1_HOST_CTRL_ADDR;
	//uart_printf("%s %d\r\n", __func__, pdrv);
	switch (pdrv) {
	case DEV_RAM :
		// translate the arguments here

		//result = RAM_disk_read(buff, sector, count);

		// translate the reslut code here

		return res;

	case DEV_MMC :
		// translate the arguments here

		result = MMC_disk_read(buff, sector, count);
        if (result != 0)
			return RES_ERROR;
		// translate the reslut code here

		return RES_OK;

	case DEV_USB :
		// translate the arguments here

		//result = USB_disk_read(buff, sector, count);

		// translate the reslut code here

		return res;
	#if 0
	case DEV_FLASH:
		result = flash_disk_read(buff, sector, count);
		if (result != 0)
			return RES_ERROR;
		return RES_OK;
	#endif
	default:
		return RES_PARERR;
	}

	return RES_PARERR;
}



/*-----------------------------------------------------------------------*/
/* Write Sector(s)                                                       */
/*-----------------------------------------------------------------------*/

#if FF_FS_READONLY == 0

UINT MMC_disk_write(void *buff, DWORD sector, UINT count)
{
    UINT base = SD1_HOST_CTRL_ADDR;
	UINT ret = 0;
	//char *p = buff;
	//uart_printf("SDCARD :%s:%d :%d:%d\n", __FILE__, __LINE__, sector, count);
	if(count == 0)
		return 0;
	//uart_printf("SDCARD :%s:%d\n", __FILE__, __LINE__);
    if (sector > sdcard_get_blknum() || (sector + count) > sdcard_get_blknum()) {
		fatal_printf("sdcard write err\r\n");
		sd_full_status = 1;
		return -1;
    }
	//fatal_printf("diskWrite: %02x, %02x, %02x, %02x\n", *p, *(p+1), *(p+2), *(p+3));
	if(eeGetSystemAssertFlag()==TRUE)
	{
		memcpy(align_buf, buff, SINGLE_BLOCK_SIZE * count);
		if(count == 1)
			ret =  sdcard_write_singleblk(base, align_buf, sector);
		else
			ret = sdcard_write_multiblks(base, align_buf, sector, count);
	}
	else
	{
		if(count == 1)
			ret = sdcard_write_singleblk(base, buff, sector);
		else
			ret = sdcard_write_multiblks(base, buff, sector, count);
	}

	return ret;

}
#if 0
static char flash_disk_read_buf[8 * 512];
int flash_disk_write(char *buff, DWORD sector, UINT count)
{
    unsigned int start_address = qspi_nvm_start_block * qspi_nvm_block_size + qspi_nvm_total_size;
    unsigned int addr = sector * 512 + start_address;
	int count_4k = count/8;
	int count_last = count%8;
	int ret;
	if (sector%8 != 0) {
		addr = addr - sector%8 * 512;
		ret = spi_nor_do_read(addr, flash_disk_read_buf, 8* 512);
		if (ret != 0) {
			return ret;
		}
		memcpy(flash_disk_read_buf+sector%8*512, buff, 8*512 - sector%8*512);
		ret = spi_nor_do_erase_4k(addr,8 * 512);
		if (ret != 0)
			return ret;
		ret = spi_nor_do_write(addr, flash_disk_read_buf, 8 * 512);
		if (ret != 0) 
			return ret;
		if((sector+count) * 512 <= (addr+8* 512))
			return 0;
		buff += (8*512- sector%8*512);
		count -= (8 - sector % 8);
		sector += (8 - sector % 8);
		count_4k = count/8;
		count_last = count%8;
		addr += (8*512- sector%8*512);
	}
	if (count_4k != 0) {
        ret = spi_nor_do_erase_4k(addr,count_4k * 8 * 512);
	    if (ret != 0 ) {
		    return ret;
	    }
	    ret  = spi_nor_do_write(addr, buff, count_4k * 8 * 512);
		if (ret != 0)
			return ret;
	}
	addr = addr + count_4k * 8 * 512;
	if (count_last != 0) {
		//read out
		ret = spi_nor_do_read(addr, flash_disk_read_buf, 8* 512);
		if (ret != 0) {
			return ret;
		}
		memcpy(flash_disk_read_buf, buff + count_4k * 8 * 512, count_last * 512);
		ret = spi_nor_do_erase_4k(addr,8 * 512);
		if (ret != 0)
			return ret;
		ret = spi_nor_do_write(addr, flash_disk_read_buf, 8 * 512);
	}
    return ret;
}
#endif

DRESULT disk_write (
	BYTE pdrv,			/* Physical drive nmuber to identify the drive */
	const BYTE *buff,	/* Data to be written */
	DWORD sector,		/* Start sector in LBA */
	UINT count			/* Number of sectors to write */
)
{
	DRESULT res;
	int result;
    //uart_printf("%s %d\r\n", __func__, pdrv);
	switch (pdrv) {
	case DEV_RAM :
		// translate the arguments here

		//result = RAM_disk_write(buff, sector, count);

		// translate the reslut code here

		return res;

	case DEV_MMC :
		// translate the arguments here

		result = MMC_disk_write(buff, sector, count);

		// translate the reslut code here
        if (result != 0)
			return RES_ERROR;
		return RES_OK;

	case DEV_USB :
		// translate the arguments here

		//result = USB_disk_write(buff, sector, count);

		// translate the reslut code here

		return res;
	case DEV_FLASH:
		#if 0
		result = flash_disk_write(buff, sector, count);
		if (result != 0)
			return RES_ERROR;
		#endif
		return RES_OK;
	default:
		//ASSERT(0);
	}

	return RES_PARERR;
}

#endif


/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions                                               */
/*-----------------------------------------------------------------------*/
#define FLASH_DISK_TOTAL_SIZE 0x200000
DRESULT disk_ioctl (
	BYTE pdrv,		/* Physical drive nmuber (0..) */
	BYTE cmd,		/* Control code */
	void *buff		/* Buffer to send/receive control data */
)
{
	DRESULT res;
	int result;
    //uart_printf("%s %d cmd:%d\r\n", __func__, pdrv, cmd);
	switch (pdrv) {
	case DEV_RAM :

		// Process of the command for the RAM drive

		return res;

	case DEV_MMC :

		// Process of the command for the MMC/SD card
		switch(cmd) {
		case CTRL_SYNC:
			res = RES_OK;
			break;
		case GET_SECTOR_COUNT:
			*(DWORD *)buff = sdcard_get_blknum();
			res = RES_OK;
			break;
		case GET_SECTOR_SIZE:
			*(DWORD *)buff = SINGLE_BLOCK_SIZE;
			res = RES_OK;
			break;
		case GET_BLOCK_SIZE:
			*(DWORD *)buff = SINGLE_BLOCK_SIZE;
			res = RES_OK;
			break;
		case ISDIO_READ:
		case ISDIO_WRITE:
		default:
		    res = RES_ERROR;
			
		}

		return res;

	case DEV_USB :

		// Process of the command the USB drive

		return res;
	#if 0
	case DEV_FLASH:

		// Process of the command for the Flash
		switch(cmd) {
		case CTRL_SYNC:
			res = RES_OK;
			break;
		case GET_SECTOR_COUNT:
			*(DWORD *)buff = FLASH_DISK_TOTAL_SIZE/SINGLE_BLOCK_SIZE;
			res = RES_OK;
			break;
		case GET_SECTOR_SIZE:
			*(DWORD *)buff = SINGLE_BLOCK_SIZE;
			res = RES_OK;
			break;
		case GET_BLOCK_SIZE:
			*(DWORD *)buff = SINGLE_BLOCK_SIZE;
			res = RES_OK;
			break;
		case ISDIO_READ:
		case ISDIO_WRITE:
		default:
		    res = RES_ERROR;
			
		}
		return res;
	#endif
	default:
		return RES_PARERR;
	}

	return RES_PARERR;
}
DWORD get_fattime(void)
{
    //t_rtc tmp;
	DWORD t;
	//memset(&tmp, 0, sizeof(t_rtc));
	//PMIC_RTC_GetTime(&tmp,APP_OFFSET);
    //if (tmp.tm_year < 1980)
	//	tmp.tm_year = 1980;
	//t = (tmp.tm_year - 1980)<<25 | tmp.tm_mon<<21 | tmp.tm_mday<<16 | tmp.tm_hour<<11 | tmp.tm_min<<5 | tmp.tm_sec;
	t =  (2019)<<25 | 5<<21 | 24<<16 | 12<<11 | 12<<5 | 12;
	return t;
}




#include <stdio.h>
#include <string.h>
#include "ff.h"         /* Declarations of sector size */
#include "diskio.h"     /* Declarations of disk functions */
static
DWORD pn (		/* Pseudo random number generator */
    DWORD pns	/* 0:Initialize, !0:Read */
)
{
    static DWORD lfsr;
    UINT n;


    if (pns) {
        lfsr = pns;
        for (n = 0; n < 32; n++) pn(0);
    }
    if (lfsr & 1) {
        lfsr >>= 1;
        lfsr ^= 0x80200003;
    } else {
        lfsr >>= 1;
    }
    return lfsr;
}


int test_diskio (
    BYTE pdrv,      /* Physical drive number to be checked (all data on the drive will be lost) */
    UINT ncyc,      /* Number of test cycles */
    DWORD* buff,    /* Pointer to the working buffer */
    UINT sz_buff    /* Size of the working buffer in unit of byte */
)
{
    UINT n, cc, ns;
    DWORD sz_drv, lba, lba2, sz_eblk, pns = 1;
    WORD sz_sect;
    BYTE *pbuff = (BYTE*)buff;
    DSTATUS ds;
    DRESULT dr;


    fatal_printf("test_diskio(%u, %u, 0x%08X, 0x%08X)\n", pdrv, ncyc, (UINT)buff, sz_buff);

    if (sz_buff < FF_MAX_SS + 4) {
        fatal_printf("Insufficient work area to run program.\n");
        return 1;
    }

    for (cc = 1; cc <= ncyc; cc++) {
        fatal_printf("**** Test cycle %u of %u start ****\n", cc, ncyc);

        fatal_printf(" disk_initalize(%u)", pdrv);
        ds = disk_initialize(pdrv);
        if (ds & STA_NOINIT) {
            fatal_printf(" - failed.\n");
            return 2;
        } else {
            fatal_printf(" - ok.\n");
        }

        fatal_printf("**** Get drive size ****\n");
        fatal_printf(" disk_ioctl(%u, GET_SECTOR_COUNT, 0x%08X)", pdrv, (UINT)&sz_drv);
        sz_drv = 0;
        dr = disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_drv);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 3;
        }
        if (sz_drv < 128) {
            fatal_printf("Failed: Insufficient drive size to test.\n");
            return 4;
        }
        fatal_printf(" Number of sectors on the drive %u is %lu.\n", pdrv, sz_drv);

#if FF_MAX_SS != FF_MIN_SS
        fatal_printf("**** Get sector size ****\n");
        fatal_printf(" disk_ioctl(%u, GET_SECTOR_SIZE, 0x%X)", pdrv, (UINT)&sz_sect);
        sz_sect = 0;
        dr = disk_ioctl(pdrv, GET_SECTOR_SIZE, &sz_sect);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 5;
        }
        fatal_printf(" Size of sector is %u bytes.\n", sz_sect);
#else
        sz_sect = FF_MAX_SS;
#endif

        fatal_printf("**** Get block size ****\n");
        fatal_printf(" disk_ioctl(%u, GET_BLOCK_SIZE, 0x%X)", pdrv, (UINT)&sz_eblk);
        sz_eblk = 0;
        dr = disk_ioctl(pdrv, GET_BLOCK_SIZE, &sz_eblk);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
        }
        if (dr == RES_OK || sz_eblk >= 2) {
            fatal_printf(" Size of the erase block is %lu sectors.\n", sz_eblk);
        } else {
            fatal_printf(" Size of the erase block is unknown.\n");
        }

        /* Single sector write test */
        fatal_printf("**** Single sector write test 1 ****\n");
        lba = 0;
        for (n = 0, pn(pns); n < sz_sect; n++) pbuff[n] = (BYTE)pn(0);
        fatal_printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
        dr = disk_write(pdrv, pbuff, lba, 1);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 6;
        }
        fatal_printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
        dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 7;
        }
        memset(pbuff, 0, sz_sect);
        fatal_printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
        dr = disk_read(pdrv, pbuff, lba, 1);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 8;
        }
        for (n = 0, pn(pns); n < sz_sect && pbuff[n] == (BYTE)pn(0); n++) ;
        if (n == sz_sect) {
            fatal_printf(" Data matched.\n");
        } else {
            fatal_printf("Failed: Read data differs from the data written.\n");
            return 10;
        }
        pns++;

        fatal_printf("**** Multiple sector write test ****\n");
        lba = 1; ns = sz_buff / sz_sect;
        if (ns > 4) ns = 4;
        for (n = 0, pn(pns); n < (UINT)(sz_sect * ns); n++) pbuff[n] = (BYTE)pn(0);
        fatal_printf(" disk_write(%u, 0x%X, %lu, %u)", pdrv, (UINT)pbuff, lba, ns);
        dr = disk_write(pdrv, pbuff, lba, ns);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 11;
        }
        fatal_printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
        dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 12;
        }
        memset(pbuff, 0, sz_sect * ns);
        fatal_printf(" disk_read(%u, 0x%X, %lu, %u)", pdrv, (UINT)pbuff, lba, ns);
        dr = disk_read(pdrv, pbuff, lba, ns);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 13;
        }
        for (n = 0, pn(pns); n < (UINT)(sz_sect * ns) && pbuff[n] == (BYTE)pn(0); n++) ;
        if (n == (UINT)(sz_sect * ns)) {
            fatal_printf(" Data matched.\n");
        } else {
            fatal_printf("Failed: Read data differs from the data written.\n");
            return 14;
        }
        pns++;

        fatal_printf("**** Single sector write test (misaligned address) ****\n");
        lba = 5;
        for (n = 0, pn(pns); n < sz_sect; n++) pbuff[n+3] = (BYTE)pn(0);
        fatal_printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+3), lba);
        dr = disk_write(pdrv, pbuff+3, lba, 1);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 15;
        }
        fatal_printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
        dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 16;
        }
        memset(pbuff+5, 0, sz_sect);
        fatal_printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+5), lba);
        dr = disk_read(pdrv, pbuff+5, lba, 1);
        if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
        } else {
            fatal_printf(" - failed.\n");
            return 17;
        }
        for (n = 0, pn(pns); n < sz_sect && pbuff[n+5] == (BYTE)pn(0); n++) ;
        if (n == sz_sect) {
            fatal_printf(" Data matched.\n");
        } else {
            fatal_printf("Failed: Read data differs from the data written.\n");
            return 18;
        }
        pns++;

        fatal_printf("**** 4GB barrier test ****\n");
        if (sz_drv >= 128 + 0x80000000 / (sz_sect / 2)) {
            lba = 6; lba2 = lba + 0x80000000 / (sz_sect / 2);
            for (n = 0, pn(pns); n < (UINT)(sz_sect * 2); n++) pbuff[n] = (BYTE)pn(0);
            fatal_printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
            dr = disk_write(pdrv, pbuff, lba, 1);
            if (dr == RES_OK) {
                fatal_printf(" - ok.\n");
            } else {
                fatal_printf(" - failed.\n");
                return 19;
            }
            fatal_printf(" disk_write(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+sz_sect), lba2);
            dr = disk_write(pdrv, pbuff+sz_sect, lba2, 1);
            if (dr == RES_OK) {
                fatal_printf(" - ok.\n");
            } else {
                fatal_printf(" - failed.\n");
                return 20;
            }
            fatal_printf(" disk_ioctl(%u, CTRL_SYNC, NULL)", pdrv);
            dr = disk_ioctl(pdrv, CTRL_SYNC, 0);
            if (dr == RES_OK) {
            fatal_printf(" - ok.\n");
            } else {
                fatal_printf(" - failed.\n");
                return 21;
            }
            memset(pbuff, 0, sz_sect * 2);
            fatal_printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)pbuff, lba);
            dr = disk_read(pdrv, pbuff, lba, 1);
            if (dr == RES_OK) {
                fatal_printf(" - ok.\n");
            } else {
                fatal_printf(" - failed.\n");
                return 22;
            }
            fatal_printf(" disk_read(%u, 0x%X, %lu, 1)", pdrv, (UINT)(pbuff+sz_sect), lba2);
            dr = disk_read(pdrv, pbuff+sz_sect, lba2, 1);
            if (dr == RES_OK) {
                fatal_printf(" - ok.\n");
            } else {
                fatal_printf(" - failed.\n");
                return 23;
            }
            for (n = 0, pn(pns); pbuff[n] == (BYTE)pn(0) && n < (UINT)(sz_sect * 2); n++) ;
            if (n == (UINT)(sz_sect * 2)) {
                fatal_printf(" Data matched.\n");
            } else {
                fatal_printf("Failed: Read data differs from the data written.\n");
                return 24;
            }
        } else {
            fatal_printf(" Test skipped.\n");
        }
        pns++;

        fatal_printf("**** Test cycle %u of %u completed ****\n\n", cc, ncyc);
    }

    return 0;
}


DWORD buffx[FF_MAX_SS];

int ff_test0 (void)
{
    int rc;
      /* Working buffer (4 sector in size) */

    /* Check function/compatibility of the physical drive #0 */
    //rc = test_diskio(1, 1, buffx, sizeof buffx);
    rc = test_diskio(1, 1, buffx, sizeof buffx);
    if (rc) {
        fatal_printf("Sorry the function/compatibility test failed. (rc=%d)\nFatFs will not work with this disk driver.\n", rc);
    } else {
        fatal_printf("Congratulations! The disk driver works well.\n");
    }

    return rc;
}
int ff_test(void)
{
    FIL file;
	UINT ret;
	char buf[12];
	FATFS fs;
	FRESULT res;
	//res = f_mkfs("F:", FM_ANY, 0, buffx, sizeof(buffx));
	//fatal_printf("fatfs format :%d\r\n", res);
	//return 0;
	res = f_mount(&fs,"D:", 1);
	fatal_printf("fatfs mount err:%d\n", res);
	if(res != FR_OK)
		return 0;
    res = f_open(&file, "D:\\1.txt", FA_WRITE|FA_CREATE_ALWAYS);
	if (res != FR_OK) {
		fatal_printf("fatfs open err:%d\n", res);
		return -1;
	}
	res = f_write(&file, "123456789", 9, &ret);
	fatal_printf("fatafs write result:%d\n", res);
	f_close(&file);
	res = f_open(&file, "D:\\1.txt", FA_READ);
	if (res != FR_OK) {
		fatal_printf("fatfs open err:%d\n", res);
		return -1;
	}
	res = f_read(&file, buffx, 10, &ret);
	fatal_printf("fatafs write result:%d len:%d, :%s\n", res, ret, buffx);
	f_close(&file);
	
	DIR dj;
	FILINFO fno;
	memset(&dj, 0, sizeof(dj));
	memset(&fno, 0, sizeof(fno));
	res = f_findfirst(&dj, &fno, "D:\\","*.txt");
	while(res == FR_OK && fno.fname[0]){
		uart_printf("%s\n", fno.fname);
		memset(&fno, 0, sizeof(fno));
		res = f_findnext(&dj, &fno);
	}
	f_closedir(&dj);
	return 0;
}