// SPDX-License-Identifier: GPL-2.0
/*
 * Author(s):
 * cdp
 *
 * Distributed by:
 * Silicon Laboratories, Inc
 *
 * This file contains proprietary information.
 * No dissemination allowed without prior written permission from
 * Silicon Laboratories, Inc.
 *
 * File Description:
 * This is the interface file for the ProSLIC test-in functions.
 *
 *
 */

#include "../config_inc/si_voice_datatypes.h"
#include "../inc/si_voice_ctrl.h"
#include "../inc/si_voice_timer_intf.h"
#include "../inc/proslic.h"
#include "../config_inc/proslic_api_config.h"
#include "../inc/proslic_tstin.h"

#ifdef SI3217X
#include "si3217x.h"
#include "si3217x_intf.h"
#endif
#ifdef SI3218X
#include "../inc/si3218x.h"
#include "../inc/si3218x_intf.h"
#endif
#ifdef SI3219X
#include "si3219x.h"
#include "si3219x_intf.h"
#endif
#ifdef SI3226X
#include "si3226x.h"
#include "si3226x_intf.h"
#endif
#ifdef SI3228X
#include "si3228x.h"
#include "si3228x_intf.h"
#endif

/*
** Function Pointer Macros
*/
#define WriteReg        pProslic->deviceId->ctrlInterface->WriteRegister_fptr
#define ReadReg         pProslic->deviceId->ctrlInterface->ReadRegister_fptr
#define pProHW          pProslic->deviceId->ctrlInterface->hCtrl
#define Reset           pProslic->deviceId->ctrlInterface->Reset_fptr
#define Delay           pProslic->deviceId->ctrlInterface->Delay_fptr
#define pProTimer       pProslic->deviceId->ctrlInterface->hTimer
#define WriteRAM        pProslic->deviceId->ctrlInterface->WriteRAM_fptr
#define ReadRAM         pProslic->deviceId->ctrlInterface->ReadRAM_fptr
#define TimeElapsed     pProslic->deviceId->ctrlInterface->timeElapsed_fptr
#define getTime         pProslic->deviceId->ctrlInterface->getTime_fptr
#define SetSemaphore    pProslic->deviceId->ctrlInterface->Semaphore_fptr

#define WriteRegX       deviceId->ctrlInterface->WriteRegister_fptr
#define ReadRegX        deviceId->ctrlInterface->ReadRegister_fptr
#define pProHWX         deviceId->ctrlInterface->hCtrl
#define DelayX          deviceId->ctrlInterface->Delay_fptr
#define pProTimerX      deviceId->ctrlInterface->hTimer
#define WriteRAMX       deviceId->ctrlInterface->WriteRAM_fptr
#define ReadRAMX        deviceId->ctrlInterface->ReadRAM_fptr
#define getTimeX        deviceId->ctrlInterface->getTime_fptr
#define TimeElapsedX    deviceId->ctrlInterface->timeElapsed_fptr

/*
* Valid Device Number Ranges
*/

#define TSTIN_VALID_SI3217X_PART_NUM (pProslic->deviceId->chipType >= SI32171 && pProslic->deviceId->chipType <= SI32179)
#define TSTIN_VALID_SI3218X_PART_NUM (pProslic->deviceId->chipType >= SI32180 && pProslic->deviceId->chipType <= SI32189)
#define TSTIN_VALID_SI3219X_PART_NUM (pProslic->deviceId->chipType >= SI32190 && pProslic->deviceId->chipType <= SI32199)
#define TSTIN_VALID_SI3226X_PART_NUM (pProslic->deviceId->chipType >= SI32260 && pProslic->deviceId->chipType <= SI32269)
#define TSTIN_VALID_SI3228X_PART_NUM (pProslic->deviceId->chipType >= SI32280 && pProslic->deviceId->chipType <= SI32289)

#define TSTIN_INVALID_PART_NUM  !(TSTIN_VALID_SI3217X_PART_NUM ||\
    TSTIN_VALID_SI3218X_PART_NUM || TSTIN_VALID_SI3219X_PART_NUM ||\
    TSTIN_VALID_SI3226X_PART_NUM || TSTIN_VALID_SI3228X_PART_NUM)

#define LOGPRINT_PREFIX "ProSLIC:"

ProSLIC_DCfeed_Cfg ringtripTestDCFeedPreset[] =
{
  {
    0x196038D8L,	/* SLOPE_VLIM */
    0x1D707651L,	/* SLOPE_RFEED */
    0x0040A0E0L,	/* SLOPE_ILIM */
    0x1E07FE48L,	/* SLOPE_DELTA1 */
    0x1ED62D87L,	/* SLOPE_DELTA2 */
    0x01A50724L,	/* V_VLIM (14.000 v) */
    0x016EE54FL,	/* V_RFEED (12.200 v) */
    0x012CBBF5L,	/* V_ILIM  (10.000 v) */
    0x00AF8C10L,	/* CONST_RFEED (10.000 mA) */
    0x0045CBBCL,	/* CONST_ILIM (15.000 mA) */
    0x000D494BL,	/* I_VLIM (0.000 mA) */
    0x005B0AFBL,	/* LCRONHK (10.000 mA) */
    0x006D4060L,	/* LCROFFHK (12.000 mA) */
    0x00008000L,	/* LCRDBI (5.000 ms) */
    0x0048D595L,	/* LONGHITH (8.000 mA) */
    0x003FBAE2L,	/* LONGLOTH (7.000 mA) */
    0x00008000L,	/* LONGDBI (5.000 ms) */
    0x000F0000L,	/* LCRMASK (150.000 ms) */
    0x00080000L,	/* LCRMASK_POLREV (80.000 ms) */
    0x00140000L,	/* LCRMASK_STATE (200.000 ms) */
    0x00140000L,	/* LCRMASK_LINECAP (200.000 ms) */
    0x01999999L,	/* VCM_OH (25.000 v) */
    0x0051EB85L,	/* VOV_BAT (5.000 v) */
    0x00418937L 	/* VOV_GND (4.000 v) */
  }
};

/*
** dB lookup table
*/
#define DB_TABLE_STEP_SIZE     250
#define MAX_DB_TABLE           279

