2k_mass.c

来自「HID-Ukey底层源码实现（st72651芯片） windows上层驱动」· C语言 代码 · 共 1,672 行 · 第 1/3 页

C
1,672 行
字号
123
---------------------------------------------------------------------------*/
unsigned char DTC_SMC_Read_USB(void)
{
//	if (DTC_Code_Number != CODE_READ_USB) {
//		DTC_Load_Code(SMC_DTC_USB_Mass_Upld);
//		DTC_Code_Number = CODE_READ_USB;
//	}
	
	if (DTC_Code_Number != CODE_READ_USB256) {
		DTC_Load_Code(SMC_DTC_USB_Mass_Upld256);
		DTC_Code_Number = CODE_READ_USB256;
	}

	Copy_malPaddr();
	Buffer_Param[0x3F] = malNpage; // Nb of Sectors processed
	
	if (SMC_Cluster_Size != 64)
		Buffer_Param[0x00] = 0x01;	//flag to recognize 2K or 512 flash
	else
		Buffer_Param[0x00] = 0x00;	//flag to recognize 2K or 512 flash

	Enable_DTC_Int();
//	DTC_Process(SMC_DTC_USB_Upload); 
	DTC_Process(0x00);		//for 256MB

	return 0x00;
}

unsigned char DTC_SMC_Read_USB2(void)
{
	Enable_DTC_Int();
//	DTC_Process(SMC_DTC_USB_Upload2);	// for 256MB
	DTC_Process(0xb5);
	return 0x00;
}

/*-----------------------------------------------------------------------------
Routine : DTC_SMC_Copy_Pages
Input   :
Output  :
Description 
-----------------------------------------------------------------------------*/
unsigned char DTC_SMC_Copy_Pages(void)
{
	unsigned char DTC_Status;	// , Nbblocks;
	unsigned long Raddrtemp, Laddrtemp;
	
	if(SMC_Cluster_Size == 64){
		if (DTC_Code_Number != CODE_COPY_PAGES256){ 
			DTC_Load_Code(SMC_DTC_Copypages256);
			DTC_Code_Number = CODE_COPY_PAGES256;
		}
		asm {		// Copy the source page address with 8 bits shift left
			LD		A, malRaddr:3
			LD		Buffer_Param:35, A
			LD		A, malRaddr:2
			LD		Buffer_Param:34, A
			LD		A, malRaddr:1
			LD		Buffer_Param:33, A
			LD		A, malRaddr:0
			LD		Buffer_Param:32, A
		}
		asm {		// Copy the destination page address with 8 bits shift left
			LD		A, malPaddr:3
			LD		Buffer_Param:30, A
			LD		A, malPaddr:2
			LD		Buffer_Param:29, A
			LD		A, malPaddr:1
			LD		Buffer_Param:28, A
			LD		A, malPaddr:0
			LD		Buffer_Param:27, A
		}
		Buffer_Param[0x1F] = Buffer_Param[0x24] = 0;

		Buffer_Param[0x3F] = malNpage; 	// Nb of Sectors processed
	//	Buffer_Param[0x3e] = ((malNpage * 4) + SubBlock); // Nb of Sectors processed
	//	Nbblocks = Buffer_Param[0x3e];
	}
	else {
		if (DTC_Code_Number != CODE_COPY_PAGES){ 
			DTC_Load_Code(SMC_DTC_Copy_Pages);
			DTC_Code_Number = CODE_COPY_PAGES;
		}
		asm {		// Copy the source page address with 8 bits shift left
			LD		A, malRaddr:1
			LD		Buffer_Param:37, A
			LD		A, malRaddr:2
			LD		Buffer_Param:36, A
			LD		A, malRaddr:3
			LD		Buffer_Param:35, A
			CLR		A
			LD		Buffer_Param:34, A
		}
		asm {		// Copy the destination page address with 8 bits shift left
			CLR		A
			LD		Buffer_Param:39, A
			LD		A, malPaddr:1
			LD		Buffer_Param:42, A
			LD		A, malPaddr:2
			LD		Buffer_Param:41, A
			LD		A, malPaddr:3
			LD		Buffer_Param:40, A
		}
		Buffer_Param[0x3F] = malNpage;	// Nb of Sectors processed
	} 

	No_DTC_Int();
	DTC_Process(0x00);
	
	Laddrtemp = malPaddr;
	Raddrtemp = malRaddr;

	// forward the pointers
	if(SMC_Cluster_Size == 64){
		malNpage = malNpage << 8;
//		malNpage = (malNpage - 1) << 8;
	//	malPaddr += malNpage;
	//	malRaddr += malNpage;
	//	malNpage = 0;
	}
//	else {		// added for 256MB
		malPaddr += malNpage;
		malRaddr += malNpage;
		malNpage = 0;
//	}
	DTC_Status = DTC_Wait_Stop();
	return DTC_Status;
}

