simd.c

8032底层驱动部分。因为可以移植 所以单独来拿出来

/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
  #endif
   /*for clock stop mode*/
   SIM_DisAllIntr();
   
   if (SimCard.clkStop == KAL_TRUE)
   {
      SIM_ActiveClk();
   }
   else
   {
      DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_SIM,PDN_SIM);
   }

   SIM_DisAllIntr();
   
   if( (SimCard.Speed != Speed372) &&
       ((DRV_Reg(SIM_CTRL)) & SIM_CTRL_HALT) 
     )     
   {
      DRV_Reg(SIM_CONF) &= ~SIM_CONF_TOUTEN;
      SIM_SetTOUT(ClkStopTimeTable[SimCard.Speed][0]*TOUT_Factor);
      DRV_Reg(SIM_CONF) |= SIM_CONF_TOUTEN;
      SimCard.cmdState = SIM_ProcessClk;
      DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_TOUT);
      SIM_WaitEvent(SimCard,CLK_PROC);
   }
	else if(SimCard.is_err && SimCard.Speed == Speed32) // to solve ROSSINI SIM issue
	{		
		kal_uint32 t1;
	
		t1 = SIM_GetCurrentTime();
		while((SIM_GetCurrentTime()-t1) < 5); // delay 500 clock cycles (152us) 
		
	}
   DRV_Reg(SIM_CONF) &= ~SIM_CONF_TOUTEN;

   kal_set_eg_events(SimCard.event,0,KAL_AND);  //2: NU_AND
   
   SIM_SetTOUT(TOUTValue);
   SIM_FIFO_Flush();
   *Error = KAL_FALSE;
   SimCard.recDataErr = KAL_FALSE;
	
#ifdef SIM_ADDDMA
   txaddr = (kal_uint32)txData;
   rxaddr = (kal_uint32)result;
#else /*SIM_ADDDMA*/
   SimCard.txbuffer = txData;
   SimCard.txsize = txSize;
   SimCard.rxbuffer = result;
   SimCard.recDataLen = 0;
#ifdef NoT0CTRL 
   SimCard.recsize = expSize;
   SimCard.txindex = 0;
   SimCard.INS = *(txData+1);
#endif   /*NoT0CTRL*/
#endif/*SIM_ADDDMA*/

#ifndef NoT0CTRL
   INS = (kal_uint16)*(txData+1);
   SIM_SetIMP3(*(txData+4));
   SimCard.cmdState = SIM_WaitCmdEnd;
#endif   /*NoT0CTRL*/
   
#ifdef SIM_ADDDMA   
   for(index=0;index<5;index++)
   {
      DRV_WriteReg(SIM_DATA,*(txData+index));
   }
   //DRVPDN_Disable(DRVPDN_CON0,DRVPDN_CON0_DMA,PDN_DMA);
   
   #if ( (defined(MT6205)) || (defined(MT6205B)) )
      DMA2_Stop();
   #else /*!MT6205, MT6205B*/
      DMA_Stop(sim_dmaport);
   #endif   /*MT6205, MT6205B*/
   SIM_SetRXTIDE(1);
   if (expSize == 0)
   {
      SIM_SetTXTIDE(0);
      #if ( defined(MT6205) || defined(MT6205B) )
         SIM_DMAIni(KAL_TRUE); //Transmit
         DMA2_Init((txaddr+5),SIM_DATA,txSize-5,NULL);
         /*DMA2_Start();*/
      #elif defined(MT6218B)
         sim_menu.source  = (kal_uint32)(txaddr+5);  /*1*/
         sim_menu.destination = SIM_DATA;
         sim_input.type = DMA_HWTX; /*2*/
         sim_input.count = txSize-5;       /*3*/
			if(sim_input.count > SIM_TX_DELAY_LEN && SimCard.Speed > Speed372 
				&& SimCard.is_err)
				txDelay = KAL_TRUE;			
         sim_input.callback = NULL;   /*4*/
      #else /*MT6218, MT6219, MT6217, MT6226, MT6227, MT6228, MT6229*/
         sim_menu.addr = (kal_uint32)(txaddr+5);  /*1*/
         sim_input.type = DMA_HWTX; /*2*/
         sim_input.count = txSize-5;       /*3*/
			if(sim_input.count > SIM_TX_DELAY_LEN && SimCard.Speed > Speed372)
				txDelay = KAL_TRUE;
         sim_input.callback = NULL;   /*4*/
         /*DMA_Config(sim_dmaport, &sim_input, KAL_TRUE);     */
      #endif

      INS |= SIM_INS_INSD;
   }
   else
   {
      SIM_SetTXTIDE(0xffff);
      
      #if ( defined(MT6205) || defined(MT6205B) )
         SIM_DMAIni(KAL_FALSE); //Receive
         DMA2_Init(SIM_DATA,rxaddr,expSize,NULL);
         /*DMA2_Start();*/
      #elif defined(MT6218B)
         sim_menu.source  = SIM_DATA;                 /*1*/
 			sim_menu.destination = (kal_uint32)(rxaddr);
         sim_input.type = DMA_HWRX; /*2*/
         sim_input.count = expSize;       /*3*/
         sim_input.callback = NULL;   /*4*/
      #else /*MT6218, MT6219, MT6217, MT6226, MT6227, MT6228, MT6229*/
         sim_menu.addr = (kal_uint32)(rxaddr);  /*1*/
         sim_input.type = DMA_HWRX; /*2*/
         sim_input.count = expSize;       /*3*/
         sim_input.callback = NULL;   /*4*/
         /*DMA_Config(sim_dmaport, &sim_input, KAL_TRUE);  */
      #endif
   }
   temp = DRV_Reg(SIM_STS);
   DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDDMANormal);
