ctcaldat.c

free sources for gsm

/* ADC and battery sampling static variables */
static UINT8 CTdummy8 = 0;
static ADChannelOffsetType CTADChannelOffset = {0, 0, 0};
static BattSamplesType CTBattSetup = {1, 0};

#if defined (PSC2010)
static UINT16 CTBattSamples[CT_BATT_SAMPLES + 1];

#endif
static UINT32 dwCTUserCalDataAddr = 0;

#if defined( BRITE4_RF )
static UINT8 bCTDCROffsetArea[2];
static INT16 wCTDCROffsetData[DCROFFS_SUBBANDS * 2];
static BOOLEAN BShowInHex = FALSE;

#endif

#if 0 && defined (POLARIS_II)
static UINT16 CTPLLCallTable[SIZE_OF_PLLTABLE];

#endif

#if defined (RENESAS_RF_B5)
static UINT16 CTRxTxFreqOffset[NO_RF_BANDS];
static RFConfigCal CTRFConfigCal =
   {
   0,
      {
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0
      }
   };

static RFInitCal CTRFInitCal =
   {
   0,
      {
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0,
      0, 0, 0, 0
      }
   };

#endif


 /* The size of the buffer to allocate and write everything into is LARGE! */
static UINT16 BufSize = COMPLETE_CAL_REPORT_BUF_SIZE;
static UINT8 GeneralPurposeArray[35];
static UINT16 currentReply = 0;
static UINT16 CTAFCDACValue = 0;

#if defined( AERO_PLUS ) || defined(MARS)
static UINT16 CTCDACValue = 0;
static INT16 CTCVARSlopeValue = 0;

#endif
static BOOLEAN CTRAMCalDataFlag = FALSE;
static CALIBRATION_DATA *HWCalibrationData;  /* This is the RAM copy of cal data for PTE */
static BOOLEAN bListDCROffsetsOnly = FALSE;

/*----------------------- Local Function Prototypes: ---------------------*/
#if defined(IMEI_SECURITY)
static void CTimeirandom(void);
static void CTimeiwrite( CTTokenList * CTCmd );
//static void CTSetIMEI( void );
#endif
static void CTShowIMEI( void );
static void CTPokeHWNVM( void );
static void CTPeekHWNVM( void );
static void CTSetVersion( void );
static void CTSetVersionString( CTTokenList * tokenList );
static void CTShowVersion( void );
static void CTShowVersionText( void );
static void CTShowCalStruct( void );
static void CTUseDefCalData( void );
static void CTListCalibrationData( void );
static void CTShowDefaultCalContents( void );
static void CTShowAFCDACVal( void );
static void CTSetAFCDACVal( void );

#if 0 && defined (POLARIS_II)
static void CTShowPLLCallTable( void );
static void CTSetPLLCallTable( void );

#endif

#if defined (AERO_PLUS) || defined(MARS)
static void CTShowCDAC( void );
static void CTSetCDAC( void );

#if 1                           /* OCR3789 */
static void CTShowCVARSlope( void );
static void CTSetCVARSlope( void );

#endif

#endif

#if defined (RENESAS_RF_B5)
static void CTShowRxTxFreqOffsetCal( void );
static void CTSetRxTxFreqOffsetCal( void );
static void CTSetRFConfigCal( void );
static void CTSendRFConfigCal( void );
static void CTShowRFConfigCal( void );
static void CTShowRFInit( void );
static void CTSetRFInit( void );

#endif

static void CTQueryCalChecksum( void );

#if !defined(FFS)
static void CTForceHWNVMValid( void );
static void CTForceHWNVMInvalid( void );

#endif

static void CTDumpDSP( void );
static void CTStoreCalData( void );
static void CTLoadCalDataFromFlash( void );
static void CTDeallocateRAMCalData( void );
static void CTReadADCChannel( void );

/*static void CTSelectADChannel( void );*/
static void CTGetADOffset( void );
static void CTSetupSetADChannelOffset( void );
static void CTSetADChannelOffset( void );
static void CTDoBatteryMeasurement( void );

#if defined (PSC2010)
static void CTBattSampling( void * );

#endif

#if defined( BRITE4_RF )
static void CTSetDCROffsetArea( void );
static void CTSetDCROffsetData( void );
static void CTShowDCROffsetsDec( void );
static void CTShowDCROffsetsHex( void );
static void CTShowDCRArea( void );
static void CTShowDCROffsetsAll( void );
static void CTReadDCROffset( void );
static void CTEnableDSPDCROffset( void );

