fc-tourmaline: src/cs/drivers/drv_app/sim/sim.c comparison

comparison src/cs/drivers/drv_app/sim/sim.c @ 191:c1205c437943

../drv_app/sim/sim.c: white space fixes

author	Mychaela Falconia <falcon@freecalypso.org>
date	Sat, 30 Jan 2021 07:34:00 +0000
parents	b37e6c916df1
children

comparison

equal deleted inserted replaced

-:2e4afc93045d
+:c1205c437943
 //current voltage mode 3V or 5V, or 1.8V
 SYS_UWORD8            CurrentVolt;
 /* FreeCalypso addition */
 SYS_UWORD8 SIM_allow_speed_enhancement = 1;
 #ifdef SIM_DEBUG_TRACE
 #ifdef SIM_RETRY
 /* Add variables to support sim retry */
 SYS_UWORD8 SimRetries;
 #endif
 /*
 * Low level routines  : mapped to hardware
 *    SIM_WriteBuffer
 *    SIM_Command
 *    SIM_Reset
 *
 */
 /*
 * SIM_WriteBuffer
 *
 return (SIM_ERR_XMIT);
 len = p->rx_index;
 *lenP = len - offset;
 if ((*lenP == 0) && (p->apdu_ans_length == 256))
-		*lenP = 256;
+	*lenP = 256;
 if (p->expected_data == 256)
 {
 verdict = SIM_Memcpy(rP, ((p->rbuf) + offset), 256 - offset);
 if (verdict != 0)
 return((sw1 << 8) | sw2);
 }
 /*
 * SIM_Command_base
 *
 * Perform a command with the SIM T=0 protocol
 *
 * Returns an error code :
 *             SIM_ERR_READ : no answer from the card to a command
 *             SIM_ERR_LEN  : the answer is not corresponding to a
 *                            correct answer of T=0 protocol
 * 06/11/2002	JYT
-*		Modified to be base command function. New SIM_Command() created to call it
+*  Modified to be base command function. New SIM_Command() created to call it
-* 		with wrapper. Created to manage retries on Internals errors of the driver.
+*  with wrapper. Created to manage retries on Internals errors of the driver.
 */
 SYS_UWORD16 SIM_Command_Base(SIM_PORT *p, SYS_UWORD16 n, SYS_UWORD8 *dP, SYS_UWORD16 *lP)
 {
 SYS_UWORD16  res;
 }
 }
 res = SIM_Result(p, dP, lP, 0);
 if ((SIM_sleep_status == SIM_SLEEP_DESACT) || (SIM_sleep_status == SIM_SLEEP_ACT))
 {   //enable to count 2.5s before entering in sleep mode
 status_os_sim = NU_Reset_Timer (&SIM_timer, SIM_SleepMode_In,
 SIM_SLEEP_WAITING_TIME,
 0, NU_ENABLE_TIMER);
 }
 return(res);
 }
 /* Main function to manage the retry mechanism */
