sle4442.c

逻辑加密卡SLE4442的操作C51函数

/*
;程 序 最 后 修 改 时 间  0-4-3 23:43
;软 件 标 题：sle4442 操作子程序
;软 件 说 明：sle4442 I2C 逻辑加密卡
;_________________________________________

;原作者:	jl_mx
;程序修改人：
;版本号：
;_________________________________________
*/

#include <stdio.h>
#include <intrins.h>
#include <string.h>

#include "upsd3200.h"
#include "upsd_hardware.h"
#include "common.h"

#if(1)
	 sbit rst=P1^5;		/*sle4442复位*/
	 sbit sdio=P1^4;	/*sle4442输出*/
	 sbit sclk=P1^1;	/*sle4442时钟*/
#else
	 sbit rst=P4^2;		/*sle4442复位*/
	 sbit sclk=P4^1;	/*sle4442时钟*/
	 sbit sdio=P4^0;	/*sle4442输出*/
#endif

//定义对各存储器的操作命令
 uchar code RD_MAIN_RAM=0X30;		//读主存储器 ic卡模式:outgoing data
 uchar code WR_MAIN_RAM=0X38;		//写主存储器 ic卡模式:processing
 uchar code RD_P_RAM=0X34;		//读保护存储器 ic卡模式:outgoing data
 uchar code WR_P_RAM=0X3C;		//写保护存储器 ic卡模式:processing
 uchar code RD_PSC_RAM=0X31;		//读安全存储器 ic卡模式:outgoing data
 uchar code WR_PSC_RAM=0X39;		//写安全存储器 ic卡模式:processing
 uchar code COMP_PSC_RAM=0X33;     	//比较安全存储器 ic卡模式:processing



unsigned char xdata ISO[4];			//存放复位响应数据

//短延时
void Delay_ic(uchar j)
{uchar i;
i=j;
for(i;i>0;i--);
}


/**********************************************/
/*          control line state settings       */
/**********************************************/

/*******************************************************/
/*               interface routines                    */
/*******************************************************/
/*1. ISSUE a xstart condition */
void ic_start()                                   
 {
  sclk=0;
  sdio=1;
  Delay_ic(5);
  sclk=1;
  Delay_ic(5);
  sdio=0;
  Delay_ic(5);
  sclk=0;

 }

/*2.  ISSUE a xstop condition */
void ic_stop()                                  
 {
  sdio=0;
  sclk=1;
  Delay_ic(5);
  sdio=1;
  sclk=0;
 }

/*3. ISSUE a clock pulse  */
void  clock()
 {

  sclk=1;
  Delay_ic(5);
  sclk=0;
  Delay_ic(5);
 }

/*****************************************************************************/
/*6. sends 8 bit 'byte' to the sle4442       */
/*****************************************************************************/
void out_byte(uchar byte)
{
uchar count,byte_temp;
  for (count=0;count<8;count++)
  {
  		byte_temp=byte;
		sdio=0x1&(byte_temp>>count);
		clock();
  }
}

/*****************************************************************************/
/*7. reads 8 bits from the sle4442 & stores value in 'rd_data'  */
/*****************************************************************************/
static char read_data()
{	uchar rd_data=0;
	uchar sdio_value;
	uchar count;
	sdio=1;
    for(count=0;count<8;count++)
    {
      rd_data=rd_data>>1;
	  sclk=1;
	  Delay_ic(5);
	  sdio_value=sdio;
	  sclk=0;
	  Delay_ic(5);
      if(sdio_value==1)rd_data|=0x80;
	  else{rd_data&=0x7f;}
    }
	  return(rd_data);
}

 
void ic_break()
{
	  sclk=0;
	  Delay_ic(5);
	  rst=1;
	  Delay_ic(5);
	  rst=0;
	  Delay_ic(5);

}


/*******************************************************/
/*9. reads 32 bit ISO 
stasndard response to reset      */ 
/*******************************************************/
unsigned long ISO_no_read()
{uchar count1; 
 unsigned long *ret_data;
 //unsigned char xdata ISO[4];			//存放复位响应数据
 	ret_data=(unsigned long *)&ISO;
	rst=0;
	sclk=0;
	sdio=0;
	Delay_ic(150); 
	sdio=1;
	rst=1; 
	Delay_ic(40); 
	clock();
	Delay_ic(2);
	rst=0; 
	Delay_ic(3);
	for (count1=0;count1<4;count1++)
		 {ISO[count1]=read_data();}
//	rst=1;_nop_(); _nop_(); _nop_();
//	rst=0; 
	return (*ret_data);
}

//读命令
//uchar comm_type; 30h,34h,31h;
//uchar read_start_addr; comm_type=30h:00-0xff;comm_type=34h:00-0xff;
uchar rd_main_ram(uchar *data_save_addr,uchar read_start_addr,uint read_bytes)
{uint  i;
 	ic_start();
	out_byte(RD_MAIN_RAM);
	out_byte(read_start_addr);
	out_byte(read_start_addr);
	ic_stop();
//	read_data_temp[0]=read_bytes;
	for(i=0;i<read_bytes;i++)
		{*data_save_addr++=read_data();}
    ic_break();
	return (1);
}
//ic_card 在处理模式时进行监测是否处理完毕，最大延时255个时钟
void proc_mode_chek()
{uint  i;
	for(i=0;i<512;i++)
		{if (sdio!=0)
		    { i=511;}
		 else{clock();}	
		}
}