static const uInt32 dBTable10_n60 [] =
{
  31623,
  30726,
  29854,
  29007,
  28184,
  27384,
  26607,
  25852,
  25119,
  24406,
  23714,
  23041,
  22387,
  21752,
  21135,
  20535,
  19953,
  19387,
  18836,
  18302,
  17783,
  17278,
  16788,
  16312,
  15849,
  15399,
  14962,
  14538,
  14125,
  13725,
  13335,
  12957,
  12589,
  12232,
  11885,
  11548,
  11220,
  10902,
  10593,
  10292,
  10000,
  9716,
  9441,
  9173,
  8913,
  8660,
  8414,
  8175,
  7943,
  7718,
  7499,
  7286,
  7079,
  6879,
  6683,
  6494,
  6310,
  6131,
  5957,
  5788,
  5623,
  5464,
  5309,
  5158,
  5012,
  4870,
  4732,
  4597,
  4467,
  4340,
  4217,
  4097,
  3981,
  3868,
  3758,
  3652,
  3548,
  3447,
  3350,
  3255,
  3162,
  3073,
  2985,
  2901,
  2818,
  2738,
  2661,
  2585,
  2512,
  2441,
  2371,
  2304,
  2239,
  2175,
  2113,
  2054,
  1995,
  1939,
  1884,
  1830,
  1778,
  1728,
  1679,
  1631,
  1585,
  1540,
  1496,
  1454,
  1413,
  1372,
  1334,
  1296,
  1259,
  1223,
  1189,
  1155,
  1122,
  1090,
  1059,
  1029,
  1000,
  972,
  944,
  917,
  891,
  866,
  841,
  818,
  794,
  772,
  750,
  729,
  708,
  688,
  668,
  649,
  631,
  613,
  596,
  579,
  562,
  546,
  531,
  516,
  501,
  487,
  473,
  460,
  447,
  434,
  422,
  410,
  398,
  387,
  376,
  365,
  355,
  345,
  335,
  325,
  316,
  307,
  299,
  290,
  282,
  274,
  266,
  259,
  251,
  244,
  237,
  230,
  224,
  218,
  211,
  205,
  200,
  194,
  188,
  183,
  178,
  173,
  168,
  163,
  158,
  154,
  150,
  145,
  141,
  137,
  133,
  130,
  126,
  122,
  119,
  115,
  112,
  109,
  106,
  103,
  100,
  97,
  94,
  92,
  89,
  87,
  84,
  82,
  79,
  77,
  75,
  73,
  71,
  69,
  67,
  65,
  63,
  61,
  60,
  58,
  56,
  55,
  53,
  52,
  50,
  49,
  47,
  46,
  45,
  43,
  42,
  41,
  40,
  39,
  38,
  37,
  35,
  34,
  33,
  33,
  32,
  31,
  30,
  29,
  28,
  27,
  27,
  26,
  25,
  24,
  24,
  23,
  22,
  22,
  21,
  21,
  20,
  19,
  19,
  18,
  18,
  17,
  17,
  16,
  16,
  15,
  15,
  15,
  14,
  14,
  13,
  13,
  13,
  12,
  12,
  12,
  11,
  11,
  11,
  10,
  10
};


/* *********************************** */
static int setInternalTestLoad(proslicChanType *pProslic, int connect)
{
  ramData ram_save;
  ramData test_load_addr;
  ramData test_load_bitmask;

  if(pProslic->deviceId->chipType >= SI32171
      && pProslic->deviceId->chipType <= SI32179)
  {
    test_load_addr = 1516;
    test_load_bitmask = 0x00800000L;  /* bit 23 */
  }
  else
  {
    test_load_addr = 1611;
    test_load_bitmask = 0x00040000L;  /* bit 18 */
  }

  ProSLIC_SetUserMode(pProslic,1,0);
  ram_save = ProSLIC_ReadRAM(pProslic,test_load_addr);

  if(connect)
  {
    ram_save |= test_load_bitmask;
  }
  else
  {
    ram_save &= ~test_load_bitmask;
  }

  ProSLIC_WriteRAM(pProslic,test_load_addr,ram_save);

  return RC_NONE;
}

/* *********************************** */
static void setup1kHzBandpass(proslicChanType *pProslic)
{
  /* 1kHz bandpass - Gain = -1.7055 */
  ProSLIC_WriteRAM(pProslic, 32, 0x180A50L);	/* TESTB0_1 */
  ProSLIC_WriteRAM(pProslic, 33, 0x0L);		/* TESTB1_1 */
  ProSLIC_WriteRAM(pProslic, 34, 0x1FE7F5B0L);/* TESTB2_1 */
  ProSLIC_WriteRAM(pProslic, 35, 0xB166220L);	/* TESTA1_1 */
  ProSLIC_WriteRAM(pProslic, 36, 0x185119D0L);/* TESTA2_1 */
  ProSLIC_WriteRAM(pProslic, 37, 0xAF624E0L);	/* TESTB0_2 */
  ProSLIC_WriteRAM(pProslic, 38, 0x0L);		/* TESTB1_2 */
  ProSLIC_WriteRAM(pProslic, 39, 0xAF624E0L);	/* TESTB2_2 */
  ProSLIC_WriteRAM(pProslic, 40, 0x0L); 		/* TESTA1_2 */
  ProSLIC_WriteRAM(pProslic, 41, 0x185119D0L);/* TESTA2_2 */
  ProSLIC_WriteRAM(pProslic, 42, 0x7C6E410L);	/* TESTB0_3 */
  ProSLIC_WriteRAM(pProslic, 43, 0xAFF8B80L);	/* TESTB1_3 */
  ProSLIC_WriteRAM(pProslic, 44, 0x7C6E410L);	/* TESTB2_3 */
  ProSLIC_WriteRAM(pProslic, 45, 0x14E99DE0L);/* TESTA1_3 */
  ProSLIC_WriteRAM(pProslic, 46, 0x185119D0L);/* TESTA2_3 */
  ProSLIC_WriteRAM(pProslic, 50, 0x40000L);	/* TESTAVBW */
  ProSLIC_WriteRAM(pProslic, 49, 0x1F40000L);	/* TESTWLN */
  ProSLIC_WriteRAM(pProslic, 54, 0x0L);		/* TESTAVTH */
  ProSLIC_WriteRAM(pProslic, 53, 0x0L);		/* TESTPKTH */
}

/* *********************************** */
/* Return value in dB*1000 (mdB) */
static int32 dBLookup(uInt32 number)
{
  int i;
  uInt32 err;

  if(number >= dBTable10_n60[0])
  {
    return 10000;  /* out of range - clamp at 10dB */
  }

  for(i=0; i<MAX_DB_TABLE; i++) /* 139 */
  {
    if((number < dBTable10_n60[i])&&(number >= dBTable10_n60[i+1]))
    {
      /* See which level it is closest to */
      err = dBTable10_n60[i] - number;
      if(err < (number - dBTable10_n60[i+1]))
      {
        return (10000 - i*DB_TABLE_STEP_SIZE);
      }
      else
      {
        return (10000 - (i+1)*DB_TABLE_STEP_SIZE);
      }
    }
  }
  /* No solution found?  Return -60dB */
  return -60000;
}

/* *********************************** */
static int32 readAudioDiagLevel(proslicChanType *pProslic,int32 zero_dbm_mvpk)
{
  int32 data;

  data = ProSLIC_ReadRAM(pProslic,47); /* TESTPKO */
  DEBUG_PRINT(pProslic, "TESTPKO = %d\n", (int)data);

  data /= 40145;         /* 2^28 * 0.182 * 10^(Gfilt/20) */
  data *= 1000;
  data /= zero_dbm_mvpk;
  data *= 10;

  return(dBLookup(data));
}

