smc.c

image capture billing control system

	DMA_Mode_Off();

	Write_MMU(511, x);

	Upload(1);
}

void Upload_Word(Word x)
{
	MMU_Reset();
	DMA_Mode_Off();

	Write_MMU(510, x/256);
	Write_MMU(511, x);

	Upload(2);
}
/*
void Upload_DwordData(Dword x)
{
	MMU_Reset();
	DMA_Mode_Off();

	Write_MMU(508, x/256/256/256);
	Write_MMU(509, x/256/256);
	Write_MMU(510, x/256);
	Write_MMU(511, x);

	Upload(4);
}
*/
/*
void Upload_MMU()
{
	USB_Reset();
	MMU_Pointer_Set(511);

	USBI_BULK = UPLOAD_REQ;	// b'00001011', read request
	if(!Bulk_Check())
	{
		Red_Light(3,1);
		return;
	}
	Green_Light(3, 1);
}
*/

void Count_Mem_Area()
{
// TOTAL = RD_AREA + BAD_BLOCK + USED_BLOCK + UNUSED_BLOCK
// VALID_BLOCK = USED_BLOCK + UNUSED_BLOCK

	Word wi;

	MMU_Reset();
	DMA_Mode_Off();

	Unused_Blocks = 0;
	File_Blocks = 0;
	Bad_Blocks = 0;

	for(wi=FILE_AREA_BLOCK_INDEX ; wi<Current_Flash_Mem_Blocks ; wi++)
	{
		if( FAT_Read(wi, VALID_CHECK_LOCATION) == VALID_BLOCK)
		{
			if( FAT_Read(wi, NEXT_CHECK_LOCATION) == UNUSED_BLOCK) Unused_Blocks++;
			else File_Blocks++;
		}
		else Bad_Blocks++;
	}

	Flash_Mem_Read(MEM_INFO_INDEX, 0);
	if(Read_MMU(0) == FORMAT_MARK)
	{
		Formatted = 1;
	}
	else Formatted = 0;
}

Bool Flash_Mem_Erase_and_Check(Word block)
{
	if( Flash_Mem_Erase(block) )
	{
		if(FAT_Write(block, VALID_CHECK_LOCATION, VALID_BLOCK))
		{
			return 1;//( FAT_Read(block, VALID_CHECK_LOCATION) == VALID_BLOCK );
		}
		return 0;
	}
	return 0;
}

/////////////////////////////////////////////////////////////////////////////////////
Bool Wait_UID_Transfered(Byte a)
{
//	Word wi;

	EA = 0;
	UsbInterruptData = a;
	UID_Transfered = 0;
	EA = 1;
/*
	for(wi=0 ; wi<20000 ; wi++)
	{
		if(UID_Transfered) break;
	}
*/
	while(!UID_Transfered);

	UsbInterruptData = USB_READY;
	return(1);

//	if(UID_Transfered) return(PASS);
//	return(FAIL);
}

/*
void USB_Command_Ini()
{
//	System_Area_Error = 0;
	File_Area_Error = 0;
//	UsbInterruptData = START;
	Wait_UID_Transfered(START);
}
*/
Bool Flash_Mem_Format()
{
	Dword wi;
	Byte percent;

	MMU_Reset();
	DMA_Mode_Off();

	Clear_MMU();

	Error=0;

	Flash_Mem_Erase_and_Check(0);
	Write_MMU(0, FORMAT_MARK);
	Write_MMU(1, Volume);
	Write_MMU(2, EQ_Mode);
	Flash_Mem_Write(0, 0);

	for(wi=1 ; wi<FILE_AREA_BLOCK_INDEX ; wi++)
	{
		Flash_Mem_Erase_and_Check(wi);
	}

	if(Error)
	{
			Req(SYSTEM_AREA_ERROR);
			return 0;
	}

	Req(END);

//	Upload_Word(Current_Flash_Mem_Blocks-FILE_AREA_BLOCK_INDEX);
//	if(!Wait_UID_Transfered(END)) return;

//	if(!Wait_UID_Transfered(START)) return;
	percent = 1;
//	Upload_Word(Current_Flash_Mem_Blocks);

	for(wi=FILE_AREA_BLOCK_INDEX ; wi<Current_Flash_Mem_Blocks ; wi++)
	{
		Flash_Mem_Erase_and_Check(wi);

		if( (wi+1)*100/Current_Flash_Mem_Blocks == percent )
		{
			Req(percent);
			percent++;
		}
	}

	return 1;
}