#endif

void  CTSendRFInit( void );
void  CTRFInit( void );

/*-------------------------------- Globals -------------------------------*/

CTChecksumCauseType CTChecksumCause;   /* For all store commands (except StoreHW) the
                                          checksum is not written to flash directly after
                                          the write but rather CT_CHECK_SUM_WRITE_DELAY
                                          milliseconds later. This variable stores an
                                          identifier of the 'calling' command so the CT
                                          response string looks right */


CT_TABLE_BEGIN( CTCalDataTable, "CalData" ),
CT_ITEM_FUNCTION( "ShowCalStruct", CTShowCalStruct ),
CT_ITEM_ARRAY_FUNCTION( "SetCalDataVer", UINT8_TYPE, DECIMAL, GeneralPurposeArray, CTSetVersion, 10 ),
CT_ITEM_CT_CMD_LINE_FUNCTION( "SetCalDataVerText", CTSetVersionString ),
CT_ITEM_FUNCTION( "ShowCalDataVer", CTShowVersion ),
CT_ITEM_FUNCTION( "ShowCalDataVerText", CTShowVersionText ),
#if defined(IMEI_SECURITY)
CT_ITEM_FUNCTION( "imeirandom", CTimeirandom ),
CT_ITEM_CT_CMD_LINE_FUNCTION( "imeiwrite", ( pCT_CT_CMD_LINE_Fun ) CTimeiwrite),
//CT_ITEM_ARRAY_FUNCTION( "SetIMEI", UINT8_TYPE, HEX, GeneralPurposeArray, CTSetIMEI, 8 ),
#endif
CT_ITEM_ARRAY_FUNCTION( "ShowIMEI", UINT8_TYPE, DECIMAL, GeneralPurposeArray, CTShowIMEI, 8 ),
CT_ITEM_FUNCTION( "ShowAFCDAC", CTShowAFCDACVal ),
CT_ITEM_VARIABLE_FUNCTION( "SetAFCDAC", UINT16_TYPE, DECIMAL, &CTAFCDACValue, CTSetAFCDACVal ),
#if 0 && defined (POLARIS_II)
CT_ITEM_FUNCTION( "ShowPLLCalTable", CTShowPLLCallTable ),
CT_ITEM_ARRAY_FUNCTION( "SetPLLCalTable", UINT16_TYPE, DECIMAL, CTPLLCallTable, CTSetPLLCallTable, SIZE_OF_PLLTABLE ),
#endif
#if defined (AERO_PLUS) || defined(MARS)
CT_ITEM_FUNCTION( "ShowCDAC", CTShowCDAC ),
CT_ITEM_VARIABLE_FUNCTION( "SetCDAC", UINT16_TYPE, DECIMAL, &CTCDACValue, CTSetCDAC ),
CT_ITEM_FUNCTION( "ShowCVARSlope", CTShowCVARSlope ),
CT_ITEM_VARIABLE_FUNCTION( "SetCVARSlope", INT16_TYPE, DECIMAL, &CTCVARSlopeValue, CTSetCVARSlope ),
#endif
CT_ITEM_ARRAY_FUNCTION( "PokeHWNVM", UINT8_TYPE, DECIMAL, GeneralPurposeArray, CTPokeHWNVM, 35 ),
CT_ITEM_ARRAY_FUNCTION( "PeekHWNVM", UINT8_TYPE, DECIMAL, GeneralPurposeArray, CTPeekHWNVM, 3 ),
CT_ITEM_FUNCTION( "UseDefCalData", CTUseDefCalData ),
CT_ITEM_FUNCTION( "ListCalData", CTListCalibrationData ),
CT_ITEM_FUNCTION( "ListDefCalData", CTShowDefaultCalContents ),
CT_ITEM_FUNCTION( "ShowCalData", CTListCalibrationData ),
CT_ITEM_FUNCTION( "ShowDefCalData", CTShowDefaultCalContents ),
CT_ITEM_FUNCTION( "CheckCalDataOK", CTQueryCalChecksum ),
CT_ITEM_FUNCTION( "StoreCalData", CTStoreCalData ),
CT_ITEM_VARIABLE_FUNCTION( "LoadCalData", INT32_TYPE, HEX, &dwCTUserCalDataAddr, CTLoadCalDataFromFlash ),
/*CT_ITEM_VARIABLE_FUNCTION( "DisplayBitmap", UINT8_TYPE, DECIMAL, &CTdummy8, CTDisplayBitmap ),*/
CT_ITEM_VARIABLE_FUNCTION( "ReadADCChannel", UINT8_TYPE, DECIMAL, &CTdummy8, CTReadADCChannel ),
CT_ITEM_ARRAY_FUNCTION( "GetADCAdjust", INT16_TYPE, DECIMAL, &CTADChannelOffset, CTGetADOffset, 3 ),
CT_ITEM_ARRAY_FUNCTION( "ShowADCAdjust", INT16_TYPE, DECIMAL, &CTADChannelOffset, CTGetADOffset, 3 ),
CT_ITEM_ARRAY_FUNCTION( "SetADCAdjust", INT16_TYPE, DECIMAL, &CTADChannelOffset, CTSetupSetADChannelOffset, 3 ),
CT_ITEM_ARRAY_FUNCTION( "DoBattMeas", UINT16_TYPE, DECIMAL, &CTBattSetup, CTDoBatteryMeasurement, 2 ),
#if defined( BRITE4_RF )
CT_ITEM_FUNCTION( "ShowDCROffsetAll", CTShowDCROffsetsAll ),
CT_ITEM_ARRAY_FUNCTION( "SetDCROffsetArea", UINT8_TYPE, DECIMAL, bCTDCROffsetArea, CTSetDCROffsetArea, 2 ),
CT_ITEM_ARRAY_FUNCTION( "SetDCROffsetData", INT16_TYPE, DECIMAL, wCTDCROffsetData, CTSetDCROffsetData, 14 ),
CT_ITEM_FUNCTION( "ShowDCROffsetDec", CTShowDCROffsetsDec ),
CT_ITEM_FUNCTION( "ShowDCROffsetHex", CTShowDCROffsetsHex ),
CT_ITEM_FUNCTION( "ShowDCROffsetArea", CTShowDCRArea ),
CT_ITEM_FUNCTION( "EnableDSPDCROffset", CTEnableDSPDCROffset ),
CT_ITEM_FUNCTION( "ReadDCROffset", CTReadDCROffset ),
#endif