/* *********************************** */
static char *applyTestLimits(proslicTestObj *test)
{
  if((test->value >= test->lowerLimit)&&(test->value <= test->upperLimit))
  {
    test->testResult = RC_TEST_PASSED;
    return ("PASS");
  }
  else
  {
    test->testResult = RC_TEST_FAILED;
    return ("FAIL");
  }
}



/* *********************************** */
static int logTest(proslicChanType *pProslic,proslicTestObj *test,
                   const char *label)
{
  char resultStr[10];
  SIVOICE_STRCPY(resultStr,applyTestLimits(test));
  DEBUG_PRINT(pProslic, "ProSLIC : TestIn : %-14s = %-8d :: %s\n", label, (int)(test->value),
             resultStr);
#ifndef ENABLE_DEBUG
  SILABS_UNREFERENCED_PARAMETER(pProslic);
  SILABS_UNREFERENCED_PARAMETER(label);
#endif
  return test->testResult;

}
/* *********************************** */
static int logStatus(proslicChanType *pProslic, int status,const char *label)
{
  DEBUG_PRINT(pProslic, "ProSLIC : TestIn : %-14s = %d\n", label,status);
#ifndef ENABLE_DEBUG
  SILABS_UNREFERENCED_PARAMETER(pProslic);
  SILABS_UNREFERENCED_PARAMETER(label);
  SILABS_UNREFERENCED_PARAMETER(status);
#endif
  return RC_NONE;
}

/* *********************************** */
static uInt32 Isqrt32(uInt32 num)
{
  uInt32 one,res,op;

  op=num;
  res=0;
  one = 1L << 30;
  while(one > op)
  {
    one >>=2;
  }

  while(one !=0)
  {
    if(op >= res + one)
    {
      op = op - (res + one);
      res = res + 2*one;
    }
    res >>= 1;
    one >>= 2;
  }

  return (res);
}


/* *********************************** */
static int storeDCFeedPreset(proslicChanType *pProslic,ProSLIC_DCfeed_Cfg *cfg,uInt8 preset)
{
  cfg[preset].slope_vlim = ProSLIC_ReadRAM(pProslic,634);
  cfg[preset].slope_rfeed = ProSLIC_ReadRAM(pProslic,635);
  cfg[preset].slope_ilim = ProSLIC_ReadRAM(pProslic,636);
  cfg[preset].delta1 = ProSLIC_ReadRAM(pProslic,638);
  cfg[preset].delta2 = ProSLIC_ReadRAM(pProslic,639);
  cfg[preset].v_vlim = ProSLIC_ReadRAM(pProslic,640);
  cfg[preset].v_rfeed = ProSLIC_ReadRAM(pProslic,641);
  cfg[preset].v_ilim = ProSLIC_ReadRAM(pProslic,642);
  cfg[preset].const_rfeed = ProSLIC_ReadRAM(pProslic,643);
  cfg[preset].const_ilim = ProSLIC_ReadRAM(pProslic,644);
  cfg[preset].i_vlim = ProSLIC_ReadRAM(pProslic,645);
  cfg[preset].lcronhk = ProSLIC_ReadRAM(pProslic,853);
  cfg[preset].lcroffhk = ProSLIC_ReadRAM(pProslic,852);
  cfg[preset].lcrdbi = ProSLIC_ReadRAM(pProslic,701);
  cfg[preset].longhith = ProSLIC_ReadRAM(pProslic,858);
  cfg[preset].longloth = ProSLIC_ReadRAM(pProslic,859);
  cfg[preset].longdbi = ProSLIC_ReadRAM(pProslic,702);
  cfg[preset].lcrmask = ProSLIC_ReadRAM(pProslic,854);
  cfg[preset].lcrmask_polrev = ProSLIC_ReadRAM(pProslic,855);
  cfg[preset].lcrmask_state = ProSLIC_ReadRAM(pProslic,856);
  cfg[preset].lcrmask_linecap = ProSLIC_ReadRAM(pProslic,857);
  cfg[preset].vcm_oh = ProSLIC_ReadRAM(pProslic,748);
  cfg[preset].vov_bat = ProSLIC_ReadRAM(pProslic,752);
  cfg[preset].vov_gnd = ProSLIC_ReadRAM(pProslic,751);

  return RC_NONE;
}


/* *********************************** */
int ProSLIC_createTestInObjs(proslicTestInObjType_ptr *pTstin, uInt32 num_objs)
{
#ifndef DISABLE_MALLOC
  *pTstin = SIVOICE_CALLOC(sizeof(proslicTestInObjType),num_objs);

  if(*pTstin == NULL)
  {
#ifdef ENABLE_DEBUG
    LOGPRINT("%s: %s: failed to allocate memory", LOGPRINT_PREFIX, __FUNCTION__);
#endif
    return RC_NO_MEM;
  }

  return RC_NONE;
#else
  SILABS_UNREFERENCED_PARAMETER(pTstin);
  SILABS_UNREFERENCED_PARAMETER(num_objs);
  return RC_UNSUPPORTED_FEATURE;
#endif
}
/* *********************************** */
int ProSLIC_destroyTestInObjs(proslicTestInObjType_ptr *pTstin)
{
#ifndef DISABLE_MALLOC
  SIVOICE_FREE((proslicTestInObjType_ptr) *pTstin);
  *pTstin = NULL;
  return RC_NONE;
#else
  SILABS_UNREFERENCED_PARAMETER(pTstin);
  return RC_UNSUPPORTED_FEATURE;
#endif
}

/* *********************************** */
int ProSLIC_testInPCMLpbkEnable(proslicChanType *pProslic,
                                proslicTestInObjType *pTstin)
{
  uInt8 regData;

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if(!pTstin->pcmLpbkTest.testEnable)
  {
    return RC_TEST_DISABLED;
  }
  /* Return if already enabled */
  if(pTstin->pcmLpbkTest.pcmLpbkEnabled)
  {
    return RC_NONE;
  }

  /* Store PCM Settings */
  pTstin->pcmLpbkTest.pcmModeSave = ProSLIC_ReadReg(pProslic,11); /* PCMMODE */


  /* Disable PCM bus before changing format */
  regData = pTstin->pcmLpbkTest.pcmModeSave & ~0x10; /* PCM_EN = 0 */
  ProSLIC_WriteReg(pProslic,11,regData);

  /* Configure for either 8 or 16bit linear */
  if(pTstin->pcmLpbkTest.pcm8BitLinear == PCM_8BIT)
  {
    regData |= 0x02;   /* PCM_FMT[1] = 1 */
    regData &= ~0x01;  /* PCM_FMT[0] = 0 */
  }
  else /* PCM_16BIT */
  {
    regData |= 0x03;  /* PCM_FMT[1:0] = 11 */
  }

  ProSLIC_WriteReg(pProslic,11,regData);

  /* Enable PCM Loopback */
  ProSLIC_WriteReg(pProslic,43,0x01);  /* LOOPBACK */

  /* Re-enable PCM Bus */
  ProSLIC_WriteReg(pProslic,11,regData|0x10);  /* PCMMODE */

  pTstin->pcmLpbkTest.pcmLpbkEnabled = 1;
  DEBUG_PRINT(pProslic, "ProSLIC : TestIn : pcmLpbk : ENABLED\n");
  return RC_NONE;
}

