/*
 * RT-Thread Device Interface for uffs
 */

#include <rtthread.h>
#include <rtdevice.h>
#include "dfs_uffs.h"

static int nand_init_flash(uffs_Device *dev)
{
	return UFFS_FLASH_NO_ERR;
}

static int nand_release_flash(uffs_Device *dev)
{
	return UFFS_FLASH_NO_ERR;
}
static int nand_erase_block(uffs_Device *dev, unsigned block)
{
	int res;
	res = rt_mtd_nand_erase_block(RT_MTD_NAND_DEVICE(dev->_private), block);
	return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR;
}

#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
static int nand_check_block(uffs_Device *dev, unsigned block)
{
	int res;
	res = rt_mtd_nand_check_block(RT_MTD_NAND_DEVICE(dev->_private), block);
	return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK;
}

static int nand_mark_badblock(uffs_Device *dev, unsigned block)
{
	int res;
	res = rt_mtd_nand_mark_badblock(RT_MTD_NAND_DEVICE(dev->_private), block);
	return res == RT_EOK ? UFFS_FLASH_NO_ERR : UFFS_FLASH_IO_ERR;
}
#endif

#if (RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_NONE) || (RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_SOFT)

static int nand_read_page(
    uffs_Device *dev,
    u32 block, u32 page,
    u8 *data, int data_len,
    u8 * ecc,
    rt_uint8_t *spare, int spare_len)
{
	int res;

	page = block * dev->attr->pages_per_block + page;
	if (data == NULL && spare == NULL)
	{
#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
		RT_ASSERT(0); //should not be here
#else
		/* check block status: bad or good */
		rt_uint8_t spare[UFFS_MAX_SPARE_SIZE];

		rt_memset(spare, 0, UFFS_MAX_SPARE_SIZE);

		rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private),
		                 page, RT_NULL, 0,
		                 spare, dev->attr->spare_size);//dev->mem.spare_data_size

		res = spare[dev->attr->block_status_offs] == 0xFF ?
				               UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK;
		return res;
#endif
	}

	rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private),
	                   	   page, data, data_len, spare, spare_len);

	return UFFS_FLASH_NO_ERR;
}

static int nand_write_page(
    uffs_Device *dev,
    u32 block, u32 page,
    const u8 *data, int data_len,
    const u8 *spare, int spare_len)
{
	int res;

	RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size);

	page = block * dev->attr->pages_per_block + page;

	if (data == NULL && spare == NULL)
	{
#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
		RT_ASSERT(0); //should not be here
#else
		/* mark bad block  */
		rt_uint8_t spare[UFFS_MAX_SPARE_SIZE];

		rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE);
		spare[dev->attr->block_status_offs] =  0x00;

		res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private),
		                        page, RT_NULL, 0,
		                        spare, dev->attr->spare_size);//dev->mem.spare_data_size
		if (res != RT_EOK)
			goto __error;
#endif
	}

	res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private),
	                   	   page,  data, data_len, spare, spare_len);
	if (res != RT_EOK)
		goto __error;

	return UFFS_FLASH_NO_ERR;

__error:
	return UFFS_FLASH_IO_ERR;
}

const uffs_FlashOps nand_ops =
{
	nand_init_flash,	/* InitFlash() */
	nand_release_flash,	/* ReleaseFlash() */
	nand_read_page,		/* ReadPage() */
	NULL,				/* ReadPageWithLayout */
	nand_write_page,	/* WritePage() */
	NULL,				/* WirtePageWithLayout */
#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
	nand_check_block,
	nand_mark_badblock,
#else
	NULL,               /* IsBadBlock(), let UFFS take care of it. */
	NULL,               /* MarkBadBlock(), let UFFS take care of it. */
#endif
	nand_erase_block,	/* EraseBlock() */
};

void uffs_setup_storage(
    struct uffs_StorageAttrSt *attr,
    struct rt_mtd_nand_device * nand)
{
	rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt));

//	attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */
	attr->page_data_size = nand->page_size;                /* page data size */
	attr->pages_per_block = nand->pages_per_block;         /* pages per block */
	attr->spare_size = nand->oob_size;                     /* page spare size */
	attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE;               /* ecc option */
	attr->ecc_size = 0;                                    /* ecc size is 0 , the uffs will calculate the ecc size*/
	attr->block_status_offs = attr->ecc_size;              /* indicate block bad or good, offset in spare */
	attr->layout_opt = RT_CONFIG_UFFS_LAYOUT;              /* let UFFS do the spare layout */
}

#elif  RT_CONFIG_UFFS_ECC_MODE == UFFS_ECC_HW_AUTO

static int WritePageWithLayout(
	uffs_Device *dev, u32 block, u32 page,
	const u8 *data, int data_len,
	const u8 *ecc,  //NULL
	const uffs_TagStore *ts)
{
	int res;
	int spare_len;
	rt_uint8_t spare[UFFS_MAX_SPARE_SIZE];

	RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size);

	page = block * dev->attr->pages_per_block + page;
	spare_len = dev->mem.spare_data_size;

	if (data == NULL && ts == NULL)
	{
#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
		RT_ASSERT(0); //should not be here
#else
		/* mark bad block  */
		rt_memset(spare, 0xFF, UFFS_MAX_SPARE_SIZE);
		spare[dev->attr->block_status_offs] =  0x00;

		res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private),
		                        page, RT_NULL, 0,
		                        spare, dev->attr->spare_size);//dev->mem.spare_data_size
		if (res != RT_EOK)
			goto __error;

		dev->st.io_write++;
		return UFFS_FLASH_NO_ERR;