-SYS_UWORD16 SIM_Command(SIM_PORT *p, SYS_UWORD16 n, SYS_UWORD8 *dP, SYS_UWORD16 *lP) {
+SYS_UWORD16 SIM_Command(SIM_PORT *p, SYS_UWORD16 n, SYS_UWORD8 *dP, SYS_UWORD16 *lP)
-	int res;
+{
+int res;
 #ifdef SIM_DEBUG_TRACE
-	memset(SIM_dbg_null, 0x00, SIM_DBG_NULL);
+memset(SIM_dbg_null, 0x00, SIM_DBG_NULL);
-	SIM_dbg_tdma_diff = 0;
+SIM_dbg_tdma_diff = 0;
 #endif
-	// Issue initial SIM_Command() call
+// Issue initial SIM_Command() call
 res = SIM_Command_Base(p, n, dP, lP);
 /* Change from to 10 to 15 for specific SIM card (Racal) */
 #ifdef SIM_RETRY
 // While there is an error then retry NUM_SIM_RETRIES times
-	while ((res & 0xFF00) == 0)	{	// Reissue command
+while ((res & 0xFF00) == 0)	{	// Reissue command
-		p->errorSIM = 0;
+	p->errorSIM = 0;
-		if(++SimRetries > NUM_SIM_RETRIES) {	// return special retry failure
+	if(++SimRetries > NUM_SIM_RETRIES) {	// return special retry failure
-		   	res = SIM_ERR_RETRY_FAILURE;
+		res = SIM_ERR_RETRY_FAILURE;
-		   	break;
+		break;
-		}
-	    res = SIM_Command_Base(p, n, dP, lP);
 	}
+	res = SIM_Command_Base(p, n, dP, lP);
+}
 #ifdef SIM_DEBUG_TRACE
-	SIM_dbg_null[SIM_DBG_NULL-1] = SimRetries;
+SIM_dbg_null[SIM_DBG_NULL-1] = SimRetries;
 #endif
-	SimRetries = 0;
+SimRetries = 0;
 #endif
 return(res);
 }
 /*
 * SIM_ByteReverse
 *
 SYS_UWORD8 SIM_ByteReverse(SYS_UWORD8 b)
 {
 SYS_UWORD8 bh, bl;
 int i;
 const SYS_UWORD8 Reverse[] = {0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF };
 // Up/Down
 b = ~ b;
 // left / right (by nibble)
 bh = (b >> 4) & 0xF;
 bl = b & 0xF;
 b = (Reverse[bl]) << 4 | Reverse[bh];
 return(b);
 }
 /*
 * SIM_TxParityErrors
 *
 */
 SYS_UWORD16 SIM_TxParityErrors(void)
 {
 SIM_PORT *p;
-p= &(Sim[0]);
+p = &(Sim[0]);
 return(p->txParityErr);
 }
 {
 	return(SIM_Reset_Restart_Internal(cP, 1));
 }
 /*
 * SIM_Restart
 *
 * Restart SIM card
 *
 unsigned int    ATR_Attempt;
 SYS_UWORD8      BackValue;
 SYS_UWORD8      Result_ATR;
 #ifdef SIM_DEBUG_TRACE
-	memset(SIM_dbg_null, 0x00, SIM_DBG_NULL);
+memset(SIM_dbg_null, 0x00, SIM_DBG_NULL);
-	SIM_dbg_cmd_cmpt = 0;
+SIM_dbg_cmd_cmpt = 0;
-	memset(SIM_dbg_cmd, 0x00, SIM_DBG_CMD);
+memset(SIM_dbg_cmd, 0x00, SIM_DBG_CMD);
 #endif
 // Initialize pointers
 p = &(Sim[0]);
 return (SIM_ERR_NOCARD);
 }
 // ATR received but wrong characters value
 // Comply with Test 27.11.2.4.5 and Test 27.11.1.3
 else if (BackValue == SIM_ERR_CARDREJECT)
+{
+if (ATR_Attempt >= 3)
 {
-if (ATR_Attempt >= 3)
-{
 SIM_PowerOff ();
 return ((SYS_UWORD16)BackValue);
 }
 ATR_Attempt++;
 SIM_WARMReset(p);    // assert a reset during at least 400 ETU
 }
 else if (BackValue != 0) //SIM_ERR_WAIT
 {
 if (ATR_Attempt == 3)
 {    // switch to 5V (ANALOG1) or 3V (ANALOG2) if card send wrong ATR 3 consecutive times
 // Apply 3 consecutive resets at 5V (ANALOG1) or 3V (ANALOG2)
 // fix prb for old chinese card not GSM compliant
 }
 status_os_sim = NU_Control_Timer (&SIM_timer,  NU_ENABLE_TIMER);
 //enable starting of the os timer for sleep mode
 if (ResetFlag) {
 if (p->InsertFunc != NULL)
 (p->InsertFunc)(cP);
-	}
+}
 return(0);
 }
 /* SIM manual start
 *
 *  purpose : manage manual start of the SIM interface
 // Unmask interrupt controller
 IQ_Unmask (IQ_SIM);
 p->c->cmd = (p->c->cmd & MASK_CMD) | SIM_CMD_STOP;
-ind_os_sleep (4);                           //wait 5 TDMA due to SVCC falling down duration
+ind_os_sleep (4);           //wait 5 TDMA due to SVCC falling down duration
 p->c->cmd = (p->c->cmd & MASK_CMD) | SIM_CMD_SWRST;
-ind_os_sleep (1);                           //wait 5 TDMA due to SVCC falling down duration
+ind_os_sleep (1);           //wait 5 TDMA due to SVCC falling down duration
 p->c->conf2  = 0x0940;
 i = p->c->it;
 {
 SIM_PORT *p;
 volatile SYS_UWORD16 cmd;
 // Initialize pointers
 p = &(Sim[0]);
 // Reset and wait a while
 */
 SYS_UWORD16 SIM_Status_Extended(SYS_UWORD8 *dat, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_STATUS;
 */
 SYS_UWORD16 SIM_ReadBinary(SYS_UWORD8 *dat, SYS_UWORD16 offset, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_READ_BINARY;
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_VerifyChv
 #endif
 if(p->Freq_Algo)
 p->c->conf1 = p->conf1 |= SIM_CONF1_SCLKDIV;
 return(res);
 }
 /*
 */
 SYS_UWORD16 SIM_GetResponse(SYS_UWORD8 *dat, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_GET_RESPONSE;
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_EnableCHV
 return(res);
 }
 /*
 * SIM_UnblockCHV
 *
 * Unblock the specified CHV (chvType) and store a new CHV
 */
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_Invalidate
 *
 * Invalidate the current EF
 */
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_Rehabilitate
 *
 * Rehabilitate the current EF
 */
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_UpdateBinary
 SYS_UWORD16 SIM_UpdateBinary(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD16 offset, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_UPDATE_BINARY;
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * SIM_ReadRecord
 */
 SYS_UWORD16 SIM_ReadRecord(SYS_UWORD8 *dat, SYS_UWORD8 mode, SYS_UWORD8 recNum, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_READ_RECORD;
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 #ifdef SIM_APDU_TEST
 SYS_UWORD8 snd[270];
 SYS_UWORD8 rec[270];
 SYS_UWORD16 SIM_UpdateRecord(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD8 mode, SYS_UWORD8 recNum, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 #ifdef SIM_SAT_REFRESH_TEST
 // do 1000 times the following sequence
 for (i=0;i<1000;i++) {
 SIM_PowerOff();
 		snd[1] = 0xB0;
 		snd[2] = 0x00;
 		snd[3] = 0x00;
 		snd[4] = 0x00;
 		rescmd = SIM_XchTPDU(&snd[0], 5, &rec[0], 256, &recl);
 	}
+#endif
-#endif
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_UPDATE_RECORD;
 	SIM_dbg_tmp[0] = (SYS_UWORD8)(SIM_dbg_tdma_diff >> 8);
 	SIM_dbg_tmp[1] = (SYS_UWORD8)(SIM_dbg_tdma_diff);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 #ifdef SIM_APDU_TEST
 	// send CLOSE LOGICAL CHANNEL
 	snd[0] = 0x00;
 	snd[1] = 0x70;
 	snd[2] = 0x80;
 	snd[3] = logchan;
 	snd[4] = 0x00;
 	resclose = SIM_XchTPDU(&snd[0], 5, &rec[0], 0, &recl);
 #endif
 return(res);
 }
 SYS_UWORD16 SIM_Seek(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD8 mode, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_SEEK;
 SYS_UWORD16 SIM_TerminalProfile(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_TERMINAL_PROFILE;
 SYS_UWORD16 SIM_Fetch(SYS_UWORD8 *result, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_FETCH;
 p->xbuf[2] = 0;
 p->xbuf[3] = 0;
 p->xbuf[4] = (SYS_UWORD8)llen;
 res = SIM_Command(p, 0, result, rcvSize);
 #ifdef SIM_DEBUG_TRACE
 	SIM_dbg_write_trace((SYS_UWORD8 *)"ATCMD", 5);
 SYS_UWORD16 SIM_TerminalResponse(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_TERMINAL_RESPONSE;
 /*
 * SIM_Envelope
 *
-* Used by Network to tansfert data download to the SIM in a transparent way for user
+* Used by Network to transfer data download to the SIM in a transparent way for user
 */
 SYS_UWORD16 SIM_Envelope(SYS_UWORD8 *result, SYS_UWORD8 *dat, SYS_UWORD16 len, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT    *p;
 int         i;
 int         res;
-	SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
+SYS_UWORD16 llen = len & SIM_UWORD16_MASK;
 p = &(Sim[0]);
 p->xbuf[0] = GSM_CLASS;
 p->xbuf[1] = SIM_ENVELOPE;
 return(res);
 }
 /*
 * SIM_XchTPDU *
 * Used for ME to send generic command to WIM Card
 */
 SYS_UWORD16 SIM_XchTPDU(SYS_UWORD8 *dat, SYS_UWORD16 trxLen, SYS_UWORD8 *result,
-						SYS_UWORD16 rcvLen, SYS_UWORD16 *rcvSize)
+			SYS_UWORD16 rcvLen, SYS_UWORD16 *rcvSize)
 {
 SIM_PORT *p;
 int i;
 int res;
 for (i=5;i<trxLen;i++)
 {
 p->xbuf[i] = dat[i];
 }
-	// enable the WIM behavior of the sim driver
+// enable the WIM behavior of the sim driver
-	p->apdu_ans_length = rcvLen;
+p->apdu_ans_length = rcvLen;
 res = SIM_Command(p, (trxLen - 5), result, rcvSize);
-	// disable the WIM behavior of the sim driver
+// disable the WIM behavior of the sim driver
-	p->apdu_ans_length = 0;
+p->apdu_ans_length = 0;
 #ifdef SIM_DEBUG_TRACE
 	SIM_dbg_write_trace((SYS_UWORD8 *)"AWCMD", 5);
 	SIM_dbg_write_trace(p->xbuf, trxLen);
 	SIM_dbg_write_trace((SYS_UWORD8 *)"AWANS", 5);
 	SIM_dbg_write_trace(SIM_dbg_tmp, 2);
 #endif
 return(res);
 }
 /*
 * Use to detect end of characters reception
 * input:    p       pointer on sim structure
 */
 SYS_UWORD16 SIM_WaitReception(SIM_PORT *p)
 {
 SYS_UWORD16 returncode;
 //analyse the nature of the command to execute
 if (
 	(p->xbuf[1] == 0x12) ||
 }
 return (0);
 }
 /*
 * Use to read file characteristics information
 * input:    p       pointer on sim structure
 *
 * output:   return 0 if sucess
 {
 p->Freq_Algo = 1;
 }
 //interpret Clock stop behavior
-	// modified by J. Yp-Tcha to integrate all the behaviors required by ETSI.
+// modified by J. Yp-Tcha to integrate all the behaviors required by ETSI.
-	// 18/11/2002 : TI Chip always allowed low level, high level is hard dependant
+// 18/11/2002 : TI Chip always allowed low level, high level is hard dependant
-	if ((p->FileC & SIM_CLK_STOP_MASK) == SIM_CLK_STOP_NOT_ALLWD) {
+if ((p->FileC & SIM_CLK_STOP_MASK) == SIM_CLK_STOP_NOT_ALLWD) {
-		/* Sim Clock Stop Not Allowed */
+	/* Sim Clock Stop Not Allowed */
+	SIM_sleep_status = SIM_SLEEP_NOT_ALLOWED;
+	/* There is not need to modifiy p->conf1 */
+status_os_sim = NU_Delete_Timer (&SIM_timer);
+}
+else {
+	if ((p->FileC & SIM_CLK_STOP_MASK) == SIM_CLK_STOP_ALLWD) {
+	    /* Sim Clock Stop Allowed, no prefered level */
+	    /* Default value for TI Chip shall always be Low Level */
+	    SIM_sleep_status = SIM_SLEEP_DESACT;
+	    p->c->conf1 = p->conf1 &= ~SIM_CONF1_SCLKLEV;
+	}
+	else {
+	    /* Clock Stop is allowed, the level shall be checked */
+	    if ((p->FileC & SIM_CLK_STOP_HIGH) == SIM_CLK_STOP_HIGH) {
+		/* high level is mandatory */
+/* OMEGA/NAUSICA can not handle sim stop clock at high level */
+#ifndef ANALOG1
+	        SIM_sleep_status = SIM_SLEEP_DESACT;
+p->c->conf1 = p->conf1 |= SIM_CONF1_SCLKLEV;
+#else
+		/* Sim Clock Stop Not Allowed because the interface do not support this level */
 		SIM_sleep_status = SIM_SLEEP_NOT_ALLOWED;
 		/* There is not need to modifiy p->conf1 */
-status_os_sim = NU_Delete_Timer (&SIM_timer);
+	        status_os_sim = NU_Delete_Timer (&SIM_timer);
+#endif
+	    }
+	    else {
+		/* by default, Low Level is allowed */
+SIM_sleep_status = SIM_SLEEP_DESACT;
+	        p->c->conf1 = p->conf1 &= ~SIM_CONF1_SCLKLEV;
+	    }
 	}
-	else {
+}
-		if ((p->FileC & SIM_CLK_STOP_MASK) == SIM_CLK_STOP_ALLWD) {
-			/* Sim Clock Stop Allowed, no prefered level */
-			/* Default value for TI Chip shall always be Low Level */
-	        SIM_sleep_status = SIM_SLEEP_DESACT;
-		    p->c->conf1 = p->conf1 &= ~SIM_CONF1_SCLKLEV;
-		}
-		else {
-			/* Clock Stop is allowed, the level shall be checked */
-			if ((p->FileC & SIM_CLK_STOP_HIGH) == SIM_CLK_STOP_HIGH) {
-				/* high level is mandatory */
-/* OMEGA/NAUSICA can not handle sim stop clock at high level */
-#ifndef ANALOG1
-	            SIM_sleep_status = SIM_SLEEP_DESACT;
-	        p->c->conf1 = p->conf1 |= SIM_CONF1_SCLKLEV;
-#else
-				/* Sim Clock Stop Not Allowed because the interface do not support this level */
-				SIM_sleep_status = SIM_SLEEP_NOT_ALLOWED;
-				/* There is not need to modifiy p->conf1 */
-		        status_os_sim = NU_Delete_Timer (&SIM_timer);
-#endif
-			}
-			else {
-				/* by default, Low Level is allowed */
-	            SIM_sleep_status = SIM_SLEEP_DESACT;
-	            p->c->conf1 = p->conf1 &= ~SIM_CONF1_SCLKLEV;
-			}
-		}
-	}
 if (SIM_sleep_status == SIM_SLEEP_NONE)
 {
 status_os_sim = NU_Delete_Timer (&SIM_timer);
 }
 }
 */
 SYS_UWORD16 SIM_PTSprocedure(SIM_CARD *cP, SIM_PORT *p)
 {
 SYS_UWORD8            TA1;
 SYS_UWORD8            n;
 SYS_UWORD8            err;
-p->xbuf[0]       = 0xFF;                        //character of PTS proc to send
+p->xbuf[0]       = 0xFF;                   //character of PTS proc to send
 p->xbuf[1]       = 0;
 p->xbuf[2]       = 0xFF;
 p->xbuf[3]       = 0x7B;
 //TA1,TB1,TC1,TD1 present in ATR ?
-n   = 3;
+n = 3;
 p->PTS_Try++;
 if (p->PTS_Try > 4)
 {
 return (SIM_ERR_CARDREJECT);
 }                       // at the fourth attempt, PTS procedure is unusefull. Use default value.
 //TA1 present?  Test 27.11.2.6
-else if ( p->PTS_Try == 4)
+else if (p->PTS_Try == 4)
 {
 SIM_Calcetu (p);
 return (0);
 }
-if(cP->AtrData[1] & 0x10)
+if (cP->AtrData[1] & 0x10)
 {
 TA1 = cP->AtrData[2];
 }
 else                    //if TA1 not present, return
 {
 {
 return (err);
 }
 //should received same chars as PTS request
 if ((p->rbuf[0] != p->xbuf[0]) || (p->rbuf[1] != p->xbuf[1]) ||
 (p->rbuf[2] != p->xbuf[2]))
 {
 return(SIM_ERR_READ);
 }
 if (n == 4)
 {
 if (p->rbuf[3] != p->xbuf[3])
 {
 p->c->conf1 = p->conf1 |= SIM_CONF1_ETU; //set F=512 D=8
 }
 SIM_Calcetu (p);
 return (0);
 }
 /*
 * procedure of WARM reset consists on asserting
 * reset signal at 0 during at least 400 ETU
 * input     p pointer of type SIM_PORT
 */
 void SIM_WARMReset (SIM_PORT *p)
 {
 p->c->conf1 = p->conf1 &= ~SIM_CONF1_SRSTLEV;
 ind_os_sleep (p->etu400);  /// wait 400 ETU
 p->c->conf1 = p->conf1 |= SIM_CONF1_SRSTLEV;
 p->rx_index = 0;
 }
 /*
 * procedure use to get out sleepMode
 (&(Sim[0]))->c->conf1 &= ~SIM_CONF1_SCLKEN;  //disabled the clock for the SIM card
 SIM_sleep_status = SIM_SLEEP_ACT;
 }
 status_os_sim = NU_Control_Timer (&SIM_timer,  NU_DISABLE_TIMER);
 }
 /*
 * procedure use to get out sleepMode
 * input     p pointer of type SIM_PORT
 */
 SYS_UWORD16 SIM_ATRdynamictreatement (SIM_PORT *p, SIM_CARD *cP)
 {
+volatile SYS_UWORD8  HistChar;
-volatile SYS_UWORD8   HistChar;
+volatile SYS_UWORD8  InterfChar;
-volatile SYS_UWORD8   InterfChar;
 SYS_UWORD16          countT;
 SYS_UWORD16          mask;
 SYS_UWORD16          returncode;
-SYS_UWORD8            i;
+SYS_UWORD8           i;
-SYS_UWORD8            firstprotocol;
+SYS_UWORD8           firstprotocol;
-SYS_UWORD8            Tx,T;
+SYS_UWORD8           Tx,T;
-SYS_UWORD8            TDi;
+SYS_UWORD8           TDi;
-SYS_UWORD8            position_of_TC1, position_of_TB1;
+SYS_UWORD8           position_of_TC1, position_of_TB1;
-SYS_UWORD8            another_protocol_present;
+SYS_UWORD8           another_protocol_present;
-SYS_UWORD16            wait80000clk;
+SYS_UWORD16          wait80000clk;
 i               = 0;
 //wait for TS and T0
 p->moderx       = 0;
 p->expected_data= 1;
 if (returncode = SIM_Waitforchars (p, p->etu9600))
 {
 return returncode;
 }
-	ind_os_sleep(220);
+ind_os_sleep(220);
 if (((p->rbuf[0] & 0xF0) == 0x30) && (p->rx_index != 0))
 {
 cP->Inverse = 0;
 }
 //wait for TC1 and save its position
 if ((firstprotocol == 0) && ((Tx & 0x40) == mask))
 {
 position_of_TC1 = InterfChar - 1;
 }
-			if ((firstprotocol == 0) && ((Tx & 0x20) == mask))
+	    if ((firstprotocol == 0) && ((Tx & 0x20) == mask))
 {
 position_of_TB1 = InterfChar - 1;
 }
 mask = mask << 1;
 }
 return (translated);
 }
 /*
 * SIM_Waitforchars is used for waiting nbchar characters from SIM
 * input p          sim port
 *       max_wait   max number of TDMA to wait between 2 characters
 * output
 if ((p->moderx != 6) && (p->moderx != 5))   //treatement of mode 0, 1, 2, 3, 4
 {
 countT = 0;
 old_nb_char = p->rx_index;
-											   //leave while if moderx == 5
+	   //leave while if moderx == 5
 while((p->rx_index < p->expected_data) && (p->moderx != 5))
 {
 ind_os_sleep(1);
 countT++;                   //implementation of software Waiting time overflow
 {
 old_nb_char = p->rx_index;  //if char received before max_wait TDMA, reset the counter
 countT = 0;
 }
 } //end while
-		if (p->moderx == 0)
+	if (p->moderx == 0)
-		{
+	{
-			return (0);
+	    return (0);
-		}
+	}
 }
 if (p->moderx == 5)                 //use for reception of SW1 SW2
 {
 countT = 0;
 old_nb_char = p->SWcount;
-while(p->SWcount < 2)
+while (p->SWcount < 2)
 {                               //if p->moderx change from 6 to 5, need to wait for SW1 and SW2
 ind_os_sleep(1);
 countT++;                   //implementation of software Waiting time overflow
 countT = 0;
 }
 }
 p->SWcount = 0;                 //reset SWcount buffer index when SW1 SW2 received
 return (0);
-	}
+}
-	else		//treatement of abnormal case of the asynchronous state machine
+else	//treatement of abnormal case of the asynchronous state machine
-	{
+{
-		return (SIM_ERR_ABNORMAL_CASE1);
+	return (SIM_ERR_ABNORMAL_CASE1);
-	}
+}
+}
-}
 /*
 * SIM_Calcetu is used for calculating 9600 etu and 400 etu depending on sim clock freq
 *             and etu period
 {
 if (p->conf1 & SIM_CONF1_SCLKDIV)   //clock input is 13/8 Mhz
 {
 if (p->conf1 & SIM_CONF1_ETU)   //etu period is 512/8*Tsclk
 {
-p->etu9600     = 319;    // old = 88, increase of 363%
+p->etu9600    = 319;    // old = 88, increase of 363%
-p->etu400      = 6;
+p->etu400     = 6;
-p->stopclock   = 18;
+p->stopclock  = 18;
 p->startclock = 8;
 }
 else                            //etu period is 372/1*Tsclk
 {
-p->etu9600     = 1815;   // old = 500, increase of 363%
+p->etu9600    = 1815;   // old = 500, increase of 363%
-p->etu400      = 28;
+p->etu400     = 28;
-p->stopclock   = 94;
+p->stopclock  = 94;
 p->startclock = 38;
 }
 }
 else                                //clock input is 13/4 Mhz
 {
 if (p->conf1 & SIM_CONF1_ETU)   //etu period is 512/8*Tsclk
 {
-p->etu9600     = 159;   // old = 44, increase of 363%
+p->etu9600    = 159;   // old = 44, increase of 363%
-p->etu400      = 3;
+p->etu400     = 3;
-p->stopclock   = 9;
+p->stopclock  = 9;
 p->startclock = 4;
 }
 else                            //etu period is 372/1*Tsclk
 {
-p->etu9600     = 907;  // old = 250, increase of 363%
+p->etu9600    = 907;  // old = 250, increase of 363%
-p->etu400      = 14;
+p->etu400     = 14;
-p->stopclock   = 47;
+p->stopclock  = 47;
 p->startclock = 19;
 }
 }
 }
 /*
 * Set the level shifter voltage for start up sequence
 *
 */
 SYS_UWORD8 SIM_StartVolt (SYS_UWORD8 ResetFlag)
 {
-	SYS_UWORD8 abbmask;
+SYS_UWORD8 abbmask;
 #if(ANLG_FAM == 1)
 // we assume that in SIM_TYPE_5V there is nothing to do because it is the reset value
 #if ((SIM_TYPE == SIM_TYPE_3V) || (SIM_TYPE == SIM_TYPE_3_5V))    // { shut down VCC from ABB and prepare to start at 3V mode
-	if (ResetFlag) {
+if (ResetFlag) {
+	abbmask = MODE_INIT_OMEGA_3V;
+	CurrentVolt = SIM_3V;  // we assume the sim is 3v tech. from beginning.
+}
+else {
+	if (CurrentVolt == SIM_3V)
 		abbmask = MODE_INIT_OMEGA_3V;
-CurrentVolt   = SIM_3V;  // we assume the sim is 3v tech. from beginning.
+	else
-	}
+		abbmask = MODE5V_OMEGA;
-	else {
+}
-		if (CurrentVolt == SIM_3V)
-			abbmask = MODE_INIT_OMEGA_3V;
-		else
-			abbmask = MODE5V_OMEGA;
-	}
 ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCCTRL1) & 0xC0) | abbmask);
 ind_os_sleep(1);         //wait for charge pump regulation
 return(SIM_OK);
 #endif
 #endif
 #if(ANLG_FAM == 2)
 SYS_UWORD8 count = 0;
 // code for Iota
 // reset value for IOTA is for 1.8V, but specific procedure is needed
 #if ((SIM_TYPE == SIM_TYPE_1_8V) || (SIM_TYPE == SIM_TYPE_1_8_3V))    // shut down VCC from ABB and prepare to start at 1.8V mode
-	if (ResetFlag) {
+if (ResetFlag) {
+	abbmask = MODE_INIT_IOTA_1_8V;
+CurrentVolt = SIM_1_8V;  // we assume the sim is 1.8v tech. from beginning.
+}
+else {
+	if (CurrentVolt == SIM_1_8V)
 		abbmask = MODE_INIT_IOTA_1_8V;
-CurrentVolt   = SIM_1_8V;  // we assume the sim is 1.8v tech. from beginning.
+	else
-	}
+		abbmask = MODE_INIT_IOTA_3V;
-	else {
+}
-		if (CurrentVolt == SIM_1_8V)
-			abbmask = MODE_INIT_IOTA_1_8V;
-		else
-			abbmask = MODE_INIT_IOTA_3V;
-	}
 ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0xF4) | abbmask);
 while(count++ < 5)
 {
-		if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04) // test RSIMRSU
+	if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04) // test RSIMRSU
 return(SIM_OK);
 ind_os_sleep(1);
 }
 // IOTA failure activation
 return(SIM_ERR_HARDWARE_FAIL);
 #endif
 // 3V only
 #if (SIM_TYPE == SIM_TYPE_3V)
-	abbmask = MODE_INIT_IOTA_3V;
+abbmask = MODE_INIT_IOTA_3V;
-	CurrentVolt   = SIM_3V;  // we assume the sim is 3v tech. from beginning.
+CurrentVolt   = SIM_3V;  // we assume the sim is 3v tech. from beginning.
 ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0xF4) | abbmask);
 while(count++ < 5)
 {
-		if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04) // test RSIMRSU
+	if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04) // test RSIMRSU
 return(SIM_OK);
 ind_os_sleep(1);
 }
 // IOTA failure activation
 return(SIM_ERR_HARDWARE_FAIL);
 #if(ANLG_FAM == 3)
 SYS_UWORD8 count = 0;
 // code for Syren
 // reset value for SYREN is for 1.8V, but specific procedure is needed
 #if ((SIM_TYPE == SIM_TYPE_1_8V) || (SIM_TYPE == SIM_TYPE_1_8_3V))    // { shut down VCC from ABB and prepare to start at 1.8V mode
