simd.c

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

	   PTS_data[index]=0;
		tmp = *(TxBuffaddr+index);
		DRV_WriteReg(SIM_DATA,tmp);
	}

	SimCard.State = SIM_PROCESS_PTS;

	SIM_SetRXTIDE(Txlength);
	DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_Normal);
	
	SIM_WaitEvent(SimCard,PTS_END);
	
	if ((SimCard.recDataErr == KAL_TRUE) 
	   || (SimCard.result == SIM_INIPTSERR))
   {
      SimCard.recDataErr = KAL_FALSE;
      return KAL_FALSE;
   }
   
	for (index = 0; index < Txlength; index++)
	{
		if (PTS_data[index]!=*(TxBuffaddr+index))
		{
			return KAL_FALSE;
		}
	}
	// Some high speed SIM card after clock rate change have to wait a while to
	// to receive the first command.
	if(PTS_data[1] != 0x00)
		kal_sleep_task(10);
	
	return KAL_TRUE;
}

kal_bool SIM_ProcessATRData(void)
{
   kal_uint8 index;
	kal_uint16 tmp,tmp1;
	kal_uint16 SIM_BRR_REG;
	kal_uint8 ptsdata[4];
	kal_uint16 TOUT;
	kal_uint8 Dvalue = 1;

	#if !defined(__USIM_DRV__)
   SIM_WaitEvent(SimCard,ATR_END);
   
   if (SimCard.recDataErr == KAL_TRUE)
   {
      SimCard.recDataErr = KAL_FALSE;
      return KAL_FALSE;
   }
	#else
	kal_mem_cpy(SimCard.recData, usim_dcb.ATR_data+1, usim_dcb.ATR_index-1);
   #endif
   
   index = 1;
   if (SimCard.recData[0] & 0x00f0)
   {
      if (SimCard.recData[0] & TAMask)
      {
         tmp = SimCard.recData[index]; //TA1
         index++;
         ////dbg_print("TA1 = %x\r\n",tmp);
         if ((tmp == 0x0011)||(tmp == 0x0001))
         {
            //Don't process ATR data!!
            SimCard.State = SIM_PROCESSCMD;
            SIMCmdInit();
            #ifdef NoT0CTRL
	         SimCard.cmdState = SIMD_CmdIdle;
	         #endif
	         TOUTValue = SIM_CMD_TOUT_VALUE;
            SIM_SetTOUT(TOUTValue);
	         return KAL_TRUE;
         }
         else
         {
            switch (tmp)
            {
               case 0x0094:		//F = 512,D=8
                  SimCard.sim_card_speed = sim_card_enhance_speed_64;
#if 1
                  if (!PTS_check)
#else
/* under construction !*/
#endif
                  {
                     Dvalue = 1;
                     ptsdata[0]=0xff;
					   	ptsdata[1]=0x00;
					   	ptsdata[2]=0xff;
					   	if (!SIM_PTSProcess(ptsdata,3))
					   	{
					   	   return KAL_FALSE;
					   	}
					   	TOUTValue = SIM_CMD_TOUT_VALUE;
						   SIM_SetTOUT(TOUTValue);
				      }
                  else
                  {
#ifdef MT6218B
                     kal_uint32 savedMask;
#endif   /*MT6218B*/
					   	Dvalue = 8;
					   	ptsdata[0]=0xff;
					   	ptsdata[1]=0x10;
					   	ptsdata[2]=0x94;
					   	ptsdata[3]=0x7b;
					   	SimCard.Speed = Speed64;
					   	
					   	if (!SIM_PTSProcess(ptsdata,4))
					   	{
					   	   return KAL_FALSE;
					   	}
#ifdef MT6218B
                     if (INT_ecoVersion() < GN)
                     {
					   	   savedMask = SaveAndSetIRQMask();
					   	   dma_ch1_stop();
					   	   RestoreIRQMask(savedMask);
					      }
#endif   /*MT6218B*/
					   	SIM_BRR_REG = DRV_Reg(SIM_BRR);
					   	SIM_BRR_REG &= SIM_BRR_CLKMSK;
					   	SIM_BRR_REG |= SIM_BRR_BAUD_Div64;
					   	DRV_Reg(SIM_BRR) = SIM_BRR_REG;
					   	TOUT_Factor = 8;  //hw-specific
					   	TOUTValue = TOUT_Factor*SIM_CMD_TOUT_VALUE;
					   	SIM_SetTOUT(TOUTValue);
                  }
        				break;
        					
        			case 0x0095:		//F=512,D=16
        			   SimCard.sim_card_speed = sim_card_enhance_speed_32;
#if !defined(MT6205B)
                  if (!PTS_check)
#else
                  if (1)
#endif
                  {
        				   Dvalue = 1;
	        			   ptsdata[0]=0xff;
					      ptsdata[1]=0x00;
					      ptsdata[2]=0xff;
					      if (!SIM_PTSProcess(ptsdata,3))
						   {
						      return KAL_FALSE;
						   }
						   TOUTValue = SIM_CMD_TOUT_VALUE;
						   SIM_SetTOUT(TOUTValue);
						}
                  else
                  {
#ifdef MT6218B
                     kal_uint32 savedMask;
#endif   /*MT6218B*/
        				   Dvalue = 16;
        				   ptsdata[0]=0xff;
					      ptsdata[1]=0x10;
					      ptsdata[2]=0x95;
					      ptsdata[3]=0x7a;
					      SimCard.Speed = Speed32;
					      
					      if (!SIM_PTSProcess(ptsdata,4))
						   {
						      return KAL_FALSE;
						   }
#ifdef MT6218B
                     if (INT_ecoVersion() < GN)
                     {
					   	   savedMask = SaveAndSetIRQMask();
					   	   dma_ch1_stop();
					   	   RestoreIRQMask(savedMask);
					      }
#endif   /*MT6218B*/
						   SIM_BRR_REG = DRV_Reg(SIM_BRR);
					      SIM_BRR_REG &= SIM_BRR_CLKMSK;
					      SIM_BRR_REG |= SIM_BRR_BAUD_Div32;
					      DRV_Reg(SIM_BRR) = SIM_BRR_REG;
						   TOUT_Factor = 16;
					      TOUTValue = TOUT_Factor*SIM_CMD_TOUT_VALUE;
					      SIM_SetTOUT(TOUTValue);
                  }
        				break;
        			
	        		default:		//F=372,D=1
	        			Dvalue = 1;
	        			ptsdata[0]=0xff;
					   ptsdata[1]=0x00;
					   ptsdata[2]=0xff;
					   if (!SIM_PTSProcess(ptsdata,3))
						{
						   return KAL_FALSE;
						}
						TOUTValue = SIM_CMD_TOUT_VALUE;
						SIM_SetTOUT(TOUTValue);
        				break;
        		}
         }
      }  /*if (SimCard.recData[0] & TAMask)*/
        		
      if (SimCard.recData[0] & TBMask)
      {
         tmp = SimCard.recData[index];
         ////dbg_print("TB1 = %x\r\n",tmp);
         index++;
      }
      if (SimCard.recData[0] & TCMask)
      {
         tmp = SimCard.recData[index];
         ////dbg_print("TC1 = %x\r\n",tmp);
         if (tmp != 0xff && tmp != 0x00)
        	{
            return KAL_FALSE;
         }
        	index++;
      }
      
      if (SimCard.recData[0] & TDMask)
      {
         tmp = SimCard.recData[index];	///TD1
         index++;
         ////dbg_print("TD1 = %x\r\n",tmp);
         if (tmp & TCMask)	//TC2 is obtain
        	{
            if (tmp & TAMask)
            {
               tmp1 = SimCard.recData[index];
               ////dbg_print("TA2 = %x\r\n",tmp1);
               index++;
            }
				if (tmp & TBMask)	
        		{
        			tmp1 = SimCard.recData[index];
        			////dbg_print("TB2 = %x\r\n",tmp1);
        			index++;
        		}
        		if (tmp & TCMask)	//TC2
        		{
        		   tmp1 = SimCard.recData[index];
               ////dbg_print("TC2 = %x\r\n",tmp1);
               TOUT = (kal_uint16)(960*Dvalue);
               TOUT = (TOUT*tmp1)/4;   /*(/4)is hw-specific*/
               index++;
               TOUTValue = TOUT+8;
               //////dbg_print("TOUT = %x\r\n",TOUT);
               DRV_WriteReg(SIM_TOUT,TOUT);
        		}        			
         }
      }  /*if (SimCard.recData[0] & TDMask)*/
   }/*if (SimCard.recData[0] & 0x00f0)*/
	SimCard.State = SIM_PROCESSCMD;
	SIMCmdInit();
	#ifdef NoT0CTRL
	SimCard.cmdState = SIMD_CmdIdle;
	#endif   /*NoT0CTRL*/
	return KAL_TRUE;
}

