/*
 * NAND Flash Controller Device Driver
 * Copyright (c) 2009, Intel Corporation and its suppliers.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#include "spectraswconfig.h"
#include "ffsport.h"
#include "ffsdefs.h"
#include "lld.h"
#include "lld_nand.h"

/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
#if FLASH_EMU		/* vector all the LLD calls to the LLD_EMU code */
#include "lld_emu.h"
#include "lld_cdma.h"

/* common functions: */
u16 GLOB_LLD_Flash_Reset(void)
{
	return emu_Flash_Reset();
}

u16 GLOB_LLD_Read_Device_ID(void)
{
	return emu_Read_Device_ID();
}

int GLOB_LLD_Flash_Release(void)
{
	return emu_Flash_Release();
}

u16 GLOB_LLD_Flash_Init(void)
{
	return emu_Flash_Init();
}

u16 GLOB_LLD_Erase_Block(u32 block_add)
{
	return emu_Erase_Block(block_add);
}

u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page,
				u16 PageCount)
{
	return emu_Write_Page_Main(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 Page,
			       u16 PageCount)
{
	return emu_Read_Page_Main(read_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data,
			u32 block, u16 page, u16 page_count)
{
	return emu_Read_Page_Main(read_data, block, page, page_count);
}

u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block,
				      u16 Page, u16 PageCount)
{
	return emu_Write_Page_Main_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block,
				     u16 Page, u16 PageCount)
{
	return emu_Read_Page_Main_Spare(read_data, block, Page, PageCount);
}

u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page,
				 u16 PageCount)
{
	return emu_Write_Page_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page,
				u16 PageCount)
{
	return emu_Read_Page_Spare(read_data, block, Page, PageCount);
}

u16  GLOB_LLD_Get_Bad_Block(u32 block)
{
    return  emu_Get_Bad_Block(block);
}

#endif /* FLASH_EMU */

/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
#if FLASH_MTD		/* vector all the LLD calls to the LLD_MTD code */
#include "lld_mtd.h"
#include "lld_cdma.h"

/* common functions: */
u16 GLOB_LLD_Flash_Reset(void)
{
	return mtd_Flash_Reset();
}

u16 GLOB_LLD_Read_Device_ID(void)
{
	return mtd_Read_Device_ID();
}

int GLOB_LLD_Flash_Release(void)
{
	return mtd_Flash_Release();
}

u16 GLOB_LLD_Flash_Init(void)
{
	return mtd_Flash_Init();
}

u16 GLOB_LLD_Erase_Block(u32 block_add)
{
	return mtd_Erase_Block(block_add);
}

u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page,
				u16 PageCount)
{
	return mtd_Write_Page_Main(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 Page,
			       u16 PageCount)
{
	return mtd_Read_Page_Main(read_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data,
			u32 block, u16 page, u16 page_count)
{
	return mtd_Read_Page_Main(read_data, block, page, page_count);
}

u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block,
				      u16 Page, u16 PageCount)
{
	return mtd_Write_Page_Main_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block,
				     u16 Page, u16 PageCount)
{
	return mtd_Read_Page_Main_Spare(read_data, block, Page, PageCount);
}

u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page,
				 u16 PageCount)
{
	return mtd_Write_Page_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page,
				u16 PageCount)
{
	return mtd_Read_Page_Spare(read_data, block, Page, PageCount);
}

u16  GLOB_LLD_Get_Bad_Block(u32 block)
{
    return  mtd_Get_Bad_Block(block);
}

#endif /* FLASH_MTD */

/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
#if FLASH_NAND	/* vector all the LLD calls to the NAND controller code */
#include "lld_nand.h"
#include "lld_cdma.h"
#include "flash.h"

/* common functions for LLD_NAND */
void GLOB_LLD_ECC_Control(int enable)
{
	NAND_ECC_Ctrl(enable);
}

/* common functions for LLD_NAND */
u16 GLOB_LLD_Flash_Reset(void)
{
	return NAND_Flash_Reset();
}

u16 GLOB_LLD_Read_Device_ID(void)
{
	return NAND_Read_Device_ID();
}

