sle4442 i2c.c

sle4442 I2C 逻辑加密卡驱动程序

sle4442 I2C 逻辑加密卡,前一段时间有人问，我现在真好用到(dhd0)（点击数：938） 
/*
;程 序 最 后 修 改 时 间  2001-8-11
;软 件 标 题：sle4442 操作子程序
;软 件 说 明：sle4442 I2C 逻辑加密卡
;_________________________________________
*/

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

#define uchar unsigned char
#define uint unsigned int
#include <serial.h>
#include <ic_data_proc.h>
#include <main_proc.h>

sbit rst=P1^6;/*sle4442复位*/
sbit sdio=P1^0;/*sle4442输出*/
sbit sclk=P1^5;/*sle4442时钟*/
//定义对各存储器的操作命令
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(uchar j)
{uchar data 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(3);
  sclk=1;
  Delay(3);
  sdio=0;
  Delay(3);
  sclk=0;

}

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

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

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

/*****************************************************************************/
/*6. sends 8 bit 'byte' to the sle4442       */
/*****************************************************************************/
void out_byte(uchar byte)
{
uchar data 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 data rd_data=0;
    uchar data sdio_value;
    uchar data count;
    sdio=1;
    for(count=0;count<8;count++)
    {
      rd_data=rd_data>>1;
      sclk=1;
      Delay(1);
      sdio_value=sdio;
      sclk=0;
      Delay(1);
      if(sdio_value==1)rd_data|=0x80;
      else{rd_data&=0x7f;}
    }
      return(rd_data);
}


void ic_break()
{
      sclk=0;
      Delay(1);
      rst=1;
      _nop_();
      _nop_();
      _nop_();
      rst=0;
}


/*******************************************************/
/*9. reads 32 bit ISO 
stasndard response to reset      */ 
/*******************************************************/
unsigned long ISO_no_read()
{uchar data count1; 
unsigned long *ret_data;
unsigned char xdata ISO[4];            //存放复位响应数据
     ret_data=&ISO;
    sdio=1;    rst=1; 
    Delay(1); 
    clock();
    Delay(1);
    rst=0; 
    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 data 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  data 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)
{
    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();}
}

//写主存储器的数据，
//start_addr:从主存储器写数据的首地址
//*data_addr:要写的数据的首地址
//uint wr_bytes:要写的字节数
void wr_main_ram(uchar start_addr,uchar * data_addr,uint wr_bytes)
{uint data 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 data 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));}   
}    
*/ 

//密码校验函数                                         
//正确 返回'y' 不正确返回'n'                           
                                                       
uchar password_comp(uchar pws1,uchar pws2,uchar pws3)  
{    uchar xdata ptr[4];                              
    chip_cs(IC_CARD_CS);
    if(atr_comp()==1)
    {
        rd_p_psc_ram(RD_PSC_RAM,&ptr[0]);               
//        debug_print('1',ptr[0]);
        if(ptr[0]&0x07==0){ return('n'); }
        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){ return('y');}
        else{return 'n';}                               
    }
}   

/*
void test()
{
    uchar data i;
            static uchar code test_data[]="1234567890abcdefghijklmn";
                    i=password_comp
(0xff,0xff,0xff);   
                    if(i=='y')
                    {wr_main_ram
(0x60,&test_data,strlen(test_data));
                        debug_print
('t','w');
                    }
}