📄 simd.c
字号:
void SIM_HISR(void)
{
kal_uint16 sim_int;
sim_int = DRV_Reg(SIM_STS);
////dbg_print("sim_int = %x\r\n",sim_int);
if ( sim_int & SIM_STS_TXERR)
{
////dbg_print("SIM_STS_TXERR\r\n");
if (SimCard.State == SIM_PROCESSCMD)
{
SimCard.State = SIM_SERIOUSERR;
DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_TOUT);
}
else
{
SIM_Reject();
//SIM_SetEvent(SimCard,SIM_INIPTSERR);
}
}
if ( sim_int & SIM_STS_TX)
{
////dbg_print("SIM_STS_TX\r\n");
//SIM_DisIntr(SIM_IRQEN_TX);
#ifdef SIM_ADDDMA
////dbg_print("something error\r\n");
#else /*SIM_ADDDMA*/
SIM_Txhandler(); /* Only used for no DMA */
#endif /*SIM_ADDDMA*/
}
if ( sim_int & SIM_STS_TOUT)
{
////dbg_print("703SIM_STS_TOUT\r\n");
if(SimCard.State == SIM_WAIT_FOR_ATR)
{
SIM_SetEvent(SimCard,SIM_INIPTSERR);
}
if(SimCard.State == SIM_PROCESS_ATR)
{
SIM_Rxhandler(sim_int);
}
if( SimCard.State == SIM_PROCESS_PTS)
{
SIM_SetEvent(SimCard,SIM_INIPTSERR);
}
if (SimCard.State == SIM_PROCESSCMD)
{
if(SimCard.recDataErr == KAL_TRUE)
{
SIM_SetEvent(SimCard,SIM_CMDRECERR);
}
else
{
switch(SimCard.cmdState)
{
case SIM_ProcessClk:
////dbg_print("SIM_ProcessClk\r\n");
SIM_SetEvent(SimCard,SIM_CLKPROC);
break;
case SIM_StopClk:
////dbg_print("SIM_StopClk\r\n");
SIM_Idle(SimCard.clkStopLevel);
break;
default: /*normal command case*/
#ifdef NoT0CTRL
if (SimCard.cmdState == SIM_WaitProcByte)
{
kal_uint8 ACK;
kal_uint8 Error;
Error = KAL_TRUE;
while(SIM_FIFO_GetLev())
{
ACK = (kal_uint8)DRV_Reg(SIM_DATA);
if (ACK == 0x60) //NULL
{
continue;
}
if (SIM_CheckSW(ACK)) //ACK
{
SimCard.SW1 = ACK;
SimCard.SW2 = (kal_uint8)DRV_Reg(SIM_DATA);
SIM_SetEvent(SimCard,SIM_SUCCESS);
Error = KAL_FALSE;
}
else
{
break;
}
}
if (Error)
{
SIM_SetEvent(SimCard,SIM_CMDTOUT);
}
}
else
{
SIM_SetEvent(SimCard,SIM_CMDTOUT);
}
#else /*NoT0CTRL*/
SimCard.timeout = KAL_TRUE;
SIM_SetEvent(SimCard,SIM_CMDTOUT);
#endif /*NoT0CTRL*/
break;
}/*endof switch*/
}
}/*if (SimCard.State == SIM_PROCESSCMD)*/
if (SimCard.State == SIM_SERIOUSERR)
{
SIM_SetEvent(SimCard,SIM_CMDTXERR);
}
SIM_DisAllIntr();
}
if (sim_int & SIM_STS_RX)
{
////dbg_print("SIM_STS_RX\r\n");
if(SimCard.timeout != KAL_TRUE)
SIM_Rxhandler(sim_int);
}
if ( sim_int & SIM_STS_OV)
{
////dbg_print("SIM_STS_OV\r\n");
SimCard.recDataErr = KAL_TRUE;
#ifndef __PRODUCTION_RELEASE__
if (SimCard.State == SIM_PROCESSCMD)
ASSERT(0);
#endif
}
if ( sim_int & SIM_STS_RXERR)
{
////dbg_print("SIM_STS_RXERR\r\n");
SimCard.recDataErr = KAL_TRUE;
DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_TOUT);
#ifndef __PRODUCTION_RELEASE__
if (SimCard.State == SIM_PROCESSCMD)
ASSERT(0);
#endif
}
if ( (sim_int & SIM_IRQEN_T0END)
&& (SimCard.State == SIM_PROCESSCMD))
{
////dbg_print("SIM_IRQEN_T0END\r\n");
SIM_Cmdhandler();
SIM_DisAllIntr();
}
if ( sim_int & SIM_STS_NATR)
{
////dbg_print("SIM_STS_NATR\r\n");
SIM_DisAllIntr();
if (SimCard.SIM_ENV == ME_18V_30V)
{
if (SimCard.Power == SimCard.initialPower)
{
if (SimCard.Power != SIM_30V)
{
SimCard.Power = SIM_30V;
}
else
{
SimCard.Power = SIM_18V;
}
SIM_L1Reset();
}
else
{
SIM_Reject();
}
}
else
{
SIM_Reject();
}
}
if ( sim_int & SIM_STS_SIMOFF)
{
////dbg_print("SIM_STS_SIMOFF\r\n");
SIM_DisAllIntr();
if (SimCard.State == SIM_PWROFF)
{
DRVPDN_Enable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
if (SimCard.reject_set_event)
SIM_SetEvent(SimCard,SIM_NOREADY);
}
else
{
#if ( (!defined(MT6205)) && (!defined(MT6205B)) )
if (SimCard.State == SIM_WaitRejectDone)
{
SIM_Initialize(SimCard.Data_format,SimCard.Power);
}
else
{
ASSERT(0);
}
#else /*! (MT6205,MT6205B)*/
SIM_Initialize(SimCard.Data_format,SimCard.Power);
#endif /*MT6205,MT6205B*/
}
}
IRQClearInt(IRQ_SIM_CODE);
IRQUnmask(IRQ_SIM_CODE);
}
void SIM_LISR(void)
{
IRQMask(IRQ_SIM_CODE);
drv_active_hisr(DRV_SIM_HISR_ID);
}
#if 1
//==========================SIM adaption=============================
/*
* FUNCTION
* L1sim_PowerOff
*
* DESCRIPTION
* The function requests the driver to deactivate SIM
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*/
void L1sim_PowerOff(void) //Validate
{
SIM_DisAllIntr();
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
if(DRV_Reg(SIM_CTRL) | SIM_CTRL_HALT)
DRV_Reg(SIM_CTRL) &= ~SIM_CTRL_HALT;
SimCard.reject_set_event = KAL_FALSE;
SIM_Reject();
//DRVPDN_Enable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
}
/*
* FUNCTION
* L1sim_Reset
*
* DESCRIPTION
* The function L1sim_Reset is used to reset SIM by specific voltage
*
* CALLS
*
* PARAMETERS
* resetVolt: Request the driver to reset SIM at voltage resetVolt
* resultVolt: The pointer to the voltage after the driver reset SIM.
* (RESET_3V,RESET_5V)
* Info: The pointer to buffer of ATR data returned from SIM
*
* RETURNS
* SIM_NO_ERROR No SIM error
* SIM_NO_INSERT No SIM inserted
* SIM_CARD_ERROR SIM fatal error
*
* GLOBALS AFFECTED
* external_global
*/
kal_uint8 L1sim_Core_Reset(kal_uint8 resetVolt, kal_uint8 *resultVolt,AtrStruct *Info) //Validate
{
kal_uint8 index;
kal_sleep_task(2);
SIM_DisAllIntr();
SimCard.sim_card_speed = sim_card_normal_speed;
SimCard.reject_set_event = KAL_TRUE;
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
TOUTValue = SIM_DEFAULT_TOUT_VALUE;
TOUT_Factor=1;
SimCard.clkStop = KAL_FALSE;
SimCard.Speed = Speed372;
SimCard.State = SIM_WAIT_FOR_ATR;
SimCard.Power = resetVolt;
SimCard.initialPower = resetVolt;
#if defined(__USIM_DRV__)
{
SimCard.Data_format = usim_dcb.dir;
SimCard.result = SIM_SUCCESS;
}
#else
SimCard.Data_format = SIM_direct;
reset_index = 0;
SimCard.result = SIM_NOREADY;
SIM_L1Reset();
SIM_WaitEvent(SimCard,RST_READY);
if (SimCard.result == SIM_NOREADY)
{
//L1sim_PowerOff();
return SIM_NO_INSERT;
}
if (SimCard.result == SIM_CARDERR)
{
if (SimCard.Power == SIM_30V)
{
SimCard.Power = SIM_18V;
SIM_L1Reset();
}
else
{
SimCard.Power = SIM_30V;
SIM_L1Reset();
}
SIM_WaitEvent(SimCard,RST_READY);
}
#endif
if (SimCard.result == SIM_SUCCESS)
{
index=0;
while(1)
{
if (!SIM_ProcessATRData())
{
index++;
if (index == 3)
{
PTS_check = KAL_FALSE;
}
else if (index > 3)
{
PTS_check = KAL_FALSE;
L1sim_PowerOff();
return SIM_CARD_ERROR;
}
SIM_ResetNoATR(SimCard.Power);
}
else
{
if (resultVolt != NULL)
{
*resultVolt = SimCard.Power;
}
if (Info != NULL)
{
for (index = 0;index < SimCard.recDataLen;index++)
{
Info->info[index] = SimCard.recData[index];
}
}
return SIM_NO_ERROR;
}
}
}
else
{
L1sim_PowerOff();
return SIM_CARD_ERROR;
}
}
kal_uint8 L1sim_Reset(kal_uint8 resetVolt, kal_uint8 *resultVolt,AtrStruct *Info) //Validate
{
kal_uint8 result;
TS_HSK_ENABLE = KAL_TRUE;
result = L1sim_Core_Reset(resetVolt,resultVolt,Info);
if (result != SIM_NO_ERROR)
{
kal_print("[SIM]: SIM reset fail with TS_HSK_ENABLE");
TS_HSK_ENABLE = KAL_FALSE;
result = L1sim_Core_Reset(resetVolt,resultVolt,Info);
}
if(result == SIM_NO_ERROR)
{
kal_sprintf(sim_dbg_str,"[SIM]:SIM RESET OK, power:%d ,speed:%d",SimCard.Power,SimCard.Speed);
kal_print(sim_dbg_str);
}
else
{
kal_sprintf(sim_dbg_str,"[SIM]:SIM RESET FAIL, result:%d", result);
kal_print(sim_dbg_str);
}
return result;
}
void L1sim_NormalBaud(void)
{
#if ( (defined(MT6218)) || (defined(MT6218B)) )
SIM_DisAllIntr();
if (SimCard.clkStop == KAL_TRUE)
{
SIM_ActiveClk();
}
else
{
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
}
DRV_WriteReg(SIM_BRR,(SIM_BRR_CLK_Div4 | SIM_BRR_BAUD_Div372));
#endif /*MT6218,MT6218B*/
}
void L1sim_ChangeBaud(void)
{
#if ( (defined(MT6218)) || (defined(MT6218B)) )
SIM_DisAllIntr();
if (SimCard.clkStop == KAL_TRUE)
{
SIM_ActiveClk();
}
else
{
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
}
DRV_WriteReg(SIM_BRR,(SIM_BRR_CLK_Div4 | (0x17<<2)));
#endif /*MT6218,MT6218B*/
}
/*
* FUNCTION
* L1sim_Configure
*
* DESCRIPTION
* The function indicates clock mode when idle.
*
* CALLS
*
* PARAMETERS
* clockMode: The clockMode defines the clock mode when idle.
* CLOCK_STOP_AT_HIGH,CLOCK_STOP_AT_LOW,CLOCK_STOP_NOT_ALLOW
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*/
void L1sim_Configure(kal_uint8 clockMode) //Validate
{
switch (clockMode)
{
case CLOCK_STOP_AT_HIGH:
#if ( (defined(MT6205)) || (defined(MT6205B)) || (defined(MT6218)) )
DRV_Reg(SIM_CONF) |= SIM_CONF_HALTEN;
#endif /*MT6205,MT6205B,MT6218*/
SimCard.clkStop = KAL_TRUE;
SimCard.clkStopLevel = KAL_TRUE;
break;
case CLOCK_STOP_AT_LOW:
#if ( (defined(MT6205)) || (defined(MT6205B)) || (defined(MT6218)) )
DRV_Reg(SIM_CONF) |= SIM_CONF_HALTEN;
#endif /*MT6205,MT6205B,MT6218*/
SimCard.clkStop = KAL_TRUE;
SimCard.clkStopLevel = KAL_FALSE;
break;
case CLOCK_STOP_NOT_ALLOW:
#if ( (defined(MT6205)) || (defined(MT6205B)) || (defined(MT6218)) )
DRV_Reg(SIM_CONF) &= ~SIM_CONF_HALTEN;
#endif /*MT6205,MT6205B,MT6218*/
SimCard.clkStop = KAL_FALSE;
break;
default:
break;
}
}
/*
* FUNCTION
* SIM_CMD
*
* DESCRIPTION
* The function is used to transmit coded command and
* its following data to the driver.
*
* CALLS
*
* PARAMETERS
* txData: Pointer to the transmitted command and data.
* txSize: The size of the transmitted command and data from AL to driver.
* expSize: The size of expected data from SIM
* result: Pointer to received data
* rcvSize: Pointer to the size of data received
* parityError: 1 (parity error) or 0(no parity error)
*
* RETURNS
* status(high byte:sw1 low byte: sw2)
*
* GLOBALS AFFECTED
* external_global
*/
kal_uint16 SIM_CMD(kal_uint8 *txData,kal_uint16 txSize,kal_uint8 *result,kal_uint16 *rcvSize, kal_uint8 *Error)
//kal_uint16 L1sim_Cmd(kal_uint8 *txData,kal_uint16 txSize,kal_uint8 expSize, kal_uint8 *result,kal_uint8 *rcvSize, kal_uint8 *Error)
{
kal_uint16 SW;
kal_uint8 index;
kal_uint16 INS;
kal_uint16 temp;
kal_uint16 expSize = *rcvSize;
#ifdef SIM_ADDDMA
kal_bool txDelay = KAL_FALSE;
kal_uint32 txaddr;
kal_uint32 rxaddr;
#endif/*SIM_ADDDMA*/
if(result == NULL && *rcvSize != 0)
{
*Error = KAL_TRUE;
return 0;
}
if (SimCard.State != SIM_PROCESSCMD)
{
*Error = KAL_TRUE;
return 0;
}
#ifdef NoT0CTRL
if ((SimCard.cmdState != SIMD_CmdIdle)&&(SimCard.cmdState != SIM_StopClk))
{
*Error = KAL_TRUE;
return 0;
}
#endif /*NoT0CTRL*/
#if 0
/* under construction !*/
/* under construction !*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -