ctcaldat.c

free sources for gsm

*/

static void CTDeallocateRAMCalData( void )
   {
   CalDataPtr = pCalDataInFlash;

   GSMFree( HWCalibrationData );/* ... so that the RAM data may be freed. */
   SetCTRAMCalDataFlag( FALSE );

#if defined (DEBUG)
   CTSendStringResponse( "RAM cal data deallocated\n" );
   GSMprintf( "CalDataPtr reset to flash loc 0x%lx\n", CalDataPtr );
#endif
   return;
   }

/*---------------------------------------------------------------------*/
/*
Name: SetCTRAMCalDataFlag
Desc: Sets the state of the flag used to decide if we need to make a
      copy of the cal data in RAM for PTE
Params: RAMCopyExist
Returns: None
Caveats:
*/
void  SetCTRAMCalDataFlag( BOOLEAN RAMCopyExist )
   {
   CTRAMCalDataFlag = RAMCopyExist;
   return;
   }

/*---------------------------------------------------------------------*/
/*
Name: GetCTRAMCalDataFlag
Desc: Returns the state of the flag used to decide if we need to make a
      copy of the cal data in RAM for PTE
Params: None
Returns: Boolean flag
Caveats:
*/
BOOLEAN GetCTRAMCalDataFlag( void )
   {
   return CTRAMCalDataFlag;
   }

/*---------------------------------------------------------------------*/
/*
Name: CTReadADChannel
Desc: Reads value from the specified ADC channel.
Params: CTdummy8 is the channel number
Returns:
Caveats:
*/

static void CTReadADChannel( void )
   {
#if defined (PSC2010)
   INT8  s1[60];

   if ( CTdummy8 >= NumADCChannels )
      {
      CTSendStringResponse( "ReadADChannel:WRONG:BAD_CHANNEL\n" );
      CTdummy8 = 0;
      return;
      }
   GSMsprintf( s1, "ReadADChannel:RET:Channel %u, Value %u\n", CTdummy8, UHADCAutorange( ( ADCChannel ) CTdummy8 ) );
   CTSendStringResponse( s1 );
#else
   CTSendStringResponse( "ReadADChannel:FAIL:Only PSC2010 supported" );
#endif
   }

/*---------------------------------------------------------------------*/
/*
Name: CTGetADOffset
Desc: Show the offset for the given or current ADC channel as stored in CalDataPtr->
Params:
Returns:
Caveats:
*/
static void CTGetADOffset( void )
   {
   INT8  s1[60];
   INT16 result;

   if ( CTADChannelOffset.channelNo >= ADC_CAL_CHANNELS )
      {
      CTSendStringResponse( "GetADAdjust:WRONG:BAD_CHANNEL\n" );
      CTADChannelOffset.channelNo = 0;
      return;
      }

   if ( CTADChannelOffset.ADCLevel >= ADC_CAL_POINTS )
      {
      CTSendStringResponse( "GetADAdjust:WRONG:BAD_LEVEL\n" );
      CTADChannelOffset.channelNo = 0;
      return;
      }

   result = CalDataPtr->ADCcal[CTADChannelOffset.ADCLevel][CTADChannelOffset.channelNo];
   GSMsprintf( s1, "GetADAdjust:RET:Channel %u, Level %u, Offset %d\n", CTADChannelOffset.channelNo, CTADChannelOffset.ADCLevel, result );
   CTSendStringResponse( s1 );
   return;
   }

/*---------------------------------------------------------------------*/
/*
Name: CTSetupSetADChannelOffset
Desc: Make it happen in framer
Params: CTADChannelOffset
Returns:
Caveats:
*/
static void CTSetupSetADChannelOffset( void )
   {
   if ( CTADChannelOffset.channelNo >= ADC_CAL_CHANNELS )
      {
      CTSendStringResponse( "SetADChannelAdjust:WRONG:BAD_CHANNEL\n" );
      CTADChannelOffset.channelNo = 0;
      CTADChannelOffset.offsetValue = 0;
      CTADChannelOffset.ADCLevel = 0;
      return;
      }

   CTDSPControl.Action = CTSetADChannelOffset;
   CTDSPControl.ActionSheduled = TRUE;
   }

/*---------------------------------------------------------------------*/
/*
Name: CTSetADChannelOffset
Desc: Set up given offset for given ADC channel in HWCalibration data
Params: -
Returns: -
Caveats:
Note: this doesn't store it in the NVM! Use StoreUhData or StoreHW.
*/