/******************TO DEBUG DATA CORRUPTION*****************/
/*
#ifdef debug
	asm {		// Copy the source page address with 8 bits shift left
		LD		A, Raddrtemp:3
		LD		Buffer_Param:36, A
		LD		A, Raddrtemp:2
		LD		Buffer_Param:35, A
		LD		A, Raddrtemp:1
		LD		Buffer_Param:34, A
		LD		A, Raddrtemp:0
		LD		Buffer_Param:33, A
	}
	
	asm {		// Copy the destination page address with 8 bits shift left
		LD		A, Laddrtemp:0
		LD		Buffer_Param:39, A
		LD		A, Laddrtemp:1
		LD		Buffer_Param:40, A
		LD		A, Laddrtemp:2
		LD		Buffer_Param:41, A
		LD		A, Laddrtemp:3
		LD		Buffer_Param:42, A
	}
	if (Buffer_Param[0x3c] == 0) {
		Buffer_Param[0x25] = Buffer_Param[0x2b]=0x00;
		Buffer_Param[0x24] = Buffer_Param[0x2a]=0x00;
	}
	else if (Buffer_Param[0x3c] == 1) {
		Buffer_Param[0x25] = Buffer_Param[0x2b]=0x10;
		Buffer_Param[0x24] = Buffer_Param[0x2a]=0x02;
		Nbblocks = Nbblocks - 1;
	} 
	else if (Buffer_Param[0x3c] == 1) {
		Buffer_Param[0x25] = Buffer_Param[0x2b]=0x20;
		Buffer_Param[0x24] = Buffer_Param[0x2a]=0x04;
		Nbblocks = Nbblocks - 2;
	}
	else {
		Buffer_Param[0x25] = Buffer_Param[0x2b]=0x30;
		Buffer_Param[0x24] = Buffer_Param[0x2a]=0x06;
		Nbblocks = Nbblocks - 3;
	}

	DTC_Status = 0x00;
	if (DTC_Code_Number != CODE_DEBUG) {
		DTC_Load_Code(SMC_DTC_Debug);
		DTC_Code_Number = CODE_DEBUG ;
	}

	Buffer_Param[0x20] = Nbblocks;
	DTC_Process(0x00);
	while(!(DTC_Status)){
		DTC_Status = DTCSTATUS & 0x03;
	}
	if (DTC_Status & 0x02) {
		counter++;
		asm nop;
		Error_Laddr[counter] = SMC_Laddr ;
		Error_Page[counter] =((unsigned char *)(&(Laddrtemp)))[2];
		Error_offset[counter]= Buffer_Param[0x20];
	}
	asm nop;
#endif
}
*/
/*-----------------------------------------------------------------------------
Routine : DTC_SMC_Mark_Pages
Input   :
Output  : void
Description 
-----------------------------------------------------------------------------*/
unsigned char DTC_SMC_Mark_Page0(unsigned char Marking_Mark)
{
	unsigned char value;
	if (DTC_Code_Number != CODE_MARK_PAGES) {
//		DTC_Load_Code(SMC_DTC_Mark_Pages);
		DTC_Load_Code(SMC_DTC_Markpages256); // for 256MB
		DTC_Code_Number = CODE_MARK_PAGES;
	}

	asm {
		LD		X, #15
		LD		A, #0xFF
FF_Spare:
		LD		(Buffer_Param[0x27], X), A
		DEC		X
		JRPL	FF_Spare
	}
//	Spare_Area.Reserved_Field = 0xFFFFFFFFL;
//	Spare_Area.ECC_Field_2[0] = 0xFF;
//	Spare_Area.ECC_Field_2[1] = 0xFF;
//	Spare_Area.ECC_Field_2[2] = 0xFF;
//	Spare_Area.ECC_Field_1[0] = 0xFF;
//	Spare_Area.ECC_Field_1[1] = 0xFF;
//	Spare_Area.ECC_Field_1[2] = 0xFF; 
//	Spare_Area.Data_Status_Byte = 0xFF;

	Spare_Area.Block_Status_Byte = Marking_Mark;
	if (Marking_Mark == 0xFF) {
		Spare_Area.Block_Address_Field_1 =
		Spare_Area.Block_Address_Field_2 = DTC_SMC_Addr_Parity(SMC_Laddr);
	}
//	else {
//		Spare_Area.Block_Address_Field_1 = 0xFFFF;
//		Spare_Area.Block_Address_Field_2 = 0xFFFF;
//	}
	
	if (SMC_Cluster_Size != 64)			// for 256MB
		Buffer_Param[0x3F] = malNpage; // Nb of Sectors processed
	else
		Buffer_Param[0x3f] = ((malNpage * 4) + SubBlock);

	No_DTC_Int();
	DTC_Process(0x00);
	value = DTC_Wait_Stop();

	malNpage = Buffer_Param[0x3F];
//	return malNpage;
	return value;
}

