mf_rc500.c

RC500 Mifare Chip for 8051 code

   return status;  
}

char MF_Select(unsigned char *snr,
                        unsigned char *sak)
{
   char idata status = MI_OK; 
 
   RC_SetTmod(tmod_1ms);
	
   RC_WriteRC(RegChannelRedundancy,0x0F); 
   RC_ClearBit(RegControl,0x08);    
   ResetInfo(MInfo);   
   SerBuffer[0] = 0x93;
   SerBuffer[1] = 0x70;        
   
   memcpy(SerBuffer + 2,snr,4);
   SerBuffer[6] = SerBuffer[2] ^ SerBuffer[3] ^ SerBuffer[4] ^ SerBuffer[5];
   MInfo.nBytesToSend   = 7;
   status = RC_Command(PCD_TRANSCEIVE,
                       SerBuffer,
                       &MInfo);

   *sak = 0;   
   if (status == MI_OK)  
   {
      if (MInfo.nBitsReceived != 8)   
      {
         status = MI_BITCOUNTERR;
      }
      else
      {
	 *sak = SerBuffer[0];
      }	
   }
  
   return status;
}
#if(0)

char MF_LoadKeyE2(unsigned char key_type,
                       unsigned char sector,
                       unsigned char *uncoded_keys)
{
   signed char status = MI_OK;
   unsigned int e2addr = 0x80 + sector * 0x18;
   unsigned char coded_keys[12];

   if (key_type == PICC_AUTHENT1B)
      e2addr += 12; // key B offset
   if ((status = MF_ChgAvailableKey(uncoded_keys,coded_keys)) == MI_OK)
      status = RC_WriteE2(  e2addr,12,coded_keys);
   return status;
}

char RC_WriteE2(unsigned int startaddr,
                unsigned char length,
                unsigned char* _data)
{
   char status = MI_OK;
   ResetInfo(MInfo);   
   SerBuffer[0] = startaddr & 0xFF;
   SerBuffer[1] = (startaddr >> 8) & 0xFF;
   memcpy(SerBuffer + 2,_data,length);

   MInfo.nBytesToSend   = length + 2;
         
   status = RC_Command(PCD_WRITEE2,
                       SerBuffer,
                       &MInfo); 
   return status;
}   

char MF_AuthE2( unsigned char auth_mode, 
                     unsigned char *snr,      
                     unsigned char keynr,
                     unsigned char block)     
                                              
{
   char idata status = MI_OK;
   unsigned int e2addr = 0x80 + keynr * 0x18;
   unsigned char *e2addrbuf = (unsigned char*)&e2addr;
   

   if (auth_mode == PICC_AUTHENT1B)
      e2addr += 12; 
   RC_FlushFIFO();    
   ResetInfo(MInfo);

   memcpy(SerBuffer,e2addrbuf,2); 
   SerBuffer[2] = SerBuffer[0];      
   SerBuffer[0] = SerBuffer[1]; 
   SerBuffer[1] = SerBuffer[2];
   MInfo.nBytesToSend   = 2;
   if ((status=RC_Command(PCD_LOADKEYE2,SerBuffer,&MInfo)) == MI_OK)
   {  
      status = MF_AuthState(auth_mode,snr,block);  //11.9
   }
   return status;
}                        
char load_key(void)
{
          uchar code Nkey_a1[6]={0xc5,0xc4,0xc3,0xc2,0xc1,0xc0};
          uchar code Nkey_b1[6]={0xd5,0xd4,0xd3,0xd2,0xd1,0xd0};
          uchar code Nkey_a2[6]={0xff,0xff,0xff,0xff,0xff,0xff};
          uchar code Nkey_b2[6]={0xff,0xff,0xff,0xff,0xff,0xff};
          uchar code Nkey_a[6]={0xff,0xff,0xff,0xff,0xff,0xff};
          uchar code Nkey_b[6]={0xff,0xff,0xff,0xff,0xff,0xff};
          uchar i,key_mode;//s;            
              
                if (MF_LoadKeyE2(KEYA,0,Nkey_a1))
                return LOAD_KEYA_ERR;
          
               if(MF_LoadKeyE2(KEYB,0,Nkey_b1))
               return LOAD_KEYB_ERR;

                if (MF_LoadKeyE2(KEYA,1,Nkey_a))
                return LOAD_KEYA_ERR;
  
               if(MF_LoadKeyE2(KEYB,1,Nkey_b))
               return LOAD_KEYB_ERR;
               
         
                key_mode=KEYA;//0x00   /*prepare key A (SET 0)loading*/
                for (i=2;i<16;i++)
                        {
                        watch_dog();
                       if(MF_LoadKeyE2(key_mode,i,Nkey_a2))
                       return LOAD_KEYA_ERR;
                        }
                key_mode=KEYB;//0x04   /*prepare key B (SET 0)loading*/
                for (i=2;i<16;i++)
                        {
                          watch_dog( );
                          if(MF_LoadKeyE2(key_mode,i,Nkey_b2))
                          return LOAD_KEYB_ERR;
                        //load key ok
                         }  
                return 0;                     
}

