mfrc500.c.bak

来自「mifarea卡程序mifarea卡程序mifarea卡程序」· BAK 代码 · 共 2,151 行 · 第 1/5 页

// cook key
void M500HostCodeKey(uchar *uncoded,uchar *coded)
{
    uchar idata cnt = 0;
    uchar idata ln  = 0;
    uchar 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;
    }
}

///////////////////////////////////////////////////////////////////////
//          M I F A R E     H A L T
///////////////////////////////////////////////////////////////////////
/*
char M500Halt(void)
{
   char status = MI_CODEERR;

   M500PcdSetTmo(3);//106);
   // ************* Cmd Sequence ********************************** 
   ResetInfo(&MInfo);   
   SndBuffer[0] = PICC_HALT ;     // Halt command code
   SndBuffer[1] = 0x00;         // dummy address
   MInfo.nBytesToSend   = 2;
   status = M500PcdCmd(PCD_TRANSCEIVE,
                       SndBuffer,
                       RcvBuffer,
                       &MInfo);   
   if (status)
   {
     // timeout error ==> no NAK received ==> OK
     if (status == MI_NOTAGERR || status == MI_ACCESSTIMEOUT)
        status = MI_OK;
   }
    //reset command register - no response from tag
   WriteIO(RegCommand,PCD_IDLE);
   return status; 
}
*/

uchar M500PiccAuthState(uchar AuthMode, uchar *snr, uchar Sector)
{
    uchar idata status = MI_OK;

    status = ReadIO(RegErrorFlag);

    if (status != MI_OK)
    {
        if (status & 0x40)
            status = MI_KEYERR;
        else
            status = MI_AUTHERR;
    }
    else
    {
        SndBuffer[0] = AuthMode;
        SndBuffer[1] = Sector*4+3;
        memcpy(SndBuffer + 2, snr, 4);
        ResetInfo(&MInfo);
        MInfo.nBytesToSend = 6;
        M500PcdSetTmo(3); // 3
        if ((status = M500PcdCmd(PCD_AUTHENT1, SndBuffer, RcvBuffer, &MInfo)) == MI_OK)
        {
            if (ReadIO(RegSecondaryStatus) & 0x07)
            {
                status = MI_BITCOUNTERR;
            }
            else
            {
                ResetInfo(&MInfo);
                MInfo.nBytesToSend = 0;
                if ((status = M500PcdCmd(PCD_AUTHENT2, SndBuffer, RcvBuffer, &MInfo)) == MI_OK)
                {
                    if ( ReadIO(RegControl) & 0x08 )
                    {
                        status = MI_OK;
                    }
                    else
                    {
                        status = MI_AUTHERR;
                    }
                }
            }
        }
    }
    return status;
}

uchar M500Auth(uchar Mode, uchar *snr, uchar *Keys, uchar Sector)
{
    uchar idata status = MI_OK;
    uchar idata keycoded[12];
    uchar idata offset;

    offset = (Mode == PICC_AUTHENT1A) ? 0 : 6;
    M500HostCodeKey(Keys,keycoded);
    FlushFIFO();
    ResetInfo(&MInfo);
    memcpy(SndBuffer,keycoded,12);
    MInfo.nBytesToSend = 12;
    if ((status = M500PcdCmd(PCD_LOADKEY, SndBuffer, RcvBuffer, &MInfo)) == MI_OK)
    {
        status = M500PiccAuthState(Mode, snr, Sector);
    }
    return status;
}

uchar M500Read(uchar Address,uchar *DataBuff)
{

    uchar idata status = MI_OK;
    uchar idata tmp    = 0;

    FlushFIFO();
    M500PcdSetTmo(4); //3
    WriteIO(RegChannelRedundancy,0x0F);
    ResetInfo(&MInfo);
    SndBuffer[0] = PICC_READ;
    SndBuffer[1] = Address;
    MInfo.nBytesToSend = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);
    if (status != MI_OK)
    {
        if (status != MI_NOTAGERR )
        {
            if (MInfo.nBitsReceived == 4)
            {
                RcvBuffer[0] &= 0x0f;
                if ((RcvBuffer[0] & 0x0a) == 0)
                {
                    status = MI_NOTAUTHERR;
                }
                else
                {
                    status = MI_CODEERR;
                }
            }
        }
    }
    else
    {
        if (MInfo.nBytesReceived != 16)
        {
            status = MI_BYTECOUNTERR;
        }
        else
        {
            memcpy(DataBuff,RcvBuffer,16);
        }
    }
    return status;
}