unsigned char DTC_SMC_Mark_Pages()
{
//	CopyStartAddr8(malPaddr); removed for 256MB
	Copy_malPaddr();
	if (SMC_Cluster_Size != 64) {
		Buffer_Param[0x00]= 0x01;
		Buffer_Param[0x10] = 0x50;				//1st cmd for write operation
		malPaddr += malNpage;
	}
	else {
		Buffer_Param[0x24] &= 0x06;	
		Buffer_Param[0x24] += 0x02;
		Buffer_Param[0x12] = Buffer_Param[0x26];//make a copy of number of add. bytes
		Buffer_Param[0x00]= 0x00;				//flag for 256MB recognition
		Buffer_Param[0x10] = 0x80;				//first cmd
		malPaddr += (malNpage << 8);		//added for 256MB
	}
	return DTC_SMC_Mark_Page0(0xFF);
}

//unsigned char DTC_SMC_Mark_Bad(unsigned long SMC_Bad_Paddr)
unsigned char DTC_SMC_Mark_Bad(void)
{
//	CopyStartAddr8(SMC_Bad_Paddr);
	Copy_malPaddr();			//for 256MB
	if (SMC_Cluster_Size != 64){
		malPaddr += malNpage;
		Buffer_Param[0x00]= 0x01;
		Buffer_Param[0x10] = 0x50;				//1st cmd for write operation
	}
	else {
		//	Buffer_Param[0x24] &= 0x06;	
		Buffer_Param[0x24] = 0x02;
		Buffer_Param[0x25] = 0x00;
		Buffer_Param[0x12] = Buffer_Param[0x26];//make a copy of number of add. bytes
		Buffer_Param[0x00]= 0x00;				//flag for 256MB recognition
		Buffer_Param[0x10] = 0x80;				//first cmd
	//	malPaddr += (malNpage << 8);			//added for 256MB
	}
	return DTC_SMC_Mark_Page0(0xF0);
}

/*---------------------------------------------------------------------------
Routine : DTC_SMC_Write_USB
Input   :
Output  : void
Description 
---------------------------------------------------------------------------*/
void DTC_SMC_Init_Download(void)
{
//	DTC_Load_Code(SMC_DTC_USB_Mass_Dwld);
	if (SMC_Cluster_Size == 64){
		if (DTC_Code_Number != CODE_WRITE_USB256) {
			DTC_Load_Code(SMC_DTC_USB_Mass_Dwld256);	//for 256MB	
			DTC_Code_Number = CODE_WRITE_USB256;
		}
	}
	else{
		if (DTC_Code_Number != CODE_WRITE_USB) {
			DTC_Load_Code(SMC_DTC_USB_Mass_Dwld);		//for 256MB, if other Flash
			DTC_Code_Number = CODE_WRITE_USB;
		}
	}
}