char MF_Value(unsigned char dd_mode, 
                    unsigned char addr, 
                    unsigned char *value,
                    unsigned char trans_addr)
{
   char status = MI_OK;

   RC_SetTmod(tmod_1ms); 
   ResetInfo(MInfo);   
   SerBuffer[0] = dd_mode;      
   SerBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = RC_Command(PCD_TRANSCEIVE,
                       SerBuffer,
                       &MInfo);

   if (status != MI_NOTAGERR)   
   {
        if (MInfo.nBitsReceived != 4)  
        {
           status = MI_BITCOUNTERR;
        }
        else                    
        {
           SerBuffer[0] &= 0x0f; 
           switch(SerBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              case 0x01:
                 status = MI_VALERR;
                 break;
              default:
                 status = MI_CODEERR;
                 break;
           }
        }
     }

     if ( status == MI_OK)
     {
        RC_SetTmod(tmod_6ms);    
        ResetInfo(MInfo);   
        memcpy(SerBuffer,value,4);
        MInfo.nBytesToSend   = 4;
        status = RC_Command(PCD_TRANSCEIVE,
                            SerBuffer,
                            &MInfo);
        
        if (status == MI_OK)    
        {
            if (MInfo.nBitsReceived != 4)   
            {
               status = MI_BITCOUNTERR;
            }
            else                    
            {
               SerBuffer[0] &= 0x0f; 
               switch(SerBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
         }        
         else
         if (status == MI_NOTAGERR )
            status = MI_OK;  
     }
     if ( status == MI_OK)
     {
        ResetInfo(MInfo);   
        SerBuffer[0] = PICC_TRANSFER;      
        SerBuffer[1] = trans_addr;
        MInfo.nBytesToSend   = 2;
        status = RC_Command(PCD_TRANSCEIVE,
                            SerBuffer,
                            &MInfo);
        
        if (status != MI_NOTAGERR)  
        {
            if (MInfo.nBitsReceived != 4)
            {
               status = MI_BITCOUNTERR;
            }
            else                   
            {
               SerBuffer[0] &= 0x0f; 
               switch(SerBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x0a:
                     status = MI_OK;
                     break;
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
        }        
     }
   return status;
}

#endif

char MF_ChgAvailableKey(  unsigned char *uncoded, 
                     unsigned char *coded)   
{
   char idata status = MI_OK;
   unsigned char idata cnt = 0;
   unsigned char idata ln  = 0;     
   unsigned char idata hn  = 0;      
   for (cnt = 0; cnt < 6; cnt++)
   {
      ln = uncoded[cnt] & 0x0F;
      hn = uncoded[cnt] >> 4;
      coded[cnt * 2 + 1] = (~ln << 4) | ln;
      coded[cnt * 2 ] = (~hn << 4) | hn;

   }
   return MI_OK;
}

char MF_AuthKey(  unsigned char auth_mode,unsigned char *snr,unsigned char *keys,unsigned char block)      
{
   char idata status = MI_OK;
   RC_FlushFIFO();   
   ResetInfo(MInfo);
   MF_ChgAvailableKey(keys,SerBuffer);
   MInfo.nBytesToSend = 12;
   if ((status=RC_Command(PCD_LOADKEY,SerBuffer,&MInfo)) == MI_OK)
   {      
      status = MF_AuthState(auth_mode,snr,block); 
   }
   return status;
}

char MF_AuthState( unsigned char auth_mode,
                        unsigned char *snr,
                        unsigned char block)
{
   char idata status = MI_OK;
   unsigned char idata i = 0;
   
   status = RC_ReadRC(RegErrorFlag);                                     
   if (status != MI_OK)
   {
      if (status & 0x40)           
         status = MI_KEYERR;
      else
         status = MI_AUTHERR;    
   }
   else
   {
      SerBuffer[0] = auth_mode;    

      SerBuffer[1] = block;  
      memcpy(SerBuffer + 2,snr,4); 
      ResetInfo(MInfo);
      MInfo.nBytesToSend = 6;
      if ((status = RC_Command(PCD_AUTHENT1,
                               SerBuffer,
                               &MInfo)) == MI_OK)
      {
         if (RC_ReadRC(RegSecondaryStatus) & 0x07) 
         {
            status = MI_BITCOUNTERR;
         }
         else
         {
            ResetInfo(MInfo);
            MInfo.nBytesToSend = 0;
            if ((status = RC_Command(PCD_AUTHENT2,
                                     SerBuffer,
                                     &MInfo)) == MI_OK) 
            {
               if ( RC_ReadRC(RegControl) & 0x08 ) 
               {
                   status = MI_OK;
               }
               else
               {
                   status = MI_AUTHERR;
               }
            }
         }
      }
   }
   return status;
}
char MF_ReadCard(  unsigned char addr,
                  unsigned char *_data)
{
   char idata status = MI_OK;
   char idata tmp    = 0;

   RC_FlushFIFO();    

   RC_SetTmod(tmod_6ms);  
   RC_WriteRC(RegChannelRedundancy,0x0F);
   ResetInfo(MInfo);   
   SerBuffer[0] = PICC_READ;   
   SerBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;   
   status = RC_Command(PCD_TRANSCEIVE,
                       SerBuffer,
                       &MInfo);

   if (status != MI_OK)
   {
      if (status != MI_NOTAGERR ) 
      {
         if (MInfo.nBitsReceived == 4)  
         {
             SerBuffer[0] &= 0x0f;  
             if ((SerBuffer[0] & 0x0a) == 0)
             {
                status = MI_NOTAUTHERR;
             }
             else
             {
                status = MI_CODEERR;
             }
          }
      }
      memcpy(_data,"0000000000000000",16); 
   }
   else   // Response Processing
   {
      if (MInfo.nBytesReceived != 16)
      {
         status = MI_BYTECOUNTERR;
         memcpy(_data,"0000000000000000",16);
      }
      else
      {
         memcpy(_data,SerBuffer,16);
      }
   }
   RC_SetTmod(tmod_1ms);             
   return status; 
}


char MF_WriteCard( unsigned char addr,
                  unsigned char *_data)
{
   char idata status = MI_OK;
     ResetInfo(MInfo);   
     SerBuffer[0] = PICC_WRITE; 
     SerBuffer[1] = addr;            
     MInfo.nBytesToSend   = 2;
     status = RC_Command(PCD_TRANSCEIVE,
                         SerBuffer,
                         &MInfo);

     if (status != MI_NOTAGERR)   
     {
        if (MInfo.nBitsReceived != 4)  
        {
           status = MI_BITCOUNTERR;
        }
        else                     
        {
           SerBuffer[0] &= 0x0f; 
           if ((SerBuffer[0] & 0x0a) == 0)
           {
              status = MI_NOTAUTHERR;                   
           }
           else
           {
              if (SerBuffer[0] == 0x0a)
              {
                 status = MI_OK;
              }
              else 
              {
                 status = MI_CODEERR;
              }
           }
        }
     }

     if ( status == MI_OK)
     {