#else /*SIM_ADDDMA*/
#ifdef NoT0CTRL
   for(index=0;index<5;index++)
   {
      DRV_WriteReg(SIM_DATA,*(txData+index));
   }
   SimCard.txindex = 5;
   SimCard.cmdState = SIM_WaitProcByte;
   
   if (expSize == 0) //Transmit
   {
      if (txSize == 5)
      {
         SIM_SetRXTIDE(2);
      }
      else
      {
         SIM_SetRXTIDE(1);
      }
   }
   else
   {
      if ((expSize+3) > 15)
      {
         SIM_SetRXTIDE(CMD_RECBUFSIZE-8);
      }
      else
      {
         SIM_SetRXTIDE(expSize+3);
      }
   }
   temp = DRV_Reg(SIM_STS);
   DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
#else /*NoT0CTRL*/
   if(txSize <= 15)
   {
      for(index=0;index<txSize;index++)
      {
         DRV_WriteReg(SIM_DATA,*(txData+index));
      }
      SimCard.txindex = txSize;
      temp = DRV_Reg(SIM_STS);
      DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
   }
   else
   {
      for(index=0;index<15;index++)
      {
         DRV_WriteReg(SIM_DATA,*(txData+index));
      }
      SimCard.txindex = 15;
      SIM_SetTXTIDE(0);
      temp = DRV_Reg(SIM_STS);
      DRV_WriteReg(SIM_IRQEN,(SIM_IRQEN_CMDNormal|SIM_IRQEN_TX));
   }
  
   if (expSize > 0)
   {
      if (expSize > 15)
      {
         SIM_SetRXTIDE(CMD_RECBUFSIZE);
      }
      else
      {
         SIM_SetRXTIDE(expSize);
      }
      /* maybe changed for 64k rate */
   }
   else
   {
      INS |= SIM_INS_INSD;
   }
#endif /*NoT0CTRL*/
#endif/*SIM_ADDDMA*/

#ifdef SIM_ADDDMA
   #if ( defined(MT6205) || defined(MT6205B) )
      //DMA2_Start();
   #elif defined(MT6218B)
		if(txDelay == KAL_TRUE)
		{
			kal_uint32 i,j;
			
			i = SIM_TX_DELAY_LOOP;
			j = SIM_TX_DELAY_LOOP*10;
			while(j--)
			{
				if(DRV_Reg(SIM_STATUS)&(SIM_STATUS_ACK|SIM_STATUS_NACK))
					break;
			}			
			while(i--);
		}	
      DMA_FullSize_Config(sim_dmaport, &sim_input, KAL_FALSE);
   #else /*MT6218, MT6219, MT6217, MT6226, MT6227, MT6228, MT6229*/
		/* add delay(1ms) between ACK and first transmit data for enhance speed card */
		if(txDelay == KAL_TRUE)
		{
			volatile kal_uint32 t1,t2;
			kal_uint32 loop = SIM_TX_DELAY_LOOP*10;
			
			while(loop--)
			{
				if(DRV_Reg(SIM_STATUS)&(SIM_STATUS_ACK|SIM_STATUS_NACK))
					break;
			}			
			t1 = SIM_GetCurrentTime();
			do{
			t2 = SIM_GetCurrentTime();		
			}while(SIM_GetDurationTick(t1,t2) < 32);
		}	
      DMA_Config(sim_dmaport, &sim_input, KAL_FALSE);
   #endif
