smc.c

image capture billing control system

//--------------------------------------------------------------------------
//	STATUS.0 : 0-->Pass		1-->Fail
//	STATUS.5 : 0-->Not Suspended	1-->Suspended
//	STATUS.6 : 0-->Busy		1-->Ready
//	STATUS.7 : 0-->Protected	1-->Not Protected

//void Poll_LCD();
//void Send_Command(Byte);
/*
void USB_Reset();
void LCD_Clear();
void LCD_xy(Byte, Byte);
void Print(Byte *);
void PrintDEC(Dword, Byte);
void PrintHEX(Dword, Byte);
*/
#define	M0MB	0x00
#define	M8MB	0xe6
#define	M16MB	0x73
#define	M32MB	0x75
#define	M64MB	0x76
#define	M128MB	0x79

#define	Start_Block_Write(x, y)		FAT_Write(RD0_BLOCK_INDEX, x, y)
#define	Start_Block_Read(x)			FAT_Read(RD0_BLOCK_INDEX, x)

#define	Download(x)		MMU_Transfer(x, DOWNLOAD_REQ)
#define	Upload(x)		MMU_Transfer(x, UPLOAD_REQ)

#define	BLOCKS_OF_RD	4

//#define	Download_RD()	Download_Blocks(RD0_BLOCK_INDEX, BLOCKS_OF_RD)
#define	Upload_RD()		Upload_Blocks(RD0_BLOCK_INDEX, BLOCKS_OF_RD)

#define	Req(x)			Upload_Byte(x)

//void Status_Change(Byte);
IntExt1()       interrupt	2		// SMC in/out
{
	smi_write_protect = 1;
	smi_erase_enable = 0;
	smi_card_enable = 0;

	if(!cf_card_detect)		// 0: have, 1: don't have
	{
//		if(SMC_Exist) return;
		SMC_Exist = 1;
	}
	else
	{
//		if(!SMC_Exist) return;
		SMC_Exist = 0;
	}
	SMC_In_Out=1;
	SystemStatus = STATUS_STOP;
}

void Volume_Mute();
//void Mem_Reset();
void Status_Change(Byte);
void SMC_In_Out_Check()
{
	if(SMC_In_Out)
	{
		EA=0;
		Volume_Mute();
		Delay(10000);
		SMC_In_Out=0;
		SMC_Refreshed=0;
		Status_Change(STATUS_STOP);
		Yellow_Light(1,1);
		EA=1;
	}
}

Byte SmartMediaStatus (void)
{
	smi_card_enable = 1;
	SMI_Command = 0x70;			// Status Read
	Trigger(smi_t_status);
	smi_card_enable = 0;
	return SMI_Status;
}

Byte Status_Check (void)
{
	SMI_Command = 0x70;			// Status Read
	Trigger(smi_t_status);
	return SMI_Status;
}

void SmartMediaReadID (void)
{
	smi_card_enable = 1;
	SMI_Command = 0x90;
	Trigger (smi_t_id);
	smi_card_enable = 0;
	return;
}

//--------------------------------------------------------------------------
// 8M's BlockNo = 0..1023
//	1 Block = 16 Pages
// 16M's BlockNo = 0..1023
//	1 Block = 32 Pages
/*
Word Block_Addr_Change(Word block)
{
	if(Mem_Select==BIM)
	{
		if(block<Mem1_Blocks)
		{
			Select_Mem1();
		}
		else
		{
			Select_Mem2();
			return(block - Mem1_Blocks);
		}
	}
	else if(Mem_Select==SMC)
	{
		Select_SMC();
	}
	return(block);
}
*/
/*
Dword Page_Addr_Change(Dword page)
{
	if(Mem_Select==BIM)
	{
		if(page<Mem1_Pages)
		{
			Select_Mem1();
			smi_64_128m = Mem1_Over64;
		}
		else
		{
			Select_Mem2();
			smi_64_128m = Mem2_Over64;
			return(page - Mem1_Pages);
		}
	}
	else if(Mem_Select==SMC)
	{
		Select_SMC();
		smi_64_128m = SMC_Over64;
	}
	return(page);
}
*/
/*
Dword Change_BlockAddr(Word block)
{
	if(Mem_Select==BIM)
	{
		if(block<Mem1_Blocks)
		{
			Select_Mem1();
			smi_64_128m = Mem1_Over64;
		}
		else
		{
			Select_Mem2();
			smi_64_128m = Mem2_Over64;
			return(block - Mem1_Blocks);
		}
	}
	else if(Mem_Select==SMC)
	{
		Select_SMC();
		smi_64_128m = SMC_Over64;
	}
	return(block);
}
*/
void Set_PageAddr(Dword block, Dword page)
{
	if(Mem_Select==BIM)
	{
		if(block<Mem1_Blocks)
		{
			Select_Mem1();
			smi_64_128m = Mem1_Over64;
		}
		else
		{
			Select_Mem2();
			smi_64_128m = Mem2_Over64;
			block -= Mem1_Blocks;
		}
	}
	else if(Mem_Select==SMC)
	{
		Select_SMC();
		smi_64_128m = SMC_Over64;
	}

	page = block*32 + page;

	SMI_Address0 = 0;
	SMI_Address1 = page;				// PA 7..0
	SMI_Address2 = page>>8;			// PA 15..8
	SMI_Address3 = page>>16;
}