#if defined (RENESAS_RF_B5)
CT_ITEM_FUNCTION( "ShowRxTxFreqOffsetCal", CTShowRxTxFreqOffsetCal ),
CT_ITEM_FUNCTION( "ShowRFConfigCal", CTShowRFConfigCal ),
CT_ITEM_ARRAY_FUNCTION( "SetRxTxFreqOffsetCal", INT16_TYPE, DECIMAL, CTRxTxFreqOffset, CTSetRxTxFreqOffsetCal, 4 ),
CT_ITEM_ARRAY_FUNCTION( "SetRFConfigCal", INT16_TYPE, DECIMAL, &CTRFConfigCal, CTSetRFConfigCal, 17 ),
CT_ITEM_FUNCTION( "ShowRFInit", CTShowRFInit ),
CT_ITEM_ARRAY_FUNCTION( "SetRFInit", INT16_TYPE, DECIMAL, &CTRFInitCal, CTSetRFInit, NO_OF_RFINIT_PARM + 1 ),
CT_ITEM_ARRAY_FUNCTION( "RFInit", INT16_TYPE, DECIMAL, &CTRFInitCal, CTRFInit, NO_OF_RFINIT_PARM + 1 ),
#else
CT_ITEM_FUNCTION( "RFInit", CTRFInit ),
#endif

#if !defined(FFS)
CT_ITEM_HIDDEN_FUNCTION( "ForceNVMGood", CTForceHWNVMValid ),
CT_ITEM_HIDDEN_FUNCTION( "ForceNVMBad", CTForceHWNVMInvalid ),
#endif

/* MZO : intermediate function for DSPTracing */
CT_ITEM_HIDDEN_FUNCTION( "DumpDSP", CTDumpDSP ),
CT_TABLE_END(  );


/*-------------------------------- Externs -------------------------------*/

/*---------------------------- Local Functions: --------------------------*/
#if defined(IMEI_SECURITY)

static UINT8 imei_encode_flag = 0;
static UINT8 imei_decode_flag = 0;
static UINT8 check_buff[32];