//#pragma	NO_OVERLAP
unsigned char DTC_SMC_Write_USB(unsigned char buf_no)
{
	unsigned char counter;
	DTC_SMC_Init_Download();

	asm {							// Copy the logical address
		LD		A, SMC_Laddr
		LD		X, SMC_Laddr:1
		SLL		X
		RLC		A
		OR		A, #0x10			// Shift one bit left and set bit 12 as 1
		LD		Buffer_Param[0x36], A
		LD		Buffer_Param[0x3B], A
		LD		Buffer_Param[0x37], X
		LD		Buffer_Param[0x3C], X
	}

	if (SMC_Cluster_Size != 64) {
		Buffer_Param[0x25] = 0;		// CA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[3];	// PA0-7
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[2];	// PA8-15
		Buffer_Param[0x22] = ((unsigned char *)(&(malPaddr)))[1];	// PA16-23
	}
	else
		Copy_malPaddr();

	Buffer_Param[0x20] = malNpage;	// Number of pages

	Enable_DTC_Int();
	DTC_Process(buf_no ? SMC_DTC_USB_Download_Buf1 : SMC_DTC_USB_Download_Buf0);
	return 0x00;
}

void DTC_SMC_Dummy_Write(unsigned char buf_no)
{
	Buffer_Param[0x3E] = buf_no;	// Start with even or odd page
	Buffer_Param[0x3F] = malNpage;	// Nb of Sectors processed

	if (DTC_Code_Number != CODE_DTC_CODE0) {
		DTC_Load_Code(SMC_DTC_Code0);
		DTC_Code_Number = CODE_DTC_CODE0;
	}

	Enable_DTC_Int();
	DTC_Process(SMC_DTC_Code_Dummy_Write);
}

/*-----------------------------------------------------------------------------
ROUTINE NAME : DTC_SMC_Erase
INPUT/OUTPUT : None/None
DESCRIPTION  : None
-----------------------------------------------------------------------------*/
unsigned char DTC_SMC_Erase()
{
//	DTC_SMC_Init_Download();

	if (SMC_Cluster_Size == 64){
		if (DTC_Code_Number != CODE_ERASE_256) {		// modified by HYJ on Oct. 12, 2005
			DTC_Load_Code(SMC_DTC_Erass_256);
			DTC_Code_Number = CODE_ERASE_256;
		}
	}
	else{
		if (DTC_Code_Number != CODE_WRITE_USB) {
			DTC_Load_Code(SMC_DTC_USB_Mass_Dwld);		//for 256MB, if other Flash
			DTC_Code_Number = CODE_WRITE_USB;
		}
	}

	if (SMC_Cluster_Size != 64) {		//for 256MB
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[3];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[2];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[1];	// PA16-23
	}
	else{
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[2];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[1];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[0]; 
	}
	No_DTC_Int();
	DTC_Process(SMC_DTC_USB_DownErase);

	return DTC_Wait_Stop();
}

/*----------------------------------------------------------------------------
ROUTINE NAME : DTC_SMC_Format_Chk
INPUT/OUTPUT : Buffer_0 fill with the check pattern
DESCRIPTION  : None
----------------------------------------------------------------------------*/
void DTC_SMC_Format_Start()
{
	if (SMC_Cluster_Size == 64){
		if (DTC_Code_Number != CODE_SMC_FORMAT256) {
			DTC_Load_Code(SMC_DTC_Format256);		//for 256MB
			DTC_Code_Number = CODE_SMC_FORMAT256;
		}
	}
	else {
		if (DTC_Code_Number != CODE_SMC_FORMAT) {
			DTC_Load_Code(SMC_DTC_Format);			//for 256MB
			DTC_Code_Number = CODE_SMC_FORMAT;
		}
	}

	Buffer_0[0] = ~0x01;
	Buffer_0[1] = ~0x02;
	Buffer_0[2] = ~0x04;
	Buffer_0[3] = ~0x08;
	Buffer_0[4] = ~0x10;
	Buffer_0[5] = ~0x20;
	Buffer_0[6] = ~0x40;
	Buffer_0[7] = ~0x80;
	Buffer_0[8] = 0xFF;

	Buffer_Param[0x3F] = malNpage;	// Nb of Sectors processed

	Enable_DTC_Int();
	if (SMC_Cluster_Size != 64) {
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[3];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[2];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[1];
		Buffer_Param[0x22] = ((unsigned char *)(&(malPaddr)))[0];
		
		DTC_Process(SMC_DTC_Format_Cmd_Check);
	}
	else{
		Copy_malPaddr();	// cluster address
		Buffer_Param[0x25] = 0x00;
		Buffer_Param[0x24] = 0x02;
		DTC_Process(SMC_DTC_Format_Cmd_Check256);
	}
	return;
}

