mstick.c

三星s3c2460开发板完整功能测试代码

	Mstpc_Set_Command(MS_SLEEP);

	Int_Status = Mstpc_Get_Int(1, INT_CED);
	printf("Page write cnt(%x).\n", Int_Status);

	if(IntStatus & (1<<15)) return 0;
	else return 1;

}

int Check_Wp(void)
{
	unsigned char tmps[2];
	
	Mstpc_Read_Status_Reg(0x2, 0x1, tmps);
	if(tmps[0] & STATUS_WP) {	// Write protect is enabled.
		printf("xxx\n");
		return 1;
	}
	else return 0;	// Not write-protect.
	
}

 
int Ms_Page_Write(unsigned int Block_Addr, unsigned int Page_Addr, unsigned char *Write_Buffer)
{
	//int i, cnt=0;
	int i;
	//unsigned short IntStatus1, IntStatus2;
	static int offset=0;
	unsigned char Extra_Buffer[EXTRA_SIZE];
	unsigned short Chksum, htmp;

	//printf("write data.\n");

	// Check if write protect...
	if(Check_Wp()==1) {	// Write protect is enabled.
		return -1;
	}
	
	// 1. SET R/W address in device TPC
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x0, 0x10, 0x6);

	// 2. Write_Reg TPC
	Mstpc_Write_Param_Reg(Block_Addr, PARAM_BAMD, Page_Addr, DE_AREA);

	// make checksum...
	for(Chksum=0, i=0; i<ONEPAGE_SIZE; i++)
	{
		Chksum += Write_Buffer[i];
	
	}
	printf("Write checksum is [%04x]\n", Chksum);
	
	// Write checksum.
	Extra_Buffer[1] = (unsigned char)(Chksum>>8);
	Extra_Buffer[0] = (unsigned char)Chksum;

	Mstpc_Write_Status_Reg(CHKSUM_REG_START, CHKSUM_SIZE, Extra_Buffer);

	
	// SET_CMD TPC
	Mstpc_Set_Command(BLOCK_WRITE);

	// Get INT register
	Int_Status = Mstpc_Get_Int(1, INT_BREQ);
	//printf("Page write cnt(%x).\n", Int_Status);


	rTP_CMD = WRITE_PAGE_DATA | ONEPAGE_SIZE;
	for(i=0; i<ONEPAGE_SIZE; i+=2)
	{
		htmp = ((unsigned short)(Write_Buffer[i+1]))<<8 | (unsigned char)Write_Buffer[i];
		rDAT_FIFO = htmp;
		while(!TBE);
	}
	while(!INT_P_END);

	Int_Status = Mstpc_Get_Int(1, INT_CED);
	//printf("Page write end cnt(%x).\n", Int_Status);

	offset++;
}



void Ms_Page_Read(unsigned int Block_Addr, unsigned int Page_Addr, unsigned char *Extra_Buffer, unsigned char *Read_Buffer)
{

	//int i, cnt=0;
	int i;
	//unsigned short IntStatus1, IntStatus2;
	//unsigned short Calc_Chksum, In_Chksum, htmp;
	unsigned short htmp;
	
	// 1. SET R/W address in device TPC
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x00, 0x10, 0x6);

	// 2. Write_Reg TPC
	Mstpc_Write_Param_Reg(Block_Addr, PARAM_BAMD, Page_Addr, DE_AREA);

	// 3. SET_CMD TPC
	Mstpc_Set_Command(BLOCK_READ);

	// 4. Get_Int or Get status.
	#if 1
	Int_Status = Mstpc_Get_Int(1, INT_BREQ|INT_CED);
	//printf("Page read cnt(%x).\n", Int_Status);
	
	Mstpc_Read_Status_Reg(EXTRA_REG_START,EXTRA_SIZE, Extra_Buffer);
	#else
	// 4. Get INT register
	Int_Status = Mstpc_Get_Int(1, INT_BREQ);
	//printf("Page read cnt(%x).\n", Int_Status);
	#endif
	
	rTP_CMD = READ_PAGE_DATA | ONEPAGE_SIZE;

	for(i=0; i<ONEPAGE_SIZE; i+=2) {
		while(RBE);
		htmp = rDAT_FIFO;
		Read_Buffer[i+1] = (unsigned char)(htmp>>8);	// High byte
		Read_Buffer[i] = (unsigned char)htmp;			// Low byte
	} while(!INT_P_END);

	Int_Status = Mstpc_Get_Int(1, INT_CED);
	
	#if 0
		printf("\nRead Page data is"); 
		for(i=0; i<ONEPAGE_SIZE; i++) {
			if(!(i%16)) printf("\n%3x:  ", i);
			printf("[%02x]", Read_Buffer[i]);
		}
		printf("\n");
	#endif


}