#endif
	}

	if (data != NULL && data_len != 0)
	{
		RT_ASSERT(data_len == dev->attr->page_data_size);

		dev->st.page_write_count++;
		dev->st.io_write += data_len;
	}

	if (ts != RT_NULL)
	{
		uffs_FlashMakeSpare(dev, ts, RT_NULL, (u8 *)spare);
		dev->st.spare_write_count++;
		dev->st.io_write += spare_len;
	}

	res = rt_mtd_nand_write(RT_MTD_NAND_DEVICE(dev->_private),
	                   	   page,  data, data_len, spare, spare_len);
	if (res != RT_EOK)
		goto __error;

	return UFFS_FLASH_NO_ERR;

__error:
	return UFFS_FLASH_IO_ERR;
}

static URET ReadPageWithLayout(
	uffs_Device *dev, u32 block, u32 page,
	u8* data, int data_len,
	u8 *ecc,              //NULL
	uffs_TagStore *ts,
	u8 *ecc_store)        //NULL
{
	int res = UFFS_FLASH_NO_ERR;
	int spare_len;
	rt_uint8_t spare[UFFS_MAX_SPARE_SIZE];

	RT_ASSERT(UFFS_MAX_SPARE_SIZE >= dev->attr->spare_size);

	page = block * dev->attr->pages_per_block + page;
	spare_len = dev->mem.spare_data_size;

	if (data == RT_NULL && ts == RT_NULL)
	{
#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
		RT_ASSERT(0); //should not be here
#else
		/* check block good or bad */

		rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private),
		                 page, RT_NULL, 0,
		                 spare, dev->attr->spare_size);//dev->mem.spare_data_size

		dev->st.io_read++;

		res = spare[dev->attr->block_status_offs] == 0xFF ?
				               UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK;
		return res;
#endif
	}

	if (data != RT_NULL)
	{
		dev->st.io_read += data_len;
		dev->st.page_read_count++;
	}

	res = rt_mtd_nand_read(RT_MTD_NAND_DEVICE(dev->_private),
	                   	   page, data, data_len, spare, spare_len);
	if (res == 0)
		res = UFFS_FLASH_NO_ERR;
	else if (res == -1)
	{
		//TODO ecc correct, add code to use hardware do ecc correct
		res = UFFS_FLASH_ECC_OK;
	}
	else
		res = UFFS_FLASH_ECC_FAIL;

	if (ts != RT_NULL)
	{
		// unload ts and ecc from spare, you can modify it if you like
		uffs_FlashUnloadSpare(dev, (const u8 *)spare, ts, RT_NULL);

		if ((spare[spare_len - 1] == 0xFF) && (res == UFFS_FLASH_NO_ERR))
			res = UFFS_FLASH_NOT_SEALED;

		dev->st.io_read += spare_len;
		dev->st.spare_read_count++;
	}

	return res;
}

const uffs_FlashOps nand_ops =
{
	nand_init_flash,    /* InitFlash() */
	nand_release_flash, /* ReleaseFlash() */
	NULL,               /* ReadPage() */
	ReadPageWithLayout,	/* ReadPageWithLayout */
	NULL,               /* WritePage() */
	WritePageWithLayout,/* WirtePageWithLayout */

#if defined(RT_UFFS_USE_CHECK_MARK_FUNCITON)
	nand_check_block,
	nand_mark_badblock,
#else
	NULL,               /* IsBadBlock(), let UFFS take care of it. */
	NULL,               /* MarkBadBlock(), let UFFS take care of it. */
#endif
	nand_erase_block,   /* EraseBlock() */
};

static rt_uint8_t hw_flash_data_layout[UFFS_SPARE_LAYOUT_SIZE] =
{0x05, 0x08, 0xFF, 0x00};

static rt_uint8_t hw_flash_ecc_layout[UFFS_SPARE_LAYOUT_SIZE] =
{0x00, 0x04, 0xFF, 0x00};

void uffs_setup_storage(
    struct uffs_StorageAttrSt *attr,
    struct rt_mtd_nand_device * nand)
{
	rt_memset(attr, 0, sizeof(struct uffs_StorageAttrSt));

//	attr->total_blocks = nand->end_block - nand->start_block + 1;/* no use */
	attr->page_data_size = nand->page_size;                /* page data size */
	attr->pages_per_block = nand->pages_per_block;         /* pages per block */
	attr->spare_size = nand->oob_size;                     /* page spare size */
	attr->ecc_opt = RT_CONFIG_UFFS_ECC_MODE;               /* ecc option */
	attr->ecc_size = nand->oob_size-nand->oob_free;        /* ecc size */
	attr->block_status_offs = attr->ecc_size;              /* indicate block bad or good, offset in spare */
	attr->layout_opt = RT_CONFIG_UFFS_LAYOUT;              /* let UFFS do the spare layout */

	/* calculate the ecc layout array */
	hw_flash_data_layout[0] = attr->ecc_size + 1; /* ecc size + 1byte block status */
	hw_flash_data_layout[1] = 0x08;
	hw_flash_data_layout[2] = 0xFF;
	hw_flash_data_layout[3] = 0x00;

	hw_flash_ecc_layout[0] = 0;
	hw_flash_ecc_layout[1] = attr->ecc_size;
	hw_flash_ecc_layout[2] = 0xFF;
	hw_flash_ecc_layout[3] = 0x00;

	/* initialize  _uffs_data_layout and _uffs_ecc_layout */
	rt_memcpy(attr->_uffs_data_layout, hw_flash_data_layout, UFFS_SPARE_LAYOUT_SIZE);
	rt_memcpy(attr->_uffs_ecc_layout, hw_flash_ecc_layout, UFFS_SPARE_LAYOUT_SIZE);

	attr->data_layout = attr->_uffs_data_layout;
	attr->ecc_layout = attr->_uffs_ecc_layout;
}
#endif