static void CTimeirandom(void)
{   
 //   char St[32]; //,  Ak[60]; //Qu[100],
    char St[64];     // add 11
    imei_encode_flag = 1;
//    IMEI_Encryption();
       
    GSMmemset(St, 0, sizeof( St ));
    Get_Number( St, check_buff );
    
    //GSMprintf( " [%s], [%s] .\n", St, check_buff);
    CTSendStringResponse( " IMEIstart : DONE\n " );
}
static void CTimeiwrite( CTTokenList * CTCmd )
{
   UINT8 i;
   INT8 *str = ( INT8 * ) GSMMalloc( 32 );
   // UINT8 stringLen;
   // stringLen = GSMstrlen(CTCmd->Token[1]);
   
   GSMsprintf( str, "%s", CTCmd->Token[1] );
  
   if ( ( imei_encode_flag == 1 ) && ( strcmp( check_buff, str ) == 0 ) )
   {
       if ( CTCmd->NumTokens == 10 )
	       {
			   for ( i = 0; i < (CTCmd->NumTokens - 2) ; i++ )
			      {
			         CalDataPtr->GLIMEISV[i]  = (UINT8)GSMstrtoul(CTCmd->Token[i+2]);
                  }
            
			      UHNVMEncodeIMEI( CalDataPtr->GLIMEISV );
			      NVSetIMEI(  );
			      CTSendStringResponse( "IMEIwrite:DONE\n" );
			 }
       else
          {
            
            CTSendStringResponse( " IMEI paramater index is not matched .. Retry IMEIstart\n " );      
          }
            
      }
    else
      {
        
         CTSendStringResponse( " IMEIcheck value : Failed .. Retry IMEIstart\n " );      
      }

   imei_encode_flag = 0;
   GSMmemset(check_buff, 0, sizeof( check_buff ));
   GSMFree( str );
}


/*---------------------------------------------------------------------*/
/*
Name: CTSetIMEI
Desc: Sets the IMEI value up in CalDataPtr->GLIMEISV[].
Params:
Returns:
Caveats:
The IMEI given should be in scrambled from. However, the option is available to
customers to pass it to the mobile in descrambled form. Therefore the driver
UHNVMEncodeIMEI() is called here. It will normally do nothing, but can be a matching scrambling
routine for the descrambling routine in UHNVMDecodeIMEI().
*/
 #if 0
 static void CTSetIMEI( void )
   {
   UINT8 i;

   for ( i = 0; i < 8; i++ )
      {
      CalDataPtr->GLIMEISV[i] = GeneralPurposeArray[i];
      }

   /* On phone scrambling could (but shouldn't) happen here */
   UHNVMEncodeIMEI( CalDataPtr->GLIMEISV );

   NVSetIMEI(  );
   CTSendStringResponse( "SetIMEI:DONE\n" );
   }
 #endif
#endif
/*---------------------------------------------------------------------*/
/*
Name: CTShowIMEI
Desc: Shows the content of the IMEI array in the hw calibration data.
Params:
Returns:
Caveats:
*/
static void CTShowIMEI( void )
   {
   UINT16 i;
   STRING s1 = GSM_NEW_STRING( 55 );   /* collect string for output to CT window */
   STRING ctout = s1;
   UINT8 tempGLIMEISV[8];

   /* Copy the scrambled IMEI into a buffer and get it descrambled */
   GSMmemcpy( tempGLIMEISV, CalDataPtr->GLIMEISV, 8 );
   UHNVMDecodeIMEI( tempGLIMEISV );

   ctout += GSMsprintf( s1, "ShowIMEI:RET:" );
   ctout += GSMsprintf( ctout, "0x%02x", ( UINT8 ) tempGLIMEISV[0] );
   for ( i = 1; i < 8; i++ )
      {
      ctout += GSMsprintf( ctout, ",0x%02x", ( UINT8 ) tempGLIMEISV[i] );
      }

   GSMsprintf( ctout, "\n" );

   CTSendStringResponse( s1 );

   GSMFree( s1 );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTPokeHWNVM
Desc: Fills the required number of bytes ( up to 32 ) into the HW NVM area.
Params: Are trensfered via the GeneralPurposeArray
Returns:
Caveats: The parameters in the GeneralPurposeArray are (in the given
         sequence): high byte of the offset relative to the begining of
         the HW NVM Area, low byte of the offset, length, bytes to be
         poked into the area. The changed area is finaly stored by the
         command 'StoreHW'.
*/
static void CTPokeHWNVM( void )
   {
   UINT16 Offset = GeneralPurposeArray[0] * 256 + GeneralPurposeArray[1];
   UINT8 Length = GeneralPurposeArray[2];
   UINT8 *Buffer = ( UINT8 * ) & GeneralPurposeArray[3];