void Ms_Extra_Write(unsigned int Block_Addr, unsigned char Page_Addr, unsigned char *Buffer)
{
	//int i, cnt=0;
	int i;
	//unsigned short IntStatus1, IntStatus2, htmp;
	unsigned short htmp;
	//unsigned char Extra_Buffer[EXTRA_SIZE];

	// 1. SET R/W address in device TPC
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x0, 0x10, 6);

	// 2. Write_Reg TPC
	Mstpc_Write_Param_Reg(Block_Addr, PARAM_BAMD, Page_Addr, E_AREA);

	// 2. Write_Reg TPC
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x0, EXTRA_REG_START, EXTRA_SIZE);

	// Write_Reg TPC
	rTP_CMD = WRITE_REG | EXTRA_SIZE;

	// Write extra data.
	for(i=0; i<(EXTRA_SIZE+1); i+=2) {
		htmp = ((unsigned short)Buffer[i+1])<<8 | (unsigned short)Buffer[i];
		rDAT_FIFO = htmp;
		while(!TBE);
	}
	while(!INT_P_END);

	// 3. Set_Cmd[BLock_Write].
	Mstpc_Set_Command(BLOCK_WRITE);

	// 4.5. GET INT.
	Int_Status = Mstpc_Get_Int(1, INT_CED);
	//printf("Extra data read end cnt(%x).\n", Int_Status);
	
}


void Ms_Extra_Read(unsigned int Block_Addr, unsigned char Page_Addr, unsigned char *Buffer)
{
	//int i, cnt=0;
	int i;
	//unsigned short IntStatus1, IntStatus2, htmp;
	unsigned short htmp;
	unsigned char Extra_Buffer[EXTRA_SIZE];


	// 1. SET R/W address in device TPC
	Mstpc_Write_Rw_Reg_Addr(0x16, 0x09, 0x10, 0x06);

	// 2. Write_Reg TPC
	Mstpc_Write_Param_Reg(Block_Addr, PARAM_BAMD, Page_Addr, E_AREA);

	// 3. SET_CMD TPC
	Mstpc_Set_Command(BLOCK_READ);
	
	// 5.Get INT.
	Int_Status = Mstpc_Get_Int(1, INT_CED);
	//printf("Extra data read cnt(%x).\n", Int_Status);

	// 7. Read reg
	rTP_CMD = READ_REG | EXTRA_SIZE;

	for(i=0; i<(EXTRA_SIZE+1); i+=2) {
		while(RBE);
		htmp = rDAT_FIFO;
		Extra_Buffer[i+1] = (unsigned char)(htmp>>8);
		Extra_Buffer[i] = (unsigned char)htmp;		
	}
	while(!INT_P_END);

	
	#if 1
	printf("Extra data is\n");
	for(i=0; i<EXTRA_SIZE; i++) {
		//if(!(i%8)) printf("\n%3x:  ", i*2);
		printf("[%02x]", Extra_Buffer[i]);
	}
	printf("\n");
	#endif
	
}


int Mstpc_Write_Extra_Reg(unsigned char *Extra_Buffer)
{
	//unsigned char Extra_Buffer[EXTRA_SIZE];
	//int i;
	
	// Write_Reg TPC
	rTP_CMD = WRITE_REG | EXTRA_SIZE;

	rDAT_FIFO = (Extra_Buffer[1]<<8) | (Extra_Buffer[0]<<0);
	while(!TBE);
	rDAT_FIFO = (Extra_Buffer[3]<<8) | (Extra_Buffer[2]<<0);
	while(!TBE);
	rDAT_FIFO = (Extra_Buffer[5]<<8) | (Extra_Buffer[4]<<0);
	while(!TBE);
	rDAT_FIFO = (Extra_Buffer[7]<<8) | (Extra_Buffer[6]<<0);
	while(!TBE);
	rDAT_FIFO = (0x00<<8) | (Extra_Buffer[8]<<0);
	while(!TBE);

	while(!INT_P_END);

}


/*
 *	function name 	: Ms_Block_Erase
 *	purpose			: Erase a pade data before write to flash
 */
void Ms_Block_Erase(unsigned int Block_Addr)
{
	//int i, cnt=0;
	//unsigned short IntStatus;

	// 1. SET_R_W_REG_ADS
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x1f, 0x10, 0x06);

	// 2. Write_Reg
	Mstpc_Write_Param_Reg(Block_Addr, PARAM_BAMD, 0, DE_AREA);

	// 3. SET_CMD TPC
	Mstpc_Set_Command(BLOCK_ERASE);


	// 4. Get INT register
	Int_Status = Mstpc_Get_Int(1, INT_CED);
	//printf("Block erase cnt(%x).\n", Int_Status);

}