#endif   /*SIM_ADDDMA*/

	{
		kal_uint32 savedMask;
		extern void DMA_Run(kal_uint8 channel);
		
		savedMask = SaveAndSetIRQMask();
#ifndef    NoT0CTRL
		SIM_SetCmdINS(INS);
#endif   /*NoT0CTRL*/

#ifdef SIM_ADDDMA
	#if ( defined(MT6205) || defined(MT6205B) )
	DMA2_Start();
	#else	
	DMA_Run(sim_dmaport);	
	#endif
#endif   /*SIM_ADDDMA*/
		RestoreIRQMask(savedMask);
	}

   DRV_Reg(SIM_CONF) |= SIM_CONF_TOUTEN;   
   SIM_WaitEvent(SimCard,CMD_END);

#ifdef SIM_ADDDMA
   #if ( defined(MT6205) || defined(MT6205B) )
      DMA2_Stop();
   #else /*MT6218, MT6218B, MT6219, MT6217, MT6226, MT6227, MT6228, MT6229*/
      DMA_Stop(sim_dmaport);
   #endif
#endif   /*SIM_ADDDMA*/
   
#ifdef NoT0CTRL
   SimCard.initialPower = SimCard.cmdState;
   SimCard.cmdState = SIMD_CmdIdle;
#endif   /*NoT0CTRL*/
   
   if (SimCard.result == SIM_SUCCESS && SimCard.recDataErr == KAL_FALSE)
   {
    #ifdef  SIM_ADDDMA
    if(expSize != 0) 
       *rcvSize = expSize - DRV_Reg(SIM_IMP3);
   //DRVPDN_Enable(DRVPDN_CON0,DRVPDN_CON0_DMA,PDN_DMA);
    #else /*SIM_ADDDMA*/
   *rcvSize = SimCard.recDataLen;
    #endif /*SIM_ADDDMA*/
    
      #ifdef NoT0CTRL
      SW = (SimCard.SW2 | (SimCard.SW1 << 8));
      #else /*NoT0CTRL*/
      SIM_ObtainSW(SW);
      #endif   /*NoT0CTRL*/
      //dbg_print("SW=%x\r\n",SW);
      /*for clock stop mode*/
      if(SimCard.clkStop == KAL_TRUE)
      {
         SIM_DisAllIntr();
         DRV_Reg(SIM_CONF) &= ~SIM_CONF_TOUTEN;
         SIM_SetTOUT(ClkStopTimeTable[SimCard.Speed][1]*TOUT_Factor);
         DRV_Reg(SIM_CONF) |= SIM_CONF_TOUTEN;
         SimCard.cmdState = SIM_StopClk;
         DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_TOUT);
      }
      return SW;
   }
   else
   {
   	kal_sprintf(sim_dbg_str,"[SIM]:SIM_CMD fail status = %d", SimCard.result);
   	kal_print(sim_dbg_str);
      //SimCard.recDataErr = KAL_FALSE;
		SimCard.is_err = KAL_TRUE;
      *Error = KAL_TRUE;
      return 0;
   }
}

/*
* FUNCTION
*	L1sim_Enable_Enhanced_Speed
*
* DESCRIPTION                                                           
*   	The function must call before L1sim_Reset. Otherwise, enhance speed is disable.
*     This function can enable enhance speed mode or not.
*
* CALLS  
*
* PARAMETERS
*	enable: KAL_TRUE: enable enhanced speed. KAL_FALSE: disable it.
*
* RETURNS
*	NULL
*
* GLOBALS AFFECTED
*   external_global
*/
void L1sim_Enable_Enhanced_Speed(kal_bool enable)
{
   PTS_check = enable;
}
/*
* FUNCTION                                                            
*	L1sim_Cmd
*
* DESCRIPTION                                                           
*   	The function is used to implement re-try command mechanism.
*
* 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
*/
sim_card_speed_type L1sim_Get_CardSpeedType(void)
{
   return SimCard.sim_card_speed;
}