/* *********************************** */
int ProSLIC_testInPCMLpbkDisable(proslicChanType *pProslic,
                                 proslicTestInObjType *pTstin)
{
  uInt8 regData;

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if(!pTstin->pcmLpbkTest.testEnable)
  {
    return RC_TEST_DISABLED;
  }

  /* Return if already disabled */
  if(!pTstin->pcmLpbkTest.pcmLpbkEnabled)
  {
    return RC_NONE;
  }

  /* Disable PCM Bus */
  regData = ProSLIC_ReadReg(pProslic,11); /* PCMMODE */
  ProSLIC_WriteReg(pProslic,11,regData &= ~0x10);

  /* Disable PCM Loopback */
  ProSLIC_WriteReg(pProslic,43,0);

  /* Restore PCMMODE. Force disabled while changing format */
  ProSLIC_WriteReg(pProslic,11,pTstin->pcmLpbkTest.pcmModeSave &= ~0x10);
  ProSLIC_WriteReg(pProslic,11,pTstin->pcmLpbkTest.pcmModeSave);

  pTstin->pcmLpbkTest.pcmLpbkEnabled = 0;
  DEBUG_PRINT(pProslic, "ProSLIC : TestIn : pcmLpbk : DISABLED\n");
  return RC_NONE;
}

/* *************************************************** */

int ProSLIC_testInDCFeed(proslicChanType *pProslic,
                         proslicTestInObjType *pTstin)
{
  uInt8 enhanceRegSave;
  proslicMonitorType monitor;
  ramData lcroffhk_save = 0;
  ramData lcronhk_save = 0;

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if(!pTstin->dcFeedTest.testEnable)
  {
    return RC_TEST_DISABLED;
  }

  /* Invalidate last test results */
  pTstin->dcFeedTest.testDataValid = TSTIN_RESULTS_INVALID;

  /* Verify line not in use */
  if(ProSLIC_ReadReg(pProslic,34) & 0x02)  /* LCR */
  {
    DEBUG_PRINT(pProslic, "\nProSLIC : TestIn : DC Feed : Line in Use\n");

    if(pTstin->dcFeedTest.abortIfLineInUse==ABORT_LIU_ENABLED)
    {
      return RC_LINE_IN_USE;
    }
  }

  /* Disable Powersave */
  enhanceRegSave = ProSLIC_ReadReg(pProslic,47);
  ProSLIC_WriteReg(pProslic,47,0x20);
  Delay(pProTimer,10);

  /* Onhook measurement */
  ProSLIC_LineMonitor(pProslic,&monitor);

  pTstin->dcFeedTest.dcfeedVtipOnhook.value = monitor.vtip;
  pTstin->dcFeedTest.dcfeedVringOnhook.value = monitor.vring;
  pTstin->dcFeedTest.dcfeedVloopOnhook.value = monitor.vtr;
  pTstin->dcFeedTest.dcfeedVbatOnhook.value = monitor.vbat;
  pTstin->dcFeedTest.dcfeedItipOnhook.value = monitor.itip;
  pTstin->dcFeedTest.dcfeedIringOnhook.value = monitor.iring;
  pTstin->dcFeedTest.dcfeedIloopOnhook.value = monitor.itr;
  pTstin->dcFeedTest.dcfeedIlongOnhook.value = monitor.ilong;

  /* Modify LCR threshold (optional) before connecting test load */
  if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
  {
    lcroffhk_save = ProSLIC_ReadRAM(pProslic,852);
    lcronhk_save = ProSLIC_ReadRAM(pProslic,853);
    ProSLIC_WriteRAM(pProslic,852,pTstin->dcFeedTest.altLcrOffThresh);
    ProSLIC_WriteRAM(pProslic,853,pTstin->dcFeedTest.altLcrOnThresh);
  }

  /* Connect internal test load for 2nd dc feed i/v point */
  setInternalTestLoad(pProslic,1);
  Delay(pProTimer,50);
  /* Offhook measurement */
  ProSLIC_LineMonitor(pProslic,&monitor);

  pTstin->dcFeedTest.dcfeedVtipOffhook.value = monitor.vtip;
  pTstin->dcFeedTest.dcfeedVringOffhook.value = monitor.vring;
  pTstin->dcFeedTest.dcfeedVloopOffhook.value = monitor.vtr;
  pTstin->dcFeedTest.dcfeedVbatOffhook.value = monitor.vbat;
  pTstin->dcFeedTest.dcfeedItipOffhook.value = monitor.itip;
  pTstin->dcFeedTest.dcfeedIringOffhook.value = monitor.iring;
  pTstin->dcFeedTest.dcfeedIloopOffhook.value = monitor.itr;
  pTstin->dcFeedTest.dcfeedIlongOffhook.value = monitor.ilong;

  pTstin->dcFeedTest.testResult = RC_TEST_PASSED;  /* initialize */
  /* Read LCR */
  if(ProSLIC_ReadReg(pProslic,34) & 0x07)  /* LCRRTP */
  {
    pTstin->dcFeedTest.lcrStatus = 1;
  }
  else
  {
    pTstin->dcFeedTest.lcrStatus = 0;
  }

  /* Only fail check if enabled */
  if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
  {
    pTstin->dcFeedTest.testResult |= !pTstin->dcFeedTest.lcrStatus;
  }

  /* Disconnect Test Load */
  setInternalTestLoad(pProslic,0);

  /* Restore LCR thresholds */
  if(pTstin->dcFeedTest.applyLcrThresh == LCR_CHECK_ENABLED)
  {
    ProSLIC_WriteRAM(pProslic,852,lcroffhk_save);
    ProSLIC_WriteRAM(pProslic,853,lcronhk_save);
  }

  /* Restore enhance reg */
  ProSLIC_WriteReg(pProslic,47,enhanceRegSave);

  /* Process Results */
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVtipOnhook),"DcFeed : Vtip Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVringOnhook),"DcFeed : Vring Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVloopOnhook),"DcFeed : Vloop Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVbatOnhook),"DcFeed : Vbat Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedItipOnhook),"DcFeed : Itip Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIringOnhook),"DcFeed : Iring Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIloopOnhook),"DcFeed : Iloop Onhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIlongOnhook),"DcFeed : Ilong Onhook");

  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVtipOffhook),"DcFeed : Vtip Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVringOffhook),"DcFeed : Vring Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVloopOffhook),"DcFeed : Vloop Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedVbatOffhook),"DcFeed : Vbat Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedItipOffhook),"DcFeed : Itip Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIringOffhook),"DcFeed : Iring Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIloopOffhook),"DcFeed : Iloop Offhook");
  pTstin->dcFeedTest.testResult |= logTest(pProslic,
                                   &(pTstin->dcFeedTest.dcfeedIlongOffhook),"DcFeed : Ilong Offhook");

  logStatus(pProslic,pTstin->dcFeedTest.lcrStatus,"DcFeed : LCR");


  pTstin->dcFeedTest.testDataValid = 1;   /* New valid results */

  /* return cumulative pass/fail result */

  return (pTstin->dcFeedTest.testResult);
}