-	if (ResetFlag) {
+if (ResetFlag) {
+	abbmask = MODE_INIT_SYREN_1_8V;
+CurrentVolt = SIM_1_8V;  // we assume the sim is 1.8v tech. from beginning.
+}
+else {
+	if (CurrentVolt == SIM_1_8V)
 		abbmask = MODE_INIT_SYREN_1_8V;
-CurrentVolt   = SIM_1_8V;  // we assume the sim is 1.8v tech. from beginning.
+	else
-	}
+		abbmask = MODE_INIT_SYREN_3V;
-	else {
+}
-		if (CurrentVolt == SIM_1_8V)
+ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x1F4) | abbmask);
-			abbmask = MODE_INIT_SYREN_1_8V;
-		else
-			abbmask = MODE_INIT_SYREN_3V;
-	}
-	ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x1F4) | abbmask);
 while(count++ < 5)
 {
-		if (ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x04) // test RSIMRSU
+	if (ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x04) // test RSIMRSU
 return(SIM_OK);
 ind_os_sleep(1);
 }
 // SYREN failure activation
 return(SIM_ERR_HARDWARE_FAIL);
 #endif
 // 3V only
 #if (SIM_TYPE == SIM_TYPE_3V)
-	abbmask = MODE_INIT_SYREN_3V;
+abbmask = MODE_INIT_SYREN_3V;
-	CurrentVolt   = SIM_3V;  // we assume the sim is 3v tech. from beginning.
+CurrentVolt   = SIM_3V;  // we assume the sim is 3v tech. from beginning.
 ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x1F4) | abbmask);
 while(count++ < 5)
 {
 if (ABB_Read_Register_on_page(PAGE1,VRPCSIMR) & 0x04) // test RSIMRSU
 return(SIM_OK);
 SYS_UWORD8 SIM_SwitchVolt (SYS_UWORD8 ResetFlag)
 {
 SYS_UWORD8 count = 0;
-	SYS_UWORD8 abbmask;
+SYS_UWORD8 abbmask;
 SIM_PowerOff();
 #if(ANLG_FAM == 1)
 #if (SIM_TYPE == SIM_TYPE_3_5V)    // shut down VCC from ABB and prepare to start at 5V mode
 	if (ResetFlag) {
 		abbmask = MODE5V_OMEGA;
-CurrentVolt   = SIM_5V;
+		CurrentVolt   = SIM_5V;
 	}
 	else {
 		if (CurrentVolt == SIM_3V)
 			abbmask = MODE_INIT_OMEGA_3V;
 		else
 			abbmask = MODE5V_OMEGA;
 	}
 	ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCCTRL1) & 0xC0) | abbmask);
