int yaffs_StartUp(void)
{
// Stuff to configure YAFFS
// Stuff to initialise anything special (eg lock semaphore).
yaffsfs_LocalInitialisation();
// Set up devices
memset(&ramDev.param, 0, sizeof(ramDev.param));
memset(&bootDev.param, 0, sizeof(bootDev.param));
memset(&flashDev.param, 0, sizeof(flashDev.param));
// /ram
ramDev.param.totalBytesPerChunk = 512;
ramDev.param.nChunksPerBlock = 32;
ramDev.param.nReservedBlocks = 2; // Set this smaller for RAM
ramDev.param.startBlock = 1; // Can't use block 0
ramDev.param.endBlock = 127; // Last block in 2MB.
ramDev.param.useNANDECC = 1;
ramDev.param.nShortOpCaches = 0; // Disable caching on this device.
ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat.
ramDev.param.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
ramDev.param.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
ramDev.param.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
ramDev.param.initialiseNAND = yramdisk_InitialiseNAND;
// /boot
bootDev.param.totalBytesPerChunk = 512;
bootDev.param.nChunksPerBlock = 32;
bootDev.param.nReservedBlocks = 5;
bootDev.param.startBlock = 1; // Can't use block 0
bootDev.param.endBlock = 127; // Last block in 2MB.
bootDev.param.useNANDECC = 0; // use YAFFS's ECC
bootDev.param.nShortOpCaches = 10; // Use caches
bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
bootDev.param.writeChunkToNAND = yflash_WriteChunkToNAND;
bootDev.param.readChunkFromNAND = yflash_ReadChunkFromNAND;
bootDev.param.eraseBlockInNAND = yflash_EraseBlockInNAND;
bootDev.param.initialiseNAND = yflash_InitialiseNAND;
// /flash
flashDev.param.totalBytesPerChunk = 512;
flashDev.param.nChunksPerBlock = 32;
flashDev.param.nReservedBlocks = 5;
flashDev.param.startBlock = 128; // First block after 2MB
flashDev.param.endBlock = 1023; // Last block in 16MB
flashDev.param.useNANDECC = 0; // use YAFFS's ECC
flashDev.param.nShortOpCaches = 10; // Use caches
flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat.
flashDev.param.writeChunkToNAND = yflash_WriteChunkToNAND;
flashDev.param.readChunkFromNAND = yflash_ReadChunkFromNAND;
flashDev.param.eraseBlockInNAND = yflash_EraseBlockInNAND;
flashDev.param.initialiseNAND = yflash_InitialiseNAND;
yaffs_initialise(yaffsfs_config);
return 0;
}
int yaffs_start_up(void)
{
// Stuff to configure YAFFS
// Stuff to initialise anything special (eg lock semaphore).
yaffsfs_LocalInitialisation();
#if 1
yramsim_CreateSim("yaffs2");
#else
// Set up devices
// /ram
ramDev.data_bytes_per_chunk = 512;
ramDev.chunks_per_block = 32;
ramDev.n_reserved_blocks = 2; // Set this smaller for RAM
ramDev.start_block = 1; // Can't use block 0
ramDev.end_block = 127; // Last block in 2MB.
ramDev.use_nand_ecc = 1;
ramDev.n_caches = 0; // Disable caching on this device.
ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat.
ramDev.write_chunk_tags_fn = yramdisk_wr_chunk;
ramDev.read_chunk_tags_fn = yramdisk_rd_chunk;
ramDev.erase_fn = yramdisk_erase;
ramDev.initialise_flash_fn = yramdisk_initialise;
// /boot
bootDev.data_bytes_per_chunk = 512;
bootDev.chunks_per_block = 32;
bootDev.n_reserved_blocks = 5;
bootDev.start_block = 1; // Can't use block 0
bootDev.end_block = 127; // Last block in 2MB.
bootDev.use_nand_ecc = 0; // use YAFFS's ECC
bootDev.n_caches = 10; // Use caches
bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
bootDev.write_chunk_fn = yflash_WriteChunkToNAND;
bootDev.read_chunk_fn = yflash_ReadChunkFromNAND;
bootDev.erase_fn = yflash_EraseBlockInNAND;
bootDev.initialise_flash_fn = yflash_InitialiseNAND;
// /flash
flashDev.data_bytes_per_chunk = 512;
flashDev.chunks_per_block = 32;
flashDev.n_reserved_blocks = 5;
flashDev.start_block = 128; // First block after 2MB
flashDev.end_block = 1023; // Last block in 16MB
flashDev.use_nand_ecc = 0; // use YAFFS's ECC
flashDev.n_caches = 10; // Use caches
flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat.
flashDev.write_chunk_fn = yflash_WriteChunkToNAND;
flashDev.read_chunk_fn = yflash_ReadChunkFromNAND;
flashDev.erase_fn = yflash_EraseBlockInNAND;
flashDev.initialise_flash_fn = yflash_InitialiseNAND;
yaffs_initialise(yaffsfs_config);
#endif
return 0;
}
int yaffs_StartUp(void)
{
// /boot
bootDev.nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
bootDev.nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
bootDev.nReservedBlocks = 5;
bootDev.startBlock = physmap_partitions[0].offset;
bootDev.endBlock = physmap_partitions[0].offset +
physmap_partitions[0].size/NAND_SIZE_PER_BLOCK - 1;
bootDev.useNANDECC = 0; // use YAFFS's ECC
bootDev.nShortOpCaches = 10; // Use caches
bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
bootDev.writeChunkToNAND = yflash_WriteChunkToNAND;
bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND;
bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
bootDev.initialiseNAND = yflash_InitialiseNAND;
// "/mnt"
flashDev0.nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
flashDev0.nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
flashDev0.nReservedBlocks = 5;
flashDev0.startBlock = physmap_partitions[1].offset;
flashDev0.endBlock = physmap_partitions[1].offset +
physmap_partitions[1].size/NAND_SIZE_PER_BLOCK - 1;
flashDev0.useNANDECC = 0; // use YAFFS's ECC
flashDev0.nShortOpCaches = 10; // Use caches
flashDev0.genericDevice = (void *) 2; // Used to identify the device in fstat.
flashDev0.writeChunkToNAND = yflash_WriteChunkToNAND;
flashDev0.readChunkFromNAND = yflash_ReadChunkFromNAND;
flashDev0.eraseBlockInNAND = yflash_EraseBlockInNAND;
flashDev0.initialiseNAND = yflash_InitialiseNAND;
// "/flash"
flashDev1.nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
flashDev1.nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
flashDev1.nReservedBlocks = 20;
flashDev1.startBlock = physmap_partitions[2].offset;
flashDev1.endBlock = physmap_partitions[2].offset +
physmap_partitions[2].size/NAND_SIZE_PER_BLOCK - 1;
flashDev1.useNANDECC = 0; // use YAFFS's ECC
flashDev1.nShortOpCaches = 10; // Use caches
flashDev1.genericDevice = (void *) 3; // Used to identify the device in fstat.
flashDev1.writeChunkToNAND = yflash_WriteChunkToNAND;
flashDev1.readChunkFromNAND = yflash_ReadChunkFromNAND;
flashDev1.eraseBlockInNAND = yflash_EraseBlockInNAND;
flashDev1.initialiseNAND = yflash_InitialiseNAND;
yaffs_initialise(yaffsfs_config);
nand_flash_hwr_init();
// mem_init();
return 0;
}
int yaffs_StartUp(void)
{
// Stuff to configure YAFFS
// Stuff to initialise anything special (eg lock semaphore).
yaffsfs_LocalInitialisation();
// Set up devices
// /ram1 ram, yaffs1
memset(&ram1Dev,0,sizeof(ram1Dev));
ram1Dev.param.totalBytesPerChunk = 512;
ram1Dev.param.nChunksPerBlock = 32;
ram1Dev.param.nReservedBlocks = 2; // Set this smaller for RAM
ram1Dev.param.startBlock = 0; // Can use block 0
ram1Dev.param.endBlock = 127; // Last block in 2MB.
//ram1Dev.param.useNANDECC = 1;
ram1Dev.param.nShortOpCaches = 0; // Disable caching on this device.
ram1Dev.context = (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;
// /M18-1 yaffs1 on M18 nor sim
memset(&m18_1Dev,0,sizeof(m18_1Dev));
m18_1Dev.param.totalBytesPerChunk = 1024;
m18_1Dev.param.nChunksPerBlock =248;
m18_1Dev.param.nReservedBlocks = 2;
m18_1Dev.param.startBlock = 0; // Can use block 0
m18_1Dev.param.endBlock = 31; // Last block
m18_1Dev.param.useNANDECC = 0; // use YAFFS's ECC
m18_1Dev.param.nShortOpCaches = 10; // Use caches
m18_1Dev.context = (void *) 1; // Used to identify the device in fstat.
m18_1Dev.param.writeChunkToNAND = ynorif1_WriteChunkToNAND;
m18_1Dev.param.readChunkFromNAND = ynorif1_ReadChunkFromNAND;
m18_1Dev.param.eraseBlockInNAND = ynorif1_EraseBlockInNAND;
m18_1Dev.param.initialiseNAND = ynorif1_InitialiseNAND;
m18_1Dev.param.deinitialiseNAND = ynorif1_DeinitialiseNAND;
// /yaffs2
// Set this puppy up to use
// the file emulation space as
// 2kpage/64chunk per block
//
memset(&flashDev,0,sizeof(flashDev));
flashDev.param.totalBytesPerChunk = 2048;
flashDev.param.nChunksPerBlock = 64;
flashDev.param.nReservedBlocks = 5;
flashDev.param.inbandTags = 0;
flashDev.param.startBlock = 0;
flashDev.param.endBlock = yflash2_GetNumberOfBlocks()-1;
flashDev.param.isYaffs2 = 1;
flashDev.param.useNANDECC=1;
flashDev.param.wideTnodesDisabled=0;
flashDev.param.refreshPeriod = 10000;
flashDev.param.nShortOpCaches = 10; // Use caches
flashDev.context = (void *) 2; // Used to identify the device in fstat.
flashDev.param.writeChunkWithTagsToNAND = yflash2_WriteChunkWithTagsToNAND;
flashDev.param.readChunkWithTagsFromNAND = yflash2_ReadChunkWithTagsFromNAND;
flashDev.param.eraseBlockInNAND = yflash2_EraseBlockInNAND;
flashDev.param.initialiseNAND = yflash2_InitialiseNAND;
flashDev.param.markNANDBlockBad = yflash2_MarkNANDBlockBad;
flashDev.param.queryNANDBlock = yflash2_QueryNANDBlock;
yaffs_initialise(yaffsfs_config);
return 0;
}
int yaffs_StartUp(void)
{
struct mtd_info *mtd = &nand_info[0];
int yaffsVersion = 2;
int nBlocks;
yaffs_Device *flashDev = calloc(1, sizeof(yaffs_Device));
yaffsfs_config[0].dev = flashDev;
/* store the mtd device for later use */
flashDev->genericDevice = mtd;
// Stuff to configure YAFFS
// Stuff to initialise anything special (eg lock semaphore).
yaffsfs_LocalInitialisation();
// Set up devices
/* XXX U-BOOT XXX */
#if 0
// /ram
ramDev.nBytesPerChunk = 512;
ramDev.nChunksPerBlock = 32;
ramDev.nReservedBlocks = 2; // Set this smaller for RAM
ramDev.startBlock = 1; // Can't use block 0
ramDev.endBlock = 127; // Last block in 2MB.
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;
// /boot
bootDev.nBytesPerChunk = 612;
bootDev.nChunksPerBlock = 32;
bootDev.nReservedBlocks = 5;
bootDev.startBlock = 1; // Can't use block 0
bootDev.endBlock = 127; // Last block in 2MB.
bootDev.useNANDECC = 0; // use YAFFS's ECC
bootDev.nShortOpCaches = 10; // Use caches
bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
bootDev.writeChunkToNAND = yflash_WriteChunkToNAND;
bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND;
bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
bootDev.initialiseNAND = yflash_InitialiseNAND;
#endif
// /flash
flashDev->nReservedBlocks = 5;
// flashDev->nShortOpCaches = (options.no_cache) ? 0 : 10;
flashDev->nShortOpCaches = 10; // Use caches
flashDev->useNANDECC = 0; // do not use YAFFS's ECC
if (yaffsVersion == 2)
{
flashDev->writeChunkWithTagsToNAND = nandmtd2_WriteChunkWithTagsToNAND;
flashDev->readChunkWithTagsFromNAND = nandmtd2_ReadChunkWithTagsFromNAND;
flashDev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
flashDev->queryNANDBlock = nandmtd2_QueryNANDBlock;
flashDev->spareBuffer = YMALLOC(mtd->oobsize);
flashDev->isYaffs2 = 1;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
flashDev->nDataBytesPerChunk = mtd->writesize;
flashDev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
#else
flashDev->nDataBytesPerChunk = mtd->oobblock;
flashDev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
#endif
nBlocks = mtd->size / mtd->erasesize;
flashDev->nCheckpointReservedBlocks = 10;
flashDev->startBlock = 0;
flashDev->endBlock = nBlocks - 1;
}
else
{
flashDev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
flashDev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
flashDev->isYaffs2 = 0;
nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
flashDev->startBlock = 320;
flashDev->endBlock = nBlocks - 1;
flashDev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
flashDev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
}
/* ... and common functions */
flashDev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
flashDev->initialiseNAND = nandmtd_InitialiseNAND;
yaffs_initialise(yaffsfs_config);
return 0;
}
int yaffs_StartUp(void)
{
// Stuff to configure YAFFS
// Stuff to initialise anything special (eg lock semaphore).
yaffsfs_LocalInitialisation();
// Set up devices
// /ram
memset(&ramDev,0,sizeof(ramDev));
ramDev.totalBytesPerChunk = 512;
ramDev.nChunksPerBlock = 32;
ramDev.nReservedBlocks = 2; // Set this smaller for RAM
ramDev.startBlock = 0; // Can use block 0
ramDev.endBlock = 127; // Last block in 2MB.
//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;
// /boot (yaffs1)
memset(&bootDev,0,sizeof(bootDev));
bootDev.totalBytesPerChunk = 512;
bootDev.nChunksPerBlock = 32;
bootDev.nReservedBlocks = 5;
bootDev.startBlock = 0; // Can use block 0
bootDev.endBlock = 63; // Last block
//bootDev.useNANDECC = 0; // use YAFFS's ECC
bootDev.nShortOpCaches = 10; // Use caches
bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat.
bootDev.writeChunkToNAND = yflash_WriteChunkToNAND;
bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND;
bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND;
bootDev.initialiseNAND = yflash_InitialiseNAND;
// /flash (yaffs2)
// Set this puppy up to use
// the file emulation space as
// 2kpage/64chunk per block/128MB device
memset(&flashDev,0,sizeof(flashDev));
flashDev.totalBytesPerChunk = 512;
flashDev.nChunksPerBlock = 64;
flashDev.nReservedBlocks = 5;
flashDev.inbandTags = 1;
//flashDev.checkpointStartBlock = 1;
//flashDev.checkpointEndBlock = 20;
flashDev.startBlock = 0;
flashDev.endBlock = 200; // Make it smaller
//flashDev.endBlock = yflash_GetNumberOfBlocks()-1;
flashDev.isYaffs2 = 1;
flashDev.wideTnodesDisabled=0;
flashDev.nShortOpCaches = 10; // Use caches
flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat.
flashDev.writeChunkWithTagsToNAND = yflash2_WriteChunkWithTagsToNAND;
flashDev.readChunkWithTagsFromNAND = yflash2_ReadChunkWithTagsFromNAND;
flashDev.eraseBlockInNAND = yflash2_EraseBlockInNAND;
flashDev.initialiseNAND = yflash2_InitialiseNAND;
flashDev.markNANDBlockBad = yflash2_MarkNANDBlockBad;
flashDev.queryNANDBlock = yflash2_QueryNANDBlock;
// /ram2k
// Set this puppy up to use
// the file emulation space as
// 2kpage/64chunk per block/128MB device
memset(&ram2kDev,0,sizeof(ram2kDev));
ram2kDev.totalBytesPerChunk = nandemul2k_GetBytesPerChunk();
ram2kDev.nChunksPerBlock = nandemul2k_GetChunksPerBlock();
ram2kDev.nReservedBlocks = 5;
ram2kDev.startBlock = 0; // First block after /boot
//ram2kDev.endBlock = 127; // Last block in 16MB
ram2kDev.endBlock = nandemul2k_GetNumberOfBlocks() - 1; // Last block in 512MB
ram2kDev.isYaffs2 = 1;
ram2kDev.nShortOpCaches = 10; // Use caches
ram2kDev.genericDevice = (void *) 3; // Used to identify the device in fstat.
ram2kDev.writeChunkWithTagsToNAND = nandemul2k_WriteChunkWithTagsToNAND;
ram2kDev.readChunkWithTagsFromNAND = nandemul2k_ReadChunkWithTagsFromNAND;
ram2kDev.eraseBlockInNAND = nandemul2k_EraseBlockInNAND;
ram2kDev.initialiseNAND = nandemul2k_InitialiseNAND;
ram2kDev.markNANDBlockBad = nandemul2k_MarkNANDBlockBad;
ram2kDev.queryNANDBlock = nandemul2k_QueryNANDBlock;
yaffs_initialise(yaffsfs_config);
return 0;
}