//写命令子程序
//uchar comm_type; 38h,3ch,39h,33h;
//uchar read_start_addr; comm_type=30h:00-0xff;comm_type=34h:00-0xff;
void  write_eepram(uchar comm_type,uchar write_start_addr,uchar write_data)
{
	EA=0;
	ic_start();
	out_byte(comm_type);
	out_byte(write_start_addr);
	out_byte(write_data);
	ic_stop();
	if(comm_type==0x38||comm_type==0x39||comm_type==0x3c||comm_type==0x33)
		{proc_mode_chek();}
	EA=1;
}

//写主存储器的数据，
//start_addr:从主存储器写数据的首地址
//*data_addr:要写的数据的首地址
//uint wr_bytes:要写的字节数
void wr_main_ram(uchar * data_addr,uchar start_addr,uint wr_bytes)
{uint  i;
	for(i=0;i<wr_bytes;i++)
		{write_eepram(WR_MAIN_RAM,(start_addr+i),*(data_addr+i));}
}
//读取保护\安全存储器4个字节的数据，数据一地址指针rd_data_ptr中
//uchar ram_type:保护寄存器=RD_P_RAM;安全寄存器=RD_PSC_RAM
uchar rd_p_psc_ram(uchar ram_type,uchar * data_temp)
{ 	uchar  i;                                        
	ic_start();                                         
	out_byte(ram_type);                                
	out_byte(ram_type);                          
	out_byte(ram_type);                          
	ic_stop();                                          
	for(i=0;i<4;i++)                           
		{*(data_temp+i)=read_data();}          
//    ic_break();
	return (1); 
}
/*
//写保护、安全存储器的数据，                                                         
//start_addr:从保护存储器写数据的首地址 00-03h                                       
//*data_addr:要写的数据的首地址 
//uint wr_bytes:要写的字节数          03h-start_addr=0~3 
//uchar ram_type:保护寄存器=WR_P_RAM;安全寄存器=WR_PSC_RAM                                      
void wr_p_psc_ram(uchar ram_type,uchar start_addr,uchar * data_addr,uint wr_bytes)           
{uint data i;                                                                
	for(i=0;i<wr_bytes;i++)                                              
		{write_eepram(ram_type,(start_addr+i),*(data_addr+i));}   
}    
*/ 

//密码校验函数                                         
//正确 返回 0 不正确返回 1
                                                       
uchar password_comp(uchar pws1,uchar pws2,uchar pws3)  
{	uchar xdata ptr[4];                              
	rd_p_psc_ram(RD_PSC_RAM,&ptr[0]);               
//		debug_print('1',ptr[0]);
	if(ptr[0]&0x07==0){			//密码重试次数=0;卡锁定
		return 2;
	}
	else{switch (ptr[0]&0x07)
			{case 1:	write_eepram(WR_PSC_RAM,0,0xf8);               
					break;
			 case 2:	write_eepram(WR_PSC_RAM,0,0xf8);
			 		break;
			 case 3:	write_eepram(WR_PSC_RAM,0,0xf9);               
			 		break;
			 case 4:	write_eepram(WR_PSC_RAM,0,0xf8);               
			 		break;
			 case 5:	write_eepram(WR_PSC_RAM,0,0xf9);               
			 		break;
			 case 6:	write_eepram(WR_PSC_RAM,0,0xfa);               
			 		break;
			 case 7:	write_eepram(WR_PSC_RAM,0,0xfb);               
				 	break;
		   }
		}
	write_eepram(COMP_PSC_RAM,1,pws1);             
	write_eepram(COMP_PSC_RAM,2,pws2);             
	write_eepram(COMP_PSC_RAM,3,pws3);             
	write_eepram(WR_PSC_RAM,0,0xff);               
	rd_p_psc_ram(RD_PSC_RAM,&ptr[0]);               
//		debug_print('2',ptr[0]);                                                       
	if(ptr[0]&0x07==7){			//密码正确,重试次数恢复为3
		return 0;
	}
	else{						//密码错误,
		return 1;
	}                               
}   

uchar  ic_data_proc();

#if(0)
void main()
{	unsigned long atm_anw;
	char data i;
	char xdata ram_buff[512];
	static uchar code test_data[]="1234567890abcdefghijklmn";
	while(1){
		ISO_no_read();
		atm_anw=ISO_no_read();
		rd_main_ram(ram_buff,0,512);
		ic_data_proc();
		i=password_comp(0x0f,0x73,0x47);   
		if(i==0){
		wr_main_ram(0x60,&test_data,strlen(test_data));
		}
	}
}

#endif