-return(SIM_OK);
+	return(SIM_OK);
 #endif
 #elif(ANLG_FAM == 2)
 #if (SIM_TYPE == SIM_TYPE_1_8_3V)  // shut down VCC from ABB and prepare to start at 3V mode
 	if (ResetFlag) {
 		abbmask = MODE_INIT_IOTA_3V;
-CurrentVolt   = SIM_3V;
+		CurrentVolt   = SIM_3V;
 	}
 	else {
 		if (CurrentVolt == SIM_1_8V)
 			abbmask = MODE_INIT_IOTA_1_8V;
 		else
 			abbmask = MODE_INIT_IOTA_3V;
 	}
 	ABB_wa_VRPC ((ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0xF4) | abbmask);
-while(count++ < 5)
+	while(count++ < 5)
-{
+	{
-if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04)
+		if (ABB_Read_Register_on_page(PAGE1,VRPCSIM) & 0x04)
-return(SIM_OK);
+			return(SIM_OK);
-ind_os_sleep(1);
+		ind_os_sleep(1);
-}
+	}
-// IOTA failure activation
+	// IOTA failure activation
-return(SIM_ERR_HARDWARE_FAIL);
+	return(SIM_ERR_HARDWARE_FAIL);
 #endif
 #elif(ANLG_FAM == 3)
 #if (SIM_TYPE == SIM_TYPE_1_8_3V)  // shut down VCC from ABB and prepare to start at 3V mode
 	if (ResetFlag) {
 		abbmask = MODE_INIT_SYREN_3V;
-CurrentVolt   = SIM_3V;
+		CurrentVolt   = SIM_3V;
 	}
 	else {
 		if (CurrentVolt == SIM_1_8V)
 			abbmask = MODE_INIT_SYREN_1_8V;
 		else
 }
 // SYREN failure activation
 return(SIM_ERR_HARDWARE_FAIL);
 #endif
 #endif	 // ANLG_FAM == 1, 2, 3