void SIM_Cmdhandler(void)
{
#ifndef SIM_ADDDMA
   while(SIM_FIFO_GetLev())
   {
      *(SimCard.rxbuffer+SimCard.recDataLen) = (kal_uint8)DRV_Reg(SIM_DATA);
      SimCard.recDataLen++;
   }
#endif /*SIM_ADDDMA*/
   SIM_SetEvent(SimCard,SIM_SUCCESS);
   return;
}

#ifndef SIM_ADDDMA
void SIM_Txhandler(void)
{
#ifdef NoT0CTRL
   kal_uint8 index;
   kal_uint16 reslen;
   reslen = SimCard.txsize - SimCard.txindex;
   if(reslen <= 15)
   {
      for(index=0;index<reslen;index++)
      {
         DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
         SimCard.txindex++;
      }
      SIM_SetRXTIDE(2);
      SimCard.cmdState = SIM_WaitProcByte;
      DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
   }
   else
   {
      for(index=0;index<15;index++)
      {
         DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
         SimCard.txindex++;
      }
      SIM_SetTXTIDE(0);
      DRV_WriteReg(SIM_IRQEN,(SIM_IRQEN_CMDNormal|SIM_IRQEN_TX));
   }
   return;
#else   /*NoT0CTRL*/
   kal_uint8 index;
   kal_uint16 reslen;
   
   reslen = SimCard.txsize - SimCard.txindex;
   if(reslen <= 15)
   {
      for(index=0;index<reslen;index++)
      {
         DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
         SimCard.txindex++;
      }
      DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
   }
   else
   {
      for(index=0;index<15;index++)
      {
         DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
         SimCard.txindex++;
      }
      SIM_SetTXTIDE(0);
      DRV_WriteReg(SIM_IRQEN,(SIM_IRQEN_CMDNormal|SIM_IRQEN_TX));
   }
#endif   /*NoT0CTRL*/
}
#endif   /*SIM_ADDDMA*/