uchar M500Write(uchar Address,uchar *DataBuff)
{

    uchar idata status = MI_OK;

    ResetInfo(&MInfo);
    SndBuffer[0] = PICC_WRITE;
    SndBuffer[1] = Address;
    MInfo.nBytesToSend = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);

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

    if ( status == MI_OK)
    {

        M500PcdSetTmo(3);

        ResetInfo(&MInfo);
        memcpy(SndBuffer,DataBuff,16);
        MInfo.nBytesToSend   = 16;
        status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);

        if (status != MI_NOTAGERR)
        {

            if (MInfo.nBitsReceived != 4)
            {
                status = MI_BITCOUNTERR;
            }
            else
            {
                RcvBuffer[0] &= 0x0f;
                if ((RcvBuffer[0] & 0x0a) == 0)
                {
                    status = MI_WRITEERR;
                }
                else
                {
                    if (RcvBuffer[0] == 0x0a)
                    {
                        status = MI_OK;
                    }
                    else
                    {
                        status = MI_CODEERR;
                    }
                }
            }
        }
    }
    return status;
}

uchar M500Increment(uchar addr, uchar *value, uchar bakaddr)
{
    uchar i;
    if((i=M500Value(PICC_INCREMENT, addr, value, addr)) != MI_OK)
        return i;

    if(addr != bakaddr)
        return M500Copy(addr, bakaddr);
    else
        return MI_OK;
}

uchar M500Decrement(uchar addr, uchar *value, uchar bakaddr)
{
    uchar i;
    if((i=M500Value(PICC_DECREMENT, addr, value, addr)) != MI_OK)
        return i;
        
    if(addr != bakaddr)
        return M500Copy(addr, bakaddr);
    else
        return MI_OK;
}

uchar M500Copy(uchar srcaddr, uchar desaddr)
{
    uchar i;
    
    if((i=M500Restore(srcaddr)) != MI_OK)
        return i;
    else
        return M500Transfer(desaddr);
}

uchar M500Restore(uchar Address)
{
    uchar status = MI_OK;

    M500PcdSetTmo(1);
    ResetInfo(&MInfo);
    SndBuffer[0] = PICC_RESTORE;
    SndBuffer[1] = Address;
    MInfo.nBytesToSend   = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);

    if (status != MI_NOTAGERR)
    {
        if (MInfo.nBitsReceived != 4)
        {
            status = MI_BITCOUNTERR;
        }
        else
        {
            RcvBuffer[0] &= 0x0f;
            switch(RcvBuffer[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)
    {

        M500PcdSetTmo(3);
        ResetInfo(&MInfo);
        SndBuffer[0]=0;
        SndBuffer[1]=0;
        SndBuffer[2]=0;
        SndBuffer[3]=0;
        MInfo.nBytesToSend   = 4;
        status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);
        if (status == MI_OK)
        {
            if (MInfo.nBitsReceived != 4)
            {
                status = MI_BITCOUNTERR;
            }
            else
            {
                RcvBuffer[0] &= 0x0f;
                switch(RcvBuffer[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;
    }
    return status;
}

uchar M500Transfer(uchar Address)
{
    uchar status = MI_OK;

    ResetInfo(&MInfo);
    M500PcdSetTmo(3);
    SndBuffer[0] = PICC_TRANSFER;
    SndBuffer[1] = Address;
    MInfo.nBytesToSend   = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);
    if (status != MI_NOTAGERR)
    {
        if (MInfo.nBitsReceived != 4)
        {
            status = MI_BITCOUNTERR;
        }
        else
        {
            RcvBuffer[0] &= 0x0f;
            switch(RcvBuffer[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;
}


///////////////////////////////////////////////////////////////////////
//                V A L U E   M A N I P U L A T I O N 
///////////////////////////////////////////////////////////////////////
char M500Value(unsigned char dd_mode, 
                   unsigned char addr, 
                   unsigned char *value,
                   unsigned char trans_addr)
{
   char status = MI_OK;

   M500PcdSetTmo(3);//255);  // 106
   // ************* Cmd Sequence ********************************** 
   ResetInfo(&MInfo);   
   SndBuffer[0] = dd_mode;        // Inc,Dec command code
   SndBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = M500PcdCmd(PCD_TRANSCEIVE,
                       SndBuffer,
                       RcvBuffer,
                       &MInfo);

   if (status != MI_NOTAGERR)   // no timeout error
   {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
        }
        else                     // 4 bit received
        {
           RcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(RcvBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              case 0x01:
                 status = MI_VALERR;
                 break;