/* *********************************** */
int ProSLIC_testInRinging(proslicChanType *pProslic,
                          proslicTestInObjType *pTstin)
{
  uInt8 ringcon_save,enhance_save;
  int32 vtr[MAX_RINGING_SAMPLES];
  int i;
  uInt8 lf;
  uInt32 rtper_save, ringfr_save,ringamp_save,ringof_save,rtacth_save,rtdcth_save;
  ProSLIC_DCfeed_Cfg dcfeedCfg[1];

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if( (!pTstin->ringingTest.testEnable)
      || (pTstin->ringingTest.numSamples == 0) )
  {
    return RC_TEST_DISABLED;
  }

  /* Verify line not in use */
  if(ProSLIC_ReadReg(pProslic,34) & 0x02)  /* LCR */
  {
    DEBUG_PRINT(pProslic, "\nProSLIC : TestIn : Ringing : Line in Use\n");

    if(pTstin->ringingTest.abortIfLineInUse)
    {
      return RC_LINE_IN_USE;
    }
  }

  /* Invalidate last test results */
  pTstin->ringingTest.testDataValid = TSTIN_RESULTS_INVALID;

  /* Check sample size/rate */
  if(pTstin->ringingTest.numSamples > MAX_RINGING_SAMPLES)
  {
    pTstin->ringingTest.numSamples = MAX_RINGING_SAMPLES;
  }

  if(pTstin->ringingTest.sampleInterval > MAX_RINGING_SAMPLE_INTERVAL)
  {
    pTstin->ringingTest.sampleInterval = MAX_RINGING_SAMPLE_INTERVAL;
  }

  if(pTstin->ringingTest.sampleInterval < MIN_RINGING_SAMPLE_INTERVAL)
  {
    pTstin->ringingTest.sampleInterval = MIN_RINGING_SAMPLE_INTERVAL;
  }

  /* Disable Powersave */
  enhance_save = ProSLIC_ReadReg(pProslic,47);
  ProSLIC_WriteReg(pProslic,47,0x20);
  Delay(pProTimer,10);

  /* Disable ring cadencing */
  ringcon_save = ProSLIC_ReadReg(pProslic,38); /* RINGCON */
  ProSLIC_WriteReg(pProslic,38,ringcon_save&0xE7); /* RINGCON */

  /* Must enter ringing through active state */
  lf = ProSLIC_ReadReg(pProslic,30);  /* LINEFEED */
  ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
  Delay(pProTimer,20); /* settle */

  /* Start ringing */
  ProSLIC_SetLinefeedStatus(pProslic,LF_RINGING);
  Delay(pProTimer,500);

  /* Verify Ring Started */
  if(ProSLIC_ReadReg(pProslic,30) != 0x44)
  {
    ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
    ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
    ProSLIC_WriteReg(pProslic,38,ringcon_save);
    ProSLIC_WriteReg(pProslic,47,enhance_save);
    ProSLIC_SetLinefeedStatus(pProslic,lf);
    
    DEBUG_PRINT(pProslic, "ProSLIC : TestIn : Ringing : Ring Start Fail\n");

    pTstin->ringingTest.testResult = RC_TEST_FAILED;
    return RC_RING_START_FAIL;
  }

  /* Capture samples */
  pTstin->ringingTest.ringingVdc.value = 0;
  for(i=0; i<pTstin->ringingTest.numSamples; i++)
  {
    vtr[i] = ProSLIC_ReadMADCScaled(pProslic,69,0); /* VDIFF_FILT */
    pTstin->ringingTest.ringingVdc.value += vtr[i];

    DEBUG_PRINT(pProslic, "ProSLIC : TestIn : Ringing : Vtr[%d] = %d\n",i, (int)(vtr[i]));

    Delay(pProTimer,pTstin->ringingTest.sampleInterval);
  }

  /* Restore linefeed */
  ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
  Delay(pProTimer,20);

  /* Process Results */
  pTstin->ringingTest.ringingVdc.value /= pTstin->ringingTest.numSamples;
  for(i=0; i<pTstin->ringingTest.numSamples; i++)
  {
    vtr[i] -= pTstin->ringingTest.ringingVdc.value;
    pTstin->ringingTest.ringingVac.value += ((vtr[i]/100L) * (vtr[i]/100L));
  }


  pTstin->ringingTest.ringingVac.value /= pTstin->ringingTest.numSamples;
  pTstin->ringingTest.ringingVac.value = Isqrt32(
      pTstin->ringingTest.ringingVac.value);
  pTstin->ringingTest.ringingVac.value *= 100L;

  pTstin->ringingTest.testResult = RC_TEST_PASSED;
  pTstin->ringingTest.testResult |= logTest(pProslic,
                                    &(pTstin->ringingTest.ringingVdc),"Ringing : VDC");
  pTstin->ringingTest.testResult |= logTest(pProslic,
                                    &(pTstin->ringingTest.ringingVac),"Ringing : VAC");
  /*
  ** Optional Ringtrip Test
  */

  if(pTstin->ringingTest.ringtripTestEnable == RTP_CHECK_ENABLED)
  {
    /* Setup low voltage linefeed so low level ringing may be used */
    ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
    storeDCFeedPreset(pProslic,&(dcfeedCfg[0]),0);
    ProSLIC_DCFeedSetupCfg(pProslic,&(ringtripTestDCFeedPreset[0]),0);

    /* Optional Ringtrip Test (modified ringer settings to use test load to trip) */
    rtper_save = ProSLIC_ReadRAM(pProslic,755);
    ringfr_save = ProSLIC_ReadRAM(pProslic,844);
    ringamp_save = ProSLIC_ReadRAM(pProslic,845);
    ringof_save = ProSLIC_ReadRAM(pProslic,843);
    rtacth_save = ProSLIC_ReadRAM(pProslic,848);
    rtdcth_save = ProSLIC_ReadRAM(pProslic,847);

    ProSLIC_WriteRAM(pProslic,755,0x50000L);  /* RTPER */
    ProSLIC_WriteRAM(pProslic,844,0x7EFE000L);/* RINGFR */
    ProSLIC_WriteRAM(pProslic,845,0xD6307L);  /* RINGAMP */
    ProSLIC_WriteRAM(pProslic,843,0x0L);      /* RINGOF */
    ProSLIC_WriteRAM(pProslic,848,0x7827FL);  /* RTACTH */
    ProSLIC_WriteRAM(pProslic,847,0xFFFFFFFL);/* RTDCTH */

    /* Start ringing from active state */
    ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
    Delay(pProTimer,20);
    ProSLIC_SetLinefeedStatus(pProslic,LF_RINGING);
    Delay(pProTimer,200);

    /* Verify Ring Started */
    if(ProSLIC_ReadReg(pProslic,30) != 0x44)
    {
      ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
      ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
      ProSLIC_WriteReg(pProslic,38,ringcon_save);
      ProSLIC_WriteReg(pProslic,47,enhance_save);
      
      /* Restore DC Feed */
      ProSLIC_DCFeedSetupCfg(pProslic,&(dcfeedCfg[0]),0);

      /* Restore Ring Settings */
      ProSLIC_WriteRAM(pProslic,755,rtper_save); /* RTPER */
      ProSLIC_WriteRAM(pProslic,844,ringfr_save); /*RINGFR */
      ProSLIC_WriteRAM(pProslic,845,ringamp_save); /* RINGAMP */
      ProSLIC_WriteRAM(pProslic,843,ringof_save); /* RINGOF */
      ProSLIC_WriteRAM(pProslic,848,rtacth_save); /* RTACTH */
      ProSLIC_WriteRAM(pProslic,847,rtdcth_save); /* RTDCTH */
      
      ProSLIC_SetLinefeedStatus(pProslic,lf);

      DEBUG_PRINT(pProslic, "ProSLIC : TestIn : Ringtrip : Ring Start Fail\n");

      pTstin->ringingTest.testResult=RC_TEST_FAILED;
      return RC_RING_START_FAIL;
    }

    /* Connect Test Load to cause ringtrip */
    setInternalTestLoad(pProslic,1);
    Delay(pProTimer,200);

    /* Check for RTP */
    if(ProSLIC_ReadReg(pProslic,34) & 0x01)  /* LCRRTP */
    {
      pTstin->ringingTest.rtpStatus = 1;
      pTstin->ringingTest.testResult |= RC_TEST_PASSED;
    }
    else
    {
      pTstin->ringingTest.rtpStatus = 0;
      pTstin->ringingTest.testResult |= RC_TEST_FAILED;
      ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
    }
    setInternalTestLoad(pProslic,0);
    Delay(pProTimer,20);

    logStatus(pProslic,pTstin->ringingTest.rtpStatus,"Ringing : RTP");

    /* Restore DC Feed */
    ProSLIC_DCFeedSetupCfg(pProslic,&(dcfeedCfg[0]),0);

    /* Restore Ring Settings */
    ProSLIC_WriteRAM(pProslic,755,rtper_save);/* RTPER */
    ProSLIC_WriteRAM(pProslic,844,ringfr_save);/*RINGFR */
    ProSLIC_WriteRAM(pProslic,845,ringamp_save); /* RINGAMP */
    ProSLIC_WriteRAM(pProslic,843,ringof_save); /* RINGOF */
    ProSLIC_WriteRAM(pProslic,848,rtacth_save);/* RTACTH */
    ProSLIC_WriteRAM(pProslic,847,rtdcth_save);/* RTDCTH */

  }/* end of ringtrip test  */

  /* Restore Linefeed */
  ProSLIC_SetLinefeedStatus(pProslic,lf);

  /* Restore RINGCON and ENHANCE */
  ProSLIC_WriteReg(pProslic,38,ringcon_save);
  ProSLIC_WriteReg(pProslic,47,enhance_save);

  pTstin->ringingTest.testDataValid = TSTIN_RESULTS_VALID;

  return (pTstin->ringingTest.testResult);
}

