/* Compile this for a simulation */
#include "ynorsim.h"
-#define ynorif1_FlashInit() ynorsim_Initialise()
-#define ynorif1_FlashDeinit() ynorsim_Shutdown()
-#define ynorif1_FlashWrite32(addr,buf,nwords) ynorsim_Write32(addr,buf,nwords)
-#define ynorif1_FlashRead32(addr,buf,nwords) ynorsim_Read32(addr,buf,nwords)
-#define ynorif1_FlashEraseBlock(addr) ynorsim_EraseBlock(addr)
-#define DEVICE_BASE ynorsim_GetBase()
+#define ynorif1_FlashInit() ynorsim_initialise()
+#define ynorif1_FlashDeinit() ynorsim_shutdown()
+#define ynorif1_FlashWrite32(addr,buf,nwords) ynorsim_wr32(addr,buf,nwords)
+#define ynorif1_FlashRead32(addr,buf,nwords) ynorsim_rd32(addr,buf,nwords)
+#define ynorif1_FlashEraseBlock(addr) ynorsim_erase(addr)
+#define DEVICE_BASE ynorsim_get_base()
#else
/* Compile this for running on blob, hacked for yaffs access */
typedef struct
{
__u8 data[528]; // Data + spare
-} yramdisk_Page;
+} yramdisk_page;
typedef struct
{
- yramdisk_Page page[32]; // The pages in the block
+ yramdisk_page page[32]; // The pages in the block
-} yramdisk_Block;
+} yramdisk_block;
typedef struct
{
- yramdisk_Block **block;
+ yramdisk_block **block;
int nBlocks;
-} yramdisk_Device;
+} yramdisk_device;
-static yramdisk_Device ramdisk;
+static yramdisk_device ramdisk;
static int CheckInit(yaffs_Device *dev)
{
ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
- ramdisk.block = YMALLOC(sizeof(yramdisk_Block *) * ramdisk.nBlocks);
+ ramdisk.block = YMALLOC(sizeof(yramdisk_block *) * ramdisk.nBlocks);
if(!ramdisk.block) return 0;
for(i=0; i <ramdisk.nBlocks && !fail; i++)
{
- if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_Block))) == 0)
+ if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_block))) == 0)
{
fail = 1;
}
else
{
- yramdisk_EraseBlockInNAND(dev,i);
+ yramdisk_erase(dev,i);
nAllocated++;
}
}
return 1;
}
-int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags)
+int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags)
{
int blk;
int pg;
}
-int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
{
int blk;
int pg;
}
-int yramdisk_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+int yramdisk_check_chunk_erased(yaffs_Device *dev,int chunkInNAND)
{
int blk;
int pg;
}
-int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+int yramdisk_erase(yaffs_Device *dev, int blockNumber)
{
CheckInit(dev);
}
else
{
- memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_Block));
+ memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_block));
return YAFFS_OK;
}
}
-int yramdisk_InitialiseNAND(yaffs_Device *dev)
+int yramdisk_initialise(yaffs_Device *dev)
{
//dev->useNANDECC = 1; // force on useNANDECC which gets faked.
// This saves us doing ECC checks.
#include "yaffs_guts.h"
-int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
-int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags);
-int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
-int yramdisk_InitialiseNAND(yaffs_Device *dev);
-int yramdisk_MarkNANDBlockBad(yaffs_Device *dev,int blockNumber);
-int yramdisk_QueryNANDBlock(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
+int yramdisk_erase(yaffs_Device *dev, int blockNumber);
+int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags);
+int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
+int yramdisk_initialise(yaffs_Device *dev);
+int yramdisk_mark_block_bad(yaffs_Device *dev,int blockNumber);
+int yramdisk_query_block(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
#endif
ramDev.useNANDECC = 1;
ramDev.nShortOpCaches = 0; // Disable caching on this device.
ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat.
- ramDev.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
- ramDev.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
- ramDev.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
- ramDev.initialiseNAND = yramdisk_InitialiseNAND;
+ ramDev.writeChunkWithTagsToNAND = yramdisk_wr_chunk;
+ ramDev.readChunkWithTagsFromNAND = yramdisk_rd_chunk;
+ ramDev.eraseBlockInNAND = yramdisk_erase;
+ ramDev.initialiseNAND = yramdisk_initialise;
// /boot
bootDev.nDataBytesPerChunk = 512;
//ram1Dev.param.useNANDECC = 1;
ram1Dev.param.nShortOpCaches = 0; // Disable caching on this device.
ram1Dev.driverContext = (void *) 0; // Used to identify the device in fstat.
- ram1Dev.param.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
- ram1Dev.param.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
- ram1Dev.param.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
- ram1Dev.param.initialiseNAND = yramdisk_InitialiseNAND;
+ ram1Dev.param.writeChunkWithTagsToNAND = yramdisk_wr_chunk;
+ ram1Dev.param.readChunkWithTagsFromNAND = yramdisk_rd_chunk;
+ ram1Dev.param.eraseBlockInNAND = yramdisk_erase;
+ ram1Dev.param.initialiseNAND = yramdisk_initialise;
yaffs_add_device(&ram1Dev);
while(1){}
}
-static void ynorsim_SaveImage(void)
+static void ynorsim_save_image(void)
{
int h = open(YNORSIM_FNAME, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
write(h,word,sizeof(word));
close(h);
}
-static void ynorsim_RestoreImage(void)
+static void ynorsim_restore_image(void)
{
int h = open(YNORSIM_FNAME, O_RDONLY, S_IREAD | S_IWRITE);
memset(word,0xFF,sizeof(word));
}
-static void ynorsim_PowerFail(void)
+static void ynorsim_power_fail(void)
{
- ynorsim_SaveImage();
+ ynorsim_save_image();
exit(1);
}
int ops_multiplier = 500;
-static void ynorsim_MaybePowerFail(void)
+static void ynorsim_maybe_power_fail(void)
{
nops_so_far++;
if(simulate_power_failure &&
remaining_ops < 1){
printf("Simulated power failure after %d operations\n",nops_so_far);
- ynorsim_PowerFail();
+ ynorsim_power_fail();
}
}
-static void ynorsim_Ready(void)
+static void ynorsim_ready(void)
{
if(initialised)
return;
srand(random_seed);
remaining_ops = 1000000000;
remaining_ops = (rand() % 10000) * ops_multiplier * YNORSIM_BIT_CHANGES;
- ynorsim_RestoreImage();
+ ynorsim_restore_image();
}
-void ynorsim_Read32(__u32 *addr,__u32 *buf, int nwords)
+void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords)
{
while(nwords > 0){
*buf = *addr;
}
}
-void ynorsim_WriteOneWord32(__u32 *addr,__u32 val)
+void ynorsim_wr_one_word32(__u32 *addr,__u32 val)
{
__u32 tmp;
__u32 m;
if(!(m & val)){
tmp &= ~m;
*addr = tmp;
- ynorsim_MaybePowerFail();
+ ynorsim_maybe_power_fail();
}
}
*addr = tmp & val;
- ynorsim_MaybePowerFail();
+ ynorsim_maybe_power_fail();
}
-void ynorsim_Write32(__u32 *addr, __u32 *buf, int nwords)
+void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords)
{
while(nwords >0){
- ynorsim_WriteOneWord32(addr,*buf);
+ ynorsim_wr_one_word32(addr,*buf);
addr++;
buf++;
nwords--;
}
}
-void ynorsim_EraseBlock(__u32 *addr)
+void ynorsim_erase(__u32 *addr)
{
/* Todo... bit flipping */
memset(addr,0xFF,YNORSIM_BLOCK_SIZE_U32 * 4);
}
-void ynorsim_Initialise(void)
+void ynorsim_initialise(void)
{
- ynorsim_Ready();
+ ynorsim_ready();
}
-void ynorsim_Shutdown(void)
+void ynorsim_shutdown(void)
{
- ynorsim_SaveImage();
+ ynorsim_save_image();
initialised=0;
}
-__u32 *ynorsim_GetBase(void)
+__u32 *ynorsim_get_base(void)
{
return word;
}
#include "yaffs_guts.h"
-void ynorsim_Read32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_Write32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_EraseBlock(__u32 *addr);
-void ynorsim_Shutdown(void);
-void ynorsim_Initialise(void);
-__u32 * ynorsim_GetBase(void);
+void ynorsim_rd32(__u32 *addr, __u32 *data, int nwords);
+void ynorsim_wr32(__u32 *addr, __u32 *data, int nwords);
+void ynorsim_erase(__u32 *addr);
+void ynorsim_shutdown(void);
+void ynorsim_initialise(void);
+__u32 * ynorsim_get_base(void);
#endif
}
-static int yramsim_EraseBlockInternal(SimData *sim, unsigned blockId,int force)
+static int yramsim_erase_internal(SimData *sim, unsigned blockId,int force)
{
if(blockId < 0 || blockId >= sim->nBlocks){
return 0;
-static int yramsim_Initialise(yaffs_Device *dev)
+static int yramsim_initialise(yaffs_Device *dev)
{
SimData *sim = DevToSim(dev);
Block **blockList = sim->blockList;
}
-static int yramsim_Deinitialise(yaffs_Device *dev)
+static int yramsim_deinitialise(yaffs_Device *dev)
{
return 1;
}
-static int yramsim_ReadChunk (yaffs_Device *dev, unsigned pageId,
+static int yramsim_rd_chunk (yaffs_Device *dev, unsigned pageId,
unsigned char *data, unsigned dataLength,
unsigned char *spare, unsigned spareLength,
int *eccStatus)
return 1;
}
-static int yramsim_WriteChunk (yaffs_Device *dev,unsigned pageId,
+static int yramsim_wr_chunk (yaffs_Device *dev,unsigned pageId,
const unsigned char *data, unsigned dataLength,
const unsigned char *spare, unsigned spareLength)
{
}
-static int yramsim_EraseBlock(yaffs_Device *dev,unsigned blockId)
+static int yramsim_erase(yaffs_Device *dev,unsigned blockId)
{
SimData *sim = DevToSim(dev);
CheckInitialised();
- return yramsim_EraseBlockInternal(sim,blockId,0);
+ return yramsim_erase_internal(sim,blockId,0);
}
-static int yramsim_CheckBlockOk(yaffs_Device *dev,unsigned blockId)
+static int yramsim_check_block_ok(yaffs_Device *dev,unsigned blockId)
{
SimData *sim = DevToSim(dev);
Block **blockList = sim->blockList;
return blockList[blockId]->blockOk ? 1 : 0;
}
-static int yramsim_MarkBlockBad(yaffs_Device *dev,unsigned blockId)
+static int yramsim_mark_block_bad(yaffs_Device *dev,unsigned blockId)
{
SimData *sim = DevToSim(dev);
Block **blockList = sim->blockList;
}
-static SimData *yramsim_AllocSimData(__u32 devId, __u32 nBlocks)
+static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks)
{
int ok = 1;
b= malloc(sizeof(Block));
if(b){
blockList[i] = b;
- yramsim_EraseBlockInternal(sim,i,1);
+ yramsim_erase_internal(sim,i,1);
}
else
ok = 0;
SimData *sim;
ynandif_Geometry *g;
- sim = yramsim_AllocSimData(devId, nBlocks);
+ sim = yramsim_alloc_sim_data(devId, nBlocks);
g = YMALLOC(sizeof(ynandif_Geometry));
g->hasECC = 1;
g->inbandTags = 0;
g->useYaffs2 = 1;
- g->initialise = yramsim_Initialise;
- g->deinitialise = yramsim_Deinitialise;
- g->readChunk = yramsim_ReadChunk,
- g->writeChunk = yramsim_WriteChunk,
- g->eraseBlock = yramsim_EraseBlock,
- g->checkBlockOk = yramsim_CheckBlockOk,
- g->markBlockBad = yramsim_MarkBlockBad,
+ g->initialise = yramsim_initialise;
+ g->deinitialise = yramsim_deinitialise;
+ g->readChunk = yramsim_rd_chunk,
+ g->writeChunk = yramsim_wr_chunk,
+ g->eraseBlock = yramsim_erase,
+ g->checkBlockOk = yramsim_check_block_ok,
+ g->markBlockBad = yramsim_mark_block_bad,
g->privateData = (void *)sim;
return yaffs_add_dev_from_geometry(name,g);
static unsigned xx[XX_SIZE];
-static int yWriteFile(const char *fname, unsigned sz32)
+static int y_wr_file(const char *fname, unsigned sz32)
{
int h;
int r;
}
-static int yVerifyFile(const char *fName)
+static int y_verify_file(const char *fName)
{
unsigned checksum = 0;
unsigned totalSize;
int sz32;
sz32 = (myrand() % 1000) + 20;
- result = yWriteFile(fullTempMainName,sz32);
+ result = y_wr_file(fullTempMainName,sz32);
FSX();
if(!no_verification && result)
FatalError(__LINE__);
int result;
if(no_verification)
return;
- result = yVerifyFile(fullMainName);
+ result = y_verify_file(fullMainName);
if(result)
FatalError(__LINE__);
else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
yaffsfs_SetError(-ENOTDIR);
else {
- result = yaffs_Unlink(dir,name);
+ result = yaffs_unlinker(dir,name);
if(result == YAFFS_FAIL && isDirectory)
yaffsfs_SetError(-ENOTEMPTY);
static void little_to_big_endian(yaffs_Tags *tagsPtr)
{
#if 0 // FIXME NCB
- yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
- yaffs_TagsUnion temp;
+ yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
+ yaffs_tags_union_t temp;
memset(&temp, 0, sizeof(temp));
// Ick, I hate magic numbers.
static void yaffs_calc_tags_ecc(yaffs_Tags *tags)
{
// Todo don't do anything yet. Need to calculate ecc
- unsigned char *b = ((yaffs_TagsUnion *)tags)->asBytes;
+ unsigned char *b = ((yaffs_tags_union_t *)tags)->asBytes;
unsigned i,j;
unsigned ecc = 0;
unsigned bit = 0;
}
static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
{
- yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+ yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr;
//yaffs_calc_tags_ecc(tagsPtr);
- sparePtr->tagByte0 = tu->asBytes[0];
- sparePtr->tagByte1 = tu->asBytes[1];
- sparePtr->tagByte2 = tu->asBytes[2];
- sparePtr->tagByte3 = tu->asBytes[3];
- sparePtr->tagByte4 = tu->asBytes[4];
- sparePtr->tagByte5 = tu->asBytes[5];
- sparePtr->tagByte6 = tu->asBytes[6];
- sparePtr->tagByte7 = tu->asBytes[7];
+ sparePtr->tb0 = tu->asBytes[0];
+ sparePtr->tb1 = tu->asBytes[1];
+ sparePtr->tb2 = tu->asBytes[2];
+ sparePtr->tb3 = tu->asBytes[3];
+ sparePtr->tb4 = tu->asBytes[4];
+ sparePtr->tb5 = tu->asBytes[5];
+ sparePtr->tb6 = tu->asBytes[6];
+ sparePtr->tb7 = tu->asBytes[7];
}
/* This little function converts a little endian tag to a big endian tag.
*/
static void little_to_big_endian(yaffs_Tags *tagsPtr)
{
- yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
- yaffs_TagsUnion temp;
+ yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
+ yaffs_tags_union_t temp;
memset(&temp, 0, sizeof(temp));
// Ick, I hate magic numbers.
dev = dev;
}
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
{
- return (yaffs_Tnode *)YMALLOC(dev->tnodeSize);
+ return (yaffs_tnode_t *)YMALLOC(dev->tnodeSize);
}
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
{
dev = dev;
YFREE(tn);
#else
-struct yaffs_TnodeList_struct {
- struct yaffs_TnodeList_struct *next;
- yaffs_Tnode *tnodes;
+struct yaffs_tnode_list {
+ struct yaffs_tnode_list *next;
+ yaffs_tnode_t *tnodes;
};
-typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
+typedef struct yaffs_tnode_list yaffs_tnodelist_t;
struct yaffs_ObjectList_struct {
yaffs_Object *objects;
struct yaffs_AllocatorStruct {
int nTnodesCreated;
- yaffs_Tnode *freeTnodes;
+ yaffs_tnode_t *freeTnodes;
int nFreeTnodes;
- yaffs_TnodeList *allocatedTnodeList;
+ yaffs_tnodelist_t *allocatedTnodeList;
int nObjectsCreated;
yaffs_Object *freeObjects;
yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
- yaffs_TnodeList *tmp;
+ yaffs_tnodelist_t *tmp;
if(!allocator){
YBUG();
{
yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
int i;
- yaffs_Tnode *newTnodes;
+ yaffs_tnode_t *newTnodes;
__u8 *mem;
- yaffs_Tnode *curr;
- yaffs_Tnode *next;
- yaffs_TnodeList *tnl;
+ yaffs_tnode_t *curr;
+ yaffs_tnode_t *next;
+ yaffs_tnodelist_t *tnl;
if(!allocator){
YBUG();
/* New hookup for wide tnodes */
for (i = 0; i < nTnodes - 1; i++) {
- curr = (yaffs_Tnode *) &mem[i * dev->tnodeSize];
- next = (yaffs_Tnode *) &mem[(i+1) * dev->tnodeSize];
+ curr = (yaffs_tnode_t *) &mem[i * dev->tnodeSize];
+ next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnodeSize];
curr->internal[0] = next;
}
- curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * dev->tnodeSize];
+ curr = (yaffs_tnode_t *) &mem[(nTnodes - 1) * dev->tnodeSize];
curr->internal[0] = allocator->freeTnodes;
- allocator->freeTnodes = (yaffs_Tnode *)mem;
+ allocator->freeTnodes = (yaffs_tnode_t *)mem;
allocator->nFreeTnodes += nTnodes;
allocator->nTnodesCreated += nTnodes;
* but it just means we can't free this bunch of tnodes later.
*/
- tnl = YMALLOC(sizeof(yaffs_TnodeList));
+ tnl = YMALLOC(sizeof(yaffs_tnodelist_t));
if (!tnl) {
T(YAFFS_TRACE_ERROR,
(TSTR
}
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
{
yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
- yaffs_Tnode *tn = NULL;
+ yaffs_tnode_t *tn = NULL;
if(!allocator){
YBUG();
}
/* FreeTnode frees up a tnode and puts it back on the free list */
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
{
yaffs_Allocator *allocator = dev->allocator;
void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev);
void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev);
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev);
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn);
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev);
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn);
yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev);
void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj);
*/
-yaffs_Tnode *yaffs_get_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev)
{
- yaffs_Tnode *tn = yaffs_alloc_raw_tnode(dev);
+ yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev);
if (tn){
memset(tn, 0, dev->tnodeSize);
dev->nTnodes++;
}
/* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_free_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+static void yaffs_free_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
{
yaffs_free_raw_tnode(dev,tn);
dev->nTnodes--;
}
-void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos,
+void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos,
unsigned val)
{
__u32 *map = (__u32 *)tn;
}
}
-__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_Tnode *tn,
+__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn,
unsigned pos)
{
__u32 *map = (__u32 *)tn;
*/
/* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-yaffs_Tnode *yaffs_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev,
yaffs_FileStructure *fStruct,
__u32 chunkId)
{
- yaffs_Tnode *tn = fStruct->top;
+ yaffs_tnode_t *tn = fStruct->top;
__u32 i;
int requiredTallness;
int level = fStruct->topLevel;
* be plugged into the ttree.
*/
-yaffs_Tnode *yaffs_add_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev,
yaffs_FileStructure *fStruct,
__u32 chunkId,
- yaffs_Tnode *passedTn)
+ yaffs_tnode_t *passedTn)
{
int requiredTallness;
int i;
int l;
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
__u32 x;
* Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
*/
-static int yaffs_del_worker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
+static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level,
int chunkOffset, int *limit)
{
int i;
* Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
*/
-static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_Tnode *tn,
+static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_tnode_t *tn,
__u32 level, int chunkOffset)
{
int i;
* If there is no data in a subtree then it is pruned.
*/
-static yaffs_Tnode *yaffs_prune_worker(yaffs_Device *dev, yaffs_Tnode *tn,
+static yaffs_tnode_t *yaffs_prune_worker(yaffs_Device *dev, yaffs_tnode_t *tn,
__u32 level, int del0)
{
int i;
int i;
int hasData;
int done = 0;
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
if (fStruct->topLevel > 0) {
fStruct->top =
yaffs_ObjectType type)
{
yaffs_Object *theObject=NULL;
- yaffs_Tnode *tn = NULL;
+ yaffs_tnode_t *tn = NULL;
if (number < 0)
number = yaffs_new_obj_id(dev);
yaffs_hash_obj(theObject);
theObject->variantType = type;
#ifdef CONFIG_YAFFS_WINCE
- yfsd_WinFileTimeNow(theObject->win_atime);
+ yfsd_win_file_time_now(theObject->win_atime);
theObject->win_ctime[0] = theObject->win_mtime[0] =
theObject->win_atime[0];
theObject->win_ctime[1] = theObject->win_mtime[1] =
in->yst_mode = mode;
#ifdef CONFIG_YAFFS_WINCE
- yfsd_WinFileTimeNow(in->win_atime);
+ yfsd_win_file_time_now(in->win_atime);
in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
yaffs_ExtendedTags *tags)
{
/*Get the Tnode, then get the level 0 offset chunk offset */
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
int theChunk = -1;
yaffs_ExtendedTags localTags;
int retVal = -1;
yaffs_ExtendedTags *tags)
{
/* Get the Tnode, then get the level 0 offset chunk offset */
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
int theChunk = -1;
yaffs_ExtendedTags localTags;
* chunkInNAND = 0 is a dummy insert to make sure the tnodes are there.
*/
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
yaffs_Device *dev = in->myDev;
int existingChunk;
yaffs_ExtendedTags existingTags;
else {
if (updateTime) {
#ifdef CONFIG_YAFFS_WINCE
- yfsd_WinFileTimeNow(in->win_mtime);
+ yfsd_win_file_time_now(in->win_mtime);
#else
in->yst_mtime = Y_CURRENT_TIME;
return YAFFS_FAIL;
}
-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name)
+int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name)
{
yaffs_Object *obj;
dev->chunkGroupBits = bits - dev->tnodeWidth;
dev->tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
- if(dev->tnodeSize < sizeof(yaffs_Tnode))
- dev->tnodeSize = sizeof(yaffs_Tnode);
+ if(dev->tnodeSize < sizeof(yaffs_tnode_t))
+ dev->tnodeSize = sizeof(yaffs_tnode_t);
dev->chunkGroupSize = 1 << dev->chunkGroupBits;
static int yaffs_check_structures(void)
{
/* yaffs_check_struct(yaffs_Tags,8,"yaffs_Tags"); */
-/* yaffs_check_struct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
+/* yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */
/* yaffs_check_struct(yaffs_Spare,16,"yaffs_Spare"); */
-/* yaffs_check_struct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode"); */
+/* yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */
#ifndef CONFIG_YAFFS_WINCE
yaffs_check_struct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
typedef union {
yaffs_Tags asTags;
__u8 asBytes[8];
-} yaffs_TagsUnion;
+} yaffs_tags_union_t;
#endif
/* Spare structure for YAFFS1 */
typedef struct {
- __u8 tagByte0;
- __u8 tagByte1;
- __u8 tagByte2;
- __u8 tagByte3;
+ __u8 tb0;
+ __u8 tb1;
+ __u8 tb2;
+ __u8 tb3;
__u8 pageStatus; /* set to 0 to delete the chunk */
__u8 blockStatus;
- __u8 tagByte4;
- __u8 tagByte5;
+ __u8 tb4;
+ __u8 tb5;
__u8 ecc1[3];
- __u8 tagByte6;
- __u8 tagByte7;
+ __u8 tb6;
+ __u8 tb7;
__u8 ecc2[3];
} yaffs_Spare;
/*--------------------------- Tnode -------------------------- */
-union yaffs_Tnode_union {
- union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
+union yaffs_tnode_union {
+ union yaffs_tnode_union *internal[YAFFS_NTNODES_INTERNAL];
};
-typedef union yaffs_Tnode_union yaffs_Tnode;
+typedef union yaffs_tnode_union yaffs_tnode_t;
/*------------------------ Object -----------------------------*/
__u32 scannedFileSize;
__u32 shrinkSize;
int topLevel;
- yaffs_Tnode *top;
+ yaffs_tnode_t *top;
} yaffs_FileStructure;
typedef struct {
__u8 *buffer;
int line; /* track from whence this buffer was allocated */
int maxLine;
-} yaffs_TempBuffer;
+} yaffs_buffer_t;
/*----------------- Device ---------------------------------*/
int nBackgroundDeletions; /* Count of background deletions. */
/* Temporary buffer management */
- yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
+ yaffs_buffer_t tempBuffer[YAFFS_N_TEMP_BUFFERS];
int maxTemp;
int tempInUse;
int unmanagedTempAllocations;
int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName,
yaffs_Object *newDir, const YCHAR *newName);
-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name);
+int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name);
int yaffs_del_obj(yaffs_Object *obj);
int yaffs_get_obj_name(yaffs_Object *obj, YCHAR *name, int buffSize);
#ifdef CONFIG_YAFFS_WINCE
/* CONFIG_YAFFS_WINCE special stuff */
-void yfsd_WinFileTimeNow(__u32 target[2]);
+void yfsd_win_file_time_now(__u32 target[2]);
#endif
void yaffs_handle_defered_free(yaffs_Object *obj);
void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId,
int backwardScanning);
int yaffs_check_alloc_available(yaffs_Device *dev, int nChunks);
-yaffs_Tnode *yaffs_get_tnode(yaffs_Device *dev);
-yaffs_Tnode *yaffs_add_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev);
+yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev,
yaffs_FileStructure *fStruct,
__u32 chunkId,
- yaffs_Tnode *passedTn);
+ yaffs_tnode_t *passedTn);
int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset,
int nBytes, int writeThrough);
int yaffs_count_free_chunks(yaffs_Device *dev);
-yaffs_Tnode *yaffs_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev,
yaffs_FileStructure *fStruct,
__u32 chunkId);
-__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
+__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos);
#endif
}
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
{
yaffs_Allocator *allocator = dev->allocator;
if(!allocator || !allocator->tnode_cache){
return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS);
}
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
{
yaffs_Allocator *allocator = dev->allocator;
kmem_cache_free(allocator->tnode_cache,tn);
{
/* Calculate an ecc */
- unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+ unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes;
unsigned i, j;
unsigned ecc = 0;
unsigned bit = 0;
if (ecc && ecc <= 64) {
/* TODO: Handle the failure better. Retire? */
- unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+ unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes;
ecc--;
static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr,
yaffs_Tags *tagsPtr)
{
- yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
yaffs_calc_tags_ecc(tagsPtr);
- sparePtr->tagByte0 = tu->asBytes[0];
- sparePtr->tagByte1 = tu->asBytes[1];
- sparePtr->tagByte2 = tu->asBytes[2];
- sparePtr->tagByte3 = tu->asBytes[3];
- sparePtr->tagByte4 = tu->asBytes[4];
- sparePtr->tagByte5 = tu->asBytes[5];
- sparePtr->tagByte6 = tu->asBytes[6];
- sparePtr->tagByte7 = tu->asBytes[7];
+ sparePtr->tb0 = tu->asBytes[0];
+ sparePtr->tb1 = tu->asBytes[1];
+ sparePtr->tb2 = tu->asBytes[2];
+ sparePtr->tb3 = tu->asBytes[3];
+ sparePtr->tb4 = tu->asBytes[4];
+ sparePtr->tb5 = tu->asBytes[5];
+ sparePtr->tb6 = tu->asBytes[6];
+ sparePtr->tb7 = tu->asBytes[7];
}
static void yaffs_get_tags_from_spare(yaffs_Device *dev, yaffs_Spare *sparePtr,
yaffs_Tags *tagsPtr)
{
- yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
int result;
- tu->asBytes[0] = sparePtr->tagByte0;
- tu->asBytes[1] = sparePtr->tagByte1;
- tu->asBytes[2] = sparePtr->tagByte2;
- tu->asBytes[3] = sparePtr->tagByte3;
- tu->asBytes[4] = sparePtr->tagByte4;
- tu->asBytes[5] = sparePtr->tagByte5;
- tu->asBytes[6] = sparePtr->tagByte6;
- tu->asBytes[7] = sparePtr->tagByte7;
+ tu->asBytes[0] = sparePtr->tb0;
+ tu->asBytes[1] = sparePtr->tb1;
+ tu->asBytes[2] = sparePtr->tb2;
+ tu->asBytes[3] = sparePtr->tb3;
+ tu->asBytes[4] = sparePtr->tb4;
+ tu->asBytes[5] = sparePtr->tb5;
+ tu->asBytes[6] = sparePtr->tb6;
+ tu->asBytes[7] = sparePtr->tb7;
result = yaffs_check_tags_ecc(tagsPtr);
if (result > 0)
{
if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
- s0->tagByte0 != s1->tagByte0 ||
- s0->tagByte1 != s1->tagByte1 ||
- s0->tagByte2 != s1->tagByte2 ||
- s0->tagByte3 != s1->tagByte3 ||
- s0->tagByte4 != s1->tagByte4 ||
- s0->tagByte5 != s1->tagByte5 ||
- s0->tagByte6 != s1->tagByte6 ||
- s0->tagByte7 != s1->tagByte7 ||
+ s0->tb0 != s1->tb0 ||
+ s0->tb1 != s1->tb1 ||
+ s0->tb2 != s1->tb2 ||
+ s0->tb3 != s1->tb3 ||
+ s0->tb4 != s1->tb4 ||
+ s0->tb5 != s1->tb5 ||
+ s0->tb6 != s1->tb6 ||
+ s0->tb7 != s1->tb7 ||
s0->ecc1[0] != s1->ecc1[0] ||
s0->ecc1[1] != s1->ecc1[1] ||
s0->ecc1[2] != s1->ecc1[2] ||
#if 0
/* Not being used, but don't want to throw away yet */
-int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_Tnode *tn,
+int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_tnode_t *tn,
__u32 level, int chunkOffset)
{
int i;
__u32 i;
yaffs_Device *dev;
yaffs_ExtendedTags tags;
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
__u32 objectId;
if (!obj)
int fSize;
int failed = 0;
int objId;
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
yaffs_Tags localTags;
yaffs_Tags *tags = &localTags;
int theChunk;
yaffs_gross_lock(dev);
- retVal = yaffs_Unlink(obj, dentry->d_name.name);
+ retVal = yaffs_unlinker(obj, dentry->d_name.name);
if (retVal == YAFFS_OK) {
dentry->d_inode->i_nlink--;
return error;
}
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,
+static struct super_block *yaffs_internal_read_super(int yaffs_version,
struct super_block *sb,
void *data, int silent)
{
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
T(YAFFS_TRACE_OS,
- (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion));
+ (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
T(YAFFS_TRACE_OS,
(TSTR("yaffs_read_super: block size %d\n"),
(int)(sb->s_blocksize)));
#ifdef CONFIG_YAFFS_AUTO_YAFFS2
- if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
+ if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
T(YAFFS_TRACE_ALWAYS,
(TSTR("yaffs: auto selecting yaffs2\n")));
- yaffsVersion = 2;
+ yaffs_version = 2;
}
/* Added NCB 26/5/2006 for completeness */
- if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
+ if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
T(YAFFS_TRACE_ALWAYS,
(TSTR("yaffs: auto selecting yaffs1\n")));
- yaffsVersion = 1;
+ yaffs_version = 1;
}
#endif
- if (yaffsVersion == 2) {
+ if (yaffs_version == 2) {
/* Check for version 2 style functions */
if (!mtd->erase ||
!mtd->block_isbad ||
param->emptyLostAndFound = options.empty_lost_and_found;
/* ... and the functions. */
- if (yaffsVersion == 2) {
+ if (yaffs_version == 2) {
param->writeChunkWithTagsToNAND =
nandmtd2_WriteChunkWithTagsToNAND;
param->readChunkWithTagsFromNAND =
yaffs_gross_lock(dev);
- retVal = yaffs_Unlink(obj, dentry->d_name.name);
+ retVal = yaffs_unlinker(obj, dentry->d_name.name);
if (retVal == YAFFS_OK) {
dentry->d_inode->i_nlink--;
return error;
}
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,
+static struct super_block *yaffs_internal_read_super(int yaffs_version,
struct super_block *sb,
void *data, int silent)
{
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
T(YAFFS_TRACE_OS,
- (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion));
+ (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
T(YAFFS_TRACE_OS,
(TSTR("yaffs_read_super: block size %d\n"),
(int)(sb->s_blocksize)));
#ifdef CONFIG_YAFFS_AUTO_YAFFS2
- if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
+ if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
T(YAFFS_TRACE_ALWAYS,
(TSTR("yaffs: auto selecting yaffs2\n")));
- yaffsVersion = 2;
+ yaffs_version = 2;
}
/* Added NCB 26/5/2006 for completeness */
- if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
+ if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
T(YAFFS_TRACE_ALWAYS,
(TSTR("yaffs: auto selecting yaffs1\n")));
- yaffsVersion = 1;
+ yaffs_version = 1;
}
#endif
- if (yaffsVersion == 2) {
+ if (yaffs_version == 2) {
/* Check for version 2 style functions */
if (!mtd->erase ||
!mtd->block_isbad ||
param->emptyLostAndFound = options.empty_lost_and_found;
/* ... and the functions. */
- if (yaffsVersion == 2) {
+ if (yaffs_version == 2) {
param->writeChunkWithTagsToNAND =
nandmtd2_WriteChunkWithTagsToNAND;
param->readChunkWithTagsFromNAND =
-static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_Tnode *tn,
+static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_tnode_t *tn,
__u32 level, int chunkOffset)
{
int i;
int ok = 1;
yaffs_Device *dev = obj->myDev;
yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
- yaffs_Tnode *tn;
+ yaffs_tnode_t *tn;
int nread = 0;
ok = (yaffs2_checkpt_rd(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));