void Flash_Mem_Reset()
{
	smi_card_enable = 1;
	SMI_Command = 0xff;
	Trigger(smi_t_command);
	while (!smi_ready);
//	Delay_10us(1);
	smi_card_enable = 0;
}

Bool Flash_Mem_Erase(Word block)
{
	Set_PageAddr(block, 0);

	Flash_Mem_Reset();

	smi_card_enable = 1;
	smi_erase_enable = 1;
	smi_write_protect = 0;

	SMI_Command = 0x60;			// Auto Block Erase Setup
	Trigger (smi_t_command_address);

	SMI_Command = 0xD0;			// Erase Command
	Trigger (smi_t_command);
	while (!smi_ready);

	smi_write_protect = 1;
	smi_erase_enable = 0;
	smi_card_enable = 0;

//	Error = SmartMediaStatus()&0x01;
	while ( !(Status_Check() & 0x40) );	// Waitting for status ready

	if(SmartMediaStatus()&0x01)
	{
		Error = 1;
		return(0);
	}
	return(1);
}

//--------------------------------------------------------------------------
//void Mem_Reset();
Bool Bulk_Check()
{
	Dword dwi;
	for( dwi=0; dwi<BULK_TIME_OUT ; dwi++)
	{
		if(Bulk_Complete) return(1);
	}

	return(0);
}

Bool Spare_Area_Write(Dword block, Dword page)
{
//	Red_On();

//	block = Change_BlockAddr(block);
//	page = block*32 + page;
	Set_PageAddr(block, page);

	Flash_Mem_Reset();

	smi_card_enable = 1;
	smi_write_protect = 0;
	smi_xfer_dir = 1;

	SMI_Command = 0x50;
	Trigger(smi_t_command);

	SMI_Command = 0x80;					// Write
/*
	SMI_Address0 = 0;
	SMI_Address1 = page;				// PA 7..0
	SMI_Address2 = page/256;			// PA 15..8
	if(smi_64_128m) SMI_Address3 = page/256/256;
//	SMI_Address3 = page/256/256;
*/
	Trigger (smi_t_command_address);

	MMU_Pointer_Set(4);
	Trigger(smi_t_data);

	SMI_Command = 0x10;			// Page Program
	Trigger(smi_t_command);
//	Delay_10us(50);
	while (!smi_ready);		 	// Waitting for ready
	while ( !(Status_Check() & 0x40) );	// Waitting for status ready

	smi_xfer_dir = 0;
	smi_write_protect = 1;
	smi_card_enable = 0;

//	return(~(SmartMediaStatus()&0x01));
	if(SmartMediaStatus()&0x01)
	{
		Error=1;
		return 0;
	}
	return 1;
//	Red_Off();
}

void Spare_Area_Read(Dword block, Dword page)
{
//	Red_On();

//	block = Change_BlockAddr(block);
//	page = block*32 + page;
	Set_PageAddr(block, page);

	Flash_Mem_Reset();

	smi_card_enable = 1;

	SMI_Command = 0x50;
/*
	SMI_Address0 = 0;			// PA 7..0
	SMI_Address1 = page;				// PA 16..9
	SMI_Address2 = page/256;			// PA 23..17
	if(smi_64_128m) SMI_Address3 = page/256/256;
//	SMI_Address3 = page/256/256;
*/
	Trigger(smi_t_command_address);

//	Delay_10us(5);
	while (!smi_ready);

	MMU_Pointer_Set(4);
	Trigger(smi_t_data);

	smi_card_enable = 0;

//	Red_Off();
}