/* *********************************** */
int ProSLIC_testInBattery(proslicChanType *pProslic,
                          proslicTestInObjType *pTstin)
{
  proslicMonitorType monitor;

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if(!pTstin->batteryTest.testEnable)
  {
    return RC_TEST_DISABLED;
  }

  /* Invalidate last test results */
  pTstin->batteryTest.testDataValid = TSTIN_RESULTS_INVALID;

  /* Measure Battery */
  ProSLIC_LineMonitor(pProslic,&monitor);

  pTstin->batteryTest.vbat.value = monitor.vbat;

  pTstin->batteryTest.testResult = logTest(pProslic,&(pTstin->batteryTest.vbat),
                                   "Battery : VBAT");

  pTstin->batteryTest.testDataValid =
    TSTIN_RESULTS_VALID;   /* New valid results */

  return (pTstin->batteryTest.testResult);
}

/* *********************************** */
int ProSLIC_testInAudio(proslicChanType *pProslic, proslicTestInObjType *pTstin)
{
  uInt8 enhanceRegSave;
  uInt8 lf;
  int32 data;
  int32 gainMeas1,gainMeas2;
  int32 gainMeas3 = 0;
  ProSLIC_audioGain_Cfg gainCfg;
  int32 Pin = -3980;   /* -10dBm + 6.02dB (since OHT w/ no AC load) */

  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  /* Check if enabled */
  if(!pTstin->audioTest.testEnable)
  {
    return RC_TEST_DISABLED;
  }

  /* Invalidate last test results */
  pTstin->audioTest.testDataValid = TSTIN_RESULTS_INVALID;

  /* Verify line not in use */
  if(ProSLIC_ReadReg(pProslic,34) & 0x02)  /* LCR */
  {
    DEBUG_PRINT(pProslic, "\nProSLIC : TestIn : Audio : Line in Use\n");

    if(pTstin->audioTest.abortIfLineInUse == ABORT_LIU_ENABLED)
    {
      return RC_LINE_IN_USE;
    }
  }

  /* Disable Powersave */
  enhanceRegSave = ProSLIC_ReadReg(pProslic,47);
  ProSLIC_WriteReg(pProslic,47,0x20);
  Delay(pProTimer,10);


  /* Setup Audio Filter, enable audio in OHT */
  lf = ProSLIC_ReadReg(pProslic,30);  /* LINEFEED */
  ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
  Delay(pProTimer,20); /* settle */
  setup1kHzBandpass(pProslic);
  ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_OHT);

  /* Setup osc1 for 1kHz -10dBm tone, disable hybrid, enable filters */
  ProSLIC_WriteRAM(pProslic,26,0x5A80000L); /* OSC1FREQ */
  ProSLIC_WriteRAM(pProslic,27,0x5D8000L);  /* OSC1AMP */
  ProSLIC_WriteReg(pProslic,48,0x02);       /* OMODE */
  ProSLIC_WriteReg(pProslic,49,0x01);       /* OCON */
  ProSLIC_WriteReg(pProslic,44,0x10);       /* DIGCON */
  ProSLIC_WriteReg(pProslic,71,0x10);       /* DIAG1 */

  /* Settle */
  Delay(pProTimer,800);

  /* Read first gain measurement (Gtx + Grx + Gzadj) */
  gainMeas1 = readAudioDiagLevel(pProslic,pTstin->audioTest.zerodBm_mVpk);

  /* Bypass TXACHPF and set TXACEQ to unity */
  gainCfg.acgain = ProSLIC_ReadRAM(pProslic,544);  /* TXACGAIN */
  gainCfg.aceq_c0 = ProSLIC_ReadRAM(pProslic,540); /* TXACEQ_C0 */
  gainCfg.aceq_c1 = ProSLIC_ReadRAM(pProslic,541); /* TXACEQ_C1 */
  gainCfg.aceq_c2 = ProSLIC_ReadRAM(pProslic,542); /* TXACEQ_C2 */
  gainCfg.aceq_c3 = ProSLIC_ReadRAM(pProslic,543); /* TXACEQ_C3 */
  ProSLIC_WriteRAM(pProslic,544,0x8000000L);
  ProSLIC_WriteRAM(pProslic,543,0x0L);
  ProSLIC_WriteRAM(pProslic,542,0x0L);
  ProSLIC_WriteRAM(pProslic,541,0x0L);
  ProSLIC_WriteRAM(pProslic,540,0x8000000L);
  ProSLIC_WriteReg(pProslic,44,0x18);

  /* Settle */
  Delay(pProTimer,800);

  /* Read second level measurement (RX level only) */
  gainMeas2 = readAudioDiagLevel(pProslic,pTstin->audioTest.zerodBm_mVpk);

  /* Adjust txgain if TXACGAIN wasn't unity during gainMeas1 */
  if(gainCfg.acgain != 0x8000000L)
  {
    data = (gainCfg.acgain*10)/134217;
    gainMeas3 = dBLookup(data);
  }

  /* Computations */
  pTstin->audioTest.rxGain.value = gainMeas2 - Pin;
  pTstin->audioTest.txGain.value = gainMeas1 - gainMeas2 + gainMeas3;