+}
-}
 SYS_UWORD8 SIM_Memcpy(SYS_UWORD8 *Buff_target, SYS_UWORD8 Buff_source[], SYS_UWORD16 len)
 {
 SYS_UWORD16 i;  //unsigned short type counter chosen for copy of 256 bytes
 for (i = 0; i < len; i++)
 {
 if (i == RSIMBUFSIZE)
 {
 return (SIM_ERR_BUFF_OVERFL);
 }
 else
-	  {
+	{
 (*(Buff_target+i)) = Buff_source[i];
 }
 }
 return (0);
 }
 /*
 * SIM_SleepStatus
 *
 	if ((SIM_sleep_status == SIM_SLEEP_ACT) ||  (SIM_sleep_status == SIM_SLEEP_NONE))
 		return(1);		 // SIM is ready for deep sleep
 	else
 		return(0);
 }
 /*
 * Special lock function to force SIM entity to use adequat SIM Driver
 */
 void SIM_dbg_write_trace(SYS_UWORD8 *ptr, SYS_UWORD16 len) {
 SYS_UWORD16 i;
 for(i=0;i<len;i++) {
 if (SIM_dbg_cmd_cmpt == SIM_DBG_CMD)
 	     SIM_dbg_cmd_cmpt = 0;
-	  SIM_dbg_cmd[SIM_dbg_cmd_cmpt++] = ptr[i];
+SIM_dbg_cmd[SIM_dbg_cmd_cmpt++] = ptr[i];
 }
 }
 #endif

FreeCalypso > hg > fc-tourmaline

comparison src/cs/drivers/drv_app/sim/sim.c @ 191:c1205c437943