/*----------------------------------------------------------------------------
* RL-ARM - FlashFS
*----------------------------------------------------------------------------
* Name: FILE_LIB.C
* Purpose: FlashFS System Configuration
* Rev.: V4.20
*----------------------------------------------------------------------------
* This code is part of the RealView Run-Time Library.
* Copyright (c) 2004-2011 KEIL - An ARM Company. All rights reserved.
*---------------------------------------------------------------------------*/
#include <absacc.h>
#pragma thumb
#pragma O3
/*----------------------------------------------------------------------------
* Library for File_Config.c
*---------------------------------------------------------------------------*/
/* If MC1 drive not defined */
#ifndef MC1_EN
#define MC1_EN 0
#define MC1_DEF 0
#endif
/* If USB1 drive not defined */
#ifndef USB1_EN
#define USB1_EN 0
#define USB1_DEF 0
#endif
/* Check number of enabled drives */
#define FS_NDRV (FL0_EN + \
SF0_EN + \
RAM0_EN + \
MC0_EN + MC1_EN + \
USB0_EN + USB1_EN + \
NAND0_EN)
#if (FS_NDRV == 0)
#error all drives disabled in configuration
#endif
/* Check Default drive settings */
#define __DEF ((FL0_DEF & FL0_EN) + \
(SF0_DEF & SF0_EN) + \
(RAM0_DEF & RAM0_EN) + \
(MC0_DEF & MC0_EN) + (MC1_DEF & MC1_EN) + \
(USB0_DEF & USB0_EN) + (USB1_DEF & USB1_EN) + \
(NAND0_DEF & NAND0_EN))
#if (__DEF == 0)
#error default drive not specified
#elif (__DEF > 1)
#error multiple default drives enabled
#endif
/* Check FS usage */
#define EFS_USE (FL0_EN + SF0_EN + RAM0_EN)
#define FAT_USE (MC0_EN + MC1_EN + USB0_EN + USB1_EN + NAND0_EN)
/* Memory resources allocated by the Flash File System */
struct iob _iob[N_FILES];
/* Exported Defines to other modules */
U16 const _NFILE = N_FILES;
U16 const _NDRV = FS_NDRV;
/*----------------------------------------------------------------------------
* Parallel Flash device FL0 configuration
*---------------------------------------------------------------------------*/
#if (FL0_EN)
extern EFS_DRV fl0_drv;
/* Parallel Flash Device Configuration Table */
#define DFB(sz,adr) { (U32)adr+FL0_BADR, ((U32)(adr+sz)-4)+FL0_BADR }
#include FL0_HFILE
static EFS_CFG fl0_cfg [FL_NSECT] = { FLASH_DEVICE };
static EFS_VI fl0_vol;
#endif
/*----------------------------------------------------------------------------
* SPI Flash device SF0 configuration
*---------------------------------------------------------------------------*/
#if (SF0_EN)
extern EFS_DRV sf0_drv;
#define DSB(size,badr) { (U32)badr, ((U32)(badr+size)-4) }
#include SF0_HFILE
/* Flash Device Configuration Table */
static EFS_CFG sf0_cfg [SF_NSECT] = { SPI_FLASH_DEVICE };
static EFS_VI sf0_vol;
#endif
/*----------------------------------------------------------------------------
* RAM device RAM0 configuration
*---------------------------------------------------------------------------*/
#if (RAM0_EN)
#define RBS ((RAM0_SIZE / RAM0_NSECT) & ~3)
#define DRB(n) {(U32)RBS*n+RAM0_BADR, ((U32)(RBS*(n+1))-4)+RAM0_BADR}
/* Ram Device Configuration Table */
static EFS_CFG ram0_cfg [RAM0_NSECT] = {
DRB(0), DRB(1), DRB(2), DRB(3), DRB(4), DRB(5), DRB(6), DRB(7),
#if RAM0_NSECT > 8
DRB(8), DRB(9), DRB(10), DRB(11), DRB(12), DRB(13), DRB(14), DRB(15),
#endif
#if RAM0_NSECT > 16
DRB(16), DRB(17), DRB(18), DRB(19), DRB(20), DRB(21), DRB(22), DRB(23),
DRB(24), DRB(25), DRB(26), DRB(27), DRB(28), DRB(29), DRB(30), DRB(31),
#endif
#if RAM0_NSECT > 32
DRB(32), DRB(33), DRB(34), DRB(35), DRB(36), DRB(37), DRB(38), DRB(39),
DRB(40), DRB(41), DRB(42), DRB(43), DRB(44), DRB(45), DRB(46), DRB(47),
DRB(48), DRB(49), DRB(50), DRB(51), DRB(52), DRB(53), DRB(54), DRB(55),
DRB(56), DRB(57), DRB(58), DRB(59), DRB(60), DRB(61), DRB(62), DRB(63),
#endif
#if RAM0_NSECT > 64
DRB(64), DRB(65), DRB(66), DRB(67), DRB(68), DRB(69), DRB(70), DRB(71),
DRB(72), DRB(73), DRB(74), DRB(75), DRB(76), DRB(77), DRB(78), DRB(79),
DRB(80), DRB(81), DRB(82), DRB(83), DRB(84), DRB(85), DRB(86), DRB(87),
DRB(88), DRB(89), DRB(90), DRB(91), DRB(92), DRB(93), DRB(94), DRB(95),
DRB(96), DRB(97), DRB(98), DRB(99), DRB(100),DRB(101),DRB(102),DRB(103),
DRB(104),DRB(105),DRB(106),DRB(107),DRB(108),DRB(109),DRB(110),DRB(111),
DRB(112),DRB(113),DRB(114),DRB(115),DRB(116),DRB(117),DRB(118),DRB(119),
DRB(120),DRB(121),DRB(122),DRB(123),DRB(124),DRB(125),DRB(126),DRB(127),
#endif
};
#if (RAM0_RELOC == 1)
#define __AT_RAM0 __at(RAM0_BADR)
#else
#define __AT_RAM0
#endif
/* RAM Device data buffer */
static U32 ram0_buf[(RAM0_SIZE/4)] __AT_RAM0;
static EFS_VI ram0_vol;
#endif
/*----------------------------------------------------------------------------
* Memory Card device MC0 configuration
*---------------------------------------------------------------------------*/
#if (MC0_EN)
#if (MC0_RELOC == 1)
#define __AT_MC0 __at(MC0_CADR)
#else
#define __AT_MC0
#endif
/* MC0 Cache Buffer for Data and FAT Caching */
static U32 mc0_cache[(MC0_CASZ+1) * 256] __AT_MC0;
static FAT_VI mc0_vol;
#if (MC0_SPI == 0)
/* SD Native bus mode */
extern MCI_DRV mci0_drv;
static MCI_DEV mci0_dev;
#define MC0_INIT(m) mci_Init (m,&mci0_dev)
#define MC0_UNINIT(m) mci_UnInit (m,&mci0_dev)
#define MC0_RDSEC(s,b,c) mci_ReadSector (s,b,c,&mci0_dev)
#define MC0_WRSEC(s,b,c) mci_WriteSector (s,b,c,&mci0_dev)
#define MC0_RDINFO(i) mci_ReadInfo (i,&mci0_dev)
#define MC0_CHKMEDIA mci0_drv.CheckMedia
#else
/* SPI bus mode */
extern SPI_DRV spi0_drv;
static MMC_DEV mmc0_dev;
#define MC0_INIT(m) mmc_Init (m,&mmc0_dev)
#define MC0_UNINIT(m) mmc_UnInit (m,&mmc0_dev)
#define MC0_RDSEC(s,b,c) mmc_ReadSector (s,b,c,&mmc0_dev)
#define MC0_WRSEC(s,b,c) mmc_WriteSector (s,b,c,&mmc0_dev)
#define MC0_RDINFO(i) mmc_ReadInfo (i,&mmc0_dev)
#define MC0_CHKMEDIA spi0_drv.CheckMedia
#endif
/* MC0 wrapper functions */
static BOOL mc0_Init (U32 mode) {
return (MC0_INIT (mode));
}
static BOOL mc0_UnInit (U32 mode) {
return (MC0_UNINIT (mode));
}
static BOOL mc0_RdSect (U32 sect, U8 *buf, U32 cnt) {
return (MC0_RDSEC (sect, buf, cnt));
}
static BOOL mc0_WrSect (U32 sect, U8 *buf, U32 cnt) {
return (MC0_WRSEC (sect, buf, cnt));
}
static BOOL mc0_RdInfo (Media_INFO *info) {
return (MC0_RDINFO (info));
}
static U32 mc0_ChkMedia (void) {
if (!MC0_CHKMEDIA) return (M_INSERTED);
return (MC0_CHKMEDIA());
}
/* MC0 FAT device driver */
FAT_DRV mc0_drv = {
mc0_Init,
mc0_UnInit,
mc0_RdSect,
mc0_WrSect,
mc0_RdInfo,
mc0_ChkMedia,
};
#endif
/*----------------------------------------------------------------------------
* Memory Card device MC1 configuration
*---------------------------------------------------------------------------*/
#if (MC1_EN)
#if (MC1_RELOC == 1)
#define __AT_MC1 __at(MC1_CADR)
#else
#define __AT_MC1
#endif
/* MC1 Cache Buffer for Data and FAT Caching */
static U32 mc1_cache[(MC1_CASZ+1) * 256] __AT_MC1;
static FAT_VI mc1_vol;
#if (MC1_SPI == 0)
/* SD Native bus mode */
extern MCI_DRV mci1_drv;
static MCI_DEV mci1_dev;
#define MC1_INIT(m) mci_Init (m,&mci1_dev)
#define MC1_UNINIT(m) mci_UnInit (m,&mci1_dev)
#define MC1_RDSEC(s,b,c) mci_ReadSector (s,b,c,&mci1_dev)
#define MC1_WRSEC(s,b,c) mci_WriteSector (s,b,c,&mci1_dev)
#define MC1_RDINFO(i) mci_ReadInfo (i,&mci1_dev)
#define MC1_CHKMEDIA mci1_drv.CheckMedia
#else
/* SPI bus mode */
extern SPI_DRV spi1_drv;
static MMC_DEV mmc1_dev;
#define MC1_INIT(m) mmc_Init (m,&mmc1_dev)
#define MC1_UNINIT(m) mmc_UnInit (m,&mmc1_dev)
#define MC1_RDSEC(s,b,c) mmc_ReadSector (s,b,c,&mmc1_dev)
#define MC1_WRSEC(s,b,c) mmc_WriteSector (s,b,c,&mmc1_dev)
#define MC1_RDINFO(i) mmc_ReadInfo (i,&mmc1_dev)
#define MC1_CHKMEDIA spi1_drv.CheckMedia
#endif
/* MC1 wrapper functions */
static BOOL mc1_Init (U32 mode) {
return (MC1_INIT (mode));
}
static BOOL mc1_UnInit (U32 mode) {
return (MC1_UNINIT (mode));
}
static BOOL mc1_RdSect (U32 sect, U8 *buf, U32 cnt) {
return (MC1_RDSEC (sect, buf, cnt));
}
static BOOL mc1_WrSect (U32 sect, U8 *buf, U32 cnt) {
return (MC1_WRSEC (sect, buf, cnt));
}
static BOOL mc1_RdInfo (Media_INFO *info) {
return (MC1_RDINFO (info));
}
static U32 mc1_ChkMedia (void) {
if (!MC1_CHKMEDIA) return (M_INSERTED);
return (MC1_CHKMEDIA());
}
/* MC1 FAT device driver */
FAT_DRV mc1_drv = {
mc1_Init,
mc1_UnInit,
mc1_RdSect,
mc1_WrSect,
mc1_RdInfo,
mc1_ChkMedia
};
#endif
/*----------------------------------------------------------------------------
* USB Flash device USB0 configuration
*---------------------------------------------------------------------------*/
#if (USB0_EN)
extern FAT_DRV usb0_drv;
/* USB Cache Buffer for Data and FAT Caching */
static U32 usb0_cache[(USB0_CASZ+1) * 256];
static FAT_VI usb0_vol;
#endif
/*----------------------------------------------------------------------------
* USB Flash device USB1 configuration
*---------------------------------------------------------------------------*/
#if (USB1_EN)
extern FAT_DRV usb1_drv;
/* USB Cache Buffer for Data and FAT Caching */
static U32 usb1_cache[(USB1_CASZ+1) * 256];
static FAT_VI usb1_vol;
#endif
/*----------------------------------------------------------------------------
* NAND Flash device NAND0 configuration
*---------------------------------------------------------------------------*/
#if (NAND0_EN)
extern NAND_DRV nand0_drv;
#if (NAND0_RELOC == 1)
#define __AT_NAND0 __at(NAND0_CADR)
#else
#define __AT_NAND0
#endif
/* NAND Cache Buffer for FAT, Page and Block Caching */
#define NAND0_CSZ ((NAND0_CASZ+1) * 1024 + \
(NAND0_CAPG+2) * NAND0_PGSZ + \
(NAND0_CABL+2) * NAND0_PGCNT)
static U32 nand0_cache[NAND0_CSZ/4] __AT_NAND0;
static PAGE_CACHE nand0_capg[NAND0_CAPG+1];
static BLOCK_CACHE nand0_cabl[NAND0_CABL+2];
static U32 nand0_ttsn[NAND_TSN_SIZE(NAND0_BLCNT,NAND0_PGSZ)];
static NAND_FTL_DEV nand0_dev;
static FAT_VI nand0_vol;
/* NAND Flash Configuration */
static NAND_FTL_CFG nand0_cfg = {
/* NAND Flash Geometry */
{ &nand0_dev.PgLay,
NAND0_BLCNT,
NAND0_PGCNT,
NAND0_PGSZ,
NAND_SEC_BLOCK (NAND0_PGCNT,NAND0_PGSZ),
NAND_SEC_PAGE (NAND0_PGSZ),
NAND_ADDR_CYCLES (NAND0_BLCNT,NAND0_PGCNT,NAND0_PGSZ),
NAND0_SWECC,
0
},
/* Block Translation Table Space */
1,
NAND_BTT_SIZE (NAND0_BLCNT),
/* Data Space */
NAND_BTT_SIZE (NAND0_BLCNT) + 1,
NAND0_BLCNT - 1,
/* Caching */
NAND0_CABL + 2,
NAND0_CAPG + 1,
NAND_TSN_SIZE(NAND0_BLCNT,NAND0_PGSZ),
/* Page buffer & Caches */
(U8 *)&nand0_cache[(NAND0_CASZ+1)*256],
&nand0_cabl[0],
(U8 *)&nand0_cache[(NAND0_CASZ+1)*256+(NAND0_CAPG+2)*NAND0_PGSZ/4],
&nand0_capg[0],
(U8 *)&nand0_cache[(NAND0_CASZ+1)*256+NAND0_PGSZ/4],
&nand0_ttsn[0]
};
/* NAND0 wrapper functions */
static BOOL nand0_Init (U32 mode) {
return (ftl_Init (mode, &nand0_dev));
}
static BOOL nand0_UnInit (U32 mode) {
return (ftl_UnInit (mode, &nand0_dev));
}
static BOOL nand0_RdSect (U32 sect, U8 *buf, U32 cnt) {
U32 retv = ftl_ReadSect (sect, buf, cnt, &nand0_dev);
if (retv == RTV_NOERR) return (__TRUE);
else return (__FALSE);
}
static BOOL nand0_WrSect (U32 sect, U8 *buf, U32 cnt) {
U32 retv = ftl_WriteSect (sect, buf, cnt, &nand0_dev);
if (retv == RTV_NOERR || retv == ERR_FTL_WARN) return (__TRUE);
else return (__FALSE);
}
static BOOL nand0_RdInfo (Media_INFO *info) {
return (ftl_ReadInfo (info, &nand0_dev));
}
FAT_DRV nfat0_drv = {
nand0_Init,
nand0_UnInit,
nand0_RdSect,
nand0_WrSect,
nand0_RdInfo,
NULL
};
#endif
/*----------------------------------------------------------------------------
* An array of installed Device drivers
*---------------------------------------------------------------------------*/
FS_DEV fs_DevPool[FS_NDRV] = {
#if (FL0_EN)
{ &fl0_vol, "F0", FS_EMB | FL0_DEF },
#endif
#if (SF0_EN)
{ &sf0_vol, "S0", FS_EMB | SF0_DEF },
#endif
#if (RAM0_EN)
{ &ram0_vol, "R0", FS_EMB | RAM0_DEF },
#endif
#if (MC0_EN)
{ &mc0_vol, "M0", FS_FAT | MC0_DEF | FS_IOC },
#endif
#if (MC1_EN)
{ &mc1_vol, "M1", FS_FAT | MC1_DEF | FS_IOC },
#endif
#if (USB0_EN)
{ &usb0_vol, "U0", FS_FAT | USB0_DEF },
#endif
#if (USB1_EN)
{ &usb1_vol, "U1", FS_FAT | USB1_DEF },
#endif
#if (NAND0_EN)
{ &nand0_vol,"N0", FS_FAT | NAND0_DEF| FS_IOC },
#endif
};
/*----------------------------------------------------------------------------
* Configure Flash File System
*---------------------------------------------------------------------------*/
void fs_config (void) {
#if (FL0_EN)
fl0_vol.BaseAdr = FL0_BADR;
fl0_vol.InitVal = (U32)0x1010101 * FL0_INITV;
fl0_vol.NumSect = sizeof(fl0_cfg)/sizeof(EFS_CFG);
fl0_vol.Size = FL0_SIZE;
fl0_vol.DevCfg = fl0_cfg;
fl0_vol.drv = &fl0_drv;
fl0_vol.CpuClk = CPU_CLK;
#endif
#if (SF0_EN)
sf0_vol.BaseAdr = 0;
sf0_vol.InitVal = (U32)0x1010101 * SF0_INITV;
sf0_vol.NumSect = sizeof(sf0_cfg)/sizeof(EFS_CFG);
sf0_vol.Size = SF0_SIZE;
sf0_vol.DevCfg = sf0_cfg;
sf0_vol.drv = &sf0_drv;
sf0_vol.CpuClk = CPU_CLK;
#endif
#if (RAM0_EN)
ram0_vol.BaseAdr= (U32)ram0_buf;
ram0_vol.InitVal= 0;
ram0_vol.NumSect= RAM0_NSECT;
ram0_vol.Size = RAM0_SIZE;
ram0_vol.DevCfg = ram0_cfg;
ram0_vol.drv = NULL;
#endif
#if (MC0_EN)
mc0_vol.CaSize = MC0_CASZ * 2;
mc0_vol.CaBuf = mc0_cache;
mc0_vol.drv = &mc0_drv;
#if (MC0_SPI == 0)
/* Register MCI driver for SD-Native mode */
mci0_dev.drv = &mci0_drv;
#else
/* Register SPI driver for SPI mode */
mmc0_dev.spi = &spi0_drv;
#endif
#endif
#if (MC1_EN)
mc1_vol.CaSize = MC1_CASZ * 2;
mc1_vol.CaBuf = mc1_cache;
mc1_vol.drv = &mc1_drv;
#if (MC1_SPI == 0)
/* Register MCI driver for SD-Native mode */
mci1_dev.drv = &mci1_drv;
#else
/* Register SPI driver for SPI mode */
mmc1_dev.spi = &spi1_drv;
#endif
#endif
#if (USB0_EN)
usb0_vol.CaSize = USB0_CASZ * 2;
usb0_vol.CaBuf = usb0_cache;
usb0_vol.drv = &usb0_drv;
#endif
#if (USB1_EN)
usb1_vol.CaSize = USB1_CASZ * 2;
usb1_vol.CaBuf = usb1_cache;
usb1_vol.drv = &usb1_drv;
#endif
#if (NAND0_EN)
nand0_vol.CaSize= NAND0_CASZ * 2;
nand0_vol.CaBuf = nand0_cache;
nand0_vol.drv = &nfat0_drv;
nand0_dev.Cfg = &nand0_cfg;
nand0_dev.Drv = &nand0_drv;
#endif
}
#if (EFS_USE == 0)
/* Empty functions to reduce image size when EFS not used */
BOOL efs_rename (const char *filename, IOB *fcb) { return (__FALSE); }
BOOL efs_create (const char *fname, IOB *fcb) { return (__FALSE); }
BOOL efs_delete (IOB *fcb) { return (__FALSE); }
U32 efs_free (EFS_VI *vi) { return (0); }
BOOL efs_format (EFS_VI *vi) { return (__FALSE); }
BOOL efs_ffind (FINFO *info, IOB *fcb) { return (__FALSE); }
BOOL efs_wclose (IOB *fcb) { return (__FALSE); }
U32 efs_read (IOB *fcb, U8 *buf, U32 len) { return (0); }
BOOL efs_write (IOB *fcb, const U8 *buf, U32 len){ return (__FALSE); }
BOOL efs_ensure (IOB *fcb) { return (__FALSE); }
BOOL efs_seek (IOB *fcb, U32 pos) { return (__FALSE); }
void efs_fsize (IOB *fcb) { ; }
BOOL efs_find (const char *name, IOB *fcb) { return (__FALSE); }
int efs_analyse (EFS_VI *vi) { return (0); }
BOOL efs_check (EFS_VI *vi) { return (__FALSE); }
BOOL efs_defrag (IOB *fcb) { return (__FALSE); }
#endif
#if (FAT_USE == 0)
/* Empty functions to reduce image size when FAT not used */
int fat_init (FAT_VI *vi) { return (0); }
BOOL fat_find (const char *fn, IOB *fcb) { return (__FALSE); }
BOOL fat_seek (IOB *fcb, U32 pos) { return (__FALSE); }
U32 fat_read (IOB *fcb, U8 *buf, U32 len) { return (0); }
BOOL fat_write (IOB *fcb, const U8 *buf, U32 len){ return (__FALSE); }
U64 fat_free (FAT_VI *vi) { return (0) ; }
BOOL fat_delete (const char *fn, IOB *fcb) { return (__FALSE); }
BOOL fat_wclose (IOB *fcb) { return (__FALSE); }
BOOL fat_rename (const char *old, const char *newn, IOB *fcb) {
return (__FALSE); }
BOOL fat_create (const char *fn, IOB *fcb) { return (__FALSE); }
BOOL fat_format (FAT_VI *vi, const char *label) { return (__FALSE); }
BOOL fat_ffind (const char *fn, FINFO *info, IOB *fcb) {
return (__FALSE); }
#endif
/*----------------------------------------------------------------------------
* end of file
*---------------------------------------------------------------------------*/
دیدگاه