void Download_1Block(Dword block_addr)	// 1 block download
{
	Byte i;

//	Error = 0;

//	Flash_Mem_Erase_and_Check(block_addr);

	MMU_Reset();
	MMU_Pointer_Set(511);
/*
	for (i=0 ; i<32 ; i++)
	{
		Trigger_Download();
		while(!Bulk_Complete);
		Flash_Mem_Write(block_addr, i);
	}
*/

	Trigger_Download();
//	if(!Bulk_Check()) return(0);
	while(!Bulk_Complete);
//	while(!mmu_swappable);

	for (i=0 ; i<32-1 ; i++)
	{
		Trigger_Download();
		Flash_Mem_Write(block_addr, i);
//		if(!Bulk_Check()) return(0);
		while(!Bulk_Complete);
//		while(!mmu_swappable);
	}
	Flash_Mem_Write(block_addr, i);
//	while(!mmu_swappable);

//	if(block_addr == FILE_AREA_BLOCK_INDEX) {Error=1;return(0);}
//	if(block_addr > 2000) {Error=1;return(0);}
//	return(!Error);
}
/*
void Download_Without_Writing(Dword blocks)
{
	Dword pages;
	Dword dwi;

	pages = blocks*32;

	USB_Reset();
	MMU_Pointer_Set(511);

	for (dwi=0 ; dwi<pages ; dwi++)
	{
		USBI_BULK = DOWNLOAD_REQ;
		if(!Bulk_Check()) return;
	}
}
*/
Bool Check_Unused_Mem(Word download_blocks)
{
	if(Unused_Blocks<download_blocks)
	{
//		if(!Wait_UID_Transfered(REMAINED_MEM_ERROR)) return;
		Req(REMAINED_MEM_ERROR);
		return 0;
	}
	else
	{
//		if(!Wait_UID_Transfered(END)) return;
		Req(END);
		return 1;
	}
}
/*
Bool Download_File_Info()
{
	Download(512);

	Error = 0;

	MMU_Reset();
	DMA_Mode_Off();

	Write_MMU(FILE_START_BLOCK_INDEX, File_Start_Block);
	Write_MMU(FILE_START_BLOCK_INDEX+1, File_Start_Block/256);
	Write_MMU(FILE_LAST_BLOCK_INDEX, File_Last_Block);
	Write_MMU(FILE_LAST_BLOCK_INDEX+1, File_Last_Block/256);

	Flash_Mem_Write(RD0_BLOCK_INDEX, Current_Flash_Mem_Files);
//	Start_and_Last_Block_Write(Current_Flash_Mem_Files);

	if(Error)
	{
//		if(!Wait_UID_Transfered(SYSTEM_AREA_ERROR)) return 0;
		Req(SYSTEM_AREA_ERROR);
	}
	else
	{
//		if(!Wait_UID_Transfered(END)) return 0;
		Req(END);
	}
	return ~Error;
}
*/
/*
void Upload_Remained_Blocks_Info(Word blocks)
{
	MMU_Reset();
	SectorBuffer51Mode();

	Write_MMU(0, blocks);
	Write_MMU(1, blocks/256);

	USB_Reset();
	MMU_Pointer_Set(511);

	if(!Wait_UID_Transfered(START)) return;
	USBI_BULK = UPLOAD_REQ;	// b'00001011', read request
	if(!Bulk_Check()) return;
	if(!Wait_UID_Transfered(END)) return;
}
*/
//void Delete_1File(Byte);
Bool Download_1File(Word download_blocks)
{
// if wait bulk error 	: download without writing -> delete broken file -> return
// if wait UID error	: delete broken file -> return
// if bad block error 	: download without writing -> download start again at broken position

	Word wi, prev_block, next_block;
//, remained_blocks;

//	Remained_Downloading_Blocks = download_blocks;
//	Downloaded_Blocks = 0;

// -> Unused Block Check
//	Count_Mem_Area();

//	if(!Wait_UID_Transfered(START)) return;
/*
	Write_MMU(510, 0);
	Write_MMU(511, 32);

	Upload(2);
	Red_Off();
	Green_Light(2, 2);
*/
	prev_block = FILE_AREA_BLOCK_INDEX-1;

	for(wi=0 ; wi<download_blocks ; wi++)
	{
		next_block = Unused_Block_Search(prev_block+1);

DOWNLOAD_AGAIN:
		Error=0;
		Download_1Block(next_block);
		if(Error)
//		if(!Download_1Block(next_block))
		{
//			remained_blocks = download_blocks - wi - 1;

			Flash_Mem_Erase(next_block);

			Bad_Blocks++;
			Unused_Blocks--;

			if(Unused_Blocks<download_blocks-wi)
			{
				Req(REMAINED_MEM_ERROR);
				Upload_Word(next_block);
				if(wi==0) return 1;
				while(wi!=1)
				{
					next_block = FAT_Read(prev_block, PREV_CHECK_LOCATION);
					Flash_Mem_Erase_and_Check(prev_block);
					prev_block = next_block;
					wi--;
				}
				Flash_Mem_Erase_and_Check(prev_block);
				return 1;
			}

			Req(BAD_BLOCK_ERROR);
			Upload_Word(next_block);
			next_block = Unused_Block_Search(next_block+1);
			goto DOWNLOAD_AGAIN;
		}

		if(wi==0)
		{
			File_Start_Block = next_block;
			FAT_Write(next_block, PREV_CHECK_LOCATION, START_BLOCK);
		}
		else
		{
			FAT_Write(prev_block, NEXT_CHECK_LOCATION, next_block);
			FAT_Write(next_block, PREV_CHECK_LOCATION, prev_block);
		}

		Unused_Blocks --;
		prev_block = next_block;
		Req(END);
		Upload_Word(next_block);
	}

	if(download_blocks==0)
	{
		File_Start_Block = LAST_BLOCK;
		File_Last_Block = LAST_BLOCK;
	}
	else
	{
		FAT_Write(next_block, NEXT_CHECK_LOCATION, LAST_BLOCK);
		File_Last_Block = next_block;
	}

	return 1;
}

