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) { // 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; }