void __irq IrDA_Mstick_Irq(void)
{
	int int_state;

	int_state = rSUBSRCPND;
	//printf("IrDA_Mstick_Irq occurred...\n");
	if(int_state & BIT_SUB_MSTICK) {
		rINTSUBMSK |= BIT_SUB_MSTICK;
		rSUBSRCPND = BIT_SUB_MSTICK;
		ClearPending(BIT_SDMMC_MS);
		Mstick_Sub_Irq();
		rINTSUBMSK &= ~BIT_SUB_MSTICK;
	} else if (int_state & BIT_SUB_SDMMC) {
		printf("\n\n\nNot allowed interrupt\n\n");
		rINTSUBMSK |= BIT_SUB_SDMMC;
		rSUBSRCPND = BIT_SUB_SDMMC;
		ClearPending(BIT_SDMMC_MS);
		IrDA_Sub_Irq();
		rINTSUBMSK &= ~BIT_SUB_SDMMC;
	}
	else {
		printf("IrDA_Mstick Interupt Error!\n");
	}
}



void Mstick_Sub_Irq(void)
{
	int int_status;
	
	int_status = rINTCTRL_STA;
		
	
	//printf("Mstick intr(%x).\n", int_status);
	if(int_status & (1<<7)) {
		//printf("[INT_INT_P_END]");
	} 
	if(int_status & (1<<6)) {
		//printf("\nINT_INT_SIF(receive).\n");
	} 
	if (int_status & (1<<5)) {
		//Tr_Irq();
	} 
	if(int_status & (1<<4)) {
		Stick_Ins_Irq();
	} 
	if(int_status & (1<<1)) {
		printf("\nINT_CRCerror.\n");
	} 
	if(int_status & (1<<0)) {
		printf("\nINT_Timeout.\n");
	}


}


void Stick_Ins_Irq(void)
{
	if(rINS_CON & (1<<4) ) {
		printf("Stick is inserted.\n");
		//if(Check_Wp()) printf("Write-protect enabled.\n");
		// Must takes 1msec for internal initialization after power supply.
		Delay(10);
		Ms_Reset();
		Stick_Ins = 1;
	} else {
		printf("Stick is extracted.\n");
		Stick_Ins = 0;
	}

	
}

void Tr_Irq(void)
{
	printf("Data transfer request interrupt.\n");
}

void IrDA_Sub_Irq(void)
{

	printf("IrDA interrupt(int_status).\n");

}



////////////////////////////////////////////////////////

int Mstpc_Write_Param_Reg(unsigned int Block_Addr, unsigned char Sys_Param, unsigned char Page_Addr, unsigned char Cmd_Param)
{
	unsigned char Block[3];

	//printf("Param:Block[%x], Page[%x]\n", Block_Addr, Page_Addr);
	Block[0] = (unsigned char)(Block_Addr & 0xFF);
	Block[1] = (unsigned char)((Block_Addr>>8) & 0xFF);
	Block[2] = (unsigned char)((Block_Addr>>16) & 0xFF);
	// 2. Write_Reg TPC
	rTP_CMD = WRITE_REG | 6;
	// 		Block addr2 | Sys Param.
	rDAT_FIFO = (Block[2]<<8) | (Sys_Param<<0);
	while(!TBE);
	// 		Block addr0 | Block addr1
	rDAT_FIFO = (Block[0]<<8) | (Block[1]<<0);
	while(!TBE);
	// 		  Page addr | CMD param.
	rDAT_FIFO = (Page_Addr<<8) | (Cmd_Param<<0);
	while(!TBE);

	while(!INT_P_END);

}


int Mstpc_Write_Rw_Reg_Addr(unsigned char Read_Addr, unsigned char Read_Size, unsigned char Write_Addr, unsigned char Write_Size)
{

	// 1. SET R/W address in device TPC

	rTP_CMD = SET_RW_REG_ADDRS | 4;
	// 			READ_SIZE | READ_ADDR
	rDAT_FIFO = (Read_Size<<8 | Read_Addr<<0);
	while(!TBE);	// wait until empty
	// 			WRITE_SIZE | WRITE_ADDR
	rDAT_FIFO = (Write_Size<<8 | Write_Addr<<0);
	while(!TBE);

	while(!INT_P_END);	// Wait until Protocol end.
}

int Mstpc_Set_Command(unsigned char Command)
{

	rTP_CMD = SET_CMD | 1;
	rDAT_FIFO = (0x00<<8) | (Command<<0);
	while(!TBE);

	while(!INT_P_END);
}