unsigned char DTC_SMC_Format_Chk(unsigned char flag)
{
	if (SMC_Cluster_Size == 64) {
		if (DTC_Code_Number != CODE_SMC_FORMAT256) {
			DTC_Load_Code(SMC_DTC_Format256);		//for 256MB
			DTC_Code_Number = CODE_SMC_FORMAT256;
		}
	}
	else {
		if (DTC_Code_Number != CODE_SMC_FORMAT) {
			DTC_Load_Code(SMC_DTC_Format);		
			DTC_Code_Number = CODE_SMC_FORMAT;
		}
	}

	Buffer_0[0] = ~0x01;
	Buffer_0[1] = ~0x02;
	Buffer_0[2] = ~0x04;
	Buffer_0[3] = ~0x08;
	Buffer_0[4] = ~0x10;
	Buffer_0[5] = ~0x20;
	Buffer_0[6] = ~0x40;
	Buffer_0[7] = ~0x80;
	Buffer_0[8] = 0xFF;

	Buffer_Param[0x3F] = malNpage;	// Nb of Sectors processed

	No_DTC_Int();
	if (SMC_Cluster_Size != 64) {
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[3];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[2];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[1];
		Buffer_Param[0x22] = ((unsigned char *)(&(malPaddr)))[0];
		DTC_Process(SMC_DTC_Format_Cmd_Check);
	}
	else {
		Copy_malPaddr();	// cluster address
		Buffer_Param[0x25] = 0x00;
		if (flag == format)
			Buffer_Param[0x24] = 0x02;
		else
			Buffer_Param[0x24] = 0x08; //for finding factory bad clusters

		DTC_Process(SMC_DTC_Format_Cmd_Check256);
	}

	DTC_Wait_Stop();

	if (SMC_Cluster_Size != 64)
		DTC_Process(SMC_DTC_Format_Check);
	else
		DTC_Process(SMC_DTC_Format_Check256);

	return DTC_Wait_Stop();
}

void DTC_SMC_Format_Erase()
{
	No_DTC_Int();
	if (SMC_Cluster_Size != 64 )
		DTC_Process(SMC_DTC_Format_Cmd_Erase);
	else {
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[2];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[1];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[0];
		DTC_Process(SMC_DTC_Format_Cmd_Erase256);
	}
	DTC_Wait_Stop();

	Enable_DTC_Int();
	if (SMC_Cluster_Size != 64)
		DTC_Process(SMC_DTC_Format_Erase_Wait);
	else
		DTC_Process(SMC_DTC_Format_Erase_Wait256);
}

void DTC_SMC_Format_Write()
{
	if (SMC_Cluster_Size != 64){
		No_DTC_Int();
		DTC_Process(SMC_DTC_Format_Cmd_Read0);
		DTC_Wait_Stop();
		Enable_DTC_Int();
		DTC_Process(SMC_DTC_Format_Write_0);
	}
	else {
		Copy_malPaddr();
		Buffer_Param[0x25] = 0x00;
		Enable_DTC_Int();
		DTC_Process(SMC_DTC_Format_Write0_256);
	}
}

void DTC_SMC_Format_Read()
{
	Buffer_Param[0x19] =  Buffer_Param[0x23];
	//	Copy_malPaddr();	// cluster address

	No_DTC_Int();
	if (SMC_Cluster_Size != 64) {
		Buffer_Param[0x25] = ((unsigned char *)(&(malPaddr)))[3];	// PA0-7
		Buffer_Param[0x24] = ((unsigned char *)(&(malPaddr)))[2];	// PA8-15
		Buffer_Param[0x23] = ((unsigned char *)(&(malPaddr)))[1];
		Buffer_Param[0x22] = ((unsigned char *)(&(malPaddr)))[0];

		DTC_Process(SMC_DTC_Format_Cmd_Read);
123

2k_mass.c - 源码说明

本页面展示了「HID-Ukey底层源码实现（st72651芯片） windows上层驱动」中的 2k_mass.c 源码文件，采用 C语言 编程语言编写，共 1,672 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与HID相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?