Bool FAT_Write(Dword block_addr, Byte page_offset, Word content)
{
	MMU_Reset();
	DMA_Mode_Off();

	Write_MMU(0x1fc, content/256);
	Write_MMU(0x1fd, content%256);
	return( Spare_Area_Write(block_addr, page_offset) );
}

Word FAT_Read(Dword block_addr, Byte page_offset)
{
	MMU_Reset();
	DMA_Mode_Off();

//	block_addr=0;
//	page_offset=0;

	Spare_Area_Read(block_addr, page_offset);

	return( Read_MMU(0x1fc)*256 + Read_MMU(0x1fd) );
}
/*
void Start_and_Last_Block_Write(Byte page_offset)
{
//	MMU_Reset();
	DMA_Mode_Off();
	Write_MMU(0x1fc, File_Start_Block/256);
	Write_MMU(0x1fd, File_Start_Block%256);
	Write_MMU(0x1fe, File_Last_Block/256);
	Write_MMU(0x1ff, File_Last_Block%256);
	Spare_Area_Write(RD0_BLOCK_INDEX, page_offset);
}
*/
/*
void Start_and_Last_Block_Read(Byte page_offset)
{
//	MMU_Reset();
	SectorBuffer51Mode();

	Spare_Area_Read(RD0_BLOCK_INDEX, page_offset);

	File_Start_Block = Read_MMU(0x1fc)*256 + Read_MMU(0x1fd);
	File_Last_Block = Read_MMU(0x1fe)*256 + Read_MMU(0x1ff);
}
*/
void Flash_Mem_Write(Dword block, Dword page)
{
//	Red_On();

//	page = Page_Addr_Change(block*32 + page);
	Set_PageAddr(block, page);

//	block = Change_BlockAddr(block);
//	page = block*32 + page;

	Flash_Mem_Reset();

	smi_card_enable = 1;
	smi_write_protect = 0;
	smi_xfer_dir = 1;

	SMI_Command = 0x00;
	Trigger(smi_t_command);

	SMI_Command = 0x80;					// Write

/*
	SMI_Address0 = 0;
	SMI_Address1 = page;				// PA 7..0
	SMI_Address2 = page/256;			// PA 15..8
	if(smi_64_128m) SMI_Address3 = page/256/256;
//	SMI_Address3 = page/256/256;
*/
	Trigger (smi_t_command_address);

	MMU_Pointer_Set(511);
	Trigger(smi_t_data);

	SMI_Command = 0x10;			// Page Program
	Trigger(smi_t_command);
//	Delay_10us(50);
	while (!smi_ready);		 	// Waitting for ready

	smi_xfer_dir = 0;
	smi_write_protect = 1;
	smi_card_enable = 0;

	while ( !(Status_Check() & 0x40) );	// Waitting for status ready

	if(SmartMediaStatus()&0x01) Error=1;
//	Red_Off();
}

void Flash_Mem_Read(Dword block, Dword page)
{
	Set_PageAddr(block, page);
	Flash_Mem_Reset();

	smi_card_enable = 1;

	SMI_Command = 0x00;

	Trigger(smi_t_command_address);

	while (!smi_ready);

//	smi_ecc_page = 0;

	MMU_Pointer_Set(511);
	Trigger(smi_t_data);

	smi_card_enable = 0;
}

//Word Read_FAT(Word);
Dword Size(Dword value, Word size)
{
//	return( value/size + ((value%size) != 0) );		// more code
	Dword y;
	y = value/size;
	if( value%size !=0 ) y++;
	return(y);
}