void SIM_Rxhandler(kal_uint16 sim_int)
{
   kal_uint16 TS;
   kal_uint8  index;
   
   if (SimCard.State == SIM_WAIT_FOR_ATR)
	{
		TS = DRV_Reg(SIM_DATA);
		
		if ((TS == 0x003f) || (TS == 0x003b))
		{
			SimCard.State = SIM_PROCESS_ATR;

			DRV_Reg(SIM_CONF) |= 
			         (SIM_CONF_TXHSK | SIM_CONF_RXHSK |SIM_CONF_TOUTEN);

			/* *(volatile kal_uint16 *)SIM_CONF |= SIM_CONF_TOUTEN; */
			SIM_SetRXTIDE(12);
			SIM_SetRXRetry(7);
			SIM_SetTXRetry(7);
         SimCard.recDataLen = 0;
         
			SIM_SetEvent(SimCard,SIM_SUCCESS);
			SimCard.EvtFlag = ATR_END;
			DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_Normal);
		}
		else
		{	
			reset_index++;	//Change format!!, don't change power
			if (reset_index>1)
			{
				reset_index = 0;
				SIM_SetEvent(SimCard,SIM_CARDERR);
			}
			else
			{
				if (SimCard.Data_format == SIM_indirect)
				{
					SimCard.Data_format = SIM_direct;
					SIM_L1Reset();
				}
				else
				{
					SimCard.Data_format = SIM_indirect;
					SIM_L1Reset();
				}
			}
		}
		return;	
	}
	
	if (SimCard.State == SIM_PROCESS_ATR)
	{
	   while(1)
      {
         if (SIM_FIFO_GetLev())
         {
            SimCard.recData[SimCard.recDataLen] = (kal_uint8)DRV_Reg(SIM_DATA);
            SimCard.recDataLen++;
         }
         else
         {
            if (sim_int & SIM_STS_TOUT)
            {
               SIM_SetEvent(SimCard,SIM_SUCCESS);
            }
            break;
		   }
      }
      return;
	}
	
	if (SimCard.State == SIM_PROCESS_PTS)
	{
		index = 0;
		while(KAL_TRUE)
		{
			PTS_data[index] = (kal_uint8)DRV_Reg(SIM_DATA);
			index++;
			
			if (SIM_FIFO_GetLev()==0)
			{
				SIM_SetEvent(SimCard,SIM_SUCCESS);
				break;
			}
		}
		SIM_DisAllIntr();
		return;
	}
	
	if (SimCard.State == SIM_PROCESSCMD)
	{
#ifdef SIM_ADDDMA
	   ////dbg_print("something error\r\n");
#else /*SIM_ADDDMA*/
#ifdef NoT0CTRL
{
   kal_uint16 ACK;
   while(SIM_FIFO_GetLev())
   {
      if (SimCard.cmdState == SIM_WaitProcByte)
      {
         ACK = DRV_Reg(SIM_DATA);
         if ((ACK == SimCard.INS) || (ACK == (SimCard.INS+1)))    //ACK
         {
            if (SimCard.txsize != 5)
            {
               /*Trx command*/
               DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
               SimCard.txindex++;
               SIM_SetTXTIDE(0);
               DRV_WriteReg(SIM_IRQEN,(SIM_IRQEN_CMDNormal | SIM_IRQEN_TX));
               SimCard.cmdState = SIM_AckDataState;
               return;
            }
            else
            {
               SIM_SetTXTIDE(0xffff);
               DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
               SimCard.cmdState = SIM_AckDataState;
               continue;
            }
         }
         
         if ((ACK == (~SimCard.INS & 0x00ff)) || (ACK == (~(SimCard.INS+1)& 0x00ff)))    ///NACK
         {
            if (SimCard.txsize != 5)
            {
               DRV_WriteReg(SIM_DATA,*(SimCard.txbuffer+SimCard.txindex));
               SimCard.txindex++;
               SIM_SetRXTIDE(1);
               SimCard.cmdState = SIM_WaitProcByte;
               /*Trx command*/
               DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
               return;
            }
            else
            {
               SIM_SetTXTIDE(0xffff);
               SimCard.cmdState = SIM_NAckDataState;
               DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
            }
            continue;
         }
         
         if (ACK == 0x60)    //ACK
         {
            continue;
         }
         if (SIM_CheckSW(ACK))    //ACK
         {
            SimCard.SW1 = (kal_uint8)ACK;
            SIM_SetRXTIDE(1);
            SimCard.recDataLen++;
            SimCard.cmdState = SIM_WaitSWByte;
            continue;
         }
      }
      
      if (SimCard.cmdState == SIM_WaitSWByte)
      {
         SimCard.SW2 = (kal_uint8)DRV_Reg(SIM_DATA);
         /*SimCard.recDataLen++;*/
         SimCard.recDataLen--;
         SIM_SetEvent(SimCard,SIM_SUCCESS);
         return;
      }
      
      if (SimCard.cmdState == SIM_AckDataState)
      {
         *(SimCard.rxbuffer+SimCard.recDataLen) = (kal_uint8)DRV_Reg(SIM_DATA);
         SimCard.recDataLen++;
         if (SimCard.recsize == SimCard.recDataLen)
         {
            SimCard.cmdState = SIM_WaitProcByte;
         }
         continue;
      }
      
      if (SimCard.cmdState == SIM_NAckDataState)
      {
         *(SimCard.rxbuffer+SimCard.recDataLen) = (kal_uint8)DRV_Reg(SIM_DATA);
         SimCard.recDataLen++;
         SimCard.cmdState = SIM_WaitProcByte;
         continue;
      }
   }  /*while(SIM_FIFO_GetLev())*/
   if (SimCard.txsize == 5)
   {
      if ((SimCard.recsize+2 - SimCard.recDataLen) > 15)
      {
         SIM_SetRXTIDE(CMD_RECBUFSIZE-8);
      }
      else
      {
         SIM_SetRXTIDE(SimCard.recsize+2 - SimCard.recDataLen);
      }

      DRV_WriteReg(SIM_IRQEN,SIM_IRQEN_CMDNormal);
   }
}
#else /*NoT0CTRL*/
	   while(SIM_FIFO_GetLev())
      {
         *(SimCard.rxbuffer+SimCard.recDataLen) = (kal_uint8)DRV_Reg(SIM_DATA);
         SimCard.recDataLen++;
      }
#endif /*NoT0CTRL*/
#endif /*SIM_ADDDMA*/
		return;
	}
}