![David Woodhouse](/assets/img/avatar_default.png)
It'll take some work before this is really shippable. Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
340 lines
7.8 KiB
C
340 lines
7.8 KiB
C
/*
|
|
* 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 */
|