/*
* FUNCTION                                                            
*	L1sim_Cmd
*
* DESCRIPTION                                                           
*   	The function is used to implement re-try command mechanism.
*
* 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 L1sim_Cmd(kal_uint8  *txData,kal_uint16  txSize,kal_uint8  *result,kal_uint16  *rcvSize, kal_uint8 *Error)
{
   kal_uint8 index;
   kal_uint16 SW;
   if (SimCard.State != SIM_PROCESSCMD)
   {
      *Error = KAL_TRUE;
      return 0;
   }   
   // while encounter physical errors, deactivate the SIM immediately
   for(index=0;index<3;index++)
   {
   	SimCard.timeout = KAL_FALSE;
      SW = SIM_CMD(txData,txSize,result,rcvSize,Error);
      #if defined(__USIM_DRV__)
		if(SimCard.timeout && SimCard.app_proto == USIM_PROTOCOL)
		{
			L1sim_PowerOff();	
			return SW;
		}
		#endif
      if (*Error == 0)
         break;
   }
   
   if ( ((SW&0xf000) != 0x6000) && ((SW&0xf000) != 0x9000) )
   {
      *Error = KAL_TRUE;
   }
   return SW;
}

#ifdef MT6218B
void SIM_BaudDMA_START(void)
{
   if ( (SimCard.Speed == Speed372) && (INT_ecoVersion() < GN) )
   {
      dma_ch1_start((kal_uint32)baud_data);
   }
}
#endif   /*MT6218B*/
/*
* FUNCTION                                                            
*	L1sim_Init
*
* DESCRIPTION                                                           
*   	The function L1sim_Init initialize the SIM driver.
*
* CALLS  
*
* PARAMETERS
*	None
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void L1sim_Init(void)		//Validate
{
	kal_uint16 tmp;
	SimCard.SIM_ENV = SIM_GetCurrentEnv();
	if (SimCard.SIM_ENV == ME_30V_ONLY)
	{
	   SimCard.Power = SIM_30V;
	}
	else
	{
	   SimCard.Power = SIM_18V;
	}

	SimCard.Data_format = SIM_direct;
	SimCard.State = SIM_WAIT_FOR_ATR;
	SimCard.clkStop = KAL_FALSE;
	SimCard.Speed = Speed372;

#if (defined(MT6218B))
   #ifdef SIM_ADDDMA
      if (sim_dmaport == 0)
      {
         kal_uint16 baud_index;
         if (INT_ecoVersion() < GN)
         {
            for(baud_index=0;baud_index<640;baud_index++)
            {
               if (((baud_index+1)&3)!=0)
                  baud_data[baud_index] = (SIM_BRR_CLK_Div4 | SIM_BRR_BAUD_Div372);
               else
                  baud_data[baud_index] = (SIM_BRR_CLK_Div4 | (0x17<<2));
            }
            dma_ch1_init(SIM_BRR,sizeof(baud_data), 0xb9);
         }
         sim_dmaport = DMA_FullSize_GetChannel(DMA_SIM);         
      }
      
      sim_menu.TMOD.burst_mode = 0;
      sim_menu.master = DMA_SIM;
      sim_menu.source = NULL;      /*1*/
      sim_menu.destination = NULL;
      
      sim_input.type = DMA_HWTX; /*2*/
      sim_input.size = DMA_BYTE;
      sim_input.menu = &sim_menu;
      sim_input.count = 0;       /*3*/
      sim_input.callback = NULL;   /*4*/
   #endif   /*SIM_ADDDMA*/
#elif ( (!defined(MT6205)) && (!defined(MT6205B)) )
   /*MT6218,MT6219,MT6217, MT6226, MT6227, MT6228, MT6229*/
   #ifdef SIM_ADDDMA
      if (sim_dmaport == 0)
         sim_dmaport = DMA_GetChannel(DMA_SIM);
      
      sim_menu.TMOD.burst_mode = 0;
      sim_menu.master = DMA_SIM;
      sim_menu.addr = NULL;  /*1*/
      
      sim_input.type = DMA_HWTX; /*2*/
      sim_input.size = DMA_BYTE;
      sim_input.menu = &sim_menu;
      sim_input.count = 0;       /*3*/
      sim_input.callback = NULL;   /*4*/
   #endif   /*SIM_ADDDMA*/
#endif

	tmp = DRV_Reg(SIM_STS);

	if (SimCard.event == NULL)
	   SimCard.event = kal_create_event_group("SIMEVT");

   DRV_Register_HISR(DRV_SIM_HISR_ID, SIM_HISR);
   IRQ_Register_LISR(IRQ_SIM_CODE, SIM_LISR,"SIM handler");

	IRQSensitivity(IRQ_SIM_CODE,LEVEL_SENSITIVE);
	IRQUnmask(IRQ_SIM_CODE);
}
#endif
//================================ Layer type SIM driver start ==================================
/*************************************************************************
* FUNCTION
*  L1sim_Cmd_Layer
*
* DESCRIPTION
*	Layer type sim driver (transport layer) which maps C-APDU into C-TPDU for T=0
*
* PARAMETERS