Hi Charles, thanks for your answer.

We are using  a NAND512W3A2D from Numonyx, 512-Mbit, 512 byte data + 16 byte 
spare page size; minimum erasable unit is a block of 32 pages.

We chosed to use yaffs1 because it was simpler to handle, as we use YDI.

This is the configuration in use:

	memset(&m_systemDev,0,sizeof(m_systemDev));
	m_systemDev.param.name = "/system";
	m_systemDev.param.total_bytes_per_chunk = 512;
	m_systemDev.param.chunks_per_block = 32;
	m_systemDev.param.n_reserved_blocks = 5;
	m_systemDev.param.inband_tags = 0;
	m_systemDev.param.start_block = 1;
	m_systemDev.param.end_block = 2048;
	m_systemDev.param.is_yaffs2 = 0;
	m_systemDev.param.use_nand_ecc = 0;
	m_systemDev.param.wide_tnodes_disabled = 0;
	m_systemDev.param.refresh_period = 1000;
	m_systemDev.param.n_caches = 10;
	m_systemDev.driver_context = (void *) 0;
	m_systemDev.param.write_chunk_fn = yflash_WriteChunkToNAND;
	m_systemDev.param.read_chunk_fn = yflash_ReadChunkFromNAND;
	m_systemDev.param.erase_fn = yflash_EraseBlockInNAND;
	m_systemDev.param.initialise_flash_fn = yflash_InitialiseNAND;

	memset(&m_dataDev,0,sizeof(m_dataDev));
	m_dataDev.param.name = "/data";
	m_dataDev.param.total_bytes_per_chunk = 512;
	m_dataDev.param.chunks_per_block = 32;
	m_dataDev.param.n_reserved_blocks = 5;
	m_dataDev.param.inband_tags = 0;
	m_dataDev.param.start_block = m_systemDev.param.end_block + 1;
	m_dataDev.param.end_block = m_dataDev.param.start_block + 1024;
	m_dataDev.param.is_yaffs2 = 0;
	m_dataDev.param.use_nand_ecc = 0;
	m_dataDev.param.wide_tnodes_disabled = 0;
	m_dataDev.param.refresh_period = 1000;
	m_dataDev.param.n_caches = 10;
	m_dataDev.driver_context = (void *) 1;
	m_dataDev.param.write_chunk_fn = yflash_WriteChunkToNAND;
	m_dataDev.param.read_chunk_fn = yflash_ReadChunkFromNAND;
	m_dataDev.param.erase_fn = yflash_EraseBlockInNAND;
	m_dataDev.param.initialise_flash_fn = yflash_InitialiseNAND;

	memset(&m_nvramDev,0,sizeof(m_nvramDev));
	m_nvramDev.param.name = "/nvram";
	m_nvramDev.param.total_bytes_per_chunk = 512;
	m_nvramDev.param.chunks_per_block = 32;
	m_nvramDev.param.n_reserved_blocks = 5;
	m_nvramDev.param.inband_tags = 0;
	m_nvramDev.param.start_block = m_dataDev.param.end_block + 1;
	m_nvramDev.param.end_block = m_nvramDev.param.start_block + 512;
	m_nvramDev.param.is_yaffs2 = 0;
	m_nvramDev.param.use_nand_ecc = 0;
	m_nvramDev.param.wide_tnodes_disabled = 0;
	m_nvramDev.param.refresh_period = 1000;
	m_nvramDev.param.n_caches = 10;
	m_nvramDev.driver_context = (void *) 2;
	m_nvramDev.param.write_chunk_fn = yflash_WriteChunkToNAND;
	m_nvramDev.param.read_chunk_fn = yflash_ReadChunkFromNAND;
	m_nvramDev.param.erase_fn = yflash_EraseBlockInNAND;
	m_nvramDev.param.initialise_flash_fn = yflash_InitialiseNAND;

	memset(&m_tokenDev,0,sizeof(m_tokenDev));
	m_tokenDev.param.name = "/token";
	m_tokenDev.param.total_bytes_per_chunk = 512;
	m_tokenDev.param.chunks_per_block = 32;
	m_tokenDev.param.n_reserved_blocks = 5;
	m_tokenDev.param.inband_tags = 0;
	m_tokenDev.param.start_block = m_nvramDev.param.end_block + 1;
	m_tokenDev.param.end_block = min(m_tokenDev.param.start_block + 512, 4095);
	m_tokenDev.param.is_yaffs2 = 0;
	m_tokenDev.param.use_nand_ecc = 0;
	m_tokenDev.param.wide_tnodes_disabled = 0;
	m_tokenDev.param.refresh_period = 1000;
	m_tokenDev.param.n_caches = 10;
	m_tokenDev.driver_context = (void *) 3;
	m_tokenDev.param.write_chunk_fn = yflash_WriteChunkToNAND;
	m_tokenDev.param.read_chunk_fn = yflash_ReadChunkFromNAND;
	m_tokenDev.param.erase_fn = yflash_EraseBlockInNAND;
	m_tokenDev.param.initialise_flash_fn = yflash_InitialiseNAND;

Device partitioning is thus as follow (size in blocks):

start	end 	len
1	2048	2048
2049	3073	1025
3074	3586	513
3587	4095	509

Typical usage is this:
- at power up we mount all filesystem in read/write mode
- we read some files from /data (configurations), from /system (images and 
languages), from /nvram (user configuration) and from /token (customizations)
- during work time we only read from /system what we need and save data to 
/nvram; saving is performed when something is changed on when we detect that 
system is being turned off; saving requires from 5 to 15ms (depending on 
what has changed) and we are quite sure that power supply still remain active 
at least for 1,2s after we detected power failure
- after saving we *DO NOT* unmount filesystems and we expect the system to 
die

So the question are:
- is it correct to turn off device without unmounting filesystems?
- may mount mark blocks as deleted?
- if we mount the required partitions in read only mode, could this problem 
being resolved?
- is there a way from YDI to force a filesystem check programmatically?

Thanks for your support and regards,
Stefano