ctcaldat.c

free sources for gsm

                                                                                          space */
   GSMmemcpy( HWCalibrationData, CalDataPtr, sizeof( CALIBRATION_DATA ) ); /* Load the current
                                                                              values into RAM */
   CalDataPtr = HWCalibrationData;  /* From now on everything uses the RAM copy until RAM
                                       data is stored */
   SetCTRAMCalDataFlag( TRUE );
#if defined (DEBUG)
   GSMprintf( "RAM cal data allocated to %lx\n", ( UINT32 ) HWCalibrationData );
#endif
   return;
   }

/*---------------------------------------------------------------------*/
/*
Name: CTDeallocateRAMCalData
Desc: Deallocates the RAM copy of the calibration data structure for PTE work. Called internally from the
  command to store the RAM data to Flash since the RAM data is probably no longer required.
Params: None
Returns: None
Caveats:
*/

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