#ifdef ENABLE_DEBUG
  if( DEBUG_ENABLED(pProslic) )
  {
    LOGPRINT("ProSLIC : TestIn : Audio : gainMeas1 = %d\n", (int)gainMeas1);
    LOGPRINT("ProSLIC : TestIn : Audio : gainMeas2 = %d\n", (int)gainMeas2);
    LOGPRINT("ProSLIC : TestIn : Audio : gainMeas3 = %d\n", (int)gainMeas3);
  }
#endif
  pTstin->audioTest.testResult = RC_TEST_PASSED;
  pTstin->audioTest.testResult |= logTest(pProslic,&(pTstin->audioTest.rxGain),
                                          "RX Path Gain");
  pTstin->audioTest.testResult |= logTest(pProslic,&(pTstin->audioTest.txGain),
                                          "TX Path Gain");



  /*
  ** Restore
  */

  /* Need to store/restore all modified reg/RAM */
  ProSLIC_WriteRAM(pProslic,544,gainCfg.acgain);
  ProSLIC_WriteRAM(pProslic,540,gainCfg.aceq_c0);
  ProSLIC_WriteRAM(pProslic,541,gainCfg.aceq_c1);
  ProSLIC_WriteRAM(pProslic,542,gainCfg.aceq_c2);
  ProSLIC_WriteRAM(pProslic,543,gainCfg.aceq_c3);

  ProSLIC_WriteReg(pProslic,71,0x0);  /* DIAG1 */
  ProSLIC_WriteReg(pProslic,44,0x0);  /* DIGCON */
  ProSLIC_WriteReg(pProslic,48,0x0);  /* OMODE */
  ProSLIC_WriteReg(pProslic,49,0x0);  /* OCON */
  ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
  ProSLIC_WriteReg(pProslic,47,enhanceRegSave);
  ProSLIC_SetLinefeedStatus(pProslic,lf);

  /* Validate last test results */
  pTstin->audioTest.testDataValid = TSTIN_RESULTS_VALID;

  return pTstin->audioTest.testResult;
}


/* *********************************** */

int ProSLIC_testInPcmLpbkSetup(proslicTestInObjType *pTstin,
                               proslicPcmLpbkTest *pcmLpbkTest)
{
  pTstin->pcmLpbkTest = *pcmLpbkTest;
  pTstin->pcmLpbkTest.testEnable = 1;

  return RC_NONE;
}

/* *********************************** */

int ProSLIC_testInDcFeedSetup(proslicTestInObjType *pTstin,
                              proslicDcFeedTest *dcFeedTest)
{
  pTstin->dcFeedTest = *dcFeedTest;
  pTstin->dcFeedTest.testEnable = 1;

  return RC_NONE;
}

/* *********************************** */

int ProSLIC_testInRingingSetup(proslicTestInObjType *pTstin,
                               proslicRingingTest *ringingTest)
{
  /* Copy limits per-channel */

  pTstin->ringingTest = *ringingTest;
  pTstin->ringingTest.testEnable = 1;

  return RC_NONE;
}
/* *********************************** */

int ProSLIC_testInBatterySetup(proslicTestInObjType *pTstin,
                               proslicBatteryTest *batteryTest)
{
  /* Copy limits per-channel */

  pTstin->batteryTest = *batteryTest;
  pTstin->batteryTest.testEnable = 1;

  return RC_NONE;
}

/* *********************************** */

int ProSLIC_testInAudioSetup(proslicTestInObjType *pTstin,
                             proslicAudioTest *audioTest)
{
  /* Copy limits per-channel */

  pTstin->audioTest = *audioTest;
  pTstin->audioTest.testEnable = 1;

  return RC_NONE;
}


/* *********************************** */
int ProSLIC_testInPrintLimits(proslicChanType *pProslic,
                              proslicTestInObjType *pTstin)
{
  /* Valid device check */
  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }
