fk4428.c

2106卡的程序

		default:
	  _Retcode = W_DECR;
	  break;
      }
	}
  }

  return (_Retcode);
}
/****************************************************************************
* Function:     mifs_restore                                                *
****************************************************************************/
BYTE mifs_restore(BYTE _Adr)
{
  BYTE _Status;
  BYTE _Retcode;

  TOGGLE_WD();

  MCM_BCNTS = 16;
  MCM_BCNTR = 4;
  MCM_DATA  = 0xC2;
  MCM_DATA  = _Adr;

  MCM_TOC = 10;//TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & (_TE | _BE))
  {
    if (_Status & _TE)
    {
      _Retcode = W_NOTAG;
    }
    else
    {
      _Retcode = W_BITCNT;
	}
  }
  else
  {
    switch (MCM_DATA & 0x0B)
    {
	  case 0x00:
		_Retcode = W_NOTAUTH;
	break;

	  case 0x0A:
		_Retcode = OK;
	break;

	  default:
	_Retcode = W_DECR;
	break;
    }
  }

  if (_Retcode == OK)
  {
    MCM_BCNTS = 32;
    MCM_BCNTR = 4;
	MCM_TOC   = 10;//TIMEOUT;

    MCM_DATA = 0;
    MCM_DATA = 0;
    MCM_DATA = 0;
    MCM_DATA = 0;

    while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
    MCM_TOC = 0;

    if (!(_Status & _TE))
	{
      if ((MCM_DATA & 0x0F) == 0x04)
      {
		_Retcode = W_EMPTY;
      }
      else
	  {
		_Retcode = W_DECR;
	  }
    }
    else
    {
      _Retcode = OK;
    }
  }

  return (_Retcode);
}
/****************************************************************************
* Function:     mifs_transfer                                               *
****************************************************************************/
BYTE mifs_transfer(BYTE _Adr)
{
  BYTE _Status;
  BYTE _Retcode;

  TOGGLE_WD();

  MCM_BCNTS = 16;
  MCM_BCNTR = 4;
  MCM_DATA  = 0xB0;
  MCM_DATA  = _Adr;

  MCM_TOC = 16;//MEDIUM_TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
  MCM_TOC = 0;

  if (_Status & (_BE | _PE))
  {
    _Retcode = W_CODE;
  }
  else
  {
	MCM_TOC = 95;//LONG_TIMEOUT;
    while (!((_Status = MCM_STACON) & _DV))TOGGLE_WD();
    MCM_TOC = 0;

	if (_Status & (_TE | _BE))
    {
	  if (_Status & _TE)
      {
	_Retcode = W_NOTAG;
	  }
      else
	  {
		_Retcode = W_BITCNT;
	  }
	}
	else
	{
	  switch (MCM_DATA & 0x0F)
	  {
		case 0x0A:
	  _Retcode = OK;
	  break;

		case 0x04:
		case 0x05:
	  _Retcode = W_TRANS;
	  break;

		default:
	  _Retcode = W_CODE;
	  break;
      }
	}
  }

  return (_Retcode);
}
/****************************************************************************
* Function:     mifs_load_key                                               *
****************************************************************************/
BYTE mifs_load_key(BYTE _Mode, BYTE _SecNr, KEY *_TK, KEY *_NK)
{
  BYTE i;
  BYTE _Retcode;

  TOGGLE_WD();

  MCM_KEYSTACON = _LOAD | ( _Mode & KEYS);
  MCM_KEYADR    = _LOAD | ((_Mode & KEYB)? _KEYB : _KEYA) | _SecNr;

  for (i = 0; i < 6; i++)
  {
	MCM_KEYDATA = _TK->_key[i];
  }

  for (i = 0; i < 6; i++)
  {
	MCM_KEYDATA = _NK->_key[i];
  }

  if (MCM_STACON & _AE)
  {
	_Retcode = W_AUTH;
  }
  else
  {
	_Retcode = OK;
  }

  return (_Retcode);
}
/****************************************************************************
*                                                                           *
* Function:     mifs_reset                                                  *
*                                                                           *
* Input:        Msec                                                        *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/
void mifs_reset(BYTE idata *_Msec)
{
  TOGGLE_WD();

  MCM_STACON = _NRF | mif_control;

  if (_Msec[0] != 0 || _Msec[1] != 0)
  {
    delay_10ms((_Msec[0] | ((WORD)_Msec[1]) << 8)/10);
    delay_50us((_Msec[0] % 10)*20);

    MCM_STACON = mif_control;
    delay_50us(4);
  }
}
/****************************************************************************
* Function:     mifs_config                                                 *
****************************************************************************/
void mifs_config(BYTE _Mode, BYTE _Baud)
{
  TOGGLE_WD();

  __Mode    = _Mode;
  __Divider = _Baud;
}
/****************************************************************************
* Function:     qry_ext1                                                    *
****************************************************************************/
void qry_ext1(BYTE bytenr,BYTE *Buffer)
{
  ptr=0;
  do{
    do{
    }while(RdIO);
    BitCnt=11;
    TL1=StrtVal;
    TH1=BaudVal;          //96
    RcvDat=0;
    RxErr=0;
    TR1=TRUE;
    RxFlag=1;
    do{
    }while(RxFlag);
    Buffer[ptr]=RcvDat;
    ptr++;
  }while(ptr<bytenr);
}
/****************************************************************************
* Function:     RSXmt                                                       *
****************************************************************************/
void RSXmt(void)
{
  do{}while(RxFlag);    //wait rcv finish
  BitCnt=11;
  TL1=BaudVal;          //96
  TH1=BaudVal;
  TR1=1;
  IO(0);
  TxFlag=1;             //SETB TxFlag
  ACC=XmtDat;
  Parity=P;
  do{}while(TxFlag);    //wait send finish
}
/****************************************************************************
* Function:     Power_off                                                   *
****************************************************************************/
void Power_off(void)
{
  ICVCC=0;
  ICRST=0;
  ICIO =0;
  LED(RED,OFF);
}  
/****************************************************************************
* Function:     Reset                                                       *
****************************************************************************/
void Reset(BYTE *len, BYTE *resp)
{
  LED(RED,ON);    

  if(!RdVCC)
  { 
    VCC(1);
    delay_10ms(1);
    IO(1);          //Receive State
    if(bUseSAM)
    {
      PVCC=1;
    }else{
      ICCLK=1;ECPUCLK =TRUE;
    }
  }else{
    RST(0);
  }
  TMOD=0x22;        //Timer1, mode2, Timer0, mode2
  TH1=-52;          
  TL1=-52;
  ET1=FALSE;
  delay_50us(1);    //Delay 200 period  200/3.57Mhz=56us,
                    //56us/1.085us=51.6Cyl
  ET0=FALSE;    
  ET1=TRUE;
  TR1=FALSE;
  RST(1);
  qry_ext1(2,resp);         
  *len=(resp[1]&0x0f)+2;
  qry_ext1(*len,&(resp[2]));
  *len+=2;
}  
/****************************************************************************
* Function:     CPUC_Cmd                                                    *
****************************************************************************/
WORD CPUC_Cmd(BYTE len,BYTE* comm, BYTE *lenr, BYTE* resp)
{
  BYTE Lc, Le, sw1, sw2, i;
  BYTE BPrc,INS;

Begin:
  comm[len]=0;
  INS=comm[1];
  if(len>5)
  {
    Lc=comm[4];
    Le=comm[5+Lc];
  }else{
    Le=comm[4];
    Lc=0;
  }
  for(i=0;i<5;i++)      //Send CLA, INS, P1, P2, 0/Le/Lc
  {
    XmtDat=comm[i];
    RSXmt();
  }
A:  
  qry_ext1(1,&BPrc);

  if((BPrc==INS)||(BPrc==~INS))
  {
    if(Lc==0)
    {
      qry_ext1(Le+2,resp);       
      sw1=resp[Le]; sw2=resp[Le+1];
    }else{
      delay_50us(2);
      for(i=0;i<Lc;i++) 
      {
        XmtDat=comm[5+i];
        RSXmt();
      }  
      Lc=0;
      goto A;
    }  
  }else if(BPrc==0x6c) //repeat send Cmd ,change Lc/Le
  {
    qry_ext1(1,&BPrc);
    comm[4]=BPrc;
    goto Begin;
  }else if(BPrc==0x60) //wait
  {
    goto A; 
  }else
  {
    sw1=BPrc;  
    qry_ext1(1,&BPrc);
    sw2=BPrc;
    if(sw1==0x61)
    {
      comm[0]=0x00;
      comm[1]=0xC0;
      comm[2]=0x00;
      comm[3]=0x00;
      comm[4]=sw2;
      comm[5]=0;
      len=5;
      delay_50us(2);
      goto Begin;
    }  
  }
  *lenr=Le;
  
  return ( (((WORD)sw1)<<8)+sw2 );
}
/*
void Get_Challenge()
{
  SerBuffer[0]=0x00;
  SerBuffer[1]=0x84;
  SerBuffer[2]=0x00;
  SerBuffer[3]=0x00;
  SerBuffer[4]=0x08;
  CPUC_Cmd(SerBuffer, SerBuffer);
}
WORD External_Authenticate()
{
  char i;
  WORD Ret;
f2:
  for(i=8;i!=0;i--)
    SerBuffer[i+4]=SerBuffer[i-1];
  SerBuffer[0]=0x00;    
  SerBuffer[1]=0x82;
  SerBuffer[2]=0x00;
  SerBuffer[3]=0x99;
  SerBuffer[4]=0x08;
  Ret=CPUC_Cmd(SerBuffer, SerBuffer);
  return Ret;
}
void Internal_Authenticate()
{
  char i;

  for(i=8;i!=0;i--)
  {
    SerBuffer[i+4]=SerBuffer[i-1];
  }
  SerBuffer[0]=0x00;
  SerBuffer[1]=0x88;
  SerBuffer[2]=0x00;
  SerBuffer[3]=0x77;
  SerBuffer[4]=0x08;
  CPUC_Cmd(SerBuffer, SerBuffer);
}*/
/****************************************************************************
* Function:     InitCommPort                                                *
****************************************************************************/
void InitCommPort(void)
{
  TxFlag=0;
  RxFlag=0;
  RxErr =0;
  RcvRdy=0;
  RPtr=0;

//For 11.0592 MHz OSC, use Timer 2 can generate 38.4K, 19.2 or 9600 bps.
  SCON  = 0x50; // Mode 1, 8-bit UART, enable receiption
  T2CON = 0x34; // baud rate generator for Phytec's 12.0/11.0592 MHz OSC
                // recv'd & X'mit have the same baud rate,use timer 2
  RCAP2H= 0xff; // 11.0592 MHz OSC, for 115.2K bps use FFH
  RCAP2L= 0xdc; // 11.0592 MHz OSC, for 115.2K bps use FDH;9.6K bps use DCH
  PCON  = 0x00; // SMOD = 0; (single baud rate)
  ES    = TRUE;

  ET0   = TRUE; // Enable timer 0 interrupt
  ET1   = TRUE; // Enable timer 0 interrupt
  EA    = TRUE;

  DataDleReceived=FALSE;
  CmdValid    = FALSE;
  RecvState   = RECV_STX;
}
/****************************************************************************
* function:     init                                                        *
****************************************************************************/
void init(void)
{
  BYTE i;
  bit SW=ON;

  beep=ON;
  for(i=0;i<5;i++)
  {
    TOGGLE_WD();
    TOGGLE_BP();
    SW=~SW;
    LED(GREEN,~SW);
    LED(RED,   SW);
    delay_10ms(20);
  }
  InitCommPort();
  Power_off();
  ECPUCLK =TRUE;
  ICCLK=1;   
  PRST=1;
  PIO =1;
}
/****************************************************************************
* Function:     Check_cmd                                                   *
****************************************************************************/
void Check_cmd()
{
  if (CmdValid) //TRUE
  {
    CmdValid = FALSE;
    TOGGLE_WD();
    cmd_execution();
    TI= 1;
  }
}
/****************************************************************************
* Function:     Check_ICSW                                                  *
****************************************************************************/
BYTE Check_ICSW()
{
  if(ICSW ==OFF)
  {
    delay_10ms(1);
    if(ICSW ==OFF)
    {
      Power_off();
      return W_NOCARD;
    }
  }
  return OK;
}

