lll_msr.c

非接触式M1卡读写器,读写源程序,可读S50/S70的卡

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

		case 0x04:
          _Retcode = W_EMPTY;
          break;

		default:
          _Retcode = W_DECR;
          break;
      }
	}
  }
  MCM_CS=1;
  return (_Retcode);
}


/****************************************************************************
*                                                                           *
* Function:     mifs_restore                                                *
*                                                                           *
* Input:        Adr                                                         *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

uchar mifs_restore(uchar _Adr)
{
  uchar _Status;
  uchar _Retcode;

  TOGGLE_WD();
  MCM_CS=0;
  MCM_BCNTS = 16;
  MCM_BCNTR = 4;
  MCM_DATA  = 0xC2;
  MCM_DATA  = _Adr;

  MCM_TOC = TIMEOUT;
  while (!((_Status = MCM_STACON) & _DV));
  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   = TIMEOUT;

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

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

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


/****************************************************************************
*                                                                           *
* Function:     mifs_transfer                                               *
*                                                                           *
* Input:        Adr                                                         *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

uchar mifs_transfer(uchar _Adr)
{
  uchar _Status;
  uchar _Retcode;

  TOGGLE_WD();
  MCM_CS=0;
  MCM_BCNTS = 16;
  MCM_BCNTR = 4;
  MCM_DATA  = 0xB0;
  MCM_DATA  = _Adr;

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

  if (_Status & (_BE | _PE))
  {
    _Retcode = W_CODE;
  }
  else
  {
	MCM_TOC = LONG_TIMEOUT;
    while (!((_Status = MCM_STACON) & _DV));
    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;
      }
	}
  }
   MCM_CS=1;
  return (_Retcode);
}


/****************************************************************************
*                                                                           *
* Function:     mifs_load_key                                               *
*                                                                           *
* Input:        Mode, SecNr, TK, NK                                         *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

uchar mifs_load_key(uchar _Mode, uchar _SecNr, KEY *_TK, KEY *_NK)
{
  uchar i;
  uchar _Retcode;

  TOGGLE_WD();
  MCM_CS=0;
  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;
  }
  MCM_CS=1;
  return (_Retcode);
}


/****************************************************************************
*                                                                           *
* Function:     mifs_reset                                                  *
*                                                                           *
* Input:        Msec                                                        *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void mifs_reset(uchar idata *_Msec)
{
  TOGGLE_WD();
  MCM_CS=0;
  MCM_STACON = _NRF | mif_control;

  if (_Msec[0] != 0 || _Msec[1] != 0)
  {
	delay_10ms((_Msec[0] | ((uint)_Msec[1]) << 8)/10);
	delay_1ms(_Msec[0] % 10);

	MCM_STACON = mif_control;
    delay_50us(4);
  }
   MCM_CS=1;
}


/****************************************************************************
*                                                                           *
* Function:     mifs_set_control_bit                                        *
*                                                                           *
* Input:        Byte                                                        *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void mifs_set_control_bit(uchar _Byte)
{
  TOGGLE_WD();
  mif_control |= _Byte;
}


/****************************************************************************
*                                                                           *
* Function:     mifs_clr_control_bit                                        *
*                                                                           *
* Input:        Byte                                                        *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void mifs_clr_control_bit(uchar _Byte)
{
  TOGGLE_WD();
  mif_control &= ~_Byte;
}


/****************************************************************************
*                                                                           *
* Function:     mifs_config                                                 *
*                                                                           *
* Input:        Mode, Baud                                                  *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void mifs_config(uchar _Mode, uchar _Baud)
{
  TOGGLE_WD();

  __Mode    = _Mode;
  __Divider = _Baud;
}


/****************************************************************************
*                                                                           *
* Function:     idle_mifs_request                                           *
*                                                                           *
* Input:        -                                                           *
* Output:       -                                                           *
*                                                                           *
****************************************************************************/

void idle_mifs_request(void)
{
  uchar _Status, _10ms;

  auto_baud();
  TOGGLE_WD();
  auto_baud();
  MCM_CS=0;
  MCM_STACON   = _SOR | mif_control;
  MCM_CS=1;
  auto_baud();
   MCM_CS=0;
  MCM_BAUDRATE = __Divider;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_ENABLE   = _PEN | _PRE;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_MODE     = __Mode;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_STACON   = mif_control;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_RCODE    = 3;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_BCNTS    = 7;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_BCNTR    = 16;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_DATA     = _REQUEST;
  MCM_CS=1;
  auto_baud();
  MCM_CS=0;
  MCM_TOC      = TIMEOUT;
  MCM_CS=1;
  auto_baud();
  while (1)
  {
  	auto_baud();
	MCM_CS=0;
	_Status = MCM_STACON;
	MCM_CS=1;
	auto_baud();
	if (_Status & _DV)
	{
	  auto_baud();
	  break;
	}
  }
  auto_baud();
   MCM_CS=0;
  MCM_TOC      = 0;
   MCM_CS=1;
  auto_baud();

  if (Enable_LEDs)
  {
	auto_baud();
	if (_Status & (_TE | _BE))
	{
	  auto_baud();
	  GRUEN = ON;
	  auto_baud();
	}
	else
	{
	  auto_baud();
	  GRUEN = OFF;
	  auto_baud();
	}
  }
  auto_baud();
   MCM_CS=0;
  _Status = MCM_DATA;
   MCM_CS=1;
  auto_baud();
   MCM_CS=0;
  _Status = MCM_DATA;
   MCM_CS=1;
  auto_baud();

#ifndef NO_TIMER2
  RCAP2LH = RCAP2_10ms;
  auto_baud();
  T2LH    = RCAP2_10ms;
  auto_baud();
  TR2 = TRUE;
  auto_baud();
  _10ms = 10;
  auto_baud();
  do
  {
	auto_baud();
	while (!TF2)
	{
	  auto_baud();
	  if (CmdValid)
	  {
		TR2 = FALSE;
		TF2 = FALSE;
		return;
	  }
	  auto_baud();
	  if (CmdReceived)
	  {
		TR2 = FALSE;
		TF2 = FALSE;
		return;
	  }
	  auto_baud();
	}
	auto_baud();
	TF2 = FALSE;
	auto_baud();
	_10ms--;
	auto_baud();
	TOGGLE_WD();
	auto_baud();
  } while (_10ms);
  auto_baud();
  TR2 = FALSE;
  auto_baud();
#endif
   MCM_CS=1;
}


/***************************************************************************/