#ifdef ENABLE_DEBUG
  if( DEBUG_ENABLED(pProslic ) )
  {
    LOGPRINT("\n");
    LOGPRINT("************   Test-In Test Limits **************\n");
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("ProSLIC : Test-In : Limits : vtip_on_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVtipOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vtip_on_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVtipOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vring_on_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVringOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vring_on_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVringOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vloop_on_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVloopOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vloop_on_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVloopOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vbat_on_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVbatOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vbat_on_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVbatOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : itip_on_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedItipOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : itip_on_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedItipOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iring_on_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIringOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iring_on_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIringOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iloop_on_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIloopOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iloop_on_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIloopOnhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ilong_on_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIlongOnhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ilong_on_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIlongOnhook.upperLimit));
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("ProSLIC : Test-In : Limits : vtip_off_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVtipOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vtip_off_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVtipOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vring_off_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVringOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vring_off_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVringOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vloop_off_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVloopOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vloop_off_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVloopOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vbat_off_min (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVbatOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : vbat_off_max (mv) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedVbatOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : itip_off_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedItipOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : itip_off_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedItipOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iring_off_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIringOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iring_off_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIringOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iloop_off_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIloopOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : iloop_off_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIloopOffhook.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ilong_off_min (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIlongOffhook.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ilong_off_max (ua) = %d\n",
             (int)(pTstin->dcFeedTest.dcfeedIlongOffhook.upperLimit));
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("ProSLIC : Test-In : Limits : ringing_vac_min (mv) = %d\n",
             (int)(pTstin->ringingTest.ringingVac.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ringing_vac_max (mv) = %d\n",
             (int)(pTstin->ringingTest.ringingVac.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ringing_vdc_min (mv) = %d\n",
             (int)(pTstin->ringingTest.ringingVdc.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : ringing_vdc_max (mv) = %d\n",
             (int)(pTstin->ringingTest.ringingVdc.upperLimit));
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("ProSLIC : Test-In : Limits : battery_vbat_min (mv) = %d\n",
             (int)(pTstin->batteryTest.vbat.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : battery_vbat_max (mv) = %d\n",
             (int)(pTstin->batteryTest.vbat.upperLimit));
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("ProSLIC : Test-In : Limits : audio_txgain_min (mdB) = %d\n",
             (int)(pTstin->audioTest.txGain.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : audio_txgain_max (mdB) = %d\n",
             (int)(pTstin->audioTest.txGain.upperLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : audio_rxgain_min (mdB) = %d\n",
             (int)(pTstin->audioTest.rxGain.lowerLimit));
    LOGPRINT("ProSLIC : Test-In : Limits : audio_rxgain_max (mdB) = %d\n",
             (int)(pTstin->audioTest.rxGain.upperLimit));
    LOGPRINT("----------------------------------------------------------------\n");
    LOGPRINT("\n");
  }
#else
  SILABS_UNREFERENCED_PARAMETER(pTstin);
#endif
  return RC_NONE;
}


static ProSLIC_DCfeed_Cfg testLoad_DC_Cfg[] =
{
  {
  0x1DC6E1D3L,  /* SLOPE_VLIM */
  0x1F909679L,   /* SLOPE_RFEED */
  0x0040A0E0L,   /* SLOPE_ILIM */
  0x1B8687BBL,  /* SLOPE_DELTA1 */
  0x1CC4B75DL,  /* SLOPE_DELTA2 */
  0x05A38633L,   /* V_VLIM (48.000 v) */
  0x050D2839L,   /* V_RFEED (43.000 v) */
  0x03FE7F0FL,   /* V_ILIM  (34.000 v) */
  0x009DAFD9L, /* CONST_RFEED (10.000 mA) */
  0x0045CBBCL,  /* CONST_ILIM (15.000 mA) */
  0x002D8D96L,  /* I_VLIM (0.000 mA) */
  0x005B0AFBL,  /* LCRONHK (10.000 mA) */
  0x006D4060L,   /* LCROFFHK (12.000 mA) */
  0x00008000L,   /* LCRDBI (5.000 ms) */
  0x0048D595L,   /* LONGHITH (8.000 mA) */
  0x003FBAE2L,  /* LONGLOTH (7.000 mA) */
  0x00008000L,   /* LONGDBI (5.000 ms) */
  0x000F0000L,   /* LCRMASK (150.000 ms) */
  0x00080000L,   /* LCRMASK_POLREV (80.000 ms) */
  0x00140000L,   /* LCRMASK_STATE (200.000 ms) */
  0x00140000L,   /* LCRMASK_LINECAP (200.000 ms) */
  0x01BA5E35L,  /* VCM_OH (27.000 v) */
  0x0051EB85L,   /* VOV_BAT (5.000 v) */
  0x00418937L,   /* VOV_GND (4.000 v) */
  }
};

/* *********************************** */
int ProSLIC_testLoadTest(
  SiVoiceChanType_ptr pProslic, 
  BOOLEAN is_testStart, 
  uint32_t timeDelayMsec)
{
  static ProSLIC_DCfeed_Cfg dcfeedCfg;
  static uInt8 digcon_reg_cache;

  TRACEPRINT(pProslic, " channel: %u is_testStart: %u delay = %u",
    pProslic->channel, 
    is_testStart,
    timeOffhookMsec);
  /* Valid device check */

  if(TSTIN_INVALID_PART_NUM)
  {
    return RC_UNSUPPORTED_FEATURE;
  }

  if( TRUE == is_testStart )
  {
    /* Verify line not in use */
    if(ProSLIC_ReadReg(pProslic,PROSLIC_REG_LCRRTP) & 0x02)  /* LCR */
    {
      DEBUG_PRINT(pProslic, "\nLine in Use: %u.\n", pProslic->channel);
      return RC_LINE_IN_USE;
    }
   
    /* Setup lower ILIM linefeed */
    ProSLIC_SetLinefeedStatus(pProslic,LF_OPEN);
    storeDCFeedPreset(pProslic, &dcfeedCfg, 0);

    ProSLIC_DCFeedSetupCfg( pProslic, testLoad_DC_Cfg, 0 ); 

    ProSLIC_SetLinefeedStatus(pProslic,LF_FWD_ACTIVE);
    Delay(pProTimer,100);
  
    /* Connect Test Load to cause LCR interrupt*/
    setInternalTestLoad(pProslic,1);
    Delay(pProTimer, timeDelayMsec);
    DEBUG_PRINT(pProslic, "\n%s: test load on for channel %u\n", 
      __FUNCTION__, pProslic->channel);
  
    /* Disable hybrid circuit for test load loopback */
    digcon_reg_cache = ProSLIC_ReadReg(pProslic,PROSLIC_REG_DIGCON);

    ProSLIC_WriteReg(pProslic, PROSLIC_REG_DIGCON,
      digcon_reg_cache |0x10 );

    /* At this point the test load should of caused a LCR interrupt and
       there is an audio path available. NOTE: there may be some distortion
       of the audio...
    */
    
  }
  else
  {
    /* Restore hybrid circuit */
    ProSLIC_WriteReg(pProslic,
      PROSLIC_REG_DIGCON, digcon_reg_cache );
 
    /* Disconnect Test Load */
    setInternalTestLoad(pProslic,0);
    Delay(pProTimer, timeDelayMsec);
    DEBUG_PRINT(pProslic, "\n%s: test load off for channel %u.\n",
      __FUNCTION__, pProslic->channel);
  
   /* Restore DC Feed */
   ProSLIC_DCFeedSetupCfg(pProslic, &dcfeedCfg, 0);
  }

  return RC_NONE;
}