void reset_4428()
{
  ECPUCLK=FALSE; 
  bUseSAM=FALSE;   
  LED(RED,ON);

  ICVCC=1;
  ICRST=0;
  ICCLK=0;
  delay_50us(10);

  ICRST=1;
  delay_15us_NOP();  
  ICCLK=1;
  delay_50us(10);
  ICCLK=0;
  delay_15us_NOP();  
  ICRST=0;
  delay_15us_NOP();    
}

BYTE SPI_RdByt()
{
  BYTE _data=0,i;

  ICCLK=0;//ICIO=1;
  delay_8us_NOP();
  for(i=0;i<8;i++)
  {
    ICCLK=1;
    delay_15us_NOP();
    _data>>=1;
    ICIO=1;
    if(ICIO==1)_data+=0x80;
    delay_15us_NOP();
    ICCLK=0;
    delay_15us_NOP();
  }
  return(_data);
}

BYTE SPI_RdMM(BYTE _addr,BYTE _len,BYTE *_dt)
{
  BYTE i;
  for(i=0;i<_len;i++)
  {
    delay_15us_NOP();
    *_dt=SPI_RdByt();
    _dt++;
  }
  return (OK);
}

BYTE SPI_RdMMwpb(BYTE _addr,BYTE _len,BYTE *_dt)
{