void RD_Read(Byte file_num)	// read Root Directory
{
/* Root Directory
Address	Bytes	Content
0-127		128		File Name, Extension
128-129		1		Attribute
130-131	2		Time
132-133	2		Date
134-135	2		Start Block Number
136-139	4		File Size (Bytes)
140-141	2		Bit Rate
142-143	1		0:Mp3	1:General
*/

//	File_Start_Block = Start_Block_Read(file_num-1);
//	Start_and_Last_Block_Read(file_num-1);
	MMU_Reset();
	DMA_Mode_Off();
	Flash_Mem_Read(RD0_BLOCK_INDEX+(file_num-1)/32, (file_num-1)%32);
//	File_Start_Block = MMU_Byte2Word(FILE_START_BLOCK_LOCATION);

	File_Bytes = MMU_Byte2Dword(FILE_BYTE_LOCATION);
	File_Pages = Size(File_Bytes, PAGE_SIZE);
	File_Blocks = Size(File_Pages, 32);
	Last_Pages = File_Blocks;
	Last_Pages = Last_Pages*32 - File_Pages;

	File_Start_Block = MMU_Byte2Word(FILE_START_BLOCK_INDEX);
	File_Last_Block = MMU_Byte2Word(FILE_LAST_BLOCK_INDEX);

//	Bit_Rate = MMU_Byte2Word(BIT_RATE_LOCATION);
//	Bit_Rate = 128;
//	Page_Per_Sec = Bit_Rate/4;	// (bit_rate*kilo) / (8*512)

//	MP3 = ( Read_MMU(142) == 0 )? 0 : 1;
	Is_MP3 = Read_MMU(MP3_OR_GF_LOCATION) & 0x01;
}
/*
void RD_Erase(Byte file_num)
{
	Byte i;

	file_num--;		// RD location = file_num - 1

	MMU_Reset();
	DMA_Mode_Off();

	Flash_Mem_Erase(RD1_BLOCK_INDEX);

	for(i=0 ; i<Current_Flash_Mem_Files-1 ; i++)
	{
//		x = (i>=file_num)? 0: 1;
//		Flash_Mem_Read(RD0_BLOCK_INDEX, i+x);
		Flash_Mem_Read(RD0_BLOCK_INDEX, i + (i>=file_num) );
		Flash_Mem_Write(RD1_BLOCK_INDEX, i);
		FAT_Write(RD1_BLOCK_INDEX, i, (FAT_Read(RD0_BLOCK_INDEX, i + (i>=file_num))));
	}

	Flash_Mem_Erase(RD0_BLOCK_INDEX);

	for(i=0 ; i<Current_Flash_Mem_Files-1 ; i++)
	{
		Flash_Mem_Read(RD1_BLOCK_INDEX, i);
		Flash_Mem_Write(RD0_BLOCK_INDEX, i);
		FAT_Write(RD0_BLOCK_INDEX, i, (FAT_Read(RD1_BLOCK_INDEX, i)));
	}
}
*/
Word Unused_Block_Search(Word block_addr)	// Searching start from block_addr
{
	Word wi;
	for(wi=block_addr ; wi<Current_Flash_Mem_Blocks ; wi++)
	{
		if((FAT_Read(wi, VALID_CHECK_LOCATION) == VALID_BLOCK)&&(FAT_Read(wi, NEXT_CHECK_LOCATION) == UNUSED_BLOCK))
		{
			return(wi);
		}
	}
	return(wi);
}
/*
void Block_Move(Dword block1, Dword block2)
{
	Byte i;
	Dword page1, page2;

	page1 = block1*32;
	page2 = block2*32;

	MMU_Reset();
	SectorBuffer51Mode();

	Flash_Mem_Erase(block2);

	for(i=0 ; i<32 ; i++)
	{
		Flash_Mem_Read(page1+i, 0, 512);
		Flash_Mem_Write(page2+i, 0, 512);
	}
}
*/

void MMU_Transfer(Word bytes, Byte request)
{
	MMU_Pointer_Set(bytes-1);

	USBI_BULK = request;	// b'00001011', read request
	while( USBI_BULK & 0x02 );
}

/*
void Upload_End()
{
//	MMU_Reset();
//	SectorBufferCardMode();

	Download(2);
}
*/

Byte Download_Byte()
{
	Download(1);
	return( Read_MMU(511) );
}

Word Download_Word()
{
	MMU_Reset();
	DMA_Mode_Off();

	Download(2);
	return( Read_MMU(510)*256 + Read_MMU(511) );
}

void Upload_Byte(Byte x)
{
	MMU_Reset();