void Upload_1Block(Word block)
{
	Dword i;
//	Dword start_page;

//	start_page = block*32;

//	USB_Reset();
	MMU_Reset();
//	DMA_Mode_Off();
//	SectorBuffer51Mode();
//	MMU_Pointer_Set(511);

	Flash_Mem_Read(block, 0);

//	MMU_Pointer_Set(511);
	for (i=1 ; i<32 ; i++)
	{
		Trigger_Upload();	// b'00001011', read request
		Flash_Mem_Read(block, i);
		if(!Bulk_Check()) return;
	}
	Trigger_Upload();	// b'00001011', read request
	if(!Bulk_Check()) return;
}

void Upload_1File(Byte file_num)
{
	Word next_block;

/*
// -> Upload file info
	Wait_UID_Transfered(START);
	RD_Upload(file_num);
	Wait_UID_Transfered(END);
// <-
*/

// -> Upload file
//	if(!Wait_UID_Transfered(START)) return;

//	prev_block = FAT_Read(RD0_BLOCK_INDEX, file_num-1);

//	Start_and_Last_Block_Read(file_num-1);
	RD_Read(file_num);
/*
	prev_block = File_Start_Block;
	while(prev_block!=LAST_BLOCK)
	{
		next_block = FAT_Read(prev_block, NEXT_CHECK_LOCATION);
		Upload_1Block(next_block);
		prev_block = next_block;
	}
*/
	next_block = File_Start_Block;
	while(next_block!=LAST_BLOCK)
	{
		Upload_1Block(next_block);
		next_block = FAT_Read(next_block, NEXT_CHECK_LOCATION);
//		prev_block = next_block;
	}

//	Upload_End();
//	Download(2);

//	if(!Wait_UID_Transfered(END)) return;
// <-
}