u16 GLOB_LLD_UnlockArrayAll(void)
{
	return NAND_UnlockArrayAll();
}

u16 GLOB_LLD_Flash_Init(void)
{
	return NAND_Flash_Init();
}

int GLOB_LLD_Flash_Release(void)
{
	return nand_release_spectra();
}

u16 GLOB_LLD_Erase_Block(u32 block_add)
{
	return NAND_Erase_Block(block_add);
}


u16 GLOB_LLD_Write_Page_Main(u8 *write_data, u32 block, u16 Page,
				u16 PageCount)
{
	return NAND_Write_Page_Main(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main(u8 *read_data, u32 block, u16 page,
			       u16 page_count)
{
	if (page_count == 1) /* Using polling to improve read speed */
		return NAND_Read_Page_Main_Polling(read_data, block, page, 1);
	else
		return NAND_Read_Page_Main(read_data, block, page, page_count);
}

u16 GLOB_LLD_Read_Page_Main_Polling(u8 *read_data,
			u32 block, u16 page, u16 page_count)
{
	return NAND_Read_Page_Main_Polling(read_data,
			block, page, page_count);
}

u16 GLOB_LLD_Write_Page_Main_Spare(u8 *write_data, u32 block,
				      u16 Page, u16 PageCount)
{
	return NAND_Write_Page_Main_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Write_Page_Spare(u8 *write_data, u32 block, u16 Page,
				 u16 PageCount)
{
	return NAND_Write_Page_Spare(write_data, block, Page, PageCount);
}

u16 GLOB_LLD_Read_Page_Main_Spare(u8 *read_data, u32 block,
				     u16 page, u16 page_count)
{
	return NAND_Read_Page_Main_Spare(read_data, block, page, page_count);
}

u16 GLOB_LLD_Read_Page_Spare(u8 *read_data, u32 block, u16 Page,
				u16 PageCount)
{
	return NAND_Read_Page_Spare(read_data, block, Page, PageCount);
}

u16  GLOB_LLD_Get_Bad_Block(u32 block)
{
	return  NAND_Get_Bad_Block(block);
}

#if CMD_DMA
u16 GLOB_LLD_Event_Status(void)
{
	return CDMA_Event_Status();
}

u16 glob_lld_execute_cmds(void)
{
	return CDMA_Execute_CMDs();
}

u16 GLOB_LLD_MemCopy_CMD(u8 *dest, u8 *src,
			u32 ByteCount, u16 flag)
{
	/* Replace the hardware memcopy with software memcpy function */
	if (CDMA_Execute_CMDs())
		return FAIL;
	memcpy(dest, src, ByteCount);
	return PASS;

	/* return CDMA_MemCopy_CMD(dest, src, ByteCount, flag); */
}

u16 GLOB_LLD_Erase_Block_cdma(u32 block, u16 flags)
{
	return CDMA_Data_CMD(ERASE_CMD, 0, block, 0, 0, flags);
}

u16 GLOB_LLD_Write_Page_Main_cdma(u8 *data, u32 block, u16 page, u16 count)
{
	return CDMA_Data_CMD(WRITE_MAIN_CMD, data, block, page, count, 0);
}

u16 GLOB_LLD_Read_Page_Main_cdma(u8 *data, u32 block, u16 page,
				u16 count, u16 flags)
{
	return CDMA_Data_CMD(READ_MAIN_CMD, data, block, page, count, flags);
}

u16 GLOB_LLD_Write_Page_Main_Spare_cdma(u8 *data, u32 block, u16 page,
					u16 count, u16 flags)
{
	return CDMA_Data_CMD(WRITE_MAIN_SPARE_CMD,
			data, block, page, count, flags);
}

u16 GLOB_LLD_Read_Page_Main_Spare_cdma(u8 *data,
				u32 block, u16 page, u16 count)
{
	return CDMA_Data_CMD(READ_MAIN_SPARE_CMD, data, block, page, count,
			LLD_CMD_FLAG_MODE_CDMA);
}

#endif /* CMD_DMA */
#endif /* FLASH_NAND */

/*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/

/* end of LLD.c */