static void CTSetADChannelOffset( void )
   {
   INT8  s1[60];

   CTDSPControl.ActionSheduled = FALSE;
   CalDataPtr->ADCcal[CTADChannelOffset.ADCLevel][CTADChannelOffset.channelNo] = CTADChannelOffset.offsetValue;
   GSMsprintf( s1, "SetADChannelAdjust:DONE:Channel %u, Level %u, Value %d\n",
               CTADChannelOffset.channelNo, CTADChannelOffset.ADCLevel, CTADChannelOffset.offsetValue );
   CTSendStringResponse( s1 );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTDoBatteryMeasurement
Desc: Returns a number of samples of the ADC measurement for the battery.
Params: CTBattSetup
Returns:
Caveats:
*/

static void CTDoBatteryMeasurement( void )
   {
#if defined (PSC2010)
/* Limit number of samples. User must reissue command for more samples.*/
   if ( CTBattSetup.SampleNumber > CT_BATT_SAMPLES )
      {
      CTSendStringResponse( "DoBattMeas:WRONG:TOO_MANY_SAMPLES\n" );
      return;
      }
   if ( !CTBattSetup.SampleDelay )
      CTBattSetup.SampleDelay = 1;  /* minimum delay */

   if ( !CTBattSetup.SampleNumber )
      CTBattSetup.SampleNumber = 1; /* minimum samples of 1 */

   CTdummy8 = ( UINT8 ) CTBattSetup.SampleNumber;
   CTBattSamples[CTBattSetup.SampleNumber] = UHADCAutorange( ADC_BATT_CHANNEL );
   CTBattSetup.SampleNumber--;

   GSMStartTimer( CT_MISC_TIMER, MSECS( CTBattSetup.SampleDelay ), CTBattSampling, NULL );
#else
   CTSendStringResponse( "DoBattMeas:FAIL:Only PSC2010 supported" );
#endif
   }

/*---------------------------------------------------------------------*/
/*
Name: CTBattSampling
Desc: Makes an ADC measurement on each timer sample period
Params: CTBattSamples
Returns:
Caveats:
*/
#if defined (PSC2010)

static void CTBattSampling( void *dummy )
   {
   /* Take the rest of the samples. */
   UNUSED( dummy );
   if ( CTBattSetup.SampleNumber > 0 )
      {
      CTBattSamples[CTBattSetup.SampleNumber] = UHADCAutorange( ADC_BATT_CHANNEL );
      CTBattSetup.SampleNumber--;
      GSMStartTimer( CT_MISC_TIMER, MSECS( CTBattSetup.SampleDelay ), CTBattSampling, NULL );
      }

   else
      {
      INT8 *s1 = GSM_NEW_ARRAY( INT8, 170 ); /* collect string for output to CT window */
      INT8 *ctout = s1;
      UINT16 CTdummyU16;

      /* Create the output string. */
      ctout += GSMsprintf( ctout, "DoBattMeas:RET:" );
      for ( CTdummyU16 = CTdummy8; CTdummyU16 > 0; CTdummyU16-- )
         {
         ctout += GSMsprintf( ctout, "%u,", ( UINT16 ) CTBattSamples[CTdummyU16] );
         }
      /* Remove the trailing comma. */
      ctout--;

      GSMsprintf( ctout, "\n" );
      CTSendStringResponse( s1 );
      GSMFree( s1 );
      }
   }

#endif

/*---------------------------------------------------------------------*/
/*
Name: UseOldCalData
Desc: Loads sector 0 cal data into RAM
Params: None
Returns: Acknowledgement
Caveats:
*/

static void CTLoadCalDataFromFlash( void )
   {
   if ( dwCTUserCalDataAddr )
      GSMmemcpy( CalDataPtr, ( UINT8 * ) dwCTUserCalDataAddr, sizeof( CALIBRATION_DATA ) );
   else
      GSMmemcpy( CalDataPtr, pCalDataInFlash, sizeof( CALIBRATION_DATA ) );

   dwCTUserCalDataAddr = 0;
   CTSendStringResponse( "LoadCalData:DONE" );
   }

#if defined( BRITE4_RF )
/*---------------------------------------------------------------------*/
/*
Name: CTSetDCROffsetArea
Desc: Checks and acknowledges the setting of the bCTDCROffsetArea variables
Params: None
Returns: Acknowledgement
Caveats:
*/
static void CTSetDCROffsetArea( void )
   {
   if ( bCTDCROffsetArea[0] < NO_RF_BANDS && bCTDCROffsetArea[1] < DCROFFS_SUBBANDS )
      CTSendStringResponse( "CTSetDCROffsetArea:DONE" );
   else
      {
      bCTDCROffsetArea[0] = 0;
      bCTDCROffsetArea[1] = 0;
      CTSendStringResponse( "CTSetDCROffsetArea:FAIL:Bad Parameters." );
      }
   }

/*---------------------------------------------------------------------*/
/*
Name: CTSetDCROffsetData
Desc: Set the DCR data for I and Q, all gainsettins in the sub band specified by the SetDCROffsetArea command.
Params: None
Returns: Acknowledgement
Caveats:
*/
static void CTSetDCROffsetData( void )
   {
   INT16 *Src = wCTDCROffsetData,
        *Dst = CalDataPtr->DCRRXOffset[bCTDCROffsetArea[0]][bCTDCROffsetArea[1]][0];
   UINT16 wSize = sizeof( wCTDCROffsetData );

   GSMmemcpy( Dst, Src, wSize );
   CTSendStringResponse( "CTSetDCROffsetData:DONE" );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTShowDCROffsetsDec
Desc: Displays DCR offsets for the area set by SetDCROffsetArea command.
Params: None
Returns: Acknowledgement and data.
Caveats:
*/
static void CTShowDCROffsetsDec( void )
   {
   char *pCTStringWhole = GSM_NEW_ARRAY( char, 150 );
   char *pCTStringBuild = pCTStringWhole;
   UINT8 bDCRGainSetting;

   if ( BShowInHex )
      pCTStringBuild += GSMsprintf( pCTStringBuild, "CTShowDCROffsetHex:RET:" );
   else
      pCTStringBuild += GSMsprintf( pCTStringBuild, "CTShowDCROffsetDec:RET:" );

   for ( bDCRGainSetting = 0; bDCRGainSetting < DCROFFS_GAIN_SETTINGS; bDCRGainSetting++ )
      {
      if ( BShowInHex )
         pCTStringBuild += GSMsprintf( pCTStringBuild, "(0x%x, 0x%x), ", CalDataPtr->DCRRXOffset[bCTDCROffsetArea[0]][bCTDCROffsetArea[1]][bDCRGainSetting][0], CalDataPtr->DCRRXOffset[bCTDCROffsetArea[0]][bCTDCROffsetArea[1]][bDCRGainSetting][1] );
      else
         pCTStringBuild += GSMsprintf( pCTStringBuild, "(%u, %u), ", CalDataPtr->DCRRXOffset[bCTDCROffsetArea[0]][bCTDCROffsetArea[1]][bDCRGainSetting][0], CalDataPtr->DCRRXOffset[bCTDCROffsetArea[0]][bCTDCROffsetArea[1]][bDCRGainSetting][1] );
      }
   pCTStringBuild -= 2;
   pCTStringBuild = "\n";
   CTSendStringResponse( pCTStringWhole );
   GSMFree( pCTStringWhole );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTShowDCROffsetsAll
Desc: Displays all DCR offsets
Params: None
Returns: Acknowledgement and data
Caveats:
*/
static void CTShowDCROffsetsAll( void )
   {
   bListDCROffsetsOnly = TRUE;
   BufSize = DCROFFS_CAL_REPORT_BUF_SIZE;
   CTSetUpAFullListing( ( CALIBRATION_DATA * ) CalDataPtr, "ShowDCROffsetAll:RET:" );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTShowDCROffsetsHex
Desc: Loads sector 0 cal data into RAM
Params: None
Returns: Acknowledgement
Caveats:
*/
static void CTShowDCROffsetsHex( void )
   {
   BShowInHex = TRUE;
   CTShowDCROffsetsDec(  );
   BShowInHex = FALSE;
   }

/*---------------------------------------------------------------------*/
/*
Name: CTShowDCRArea
Desc: Loads sector 0 cal data into RAM
Params: None
Returns: Acknowledgement
Caveats:
*/
static void CTShowDCRArea( void )
   {
   char  sCTString[30];

   GSMsprintf( sCTString, "CTShowDCROffsetArea:RET:%u,%u", bCTDCROffsetArea[0], bCTDCROffsetArea[1] );
   CTSendStringResponse( ( INT8 * ) sCTString );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTReadDCROffset
Desc: Requests DSP for its DCR offset I and Q offsets
Params: None
Returns: Acknowledgement and results for I and Q phase
Caveats:
*/
static void CTReadDCROffset( void )
   {
   char *sCTString = GSM_NEW_ARRAY( char, 30 );
   const UINT32 dwAddr = 0xbc048;   /* Trident DSP memory location for DCR offset */
   UINT16 wDataIphase,
         wDataQphase;
   MEM_READ_RPT *DCROffsetRpt;

   DCROffsetRpt = CTInternDSPPeek( dwAddr, 2 );

   wDataIphase = DCROffsetRpt->read_word[0] & 8191;
   wDataQphase = DCROffsetRpt->read_word[1] & 8191;

   if ( DCROffsetRpt->valid )
      GSMsprintf( sCTString, "ReadDCROffset:RET:%u,%u", wDataIphase, wDataQphase );
   else
      GSMsprintf( sCTString, "ReadDCROffset:FAILED" );

   CTSendStringResponse( ( INT8 * ) sCTString );
   GSMFree( sCTString );
   }

/*---------------------------------------------------------------------*/
/*
Name: CTEnableDSPDCROffset
Desc: Enables DSP reading of DCR offset
Params: None
Returns: Acknowledgement and results for I and Q phase
Caveats:
*/
static void CTEnableDSPDCROffset( void )
   {
   char *sCTString = GSM_NEW_ARRAY( char, 30 );
   const UINT32 dwAddr = 0x4198;/* Trident DSP memory location for DCR offset */
   UINT16 wData = 0;

   if ( CTInternDSPPoke( dwAddr, wData ) )
      CTSendStringResponse( "EnableDSPDCROffset:DONE" );
   else
      CTSendStringResponse( "EnableDSPDCROffset:RET:FAIL" );
   CTSendStringResponse( ( INT8 * ) sCTString );
   GSMFree( sCTString );
   }

#endif