unsigned short Mstpc_Get_Int(int num, unsigned char End_Command)
{
	unsigned short int_status=0;
	int cnt=0;

	cnt=0;
	do {
		rTP_CMD = GET_INT | num;
		while(!INT_P_END);		// Data must be read after INT_P_END...
		while(RBE);
		int_status = (unsigned char)rDAT_FIFO;
		if(cnt++>TIME_OUT) break;
	} while(!(int_status==End_Command));

	if(cnt>TIME_OUT) printf("Time out(%d)\n", int_status);

	//printf("Get int cnt(%d)\n", cnt);
	//printf("-----int_status=%d\n",int_status);
	return int_status;
}


int Mstpc_Read_Status_Reg(unsigned char Status_Addr, unsigned char Status_Size, unsigned char *Buffer)
{
	//int i, cnt;
	int i;
	//unsigned short IntStatus1, htmp;
	unsigned short htmp;

	if(Status_Size%1) Status_Size+=1;	// Must be read by even number
	
	// Clear buffer
	for(i=0; i<Status_Size; i++) {
		Buffer[i] = 0x0;
	}
	// Set R/W register address
	Mstpc_Write_Rw_Reg_Addr(Status_Addr, Status_Size, 0x0, 0x0);

	// Status read command.
	rTP_CMD = READ_REG | (Status_Size);
	// Read status data.
	for(i=0; i<(Status_Size); i+=2) {
		while(RBE);
		while(!INT_P_END);
		htmp = rDAT_FIFO;
		Buffer[i+1] = (unsigned char)(htmp>>8);
		Buffer[i] = (unsigned char)htmp;
	}

	
}

/*
 *	function name 	: Ms_Attr_Read
 *	purpose			: Read memory stick(device) ATTR information in attribute ROM area
 */
void Ms_Attr_Read(void)
{
	int i;
//	unsigned short Attr_Buffer[ATTR_SIZE];
	unsigned short tmps;
	unsigned char Attr_Buffer[ATTR_SIZE];
	
	// Set R/W register address
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x0, 0x10, 0x06);

	// 2. WRITE_REG TPC
	Mstpc_Write_Param_Reg(0, PARAM_ATEN, 0, 0x00);

	rTP_CMD = READ_PAGE_DATA | ATTR_SIZE;

	for(i=0; i<ATTR_SIZE; i+=2)
	{
		while(RBE);
		tmps = (unsigned short)rDAT_FIFO;
		Attr_Buffer[i+1] = (unsigned char)(tmps>>8);
		Attr_Buffer[i] = (unsigned char)(tmps);
	}

	printf("ATTR data is \n");
	for(i=0; i<ATTR_SIZE; i++) {
		if(!(i%16)) printf("\n%3x:  ", i);
		//printf("[%02x]", (unsigned char)(Attr_Buffer[i]>>8), (unsigned char)Attr_Buffer[i]);
		printf("[%02x]", Attr_Buffer[i]);
	}
	printf("\n");
	
}

int Mstpc_Write_Status_Reg(unsigned char Status_Addr, unsigned char Status_Size, unsigned char *Buffer)
{
	//int i, cnt;
	int i;
	//unsigned short IntStatus1, htmp;
	unsigned short htmp;

	//Status_Size = (Status_Size+1)*2 / 2;
	if(Status_Size%2) Status_Size+=1;
	
	// Set R/W register address
	Mstpc_Write_Rw_Reg_Addr(0x0, 0x0, Status_Addr, Status_Size);

	// Status read command.
	rTP_CMD = WRITE_REG | (Status_Size);
	// Read status data.
	for(i=0; i<Status_Size; i+=2) {
		htmp = ((unsigned short)Buffer[i+1])<<8 |(unsigned short)Buffer[i]; 
		rDAT_FIFO = htmp;
		while(!TBE);
	}
	while(!INT_P_END);
	
}


void Test_Ms_Dma_Rw(void)
{
	unsigned int i, error, offset;
	unsigned int blocknum, pagenum;
	unsigned char Write_Buffer[ONEPAGE_SIZE], Read_Buffer[ONEPAGE_SIZE], Extra_Buffer[EXTRA_SIZE];
	unsigned short In_Chksum, Calc_Chksum;	
	
	printf("\n<<Memory stick DMA W/R test>>\n");
	printf("Block number ? ");
	blocknum = GetIntNum();
	printf("Page number ? ");
	pagenum = GetIntNum();
	printf("Offset value ? ");
	offset = GetIntNum();
	
	for(i=0; i<ONEPAGE_SIZE; i++) {
		Write_Buffer[i]=(unsigned char)(i+offset);
		#if DEBUG_LEVEL>1