void Delete_File(Word file_num)
{
	Word prev_block, next_block;

// ->
//	if(!Wait_UID_Transfered(START)) return;
//	Start_and_Last_Block_Read(file_num-1);
	RD_Read(file_num);
	prev_block = File_Start_Block;

	while(prev_block != LAST_BLOCK)
	{
		next_block = FAT_Read(prev_block, NEXT_CHECK_LOCATION);
		Flash_Mem_Erase_and_Check(prev_block);
		prev_block = next_block;
	}

//	RD_Erase(file_num);

//	return 1;
//	if(!Wait_UID_Transfered(END)) return;
// <-
}


/*
void Download_Blocks(Word start, Word num)
{
	Word wi;
	for( wi=0 ; wi<num ; wi++ )
	{
//		Flash_Mem_Erase(start+wi);
		if( !Download_1Block(start+wi) )
		Req(SYSTEM_AREA_ERROR);
	}
}
*/
void Download_RD()
{
	Word wi;
/*
	Error=0;

	for( wi=0 ; wi<num ; wi++ )
	{
		Download_1Block(start+wi);
	}

	if(Error)	Req(SYSTEM_AREA_ERROR);
	else		Req(END);

	return(~Error);
*/
	for( wi=0 ; wi<4 ; wi++ )
	{
		Flash_Mem_Erase_and_Check(RD0_BLOCK_INDEX+wi);
		Download_1Block(RD0_BLOCK_INDEX+wi);
	}
}

void Upload_Blocks(Word start, Word num)
{
	Word wi;
	for( wi=0 ; wi<num ; wi++ )
	{
		Upload_1Block(start+wi);
	}
}

void Upload_Mem_Info()
{
//	Byte i;
//	Word test;
	Word used_blocks;

	Count_Mem_Area();

// -> upload memory info
	MMU_Reset();
	DMA_Mode_Off();

// Free = Current_Flash_Mem_Blocks - FILE_AREA_BLOCK_INDEX - Bad_Blocks - File_Blocks =Unused_Blocks
/*
	Write_MMU(0, Current_Flash_Mem_Blocks);
	Write_MMU(1, Current_Flash_Mem_Blocks/256);            
	Write_MMU(2, FILE_AREA_BLOCK_INDEX);
	Write_MMU(3, 0);
	Write_MMU(4, File_Blocks);
	Write_MMU(5, File_Blocks/256);
	Write_MMU(6, Bad_Blocks);
	Write_MMU(7, Bad_Blocks/256);

	used_blocks = FILE_AREA_BLOCK_INDEX + File_Blocks + Bad_Blocks;
	Write_MMU(6, Bad_Blocks);
	Write_MMU(7, Bad_Blocks/256);

	Write_MMU(8, Unused_Blocks);
	Write_MMU(9, Unused_Blocks/256);

	if(Formatted) Write_MMU(10, FORMAT_MARK);
	else Write_MMU(10, 0x00);
	Write_MMU(11, 0x00);

	Write_MMU(12, VERSION);
	Write_MMU(13, VERSION/256);
	Write_MMU(14, Volume);
	Write_MMU(15, EQ_Mode);
	Write_MMU(16, USB_Command[1]&0xf0);
*/
	Write_MMU_Word(0, Current_Flash_Mem_Blocks);
	Write_MMU_Word(2, FILE_AREA_BLOCK_INDEX);
	Write_MMU_Word(4, File_Blocks);
	Write_MMU_Word(6, Bad_Blocks);

	used_blocks = FILE_AREA_BLOCK_INDEX + File_Blocks + Bad_Blocks;

	Write_MMU_Word(8, used_blocks);
	Write_MMU_Word(10, Unused_Blocks);

	if(Formatted) Write_MMU_Word(12, FORMAT_MARK);
	else Write_MMU_Word(12, 0x0000);

	Write_MMU_Word(14, VERSION);
	Write_MMU_Word(16, Volume);
	Write_MMU_Word(18, EQ_Mode);
	Write_MMU_Word(20, USB_Command[1]);

//	DMA_Mode_Off();
	Upload(512);

// -> upload root directory
	Upload_RD();

	MMU_Reset();
	Download(2);

	if(Mem_Select == BIM)
		BIM_Refreshed=1;
	else
		SMC_Refreshed=1;
}