diff options
Diffstat (limited to 'data/mnet/GP10/Host/grr')
23 files changed, 7907 insertions, 0 deletions
diff --git a/data/mnet/GP10/Host/grr/Makefile b/data/mnet/GP10/Host/grr/Makefile new file mode 100644 index 0000000..69aaecb --- /dev/null +++ b/data/mnet/GP10/Host/grr/Makefile @@ -0,0 +1,16 @@ +##########################################################
+#
+# (c) Copyright Cisco 2000
+# All Rights Reserved
+#
+##########################################################
+
+SUBDIRS= src src_api src_init
+
+# TOP_OF_VOB must be defined before including l3defs.mk
+TOP_OF_VOB = ..\..
+
+include $(TOP_OF_VOB)\l3defs.mk
+
+copyall:
+ $(CP) bin\*.out $(TOP_OF_VOB)\bin\*.out
\ No newline at end of file diff --git a/data/mnet/GP10/Host/grr/src/Makefile b/data/mnet/GP10/Host/grr/src/Makefile new file mode 100644 index 0000000..b628614 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/Makefile @@ -0,0 +1,52 @@ +##########################################################
+#
+# (c) Copyright Cisco 2000
+# All Rights Reserved
+#
+##########################################################
+
+# TOP_OF_VOB must be defined before including l3defs.mk
+TOP_OF_VOB = ..\..\..
+
+# These Must be Properly Defined
+THIS_APP_DIR = grr
+THIS_DIRECTORY = Src
+MY_OUTPUT = $(OBJDIR)\grr.out
+
+# Name(s) of Common VOB directories to include
+COMMON_BLD_DIR =
+
+include $(TOP_OF_VOB)\l3defs.mk
+
+all: makeCommonObjs $(MY_OUTPUT)
+
+# Adds the .o file(s) list needed from the Common VOB
+makeCommonObjs:
+ifneq ($(COMMON_BLD_DIR),)
+ @for %f in ($(COMMON_BLD_DIR)) do \
+ make -C $(COMMON_VOB_APP_DIR)\%f \
+ all VOB=$(VOBNAME) APPDIR=Host\$(THIS_APP_DIR)\$(THIS_DIRECTORY)
+endif
+
+# If Common VOB directories to include get the .o files from bin
+$(MY_OUTPUT): $(MODULE_OBJS)
+ifneq ($(COMMON_BLD_DIR),)
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS) $(wildcard ./bin/*.o)
+else
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS)
+endif
+ $(NM) $@.tmp | munch > _ctdt.c
+ $(CC) -traditional $(CC_ARCH_SPEC) -c _ctdt.c
+ $(LD) -r -o $@ _ctdt.o $@.tmp
+ $(RM)$(subst /,$(DIRCHAR), _ctdt.c _ctdt.o $@.tmp)
+
+cleanall:
+ @for %f in ($(notdir $(MODULE_OBJS))) do \
+ $(RM) ..\bin\%f
+
+ $(RM) $(MY_OUTPUT)
+
+ifneq ($(COMMON_BLD_DIR),)
+ $(RM) bin\*.o
+ $(RM) bin\*.out
+endif
\ No newline at end of file diff --git a/data/mnet/GP10/Host/grr/src/grr_DspUtil.cpp b/data/mnet/GP10/Host/grr/src/grr_DspUtil.cpp new file mode 100644 index 0000000..08e127a --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_DspUtil.cpp @@ -0,0 +1,237 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_DSPUTIL_CPP__
+#define __GRR_DSPTTIL_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_FirstRadioCtrl(void)
+{
+ int i;
+
+ DBG_FUNC("grr_FirstRadioCtrl", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ switch(OAMgrr_TRX_AMSTATE(i))
+ {
+ case unlocked:
+ grr_TuneTrxSynth(i,GRR_ON);
+ break;
+ case locked:
+ grr_SubmitAlarm(grr_TrxAmStateLockedAlarmCode[i]);
+ break;
+ case shuttingDown:
+ default:
+ DBG_WARNING("grr_FirstRadioCtrl: trx(%d) initialization failed due to improper amState(%d)\n",
+ i, OAMgrr_TRX_AMSTATE(i));
+ printf("grr_FirstRadioCtrl: trx(%d) initialization failed due to improper amState(%d)\n",
+ i, OAMgrr_TRX_AMSTATE(i));
+ if (OAMgrr_TRX_AMSTATE(i)==shuttingDown)
+ grr_SubmitAlarm(grr_TrxAmStateShuttingdownAlarmCode[i]);
+ else
+ grr_SubmitAlarm(grr_TrxAmStateInvalidAlarmCode[i]);
+
+ assert(0);
+ break;
+ }
+ }
+ DBG_LEAVE();
+}
+
+void grr_RadioCtrl(unsigned char pwr)
+{
+ int i;
+
+ DBG_FUNC("grr_RadioCtrl", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_RadioCtrl: set radio power(%d)\n", pwr);
+
+ if (pwr>1)
+ {
+ DBG_WARNING("grr_RadioCtrl: invalid radio power setting(%d)\n", pwr);
+ DBG_LEAVE();
+ return;
+ }
+
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ grr_TuneTrxSynth(i,pwr);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_TuneTrxSynth(unsigned char trx, unsigned char pwr)
+{
+ DBG_FUNC("grr_TuneTrxSynth", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_TuneTrxSynth: set power(%d) for trx(%d)\n", pwr, trx);
+
+ //Apply sanitary check
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_TuneTrxSynth: invalid trx(%d)\n", trx);
+ DBG_LEAVE();
+ }
+
+ grr_SendDspArfcn(trx, OAMgrr_BCCH_CARRIER_phTRX);
+
+ switch(trx)
+ {
+ case 0:
+ if (OAMgrr_BCCH_CARRIER_phTRX)
+ { //phTRX 1 as bcch carrier trx ie trx-es swapped scenario
+ grr_SendDspTuneSynth(0, 0, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(0));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ } else
+ { //phTRX 0 as bcch carrier trx ie trx-es non-swapped scenario
+ grr_SendDspTuneSynth(1, 0, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(0));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ grr_SendDspTuneSynth(1, 1, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(0));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ }
+ break;
+ case 1:
+ if (OAMgrr_BCCH_CARRIER_phTRX)
+ { //phTRX 1 as bcch carrier trx ie trx-es swapped scenario
+ grr_SendDspTuneSynth(1, 0, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(1));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ grr_SendDspTuneSynth(1, 1, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(1));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ } else
+ { //phTRX 0 as bcch carrier trx ie trx-es non-swapped scenario
+ grr_SendDspTuneSynth(0, 0, OAMgrr_HOPPING_CTRL, pwr, OAMgrr_ARFCN(1));
+ //phTRX, syth, Hopping, pwrSetting, trxPackage
+ }
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+
+void grr_StartDspsWatch(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_StartDspsWatch", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //Start keep-alive watch dogs
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ grr_InitDspWdog(i);
+ grr_StartDspWdog(i);
+ grr_SendDspPing(i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_InitDspWdog(unsigned char dsp)
+{
+ int i;
+ WDOG_ID timer_id;
+
+ DBG_FUNC("grr_InitDspWdog", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //Create watch dog timer for the trx
+ if ( (timer_id=wdCreate()) == NULL )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_WDCREATE_FAILED);
+ DBG_ERROR("grr_InitDspWdog:failed to create dsp(%d) watch dog timer\n", dsp);
+ printf("grr_InitDspWdog:failed to create dsp(%d) watch dog timer\n", dsp);
+ assert(0);
+ }
+ grr_TrxMgmt[dsp].wdog.timer_id = timer_id;
+ grr_TrxMgmt[dsp].wdog.time = OAMgrr_WDOG_TIME;
+ grr_TrxMgmt[dsp].wdog.state = false;
+
+ DBG_LEAVE();
+}
+
+
+//Start DSP watch dog
+void grr_StartDspWdog(unsigned char dsp)
+{
+ DBG_FUNC("grr_StartDspWdog", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ if ( ERROR == (wdStart(grr_TrxMgmt[dsp].wdog.timer_id,
+ OAMgrr_WDOG_TIME,(FUNCPTR)grr_ProcDspWdogExpired,
+ ((dsp<<8)|GRR_WDOG) ) ) )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_WDSTART_FAILED);
+ DBG_ERROR("grr_StartDspWdog:failed to call wdstart for dsp(%d) wdog timerId(%x) errno(%d)\n",
+ dsp, grr_TrxMgmt[dsp].wdog.timer_id, errno);
+ printf("grr_StartDspWdog:failed to call wdstart for dsp(%d) wdog timerId(%x) errno(%d)\n",
+ dsp, grr_TrxMgmt[dsp].wdog.timer_id, errno);
+
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+
+int grr_ProcDspWdogExpired(int param)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_ProcDspWdogExpired", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ grr_ItcRxGrrMsg_t msg;
+
+ msg.module_id = MODULE_GRR;
+ msg.primitive_type = GRR_DSP_WDOG_EXPIRED;
+ msg.trx = (unsigned char)(param>>8);
+ msg.timer_id = (unsigned char)(param);
+
+ //
+ if (STATUS_OK != (ret = msgQSend(grr_MsgQId, (char*)&msg, GRR_MAX_GRRMSG_LEN,
+ NO_WAIT, MSG_PRI_NORMAL) ) )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQSEND_FAILED);
+ DBG_ERROR("grr_ProcDspWdogExpired: msgQSend failed Q(%x) ret(%d) errno(%d) dsp(%d) timer(%d)\n",
+ grr_MsgQId, ret, errno, (unsigned char)(param>>8), (unsigned char)(param));
+ printf("grr_ProcDspWdogExpired: msgQSend failed Q(%x) ret(%d) errno(%d) dsp(%d) timer(%d)\n",
+ grr_MsgQId, ret, errno, (unsigned char)(param>>8), (unsigned char)(param));
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+//Acitvate the given trx and slot
+void grr_ActTrxSlot(unsigned char trx, unsigned char slot)
+{
+ DBG_FUNC("grr_ActTrxSlot", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //safeguard only
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_ActTrxSlot: invalid time slot trx(%d) slot(%d)\n",
+ trx, slot);
+ } else
+ //Activate the given trx and slot
+ grr_SendDspSlotActivate(trx,slot);
+
+ DBG_LEAVE();
+}
+
+
+#endif //__GRR_DSPUTIL_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_GetOamMib.cpp b/data/mnet/GP10/Host/grr/src/grr_GetOamMib.cpp new file mode 100644 index 0000000..becf205 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_GetOamMib.cpp @@ -0,0 +1,592 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_GETOAMMIB_CPP__
+#define __GRR_GETOAMMIB_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_GetOamBtsBasicPackage(void)
+{
+ int i;
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsBasicPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get the bts basic package structure first
+ ret = getMibStruct(MIB_btsBasicPackage, (unsigned char*)&grr_OamData.btsBasicPackage,
+ sizeof(BtsBasicPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsBasicPackage: getMibStruct failed to get btsBasicPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsBasicPackage: getMibStruct failed to get btsBasicPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ // step 2: get the cell allocation table
+ ret = getMibTbl(MIBT_cellAllocationEntry, (void *) &cellAllocationTable,
+ sizeof(cellAllocationTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsBasicPackage: getMibTbl failed to get cell allocation table err(%d)\n", ret);
+ printf("grr_GetOamBtsBasicPackage: getMibTbl failed to get cell allocation table err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.btsBasicPackage.cellAllocationTable= (Table *) &cellAllocationTable;
+
+ //step 3: get plmnPermitted Table
+ ret = getMibTbl(MIBT_plmnPermittedEntry, (void *) &plmnPermittedTable,
+ sizeof(plmnPermittedTable));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsBasicPackage: getMibTbl failed to get plmnPermittedTable err(%d)\n", ret);
+ printf("grr_GetOamBtsBasicPackage: getMibTbl failed to get plmnPermittedTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.btsBasicPackage.plmnPermittedTable= (Table *) &plmnPermittedTable;
+
+ // Convert mcc to byte string
+ getByteAryByInt( grr_OamData.btsBasicPackage.bts_mcc,
+ (char*)&grr_OamData.btsBasicPackage.bts_mcc, 3);
+
+ // get mnc directly via oam api kevinlim 05/11/01
+ oam_getMnc((UINT8 *)&grr_OamData.btsBasicPackage.bts_mnc);
+
+ // Convert rach control parameters from GUI form to internal form
+ //
+
+ //maxNumberRetransmissions
+ i = grr_OamData.btsBasicPackage.maxNumberRetransmissions;
+ if (i==1) grr_OamData.btsBasicPackage.maxNumberRetransmissions=0;
+ else if (i==2) grr_OamData.btsBasicPackage.maxNumberRetransmissions=1;
+ else if (i==4) grr_OamData.btsBasicPackage.maxNumberRetransmissions=2;
+ else if (i==7) grr_OamData.btsBasicPackage.maxNumberRetransmissions=3;
+ else
+ {
+ DBG_WARNING("grr_GetOamBtsBasicPackage: invalid maxNumberRetransmissions(%d)\n",i);
+ grr_OamData.btsBasicPackage.maxNumberRetransmissions=3; //default to 3
+ }
+
+ //Tx Integer
+ grr_OamData.btsBasicPackage.numberOfSlotsSpreadTrans -= 3;
+
+ //noOfMultiframesBetweenPaging
+ grr_OamData.btsBasicPackage.noOfMultiframesBetweenPaging -= 2;
+
+ switch(OAMgrr_GSMDCS_INDICATOR)
+ {
+ case 0: //GSM900
+ if (OAMgrr_MS_TX_PWR_MAX_CCH <=39 && OAMgrr_MS_TX_PWR_MAX_CCH >=5)
+ {
+ i = OAMgrr_MS_TX_PWR_MAX_CCH/2;
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 21 - i;
+ } else
+ {
+ DBG_WARNING("grr_GetOamBtsBasicPackage: radioSystem(%d) mSTxPwrMaxCch (%d)\n",
+ OAMgrr_GSMDCS_INDICATOR,
+ OAMgrr_MS_TX_PWR_MAX_CCH);
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 7; //29dBm
+ }
+ break;
+
+ case 1: //DCS1800
+ if ( (OAMgrr_MS_TX_PWR_MAX_CCHa<=30) && (OAMgrr_MS_TX_PWR_MAX_CCHa>=0) )
+ {
+ i = OAMgrr_MS_TX_PWR_MAX_CCH/2;
+ //Not needed now
+ //if (OAMgrr_MS_PWR_OFFSET>=0 && OAMgrr_MS_PWR_OFFSET<=6)
+ //{
+ // OAMgrr_MS_PWR_OFFSETa = OAMgrr_MS_PWR_OFFSET/2;
+ //} else
+ // OAMgrr_MS_PWR_OFFSETa = 0;
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 15 - i;
+ } else
+ {
+ DBG_WARNING("grr_GetOamBtsBasicPackage: radioSystem(%d) mSTxPwrMaxCch (%d)\n",
+ OAMgrr_GSMDCS_INDICATOR,
+ OAMgrr_MS_TX_PWR_MAX_CCHa);
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 3; //24dBm
+ //Not needed now
+ //OAMgrr_MS_PWR_OFFSETa = 0;
+ }
+ break;
+
+ case 2: //PCS1900
+ if (OAMgrr_MS_TX_PWR_MAX_CCH == 32)
+ {
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 31; //32dBm
+ } else if (OAMgrr_MS_TX_PWR_MAX_CCH == 33)
+ {
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 31; //33dBm
+ } else if ((OAMgrr_MS_TX_PWR_MAX_CCHa<=30) && (OAMgrr_MS_TX_PWR_MAX_CCHa>=0))
+ {
+ i = OAMgrr_MS_TX_PWR_MAX_CCH/2;
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 15 - i;
+ } else
+ {
+ DBG_WARNING("grr_GetOamBtsBasicPackage: radioSystem(%d) mSTxPwrMaxCch (%d)\n",
+ OAMgrr_GSMDCS_INDICATOR,
+ OAMgrr_MS_TX_PWR_MAX_CCH);
+ OAMgrr_MS_TX_PWR_MAX_CCH = 3; //24dBm
+ }
+ break;
+
+ default: //Assume a proper value but give debug information
+ DBG_WARNING("grr_GetOamBtsBasicPackage: radioSystem(%d) mSTxPwrMaxCch (%d)\n",
+ OAMgrr_GSMDCS_INDICATOR,
+ OAMgrr_MS_TX_PWR_MAX_CCH);
+ OAMgrr_MS_TX_PWR_MAX_CCHa = 7;
+ //Not needed now
+ //OAMgrr_MS_PWR_OFFSETa = 0;
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamBtsOptionPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsOptionPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get btsOptionsPackage structure first
+ ret = getMibStruct(MIB_btsOptionsPackage, (unsigned char*)&grr_OamData.btsOptionsPackage,
+ sizeof(BtsOptionsPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsOptionPackage: getMibStruct failed to get btsOptionsPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsOptionPackage: getMibStruct failed to get btsOptionsPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ // step 2: get notAllowedAccessClassTable table
+ ret = getMibTbl(MIBT_notAllowedAccessClassEntry, (void *) ¬AllowedAccessClassTable ,
+ sizeof(notAllowedAccessClassTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsOptionPackage: getMibTbl failed to get notAllowedAccessClassTable err(%d)\n", ret);
+ printf("grr_GetOamBtsOptionPackage: getMibTbl failed to get notAllowedAccessClassTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.btsOptionsPackage.notAllowedAccessClassTable= (Table *) ¬AllowedAccessClassTable;
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamBtsFirstTrxPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsFirstTrxPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get transceiverPackage structure first
+ ret = getMibStruct(MIB_firstTransceiverPackage, (unsigned char*)&grr_OamData.transceiverPackage[0],
+ sizeof(FirstTransceiverPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsFirstTrxPackage: getMibStruct failed to get firstTransceiverPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsFirstTrxPackage: getMibStruct failed to get firstTransceiverPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ // step 2: get Channel Table
+ ret = getMibTbl(MIBT_channel_0_Entry, (void *) &firstTrxPackageChannelTable ,
+ sizeof(firstTrxPackageChannelTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsFirstTrxPackage: getMibTbl failed to get firstTrxPackageChannelTable err(%d)\n", ret);
+ printf("grr_GetOamBtsFirstTrxPackage: getMibTbl failed to get firstTrxPackageChannelTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.transceiverPackage[0].channelTable= (Table *) &firstTrxPackageChannelTable;
+
+ DBG_LEAVE();
+
+}
+
+void grr_GetOamBtsSecondTrxPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsSecondTrxPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get transceiverPackage structure first
+ ret = getMibStruct(MIB_secondTransceiverPackage, (unsigned char*)&grr_OamData.transceiverPackage[1],
+ sizeof(SecondTransceiverPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsSecondTrxPackage: getMibStruct failed to get secondTransceiverPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsSecondTrxPackage: getMibStruct failed to get secondTransceiverPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ // step 2: get the Channel Table
+ ret = getMibTbl(MIBT_channel_1_Entry, (void *) &secondTrxPackageChannelTable ,
+ sizeof(secondTrxPackageChannelTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsSecondTrxPackage: getMibTbl failed to get secondTrxPackageChannelTable err(%d)\n", ret);
+ printf("grr_GetOamBtsSecondTrxPackage: getMibTbl failed to get secondTrxPackageChannelTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.transceiverPackage[1].channelTable= (Table *) &secondTrxPackageChannelTable;
+
+ DBG_LEAVE();
+
+}
+
+void grr_GetOamBtsFirstRadioCarrierPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsFirstRadioCarrierPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get the 2nd Radio Carrier Package first
+ ret = getMibStruct(MIB_firstRadioCarrierPackage, (unsigned char*) &grr_OamData.radioCarrierPackage[0],
+ sizeof(FirstRadioCarrierPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsFirstRadioCarrierPackage: getMibStruct failed to get firstRadioCarrierPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsFirstRadioCarrierPackage: getMibStruct failed to get firstRadioCarrierPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ //step 2: get the radio frequency list for the first carrier package
+ ret = getMibTbl(MIBT_carrierFrequency_0_Entry, (void *) &firstRadioCarrierPackageFrequencyListTable ,
+ sizeof(firstRadioCarrierPackageFrequencyListTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsFirstRadioCarrierPackage: getMibTbl failed to get firstRadioCarrierPackageFrequencyListTable err(%d)\n", ret);
+ printf("grr_GetOamBtsFirstRadioCarrierPackage: getMibTbl failed to get firstRadioCarrierPackageFrequencyListTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.radioCarrierPackage[0].carrierFrequencyList= (Table *) &firstRadioCarrierPackageFrequencyListTable;
+
+ DBG_LEAVE();
+
+}
+
+void grr_GetOamBtsSecondRadioCarrierPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamBtsSecondRadioCarrierPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get the 2nd Radio Carrier Package first
+ ret = getMibStruct(MIB_secondRadioCarrierPackage, (unsigned char*) &grr_OamData.radioCarrierPackage[1],
+ sizeof(SecondRadioCarrierPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsSecondRadioCarrierPackage: getMibStruct failed to get secondRadioCarrierPackage err(%d)\n", ret);
+ printf("grr_GetOamBtsSecondRadioCarrierPackage: getMibStruct failed to get secondRadioCarrierPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ //step 2: get the radio frequency list for the first carrier package
+ ret = getMibTbl(MIBT_carrierFrequency_1_Entry, (void *) &secondRadioCarrierPackageFrequencyListTable ,
+ sizeof(secondRadioCarrierPackageFrequencyListTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamBtsSecondRadioCarrierPackage: getMibTbl failed to get secondRadioCarrierPackageFrequencyListTable err(%d)\n", ret);
+ printf("grr_GetOamBtsSecondRadioCarrierPackage: getMibTbl failed to get secondRadioCarrierPackageFrequencyListTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.radioCarrierPackage[1].carrierFrequencyList= (Table *) &secondRadioCarrierPackageFrequencyListTable;
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamT31xxTimerStructure(void)
+{
+ STATUS ret;
+ int msPerTick;
+
+ DBG_FUNC("grr_GetOamT31xxTimerStructure", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ ret = getMibStruct(MIB_t31xxPackage, (unsigned char*)&grr_OamData.t31xx,
+ sizeof(T31xx));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamT31xxTimerStructure: getMibStruct failed to get t31xx err(%d)\n", ret);
+ printf("grr_GetOamT31xxTimerStructure: getMibStruct failed to get t31xx err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ msPerTick = 1000/sysClkRateGet();
+ grr_OamData.t31xx.t3101 = (grr_OamData.t31xx.t3101*10)/msPerTick;
+ grr_OamData.t31xx.t3105 = (grr_OamData.t31xx.t3105*10)/msPerTick;
+ grr_OamData.t31xx.t3109 = (grr_OamData.t31xx.t3109*10)/msPerTick;
+ grr_OamData.t31xx.t3111 = (grr_OamData.t31xx.t3111*10)/msPerTick;
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamAdjacentCellPackage(void)
+{
+ STATUS ret;
+ int i,j;
+
+ DBG_FUNC("grr_GetOamAdjacentCellPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //step 1: get adjacent cell Package first
+ ret = getMibStruct(MIB_adjacentCellPackage, (unsigned char*)&grr_OamData.adjacentCellPackage,
+ sizeof(AdjacentCellPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamAdjacentCellPackage: getMibStruct failed to get adjacentCellPackage err(%d)\n", ret);
+ printf("grr_GetOamAdjacentCellPackage: getMibStruct failed to get adjacentCellPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ //step 2: get handover table list
+ ret = getMibTbl(MIBT_adjCell_handoverEntry, (void *) &adjCell_HandoverTable,
+ sizeof(adjCell_HandoverTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamAdjacentCellPackage: getMibTbl failed to get adjCell_HandoverTable err(%d)\n", ret);
+ printf("grr_GetOamAdjacentCellPackage: getMibTbl failed to get adjCell_HandoverTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.adjacentCellPackage.adjCell_handoverTable= (Table *) &adjCell_HandoverTable;
+
+ //Compress all empty rows in the handover adjacent cell table
+ i=0;
+ while (i<OAMgrr_HO_ADJCELL_NO_MAX)
+ {
+ if (OAMgrr_HO_ADJCELL_ID(i)==OAMgrr_HO_ADJCELL_ID_NULL)
+ {
+ for (j=i+1;j<OAMgrr_HO_ADJCELL_NO_MAX;j++)
+ {
+ if (OAMgrr_HO_ADJCELL_ID(j) != OAMgrr_HO_ADJCELL_ID_NULL)
+ {
+ memcpy(&adjCell_HandoverTable[i], &adjCell_HandoverTable[j],
+ sizeof(AdjCell_HandoverEntry));
+ adjCell_HandoverTable[i].adjCell_handoverIndex=i;
+ memset(&adjCell_HandoverTable[j],0,sizeof(AdjCell_HandoverEntry));
+ adjCell_HandoverTable[j].adjCell_handoverIndex=j;
+ break;
+ }
+ }
+ }
+ i++;
+ }
+
+ //step 3: get reslection table list
+ ret = getMibTbl(MIBT_adjCell_reselectionEntry, (void *) &adjCell_ReselectionTable,
+ sizeof(adjCell_ReselectionTable));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamAdjacentCellPackage: getMibTbl failed to get adjCell_ReselectionTable err(%d)\n", ret);
+ printf("grr_GetOamAdjacentCellPackage: getMibTbl failed to get adjCell_ReselectionTable err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBTBL_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ grr_OamData.adjacentCellPackage.adjCell_reselectionTable= (Table *) &adjCell_ReselectionTable;
+
+ //Compress all empty rows in the reselection adjacent cell table
+ i=0;
+ while (i<OAMgrr_RESEL_ADJCELL_NO_MAX)
+ {
+ if (OAMgrr_RESEL_ADJCELL_ID(i)==OAMgrr_RESEL_ADJCELL_ID_NULL)
+ {
+ for (j=i+1;j<OAMgrr_RESEL_ADJCELL_NO_MAX;j++)
+ {
+ if (OAMgrr_RESEL_ADJCELL_ID(j) != OAMgrr_RESEL_ADJCELL_ID_NULL)
+ {
+ memcpy(&adjCell_ReselectionTable[i],&adjCell_ReselectionTable[j],
+ sizeof(AdjCell_ReselectionEntry));
+ adjCell_ReselectionTable[i].adjCell_reselectionIndex = i;
+ memset(&adjCell_ReselectionTable[j],0,sizeof(AdjCell_ReselectionEntry));
+ adjCell_ReselectionTable[j].adjCell_reselectionIndex = j;
+ break;
+ }
+ }
+ }
+ i++;
+ }
+
+ DBG_LEAVE();
+}
+
+
+void grr_GetOamHandoverControlPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamHandoverControlPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ ret = getMibStruct(MIB_handoverControlPackage, (unsigned char*)&grr_OamData.handoverControlPackage,
+ sizeof(HandoverControlPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamHandoverControlPackage: getMibStruct failed to get handoverControlPackage err(%d)\n", ret);
+ printf("grr_GetOamHandoverControlPackage: getMibStruct failed to get handoverControlPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ DBG_LEAVE();
+
+}
+
+void grr_GetOamPowerControlPackage(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamPowerControlPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ ret = getMibStruct(MIB_powerControlPackage, (unsigned char*)&grr_OamData.powerControlPackage,
+ sizeof(PowerControlPackage));
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamPowerControlPackage: getMibStruct failed to get powerControlPackage err(%d)\n", ret);
+ printf("grr_GetOamPowerControlPackage: getMibStruct failed to get powerControlPackage err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ DBG_LEAVE();
+ assert(0);
+ }
+
+ DBG_LEAVE();
+
+}
+
+//Get standard GSM MIB data
+void grr_GetOamGsmData(void)
+{
+ DBG_FUNC("grr_GetOamGsmData", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ // Initialize Table area
+ GRR_MEMSET(&cellAllocationTable, sizeof(cellAllocationTable));
+ GRR_MEMSET(&plmnPermittedTable, sizeof(plmnPermittedTable));
+ GRR_MEMSET(¬AllowedAccessClassTable, sizeof(notAllowedAccessClassTable));
+ GRR_MEMSET(&firstTrxPackageChannelTable, sizeof(firstTrxPackageChannelTable));
+ GRR_MEMSET(&secondTrxPackageChannelTable, sizeof(secondTrxPackageChannelTable));
+
+ GRR_MEMSET(&firstRadioCarrierPackageFrequencyListTable, sizeof(firstRadioCarrierPackageFrequencyListTable));
+ GRR_MEMSET(&secondRadioCarrierPackageFrequencyListTable, sizeof(secondRadioCarrierPackageFrequencyListTable));
+ GRR_MEMSET(&adjCell_HandoverTable, sizeof(adjCell_HandoverTable));
+ GRR_MEMSET(&adjCell_ReselectionTable, sizeof(adjCell_ReselectionTable));
+
+ GRR_MEMSET(&adjCell_HandoverTable_t,sizeof(adjCell_HandoverTable));
+ grr_OamData.adjacentCellPackage_t.adjCell_handoverTable = (Table *) &adjCell_HandoverTable_t;
+
+ grr_GetOamBtsBasicPackage();
+ grr_GetOamBtsOptionPackage();
+ grr_GetOamBtsFirstTrxPackage();
+ grr_GetOamBtsSecondTrxPackage();
+ grr_GetOamBtsFirstRadioCarrierPackage();
+ grr_GetOamBtsSecondRadioCarrierPackage();
+ grr_GetOamT31xxTimerStructure();
+ grr_GetOamAdjacentCellPackage();
+ grr_GetOamHandoverControlPackage();
+ grr_GetOamPowerControlPackage();
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamRrmData(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_GetOamRrmData", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ ret = getMibStruct(MIB_resourceConfigData, (unsigned char*)&grr_OamData.grrConfigData,
+ sizeof(ResourceConfigData));
+
+ if (ret != STATUS_OK)
+ {
+ DBG_ERROR("grr_GetOamRrmData: getMibStruct failed to get oam rrm data, err(%d)\n",ret);
+ printf("grr_GetOamRrmData: getMibStruct failed to get oam rrm data, err(%d)\n",ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_GetOamData(void)
+{
+ DBG_FUNC("grr_GetOamData", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ GRR_MEMSET(&grr_OamData, sizeof(grr_OamData));
+
+ //Get OAM data
+ grr_GetOamGsmData();
+ grr_GetOamRrmData();
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_GETOAMMIB_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_OamUtil.cpp b/data/mnet/GP10/Host/grr/src/grr_OamUtil.cpp new file mode 100644 index 0000000..49cd82f --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_OamUtil.cpp @@ -0,0 +1,358 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_OAMUTIL_CPP__
+#define __GRR_OAMUTIL_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_RegOamTrap(void)
+{
+ STATUS ret;
+
+ DBG_FUNC("grr_RegOamTrap", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Reset any trap setting to get a clean start
+ if ( STATUS_OK != (ret=oam_unsetTrapByModule(MODULE_GRR)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: unsetTrapByModule failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: unsetTrapByModule failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_UNSETTRAPBYMODULE_FAILED);
+ assert(0);
+ }
+
+ //Regsiter to trap BtsBasicPackage
+ if ( STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_btsBasicPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap btsBasicPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap btsBasicPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap BtsOptionsPackage
+ if ( STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_btsOptionsPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap BtsOptionsPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap BtsOptionsPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap first TransceiverPackages
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_firstTransceiverPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap firstTransceiverPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap firstTransceiverPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap second TransceiverPackages
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_secondTransceiverPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap secondTransceiverPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap secondTransceiverPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap first RadioCarrierPackages
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_firstRadioCarrierPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap firstRadioCarrierPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap firstRadioCarrierPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap second RadioCarrierPackages
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_secondRadioCarrierPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap secondRadioCarrierPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap secondRadioCarrierPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Regsiter to trap T31xx timers
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_t31xxPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap t31xxPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap t31xxPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap AdjacentCellPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_adjacentCellPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap adjacentCellPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap adjacentCellPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap HandoverControlPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_handoverControlPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap HandoverControlPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap HandoverControlPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoAveragingAdjCellPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoAveragingAdjCellPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoAveragingAdjCellPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoAveragingAdjCellPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoAveragingDistPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoAveragingDistPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoAveragingDistPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoAveragingDistPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoAveragingQualPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoAveragingLevPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoAveragingLevPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoAveragingLevPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoAveragingQualPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoAveragingQualPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoAveragingQualPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoThresholdDistPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoThresholdDistPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoThresholdDistPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoThresholdDistPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoThresholdInterfacePackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoThresholdInterfacePackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoThresholdInterfacePackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoThresholdInterfacePackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoThresholdLevPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoThresholdLevPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoThresholdLevPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoThresholdLevPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap hoThresholdQualPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_hoThresholdQualPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap hoThresholdQualPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap hoThresholdQualPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap interferenceAveragingPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_interferenceAveragingPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap interferenceAveragingPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap interferenceAveragingPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap PowerControlPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_powerControlPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap powerControlPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap powerControlPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcAveragingLevPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcAveragingLevPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcAveragingLevPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcAveragingLevPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcAveragingQualPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcAveragingQualPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcAveragingQualPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcAveragingQualPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcLowerThresholdLevPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcLowerThresholdLevPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcLowerThresholdLevPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcLowerThresholdLevPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcLowerThresholdQualPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcLowerThresholdQualPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcLowerThresholdQualPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcLowerThresholdQualPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcUpperThresholdLevPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcUpperThresholdLevPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcUpperThresholdLevPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcUpperThresholdLevPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap pcUpperThresholdQualPackage
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_pcUpperThresholdQualPackage)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap pcUpperThresholdQualPackage failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap pcUpperThresholdQualPackage failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ //Register to trap ResourceConfigData
+ if (STATUS_OK != (ret=oam_setTrap(MODULE_GRR, grr_MsgQId, MIB_resourceConfigData)) )
+ {
+ DBG_ERROR("grr_RegOamTrap: oam_setTrap resourceConfigData failed err(%d)\n", ret);
+ printf("grr_RegOamTrap: oam_setTrap resourceConfigData failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTRAP_FAILED);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_FixOamData(void)
+{
+ unsigned char i,j;
+
+ DBG_FUNC("grr_FixOamData", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Complete the half-done lock intent
+ if ( OAMgrr_BTS_AMSTATE != unlocked ||
+ OAMgrr_TRX_AMSTATE(0) != unlocked ||
+ OAMgrr_CHN_AMSTATE(0,0) != unlocked )
+ {
+ //Lock the whole Bts
+ if (OAMgrr_BTS_AMSTATE != locked)
+ grr_SetOamBtsAmState(locked);
+
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ if (OAMgrr_TRX_AMSTATE(i) != locked)
+ grr_SetOamTrxAmState(i,locked);
+
+ for (j=0;j<8;j++)
+ {
+ if (OAMgrr_CHN_AMSTATE(i,j) != locked)
+ grr_SetOamTrxSlotAmState(i,j,locked);
+ }
+ }
+ } else
+ {
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ //Lock the whole trx res if needed
+ if (OAMgrr_TRX_AMSTATE(i) != unlocked)
+ {
+ if (OAMgrr_TRX_AMSTATE(i) != locked)
+ grr_SetOamTrxAmState(i,locked);
+
+ for (j=0;j<8;j++)
+ {
+ if (OAMgrr_CHN_AMSTATE(i,j) != locked)
+ grr_SetOamTrxSlotAmState(i,j,locked);
+ }
+ } else
+ {
+ //TRX is unlocked, handle slots admin states
+ for (j=0;j<8;j++)
+ {
+ if (OAMgrr_CHN_AMSTATE(i,j) != unlocked)
+ {
+ if (OAMgrr_CHN_AMSTATE(i,j) != locked)
+ grr_SetOamTrxSlotAmState(i,j,locked);
+ }
+ }
+ }
+ }
+ }
+
+ DBG_LEAVE();
+}
+
+unsigned char grr_GetOamTotalAvailableHoNCells(void)
+{
+ unsigned char i, count;
+ count=0;
+
+ for (i=0;i<OAMgrr_HO_ADJCELL_NO_MAX;i++)
+ if (OAMgrr_HO_ADJCELL_ID_t(i)!=OAMgrr_HO_ADJCELL_ID_NULL)
+ count++;
+
+ return count;
+}
+
+void grr_OverloadedCellBarOff(void)
+{
+ DBG_FUNC("grr_OverloadedCellBarOff", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ if ( (OAMgrr_BTS_AMSTATE==unlocked) &&
+ (OAMgrr_TRX_AMSTATE(0)==unlocked) &&
+ (OAMgrr_CHN_AMSTATE(0,0)==unlocked) )
+ {
+ grr_PassOamMsSystemInformation2(0,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation3(0,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(0,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+ }
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_OAMUTIL_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_PassOamMib.cpp b/data/mnet/GP10/Host/grr/src/grr_PassOamMib.cpp new file mode 100644 index 0000000..5272c34 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_PassOamMib.cpp @@ -0,0 +1,753 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PASSOAMMIB_CPP__
+#define __GRR_PASSOAMMIB_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_PassOamDspBtsPackage(unsigned char trx)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_PassOamDspBtsPackage", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //skip the len of 4 bytes in the beginning
+ len = 4;
+ buf[len++] = GRR_L1MG_OAMMGMT;
+ buf[len++] = GRR_L1MT_BTSPACKAGE_MSB;
+ buf[len++] = GRR_L1MT_BTSPACKAGE_LSB;
+ buf[len++] = trx;
+
+ //Parameters contained in this message
+ buf[len++] = OAMgrr_RADIO_LINK_TIMEOUT;
+ buf[len++] = OAMgrr_BS_PA_MFRMS;
+
+ buf[len] = 0;
+ if ( ((int)OAMgrr_MS_UPLINK_DTX_STATE==1) ||
+ ((int)OAMgrr_MS_UPLINK_DTX_STATE==0) )
+ buf[len] |= 1; //DTX ul ON
+
+ if ( trx && OAMgrr_MS_DNLINK_DTX_STATE)
+ buf[len] |= 2; //DTX dl ON
+
+ len++;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamDspPwrCtrl(unsigned char trx)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_PassOamDspPwrCtrl", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ PowerControlPackage_t *pcPktPtr = &grr_OamData.powerControlPackage;
+
+ len = 4;
+
+ buf[len++] = GRR_L1MG_OAMMGMT;
+ buf[len++] = GRR_L1MT_DPCCFG_MSB;
+ buf[len++] = GRR_L1MT_DPCCFG_LSB;
+ buf[len++] = trx;
+
+ //the size for the signal sample buffer used for averaging power
+ //level[1-32]. one sample at every 480 ms (1 frame) (Hreqave)
+ buf[len++] = pcPktPtr->pcAveragingLev->hreqave;
+
+ //the size for the signal sample buffer used for averaging quality
+ //samples [1-32]. one sample at every 480 ms (1 frame) (hreqave)
+ buf[len++] = pcPktPtr->pcAveragingQual->hreqave;
+
+ //Threshold for activating uplink dynamic power control
+ buf[len++] = pcPktPtr->pcLowerThresholdLevParam->rxLevelUL;
+
+ //store length in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+
+}
+
+void grr_PassOamDspHoServCell(unsigned char trx)
+{
+ int len, tmp;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_PassOamDspHoServCell", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ HandoverControlPackage_t *hoPktPtr = &grr_OamData.handoverControlPackage;
+
+ len = 4;
+
+ //Msg discriminator and type
+ buf[len++] = GRR_L1MG_OAMMGMT;
+ buf[len++] = GRR_L1MT_HOSCELLCFG_LSB;
+ buf[len++] = GRR_L1MT_HOSCELLCFG_LSB;
+
+ buf[len++] = trx;
+
+ //Power parameters
+ //
+
+ //Rxlev threshold on the uplink for handover process to commence (-103 ~ -73)
+ tmp = hoPktPtr->hoThresholdLevParam->rxLevelUL;
+ buf[len++] = (unsigned char) tmp;
+
+ //Rxlev threshold on the downlink for handover process to commence (-103 ~ -73)
+ tmp = hoPktPtr->hoThresholdLevParam->rxLevelDL;
+ buf[len++] = (unsigned char) tmp;
+
+ //The number of averages (out of total averages) that have to be upper or lower
+ //than the threshold, before making a handover decision (P5).
+ buf[len++] = hoPktPtr->hoThresholdLevParam->px;
+
+ //The number of averages that have to be taken into account, when making a
+ //handover decision (N5).
+ buf[len++] = hoPktPtr->hoThresholdLevParam->nx;
+
+ //Quality parameters
+ //
+
+ //uplink
+ tmp = hoPktPtr->hoThresholdQualParam->rxQualUL;
+ buf[len++] = (unsigned char) tmp;
+
+ //downlink
+ tmp = hoPktPtr->hoThresholdQualParam->rxQualDL;
+ buf[len++] = (unsigned char) tmp;
+
+ buf[len++] = (unsigned char) hoPktPtr->hoThresholdQualParam->px;
+ buf[len++] = (unsigned char) hoPktPtr->hoThresholdQualParam->nx;
+
+ //Handover Margin Default
+ buf[len++] = (unsigned char) hoPktPtr->hoMarginDef;
+
+ //Maximum mobile transmission power default
+ buf[len++] = (unsigned char) hoPktPtr->mxTxPwrMaxCellDef;
+
+ //Minimum mobile receive power default
+ buf[len++] = (unsigned char) hoPktPtr->rxLevMinCellDef;
+
+ //store length in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamDspHoNeighCell(unsigned char trx, unsigned char cell, unsigned char nocells)
+{
+ int len, tmp;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_PassOamDspHoNeighCell", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ if (OAMgrr_HO_ADJCELL_ID_t(cell)==OAMgrr_HO_ADJCELL_ID_NULL) {DBG_LEAVE(); return;}
+
+ //point to the correct index;
+ AdjCell_HandoverEntry *entry
+ = (AdjCell_HandoverEntry *) grr_OamData.adjacentCellPackage_t.adjCell_handoverTable;
+ entry += cell;
+
+ len = 4;
+
+ //Encode DSP message
+ buf[len++] = GRR_L1MG_OAMMGMT;
+ buf[len++] = GRR_L1MT_HONCELLCFG_MSB;
+ buf[len++] = GRR_L1MT_HONCELLCFG_LSB;
+ buf[len++] = trx;
+ buf[len++] = cell;
+ buf[len++] = nocells;
+
+ //ARFCN
+ tmp = entry->adjCell_bCCHFrequency;
+ buf[len++] = (unsigned char) (tmp >>8);
+ buf[len++] = (unsigned char) tmp;
+
+ //BSIC
+ buf[len++] = (unsigned char) ((unsigned char) entry->adjCell_ncc << 3 |
+ (unsigned char) entry->adjCell_cid);
+ //Handover margin
+ buf[len++] = (unsigned char) entry->adjCell_hoMargin;
+
+ //Maximum Mobile Transmit Power for Neighbour Cell
+ tmp = entry->adjCell_msTxPwrMaxCell;
+ buf[len++] = (unsigned char) tmp;
+
+ //Minimum Mobile receive Power for Neighbour Cell
+ tmp = entry->adjCell_rxLevMinCell;
+ buf[len++] = (unsigned char) tmp;
+
+ //store length in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamDspPwrRedStep(unsigned char trx)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_PassOamDspPwrRedStep", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ if (trx >= OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_PassOamDspPwrRedStep: invalid trx(%d)\n", trx);
+ return;
+ }
+
+ len = 4;
+ buf[len++] = GRR_L1MG_OAMMGMT;
+ buf[len++] = GRR_L1MT_TXPWMAXRDCTCFG_MSB;
+ buf[len++] = GRR_L1MT_TXPWMAXRDCTCFG_LSB;
+ buf[len++] = trx;
+
+ buf[len++] = (unsigned char)
+ (grr_OamData.radioCarrierPackage[OAMgrr_TRX_RC(trx)].txPwrMaxReduction);
+
+ //store length in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamMsSystemInformation2(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation2", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI2 for use by RRM encoder
+ grr_PopulateSi2(barState);
+ GRR_MEMCPY(&grr_Msg, &grr_Si2, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE2));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in PH_DATA_REQ and pass to DSP
+ len = 4;
+ buf[len++] = GRR_L1MG_COMCHAN;
+ buf[len++] = GRR_L1MT_BCCHINFO_MSB;
+ buf[len++] = GRR_L1MT_BCCHINFO_LSB;
+ buf[len++] = trx;
+ buf[len++] = GRR_L1CH_BCCH_MSB;
+ buf[len++] = GRR_L1CH_BCCH_LSB;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation2: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation2: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamMsSystemInformation3(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation3", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI3 for use by RRM encoder
+ grr_PopulateSi3(barState);
+ GRR_MEMCPY(&grr_Msg, &grr_Si3, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE3));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in PH_DATA_REQ and pass to DSP
+ len = 4;
+ buf[len++] = GRR_L1MG_COMCHAN;
+ buf[len++] = GRR_L1MT_BCCHINFO_MSB;
+ buf[len++] = GRR_L1MT_BCCHINFO_LSB;
+ buf[len++] = trx;
+ buf[len++] = GRR_L1CH_BCCH_MSB;
+ buf[len++] = GRR_L1CH_BCCH_LSB;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation3: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation3: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamMsSystemInformation4(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation4", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI4 for use by RRM encoder
+ grr_PopulateSi4(barState);
+ GRR_MEMCPY(&grr_Msg, &grr_Si4, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE4));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in PH_DATA_REQ and pass to DSP
+ len = 4;
+ buf[len++] = GRR_L1MG_COMCHAN;
+ buf[len++] = GRR_L1MT_BCCHINFO_MSB;
+ buf[len++] = GRR_L1MT_BCCHINFO_LSB;
+ buf[len++] = trx;
+ buf[len++] = GRR_L1CH_BCCH_MSB;
+ buf[len++] = GRR_L1CH_BCCH_LSB;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation4: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation4: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamMsSystemInformation5(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int i,j,len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation5", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI5 for use by RRM encoder
+ grr_PopulateSi5();
+ GRR_MEMCPY(&grr_Msg, &grr_Si5, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE5));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //RIL3 will reoder the frequencies during encoding. Get the resulted f.list
+ GRR_MEMCPY(&grr_Si5, &grr_Msg, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE5));
+
+ //Construct internal adjacent ho cell tables in terms of the resulted order
+ for (i=0;i<grr_Si5.bcchFreqList.numRFfreq;i++)
+ {
+ memset(&adjCell_HandoverTable_t[i],0, sizeof(AdjCell_HandoverEntry));
+
+ for (j=0;j<grr_Si5.bcchFreqList.numRFfreq;j++)
+ {
+
+ if (grr_Si5.bcchFreqList.arfcn[i]==OAMgrr_HO_ADJCELL_BCCH_ARFCN(j))
+ break;
+ }
+
+ //printf("GRR@===f(i#=%d, o#=%d, total=%d), freq=%d\n", i,j,
+ // grr_Si5.bcchFreqList.numRFfreq,
+ // grr_Si5.bcchFreqList.arfcn[i]);
+
+ if (j<grr_Si5.bcchFreqList.numRFfreq)
+ {
+ //Put this adjacent-cell configuration in its right place
+ memcpy(&adjCell_HandoverTable_t[i], &adjCell_HandoverTable[j], sizeof(AdjCell_HandoverEntry));
+
+ //printf("GRR@===f(#=%d, total=%d), freq=%d, id=%d\n", i,
+ // grr_Si5.bcchFreqList.numRFfreq,
+ // OAMgrr_HO_ADJCELL_BCCH_ARFCN_t(i),
+ // OAMgrr_HO_ADJCELL_ID_t(i));
+
+ } else
+ {
+ DBG_WARNING("grr_PassOamMsSystemInformation5: alien freq found after RIL3 encoding\n");
+ }
+
+ }
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in SACCH FILLING sent to L1
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_SACCHFILL_MSB;
+ buf[len++] = GRR_L1MT_SACCHFILL_LSB;
+ buf[len++] = trx;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation5: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation5: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+}
+
+void grr_PassOamMsSystemInformation6(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int i,j,len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation6", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI6 for use by RRM encoder
+ grr_PopulateSi6();
+ GRR_MEMCPY(&grr_Msg, &grr_Si6, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE6));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in SACCH FILLING sent to L1
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_SACCHFILL_MSB;
+ buf[len++] = GRR_L1MT_SACCHFILL_LSB;
+ buf[len++] = trx;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation6: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation6: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+}
+
+void grr_PassOamMsSystemInformation13(
+ unsigned char trx,
+ unsigned char SI,
+ T_CNI_RIL3_CELL_BARRED_ACCESS barState
+ )
+{
+ int i,j,len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ T_CNI_RIL3_RESULT ret;
+ T_CNI_LAPDM_L3MessageUnit l3_data;
+
+ if (!OAMgrr_GPRS_FEATURE_SETTING) return;
+
+ DBG_FUNC("grr_PassOamMsSystemInformation13", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Zap rm_UmMsg 0-clean first
+ GRR_MEMSET(&grr_Msg, sizeof(T_CNI_RIL3RRM_MSG));
+
+ //Populate SI6 for use by RRM encoder
+ grr_PopulateSi13();
+ GRR_MEMCPY(&grr_Msg, &grr_Si13, sizeof(T_CNI_RIL3RRM_MSG_SYSTEM_INFO_TYPE13));
+
+ //Call RR message encoding functionality
+ ret = CNI_RIL3RRM_Encode(&grr_Msg, &l3_data);
+
+ //check the encoding result before sending the message
+ switch (ret)
+ {
+ case CNI_RIL3_RESULT_SUCCESS:
+ //Wrap the encoded SI in SACCH FILLING sent to L1
+ len = 4;
+ buf[len++] = GRR_L1MG_COMCHAN;
+ buf[len++] = GRR_L1MT_BCCHINFO_MSB;
+ buf[len++] = GRR_L1MT_BCCHINFO_LSB;
+ buf[len++] = trx;
+ buf[len++] = GRR_L1CH_BCCH_MSB;
+ buf[len++] = GRR_L1CH_BCCH_LSB;
+ buf[len++] = SI;
+ buf[len++] = l3_data.msgLength;
+ GRR_MEMCPY(&buf[len], l3_data.buffer, l3_data.msgLength);
+ len = len + l3_data.msgLength;
+
+ buf[len++] = 1; //Start time==immediate
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debugging if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_PassOamMsSystemInformation13: rrm encoder failed err(%d)\n", ret);
+ printf("grr_PassOamMsSystemInformation13: rrm encoder failed err(%d)\n", ret);
+ grr_SubmitAlarm(EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED);
+ assert(0);
+ break;
+ }
+}
+
+void grr_PassOamMsParams(unsigned char trx)
+{
+ DBG_FUNC("grr_PassOamMsParams", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ grr_PassOamMsSystemInformation2(trx,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation3(trx,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(trx,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation5(trx,GRR_L1SI_TYPE_5,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation6(trx,GRR_L1SI_TYPE_6,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation13(trx,GRR_L1SI_TYPE_13,OAMgrr_RA_CELL_BARRED_STATE);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamDspParams(unsigned char trx)
+{
+ unsigned char i, nocells;
+
+ DBG_FUNC("grr_PassOamDspParams", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ nocells=grr_GetOamTotalAvailableHoNCells();
+ for (i=0;i<OAMgrr_HO_ADJCELL_NO_MAX;i++)
+ grr_PassOamDspHoNeighCell(trx,i,nocells);
+
+ grr_PassOamDspPwrCtrl(trx);
+ grr_PassOamDspHoServCell(trx);
+ grr_PassOamDspPwrRedStep(trx);
+ grr_PassOamDspBtsPackage(trx);
+
+ DBG_LEAVE();
+}
+
+void grr_PassOamParams(unsigned char trx)
+{
+ DBG_FUNC("grr_PassOamParams", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ grr_PassOamMsParams(trx);
+ grr_PassOamDspParams(trx);
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_PASSOAMMIB_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcDspMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcDspMsg.cpp new file mode 100644 index 0000000..cde8fb3 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcDspMsg.cpp @@ -0,0 +1,202 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCDSPMSG_CPP__
+#define __GRR_PROCDSPMSG_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_ProcDspMsg(void)
+{
+ JC_STATUS jcRet;
+ unsigned char trx, slot;
+ int msgType;
+
+ DBG_FUNC("grr_ProcDspMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ if (!grr_ProcDspValidateMsg(&msgType)) {DBG_LEAVE();return;}
+
+ switch(msgType)
+ {
+ case GRR_L1MT_PINGACK:
+ //Got keep-alive rsp
+ //
+ grr_ProcDspPingAck();
+
+ break;
+
+ case GRR_L1MT_SLOTACTIVACK:
+ //Got slot act ack
+ //
+ trx = grr_pItcRxDspMsg->buffer[3];
+ slot= grr_pItcRxDspMsg->buffer[4];
+
+ //Play sanitary check
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_ProcDspMsg: slot Act ack to invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ printf("grr_ProcDspMsg: slot act ack to invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ }
+ else
+ {
+ //trx-slot op state shall stay as disabled during its configuration change
+ if (OAMgrr_CHN_OPSTATE(trx,slot)==opStateEnabled)
+ DBG_WARNING("grr_ProcDspMsg: opState should be disabled for trx(%d) slot(%d)\n",
+ trx, slot);
+ else
+ {
+ OAMgrr_CHN_OPSTATEa(trx,slot) = opStateEnabled;
+ grr_SetOamTrxSlotOpState(trx,slot,opStateEnabled);
+ }
+
+ //Notify RLC and RRM of the trx-slot channel comb change
+ //grr_SendTrxSlotChanComb(MODULE_GRR, rlcMsgQId, trx,slot,OAMgrr_TRX_SLOT_COMB(trx,slot));
+ DBG_TRACE("grr_ProcDspMsg:inform RLC_MAC of current opState (%d) for (trx=%d,slot=%d)\n",
+ opStateEnabled, trx, slot);
+
+ if (JC_OK != (jcRet=RlcMacTSOpState(trx, slot, opStateEnabled)))
+ {
+ DBG_ERROR("grr_ProcDspMsg: RlcMacTSOpState(1) error (trx=%d,slot=%d,state=%d,ret=%d)\n",
+ trx,slot,opStateEnabled,jcRet);
+ assert(0);
+ }
+
+ DBG_TRACE("grr_ProcDspMsg:inform RLC_MAC of slot config (%d) used for (trx=%d,slot=%d)\n",
+ OAMgrr_TRX_SLOT_COMB(trx,slot), trx, slot);
+
+ if (JC_OK != (jcRet=RlcMacConfigureTS(trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot))) )
+ {
+ DBG_ERROR("grr_ProcDspMsg: RlcMacConfigureTS(1) error (trx=%d, slot=%d, config=%d, ret=%d)\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot), jcRet);
+ assert(0);
+ }
+
+ grr_SendTrxSlotChanComb(MODULE_GRR, rm_MsgQId, trx,slot,OAMgrr_TRX_SLOT_COMB(trx,slot));
+ }
+
+ break;
+
+ case GRR_L1MT_SLOTACTIVNACK:
+ //Got slot act nack
+ //
+ trx = grr_pItcRxDspMsg->buffer[3];
+ slot= grr_pItcRxDspMsg->buffer[4];
+
+ //Play sanitary check
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_ProcDspMsg: slot act nack to invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ printf("grr_ProcDspMsg: slot act nack to invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ }
+ else
+ {
+ //Raise an alarm for this negative acknowledgment
+ grr_SubmitAlarm(grr_TrxSlotActNackAlarmCode[trx][slot]);
+
+ //trx-slot op state shall stay as disabled during its configuration change
+ if (OAMgrr_CHN_OPSTATE(trx,slot)==opStateEnabled)
+ {
+ DBG_WARNING("grr_ProcDspMsg: opState should be disabled for trx(%d) slot(%d)\n",
+ trx, slot);
+ OAMgrr_CHN_OPSTATEa(trx,slot) = opStateDisabled;
+ grr_SetOamTrxSlotOpState(trx,slot,opStateDisabled);
+ }
+
+ //Notify RLC and RRM of the trx-slot channel comb change
+ //grr_SendTrxSlotChanComb(MODULE_GRR, rlcMsgQId, trx,slot,OAMgrr_TRX_SLOT_COMB(trx,slot));
+ DBG_TRACE("grr_ProcDspMsg:inform RLC_MAC of current opState (%d) for (trx=%d,slot=%d)\n",
+ opStateDisabled, trx, slot);
+
+ if (JC_OK != (jcRet=RlcMacTSOpState(trx, slot, opStateDisabled)))
+ {
+ DBG_ERROR("grr_ProcDspMsg: RlcMacTSOpState(2) error (trx=%d,slot=%d,state=%d,ret=%d)\n",
+ trx,slot,opStateDisabled,jcRet);
+ assert(0);
+ }
+
+ DBG_TRACE("grr_ProcDspMsg:inform RLC_MAC of slot config (%d) used for (trx=%d,slot=%d)\n",
+ OAMgrr_TRX_SLOT_COMB(trx,slot), trx, slot);
+
+ if (JC_OK != (jcRet=RlcMacConfigureTS(trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot))) )
+ {
+ DBG_ERROR("grr_ProcDspMsg: RlcMacConfigureTS(2) error (trx=%d, slot=%d, config=%d, ret=%d)\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot), jcRet);
+ assert(0);
+ }
+
+ grr_SendTrxSlotChanComb(MODULE_GRR, rm_MsgQId, trx,slot,OAMgrr_TRX_SLOT_COMB(trx,slot));
+ }
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+bool grr_ProcDspValidateMsg(int *msgType)
+{
+
+ DBG_FUNC("grr_ValidateDspMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Validate the DSP message is expected:
+ //
+
+ //Check if received response to keep-alive inquiry
+ if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_PINGACK_MSB,GRR_L1MT_PINGACK_LSB))
+ *msgType = GRR_L1MT_PINGACK;
+ else if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_SLOTACTIVACK_MSB,GRR_L1MT_SLOTACTIVACK_LSB))
+ *msgType = GRR_L1MT_SLOTACTIVACK;
+ else if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_SLOTACTIVNACK_MSB,GRR_L1MT_SLOTACTIVNACK_LSB))
+ *msgType = GRR_L1MT_SLOTACTIVNACK;
+ else
+ *msgType = 0;
+
+ DBG_LEAVE();
+ return ((*msgType)?true:false);
+}
+void grr_ProcDspPingAck(void)
+{
+ unsigned char trx;
+
+ DBG_FUNC("grr_ProcDspPingAck", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ trx = grr_pItcRxDspMsg->buffer[3];
+
+ //Check if DSP is still ticking or not
+ if (grr_pItcRxDspMsg->buffer[4]==grr_TrxMgmt[trx].tdma1 &&
+ grr_pItcRxDspMsg->buffer[5]==grr_TrxMgmt[trx].tdma2 &&
+ grr_pItcRxDspMsg->buffer[6]==grr_TrxMgmt[trx].tdma3 &&
+ grr_pItcRxDspMsg->buffer[7]==grr_TrxMgmt[trx].tdma4 )
+ {
+ //Not ticking any more, raise a critical alarm
+ DBG_ERROR("grr_ProcDspPingAck: dsp(%d) stop ticking\n", trx);
+ printf("grr_ProcDspPingAck: dsp(%d) stop ticking\n", trx);
+ grr_SubmitAlarm(grr_DspNotTickingAnyMore[trx]);
+ assert(0);
+ } else
+ {
+ //Still ticking fine right now
+ grr_TrxMgmt[trx].alive = true;
+ grr_TrxMgmt[trx].tdma1 = grr_pItcRxDspMsg->buffer[4];
+ grr_TrxMgmt[trx].tdma2 = grr_pItcRxDspMsg->buffer[5];
+ grr_TrxMgmt[trx].tdma3 = grr_pItcRxDspMsg->buffer[6];
+ grr_TrxMgmt[trx].tdma4 = grr_pItcRxDspMsg->buffer[7];
+ }
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_PROCDSPMSG_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcGrrMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcGrrMsg.cpp new file mode 100644 index 0000000..f8f73f9 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcGrrMsg.cpp @@ -0,0 +1,68 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCGRRMSG_CPP__
+#define __GRR_PROCGRRMSG_CPP__
+
+#include "grr\grr_head.h"
+
+
+void grr_ProcGrrMsg(void)
+{
+ unsigned char trx;
+
+ DBG_FUNC("grr_ProcGrrMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ if (!grr_ProcGrrValidateMsg()) return;
+
+ trx = grr_pItcRxGrrMsg->trx;
+
+ //Check if trx is still alive
+ if (grr_TrxMgmt[trx].alive)
+ {
+ //trx is still alive. Ping it!
+ grr_TrxMgmt[trx].alive = false;
+ grr_SendDspPing(trx);
+ grr_StartDspWdog(trx);
+ } else
+ {
+ //trx not responding, raise an alarm and abort this task!
+ grr_SubmitAlarm(grr_DspNotResponding[trx]);
+ DBG_ERROR("grr_ProcGrrMsg: dsp(%d) not responding\n", trx);
+ printf("grr_ProcGrrMsg: dsp(%d) not responding\n", trx);
+ assert(0);
+ }
+ DBG_LEAVE();
+}
+
+bool grr_ProcGrrValidateMsg(void)
+{
+ bool ret;
+
+ DBG_FUNC("grr_ProcGrrValidateMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ ret = true;
+
+ if ( (grr_pItcRxGrrMsg->trx>=OAMgrr_MAX_TRXS)||
+ (grr_pItcRxGrrMsg->timer_id != GRR_WDOG) )
+ {
+ DBG_WARNING("grr_ProcGrrValidateMsg: invalid trx(%d) or wdog id(%x)\n",
+ grr_pItcRxGrrMsg->trx,
+ grr_pItcRxGrrMsg->timer_id);
+ ret = false;
+ }
+
+ DBG_LEAVE();
+ return ret;
+}
+
+#endif //__GRR_PROCGRRMSG_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcOamMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcOamMsg.cpp new file mode 100644 index 0000000..fc05fee --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcOamMsg.cpp @@ -0,0 +1,991 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCOAMMSG_CPP__
+#define __GRR_PROCOAMMSG_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_ProcOamMsg(void)
+{
+ DBG_FUNC("grr_ProcOamMsg", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ //Process in terms of message type
+ switch (grr_pItcRxOamMsg->msgType)
+ {
+ case MT_TRAP:
+ //Got a trapped param change notification
+ //
+
+ //Block unauthorized change attempts
+ if (!grr_ProcOamValidateMsg()) return;
+
+ switch (MIB_TBL(grr_pItcRxOamMsg->mibTag))
+ {
+ case MTBL_btsBasicPackage:
+ grr_ProcOamBtsBasicPackage();
+ break;
+ case MTBL_btsOptionsPackage:
+ grr_ProcOamBtsOptionsPackage();
+ break;
+ case MTBL_firstTransceiverPackage:
+ grr_ProcOamTransceiverPackage(0);
+ break;
+ case MTBL_secondTransceiverPackage:
+ grr_ProcOamTransceiverPackage(1);
+ break;
+ case MTBL_firstRadioCarrierPackage:
+ grr_ProcOamRadioCarrierPackage(0, grr_pItcRxOamMsg->mibTag);
+ break;
+ case MTBL_secondRadioCarrierPackage:
+ grr_ProcOamRadioCarrierPackage(1, grr_pItcRxOamMsg->mibTag);
+ break;
+ case MTBL_t31xx:
+ grr_ProcOamT31xxPackage();
+ break;
+ case MTBL_adjacentCellPackage:
+ grr_ProcOamAdjacentCellPackage();
+ break;
+ case MTBL_handoverControlPackage:
+ case MTBL_hoAveragingAdjCellParam:
+ case MTBL_hoAveragingDistParam:
+ case MTBL_hoAveragingLevParam:
+ case MTBL_hoAveragingQualParam:
+ case MTBL_hoThresholdDistParam:
+ case MTBL_hoThresholdInterfaceParam:
+ case MTBL_hoThresholdLevParam:
+ case MTBL_hoThresholdQualParam:
+ case MTBL_interferenceAveragingParam:
+ grr_ProcOamHandoverControlPackage();
+ break;
+ case MTBL_powerControlPackage:
+ case MTBL_pcAveragingLev:
+ case MTBL_pcAveragingQual:
+ case MTBL_pcLowerThresholdLevParam:
+ case MTBL_pcLowerThresholdQualParam:
+ case MTBL_pcUpperThresholdLevParam:
+ case MTBL_pcUpperThresholdQualParam:
+ grr_ProcOamPowerControlPackage();
+ break;
+ case MTBL_resourceConfigData:
+ grr_ProcOamResourceConfigData();
+ break;
+ default:
+ //Received unknown OAM mib table MIB_TBL(tag)
+ DBG_WARNING("grr_ProcOamMsg: unknown OAM table(%d)\n",MIB_TBL(grr_pItcRxOamMsg->mibTag));
+ break;
+ }
+ break;
+
+ default:
+ //Received unrecognized message type
+ DBG_WARNING("grr_ProcOamMsg: unknown OAM msg type(%d)\n", grr_pItcRxOamMsg->msgType);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsBasicPackage(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamBtsBasicPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsBasicPackage: changed mib param tag(%x)\n",
+ grr_pItcRxOamMsg->mibTag);
+
+ //Retrieve BtsBasicPackage
+ OAMgrr_BTS_OPSTATEold = OAMgrr_BTS_OPSTATE;
+ OAMgrr_BTS_AMSTATEold = OAMgrr_BTS_AMSTATE;
+ grr_GetOamBtsBasicPackage();
+
+ //Check if BTS operational state is changed or not
+ if (grr_pItcRxOamMsg->mibTag==MIB_bts_operationalState)
+ {
+ grr_ProcOamBtsOpStateChange();
+ return;
+ }
+
+ //Check if got BTS administrative state changed notifica
+ if (grr_pItcRxOamMsg->mibTag==MIB_bts_administrativeState)
+ {
+ grr_ProcOamBtsAmStateChange();
+ return;
+ }
+
+ //Blindly update DSPs with new parameters
+ i = 0;
+ while (i<OAMgrr_MAX_TRXS)
+ {
+ //Update both DSPs and MS
+ grr_PassOamMsSystemInformation2(i,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation3(i,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(i,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation5(i,GRR_L1SI_TYPE_5,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation6(i,GRR_L1SI_TYPE_6,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation13(i,GRR_L1SI_TYPE_13,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamDspBtsPackage(i);
+ grr_SendDspTrxConfig(i);
+
+ i++;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsOpStateChange(void)
+{
+ int i;
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_ProcOamBtsOpStateChange", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("TRACE@grr_ProcOamBtsOpStateChange: new btsOpState(%d) old btsOpState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_OPSTATEold);
+
+ switch(grr_pItcRxOamMsg->val.varVal)
+ {
+ case opStateEnabled:
+ //Turn on radio
+ if (!grr_IsBtsAmTypeBlocked()) grr_RadioCtrl(GRR_ON);
+
+ DBG_TRACE("grr_ProcOamBtsOpStateChange: inform RLC_MAC of bts opState enabled\n");
+
+ if (JC_OK != (jcRet=RlcMacGPOpState(opStateEnabled)))
+ DBG_ERROR("grr_ProcOamBtsOpStateChange: RlcMacGPOpState() err(%d)\n", jcRet);
+
+ break;
+
+ case opStateDisabled:
+ //Turn off radio
+ grr_RadioCtrl(GRR_OFF);
+
+ DBG_TRACE("grr_ProcOamBtsOpStateChange: inform RLC_MAC of bts opState disabled\n");
+
+ if (JC_OK != (jcRet=RlcMacGPOpState(opStateDisabled)))
+ DBG_ERROR("grr_ProcOamBtsOpStateChange: RlcMacGPOpState() err(%d)\n", jcRet);
+
+ break;
+
+ default:
+ DBG_ERROR("grr_ProcOamBtsOpStateChange: invalid new btsOpState Value(%d) old btsOpState\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_OPSTATEold);
+ printf("grr_ProcOamBtsOpStateChange: invalid new btsOpState Value(%d) old btsOpState\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_OPSTATEold);
+ assert(0);
+ break;
+ }
+
+ OAMgrr_BTS_OPSTATEa = (EnableDisable_t) grr_pItcRxOamMsg->val.varVal;
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsAmStateChange(void)
+{
+ DBG_FUNC("grr_ProcOamBtsAmStateChange", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsAmStateChange: get new btsAmState(%d) oldBtsAmState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_AMSTATEold);
+
+ //In terms of amState change notif
+ switch(grr_pItcRxOamMsg->val.varVal)
+ {
+ case locked:
+ grr_ProcOamBtsAmStateLocked();
+ break;
+
+ case unlocked:
+ grr_ProcOamBtsAmStateUnlocked();
+ break;
+
+ case shuttingDown:
+ grr_ProcOamBtsAmStateShuttingdown();
+ break;
+
+ default:
+ DBG_ERROR("grr_ProcOamBtsAmStateChange: invalid new btsAmState(%d) old btsAmState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_AMSTATEold);
+ printf("grr_ProcOamBtsAmStateChange: invalid new btsAmState(%d) old btsAmState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_BTS_AMSTATEold);
+ assert(0);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsAmStateLocked(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamBtsAmStateLocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsAmStateLocked: btsAmState goes locked\n");
+
+ //Report informational alarm
+ grr_SubmitAlarm(EC_GRR_BTS_LOCKED);
+
+ //Lock all TRXes in existence
+ for (i=0; i<OAMgrr_MAX_TRXS; i++ )
+ {
+ //Check if ith TRX is existent
+ grr_SetOamTrxAmState(i,locked);
+ grr_ProcOamTrxAmStateLocked(i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrxAmStateLocked(unsigned char trx)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamTrxAmStateLocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxAmStateLocked: trx(%d) amState goes locked\n", trx);
+
+ //Check if trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_ProcOamTrxAmStateLocked: invalid trx(%d)\n",trx);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxAmStateLockedAlarmCode[trx]);
+
+ //Turn off radio trans
+ grr_TuneTrxSynth(trx,0);
+
+ //lock all TSs
+ for (i=0;i<8;i++)
+ {
+ grr_SetOamTrxSlotAmState(trx,i,locked);
+ grr_ProcOamTrxSlotAmStateLocked(trx,i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrxSlotAmStateLocked(unsigned char trx, unsigned char slot)
+{
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_ProcOamTrxSlotAmStateLocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxSlotAmStateLocked: trx(%d) Ts(%d) amState goes locked\n", trx,slot);
+
+ //Check if trx & slot existent
+ if ( (trx>=OAMgrr_MAX_TRXS)||(slot>=8) )
+ {
+ DBG_WARNING("grr_ProcOamTrxSlotAmStateLocked: invalid trx(%d) slot(%d)\n",trx,slot);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxSlotAmStateLockedAlarmCode[trx][slot]);
+
+ //Send lock request to RLC, RRM
+ //grr_SendTrxSlotLockReq(MODULE_GRR, rlcMsgQId, trx, slot);
+ if (JC_OK != (jcRet=RlcMacTSAdminState(trx,slot,locked)))
+ {
+ DBG_ERROR("grr_ProcOamTrxSlotAmStateLocked: RlcMacTSAdminState error (state=%d), ret=%d)(%d)\n",
+ locked,jcRet);
+ assert(0);
+ }
+ grr_SendTrxSlotLockReq(MODULE_GRR, grr_MsgQId, trx, slot);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsAmStateUnlocked(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamBtsAmStateUnlocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsAmStateUnlocked: btsAmState goes unlocked\n");
+
+ //Report informational alarm
+ grr_SubmitAlarm(EC_GRR_BTS_UNLOCKED);
+
+ //Unlock all TRXes in existence
+ for (i=0; i<OAMgrr_MAX_TRXS; i++ )
+ {
+ //Check if ith TRX is existent
+ grr_SetOamTrxAmState(i,unlocked);
+ grr_ProcOamTrxAmStateUnlocked(i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrxAmStateUnlocked(unsigned char trx)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamTrxAmStateUnlocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxAmStateUnlocked: trx(%d) amState goes unlocked\n", trx);
+
+ //Check if trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_ProcOamTrxAmStateUnlocked: invalid trx(%d)\n",trx);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxAmStateUnlockedAlarmCode[trx]);
+
+ //unlock all TSs
+ for (i=0;i<8;i++)
+ {
+ grr_SetOamTrxSlotAmState(trx,i,unlocked);
+ grr_ProcOamTrxSlotAmStateUnlocked(trx,i);
+ }
+
+ //Turn on radio transmission if should be
+ if (OAMgrr_BTS_OPSTATE==opStateEnabled) grr_TuneTrxSynth(trx,1);
+
+ DBG_LEAVE();
+}
+
+
+void grr_ProcOamTrxSlotAmStateUnlocked(unsigned char trx, unsigned char slot)
+{
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_ProcOamTrxSlotAmStateUnlocked", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxSlotAmStateUnlocked: trx(%d) Ts(%d) amState goes unlocked\n", trx,slot);
+
+ //Check if trx & slot existent
+ if ( (trx>=OAMgrr_MAX_TRXS)||(slot>=8) )
+ {
+ DBG_WARNING("grr_ProcOamTrxSlotAmStateUnlocked: invalid trx(%d) or slot(%d)\n",trx,slot);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxSlotAmStateUnlockedAlarmCode[trx][slot]);
+
+ //Send unlock request to RLC, RRM
+ //grr_SendTrxSlotUnlockReq(MODULE_GRR, rlcMsgQId, trx, slot);
+ //grr_SendTrxSlotUnlockReq(MODULE_GRR, rm_MsgQId, trx, slot);
+ if (JC_OK != (jcRet=RlcMacTSAdminState(trx,slot,unlocked)))
+ {
+ DBG_ERROR("grr_ProcOamTrxSlotAmStateUnlocked: RlcMacTSAdminState error (state=%d, ret=%d)\n",
+ unlocked,jcRet);
+ assert(0);
+ }
+
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsAmStateShuttingdown(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamBtsAmStateShuttingdown", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsAmStateShuttingdown: btsAmState being shuttingdown\n");
+
+ //Report informational alarm
+ grr_SubmitAlarm(EC_GRR_BTS_SHUTTINGDOWN);
+
+ //Shutdown all TRXes in existence
+ for (i=0; i<OAMgrr_MAX_TRXS; i++ )
+ {
+ //Check if ith TRX is existent
+ grr_SetOamTrxAmState(i,shuttingDown);
+ grr_ProcOamTrxAmStateShuttingdown(i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrxAmStateShuttingdown(unsigned char trx)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamTrxAmStateShuttingdown", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxAmStateShuttingdown: trx(%d) amState being shutdown\n", trx);
+
+ //Check if trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_ProcOamTrxAmStateShuttingdown: invalid trx(%d)\n",trx);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxAmStateShuttingdownAlarmCode[trx]);
+
+ //Shutdown all TSs
+ for (i=0;i<8;i++)
+ {
+ grr_SetOamTrxSlotAmState(trx,i,shuttingDown);
+ grr_ProcOamTrxSlotAmStateShuttingdown(trx,i);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrxSlotAmStateShuttingdown(unsigned char trx, unsigned char slot)
+{
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_ProcOamTrxSlotAmStateShuttingdown", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrxSlotAmStateShuttingdown: trx(%d) slot(%d) amState being shutdown\n", trx,slot);
+
+ //Check if trx & slot existent
+ if ( (trx>=OAMgrr_MAX_TRXS)||(slot>=8) )
+ {
+ DBG_WARNING("grr_ProcOamTrxSlotAmStateShuttingdown: invalid trx(%d) slot(%d)\n",trx,slot);
+ return;
+ }
+
+ //Report informational alarm
+ grr_SubmitAlarm(grr_TrxSlotAmStateShuttingdownAlarmCode[trx][slot]);
+
+ //Send shutdown request to RLC, RRM
+ //grr_SendTrxSlotShutdownReq(MODULE_GRR, rlcMsgQId, trx, slot);
+ if (JC_OK != (jcRet=RlcMacTSAdminState(trx,slot,shuttingDown)))
+ {
+ DBG_ERROR("grr_ProcOamTrxSlotAmStateLocked: RlcMacTSAdminState error (state=%d, ret=%d)\n",
+ shuttingDown,jcRet);
+ assert(0);
+ }
+
+ grr_SendTrxSlotShutdownReq(MODULE_GRR, rm_MsgQId, trx, slot);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamBtsOptionsPackage(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcOamBtsOptionsPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamBtsOptionsPackage: changed mib param tag(%x)\n",
+ grr_pItcRxOamMsg->mibTag);
+
+ //Retrieve BtsOptionPackage
+ grr_GetOamBtsOptionPackage();
+
+ //Blindly update DSPs with new parameters
+ i = 0;
+ while (i<OAMgrr_MAX_TRXS)
+ {
+ //Update both DSPs and MS
+ grr_PassOamMsSystemInformation2(i,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation3(i,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(i,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation5(i,GRR_L1SI_TYPE_5,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation6(i,GRR_L1SI_TYPE_6,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation13(i,GRR_L1SI_TYPE_13,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamDspBtsPackage(i);
+ i++;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTransceiverPackage(unsigned char trx)
+{
+ unsigned char i, slot;
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_ProcOamTransceiverPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTransceiverPackage: trx(%d) changed mib param tag(%x)\n",
+ trx, grr_pItcRxOamMsg->mibTag);
+
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_ProcOamTransceiverPackage: changed mib param tag(%d) but invalid trx(%d)\n",
+ grr_pItcRxOamMsg->mibTag, trx);
+ return;
+ }
+
+ //Retrieve changed bts transceiver package
+ if (trx == 0)
+ {
+ OAMgrr_TRX0_AMSTATEold = OAMgrr_TRX_AMSTATE(0);
+ OAMgrr_TRX0SLOT0_AMSTATEold = OAMgrr_TRX_SLOT_AMSTATE(0,0);
+ grr_GetOamBtsFirstTrxPackage();
+ } else
+ grr_GetOamBtsSecondTrxPackage();
+
+ switch(grr_pItcRxOamMsg->mibTag)
+ {
+ case MIB_basebandAdministrativeState_0:
+ //Notify of Trx-0 amState change
+ //
+ grr_ProcOamTrx0AmStateChange();
+ break;
+
+ case MIB_basebandAdministrativeState_1:
+ //Notify of other trxs adminState change
+ //
+ switch(grr_pItcRxOamMsg->val.varVal)
+ {
+ case locked:
+ grr_ProcOamTrxAmStateLocked(1);
+ break;
+
+ case unlocked:
+ grr_ProcOamTrxAmStateUnlocked(1);
+ break;
+
+ case shuttingDown:
+ grr_ProcOamTrxAmStateShuttingdown(1);
+ break;
+
+ default:
+ DBG_WARNING("grr_ProcOamTransceiverPackage:trx1,invalid amStateValue:%d\n",
+ grr_pItcRxOamMsg->mibTag);
+ break;
+ }
+ break;
+
+ case MIBT_channelAdministrativeState_0:
+ case MIBT_channelAdministrativeState_1:
+ //Got trx slot amState change notif
+ //
+ slot = grr_pItcRxOamMsg->val.varTbl.idx;
+
+ if ((trx>=OAMgrr_MAX_TRXS) || (slot>=8))
+ {
+ DBG_WARNING("grr_ProcOamTransceiverPackage: amState changed for invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ return;
+ }
+
+ if ( (trx==0) && (slot==0) ) grr_ProcOamTrx0Slot0AmStateChange();
+ else
+ {
+ switch(grr_pItcRxOamMsg->val.varTbl.value)
+ {
+ case locked:
+ grr_ProcOamTrxSlotAmStateLocked(trx, slot);
+ break;
+ case unlocked:
+ grr_ProcOamTrxSlotAmStateUnlocked(trx, slot);
+ break;
+ case shuttingDown:
+ grr_ProcOamTrxSlotAmStateShuttingdown(trx, slot);
+ break;
+ default:
+ DBG_WARNING("grr_ProcOamTransceiverPackage:trx(%d) slot(%d) invalid amState(%d)\n",
+ trx,slot,grr_pItcRxOamMsg->val.varTbl.value);
+ break;
+ }
+ }
+ break;
+
+ case MIBT_channelCombination_0:
+ case MIBT_channelCombination_1:
+ //Change trx slot channel combination
+ //
+ unsigned char slot;
+
+ slot = grr_pItcRxOamMsg->val.varTbl.idx;
+
+ //trx-slot is change qualified earlier, thus going ahead to realize the change
+ OAMgrr_CHN_OPSTATEa(trx,slot) = opStateDisabled;
+ grr_SetOamTrxSlotOpState(trx,slot,opStateDisabled);
+
+ if (JC_OK != (jcRet=RlcMacTSOpState(trx, slot, opStateDisabled)))
+ {
+ DBG_ERROR("grr_ProcOamTransceiverPackage: RlcMacTSOpState error (trx=%d,slot=%d,state=%d,ret=%d)\n",
+ trx,slot,opStateDisabled,jcRet);
+ }
+
+ grr_SendDspSlotActivate(trx, slot);
+
+ break;
+
+ default:
+ //Handle other trapped notification here
+ DBG_WARNING("grr_ProcOamTransceiverPackage: change for mib param tag(%d) unsupported\n",
+ grr_pItcRxOamMsg->val.varVal);
+
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrx0AmStateChange(void)
+{
+ DBG_FUNC("grr_ProcOamTrx0AmStateChange", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrx0AmStateChange: new amState(%d) old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal, OAMgrr_TRX0_AMSTATEold);
+
+ if ( (grr_pItcRxOamMsg->val.varVal==locked) ||
+ (grr_pItcRxOamMsg->val.varVal==unlocked) ||
+ (grr_pItcRxOamMsg->val.varVal==shuttingDown) )
+ {
+ grr_SetOamBtsAmState((AdministrativeState_t)(grr_pItcRxOamMsg->val.varVal));
+ grr_ProcOamBtsAmStateChange();
+ } else
+ {
+ DBG_ERROR("grr_ProcOamTrx0AmStateChange: invalid new amState(%d) old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal,OAMgrr_TRX0_AMSTATEold);
+ printf("grr_ProcOamTrx0AmStateChange: invalid new amState(%d) old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varVal,OAMgrr_TRX0_AMSTATEold);
+ assert(0);
+ }
+
+ OAMgrr_TRX0_AMSTATEold = grr_pItcRxOamMsg->val.varVal;
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamTrx0Slot0AmStateChange(void)
+{
+ DBG_FUNC("grr_ProcOamTrx0Slot0AmStateChange", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamTrx0Slot0AmStateChange: new amState(%d) old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varTbl.value, OAMgrr_TRX0SLOT0_AMSTATEold);
+
+ if ( (grr_pItcRxOamMsg->val.varTbl.value==locked) ||
+ (grr_pItcRxOamMsg->val.varTbl.value==unlocked) ||
+ (grr_pItcRxOamMsg->val.varTbl.value==shuttingDown) )
+ {
+ grr_SetOamBtsAmState((AdministrativeState_t)(grr_pItcRxOamMsg->val.varTbl.value));
+ } else
+ {
+ DBG_WARNING("grr_ProcOamTrx0Slot0AmStateChange: invalid new amState(%d), old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varTbl.value,OAMgrr_TRX0_AMSTATEold);
+ printf("grr_ProcOamTrx0Slot0AmStateChange: invalid new amState(%d), old amState(%d)\n",
+ grr_pItcRxOamMsg->val.varTbl.value,OAMgrr_TRX0_AMSTATEold);
+ assert(0);
+ }
+
+ switch(grr_pItcRxOamMsg->val.varTbl.value)
+ {
+ case locked:
+ grr_ProcOamBtsAmStateLocked();
+ break;
+
+ case unlocked:
+ grr_ProcOamBtsAmStateUnlocked();
+ break;
+
+ case shuttingDown:
+ grr_ProcOamBtsAmStateShuttingdown();
+ break;
+ }
+
+ OAMgrr_TRX0SLOT0_AMSTATEold = grr_pItcRxOamMsg->val.varTbl.value;
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamRadioCarrierPackage(unsigned char rc, MibTag tag)
+{
+ unsigned char pwr,trx;
+
+ DBG_FUNC("grr_ProcOamRadioCarrierPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamRadioCarrierPackage: radio carrier(%d), changed mib param tag(%d)\n",
+ rc, tag);
+
+ if(rc>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("ProcOamRadioCarrierPackage: received invalid rc(%d)\n", rc);
+ return;
+ }
+
+ //Retrieve rc package
+ if (rc==0) grr_GetOamBtsFirstRadioCarrierPackage();
+ else grr_GetOamBtsSecondRadioCarrierPackage();
+
+ if (OAMgrr_TRX_RC(0) == rc) trx = 0;
+ else trx = 1;
+
+ switch (tag)
+ {
+ case MIBT_carrierFrequency_0:
+ case MIBT_carrierFrequency_1:
+ //Update DSP with new frequencies
+ //
+ if (grr_IsBtsAmTypeBlocked()||grr_IsBtsOpTypeBlocked()) pwr = 0;
+ else pwr = 1;
+
+ grr_TuneTrxSynth(trx, pwr);
+
+ break;
+
+ case MIB_txPwrMaxReduction_0:
+ case MIB_txPwrMaxReduction_1:
+ //radio carriers' Power reduction changed
+ //
+ grr_PassOamDspPwrRedStep(trx);
+
+ break;
+
+ default:
+ // do nothing for now.
+ DBG_WARNING("grr_ProcOamRadioCarrierPackage: received invalid mib param tag(%d)\n",tag);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamT31xxPackage(void)
+{
+ DBG_FUNC("grr_ProcOamT31xxPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_ProcOamT31xxPackage: do nothing but retrieve the new setting\n");
+
+ grr_GetOamT31xxTimerStructure();
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamAdjacentCellPackage(void)
+{
+ unsigned char i,j,ncellNo;
+
+ DBG_FUNC("grr_ProcOamAdjacentCellPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ switch(MIB_ITM(grr_pItcRxOamMsg->mibTag))
+ {
+ case LEAF_adjCell_reselectionTable:
+ DBG_TRACE("grr_ProcOamAdjacentCellPackage: reselction table updated\n");
+ grr_PassOamMsSystemInformation2(0,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ break;
+
+ case LEAF_adjCell_handoverTable:
+ DBG_TRACE("grr_ProcOamAdjacentCellPackage: handover table updated\n");
+ i = 0;
+ while ( i<OAMgrr_MAX_TRXS )
+ {
+ //Pass updated information to both mobile and DSP
+ grr_PassOamMsSystemInformation5(i,GRR_L1SI_TYPE_5,OAMgrr_RA_CELL_BARRED_STATE);
+
+ ncellNo=grr_GetOamTotalAvailableHoNCells();
+ for (j=0;j<OAMgrr_HO_ADJCELL_NO_MAX;j++)
+ grr_PassOamDspHoNeighCell(i,j,ncellNo);
+ i++;
+ }
+ break;
+
+ default:
+ //Received unrecognized message tag
+ DBG_WARNING("grr_ProcOamAdjacentCellPackage: unexpected OAM mib Table tag(%x)\n",
+ MIB_ITM(grr_pItcRxOamMsg->mibTag) );
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamHandoverControlPackage(void)
+{
+ int i;
+
+ DBG_FUNC("grr_ProcOamHandoverControlPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Retrive changed ho ctrl package
+ grr_GetOamHandoverControlPackage();
+
+ //Update DSP with new HandoverControlPackage
+ i = 0;
+ while ( i<OAMgrr_MAX_TRXS )
+ {
+ //Pass updated info to DSPs
+ grr_PassOamDspHoServCell(i);
+ i++;
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcOamPowerControlPackage(void)
+{
+ int i;
+
+ DBG_FUNC("grr_ProcOamPowerControlPackage", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Retrive changed pwr ctrl pkg
+ grr_GetOamPowerControlPackage();
+
+ //Update DSP with new power control package
+ i = 0;
+ while ( i<OAMgrr_MAX_TRXS )
+ {
+ grr_PassOamDspPwrCtrl(i);
+ i++;
+ }
+
+ DBG_LEAVE();
+}
+
+
+void grr_ProcOamResourceConfigData(void)
+{
+ int i;
+ int opState;
+
+ DBG_FUNC("grr_ProcOamResourceConfigData", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Retrive Rrm data
+ opState = OAMgrr_CB_FEATURE_SETTING;
+ grr_GetOamRrmData();
+
+ //Process mib rrm config change
+ switch (grr_pItcRxOamMsg->mibTag)
+ {
+ case MIB_rm_nim_0_1:
+ //CB feature control
+ //
+ if (grr_pItcRxOamMsg->val.varVal>1)
+ {
+ DBG_WARNING("grr_ProcOamResourceConfigData: invalid cb config val(%d)\n",
+ grr_pItcRxOamMsg->val.varVal);
+ printf("grr_ProcOamResourceConfigData: invalid cb config val(%d)\n",
+ grr_pItcRxOamMsg->val.varVal);
+ assert(0);
+
+ } else
+ {
+ grr_PassOamMsSystemInformation4(0,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_SendCbCfgSetting(MODULE_GRR, rm_MsgQId);
+ }
+
+ break;
+
+ case MIB_rm_nim_0_3: //Cell Reselect Offset
+ case MIB_rm_nim_0_4: //Temporary Offset
+ case MIB_rm_nim_0_5: //Penalty Offset
+ case MIB_rm_nim_0_6: //Cell Bar Qualify
+ //case MIB_rm_nim_0_7: //auth/cipher feature control
+ //Update mobile with the new config params
+ //
+ grr_PassOamMsSystemInformation3(0, GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(0, GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+
+ break;
+
+ case MIB_rm_nim_1_1:
+ //Overloaded cell barring. FS needed
+ //
+
+ break;
+
+ grr_PassOamMsSystemInformation2(0,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation3(0,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+ grr_PassOamMsSystemInformation4(0,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+
+ break;
+
+ default:
+ DBG_WARNING("grr_ProcOamResourceConfigData: invalid changed mib param tag(%d)\n",
+ grr_pItcRxOamMsg->mibTag);
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+bool grr_ProcOamValidateMsg(void)
+{
+ bool ret;
+ unsigned char trx;
+
+ DBG_FUNC("grr_ProcOamValidateMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ ret = true;
+
+ switch (grr_pItcRxOamMsg->mibTag)
+ {
+ case MIBT_channelCombination_0:
+ case MIBT_channelCombination_1:
+
+ //Attempt to change trx0 slot0 channel comb
+ //
+
+ if ( (grr_pItcRxOamMsg->val.varTbl.idx==0) &&
+ (grr_pItcRxOamMsg->mibTag==MIBT_channelCombination_0) )
+ {
+ //Not allowed to change trx0slot0's channel combination
+ DBG_WARNING("grr_ProcOamValidateMsg: apply chan comb(%d) to trx(0) slot(0)\n",
+ OAMgrr_TRX_SLOT_COMB(0,0));
+ printf("grr_ProcOamValidateMsg: apply chan comb(%d) to trx(0) slot(0)\n",
+ OAMgrr_TRX_SLOT_COMB(0,0));
+ grr_SubmitAlarm(grr_TrxSlotChanCombChangeAlarmCode[0][0]);
+ ret = false;
+ } else
+ {
+ //Before change channel slot combination, the trx-slot must be locked
+ //
+ if (grr_pItcRxOamMsg->mibTag==MIBT_channelCombination_0) trx = 0;
+ else trx = 1;
+
+ if (OAMgrr_CHN_AMSTATE(trx,grr_pItcRxOamMsg->val.varTbl.idx) != locked)
+ {
+ //GP Manager shall block this change unless amState is locked
+ //
+ DBG_WARNING("grr_ProcOamValidateMsg: lock trx(%d) slot(%d) before change chan comb\n",
+ trx, grr_pItcRxOamMsg->val.varTbl.idx);
+ printf("grr_ProcOamValidateMsg: lock trx(%d) slot(%d) before change chan comb\n",
+ trx, grr_pItcRxOamMsg->val.varTbl.idx);
+ ret = false;
+ }
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ DBG_LEAVE();
+ return ret;
+}
+
+#endif //__GRR_PROCOAMMSG_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcRlcMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcRlcMsg.cpp new file mode 100644 index 0000000..8cc0b03 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcRlcMsg.cpp @@ -0,0 +1,140 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCRLCMSG_CPP__
+#define __GRR_PROCRLCMSG_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_ProcRlcMsg(void)
+{
+ unsigned char trx, slot;
+
+ DBG_FUNC("grr_ProcRlcMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ trx = grr_pItcRxRlcMsg->trx; slot = grr_pItcRxRlcMsg->slot;
+
+ DBG_TRACE("grr_ProcRlcMsg: received Rlc msg(%d) for trx(%d) slot(%d)\n",
+ grr_pItcRxRlcMsg->message_type, trx, slot);
+
+ //Validate received RRM message
+ if (!grr_ProcRlcValidateMsg()) {DBG_LEAVE(); return;}
+
+ //Only expecting trx slot shutdown ack
+ switch (grr_pItcRxRlcMsg->message_type)
+ {
+ case GRR_TRX_SLOT_SHUTDOWN_ACK:
+ //Received trx slot shutdown ack
+ //
+ grr_ProcRlcTrxSlotShutdownAck(trx,slot);
+
+ break;
+
+ default:
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+bool grr_ProcRlcValidateMsg(void)
+{
+ unsigned char trx, slot;
+
+ DBG_FUNC("grr_ProcRlcRlcValidateMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Validate the received RLC message before processing it
+ //
+
+ //Right now only expecting trx slot shutdown acknowledgement
+ if (grr_pItcRxRlcMsg->message_type != GRR_TRX_SLOT_SHUTDOWN_ACK)
+ {
+ DBG_LEAVE();
+ return false;
+ }
+
+ //Apply sanitary check
+ trx = grr_pItcRxRlcMsg->trx; slot = grr_pItcRxRlcMsg->slot;
+
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_ProcRlcValidateMsg: recved slot shutdown ack for invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ DBG_LEAVE();
+ return false;
+ }
+
+ //Check if the (trx,slot) already left pending on shutdown ack now
+ //
+ if (OAMgrr_TRX_SLOT_AMSTATE(trx,slot) != shuttingDown) {DBG_LEAVE();return false;}
+
+ //Check if the shutdown ack makes sense to current chancomb
+ //
+ if (OAMgrr_TRX_SLOT_COMB(trx,slot)!=OAMgrr_TRX_SLOT_COMB_13)
+ {
+ DBG_WARNING("grr_ProcRlcValidateMsg: received trx(%d) slot(%d) shutdown ack chanComb(%d) n.a.\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot));
+ printf("grr_ProcRlcValidateMsg: received trx(%d) slot(%d) shutdown ack chanComb(%d) n.a.\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot));
+
+ DBG_LEAVE();
+ return false;
+ }
+
+ DBG_LEAVE();
+ return true;
+}
+
+void grr_ProcRlcTrxSlotShutdownAck(unsigned char trx, unsigned char slot)
+{
+ DBG_FUNC("grr_ProcRlcTrxSlotShutdownAck", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Apply sanitary check
+ if ( (trx>=OAMgrr_MAX_TRXS)||(slot>=8))
+ {
+ DBG_WARNING("grr_ProcRlcTrxSlotShutdownAck: invalid trx(%d) or slot(%d)\n",
+ trx, slot);
+ DBG_LEAVE();
+ return;
+ }
+
+ OAMgrr_CHN_AMSTATEa(trx, slot) = locked;
+ grr_SetOamTrxSlotAmState(trx,slot,locked);
+ grr_SubmitAlarm(grr_TrxSlotAmStateLockedAlarmCode[trx][slot]);
+
+ if (OAMgrr_TRX_AMSTATE(trx)==shuttingDown)
+ grr_ProcRlcTryShutdownTrx(trx);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcRlcTryShutdownTrx(unsigned char trx)
+{
+ DBG_FUNC("grr_ProcRlcTryShutdownTrx", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ grr_ProcUtilTryShutdownTrx(trx);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcRlcTryShutdownBts(void)
+{
+ DBG_FUNC("grr_ProcRlcTryShutdownBts", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ grr_ProcUtilTryShutdownBts();
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_PROCRLCMSG_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcRrmMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcRrmMsg.cpp new file mode 100644 index 0000000..f444efb --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcRrmMsg.cpp @@ -0,0 +1,142 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCRRMMSG_CPP__
+#define __GRR_PROCRRMMSG_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_ProcRrmMsg(void)
+{
+ unsigned char trx, slot;
+
+ DBG_FUNC("grr_ProcRrmMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ trx = grr_pItcRxRrmMsg->trx; slot = grr_pItcRxRrmMsg->slot;
+
+ DBG_TRACE("grr_ProcRrmMsg: received Rrm msg(%d) trx(%d) slot(%d)\n",
+ grr_pItcRxRrmMsg->message_type, trx, slot);
+
+ //Validate received RRM message
+ if (!grr_ProcRrmValidateMsg()) {DBG_LEAVE(); return;}
+
+ //Only expecting individual slot shutting down acknowledge
+ switch (grr_pItcRxRrmMsg->message_type)
+ {
+ case GRR_TRX_SLOT_SHUTDOWN_ACK:
+ //Received trx slot shutdown ack
+ //
+ grr_ProcRrmTrxSlotShutdownAck(trx,slot);
+
+ break;
+
+ default:
+ break;
+ }
+
+ DBG_LEAVE();
+}
+
+bool grr_ProcRrmValidateMsg(void)
+{
+ unsigned char trx, slot;
+
+ DBG_FUNC("grr_ProcRrmValidateMsg", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+
+ //Validate the RRM message is expected:
+ //
+
+ //Right now only expecting TS shuttingdow acknowledgement
+ if (grr_pItcRxRrmMsg->message_type != GRR_TRX_SLOT_SHUTDOWN_ACK)
+ {
+ DBG_LEAVE();
+ return false;
+ }
+
+ trx = grr_pItcRxRrmMsg->trx; slot = grr_pItcRxRrmMsg->slot;
+
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_ProcRrmValidateMsg: recved slot shutdown ack for invalid trx(%d) slot(%d)\n",
+ trx, slot);
+ DBG_LEAVE();
+ return false;
+ }
+
+ //Check if (trx,slot) is still pending on shutdown ack
+ //
+ if (OAMgrr_TRX_SLOT_AMSTATE(trx,slot) != shuttingDown) {DBG_LEAVE(); return false;}
+
+ //Check if (trx,slot) is configured for circuit-switched use
+ //
+ if ( (OAMgrr_TRX_SLOT_COMB(trx,slot)!=OAMgrr_TRX_SLOT_COMB_5) &&
+ (OAMgrr_TRX_SLOT_COMB(trx,slot)!=OAMgrr_TRX_SLOT_COMB_1) )
+ {
+ DBG_WARNING("grr_ProcRrmValidateMsg: recved trx(%d) slot(%d) shutdown ack chanComb(%d) n.a.\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot));
+ printf("grr_ProcRrmValidateMsg: recved trx(%d) slot(%d) shutdown ack chanComb(%d) n.a.\n",
+ trx, slot, OAMgrr_TRX_SLOT_COMB(trx,slot));
+ DBG_LEAVE();
+ return false;
+ }
+
+ DBG_LEAVE();
+ return true;
+}
+
+
+void grr_ProcRrmTrxSlotShutdownAck(unsigned char trx, unsigned char slot)
+{
+ DBG_FUNC("grr_ProcRrmTrxSlotShutdownAck", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Apply sanitary check
+ if ( (trx>=OAMgrr_MAX_TRXS)||(slot>=8))
+ {
+ DBG_WARNING("grr_ProcRrmTrxSlotShutdownAck: invalid trx(%d) or slot(%d)\n",
+ trx, slot);
+ DBG_LEAVE();
+ return;
+ }
+
+ OAMgrr_CHN_AMSTATEa(trx, slot) = locked;
+ grr_SetOamTrxSlotAmState(trx,slot,locked);
+ grr_SubmitAlarm(grr_TrxSlotAmStateLockedAlarmCode[trx][slot]);
+
+ if (OAMgrr_TRX_AMSTATE(trx)==shuttingDown)
+ grr_ProcRrmTryShutdownTrx(trx);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcRrmTryShutdownTrx(unsigned char trx)
+{
+ DBG_FUNC("grr_ProcRrmTryShutdownTrx", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ grr_ProcUtilTryShutdownTrx(trx);
+
+ DBG_LEAVE();
+}
+
+void grr_ProcRrmTryShutdownBts(void)
+{
+ DBG_FUNC("grr_ProcRrmTryShutdownBts", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ grr_ProcUtilTryShutdownBts();
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_PROCRRMMSG_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_ProcUtil.cpp b/data/mnet/GP10/Host/grr/src/grr_ProcUtil.cpp new file mode 100644 index 0000000..7cfb944 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_ProcUtil.cpp @@ -0,0 +1,105 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_PROCUTIL_CPP__
+#define __GRR_PROCUTIL_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_ProcUtilTryShutdownTrx(unsigned char trx)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_ProcUtilTryShutdownTrx", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Apply sanitary check
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_ProcUtilTryShutdownTrx: invalid trx(%d)\n", trx);
+ } else
+ {
+ //Scan through all its slots to see if all of them locked or not
+ for (i=0;i<8;i++)
+ {
+ if ( OAMgrr_CHN_AMSTATE(trx, i) == shuttingDown) break;
+ else
+ {
+ if (OAMgrr_CHN_AMSTATE(trx,i) != locked)
+ {
+ DBG_WARNING("grr_ProcUtilTryShutdownTrx: amState(%d) impossible for trx(%d) slot(%d)\n",
+ OAMgrr_CHN_AMSTATE(trx,i),trx,i);
+ OAMgrr_CHN_AMSTATEa(trx,i) = locked;
+ grr_SetOamTrxSlotAmState(trx,i,locked);
+ grr_SubmitAlarm(grr_TrxSlotAmStateLockedAlarmCode[trx][i]);
+ }
+ }
+ }
+
+ if (i>=8)
+ {
+ //Lock the whole trx
+ //
+ OAMgrr_TRX_AMSTATEa(trx) = locked;
+ grr_SubmitAlarm(grr_TrxAmStateLockedAlarmCode[trx]);
+ grr_TuneTrxSynth(trx,0);
+
+ if (OAMgrr_BTS_AMSTATE==shuttingDown)
+ grr_ProcRlcTryShutdownBts();
+ }
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_ProcUtilTryShutdownBts(void)
+{
+ int i,j;
+
+ DBG_FUNC("grr_ProcUtilTryShutdownBts", GRR_LAYER_PROC);
+ DBG_ENTER();
+
+ //Scan through all TRXs to see if all of them locked or not
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ if (OAMgrr_TRX_AMSTATE(i)==shuttingDown) break;
+ else
+ {
+ if (OAMgrr_TRX_AMSTATE(i) != locked)
+ {
+ DBG_WARNING("grr_ProcUtilTryShutdownBts: trx(%d) amState(%d) impossible\n",
+ i, OAMgrr_TRX_AMSTATE(i));
+ OAMgrr_TRX_AMSTATEa(i) = locked;
+ grr_SetOamTrxAmState(i,locked);
+ grr_SubmitAlarm(grr_TrxAmStateLockedAlarmCode[i]);
+ for (j=0;j<8;j++)
+ {
+ if (OAMgrr_CHN_AMSTATE(i,j) != locked)
+ {
+ OAMgrr_CHN_AMSTATEa(i,j) = locked;
+ grr_SetOamTrxSlotAmState(i,j,locked);
+ grr_SubmitAlarm(grr_TrxSlotAmStateLockedAlarmCode[i][j]);
+ }
+ }
+ }
+ }
+ }
+
+ if (i>=OAMgrr_MAX_TRXS)
+ {
+ //Lock BTS
+ OAMgrr_BTS_AMSTATEa = locked;
+ grr_SetOamBtsAmState(locked);
+ grr_SubmitAlarm(EC_GRR_BTS_LOCKED);
+ }
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_PROCUTIL_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_RadioCtrl.cpp b/data/mnet/GP10/Host/grr/src/grr_RadioCtrl.cpp new file mode 100644 index 0000000..9d9b63b --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_RadioCtrl.cpp @@ -0,0 +1,722 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+#ifndef __GRR_RADIOCTRL_CPP__
+#define __GRR_RADIOCTRL_CPP__
+
+#include "dsp/dsptypes.h"
+#include "dsp/dsphmsg.h"
+#include "grr/grr_head.h"
+
+extern int l1pTrxSwapState; /* 1/0 - swap/don't swap trx-dsp mapping */
+extern "C" int DS1780_getCdcTemp(void);
+extern "C" STATUS I2Cwrite(unsigned char*, unsigned char, unsigned char, int);
+extern "C" STATUS I2Cread(unsigned char*, unsigned char, unsigned char, int);
+extern "C" void I2Coperation(int);
+
+#define MONITOR_INTERVAL 60 // in seconds
+
+#define ON 1
+#define OFF 0
+
+/* Added to support ConfigTxPwrValues in l1Proxy.cpp */
+#define PWR_TABLE_ADDR 0x00
+#define TX_STEP_TABLE_SIZE 36
+#define TX_FREQ_SWEEP_SIZE 15
+#define RX_GAIN_CHAR_SIZE 6
+#define END_MARKER_SIZE 1
+#define END_MARKER_VALUE 0x2b
+
+#define PWR_TABLE_SIZE (2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + RX_GAIN_CHAR_SIZE + END_MARKER_SIZE)
+
+#define EEPROM_STATUS_OK 0
+#define EEPROM_STATUS_UPDATE 1
+#define EEPROM_STATUS_REPORT_ERROR 2
+
+int grrPowerValsConfigured = 0;
+
+/*****************************************************************************
+ *
+ * Module Name: pwrtempadjust
+ *
+ * Purpose: Query system temperature, determine Tx DAC offset due to
+ * temperature and send the offset to both DSPs
+ *
+ *****************************************************************************/
+#define CLIP_VALUE 75
+
+/* globals for all functions */
+
+int lowTempStart = 10;
+float lowTempSlope = 0.99;
+int highTempStart = 44;
+float highTempSlope = 1.02;
+int lowestTempRead;
+int highestTempRead;
+int deltaDAC = 0;
+int PwrAdjDiag=0;
+int gEnablePwrTempAdjust=1;
+
+void InitializeTempAdjust(int interval)
+{
+ DBG_FUNC("InitializeTempAdjust",GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ int temperatureValue;
+
+ temperatureValue=DS1780_getCdcTemp();
+ lowestTempRead=temperatureValue;
+ highestTempRead=temperatureValue;
+
+ DBG_TRACE("Power Temperature Adjust Active with interval time of %d\n",interval);
+ DBG_TRACE(" Low temp start point:%d Low temp slope:%f\n",lowTempStart,lowTempSlope);
+ DBG_TRACE(" High temp start point:%d High temp slope:%f\n",highTempStart,highTempSlope);
+
+ DBG_LEAVE();
+}
+
+
+void pwrtempadjust ( )
+{
+ int temperatureValue;
+ int deltaDAC;
+ unsigned char buffer[40];
+
+ DBG_FUNC("pwrtempadjust",GRR_LAYER_DSP);
+ DBG_ENTER();
+ temperatureValue=DS1780_getCdcTemp();
+
+ /*
+ * If temperature compensation is enabled and measured temperature is within legal range...
+ */
+ if ( gEnablePwrTempAdjust && CLIP_VALUE>temperatureValue )
+ {
+ if (temperatureValue>highestTempRead)
+ highestTempRead=temperatureValue;
+
+ if (temperatureValue<lowestTempRead)
+ lowestTempRead=temperatureValue;
+
+ if (PwrAdjDiag>=2) {
+ DBG_TRACE(" pwrtempadjust: Temperature is %d\n",temperatureValue);
+ }
+
+ deltaDAC = 0;
+ if (temperatureValue>highTempStart) {
+ deltaDAC = (int)(highTempSlope*(float)(temperatureValue-highTempStart));
+ if (PwrAdjDiag>=1) {
+ DBG_TRACE(" pwrtempadjust: High temperature is %d, Adjustment is %d\n", temperatureValue, deltaDAC);
+ }
+ } else if (temperatureValue<lowTempStart) {
+ deltaDAC = (int)(lowTempSlope*(float)(temperatureValue-lowTempStart));
+ if (PwrAdjDiag>=1) {
+ DBG_TRACE(" pwrtempadjust: Low temperature is %d, Adjustment is %d\n", temperatureValue, deltaDAC);
+ }
+ }
+
+ /*-- Send Temp Compensation message to DSP 0 --*/
+ buffer[0] = TRX_MANAGE_MSG; /* function type */
+ buffer[1] = TEMPERATURE_COMPENSATION>>8;
+ buffer[2] = TEMPERATURE_COMPENSATION;
+ buffer[3] = 0;
+ buffer[4] = deltaDAC & 0xff; /* DAC offset due to temperature */
+ api_SendMsgFromRmToL1(5, buffer);
+
+ /*-- Send Temp Compensation message to DSP 1 --*/
+ buffer[3] = 1;
+ api_SendMsgFromRmToL1(5, buffer);
+
+ if (PwrAdjDiag>=2) {
+ DBG_TRACE(" pwrtempadjust: out of control loop\n");
+ }
+ }
+ else if ( gEnablePwrTempAdjust )
+ {
+ if (PwrAdjDiag>=1) {
+ DBG_ERROR(" pwrtempadjust: TEMPERATURE OUT OF RANGE: %d\n",temperatureValue);
+ }
+ }
+ else
+ {
+ if (PwrAdjDiag>=2) {
+ DBG_TRACE(" pwrtempadjust: Temperature compensation is disabled (gEnablePwrTempAdjust=0)\n");
+ }
+ }
+
+ DBG_LEAVE();
+}
+
+/*****************************************************************************
+ *
+ * Module Name: pwrtempadjustPrintStats
+ *
+ *****************************************************************************/
+int pwrtempadjustPrintStats(void)
+{
+ printf(" pwrtempadjust: lowest temp, highest temp, current deltaDAC: %d, %d, %d\n",
+ lowestTempRead, highestTempRead, deltaDAC);
+}
+
+/*****************************************************************************
+ *
+ * Module Name: EnablePwrTempAdjust
+ *
+ *****************************************************************************/
+void EnablePwrTempAdjust(void)
+{
+ gEnablePwrTempAdjust = 1;
+ printf(" Temperature Compensation is now Enabled\n");
+}
+
+/*****************************************************************************
+ *
+ * Module Name: DisablePwrTempAdjust
+ *
+ *****************************************************************************/
+void DisablePwrTempAdjust(void)
+{
+ unsigned char buffer[40];
+
+ gEnablePwrTempAdjust = 0;
+
+ /*-- Send Temp Compensation message to DSP 0 --*/
+ buffer[0] = TRX_MANAGE_MSG; /* function type */
+ buffer[1] = TEMPERATURE_COMPENSATION>>8;
+ buffer[2] = TEMPERATURE_COMPENSATION;
+ buffer[3] = 0; /* trx 0 */
+ buffer[4] = 0; /* DAC offset due to temperature */
+ api_SendMsgFromRmToL1(5, buffer);
+
+ /*-- Send Temp Compensation message to DSP 1 --*/
+ buffer[3] = 1; /* trx 1 */
+ api_SendMsgFromRmToL1(5, buffer);
+
+ printf(" Temperature Compensation is now Disabled\n");
+}
+
+
+/*****************************************************************************
+ *
+ * Module Name: grr_RadioMonitor
+ *
+ *****************************************************************************/
+void grr_RadioMonitor()
+{
+ RMDBG_ENTER(("ENTER@rm_RadioMonitor()",GRR_LAYER_DSP));
+
+ int interval = sysClkRateGet() * MONITOR_INTERVAL;
+
+ InitializeTempAdjust(interval);
+
+ grrMonTaskObj.JCTaskEnterLoop();
+
+ /* spin here until some power values have been configured */
+ while (grrPowerValsConfigured <= 1)
+ {
+ taskDelay(10);
+ }
+
+ while (1)
+ {
+ taskDelay(interval);
+
+ pwrtempadjust();
+ }
+
+ grrMonTaskObj.JCTaskNormExit();
+
+}
+
+
+/*****************************************************************************
+ *
+ * Module Name: ConfigTxPwrValues
+ *
+ * Purpose: Handler for the Request to Configure Radio Tx Pwr Values msg.
+ * It reads the Power Tables for both Tx's and sends them to the
+ * associated DSP.
+ *
+ *****************************************************************************/
+void ConfigTxPwrValues(unsigned char trx)
+{
+ STATUS I2CStatus;
+ unsigned char pwrCalTable[PWR_TABLE_SIZE];
+ unsigned char *pwrcal_ptr = &pwrCalTable[0];
+ unsigned char radioEEpromDevAddr = 0x53;
+ UINT8 MsgLen = 0;
+ int i;
+ unsigned short length;
+ unsigned char buffer[40];
+
+ DBG_FUNC("ConfigTxPwrValues",GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ I2Coperation(ON);
+ I2CStatus = I2Cread(pwrcal_ptr, radioEEpromDevAddr, (unsigned char)PWR_TABLE_ADDR, (int)PWR_TABLE_SIZE);
+ I2Coperation(OFF);
+
+ if ( I2CStatus != OK )
+ {
+ DBG_ERROR( "Error in I2Cread() from ConfigTxPwrValues()\n" );
+ }
+ else
+ {
+ /*
+ * Construct a temporary packed calibration table for the appropriate DSP. Start with the
+ * appropriate 36-byte step table, followed by the appropriate 15-byte frequency sweep,
+ * followed by the 6-byte rx gain table. These sub-tables will be sent to the DSP below.
+ */
+ if((!l1pTrxSwapState && trx == 0) || (l1pTrxSwapState && trx == 1))
+ {
+ /*
+ * Construct packed calibration table for hopping radio on DSP A
+ */
+ for ( i=0; i<RX_GAIN_CHAR_SIZE ; i++ ) // move Rx gain table to follow step and sweep tables
+ {
+ pwrCalTable[TX_STEP_TABLE_SIZE + TX_FREQ_SWEEP_SIZE + i]
+ = pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + i];
+ }
+
+ }
+ else
+ {
+ /*
+ * Construct packed calibration table for non-hopping radio on DSP B
+ */
+ for ( i=0; i<TX_STEP_TABLE_SIZE ; i++ ) // move step table to beginning
+ {
+ pwrCalTable[i] = pwrCalTable[TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + i];
+ }
+ for ( i=0; i<TX_FREQ_SWEEP_SIZE ; i++ ) // move sweep table to follow step table
+ {
+ pwrCalTable[TX_STEP_TABLE_SIZE + i] = pwrCalTable[TX_STEP_TABLE_SIZE + TX_FREQ_SWEEP_SIZE + i];
+ }
+ for ( i=0; i<RX_GAIN_CHAR_SIZE ; i++ ) // move Rx gain table to follow sweep table
+ {
+ pwrCalTable[TX_STEP_TABLE_SIZE + TX_FREQ_SWEEP_SIZE + i]
+ = pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + i];
+ }
+ }
+ /*
+ * Send Tx Pwr Step Table to this DSP
+ */
+ length = 0;
+ buffer[length++] = TRX_MANAGE_MSG; /* function type */
+ buffer[length++] = RADIO_TX_PWR_CHAR_CONFIG>>8;
+ buffer[length++] = RADIO_TX_PWR_CHAR_CONFIG;
+ buffer[length++] = trx;
+ for(i=0; i<TX_STEP_TABLE_SIZE; i++)
+ {
+ buffer[length++] = pwrCalTable[i];
+ }
+ api_SendMsgFromRmToL1(length, buffer);
+
+ /*
+ * Send Tx Offset vs. Frequency Table to this DSP
+ */
+ length = 0;
+ buffer[length++] = TRX_MANAGE_MSG; /* function type */
+ buffer[length++] = TX_PWR_OFFSETS_CONFIG>>8;
+ buffer[length++] = TX_PWR_OFFSETS_CONFIG;
+ buffer[length++] = trx;
+ for(i=0; i<TX_FREQ_SWEEP_SIZE; i++)
+ {
+ buffer[length++] = pwrCalTable[TX_STEP_TABLE_SIZE + i];
+ }
+ api_SendMsgFromRmToL1(length, buffer);
+
+ /*
+ * Send Tx Offset vs. Frequency Table to this DSP
+ */
+ length = 0;
+ buffer[length++] = TRX_MANAGE_MSG; /* function type */
+ buffer[length++] = RADIO_GAIN_CHAR_CONFIG>>8;
+ buffer[length++] = RADIO_GAIN_CHAR_CONFIG;
+ buffer[length++] = trx;
+ for(i=0; i<RX_GAIN_CHAR_SIZE; i++)
+ {
+ buffer[length++] = pwrCalTable[TX_STEP_TABLE_SIZE + TX_FREQ_SWEEP_SIZE + i];
+ }
+
+ api_SendMsgFromRmToL1(length, buffer);
+ }
+
+ grrPowerValsConfigured++;
+
+ DBG_LEAVE();
+}
+
+
+/*****************************************************************************
+ *
+ * Module Name: ReadEeprom
+ *
+ * Purpose: Read Tx calibration tables and uplink amp characteristics from
+ * EEPROM on the RF board
+ *
+ *****************************************************************************/
+STATUS ReadEeprom(void)
+{
+ STATUS I2CStatus;
+ unsigned char PwrCalTable[PWR_TABLE_SIZE];
+ unsigned char *pwrcal_ptr = &PwrCalTable[0]; // pointless?
+ unsigned char radioEEpromDevAddr = 0x53;
+ UINT8 MsgLen = 0;
+ int i, j = 0;
+
+ DBG_FUNC("ReadEeprom",GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ I2Coperation(ON);
+ I2CStatus = I2Cread(pwrcal_ptr, radioEEpromDevAddr, (unsigned char)PWR_TABLE_ADDR, (int)PWR_TABLE_SIZE);
+ I2Coperation(OFF);
+
+ printf("After EEPROM read, I2CStatus = %d\n", I2CStatus);
+ for ( i=0; i<PWR_TABLE_SIZE; i++ )
+ {
+ printf("%02x ", PwrCalTable[i]);
+ if ( i%10 == 9 )
+ {
+ printf("\n");
+ }
+ }
+ printf("\n");
+ DBG_LEAVE();
+}
+
+
+/*****************************************************************************
+ *
+ * Module Name: WriteEeprom
+ *
+ * Purpose: Write Tx calibration tables and uplink amp characteristics to
+ * EEPROM on the RF board
+ *
+ *****************************************************************************/
+STATUS WriteEeprom(void)
+{
+ STATUS I2CStatus;
+ unsigned char radioEEpromDevAddr = 0x53;
+ UINT8 MsgLen = 0;
+ int i, k;
+ FILE *fp;
+ int pwrCalTable[PWR_TABLE_SIZE];
+ UINT8 usByte;
+
+ DBG_FUNC("WriteEeprom",GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ if ( fp = fopen("PowerCalTable.txt", "r") )
+ {
+
+ /*
+ * Read in 1 table of DAC values vs. Static Power Level (step)
+ * Note: this assumes TX_STEP_TABLE_SIZE is 36, format 9 across
+ */
+ for ( i=0; i<4; i++ )
+ {
+ k=9*i;
+ fscanf(fp, "%x %x %x %x %x %x %x %x %x",
+ pwrCalTable + k,
+ pwrCalTable + k + 1,
+ pwrCalTable + k + 2,
+ pwrCalTable + k + 3,
+ pwrCalTable + k + 4,
+ pwrCalTable + k + 5,
+ pwrCalTable + k + 6,
+ pwrCalTable + k + 7,
+ pwrCalTable + k + 8 );
+ }
+ /*
+ * Read in 2 tables of DAC values vs. Static Power Level (sweep)
+ * Note: this assumes TX_FREQ_SWEEP_SIZE is 15, format 15 across
+ */
+ for ( i=0; i<2; i++ )
+ {
+ k=15*i;
+ fscanf(fp, "%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
+ pwrCalTable + TX_STEP_TABLE_SIZE + k,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 1,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 2,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 3,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 4,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 5,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 6,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 7,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 8,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 9,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 10,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 11,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 12,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 13,
+ pwrCalTable + TX_STEP_TABLE_SIZE + k + 14 );
+ }
+ /*
+ * Read in 2nd table of DAC values vs. Static Power Level (step)
+ * Note: this assumes TX_STEP_TABLE_SIZE is 36, format 9 across
+ */
+ for ( i=0; i<4; i++ )
+ {
+ k=9*i;
+ fscanf(fp, "%x %x %x %x %x %x %x %x %x",
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 1,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 2,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 3,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 4,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 5,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 6,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 7,
+ pwrCalTable + TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + k + 8 );
+ }
+ /*
+ * Read in Amplifier Gain Characteristic
+ * Note: this assumes RX_GAIN_CHAR_SIZE is 6
+ */
+ fscanf(fp, "%x %x %x %x %x %x",
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE,
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + 1,
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + 2,
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + 3,
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + 4,
+ pwrCalTable + 2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + 5 );
+
+ fclose(fp);
+
+ /*
+ * Append marker byte(s)
+ */
+ for ( i=0; i<END_MARKER_SIZE; i++ )
+ {
+ pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + RX_GAIN_CHAR_SIZE + i] = END_MARKER_VALUE;
+ }
+
+ I2Coperation(ON);
+ /* EEPROM on radio board needs to be fed 1 byte at a time */
+ for ( i=0; i<PWR_TABLE_SIZE; i++ )
+ {
+ usByte = (UINT8)pwrCalTable[i];
+ printf("%02x ", usByte);
+ if ( i%10 == 9 )
+ {
+ printf("\n");
+ }
+ I2CStatus = I2Cwrite(&usByte, radioEEpromDevAddr, (unsigned char)i, 1);
+ taskDelay(2); /* Limit how fast the EEPROM gets the bytes */
+ }
+ I2Coperation(OFF);
+ printf("\nAfter EEPROM write, I2CStatus = %d\n", I2CStatus);
+ }
+ else
+ {
+ printf("\nError: Could not open PowerCalTable.txt\n");
+ }
+
+ DBG_LEAVE();
+}
+
+
+
+/*****************************************************************************
+ *
+ * Module Name: CheckEeprom
+ *
+ * Purpose: Read Tx calibration tables form EEPROM. If marker byte(s) missing,
+ * then (1) set output status to generate alarm, (2) construct table
+ * in Rel 1.5+ format by duplicating step table and appending uplink
+ * amplifier characteristics and marker, and (3) write table back
+ * to EEPROM.
+ *
+ * NOTE: The EEPROM update portion of CheckEeprom is intended to catch up
+ * pre-FCS GP10s and pre-Rel-1.5 GP10s to the EEPROM convention used
+ * in Release 1.5 and beyond. If more parameters are added to EEPROM
+ * in the future, then CheckEeprom is an ideal place to add updating
+ * code for the new format.
+ *
+ * Pre-FCS Format:
+ * 36-byte step table, two 15-byte sweep tables
+ *
+ * Pre-Rel-1.5 Format:
+ * 36-byte step table, two 15-byte sweep tables,
+ * 6-byte rx gain table, 1-byte marker
+ *
+ * Rel-1.5+ Format:
+ * one 36-byte step table, two 15-byte sweep tables,
+ * another 36-byte step table, 6-byte rx gain table, 1-byte marker
+ *
+ *****************************************************************************/
+STATUS CheckEeprom(void)
+{
+ STATUS I2CStatus;
+ unsigned char pwrCalTable[PWR_TABLE_SIZE];
+ unsigned char *pwrcal_ptr = &pwrCalTable[0]; // pointless?
+ unsigned char radioEEpromDevAddr = 0x53;
+ UINT8 usByte;
+ int i;
+ long ais;
+ int foundMarkerNewFormat;
+ int foundMarkerOldFormat;
+ int writeToEeprom = FALSE;
+ int appendUplinkInfo = FALSE;
+ STATUS returnValue;
+ /*--- Uplink amp characteristics for 900, 1800, 1900 as of 8/21/00 ---*/
+ UINT8 gainChar[3][RX_GAIN_CHAR_SIZE] = {
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+ {0x0d, 0x80, 0x01, 0x90, 0x02, 0x80},
+ {0x0f, 0x0f, 0x00, 0xd0, 0x01, 0x80} };
+ char aisname[3][9] = { {"GSM-900"}, {"DCS-1800"}, {"PCS-1900"} };
+ UINT8 defaultCalTable[PWR_TABLE_SIZE] = {
+ 0xd0,0xc8,0x54,0x43,0x37,0x22,0x32,0x22,0x23,
+ 0x23,0x33,0x24,0x34,0x43,0x55,0x44,0x54,0x54,
+ 0x44,0x34,0x33,0x42,0x33,0x23,0x32,0xc2,0x22,
+ 0x12,0x22,0x22,0x22,0x22,0x22,0x32,0x43,0x72,
+ 6, 6, 6, 7, 5, 5, 2, 0, 0, 2, 7, 9, 6, 5, 4,
+ 5, 5, 5, 5, 5, 3, 0, 0, 0, 0, 5, 7, 9, 3, 2,
+ 0xd0,0xc8,0x54,0x43,0x37,0x22,0x32,0x22,0x23,
+ 0x23,0x33,0x24,0x34,0x43,0x55,0x44,0x54,0x54,
+ 0x44,0x34,0x33,0x42,0x33,0x23,0x32,0xc2,0x22,
+ 0x12,0x22,0x22,0x22,0x22,0x22,0x32,0x43,0x72,
+ 0x0d,0x80,0x01,0x90,0x02,0x80,0x2b };
+
+ DBG_FUNC("CheckEeprom",RM_LAYER);
+ DBG_ENTER();
+
+ /*--------------------------------------------------------------------------
+ * Read power cal table from EEPROM
+ *--------------------------------------------------------------------------*/
+ I2Coperation(ON);
+ I2CStatus = I2Cread(pwrcal_ptr, radioEEpromDevAddr, (unsigned char)PWR_TABLE_ADDR, (int)PWR_TABLE_SIZE);
+ I2Coperation(OFF);
+ printf("After EEPROM read, I2CStatus = %d\n", I2CStatus);
+
+ /*--------------------------------------------------------------------------
+ * Check whether marker byte(s) are already in EEPROM at end of table in
+ * Release 1.5+ Format and also whether marker byte(s) are present at
+ * location used by earlier formats.
+ *--------------------------------------------------------------------------*/
+ foundMarkerNewFormat = TRUE;
+ foundMarkerOldFormat = TRUE;
+ for ( i=0; i<END_MARKER_SIZE; i++ )
+ {
+ if ( pwrCalTable[TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + RX_GAIN_CHAR_SIZE + i] != END_MARKER_VALUE )
+ {
+ foundMarkerOldFormat = FALSE;
+ }
+ }
+ for ( i=0; i<END_MARKER_SIZE; i++ )
+ {
+ if ( pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + RX_GAIN_CHAR_SIZE + i] != END_MARKER_VALUE )
+ {
+ foundMarkerNewFormat = FALSE;
+ }
+ }
+
+ /*--------------------------------------------------------------------------
+ * Check first two values of first step table. Both must be larger than
+ * 0x40 and in order of decreasing value (or equal). If not, copy default
+ * table and set flags to look up AIS, write to EEPROM and send alarm.
+ *--------------------------------------------------------------------------*/
+ if ( pwrCalTable[0]>0x40 && pwrCalTable[1]>0x40 && pwrCalTable[0]>=pwrCalTable[1] )
+ {
+ returnValue = EEPROM_STATUS_OK;
+ }
+ else
+ {
+ for ( i=0; i<PWR_TABLE_SIZE; i++ )
+ {
+ pwrCalTable[i] = defaultCalTable[i];
+ }
+ appendUplinkInfo = TRUE;
+ writeToEeprom = TRUE;
+ returnValue = EEPROM_STATUS_REPORT_ERROR;
+ }
+
+ /*--------------------------------------------------------------------------
+ * If marker is correct for Release 1.5+ and not for earlier format, then
+ * no action is required. Otherwise, update EEPROM format by duplicating
+ * the step table. For details, see format description in function header.
+ * NOTE: If markers are present for both formats, the GP could have been
+ * loaded with Release 1.5+, then reverted to an earlier release. In this
+ * case, we still need to update EEPROM.
+ *--------------------------------------------------------------------------*/
+ if ( returnValue==EEPROM_STATUS_OK && (!foundMarkerNewFormat || foundMarkerOldFormat) )
+ {
+ appendUplinkInfo = TRUE;
+ writeToEeprom = TRUE;
+ returnValue = EEPROM_STATUS_UPDATE;
+ /*--------------------------------------------------------------------------
+ * Duplicate existing step table to produce one for each Tx path
+ *--------------------------------------------------------------------------*/
+ for ( i=0; i<TX_STEP_TABLE_SIZE; i++ )
+ {
+ pwrCalTable[TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + i] = pwrCalTable[i];
+ }
+ }
+
+ /*--------------------------------------------------------------------------
+ * If indicated, look up Air Interface Std (AIS) in MIB and append table
+ *--------------------------------------------------------------------------*/
+ if ( appendUplinkInfo )
+ {
+ oam_getMibIntVar(MIB_gsmdcsIndicator, &ais);
+ if ( ais < 0 )
+ {
+ returnValue = EEPROM_STATUS_REPORT_ERROR;
+ printf("Error: MIB contains AIS=%d. Should be 0-2. Defaulting to 1 (DCS1800).\n", ais);
+ ais = 1;
+ }
+ else if ( ais > 2 )
+ {
+ returnValue = EEPROM_STATUS_REPORT_ERROR;
+ printf("Error: MIB contains AIS=%d. Should be 0-2. Defaulting to 1 (DCS1800).\n", ais);
+ ais = 1;
+ }
+ printf("Updating EEPROM for %s system\n", aisname[ais]);
+
+ /*--------------------------------------------------------------------------
+ * Append uplink amplifier information specific to AIS, plus marker byte(s)
+ *--------------------------------------------------------------------------*/
+ for ( i=0; i<RX_GAIN_CHAR_SIZE; i++ )
+ {
+ pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + i] = gainChar[ais][i];
+ }
+ for ( i=0; i<END_MARKER_SIZE; i++ )
+ {
+ pwrCalTable[2*TX_STEP_TABLE_SIZE + 2*TX_FREQ_SWEEP_SIZE + RX_GAIN_CHAR_SIZE + i] = END_MARKER_VALUE;
+ }
+ }
+
+ /*--------------------------------------------------------------------------
+ * If indicated, write power cal table to EEPROM and report values to shell
+ *--------------------------------------------------------------------------*/
+ if ( writeToEeprom )
+ {
+ I2Coperation(ON);
+ /*--EEPROM on radio board needs to be fed 1 byte at a time--*/
+ for ( i=0; i<PWR_TABLE_SIZE; i++ )
+ {
+ usByte = (UINT8)pwrCalTable[i];
+ printf("%02x ", usByte);
+ if ( i%10 == 9 )
+ {
+ printf("\n");
+ }
+ I2CStatus = I2Cwrite(&usByte, radioEEpromDevAddr, (unsigned char)i, 1);
+ taskDelay(2); /* Limit how fast the EEPROM gets the bytes */
+ }
+ I2Coperation(OFF);
+ printf("\nAfter EEPROM write, I2CStatus = %d\n", I2CStatus);
+ }
+ DBG_LEAVE();
+
+ return(returnValue);
+}
+
+
+
+#endif /* __GRR_RADIOCTRL_CPP__ */
diff --git a/data/mnet/GP10/Host/grr/src/grr_SendDspMsg.cpp b/data/mnet/GP10/Host/grr/src/grr_SendDspMsg.cpp new file mode 100644 index 0000000..45c2bb8 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_SendDspMsg.cpp @@ -0,0 +1,259 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_SENDDSPMSG_CPP__
+#define __GRR_SENDDSPMSG_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_SendDspSynInf(unsigned char trx)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_SendDspSynInf", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SendDspSynInf: for trx(%d)\n", trx);
+
+
+ //Fill Synchronization Information
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_SYNCH_MSB;
+ buf[len++] = GRR_L1MT_SYNCH_LSB;
+ buf[len++] = trx;
+ buf[len++] = 0;
+ buf[len++] = 0;
+ buf[len++] = 0;
+ buf[len++] = 0;
+
+ //store len in little endian
+ buf[0] = (unsigned char)len;
+ buf[1] = (unsigned char)(len>>8);
+ buf[2] = (unsigned char)(len>>16);
+ buf[3] = (unsigned char)(len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_SendDspArfcn(unsigned char trx, int swap)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ unsigned short arfcn;
+
+ DBG_FUNC("grr_SendDspArfcn", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //apply sanitary check
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_SendDspArfcn: invalid trx(%d)\n", trx);
+ DBG_LEAVE();
+ return;
+ }
+
+ switch(trx)
+ {
+ case 0:
+ arfcn = OAMgrr_ARFCN(0);
+ break;
+ case 1:
+ arfcn = OAMgrr_ARFCN(1);
+ break;
+ }
+
+ DBG_TRACE("grr_SendDspArfcn: send arfn(%d) to trx(%d) swap(%d)\n",
+ arfcn, trx, swap);
+
+ //Send arfcn via TUNE SYNTH message
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_ARFCN_MSB;
+ buf[len++] = GRR_L1MT_ARFCN_LSB;
+ buf[len++] = trx;
+ buf[len++] = (unsigned char)(arfcn>>8);
+ buf[len++] = (unsigned char)(arfcn);
+ //store len in little endian
+ buf[0] = (unsigned char)len;
+ buf[1] = (unsigned char)(len>>8);
+ buf[2] = (unsigned char)(len>>16);
+ buf[3] = (unsigned char)(len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+//Send ping message to dsp
+void grr_SendDspPing(int dsp)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_SendDspPing", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //Form ping message
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_PING_MSB;
+ buf[len++] = GRR_L1MT_PING_LSB;
+ buf[len++] = (unsigned char)dsp;
+
+ //store len in little endian
+ buf[0] = (unsigned char)len;
+ buf[1] = (unsigned char)(len>>8);
+ buf[2] = (unsigned char)(len>>16);
+ buf[3] = (unsigned char)(len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_SendDspSlotActivate(unsigned char trx, unsigned char slot)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_SendDspSlotActivate", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //ATTN:
+ //slot's bit 8-5 i.e. 5 MSB bits must be masked by caller of this
+ //function. Caller is also responsibile for validity of SLOT COMB
+ //value associated with this slot. This function just passes COMB
+ //to DSP without guard check of the input values' validity.
+
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT; //0x10
+ buf[len++] = GRR_L1MT_SLOTACTIV_MSB; //0x17
+ buf[len++] = GRR_L1MT_SLOTACTIV_LSB; //0x00
+ buf[len++] = trx;
+ buf[len++] = slot;
+ buf[len++] = OAMgrr_TRX_SLOT_COMB(trx,slot);
+
+ if ( (OAMgrr_TRX_SLOT_COMB(trx,slot) != OAMgrr_SLOT_COMB_1) &&
+ (OAMgrr_TRX_SLOT_COMB(trx,slot) != OAMgrr_SLOT_COMB_5) &&
+ (OAMgrr_TRX_SLOT_COMB(trx,slot) != OAMgrr_SLOT_COMB_13) )
+ {
+ DBG_ERROR("grr_SendDspSlotActivate: invalid config (%d) for (trx=%d,slot=%d)\n",
+ OAMgrr_TRX_SLOT_COMB(trx,slot), trx, slot);
+ printf("grr_SendDspSlotActivate: invalid config (%d) for (trx=%d,slot=%d)\n",
+ OAMgrr_TRX_SLOT_COMB(trx,slot), trx, slot);
+
+ assert(0);
+ }
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_SendDspTrxConfig(unsigned char trx)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+
+ DBG_FUNC("grr_SendDspTrxConfig", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ //skip the len of 4 bytes in the beginning
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT; //0x10
+ buf[len++] = GRR_L1MT_TRXCONFIG_MSB; //0x15
+ buf[len++] = GRR_L1MT_TRXCONFIG_LSB; //0x00
+ buf[len++] = trx;
+ buf[len++] = OAMgrr_AIRINTERFACE;
+ buf[len++] = OAMgrr_POCKETBTS_BSIC;
+ buf[len++] = OAMgrr_NETWORKIFCONFIG; //0x00
+
+ //skip unused fields
+ len += 14;
+ buf[len++] = (unsigned char) OAMgrr_IQ_SWAP;
+
+ //store len in little endian
+ buf[0] = (unsigned char) len;
+ buf[1] = (unsigned char) (len>>8);
+ buf[2] = (unsigned char) (len>>16);
+ buf[3] = (unsigned char) (len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+void grr_SendDspTuneSynth( unsigned char phTrx, unsigned char synth, unsigned char hopping,
+ unsigned char state, unsigned short arfcn)
+{
+ int len;
+ unsigned char buf[GRR_MAX_L1MSG_LEN];
+ unsigned short setting;
+
+ DBG_FUNC("grr_SendDspTuneSynth", GRR_LAYER_DSP);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SendDspTuneSynth: swapInd=%d, hopping=%d, tuneSetting:(%d,%d,%d,%d)\n",
+ OAMgrr_BCCH_CARRIER_phTRX, hopping, phTrx, synth, state, arfcn);
+
+ //Fill TUNE SYNTH message's header portion
+ len = 4;
+ buf[len++] = GRR_L1MG_TRXMGMT;
+ buf[len++] = GRR_L1MT_TUNESYNTH_MSB;
+ buf[len++] = GRR_L1MT_TUNESYNTH_LSB;
+ buf[len++] = 0; //Always sent to BCCH DSP
+
+ setting = 0;
+ setting = ( OAMgrr_phTRX_SELECT(phTrx) | OAMgrr_phTRX_SYNTH_SELECT(synth) |
+ OAMgrr_phTRX_HOPPING(hopping) | OAMgrr_phTRX_PWR_SELECT(state) |
+ (0x3FF&arfcn) );
+
+ buf[len++] = (unsigned char)(setting>>8);
+ buf[len++] = (unsigned char)(setting);
+
+ //store len in little endian
+ buf[0] = (unsigned char)len;
+ buf[1] = (unsigned char)(len>>8);
+ buf[2] = (unsigned char)(len>>16);
+ buf[3] = (unsigned char)(len>>24);
+
+ //dump the message for debug if needed
+ if (grr_DbgDump) DBG_HEXDUMP( (unsigned char*)buf, len );
+
+ sendDsp(buf, len);
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_SENDDSPMSG_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_SetOamMib.cpp b/data/mnet/GP10/Host/grr/src/grr_SetOamMib.cpp new file mode 100644 index 0000000..8ebbb0c --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_SetOamMib.cpp @@ -0,0 +1,234 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_SETOAMMIB_CPP__
+#define __GRR_SETOAMMIB_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_SetOamBtsAmState(AdministrativeState state)
+{
+ DBG_FUNC("grr_SetOamBtsAmState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamBtsAmState: state(%d)\n", state);
+
+ OAMgrr_BTS_AMSTATEa = state;
+
+ if (STATUS_OK !=
+ oam_setMibIntVar(MODULE_GRR,MIB_bts_administrativeState, state) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED);
+ DBG_ERROR("grr_SetOamBtsAmState: oam_setMibIntVar failed for setting bts amState(%d)\n",
+ state);
+ printf("grr_SetOamBtsAmState: oam_setMibIntVar failed for setting bts amState(%d)\n",
+ state);
+ assert(0);
+ }
+ DBG_LEAVE();
+}
+
+void grr_SetOamTrxAmState(unsigned char trx, AdministrativeState state)
+{
+ MibTag tag;
+
+ DBG_FUNC("grr_SetOamTrxAmState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamTrxAmState: set trx(%d) amState(%d)\n", trx, state);
+
+ //Check if the requested trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_SetOamTrxAmState: setting amState(%d) for invalid trx(%d)\n", state,trx);
+ DBG_LEAVE();
+ return;
+ }
+
+ OAMgrr_TRX_AMSTATEa(trx) = state;
+
+ if (trx==0) tag = MIB_basebandAdministrativeState_0;
+ else tag = MIB_basebandAdministrativeState_1;
+
+ if ( STATUS_OK!=oam_setMibIntVar(MODULE_GRR, tag, state) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED);
+ DBG_ERROR("grr_SetOamTrxAmState: oam_setMibIntVar failed for setting trx(%d) amState(%d)\n",
+ trx, state);
+ printf("grr_SetOamTrxAmState: failed in calling oam_setMibIntVar for trx(%d) amState(%d)\n",
+ trx, state);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_SetOamTrxSlotAmState(unsigned char trx, unsigned char slot, AdministrativeState state)
+{
+ MibTag tag;
+ STATUS sta;
+
+ DBG_FUNC("grr_SetOamTrxSlotAmState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamTrxSlotAmState: set trx(%d) slot(%d) amState(%d)\n", trx, slot, state);
+
+ //Check if (trx,slot) existent
+ if ( (trx>=OAMgrr_MAX_TRXS) || (slot>=8) )
+ {
+ DBG_WARNING("grr_SetOamTrxSlotAmState: set amState(%d) for invalid trx(%d) slot(%d)\n",
+ state, trx, slot);
+ DBG_LEAVE();
+ return;
+ }
+
+ if (trx==0) tag=MIBT_channelAdministrativeState_0;
+ else tag=MIBT_channelAdministrativeState_1;
+
+ OAMgrr_CHN_AMSTATEa(trx,slot) = state;
+
+ if ( STATUS_OK!= (sta=oam_setTblEntryField(MODULE_GRR,tag,slot,state)) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED);
+ DBG_ERROR("grr_SetOamTrxSlotAmState: oam_setMibIntVar failed for setting trx(%d) slot(%d) amState(%d) retErr(%d)\n",
+ trx, slot, state,sta);
+ printf("grr_SetOamTrxSlotAmState: oam_setMibIntVar failed for setting trx(%d) slot(%d) amState(%d) retErr(%d)\n",
+ trx, slot, state,sta);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_SetOamTrxOpState(unsigned char trx, EnableDisable state)
+{
+ MibTag tag;
+
+ DBG_FUNC("grr_SetOamTrxOpState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamTrxOpState: set trx(%d) opState(%d)\n",
+ trx, state);
+
+ //Check if the requested trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_SetOamTrxOpState: setting opState(%d) for invalid trx(%d)\n", state,trx);
+ DBG_LEAVE();
+ return;
+ }
+
+ OAMgrr_TRX_OPSTATEa(trx) = state;
+
+ if (trx==0) tag=MIB_basebandOperationalState_0;
+ else tag=MIB_basebandOperationalState_1;
+
+ if ( STATUS_OK!=oam_setMibIntVar(MODULE_GRR, tag, state) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED);
+ DBG_ERROR("grr_SetOamTrxOpState: oam_setMibIntVar failed for setting trx(%d) opState(%d)\n",
+ trx, state);
+ printf("grr_SetOamTrxOpState: oam_setMibIntVar failed for setting trx(%d) opState(%d)\n",
+ trx, state);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_SetOamAllTrxSlotOpState(unsigned char trx, EnableDisable state)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_SetOamAllTrxSlotOpState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamAllTrxSlotOpState: set trx(%d) all slots opState(%d)\n",
+ trx, state);
+
+ //Check if the requested trx existent
+ if (trx>=OAMgrr_MAX_TRXS)
+ {
+ DBG_WARNING("grr_SetOamAllTrxSlotOpState: setting opState(%d) for invalid trx(%d)\n",
+ state,trx);
+ DBG_LEAVE();
+ return;
+ }
+
+ for (i=0;i<8;i++)
+ grr_SetOamTrxSlotOpState(trx,i,state);
+
+ DBG_LEAVE();
+
+}
+
+void grr_SetOamTrxSlotOpState(unsigned char trx, unsigned char slot, EnableDisable state)
+{
+ MibTag tag;
+ STATUS sta;
+
+ DBG_FUNC("grr_SetOamTrxSlotOpState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SetOamTrxSlotOpState: set trx(%d) slot(%d) opState(%d)\n",
+ trx, slot, state);
+
+ OAMgrr_TRX_SLOT_OPSTATEa(trx,slot) = state;
+
+ if (trx==0) tag = MIBT_channelOperationalState_0;
+ else tag = MIBT_channelOperationalState_1;
+
+ if ( STATUS_OK!= (sta=oam_setTblEntryField(MODULE_GRR, tag, slot, state)) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETTBLENTRYFIELD_FAILED);
+ printf("grr_SetOamTrxSlotOpState: oam_setMibIntVar failed for setting trx(%d) slot(%d) opState(%d) retErr(%d)\n",
+ trx, slot, state,sta);
+ DBG_ERROR("grr_SetOamTrxSlotOpState: oam_setMibIntVar failed for setting trx(%d) slot(%d) opState(%d) retErr(%d)\n",
+ trx, slot, state,sta);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_SetOamTrxRcOpState(unsigned char trx, EnableDisable state)
+{
+ unsigned char rc;
+ MibTag tag;
+
+ DBG_FUNC("grr_SetOamTrxRcOpState", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ rc = OAMgrr_TRX_RC(trx);
+
+ DBG_TRACE("grr_SetOamTrxRcOpState: set trx(%d) rc(%d) opState(%d)\n",
+ trx, rc, state);
+
+ OAMgrr_RC_OPSTATEa(rc) = state;
+
+ if (rc==0) tag=MIB_carrier_operationalState_0;
+ else tag=MIB_carrier_operationalState_1;
+
+ if ( STATUS_OK!=oam_setMibIntVar(MODULE_GRR, tag, state) )
+ {
+ grr_SubmitAlarm(EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED);
+ printf("grr_SetOamTrxRcOpState: oam_setMibIntVar failed for setting trx(%d) rc(%d) opState(%d)\n",
+ trx, rc, state);
+ DBG_ERROR("grr_SetOamTrxRcOpState: oam_setMibIntVar failed for setting trx(%d) rc(%d) opState(%d)\n",
+ trx, rc, state);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+
+}
+
+#endif //__GRR_SETOAMMIB_CPP__
+
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_SysInfo.cpp b/data/mnet/GP10/Host/grr/src/grr_SysInfo.cpp new file mode 100644 index 0000000..ef9612b --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_SysInfo.cpp @@ -0,0 +1,369 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_SYSINFO_CPP__
+#define __GRR_SYSINFO_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_PopulateSi2(T_CNI_RIL3_CELL_BARRED_ACCESS barState)
+{
+ unsigned char i, idx;
+
+ DBG_FUNC("grr_PopulateSi2", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_PopulateSi2: update SI2 with barState setting(%d)\n", barState);
+
+ //ZAP grr_Si2 to have a good clean-up
+ memset(&grr_Si2, 0, sizeof(grr_Si2_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si2.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si2.header.si_ti = 0;
+ grr_Si2.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_2;
+
+ //IE: Bcch Frequency List
+ grr_Si2.bcchFreqList.ie_present = true;
+ grr_Si2.bcchFreqList.extInd = CNI_RIL3_EXT_IND_BA_COMPLETE;
+ grr_Si2.bcchFreqList.baInd = CNI_RIL3_EXT_IND_BA_COMPLETE;
+ idx=0;
+ for (i=0;i<OAMgrr_RESEL_ADJCELL_NO_MAX;i++)
+ {
+ if (OAMgrr_RESEL_ADJCELL_ID(i) != OAMgrr_RESEL_ADJCELL_ID_NULL)
+ grr_Si2.bcchFreqList.arfcn[idx++] = OAMgrr_RESEL_ADJCELL_BCCH_ARFCN(i);
+ }
+ grr_Si2.bcchFreqList.numRFfreq = idx;
+ grr_Si2.bcchFreqList.format = CNI_RIL3_SelectFrequencyListFormat(
+ grr_Si2.bcchFreqList.arfcn,idx);
+
+ //IE: Ncc Permitted
+ grr_Si2.nccPermitted.ie_present = true;
+ for (i=0;i<OAMgrr_NCC_PERMITTED_MAX;i++)
+ grr_Si2.nccPermitted.nccPermitted[i] = OAMgrr_NCC_PERMITTED(i);
+
+ //IE: Rach Control
+ grr_Si2.rachControl.ie_present = true;
+ grr_Si2.rachControl.maxRetrans = OAMgrr_RA_RETRY_MAX; //3: 7 times
+ grr_Si2.rachControl.txInt = OAMgrr_RA_TX_INTEGER; //0: wait 3 slots
+ grr_Si2.rachControl.cellBarredAccess = barState; //OAMgrr_RA_CELL_BARRED_STATE;
+ grr_Si2.rachControl.reestablish = OAMgrr_RA_REST_ALLOWED_STATE; //1: not allowed
+ grr_Si2.rachControl.emergencyCall = OAMgrr_RA_EC_ALLOWED_STATE; //1: not allowed
+ for (i=0;i<16;i++)
+ grr_Si2.rachControl.accessClass[i]=OAMgrr_RA_AC_ALLOWED_STATE(i); //1:not allowed
+
+} //grr_PopulateSi2()
+
+
+void grr_PopulateSi3(T_CNI_RIL3_CELL_BARRED_ACCESS barState)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_PopulateSi3", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_grr_PopulateSi3: update SI3 with barState setting(%d)\n", barState);
+
+ //ZAP grr_Si3 to have a good clean-up
+ memset(&grr_Si3, 0, sizeof(grr_Si3_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si3.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si3.header.si_ti = 0;
+ grr_Si3.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_3;
+
+
+ //IE: Cell ID
+ grr_Si3.cellId.ie_present = true;
+ grr_Si3.cellId.value = OAMgrr_CELLID; //0x0001
+
+ //IE: Location Area Identification
+ grr_Si3.locationId.ie_present = true;
+ grr_Si3.locationId.mcc[0] = OAMgrr_MCC(0); //0
+ grr_Si3.locationId.mcc[1] = OAMgrr_MCC(1); //0
+ grr_Si3.locationId.mcc[2] = OAMgrr_MCC(2); //1
+ grr_Si3.locationId.mnc[0] = OAMgrr_MNC(0); //0
+ grr_Si3.locationId.mnc[1] = OAMgrr_MNC(1); //1
+ grr_Si3.locationId.mnc[2] = OAMgrr_MNC(2); //1 kevinlim 05/11/01
+ grr_Si3.locationId.lac = OAMgrr_LAC; //1
+
+ //IE: Control Channel Description
+ grr_Si3.controlChannelDescription.ie_present = true;
+ grr_Si3.controlChannelDescription.att = OAMgrr_ATT_STATE;
+ grr_Si3.controlChannelDescription.bsAgBlksRes = OAMgrr_BS_AG_BLK_RES;
+ grr_Si3.controlChannelDescription.bsPaMfrms = OAMgrr_BS_PA_MFRMS;
+ grr_Si3.controlChannelDescription.ccchConf = OAMgrr_CCCH_CONF;
+ grr_Si3.controlChannelDescription.T3212 = OAMgrr_T3212;
+
+ //IE: Cell Options on BCCH
+ grr_Si3.cellOptions.ie_present = true;
+ grr_Si3.cellOptions.channelType = CNI_RIL3_CELL_OPTIONS_BCCH; //1
+ grr_Si3.cellOptions.pwrc = CNI_RIL3_PWRC_NOT_SET; //0:no hopping
+ grr_Si3.cellOptions.radioLinkTimeout = OAMgrr_RADIO_LINK_TIMEOUT; //3
+ grr_Si3.cellOptions.bcchDtx = OAMgrr_MS_UPLINK_DTX_STATEa; //2
+
+ //IE: Cell Reselection Parameters
+ grr_Si3.cellSelectionParam.ie_present = true;
+ grr_Si3.cellSelectionParam.cellReselectHysteresis = OAMgrr_CELL_RESEL_HYSTERESIS; //2
+ grr_Si3.cellSelectionParam.msTxpwrMaxCCH = OAMgrr_MS_TX_PWR_MAX_CCH; //0
+ grr_Si3.cellSelectionParam.rxlevAccessMin = OAMgrr_MS_RELEV_ACCESS_MIN; //6
+ grr_Si3.cellSelectionParam.neci = CNI_RIL3_NECI_NOT_SUPPORTED; //0
+ grr_Si3.cellSelectionParam.acs = CNI_RIL3_ACS_USE_SI4_RESET_OCTETS; //0
+
+ //IE: Rach Control
+ grr_Si3.rachControl.ie_present = true;
+ grr_Si3.rachControl.maxRetrans = OAMgrr_RA_RETRY_MAX; //3: 7 times
+ grr_Si3.rachControl.txInt = OAMgrr_RA_TX_INTEGER; //0: wait 3 slots
+ grr_Si3.rachControl.cellBarredAccess = barState; //OAMgrr_RA_CELL_BARRED_STATE;
+ grr_Si3.rachControl.reestablish = OAMgrr_RA_REST_ALLOWED_STATE; //1: not allowed
+ grr_Si3.rachControl.emergencyCall = OAMgrr_RA_EC_ALLOWED_STATE; //1: not allowed
+ for (i=0;i<16;i++)
+ grr_Si3.rachControl.accessClass[i] = OAMgrr_RA_AC_ALLOWED_STATE(i); //1:not allowed
+
+ //IE: SI3 Rest Octets
+ grr_Si3.si3RestOctets.ie_present = true;
+ grr_Si3.si3RestOctets.pi = CNI_RIL3_SELECTION_PARAMETER_PRESENT; //1
+ grr_Si3.si3RestOctets.cbq = OAMgrr_CELL_BAR_QUALIFY; //Cell Bar Qualify
+ grr_Si3.si3RestOctets.cellReselectOffset = OAMgrr_CELL_RESELECT_OFFSET;
+ grr_Si3.si3RestOctets.temporaryOffset = OAMgrr_TEMP_OFFEST;
+ grr_Si3.si3RestOctets.penaltyTime = OAMgrr_PENALTY_TIME; //20s
+ grr_Si3.si3RestOctets.poi = CNI_RIL3_POWER_OFFSET_NOT_PRESENTE;
+ grr_Si3.si3RestOctets.powerOffset = 0; //Not applicable
+ grr_Si3.si3RestOctets.si2ter = CNI_RIL3_SI_2TER_NOT_PRESENT;
+ grr_Si3.si3RestOctets.ecsi = CNI_RIL3_EARLY_CLASSMARK_SENDING_FORBIDDEN;
+ grr_Si3.si3RestOctets.wi = CNI_RIL3_WHERE_NOT_PRESENT;
+ grr_Si3.si3RestOctets.where = 0; //Not applicable
+
+ //G2
+ if (OAMgrr_GPRS_FEATURE_SETTING)
+ {
+ grr_Si3.si3RestOctets.gprs_indicator.indicator_present = true;
+ grr_Si3.si3RestOctets.gprs_indicator.ra_color = OAMgrr_GPRS_RA_COLOR;
+ grr_Si3.si3RestOctets.gprs_indicator.si13_position = OAMgrr_SI13_POS;
+ } else
+ grr_Si3.si3RestOctets.gprs_indicator.indicator_present = false;
+
+} //grr_PopulateSi3()
+
+
+void grr_PopulateSi4(T_CNI_RIL3_CELL_BARRED_ACCESS barState)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_PopulateSi4", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_grr_PopulateSi4: update SI4 with barState setting(%d)\n", barState);
+
+ //ZAP grr_Si4 to have a good clean-up
+ memset(&grr_Si4, 0, sizeof(grr_Si4_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si4.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si4.header.si_ti = 0;
+ grr_Si4.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_4;
+
+ //IE: Location Area Identification
+ grr_Si4.locationId.ie_present = true;
+ grr_Si4.locationId.mcc[0] = OAMgrr_MCC(0); //0
+ grr_Si4.locationId.mcc[1] = OAMgrr_MCC(1); //0
+ grr_Si4.locationId.mcc[2] = OAMgrr_MCC(2); //1
+ grr_Si4.locationId.mnc[0] = OAMgrr_MNC(0); //0
+ grr_Si4.locationId.mnc[1] = OAMgrr_MNC(1); //1
+ grr_Si4.locationId.mnc[2] = OAMgrr_MNC(2); //1
+ grr_Si4.locationId.lac = OAMgrr_LAC; //1
+
+ //IE: Cell Reselection Parameters
+ grr_Si4.cellSelectionParam.ie_present = true;
+ grr_Si4.cellSelectionParam.cellReselectHysteresis = OAMgrr_CELL_RESEL_HYSTERESIS; //2
+ grr_Si4.cellSelectionParam.msTxpwrMaxCCH = OAMgrr_MS_TX_PWR_MAX_CCH; //0
+ grr_Si4.cellSelectionParam.rxlevAccessMin = OAMgrr_MS_RELEV_ACCESS_MIN; //6
+ grr_Si4.cellSelectionParam.neci = CNI_RIL3_NECI_NOT_SUPPORTED; //0
+ grr_Si4.cellSelectionParam.acs = CNI_RIL3_ACS_USE_SI4_RESET_OCTETS; //0
+
+ //IE: Rach Control
+ grr_Si4.rachControl.ie_present = true;
+ grr_Si4.rachControl.maxRetrans = OAMgrr_RA_RETRY_MAX; //3: 7 times
+ grr_Si4.rachControl.txInt = OAMgrr_RA_TX_INTEGER; //0: wait 3 slots
+ grr_Si4.rachControl.cellBarredAccess = barState; //OAMgrr_RA_CELL_BARRED_STATE;
+ grr_Si4.rachControl.reestablish = OAMgrr_RA_REST_ALLOWED_STATE; //1: not allowed
+ grr_Si4.rachControl.emergencyCall = OAMgrr_RA_EC_ALLOWED_STATE; //1: not allowed
+ for (i=0;i<16;i++)
+ grr_Si4.rachControl.accessClass[i]=OAMgrr_RA_AC_ALLOWED_STATE(i); //1:not allowed
+
+ //IE(optional):CBCH channel description
+ if (OAMgrr_CB_FEATURE_SETTING)
+ {
+ grr_Si4.cbchChannelDescription.ie_present = true;
+ grr_Si4.cbchChannelDescription.hopping = false;
+ grr_Si4.cbchChannelDescription.channelType = CNI_RIL3_SDCCH_ACCH_4orCBCH;
+ grr_Si4.cbchChannelDescription.subChannelNumber = 2;
+ grr_Si4.cbchChannelDescription.TN = OAMgrr_CBCH_TRX_SLOT;
+ grr_Si4.cbchChannelDescription.TSC = OAMgrr_POCKETBTS_TSC;
+ grr_Si4.cbchChannelDescription.arfcn = OAMgrr_ARFCN(OAMgrr_CBCH_TRX);
+ }
+
+ //IE: SI4 Rest Octets
+ grr_Si4.si4RestOctets.ie_present = true;
+ grr_Si4.si4RestOctets.pi = CNI_RIL3_SELECTION_PARAMETER_PRESENT; //1
+ grr_Si4.si4RestOctets.cbq = OAMgrr_CELL_BAR_QUALIFY; //default 0
+ grr_Si4.si4RestOctets.cellReselectOffset = OAMgrr_CELL_RESELECT_OFFSET;
+ grr_Si4.si4RestOctets.temporaryOffset = OAMgrr_TEMP_OFFEST;
+ grr_Si4.si4RestOctets.penaltyTime = OAMgrr_PENALTY_TIME; //20s
+ grr_Si4.si4RestOctets.poi = CNI_RIL3_POWER_OFFSET_NOT_PRESENTE;
+ grr_Si4.si4RestOctets.powerOffset = 0; //Not applicable
+
+ //G2
+ if (OAMgrr_GPRS_FEATURE_SETTING)
+ {
+ grr_Si4.si4RestOctets.gprs_indicator.indicator_present = true;
+ grr_Si4.si4RestOctets.gprs_indicator.ra_color = OAMgrr_GPRS_RA_COLOR;
+ grr_Si4.si4RestOctets.gprs_indicator.si13_position = OAMgrr_SI13_POS;
+ } else
+ grr_Si4.si4RestOctets.gprs_indicator.indicator_present = false;
+
+} //grr_PopulateSi4()
+
+
+
+void grr_PopulateSi5(void)
+{
+ unsigned char idx,i;
+
+ DBG_FUNC("grr_PopulateSi5", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_grr_PopulateSi5: Update SI5\n");
+
+ //ZAP grr_Si5 to have a good clean-up
+ memset(&grr_Si5, 0, sizeof(grr_Si5_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si5.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si5.header.si_ti = 0;
+ grr_Si5.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_5;
+
+ //IE: Bcch Frequency List
+ grr_Si5.bcchFreqList.ie_present = true;
+ grr_Si5.bcchFreqList.extInd = CNI_RIL3_EXT_IND_BA_COMPLETE;
+ grr_Si5.bcchFreqList.baInd = CNI_RIL3_EXT_IND_BA_COMPLETE;
+
+ idx=0;
+ for (i=0;i<OAMgrr_HO_ADJCELL_NO_MAX;i++)
+ {
+ if (OAMgrr_HO_ADJCELL_ID(i) != OAMgrr_HO_ADJCELL_ID_NULL)
+ grr_Si5.bcchFreqList.arfcn[idx++] = OAMgrr_HO_ADJCELL_BCCH_ARFCN(i);
+ }
+
+ grr_Si5.bcchFreqList.numRFfreq = idx;
+ grr_Si5.bcchFreqList.format = CNI_RIL3_SelectFrequencyListFormat(
+ grr_Si5.bcchFreqList.arfcn,idx);
+} //grr_PopulateSi5()
+
+
+void grr_PopulateSi6(void)
+{
+ unsigned char i;
+
+ DBG_FUNC("grr_PopulateSi6", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_grr_PopulateSi6: Update SI6\n");
+
+ //ZAP grr_Si6 to have a good clean-up
+ memset(&grr_Si6, 0, sizeof(grr_Si6_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si6.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si6.header.si_ti = 0;
+ grr_Si6.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_6;
+
+ //IE: Cell ID
+ grr_Si6.cellId.ie_present = true;
+ grr_Si6.cellId.value = OAMgrr_CELLID; //0x0001
+
+ //IE: Location Area Identification
+ grr_Si6.locationId.ie_present = true;
+ grr_Si6.locationId.mcc[0] = OAMgrr_MCC(0); //0
+ grr_Si6.locationId.mcc[1] = OAMgrr_MCC(1); //0
+ grr_Si6.locationId.mcc[2] = OAMgrr_MCC(2); //1
+ grr_Si6.locationId.mnc[0] = OAMgrr_MNC(0); //0
+ grr_Si6.locationId.mnc[1] = OAMgrr_MNC(1); //1
+ grr_Si6.locationId.mnc[2] = OAMgrr_MNC(2); //1
+ grr_Si6.locationId.lac = OAMgrr_LAC; //1
+
+ //IE: Cell Options on BCCH
+ grr_Si6.cellOptions.ie_present = true;
+ grr_Si6.cellOptions.channelType = CNI_RIL3_CELL_OPTIONS_SACCH; //1
+ grr_Si6.cellOptions.pwrc = CNI_RIL3_PWRC_NOT_SET; //0:no hopping
+ grr_Si6.cellOptions.radioLinkTimeout = OAMgrr_RADIO_LINK_TIMEOUT; //3
+ grr_Si6.cellOptions.sacchDtx = OAMgrr_MS_UPLINK_DTX_STATE;
+
+ //IE: Ncc Permitted
+ grr_Si6.nccPermitted.ie_present = true;
+ for (i=0;i<OAMgrr_NCC_PERMITTED_MAX;i++)
+ grr_Si6.nccPermitted.nccPermitted[i] = OAMgrr_NCC_PERMITTED(i);
+
+} //grr_PopulateSi6()
+
+void grr_PopulateSi13(void)
+{
+ DBG_FUNC("grr_PopulateSi13", GRR_LAYER_OAM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_grr_PopulateSi13: update SI13\n");
+
+ //ZAP grr_Si13 to have a good clean-up
+ memset(&grr_Si13, 0, sizeof(grr_Si13_t));
+
+ //HEADER: PD,MT,SI
+ grr_Si13.header.protocol_descriminator = CNI_RIL3_PD_RRM;
+ grr_Si13.header.si_ti = 0;
+ grr_Si13.header.message_type = CNI_RIL3RRM_MSGID_SYSTEM_INFORMATION_13;
+
+ //IE: SI13 Rest Octets
+ grr_Si13.si13RestOctets.ie_present = true;
+ grr_Si13.si13RestOctets.bcch_change_mark = OAMgrr_BCCH_CHANGE_MARK; //0-4
+ grr_Si13.si13RestOctets.si_change_field = OAMgrr_SI_CHANGE_FIELD; //0-15
+
+ grr_Si13.si13RestOctets.flag_sm = false;
+ grr_Si13.si13RestOctets.si13_change_mark = 0;
+ grr_Si13.si13RestOctets.gprs_ms_allocation.ie_present = false;
+
+ grr_Si13.si13RestOctets.flag_pbcch = false;
+ grr_Si13.si13RestOctets.without_pbcch.rac = OAMgrr_GPRS_RAC;
+ grr_Si13.si13RestOctets.without_pbcch.spgc_ccch_sup = false;
+ grr_Si13.si13RestOctets.without_pbcch.priority_access_thr = 6; // priority 1-4
+ grr_Si13.si13RestOctets.without_pbcch.network_control_order = 1;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.ie_present = true;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.nmo = OAMgrr_GPRS_NMO;
+
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.t3168 = OAMgrr_GPRS_T3168;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.t3192 = OAMgrr_GPRS_T3192;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.drx_timer_max = OAMgrr_GPRS_DRX_TIMER_MAX;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.access_burst_type = OAMgrr_GPRS_ACCESS_BURST_TYPE;
+
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.control_ack_type = OAMgrr_GPRS_CONTROL_ACK_TYPE;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.bs_cv_max = OAMgrr_GPRS_BS_CV_MAX;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.pan_dec = OAMgrr_GPRS_PAN_DEC;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.pan_inc = OAMgrr_GPRS_PAN_INC;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_cell_options.pan_max = OAMgrr_GPRS_PAN_MAX;
+
+ grr_Si13.si13RestOctets.without_pbcch.gprs_power_control_parameters.alpha = OAMgrr_GPRS_ALPHA;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_power_control_parameters.t_avg_w = OAMgrr_GPRS_T_AVG_W;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_power_control_parameters.t_avg_t = OAMgrr_GPRS_T_AVG_T;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_power_control_parameters.pc_meas_chan = OAMgrr_GPRS_PC_MEAS_CHAN;
+ grr_Si13.si13RestOctets.without_pbcch.gprs_power_control_parameters.n_avg_i = OAMgrr_GPRS_N_AVG_I;
+
+ DBG_LEAVE();
+
+} //grr_PopulateSi13()
+
+#endif //__GRR_SYSINFO_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_Task.cpp b/data/mnet/GP10/Host/grr/src/grr_Task.cpp new file mode 100644 index 0000000..0933fe7 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_Task.cpp @@ -0,0 +1,212 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_TASK_CPP__
+#define __GRR_TASK_CPP__
+
+#include "grr\grr_head.h"
+
+void grr_CreateQ(void)
+{
+ DBG_FUNC("grr_CreateQ", GRR_LAYER);
+ DBG_ENTER();
+
+ //Create message queue for GRR module
+ grr_MsgQId = msgQCreate (
+ GRR_MAX_RXMSGS, //Max # of messages
+ sizeof(grr_ItcRxMsg_t), //Max length of msg
+ MSG_Q_PRIORITY //Priority-type que
+ );
+
+ if( grr_MsgQId == NULL )
+ {
+ printf("grr_CreateQ: failed to create GRR Queue, errno (%d)\n", errno);
+ DBG_ERROR("grr_CreateQ: failed to create GRR Queue, errno (%d)\n", errno);
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQCREATE_FAILED);
+ DBG_LEAVE();
+ assert( (grr_MsgQId!=NULL) );
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_Main( void )
+{
+ DBG_FUNC("grr_Main", GRR_LAYER);
+ DBG_ENTER();
+
+ //mainLoop
+ grr_StartDspsWatch();
+ grrTaskObj.JCTaskEnterLoop();
+ //ViperTaskEnterLoop();
+
+ //InitGRR
+ grr_Init();
+ printf("grr_Main: GRR finished initialization\n");
+
+ while(true)
+ {
+ int length;
+
+ //Confirm GRR is staying in its main-loop
+ DBG_TRACE("grr_Main: staying in mainloop\n");
+
+ // Retrieve a message from Q.
+ if ((length = msgQReceive(grr_MsgQId,(char*)&grr_ItcRxMsg, GRR_MAX_RXQMSG_LENGTH, WAIT_FOREVER))
+ == ERROR )
+ {
+ //failed to receive message. VxWorks error. Skip this msg!
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQRECEIVE_FAILED);
+ DBG_ERROR("grr_Main: failed to read VxWorks GRR Queue err(%d)\n", errno);
+ printf("grr_Main: failed to read VxWorks GRR msg Queue err(%d)", errno);
+ assert(0);
+ } else
+ {
+ //Good receive! If needed dump out for debug purpose
+ if (grr_DbgDump) DBG_HEXDUMP(( unsigned char *)&grr_ItcRxMsg, length);
+
+ //Handle the message in terms of origin, apply sanitory check!
+ grr_ItcRxOrigin = grr_ItcRxMsg.module_id;
+
+ //Go in terms of origin
+ switch (grr_ItcRxOrigin)
+ {
+ case MODULE_GRR:
+ //Received GRR messages
+ grr_pItcRxGrrMsg=(grr_ItcRxGrrMsg_t *)&grr_ItcRxMsg.itcRxGrrMsg;
+
+ //If needed output the fact RM got a RM message for trace
+ DBG_TRACE("GRR<=GRR@grr_Main: primitive(%d) message(%x)\n",
+ grr_pItcRxGrrMsg->primitive_type,
+ grr_pItcRxGrrMsg->message_type);
+
+ //Process watch-dog timer expiry here
+ if (grr_pItcRxGrrMsg->primitive_type==GRR_DSP_WDOG_EXPIRED)
+ grr_ProcGrrMsg();
+ else
+ DBG_WARNING("GRR<=GRR: unexpected msg (%d) msg(0x%x)\n",
+ grr_pItcRxGrrMsg->message_type);
+ break;
+
+ case MODULE_L1:
+ //Received L1 messages
+ grr_pItcRxDspMsg=(grr_ItcRxDspMsg_t *)&grr_ItcRxMsg.itcRxDspMsg;
+
+ //If needed output trace for debugging purpose
+ DBG_TRACE("GRR<=L1@grr_Main: received DSP MSG msg(%x,%x,%x) src(%x,%x,%x)\n",
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4],
+ grr_pItcRxDspMsg->buffer[5]);
+
+ grr_ProcDspMsg();
+
+ break;
+
+ case MODULE_OAM:
+ //Received OAM messages
+ grr_pItcRxOamMsg = (grr_ItcRxOamMsg_t *)&grr_ItcRxMsg;
+
+ //If needed output trace for debugging purpose
+ DBG_TRACE("GRR<=OAM@grr_Main: received OAM MSG msgTyp(%d) Tag(%x) valTyp(%d) val(%d)\n",
+ grr_pItcRxOamMsg->msgType,
+ grr_pItcRxOamMsg->mibTag,
+ grr_pItcRxOamMsg->valType,
+ grr_pItcRxOamMsg->val.varVal);
+
+ //
+ grr_ProcOamMsg();
+
+ break;
+
+ case MODULE_RM:
+ //Received RRM messages
+ grr_pItcRxRrmMsg = (grr_ItcRxRrmMsg_t *)&grr_ItcRxMsg;
+
+ //If needed output trace for debugging purpose
+ DBG_TRACE("GRR<=RRM@grr_Main: received RRM MSG msgTyp(%d) trx(%d) slot(%d)\n",
+ grr_pItcRxRrmMsg->message_type,
+ grr_pItcRxRrmMsg->trx,
+ grr_pItcRxRrmMsg->slot);
+ //
+ grr_ProcRrmMsg();
+ break;
+
+ case MODULE_RLCMAC:
+ //Received RLC messages
+ grr_pItcRxRlcMsg = (grr_ItcRxRlcMsg_t *)&grr_ItcRxMsg;
+
+ //If needed output trace for debugging purpose
+ DBG_TRACE("GRR<=RRM@grr_Main: received RRM MSG msgTyp(%d) trx(%d) slot(%d)\n",
+ grr_pItcRxRlcMsg->message_type,
+ grr_pItcRxRlcMsg->trx,
+ grr_pItcRxRlcMsg->slot);
+ //
+ grr_ProcRlcMsg();
+ break;
+
+ default:
+ //Received unexpected messages
+ DBG_WARNING("GRR<=???@grr_Main:received msg from invalid moduleID (%d)\n",
+ grr_ItcRxOrigin);
+ break;
+
+ } //switch()
+
+ } //else
+
+ } //while()
+
+} //grr_Main()
+
+int SysCommand_GRR(T_SYS_CMD action)
+{
+ int tid;
+
+ switch(action)
+ {
+ case SYS_SHUTDOWN:
+ printf("[GRR] Received system shutdown notification\n");
+ break;
+
+ case SYS_START:
+ printf("[GRR] Received task start notification\n");
+ grr_CreateQ();
+ tid = grrTaskObj.JCTaskSpawn(
+ GRR_TASK_PRIORITY,
+ GRR_TASK_OPTION,
+ GRR_TASK_STACK_SIZE,
+ (FUNCPTR)grr_Main,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ MODULE_GRR, JC_CRITICAL_TASK);
+
+ grrMonTaskObj.JCTaskSpawn(
+ GRR_MONITOR_TASK_PRIORITY,
+ GRR_MONITOR_TASK_OPTION,
+ GRR_MONITOR_TASK_STACK_SIZE,
+ (FUNCPTR)grr_RadioMonitor,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ MODULE_GRR, JC_CRITICAL_TASK) ;
+ break;
+
+ case SYS_REBOOT:
+ printf("[GRR] Reboot ready.\n");
+ break;
+
+ default:
+ printf("[GRR] Received unknown system command\n");
+ }
+
+ return 0;
+}
+
+#endif //__GRR_TASK_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src/grr_TestUtil.cpp b/data/mnet/GP10/Host/grr/src/grr_TestUtil.cpp new file mode 100644 index 0000000..48f5305 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_TestUtil.cpp @@ -0,0 +1,1087 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_TESTUTIL_CPP__
+#define __GRR_TESTUTIL_CPP__
+
+#include "grr\grr_head.h"
+
+//Print read-out gsm mib data
+void grr_PrintGsmOamData(int selection)
+{
+ if (selection==0)
+ {
+ grr_PrintIntBtsBasicPackage();
+ grr_PrintIntBtsCellAllocationTable();
+ grr_PrintIntBtsBcchConfigurationPackage();
+ grr_PrintIntBtsOptionsPackage();
+ grr_PrintIntFirstTransceiverPackage();
+ grr_PrintIntSecondTransceiverPackage();
+ grr_PrintIntFirstTrxRadioCarrierPackage();
+ grr_PrintIntSecondTrxRadioCarrierPackage();
+ grr_PrintIntAdjacentCellHandoverPackage();
+ grr_PrintIntAdjacentCellReselectPackage();
+ grr_PrintIntT31xxPackage();
+ } else
+ {
+ grr_PrintBtsBasicPackage(&grr_OamData.btsBasicPackage);
+ grr_PrintBtsOptionsPackage(&grr_OamData.btsOptionsPackage);
+ grr_PrintFirstTransceiverPackage(&grr_OamData.transceiverPackage[0]);
+ grr_PrintSecondTransceiverPackage(&grr_OamData.transceiverPackage[1]);
+ grr_PrintFirstRadioCarrierPackage(&grr_OamData.radioCarrierPackage[0]);
+ grr_PrintSecondRadioCarrierPackage(&grr_OamData.radioCarrierPackage[1]);
+ grr_PrintT31xx(&grr_OamData.t31xx);
+ grr_PrintAdjacentCellPackage(&grr_OamData.adjacentCellPackage);
+ }
+
+ grr_PrintHandoverControlPackage(&grr_OamData.handoverControlPackage);
+ grr_PrintPowerControlPackage(&grr_OamData.powerControlPackage);
+ grr_PrintIntGrrConfigData();
+}
+
+void grr_PrintCellAllocationTable(Table *tbl)
+{
+ int i;
+ CellAllocationEntry *entry = (CellAllocationEntry *) tbl;
+ printf("%s\t%s", "Index", "Cell Allociation");
+
+ for (i = 0; i< CellAllocationTableLimit; i++)
+ {
+
+ printf("%d\t\t%d", i+1, (entry+i)->cellAllocation);
+ }
+}
+
+void grr_PrintPlmnPermittedTable(Table *tbl)
+{
+ int i;
+ PlmnPermittedEntry *entry = (PlmnPermittedEntry *) tbl;
+ printf("%s\t%s", "Index", "Plmn Permitted");
+
+ for (i = 0; i< PlmnPermittedTableLimit; i++)
+ {
+
+ printf("%d\t\t%d", i+1, (entry+i)->plmnPermitted);
+ }
+}
+
+void grr_PrintNotAllowedAccessClassTable(Table *tbl)
+{
+ int i;
+ NotAllowedAccessClassEntry *entry = (NotAllowedAccessClassEntry *) tbl;
+ printf("%s\t%s", "Index", "Not Allowed Access Class");
+
+ for (i = 0; i< NotAllowedAccessClassTableLimit ; i++)
+ {
+
+ printf("%d\t\t%d", i+1, (entry+i)->notAllowedAccessClass);
+ }
+}
+
+void grr_PrintChannelTable(Table *tbl)
+{
+ int i;
+ ChannelEntry *entry = (ChannelEntry *) tbl;
+ printf("%s,%s,%s,%s,%s,%s,%s", "Idx", "ID", "Comb", "fusage", "tch", "a.state", "o.state");
+
+ for (i = 0; i<ChannelTableLimit ; i++)
+ {
+
+ printf("%d,%d,%d,%d,%d,%d,%d", i+1, (entry+i)->channelID,
+ (entry+i)->channelCombination,
+ (entry+i)->channelFrequencyUsage,
+ (entry+i)->channelTsc,
+ (entry+i)->channelAdministrativeState,
+ (entry+i)->channelOperationalState);
+ }
+}
+
+void grr_PrintCarrierFrequencyTable(Table *tbl)
+{
+ int i;
+ CarrierFrequencyEntry *entry = (CarrierFrequencyEntry *) tbl;
+ printf("%s\t%s", "Index", "Carrier Frequency");
+
+ for (i = 0; i< CarrierFrequencyTableLimit; i++)
+ {
+
+ printf("%d\t\t%d", i+1, (entry+i)->carrierFrequency);
+ }
+}
+
+void grr_PrintAdjCellHandoverTable(Table *tbl)
+{
+ int i;
+ AdjCell_HandoverEntry *entry = (AdjCell_HandoverEntry *) tbl;
+ printf("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", "Idx", "ID", "mcc", "mnc", "lac", "ci", "bcch",
+ "ncc", "cid", "sync", "hoPl", "hoM", "msTx", "rxLev");
+
+ for (i = 0; i< HandoverTableLimit; i++)
+ {
+
+ printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
+ i+1,
+ (entry+i)->adjCell_handoverCellID,
+ (entry+i)->adjCell_mcc,
+ (entry+i)->adjCell_mnc,
+ (entry+i)->adjCell_lac,
+ (entry+i)->adjCell_ci,
+ (entry+i)->adjCell_bCCHFrequency,
+ (entry+i)->adjCell_ncc,
+ (entry+i)->adjCell_cid,
+ (entry+i)->adjCell_synchronized,
+ (entry+i)->adjCell_hoPriorityLevel,
+ (entry+i)->adjCell_hoMargin,
+ (entry+i)->adjCell_msTxPwrMaxCell,
+ (entry+i)->adjCell_rxLevMinCell);
+ }
+}
+
+void grr_PrintAdjCellReselectionTable(Table *tbl)
+{
+ int i;
+ AdjCell_ReselectionEntry *entry = (AdjCell_ReselectionEntry *) tbl;
+ printf("%s\t%s\t%s", "Index", "ID", "Reselection BCCH Frequency");
+
+ for (i = 0; i< ReselectionTableLimit; i++)
+ {
+
+ printf("%d\t\t%d\t\t%d", i+1, (entry+i)->adjCell_reselectionCellID,
+ (entry+i)->adjCell_reselectionBCCHFrequency);
+ }
+}
+
+
+void grr_PrintBtsBasicPackage(BtsBasicPackage *btsBasicPackage)
+{
+ printf("\nBts Bacic Package");
+
+ char *cp;
+
+ printf("bts_ncc= %d", btsBasicPackage->bts_ncc);
+ printf("bts_cid= %d", btsBasicPackage->bts_cid);
+ printf("btsID= %d", btsBasicPackage->btsID);
+
+ grr_PrintCellAllocationTable(btsBasicPackage->cellAllocationTable);
+
+ printf("gsmdcsIndicator= %d", btsBasicPackage->gsmdcsIndicator);
+ cp = (char *) &btsBasicPackage->bts_mcc;
+ printf("bts_mcc= %d%d%d", cp[0], cp[1], cp[2]);
+ cp = (char *) &btsBasicPackage->bts_mnc;
+ printf("bts_mnc= %d%d%x", cp[0], cp[1], cp[2]); // kevinlim 05/11/01
+
+ printf("bts_lac= %d", btsBasicPackage->bts_lac);
+ printf("bts_ci= %d", btsBasicPackage->bts_ci);
+ printf("cellReselectHysteresis= %d", btsBasicPackage->cellReselectHysteresis);
+ printf("ny1= %d", btsBasicPackage->ny1);
+
+ grr_PrintPlmnPermittedTable (btsBasicPackage->plmnPermittedTable);
+
+ printf("radioLinkTimeout= %d", btsBasicPackage->radioLinkTimeout);
+ printf("relatedTranscoder= %d", btsBasicPackage->relatedTranscoder);
+ printf("rxLevAccessMin= %d", btsBasicPackage->rxLevAccessMin);
+ printf("bts_administrativeState= %d", btsBasicPackage->bts_administrativeState);
+
+ printf("bts_alarmStatus= %d", btsBasicPackage->bts_alarmStatus);
+ printf("bts_operationalState= %d", btsBasicPackage->bts_operationalState);
+ printf("maxNumberRetransmissions= %d", btsBasicPackage->maxNumberRetransmissions);
+ printf("mSTxPwrMaxCCH= %d", btsBasicPackage->mSTxPwrMaxCCH);
+ printf("numberOfSlotsSpreadTrans= %d", btsBasicPackage->numberOfSlotsSpreadTrans);
+ printf("noOfBlocksForAccessGrant= %d", btsBasicPackage->noOfBlocksForAccessGrant);
+ printf("noOfMultiframesBetweenPaging= %d",btsBasicPackage->noOfMultiframesBetweenPaging);
+
+}
+
+
+void grr_PrintBtsOptionsPackage(BtsOptionsPackage *btsOptionsPackage)
+{
+ printf("\nBts Optioons Package");
+
+ printf("allowIMSIAttachDetach= %d", btsOptionsPackage->allowIMSIAttachDetach);
+ printf("callReestablishmentAllowed= %d", btsOptionsPackage->callReestablishmentAllowed);
+ printf("cellBarred= %d", btsOptionsPackage->cellBarred);
+ printf("dtxDownlink= %d", btsOptionsPackage->dtxDownlink);
+ printf("dtxUplink= %d", btsOptionsPackage->dtxUplink);
+ printf("emergencyCallRestricted= %d", btsOptionsPackage->emergencyCallRestricted);
+
+ grr_PrintNotAllowedAccessClassTable(btsOptionsPackage->notAllowedAccessClassTable);
+
+ printf("timerPeriodicUpdateMS= %d", btsOptionsPackage->timerPeriodicUpdateMS);
+ printf("maxQueueLength= %d", btsOptionsPackage->maxQueueLength);
+ printf("msPriorityUsedInQueueing= %d", btsOptionsPackage->msPriorityUsedInQueueing);
+ printf("timeLimitCall= %d", btsOptionsPackage->timeLimitCall);
+ printf("timeLimitHandover= %d", btsOptionsPackage->timeLimitHandover);
+}
+
+void grr_PrintTransceiverPackage(TransceiverPackage *transceiverPackage)
+{
+
+ printf("basebandTransceiverID= %d", transceiverPackage->basebandTransceiverID);
+
+ printf("relatedRadioCarrier= %d", transceiverPackage->relatedRadioCarrier);
+ printf("basebandAdministrativeState= %d", transceiverPackage->basebandAdministrativeState);
+ printf("basebandAlarmStatus= %d", transceiverPackage->basebandAlarmStatus);
+ printf("basebandOperationalState= %d", transceiverPackage->basebandOperationalState);
+
+ grr_PrintChannelTable(transceiverPackage->channelTable);
+}
+
+void grr_PrintFirstTransceiverPackage(FirstTransceiverPackage *firstTransceiverPackage)
+{
+
+ printf("\nFirst Transceiver Package");
+ grr_PrintTransceiverPackage(firstTransceiverPackage);
+}
+
+void grr_PrintSecondTransceiverPackage(SecondTransceiverPackage *secondTransceiverPackage)
+{
+
+ printf("\nSecond Transceiver Package");
+ grr_PrintTransceiverPackage(secondTransceiverPackage);
+}
+
+void grr_PrintRadioCarrierPackage(RadioCarrierPackage *radioCarrierPackage)
+{
+
+ grr_PrintCarrierFrequencyTable(radioCarrierPackage->carrierFrequencyList);
+
+ printf("powerClass= %d", radioCarrierPackage->powerClass);
+ printf("radioCarrierID= %d", radioCarrierPackage->radioCarrierID);
+ printf("txPwrMaxReduction= %d", radioCarrierPackage->txPwrMaxReduction);
+ printf("carrier_administrativeState= %d", radioCarrierPackage->carrier_administrativeState);
+ printf("carrier_alarmStatus= %d", radioCarrierPackage->carrier_alarmStatus);
+ printf("carrier_operationalState= %d", radioCarrierPackage->carrier_operationalState);
+
+}
+
+void grr_PrintFirstRadioCarrierPackage(FirstRadioCarrierPackage *firstRadioCarrierPackage)
+{
+
+ printf("\nFirst Radio Carrier Package");
+ grr_PrintRadioCarrierPackage(firstRadioCarrierPackage);
+}
+
+void grr_PrintSecondRadioCarrierPackage(SecondRadioCarrierPackage *secondRadioCarrierPackage)
+{
+
+ printf("\nSecond Radio Carrier Package");
+ grr_PrintRadioCarrierPackage(secondRadioCarrierPackage);
+}
+
+
+void grr_PrintT31xx(T31xx *t31xx)
+{
+
+ printf("\nT31xx Timers");
+
+ printf("t3101= %d", t31xx->t3101);
+ printf("t3103= %d", t31xx->t3103);
+ printf("t3105= %d", t31xx->t3105);
+ printf("t3107= %d", t31xx->t3107);
+ printf("t3109= %d", t31xx->t3109);
+ printf("t3111= %d", t31xx->t3111);
+ printf("t3113= %d", t31xx->t3113);
+
+}
+
+void grr_PrintAdjacentCellPackage(AdjacentCellPackage *adjacentCellPackage)
+{
+ printf("\nAdjacent Cell Package");
+
+ grr_PrintAdjCellHandoverTable(adjacentCellPackage->adjCell_handoverTable);
+ grr_PrintAdjCellReselectionTable(adjacentCellPackage->adjCell_reselectionTable);
+}
+
+
+void grr_PrintHandoverControlPackage(HandoverControlPackage *handoverControlPackage)
+{
+ printf("\nHandover Control Package");
+
+ printf("handoverControlID= %d",handoverControlPackage->handoverControlID);
+ printf("enableOptHandoverProcessing= %d",handoverControlPackage->enableOptHandoverProcessing);
+
+ printf("%x:%x", handoverControlPackage->hoAveragingAdjCellParam, &mnetMib.hoAveragingAdjCellParam);
+
+ printf("hoAveragingAdjCellParamHreqave= %d",handoverControlPackage->hoAveragingAdjCellParam->hreqave);
+ printf("hoAveragingAdjCellParamHreqt= %d",handoverControlPackage->hoAveragingAdjCellParam->hreqt);
+ printf("hoAveragingAdjCellParamWeighting= %d",handoverControlPackage->hoAveragingAdjCellParam->weighting);
+
+ printf("hoAveragingDistParamHreqave= %d",handoverControlPackage->hoAveragingDistParam->hreqave);
+ printf("hoAveragingDistParamHreqt= %d",handoverControlPackage->hoAveragingDistParam->hreqt);
+
+ printf("hoAveragingLevParamHreqave= %d",handoverControlPackage->hoAveragingLevParam->hreqave);
+ printf("hoAveragingLevParamHreqt= %d",handoverControlPackage->hoAveragingLevParam->hreqt);
+ printf("hoAveragingLevParamWeighting= %d",handoverControlPackage->hoAveragingLevParam->weighting);
+
+ printf("hoAveragingQualParamHreqave= %d",handoverControlPackage->hoAveragingQualParam->hreqave);
+ printf("hoAveragingQualParamHreqt= %d",handoverControlPackage->hoAveragingQualParam->hreqt);
+ printf("hoAveragingQualParamWeighting= %d",handoverControlPackage->hoAveragingQualParam->weighting);
+
+ printf("hoMarginDef= %d",handoverControlPackage->hoMarginDef);
+
+ printf("hoThresholdDistParamTimeadv= %d",handoverControlPackage->hoThresholdDistParam->timeadv);
+ printf("hoThresholdDistParamP8= %d",handoverControlPackage->hoThresholdDistParam->p8);
+ printf("hoThresholdDistParamN8= %d",handoverControlPackage->hoThresholdDistParam->n8);
+
+ printf("hoThresholdInterfaceParamRxLevelUL= %d",handoverControlPackage->hoThresholdInterfaceParam->rxLevelUL);
+ printf("hoThresholdInterfaceParamRxLevelDL= %d",handoverControlPackage->hoThresholdInterfaceParam->rxLevelDL);
+ printf("hoThresholdInterfaceParamPx= %d",handoverControlPackage->hoThresholdInterfaceParam->px);
+ printf("hoThresholdInterfaceParamNx= %d",handoverControlPackage->hoThresholdInterfaceParam->nx);
+
+ printf("hoThresholdLevParamRxLevelUL= %d",handoverControlPackage->hoThresholdLevParam->rxLevelUL);
+ printf("hoThresholdLevParamRxLevelDL= %d",handoverControlPackage->hoThresholdLevParam->rxLevelDL);
+ printf("hoThresholdLevParamPx= %d",handoverControlPackage->hoThresholdLevParam->px);
+ printf("hoThresholdLevParamNx= %d",handoverControlPackage->hoThresholdLevParam->nx);
+
+ printf("hoThresholdQualParamRxQualUL= %d",handoverControlPackage->hoThresholdQualParam->rxQualUL);
+ printf("hoThresholdQualParamRxQualDL= %d",handoverControlPackage->hoThresholdQualParam->rxQualDL);
+ printf("hoThresholdQualParamPx= %d",handoverControlPackage->hoThresholdQualParam->px);
+ printf("hoThresholdQualParamNx= %d",handoverControlPackage->hoThresholdQualParam->nx);
+
+ printf("interferenceAveragingParamAveragingPeriod= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamAveragingPeriod);
+ printf("interferenceAveragingParamThresholdBoundary0= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary0);
+ printf("interferenceAveragingParamThresholdBoundary1= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary1);
+ printf("interferenceAveragingParamThresholdBoundary2= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary2);
+ printf("interferenceAveragingParamThresholdBoundary3= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary3);
+ printf("interferenceAveragingParamThresholdBoundary4= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary4);
+ printf("interferenceAveragingParamThresholdBoundary5= %d",handoverControlPackage->interferenceAveragingParam->interferenceAveragingParamThresholdBoundary5);
+
+ printf("msTxPwrMaxCellDef= %d",handoverControlPackage->mxTxPwrMaxCellDef);
+ printf("rxLevMinCellDef= %d",handoverControlPackage->rxLevMinCellDef);
+}
+
+void grr_PrintPowerControlPackage(PowerControlPackage *powerControlPackage)
+{
+ printf("\nPower Control Package");
+
+ printf("pcAveragingLevHreqave= %d",powerControlPackage->pcAveragingLev->hreqave);
+ printf("pcAveragingLevHreqt= %d",powerControlPackage->pcAveragingLev->hreqt);
+ printf("pcAveragingLevWeighting= %d",powerControlPackage->pcAveragingLev->weighting);
+
+ printf("pcAveragingQualHreqave= %d",powerControlPackage->pcAveragingQual->hreqave);
+ printf("pcAveragingQualHreqt= %d",powerControlPackage->pcAveragingQual->hreqt);
+ printf("pcAveragingQualWeighting= %d",powerControlPackage->pcAveragingQual->weighting);
+
+ printf("pcLowerThresholdLevParamRxLevelUL= %d",powerControlPackage->pcLowerThresholdLevParam->rxLevelUL);
+ printf("pcLowerThresholdLevParamRxLevelDL= %d",powerControlPackage->pcLowerThresholdLevParam->rxLevelDL);
+ printf("pcLowerThresholdLevParamPx= %d",powerControlPackage->pcLowerThresholdLevParam->px);
+ printf("pcLowerThresholdLevParamNx= %d",powerControlPackage->pcLowerThresholdLevParam->nx);
+
+ printf("pcLowerThresholdQualParamRxQualUL= %d",powerControlPackage->pcLowerThresholdQualParam->rxQualUL);
+ printf("pcLowerThresholdQualParamRxQualDL= %d",powerControlPackage->pcLowerThresholdQualParam->rxQualDL);
+ printf("pcLowerThresholdQualParamPx= %d",powerControlPackage->pcLowerThresholdQualParam->px);
+ printf("pcLowerThresholdQualParamNx= %d",powerControlPackage->pcLowerThresholdQualParam->nx);
+
+ printf("pcUpperThresholdLevParamRxLevelUL= %d",powerControlPackage->pcUpperThresholdLevParam->rxLevelUL);
+ printf("pcUpperThresholdLevParamRxLevelDL= %d",powerControlPackage->pcUpperThresholdLevParam->rxLevelDL);
+ printf("pcUpperThresholdLevParamPx= %d",powerControlPackage->pcUpperThresholdLevParam->px);
+ printf("pcUpperThresholdLevParamNx= %d",powerControlPackage->pcUpperThresholdLevParam->nx);
+
+ printf("pcUpperThresholdQualParamRxQualUL= %d",powerControlPackage->pcUpperThresholdQualParam->rxQualUL);
+ printf("pcUpperThresholdQualParamRxQualDL= %d",powerControlPackage->pcUpperThresholdQualParam->rxQualDL);
+ printf("pcUpperThresholdQualParamPx= %d",powerControlPackage->pcUpperThresholdQualParam->px);
+ printf("pcUpperThresholdQualParamNx= %d",powerControlPackage->pcUpperThresholdQualParam->nx);
+ printf("powerControlInterval= %d",powerControlPackage->powerControlInterval);
+ printf("powerIncrStepSize= %d",powerControlPackage->powerIncrStepSize);
+ printf("powerRedStepSize= %d",powerControlPackage->powerRedStepSize);
+}
+
+void grr_PrintIntBtsBasicPackage(void)
+{
+ //Administrative states
+ printf("Bts Administrative State(%d,%d) Operational State(%d,%d)\n",
+ OAMgrr_BTS_AMSTATE,
+ grr_OamData.btsBasicPackage.bts_administrativeState,
+ OAMgrr_BTS_OPSTATE,
+ grr_OamData.btsBasicPackage.bts_operationalState
+ );
+
+ printf("Base Station Identity Code: BSIC(%x,%x) NCC(%d,%d) BCC(%d,%d)\n",
+ OAMgrr_POCKETBTS_BSIC,
+ ((unsigned char)(grr_OamData.btsBasicPackage.bts_ncc<<3)|
+ (unsigned char)(grr_OamData.btsBasicPackage.bts_cid)),
+ OAMgrr_NCC,
+ ((unsigned char)(grr_OamData.btsBasicPackage.bts_ncc)),
+ OAMgrr_BCC,
+ ((unsigned char)(grr_OamData.btsBasicPackage.bts_cid))
+ );
+
+ printf("Global Cell ID: MCC(%d,%d,%d)(%d,%d,%d) MNC(%d,%d)(%d,%d) LAC(%x,%x) CI ie btsId (%d,%d)\n",
+ OAMgrr_MCC(0), OAMgrr_MCC(1), OAMgrr_MCC(2),
+ ((unsigned char*)&(grr_OamData.btsBasicPackage.bts_mcc))[0],
+ ((unsigned char*)&(grr_OamData.btsBasicPackage.bts_mcc))[1],
+ ((unsigned char*)&(grr_OamData.btsBasicPackage.bts_mcc))[2],
+ OAMgrr_MNC(0), OAMgrr_MNC(1),
+ ((unsigned char*)&(grr_OamData.btsBasicPackage.bts_mnc))[0],
+ ((unsigned char*)&(grr_OamData.btsBasicPackage.bts_mnc))[1],
+ OAMgrr_LAC,
+ ((short)(grr_OamData.btsBasicPackage.bts_lac)),
+ OAMgrr_CELLID,
+ ((unsigned int)(grr_OamData.btsBasicPackage.btsID))
+ );
+
+ printf("Cell Reselect Hysteresis in 2dB step: (%d, %d)\n",
+ OAMgrr_CELL_RESEL_HYSTERESIS,
+ ((unsigned char)(grr_OamData.btsBasicPackage.cellReselectHysteresis))
+ );
+
+ printf("Max Number of Repetitions of Physical Info.(ny1):(%d, %d)\n",
+ OAMgrr_NY1,
+ ((unsigned char)(grr_OamData.btsBasicPackage.ny1))
+ );
+
+
+ printf("Radio Indicator: (%d, %d)\n",
+ OAMgrr_GSMDCS_INDICATOR,
+ grr_OamData.btsBasicPackage.gsmdcsIndicator
+ );
+
+ printf("NccPermitted Setting 0th(%d,%d) 1st(%d,%d) 2nd(%d,%d) 3rd(%d,%d) 4th(%d,%d) 5th(%d,%d) 6th(%d,%d) 7th(%d,%d)\n",
+ OAMgrr_NCC_PERMITTED(0),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[0].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(1),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[1].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(2),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[2].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(3),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[3].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(4),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[4].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(5),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[5].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(6),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[6].
+ plmnPermitted),
+ OAMgrr_NCC_PERMITTED(7),
+ (((PlmnPermittedEntry*)(grr_OamData.btsBasicPackage.plmnPermittedTable))[7].
+ plmnPermitted)
+ );
+
+ printf("Radio Link Timeout in 4 SACCH frame unit:(%d,%d)\n",
+ OAMgrr_RADIO_LINK_TIMEOUT,
+ ((unsigned char)(grr_OamData.btsBasicPackage.radioLinkTimeout))
+ );
+
+ printf("Minimum Receive Level Access:(%d, %d)\n",
+ OAMgrr_MS_RELEV_ACCESS_MIN,
+ ((unsigned char)(grr_OamData.btsBasicPackage.rxLevAccessMin))
+ );
+
+}
+
+void grr_PrintIntBtsBcchConfigurationPackage(void)
+{
+
+ printf("Max Number Retransmission(1 2 4 7) on RACH:(%d, %d)\n",
+ OAMgrr_RA_RETRY_MAX,
+ ((unsigned char)(grr_OamData.btsBasicPackage.maxNumberRetransmissions))
+ );
+
+ printf("MS Tx Power Max CCCH:(%d, %d)\n",
+ OAMgrr_MS_TX_PWR_MAX_CCH,
+ ((unsigned char)(grr_OamData.btsBasicPackage.mSTxPwrMaxCCH))
+ );
+
+ printf("No. of Blocks for Access Grant:(%d, %d)\n",
+ OAMgrr_BS_AG_BLK_RES,
+ ((unsigned char)(grr_OamData.btsBasicPackage.noOfBlocksForAccessGrant))
+ );
+
+
+ printf("No. of Multi-frames Between Paging:(%d, %d)\n",
+ OAMgrr_BS_PA_MFRMS,
+ ((unsigned char)(grr_OamData.btsBasicPackage.noOfMultiframesBetweenPaging))
+ );
+
+ printf("No. of Slots Spread Trans (Tx Integer):(%d, %d)\n",
+ OAMgrr_RA_TX_INTEGER,
+ ((unsigned char)(grr_OamData.btsBasicPackage.numberOfSlotsSpreadTrans))
+ );
+
+ printf("Cell Reselect Offset:(%d, %d)\n",
+ OAMgrr_CELL_RESELECT_OFFSET,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_nim[0][3]))
+ );
+
+ printf("Temporary Offset:(%d, %d)\n",
+ OAMgrr_TEMP_OFFEST,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_nim[0][4]))
+ );
+
+ printf("Penalty Offset:(%d, %d)\n",
+ OAMgrr_PENALTY_TIME,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_nim[0][5]))
+ );
+
+ printf("Cell Bar Qualify:(%d, %d)\n",
+ OAMgrr_CELL_BAR_QUALIFY,
+ grr_OamData.grrConfigData.rm_nim[0][6]
+ );
+}
+
+void grr_PrintIntBtsCellAllocationTable(void)
+{
+ printf("1st ARFCN in cell allocation table:(%d,%d)\n",
+ OAMgrr_CA_ARFCN(0),
+ (((CellAllocationEntry*)(grr_OamData.btsBasicPackage.cellAllocationTable))[0].cellAllocation)
+ );
+ printf("2nd ARFCN in cell allocation table:(%d,%d)\n",
+ OAMgrr_CA_ARFCN(1),
+ (((CellAllocationEntry*)(grr_OamData.btsBasicPackage.cellAllocationTable))[1].cellAllocation)
+ );
+ printf("3rd ARFCN in cell allocation table:(%d,%d)\n",
+ OAMgrr_CA_ARFCN(2),
+ (((CellAllocationEntry*)(grr_OamData.btsBasicPackage.cellAllocationTable))[2].cellAllocation)
+ );
+}
+
+void grr_PrintIntBtsOptionsPackage(void)
+{
+ printf("Use IMSI attach/detach procedure? Setting(%d, %d)\n",
+ OAMgrr_ATT_STATE,
+ ((T_CNI_RIL3_ATT)(grr_OamData.btsOptionsPackage.allowIMSIAttachDetach))
+ );
+
+ printf("Cell Barred? (%d, %d) overLoadBarring(%d,%d) currentBarringState(%d)\n",
+ OAMgrr_RA_CELL_BARRED_STATE,
+ ((T_CNI_RIL3_CELL_BARRED_ACCESS)(grr_OamData.btsOptionsPackage.cellBarred)),
+ OAMgrr_OVERLOAD_CELLBAR
+ );
+
+ printf("Restablishment Allowed? (%d, %d)\n",
+ OAMgrr_RA_REST_ALLOWED_STATE,
+ ((T_CNI_RIL3_REESTABLISHMENT_ALLOWED)
+ (grr_OamData.btsOptionsPackage.callReestablishmentAllowed))
+ );
+
+ printf("Downlink DTX is available in the BTS(downlink)? (%d, %d)\n",
+ OAMgrr_MS_DNLINK_DTX_STATE,
+ ((int)(grr_OamData.btsOptionsPackage.dtxDownlink))
+ );
+
+ printf("Discontinuous Transmission (DTX) mode to be used by the Mobile Stations(uplink): (%d, %d)\n",
+ OAMgrr_MS_UPLINK_DTX_STATE,
+ ((T_CNI_RIL3_DTX_BCCH)(grr_OamData.btsOptionsPackage.dtxUplink))
+ );
+
+ printf("Is IMSI required for Emergency calls? (%d, %d)\n",
+ OAMgrr_IMSI_REQUIRED_FOR_EC,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_nim[1][0]))
+ );
+
+ printf("Emergency calls restricted to MSs belonging to access classes from 11 to 15? (%d, %d)\n",
+ OAMgrr_RA_EC_ALLOWED_STATE,
+ ((T_CNI_RIL3_EMERGENCY_CALL_ALLOWED)
+ (grr_OamData.btsOptionsPackage.emergencyCallRestricted))
+ );
+
+ printf("MS Access Classes not allowed to access the cell: c0(%d,%d) c1(%d,%d) c2(%d,%d) c3(%d,%d) c4(%d,%d)\n",
+ OAMgrr_RA_AC_ALLOWED_STATE(0),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[0].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(1),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[1].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(2),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[2].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(3),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[3].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(4),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[4].notAllowedAccessClass))
+ );
+
+ printf("MS Access Classes not allowed to access the cell: c5(%d,%d) c6(%d,%d) c7(%d,%d) c8(%d,%d) c9(%d,%d)\n",
+ OAMgrr_RA_AC_ALLOWED_STATE(5),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[5].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(6),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[6].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(7),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[7].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(8),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[8].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(9),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[9].notAllowedAccessClass))
+ );
+
+ printf("MS Access Classes not allowed to access the cell: c10(%d,%d) c11(%d,%d) c12(%d,%d) c13(%d,%d) c14(%d,%d) c15(%d,%d)\n",
+ OAMgrr_RA_AC_ALLOWED_STATE(10),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[10].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(11),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[11].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(12),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[12].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(13),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[13].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(14),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[14].notAllowedAccessClass)),
+ OAMgrr_RA_AC_ALLOWED_STATE(15),
+ ((unsigned char)(((NotAllowedAccessClassEntry*)
+ (grr_OamData.btsOptionsPackage.notAllowedAccessClassTable))[15].notAllowedAccessClass))
+ );
+
+ printf("Periodic Location Update Interval (T3212 Deci Hours): (%d, %d)\n",
+ OAMgrr_T3212,
+ ((unsigned char)(grr_OamData.btsOptionsPackage.timerPeriodicUpdateMS))
+ );
+
+}
+
+void grr_PrintIntFirstTransceiverPackage(void)
+{
+ int i;
+
+ //Trx 0 Administrative state
+ printf("Transceriver 0 Administrative State: (%d,%d)\n",
+ OAMgrr_TRX_AMSTATE(0),
+ grr_OamData.transceiverPackage[0].basebandAdministrativeState
+ );
+
+ //Trx 0 Operational state
+ printf("Transceiver 0 Operational State: (%d,%d)\n",
+ OAMgrr_TRX_OPSTATE(0),
+ grr_OamData.transceiverPackage[0].basebandOperationalState
+ );
+
+ for (i=0;i<8;i++)
+ {
+ printf("Transceiver 0 TS-%d States: i, Admin State(%d,%d) Opera State(%d,%d) Chan Combination(%d,%d) TSC(%d,%d)\n",
+ OAMgrr_CHN_AMSTATE(0,i),
+ ((ChannelEntry*)
+ (grr_OamData.transceiverPackage[0].channelTable))[i].channelAdministrativeState,
+ OAMgrr_CHN_OPSTATE(0,i),
+ ((EnableDisable)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[0].channelTable))[i].channelOperationalState)),
+ OAMgrr_TRX_SLOT_COMB(0,i),
+ ((unsigned char)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[0].channelTable))[i].channelCombination)),
+ OAMgrr_TRX_SLOT_TSC(0,i),
+ ((unsigned char)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[0].channelTable))[i].channelTsc))
+ );
+ }
+}
+
+void grr_PrintIntSecondTransceiverPackage(void)
+{
+ int i;
+
+ //Trx 0 Administrative state
+ printf("Transceriver 1 Administrative State: (%d,%d)\n",
+ OAMgrr_TRX_AMSTATE(1),
+ grr_OamData.transceiverPackage[1].basebandAdministrativeState
+ );
+
+ //Trx 0 Operational state
+ printf("Transceiver 1 Operational State: (%d,%d)\n",
+ OAMgrr_TRX_OPSTATE(1),
+ grr_OamData.transceiverPackage[1].basebandOperationalState
+ );
+
+ for (i=0;i<8;i++)
+ {
+ printf("Transceiver 1 TS-%d States: i, Admin State(%d,%d) Opera State(%d,%d) Chan Combination(%d,%d) TSC(%d,%d)\n",
+ OAMgrr_CHN_AMSTATE(1,i),
+ ((ChannelEntry*)
+ (grr_OamData.transceiverPackage[1].channelTable))[i].channelAdministrativeState,
+ OAMgrr_CHN_OPSTATE(1,i),
+ ((EnableDisable)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[1].channelTable))[i].channelOperationalState)),
+ OAMgrr_TRX_SLOT_COMB(1,i),
+ ((unsigned char)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[1].channelTable))[i].channelCombination)),
+ OAMgrr_TRX_SLOT_TSC(1,i),
+ ((unsigned char)(((ChannelEntry*)
+ (grr_OamData.transceiverPackage[1].channelTable))[i].channelTsc))
+ );
+ }
+}
+
+void grr_PrintIntT31xxPackage(void)
+{
+ printf("Immediate Assignment(T3101): (%d,%d)\n",
+ OAMgrr_T3101, grr_OamData.t31xx.t3101
+ );
+ printf("Handover Command(T3103): (%d,%d)\n",
+ OAMgrr_T3103, grr_OamData.t31xx.t3103
+ );
+ printf("physical Information(T3105): (%d,%d)\n",
+ OAMgrr_T3105, grr_OamData.t31xx.t3105
+ );
+ printf("Assignment Command(T3107): (%d,%d)\n",
+ OAMgrr_T3107, grr_OamData.t31xx.t3107
+ );
+ printf("lower layer failure(T3109): (%d,%d)\n",
+ OAMgrr_T3109, grr_OamData.t31xx.t3109
+ );
+ printf("Channel Activation Delay(T3111): (%d,%d)\n",
+ OAMgrr_T3111, grr_OamData.t31xx.t3111
+ );
+ printf("Paging Messages(T3113): (%d,%d)\n",
+ OAMgrr_T3111, grr_OamData.t31xx.t3113);
+}
+
+void grr_PrintIntFirstTrxRadioCarrierPackage(void)
+{
+ printf("Trx-0 Radio Carrier Configuration: pwrClass(%d,%d) rc(%d,%d) MaxTxPwrReduction(%d,%d)\n",
+ OAMgrr_TRX_RC_NO(0),
+ ((unsigned short)(grr_OamData.radioCarrierPackage[grr_OamData.transceiverPackage[0].relatedRadioCarrier].
+ radioCarrierID)),
+ OAMgrr_TRX_RC_MAXPWR_CUT(0),
+ ((unsigned short)(grr_OamData.radioCarrierPackage[grr_OamData.transceiverPackage[0].relatedRadioCarrier].
+ txPwrMaxReduction)),
+ OAMgrr_TRX_RC_ARFCN(0,0),
+ ((unsigned short)(((CarrierFrequencyEntry*)
+ (grr_OamData.radioCarrierPackage[grr_OamData.transceiverPackage[0].relatedRadioCarrier].
+ carrierFrequencyList))[0].carrierFrequency))
+ );
+}
+
+void grr_PrintIntSecondTrxRadioCarrierPackage(void)
+{
+ printf("Trx 1 First Radio Carrier Configuration: pwrClass(%d,%d) rc #(%d,%d) MaxTxPwrReduction(%d,%d) Freq(%d,%d)\n",
+ OAMgrr_TRX_RC_PWR_CLASS(1),
+ ((unsigned short)(grr_OamData.radioCarrierPackage[
+ grr_OamData.transceiverPackage[1].relatedRadioCarrier].powerClass)),
+ OAMgrr_TRX_RC_NO(1),
+ ((unsigned short)(grr_OamData.radioCarrierPackage[
+ grr_OamData.transceiverPackage[1].relatedRadioCarrier].radioCarrierID)),
+ OAMgrr_TRX_RC_MAXPWR_CUT(1),
+ ((unsigned short)(grr_OamData.radioCarrierPackage[
+ grr_OamData.transceiverPackage[1].relatedRadioCarrier].txPwrMaxReduction)),
+ OAMgrr_TRX_RC_ARFCN(1,0),
+ ((unsigned short)(((CarrierFrequencyEntry*)(grr_OamData.radioCarrierPackage[
+ grr_OamData.transceiverPackage[1].relatedRadioCarrier
+ ].carrierFrequencyList))[0].carrierFrequency))
+ );
+}
+
+
+void grr_PrintIntAdjacentCellHandoverPackage(void)
+{
+ int i;
+ for (i=0;i<16;i++)
+ {
+ printf("Adjacent Cell Handover Package from MIB %d-th adjacent cell data: selected(%d,%d) networkId(%d,%d) cellId(%d,%d)\n",
+ i,
+ OAMgrr_HO_ADJCELL_ID(i),
+ ((unsigned int)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_handoverCellID)),
+ OAMgrr_NCELL_NETWORKID(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_handoverCellID))>>16),
+ OAMgrr_NCELL_CELLID(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_handoverCellID))
+ );
+ printf("mcc(%d,%d,%d) mnc(%d,%d,%x) lac(%d,%d) ci(%d,%d) freq(%d,%d) ncc(%d,%d) bcc(%d,%d) margin(%d,%d) maxTxPwr(%d,%d) minRxLev(%d,%d)\n",
+ OAMgrr_HO_ADJCELL_MCC(i,0),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mcc))[0],
+ OAMgrr_HO_ADJCELL_MCC(i,1),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mcc))[1],
+ OAMgrr_HO_ADJCELL_MCC(i,2),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mcc))[2],
+ OAMgrr_HO_ADJCELL_MNC(i,0),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mnc))[0],
+ OAMgrr_HO_ADJCELL_MNC(i,1),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mnc))[1],
+ OAMgrr_HO_ADJCELL_MNC(i,2),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_mnc))[2],
+ OAMgrr_HO_ADJCELL_LAC(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_lac))),
+ OAMgrr_HO_ADJCELL_CI(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_ci))),
+ OAMgrr_HO_ADJCELL_BCCH_ARFCN(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_bCCHFrequency)),
+ OAMgrr_HO_ADJCELL_NCC(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_ncc)),
+ OAMgrr_HO_ADJCELL_BCC(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_cid)),
+ OAMgrr_HO_ADJCELL_HO_MARGIN(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_hoMargin)),
+ OAMgrr_HO_ADJCELL_MSTXPWR_MAX_CELL(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_msTxPwrMaxCell)),
+ OAMgrr_HO_ADJCELL_RXLEV_MIN_CELL(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_handoverTable))[i].adjCell_rxLevMinCell))
+ );
+
+ printf("Adjacent Cell Handover Package After Compression %d-th adjacent cell data: selected(%d,%d) networkId(%d,%d) cellId(%d,%d)\n",
+ i,
+ OAMgrr_HO_ADJCELL_ID_t(i),
+ ((unsigned int)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_handoverCellID)),
+ OAMgrr_NCELL_NETWORKID_t(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_handoverCellID))>>16),
+ OAMgrr_NCELL_CELLID_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_handoverCellID))
+ );
+ printf("mcc(%d,%d,%d) mnc(%d,%d,%x) lac(%d,%d) ci(%d,%d) freq(%d,%d) ncc(%d,%d) bcc(%d,%d) margin(%d,%d) maxTxPwr(%d,%d) minRxLev(%d,%d)\n",
+ OAMgrr_HO_ADJCELL_MCC_t(i,0),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mcc))[0],
+ OAMgrr_HO_ADJCELL_MCC_t(i,1),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mcc))[1],
+ OAMgrr_HO_ADJCELL_MCC_t(i,2),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mcc))[2],
+ OAMgrr_HO_ADJCELL_MNC_t(i,0),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mnc))[0],
+ OAMgrr_HO_ADJCELL_MNC_t(i,1),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mnc))[1],
+ OAMgrr_HO_ADJCELL_MNC_t(i,2),
+ ((unsigned char*)&(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_mnc))[2],
+ OAMgrr_HO_ADJCELL_LAC_t(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_lac))),
+ OAMgrr_HO_ADJCELL_CI_t(i),
+ ((short)((((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_ci))),
+ OAMgrr_HO_ADJCELL_BCCH_ARFCN_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_bCCHFrequency)),
+ OAMgrr_HO_ADJCELL_NCC(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_ncc)),
+ OAMgrr_HO_ADJCELL_BCC_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_cid)),
+ OAMgrr_HO_ADJCELL_HO_MARGIN_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_hoMargin)),
+ OAMgrr_HO_ADJCELL_MSTXPWR_MAX_CELL_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_msTxPwrMaxCell)),
+ OAMgrr_HO_ADJCELL_RXLEV_MIN_CELL_t(i),
+ ((short)(((AdjCell_HandoverEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_handoverTable))[i].adjCell_rxLevMinCell))
+ );
+
+ }
+}
+
+void grr_PrintIntAdjacentCellReselectPackage(void)
+{
+ int i;
+ for (i=0;i<16;i++)
+ {
+ printf("Adjacent Cell Reselect Package from MIB %d-th adjacent cell data: selected(%d,%d) freq(%d,%d) cellId(%d,%d)\n",
+ i,
+ OAMgrr_RESEL_ADJCELL_ID(i),
+ ((unsigned int)(((AdjCell_ReselectionEntry*)
+ (grr_OamData.adjacentCellPackage_t.adjCell_reselectionTable))[i].adjCell_reselectionCellID)),
+ OAMgrr_RESEL_ADJCELL_BCCH_ARFCN(i),
+ ((short)(((AdjCell_ReselectionEntry*)
+ (grr_OamData.adjacentCellPackage.adjCell_reselectionTable))[i].adjCell_reselectionBCCHFrequency))
+ );
+ }
+}
+
+void grr_PrintIntGrrConfigData(void)
+{
+ int i,j;
+
+ printf("Grr Module Configuration Package MIB parameters:\n");
+
+ printf("OAMgrr_T3L01: %x, %x\n",
+ OAMgrr_T3L01,
+ ((int)(grr_OamData.grrConfigData.rm_t3L01))
+ );
+ //0xFF
+ printf("OAMgrr_BS_CC_CHANS: %x, %x\n",
+ OAMgrr_BS_CC_CHANS,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_bsCcChans))
+ );
+ //0x01
+ printf("OAMgrr_BSCCCHSDCCH_COMB: %x, %x\n",
+ OAMgrr_BSCCCHSDCCH_COMB,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_bsCcchSdcchComb)));
+ //0x01
+ printf("OAMgrr_AIRINTERFACE: %x, %x\n",
+ OAMgrr_AIRINTERFACE,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_airInterface)));
+ //0x02
+ printf("OAMgrr_POCKETBTS_TSC: %x, %x\n",
+ OAMgrr_POCKETBTS_TSC,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_viperCellTsc)));
+ //0x05
+ printf("OAMgrr_SLOTS_PER_TRX: %x, %x\n",
+ OAMgrr_SLOTS_PER_TRX,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_maxSlotPerTrx)));
+ //0x08
+ printf("OAMgrr_MAX_TRXS: %x, %x\n",
+ OAMgrr_MAX_TRXS,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_maxTrxs)));
+ //0x02
+ printf("OAMgrr_MAX_TCHFS: %x, %x\n",
+ OAMgrr_MAX_TCHFS,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_maxTchfs)));
+ //0x0f
+ printf("OAMgrr_MAX_SDCCH4S: %x, %x\n",
+ OAMgrr_MAX_SDCCH4S,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_maxSdcch4s)));
+ //0x04
+ printf("OAMgrr_TRX_ONOFF_MAP: %x, %x\n",
+ OAMgrr_TRX_ONOFF_MAP,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_trxOnOffMap)));
+ //0x01
+ printf("OAMgrr_NETWORKIFCONFIG: %x, %x\n",
+ OAMgrr_NETWORKIFCONFIG,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_networkIfConfig)));
+ //0x00
+ printf("OAMgrr_BCCH_TRX: %x, %x\n",
+ OAMgrr_BCCH_TRX,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_bcchTrx)));
+ //0x00
+ printf("OAMgrr_PREALPHA_TRX: %x, %x\n",
+ OAMgrr_PREALPHA_TRX,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_preAlphaTrx)));
+ //0x00
+ printf("OAMgrr_CCCH_SDCCH_COMB: %x, %x\n",
+ OAMgrr_CCCH_SDCCH_COMB,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_ccchBcchComb)));
+ //0x01
+ printf("OAMgrr_CCCH_CONF: %x, %x\n",
+ OAMgrr_CCCH_CONF,
+ ((unsigned char)(grr_OamData.grrConfigData.rm_ccchConf)));
+ //0x01
+ //FS:T_CNI_RIL3_CCCH_CONF:CNI_RIL3_CCCH_CONF_ONE_CCCH_COMBINED_SDCCHS=1
+ for (i=0;i<2;i++)
+ for (j=0;j<8;j++)
+ {
+ printf("OAMgrr_NIM(%d,%d): %x, %x\n", i,j,
+ OAMgrr_NIM(i,j),
+ ((unsigned char)(grr_OamData.grrConfigData.rm_nim[i][j])));
+ //rm_nim[2][8]: all elements<-0xFF
+ }
+
+ printf("OAMgrr_IQ_SWAP: %d, %d\n", OAMgrr_IQ_SWAP, grr_OamData.grr_IQSwap);
+
+}
+
+void grr_SetDbgDump(void)
+{
+grr_DbgDump=1;
+}
+
+void grr_ResetDbgDump(void)
+{
+grr_DbgDump=0;
+}
+
+void grr_SetGprsCtrl(void)
+{
+grr_GprsCtrl=1;
+grr_PassOamMsParams(0);
+grr_PassOamMsParams(1);
+}
+
+void grr_ResetGprsCtrl(void)
+{
+grr_GprsCtrl=0;
+grr_PassOamMsParams(0);
+grr_PassOamMsParams(1);
+}
+
+void grr_GprsSetting(void)
+{
+printf ("OAMgrr_GPRS_RA_COLOR = (%d)\n", OAMgrr_GPRS_RA_COLOR ); //0
+printf ("OAMgrr_SI13_POS = (%d)\n", OAMgrr_SI13_POS ); //0
+printf ("OAMgrr_GPRS_NETWORK_MODE = (%d)\n", OAMgrr_GPRS_NETWORK_MODE ); //1
+printf ("OAMgrr_CBCH_TRX_SLOT = (%d)\n", OAMgrr_CBCH_TRX_SLOT ); //0
+printf ("OAMgrr_CBCH_TRX = (%d)\n", OAMgrr_CBCH_TRX ); //0
+printf ("OAMgrr_BCCH_CHANGE_MARK = (%d)\n", OAMgrr_BCCH_CHANGE_MARK ); //0
+printf ("OAMgrr_SI_CHANGE_FIELD = (%d)\n", OAMgrr_SI_CHANGE_FIELD ); //0
+printf ("OAMgrr_GPRS_RAC = (%d)\n", OAMgrr_GPRS_RAC ); //1
+printf ("OAMgrr_GPRS_NMO = (%d)\n", OAMgrr_GPRS_NMO ); //1
+printf ("OAMgrr_GPRS_T3168 = (%d)\n", OAMgrr_GPRS_T3168 ); //4
+printf ("OAMgrr_GPRS_T3192 = (%d)\n", OAMgrr_GPRS_T3192 ); //7
+printf ("OAMgrr_GPRS_DRX_TIMER_MAX = (%d)\n", OAMgrr_GPRS_DRX_TIMER_MAX ); //7
+printf ("OAMgrr_GPRS_ACCESS_BURST_TYPE = (%d)\n", OAMgrr_GPRS_ACCESS_BURST_TYPE ); //0
+printf ("OAMgrr_GPRS_CONTROL_ACK_TYPE = (%d)\n", OAMgrr_GPRS_CONTROL_ACK_TYPE ); //0
+printf ("OAMgrr_GPRS_BS_CV_MAX = (%d)\n", OAMgrr_GPRS_BS_CV_MAX ); //7
+printf ("OAMgrr_GPRS_PAN_DEC = (%d)\n", OAMgrr_GPRS_PAN_DEC ); //1
+printf ("OAMgrr_GPRS_PAN_INC = (%d)\n", OAMgrr_GPRS_PAN_INC ); //1
+printf ("OAMgrr_GPRS_PAN_MAX = (%d)\n", OAMgrr_GPRS_PAN_MAX ); //4
+printf ("OAMgrr_GPRS_ALPHA = (%d)\n", OAMgrr_GPRS_ALPHA ); //10
+printf ("OAMgrr_GPRS_T_AVG_W = (%d)\n", OAMgrr_GPRS_T_AVG_W ); //15
+printf ("OAMgrr_GPRS_T_AVG_T = (%d)\n", OAMgrr_GPRS_T_AVG_T ); //5
+printf ("OAMgrr_GPRS_PC_MEAS_CHAN = (%d)\n", OAMgrr_GPRS_PC_MEAS_CHAN ); //1
+printf ("OAMgrr_GPRS_N_AVG_I = (%d)\n", OAMgrr_GPRS_N_AVG_I ); //4
+}
+
+void grr_SetTrxSlotCombination(int trx, int slot, int comb)
+{
+
+MibTag tag;
+
+printf("current valid channel combinations\n");
+printf("1-TCH/F + FACCH/F + SACCH/F\n");
+printf("2-TCH/H(0,1) + FACCH/H(0,1) + SACCH/H(0,1)n");
+printf("3-TCH/H(0,0) + FACCH/H(0,1) + SACCH/H(0,1) + TCH/H(1,1)n");
+printf("4-FCCH + SCH + BCCH + CCCHn");
+printf("5-FCCH + SCH + BCCH + CCCH + SDCCH/4(0..3) + SACCH/C4(0..3)n");
+printf("6-BCCH + CCCHn");
+printf("7-combination 5 with CBCH as 05.02 Note 1n");
+printf("8-combination 3 with CBCH as 05.02 Note 1n");
+printf("11-combination XI for GPRSn");
+printf("12-combination XII for GPRSn");
+printf("13-combination XIII for GPRS\n");
+
+OAMgrr_TRX_SLOT_COMBa(trx,slot)= (ChannelCombination_t) comb;
+
+if (trx==0) tag = MIBT_channelCombination_0;
+else tag = MIBT_channelCombination_1;
+
+if ( STATUS_OK!=oam_setTblEntryField(MODULE_GRR, tag, slot, (ChannelCombination)comb) )
+{
+ printf("grr_SetTrxSlotCombination: oam_setTblEntryField failed for setting trx(%d) slot(%d) comb(%d)\n",
+ trx, slot, comb);
+} else
+ grr_SendDspSlotActivate( (unsigned char) trx, (unsigned char) slot);
+}
+
+#endif // __GRR_TESTUTIL_CPP__
diff --git a/data/mnet/GP10/Host/grr/src/grr_init.cpp b/data/mnet/GP10/Host/grr/src/grr_init.cpp new file mode 100644 index 0000000..41e41f1 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src/grr_init.cpp @@ -0,0 +1,550 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_INIT_CPP__
+#define __GRR_INIT_CPP__
+
+#include "grr\grr_head.h"
+
+int grr_InitWatchTimerExpired(int trx)
+{
+ DBG_FUNC("grr_InitWatchTimerExpired", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ DBG_ERROR("grr_InitWatchTimerExpired: DSP(%d) failed to respond during initialization\n", trx);
+ printf("grr_InitWatchTimerExpired: DSP(%d) failed to respond during initialization\n", trx);
+
+ grr_SubmitAlarm(grr_DspInitWatchTimerExpiredAlarmCode[trx]);
+
+ DBG_LEAVE();
+ assert(0);
+
+}
+
+void grr_InitWatchTimerStop(unsigned char trx)
+{
+ DBG_FUNC("grr_InitWatchTimerStop", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ wdCancel(grr_TrxMgmt[trx].wdog.timer_id);
+
+ DBG_LEAVE();
+}
+
+void grr_InitWatchTimerStart(int trx)
+{
+ WDOG_ID timer_id;
+
+ DBG_FUNC("grr_InitWatchTimerStart", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ //Create watchdog to monitir init
+ if ( (timer_id=wdCreate()) == NULL )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_WDCREATE_FAILED);
+ DBG_ERROR("grr_InitWatchTimerStart:failed to create initWatchTimer for trx(%d)\n", trx);
+ printf("grr_InitWatchTimerStart:failed to create initWatchTimer for trx(%d)\n", trx);
+ assert(0);
+ }
+
+ if ( ERROR == (wdStart(timer_id, GRR_INIT_WATCH_TIME,(FUNCPTR)grr_InitWatchTimerExpired,
+ trx)) )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_WDSTART_FAILED);
+ DBG_ERROR("grr_InitWatchTimerStart:failed to call wdstart for trx(%d) initWatchTimer\n", trx);
+ printf("grr_InitWatchTimerStart:failed to call wdstart for trx(%d) initWatchTimer\n", trx);
+ assert(0);
+ }
+
+ grr_TrxMgmt[trx].wdog.timer_id = timer_id;
+
+ DBG_LEAVE();
+}
+
+bool grr_InitDspOver(unsigned char trx)
+{
+
+ //Check if DSP initialization done
+ return ( (grr_TrxMgmt[trx].state==GRR_TRXMGMT_S3_TRXCONFIG_END) ? true:false);
+
+}
+
+void grr_InitDspMsgProc(unsigned char trx)
+{
+ unsigned char slot;
+
+ DBG_FUNC("grr_InitDspMsgProc", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ //Process in terms of trx state
+ slot = grr_pItcRxDspMsg->buffer[4];
+
+ switch ( grr_TrxMgmt[trx].state )
+ {
+ case GRR_TRXMGMT_S0_BOOTSTRAP_IND:
+ //
+ //Waiting for dsp bootstrap indication
+ if (!GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_BOOTSTRAPCNF_MSB,GRR_L1MT_BOOTSTRAPCNF_LSB))
+ {
+ //Got unexpected message
+ DBG_WARNING("grr_InitDspMsgProc: expecting DspBootstrapInd but recved msg(%d,%d,%d,%d)\n",
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3]);
+ return;
+ }
+
+ //Process the received msg
+ grr_SendDspTrxConfig(trx);
+ ConfigTxPwrValues(trx);
+ grr_SetOamTrxOpState(trx,opStateDisabled);
+ grr_SetOamAllTrxSlotOpState(trx, opStateDisabled);
+ grr_TrxMgmt[trx].state=GRR_TRXMGMT_S1_TRXCONFIG_ACK;
+ break;
+
+ case GRR_TRXMGMT_S1_TRXCONFIG_ACK:
+ //
+ //Waiting for trx config ack
+ if (!GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_TRXCONFIGACK_MSB,
+ GRR_L1MT_TRXCONFIGACK_LSB))
+ {
+ //Got unexpected message
+ DBG_WARNING("grr_InitDspMsgProc: expecting trxConigAck but recved msg(%d,%d,%d,%d)\n",
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3]);
+ return;
+ }
+
+ //Trx config acked, then go init its TSs
+ grr_SetOamTrxOpState(trx, opStateEnabled);
+ grr_TrxMgmt[trx].state=GRR_TRXMGMT_S2_SLOTACTIV_ACK;
+ grr_TrxMgmt[trx].slot=0;
+ grr_ActTrxSlot(trx,grr_TrxMgmt[trx].slot);
+ break;
+
+ case GRR_TRXMGMT_S2_SLOTACTIV_ACK:
+ //
+ //Apply sanitory Check here
+ if ( (grr_pItcRxDspMsg->buffer[4] != grr_TrxMgmt[trx].slot) ||
+ (grr_pItcRxDspMsg->buffer[4] >= 8) )
+ {
+ DBG_WARNING("grr_InitDspMsgProc: expecting trx(%d) slotAck for slot(%d) not slot(%d)\n",
+ trx, grr_TrxMgmt[trx].slot, grr_pItcRxDspMsg->buffer[4]);
+ return;
+ }
+
+ //check if got the expected msg
+ if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_SLOTACTIVACK_MSB,
+ GRR_L1MT_SLOTACTIVACK_LSB))
+ {
+ DBG_TRACE("grr_InitDspMsgProc: slotAct ack to trx(%d) slot(%d)\n",
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4]);
+
+ //Got positive ack, (trx,slot) goes into enabled state
+ grr_SetOamTrxSlotOpState(trx,grr_pItcRxDspMsg->buffer[4],opStateEnabled);
+
+
+ } else if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_SLOTACTIVNACK_MSB,
+ GRR_L1MT_SLOTACTIVNACK_LSB))
+ {
+ DBG_WARNING("grr_InitDspMsgProc: slotAct nack to trx(%d) slot(%d)\n",
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4]);
+
+ //Got negative ack, (trx,slot) goes into disabled state
+ grr_SubmitAlarm(grr_TrxSlotActNackAlarmCode[trx][slot]);
+ grr_SetOamTrxSlotOpState(trx, grr_pItcRxDspMsg->buffer[4], opStateDisabled);
+
+ } else
+ {
+ //Got unexpected message
+ DBG_WARNING("grr_InitDspMsgProc: expecting slotAck/Nack to trx(%d) slot(%d) but recved msg(%d,%d,%d,%d)\n",
+ trx,
+ grr_TrxMgmt[trx].slot,
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3]);
+ return;
+ }
+
+ //Check if all TSs of trx are initialized
+ if (grr_pItcRxDspMsg->buffer[4]==7)
+ {
+ grr_TrxMgmt[trx].state = GRR_TRXMGMT_S3_TRXCONFIG_END;
+ }
+ else
+ {
+ //Activate next time slot of this trx
+ grr_TrxMgmt[trx].slot++;
+ grr_ActTrxSlot(trx, grr_TrxMgmt[trx].slot);
+ }
+ break;
+
+ case GRR_TRXMGMT_S3_TRXCONFIG_END:
+ default:
+ //Unrecognized trx state
+ DBG_WARNING("grr_InitDspMsgProc: invalid state(%d) for trx(%d)\n",
+ grr_TrxMgmt[trx].state, trx);
+ break;
+ }
+}
+
+void grr_InitTrxMgmtData(unsigned char trx)
+{
+ DBG_FUNC("grr_InitTrxMgmtData", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ grr_TrxMgmt[trx].state = 0;
+ grr_TrxMgmt[trx].slot = 0;
+ grr_TrxMgmt[trx].tdma1 = 0;
+ grr_TrxMgmt[trx].tdma2 = 0;
+ grr_TrxMgmt[trx].tdma3 = 0;
+ grr_TrxMgmt[trx].tdma4 = 0;
+ grr_TrxMgmt[trx].done = false;
+ grr_TrxMgmt[trx].alive = true;
+
+ DBG_LEAVE();
+}
+
+//Initialize trx package
+void grr_InitOamTrxPkg(unsigned char trx)
+{
+ int length;
+
+ DBG_FUNC("grr_InitOamTrxPkg", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ //Reset operational state of all TRX-owned resources
+ grr_SetOamTrxOpState(trx, opStateDisabled);
+ grr_SetOamAllTrxSlotOpState(trx, opStateDisabled);
+ grr_SetOamTrxRcOpState(trx, opStateDisabled);
+
+ //Starting initializing trx and set its SM state to S0
+ DBG_TRACE("GRR starting the initialization of trx(%d)\n", trx);
+ printf("GRR starting the initialization of trx(%d)\n", trx);
+
+ //Initialize trx init management data
+ grr_InitTrxMgmtData(trx);
+
+ //Start init watch timer
+ grr_InitWatchTimerStart(trx);
+
+ //Configure trx and wait for its ack
+ grr_SendDspTrxConfig(trx);
+ ConfigTxPwrValues(trx);
+ grr_TrxMgmt[trx].state=GRR_TRXMGMT_S1_TRXCONFIG_ACK;
+
+ //Init Loop
+ while (true)
+ {
+ // Retrieve a message from Q
+ if ( (length = msgQReceive(grr_MsgQId,(char*)&grr_ItcRxMsg, sizeof(grr_ItcRxMsg_t), WAIT_FOREVER))
+ == ERROR )
+ {
+ //failed in calling vxWorks receive call. Underlying issue. Abort the task!
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQRECEIVE_FAILED);
+ DBG_ERROR("grr_InitOamTrxPkg(%d): failed to read VxWorks GRR Queue.\n",trx);
+ printf("grr_InitOamTrxPkg(%d): failed to read VxWorks GRR msg Queue\n",trx);
+ DBG_LEAVE();
+ assert(0);
+ } else
+ {
+ //Good receive! If needed dump out for debug purpose
+ if (grr_DbgDump) DBG_HEXDUMP(( unsigned char *)&grr_ItcRxMsg, length);
+
+ //Handle the message in terms of its origin, do sanitory check too!
+ grr_ItcRxOrigin = grr_ItcRxMsg.module_id;
+
+ if (grr_ItcRxOrigin == MODULE_L1)
+ {
+ //Received L1 message
+ grr_pItcRxDspMsg=(grr_ItcRxDspMsg_t *)&grr_ItcRxMsg.itcRxDspMsg;
+
+ //If needed, output trace for debugging purpose
+ DBG_TRACE("grr_InitOamTrxPkg(%d): received L1 MSG(%x,%x,%x) SRC(%x,%x,%x)\n",
+ trx,
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4],
+ grr_pItcRxDspMsg->buffer[5]);
+
+ //Carry on DSP init
+ grr_InitDspMsgProc(trx);
+
+ if ( grr_InitDspOver(trx) ) break;
+
+ } else
+ {
+ DBG_WARNING("grr_InitOamTrxPkg(%d): unexpected module origin(%d)\n",
+ trx, grr_ItcRxOrigin);
+ }
+ }
+ }
+
+ grr_InitWatchTimerStop(trx);
+
+ DBG_TRACE("GRR finished the initialization of trx(%d)\n", trx);
+ printf("GRR finished the initialization of trx(%d)\n", trx);
+
+ DBG_LEAVE();
+}
+
+void grr_InitDsp(void)
+{
+ int length;
+
+ DBG_FUNC("grr_InitDsp", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ DBG_TRACE("GRR starting DSP initializatoin (swap=%d)\n",
+ OAMgrr_TRX_SWAP_SETTING);
+ printf("GRR starting DSP initializatoin (swap=%d)\n",
+ OAMgrr_TRX_SWAP_SETTING);
+
+ if (OAMgrr_TRX_SWAP_SETTING==1) //Swap two TRXs
+ l1pTrxSwap(0,1);
+
+ grr_InitWaitForDspsUpSignal();
+
+ //Decide if I-Q swap needed
+ OAMgrr_IQ_SWAP = drfIQSwapGet();
+
+ //3a. FreqHopDsp0Value = drfFreqHopGet(0) -- This function returns a True/False value
+ //3b. FreqHopDsp1Value = drfFreqHopGet(1) -- This function returns a True/False value
+ //Decide if hopping cable. If not, turn off the hopping feature. Assumed not capable now.
+ OAMgrr_HOPPING_CTRLa = 0;
+
+ //Init all trxs one by one
+ for (int i=0;i<OAMgrr_MAX_TRXS;i++)
+ {
+ grr_InitOamTrxPkg(i);
+ grr_PassOamParams(i);
+ grr_SendDspSynInf(i);
+ }
+
+ DBG_TRACE("GRR finished DSP initializatoin (swap=%d)\n",
+ OAMgrr_TRX_SWAP_SETTING);
+ printf("GRR finished DSP initializatoin (swap=%d)\n",
+ OAMgrr_TRX_SWAP_SETTING);
+
+ DBG_LEAVE();
+}
+
+void grr_InitWaitForRlcRrmGoAck(void)
+{
+ int length;
+
+ DBG_FUNC("grr_InitWaitForRlcRrmGoAck", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ bool waitForRlcGoAck=true;
+ bool waitForRrmGoAck=true;
+
+ while(waitForRlcGoAck||waitForRrmGoAck)
+ {
+ int length;
+
+ // Retrieve a message from Q
+ if ( (length = msgQReceive(grr_MsgQId,(char*)&grr_ItcRxMsg, sizeof(grr_ItcRxMsg_t), WAIT_FOREVER))
+ == ERROR )
+ {
+ //failed in calling vxWorks msgQReceive(). Abort the task!
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQRECEIVE_FAILED);
+ DBG_ERROR("grr_InitWaitForRlcRrmGoAck: failed to read VxWorks GRR Queue.\n");
+ printf("grr_InitWaitForRlcRrmGoAck: failed to read VxWorks GRR msg Queue\n");
+ DBG_LEAVE();
+ assert(0);
+ } else
+ {
+ //Good receive! If needed dump for debug purpose
+ if (grr_DbgDump) DBG_HEXDUMP((unsigned char*)&grr_ItcRxMsg, length);
+
+ //Handle the message in terms of its origin, do sanitory check too!
+ grr_ItcRxOrigin = grr_ItcRxMsg.module_id;
+
+ if (grr_ItcRxOrigin == MODULE_RLCMAC)
+ {
+ grr_pItcRxRlcMsg=(grr_ItcRxRlcMsg_t *)&grr_ItcRxMsg.itcRxRlcMsg;
+
+ //If needed, output trace for debugging purpose
+ DBG_TRACE("grr_InitWaitForRlcRrmGoAck: received a RLC msg (%d)\n",
+ grr_pItcRxRlcMsg->message_type);
+ if (grr_pItcRxRlcMsg->message_type == GRR_READY_TO_GO_ACK)
+ waitForRlcGoAck = false;
+
+ } else if (grr_ItcRxOrigin == MODULE_RM)
+ {
+ grr_pItcRxRrmMsg=(grr_ItcRxRrmMsg_t *)&grr_ItcRxMsg.itcRxRrmMsg;
+ DBG_TRACE("grr_InitWaitForRlcRrmGoAck: received a RRM msg (%d)\n",
+ grr_pItcRxRrmMsg->message_type);
+
+ if (grr_pItcRxRrmMsg->message_type == GRR_READY_TO_GO_ACK)
+ waitForRrmGoAck = false;
+ } else
+ {
+ DBG_WARNING("grr_InitWaitForRlcRrmGoAck: unexpected module origin(%d)\n",
+ grr_ItcRxOrigin);
+ }
+ }
+ }
+ DBG_LEAVE();
+}
+
+void grr_InitOam(void)
+{
+ DBG_FUNC("grr_InitOam", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ memset(&grr_OamData, 0, sizeof(grr_OamData));
+
+ grr_GetOamData();
+ grr_FixOamData();
+ grr_RegOamTrap();
+
+ DBG_LEAVE();
+}
+
+bool grr_GotAllDspsUpSignals(char *dsp)
+{
+ int i;
+
+ DBG_FUNC("grr_GotAllDspsUpSignals", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ if (!dsp[i]) break;
+
+ DBG_LEAVE();
+ return ((i>=OAMgrr_MAX_TRXS)?true:false);
+}
+
+void grr_InitWaitForDspsUpSignal(void)
+{
+ int length;
+ char dsp[OAMgrr_MAX_TRXS];
+
+ DBG_FUNC("grr_InitWaitForDspsUpSignal", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ memset(dsp, 0, OAMgrr_MAX_TRXS);
+
+ while(!grr_GotAllDspsUpSignals(dsp))
+ {
+ int length;
+
+ // Retrieve a message from Q
+ if ( (length = msgQReceive(grr_MsgQId,(char*)&grr_ItcRxMsg, sizeof(grr_ItcRxMsg_t), WAIT_FOREVER))
+ == ERROR )
+ {
+ //failed in calling vxWorks msgQReceive(). Abort the task!
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQRECEIVE_FAILED);
+ DBG_ERROR("grr_InitWaitForDspsUpSignal: failed to read VxWorks GRR Queue.\n");
+ printf("grr_InitWaitForDspsUpSignal: failed to read VxWorks GRR msg Queue\n");
+ DBG_LEAVE();
+ assert(0);
+ } else
+ {
+ //Good receive! If needed dump for debug purpose
+ if (grr_DbgDump) DBG_HEXDUMP((unsigned char*)&grr_ItcRxMsg, length);
+
+ //Handle the message in terms of its origin, do sanitory check too!
+ grr_ItcRxOrigin = grr_ItcRxMsg.module_id;
+
+ if (grr_ItcRxOrigin != MODULE_L1)
+ {
+ DBG_WARNING("grr_InitWaitForDspsUpSignal: unexpected module origin(%d)\n",
+ grr_ItcRxOrigin);
+ } else
+ {
+ grr_pItcRxDspMsg=(grr_ItcRxDspMsg_t *)&grr_ItcRxMsg.itcRxDspMsg;
+
+ //If needed, output trace for debugging purpose
+ DBG_TRACE("grr_InitWaitForDspsUpSignal: recv DSP msg(%x,%x,%x)) src(%x,%x,%x)\n",
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4],
+ grr_pItcRxDspMsg->buffer[5]);
+
+ if (GRR_L1MSGCMP(GRR_L1MG_TRXMGMT,GRR_L1MT_BOOTSTRAPCNF_MSB,GRR_L1MT_BOOTSTRAPCNF_LSB))
+ {
+ if ( (grr_pItcRxDspMsg->buffer[3]<OAMgrr_MAX_TRXS) && !(dsp[grr_pItcRxDspMsg->buffer[3]]))
+ {
+ dsp[grr_pItcRxDspMsg->buffer[3]] = 1;
+ grr_DspCiphCap = grr_pItcRxDspMsg->buffer[4];
+
+ } else
+ DBG_WARNING("grr_InitWaitForDspsUpSignal:dsp(%d) and its bootstrap status(%d)\n",
+ grr_pItcRxDspMsg->buffer[3], dsp[grr_pItcRxDspMsg->buffer[3]]);
+ } else
+ {
+ DBG_WARNING("grr_InitWaitForDspsUpSignal: unexpected msg(%x,%x,%x) src(%x,%x,%x)\n",
+ grr_pItcRxDspMsg->buffer[0],
+ grr_pItcRxDspMsg->buffer[1],
+ grr_pItcRxDspMsg->buffer[2],
+ grr_pItcRxDspMsg->buffer[3],
+ grr_pItcRxDspMsg->buffer[4],
+ grr_pItcRxDspMsg->buffer[5]);
+ }
+
+ }
+ }
+ }
+ DBG_LEAVE();
+}
+
+void grr_Init(void)
+{
+ JC_STATUS jcRet;
+ unsigned char i;
+
+ DBG_FUNC("grr_Init", GRR_LAYER_INIT);
+ DBG_ENTER();
+
+ //Starting initialization.
+
+ //Block other GP modules
+ grr_SubmitAlarm(EC_GRR_BOOTING_UP);
+
+ grr_InitOam();
+ grr_InitDsp();
+
+ //Signify to allow RRM and RLC go
+ //grr_SendReadyToGoReq(MODULE_GRR, rlcMsgQId);
+ if (JC_OK != (jcRet=RlcMacGrrReadyToGo()) )
+ {
+ DBG_ERROR("grr_Init: RlcMacGrrReadyToGo ret code(%d)\n", jcRet);
+ assert(0);
+ }
+
+ grr_SendReadyToGoReq(MODULE_GRR, rm_MsgQId);
+
+ //Wait for RRM & RLC go cnf
+ grr_InitWaitForRlcRrmGoAck();
+
+ //Turn on radio if needed
+ grr_FirstRadioCtrl();
+
+ //Unblock other GP modules
+ grr_SubmitAlarm(EC_NOERROR);
+
+ //Initialization is done.
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_INIT_CPP__
diff --git a/data/mnet/GP10/Host/grr/src_api/Makefile b/data/mnet/GP10/Host/grr/src_api/Makefile new file mode 100644 index 0000000..bdf7bd7 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src_api/Makefile @@ -0,0 +1,52 @@ +##########################################################
+#
+# (c) Copyright Cisco 2000
+# All Rights Reserved
+#
+##########################################################
+
+# TOP_OF_VOB must be defined before including l3defs.mk
+TOP_OF_VOB = ..\..\..
+
+# These Must be Properly Defined
+THIS_APP_DIR = grr
+THIS_DIRECTORY = Src_api
+MY_OUTPUT = $(OBJDIR)\grr_api.out
+
+# Name(s) of Common VOB directories to include
+COMMON_BLD_DIR =
+
+include $(TOP_OF_VOB)\l3defs.mk
+
+all: makeCommonObjs $(MY_OUTPUT)
+
+# Adds the .o file(s) list needed from the Common VOB
+makeCommonObjs:
+ifneq ($(COMMON_BLD_DIR),)
+ @for %f in ($(COMMON_BLD_DIR)) do \
+ make -C $(COMMON_VOB_APP_DIR)\%f \
+ all VOB=$(VOBNAME) APPDIR=Host\$(THIS_APP_DIR)\$(THIS_DIRECTORY)
+endif
+
+# If Common VOB directories to include get the .o files from bin
+$(MY_OUTPUT): $(MODULE_OBJS)
+ifneq ($(COMMON_BLD_DIR),)
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS) $(wildcard ./bin/*.o)
+else
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS)
+endif
+ $(NM) $@.tmp | munch > _ctdt.c
+ $(CC) -traditional $(CC_ARCH_SPEC) -c _ctdt.c
+ $(LD) -r -o $@ _ctdt.o $@.tmp
+ $(RM)$(subst /,$(DIRCHAR), _ctdt.c _ctdt.o $@.tmp)
+
+cleanall:
+ @for %f in ($(notdir $(MODULE_OBJS))) do \
+ $(RM) ..\bin\%f
+
+ $(RM) $(MY_OUTPUT)
+
+ifneq ($(COMMON_BLD_DIR),)
+ $(RM) bin\*.o
+ $(RM) bin\*.out
+endif
\ No newline at end of file diff --git a/data/mnet/GP10/Host/grr/src_api/grr_intf.cpp b/data/mnet/GP10/Host/grr/src_api/grr_intf.cpp new file mode 100644 index 0000000..838e4f3 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src_api/grr_intf.cpp @@ -0,0 +1,508 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+
+#ifndef __GRR_INTF_CPP_
+#define __GRR_INTF_CPP__
+
+#include "grr\grr_head.h"
+
+//Administrative & operational state & chan config related inquiries
+//
+AdministrativeState grr_GetBtsAmState(void)
+{
+ return(OAMgrr_BTS_AMSTATE);
+}
+
+AdministrativeState grr_GetTrxAmState(int trx)
+{
+ return(OAMgrr_TRX_AMSTATE(trx));
+}
+
+AdministrativeState grr_GetTrxSlotAmState(int trx, int slot)
+{
+ return(OAMgrr_TRX_SLOT_AMSTATE(trx,slot));
+}
+
+EnableDisable grr_GetBtsOpState(void)
+{
+ return(OAMgrr_BTS_OPSTATE);
+}
+
+EnableDisable grr_GetTrxOpState(int trx)
+{
+ return(OAMgrr_TRX_OPSTATE(trx));
+}
+
+EnableDisable grr_GetTrxSlotOpState(int trx, int slot)
+{
+ return(OAMgrr_TRX_SLOT_OPSTATE(trx,slot));
+}
+
+bool grr_IsPccchExisting(int *trx, int* slot, int* comb)
+{
+ bool ret;
+ unsigned char i, j;
+
+ *trx = *slot = 0;
+ *comb = OAMgrr_TRX_SLOT_COMB(0,0);
+ ret=false;
+
+ for (i=0;i<OAMgrr_MAX_TRXS;i++)
+ for (j=0;j<8;j++)
+ {
+ if ( (OAMgrr_TRX_SLOT_COMB(i,j)==OAMgrr_SLOT_COMB_11) ||
+ (OAMgrr_TRX_SLOT_COMB(i,j)==OAMgrr_SLOT_COMB_12) )
+ {
+ *trx = i; *slot = j;
+ *comb = OAMgrr_TRX_SLOT_COMB(i,j);
+ ret = true;
+ break;
+ }
+ }
+
+ return ret;
+}
+
+int grr_GetTrxSlotChanComb(int trx, int slot)
+{
+ return(OAMgrr_TRX_SLOT_CHANCOMB(trx,slot));
+}
+
+int grr_GetTrxSlotTsc(int trx, int slot)
+{
+ return(OAMgrr_TRX_SLOT_TSC(trx,slot));
+}
+
+int grr_GetTrxSlotArfcn(int trx, int slot)
+{
+ return(OAMgrr_TRX_SLOT_ARFCN(trx,slot));
+}
+
+int grr_getBtsGprsNetworkMode(void)
+{
+ return (OAMgrr_GPRS_NETWORK_MODE);
+}
+
+bool grr_IsBtsAmTypeBlocked(void)
+{
+ return ( (OAMgrr_BTS_AMSTATE != unlocked) ||
+ (OAMgrr_TRX_AMSTATE(0) != unlocked) ||
+ (OAMgrr_TRX_SLOT_AMSTATE(0,0) != unlocked) );
+
+}
+
+bool grr_IsBtsOpTypeBlocked(void)
+{
+ return (OAMgrr_BTS_OPSTATE!=opStateEnabled);
+}
+
+bool grr_IsBtsBlocked(void)
+{
+ return(grr_IsBtsAmTypeBlocked()||grr_IsBtsOpTypeBlocked());
+}
+
+bool grr_IsBtsGprsFeatureActive(void)
+{
+ return (OAMgrr_GPRS_FEATURE_SETTING);
+}
+
+bool grr_IsBtsCbFeatureActive(void)
+{
+ return (OAMgrr_CB_FEATURE_SETTING);
+}
+
+
+//Update application modules i.e. RLC, RRM with current setting
+//
+void grr_SendTrxSlotChanComb(int src_module, MSG_Q_ID dst_q, int trx, int slot, int chanComb)
+{
+ DBG_FUNC("grr_SendTrxSlotChanComb", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_TRX_SLOT_CHANCOMB, trx, slot, chanComb);
+
+ DBG_TRACE("grr_SendTrxSlotChanComb: src(%d) dst(%p) trx(%d) slot(%d) msg(%d) chanComb(%d)\n",
+ src_module, dst_q, trx, slot, GRR_TRX_SLOT_CHANCOMB, chanComb);
+}
+
+void grr_SendGprsFeatureSetting(int src_module, MSG_Q_ID dst_q)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendGprsFeatureSetting", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_GPRS_FEATURE_CONTROL,0,0,OAMgrr_GPRS_FEATURE_SETTING);
+
+ DBG_TRACE("grr_SendGprsFeatureSetting: src(%d) dst(%p) setting(%d)\n",
+ src_module, dst_q, OAMgrr_GPRS_FEATURE_SETTING);
+
+ DBG_LEAVE();
+}
+
+
+void grr_SendCbFeatureSetting(int src_module, MSG_Q_ID dst_q)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendCbFeatureSetting", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_CB_FEATURE_CONTROL, 0, 0, OAMgrr_CB_FEATURE_SETTING);
+
+ DBG_TRACE("grr_SendCbFeatureSetting: src(%d) dst(%p) setting(%d)\n",
+ src_module, dst_q, OAMgrr_CB_FEATURE_SETTING);
+
+ DBG_LEAVE();
+}
+
+void grr_SendReadyToGoReq(int src_module, MSG_Q_ID dst_q)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendReadyToGoReq", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_READY_TO_GO_REQ, 0, 0, 0);
+
+ DBG_TRACE("grr_SendReadyToGoReq: src(%d) dst(%p)\n", src_module, dst_q);
+
+ DBG_LEAVE();
+
+}
+
+void grr_SendReadyToGoAck(int src_module, MSG_Q_ID dst_q)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendReadyToGoAck", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_READY_TO_GO_ACK, 0, 0, 0);
+
+ DBG_TRACE("grr_SendReadyToGoAck: src(%d) dst(%p)\n", src_module, dst_q);
+
+ DBG_LEAVE();
+}
+
+//Administrative State related operations: requests and acknowledgements
+//
+//void grr_SendBtsLockReq (int src_module, MSG_Q_ID dst_q);
+//void grr_SendBtsUnlockReq (int src_module, MSG_Q_ID dst_q);
+//void grr_SendBtsShutdownReq (int src_module, MSG_Q_ID dst_q);
+//void grr_SendBtsLockAck (int src_module, MSG_Q_ID dst_q);
+//void grr_SendBtsUnlockAck (int src_module, MSG_Q_ID dst_q);
+//void grr_SendBtsShutdownAck (int src_module, MSG_Q_ID dst_q);
+
+//void grr_SendTrxLockReq (int src_module, MSG_Q_ID dst_q, int trx);
+//void grr_SendTrxUnlockReq (int src_module, MSG_Q_ID dst_q, int trx);
+//void grr_SendTrxShutdownReq (int src_module, MSG_Q_ID dst_q, int trx);
+//void grr_SendTrxLockAck (int src_module, MSG_Q_ID dst_q, int trx);
+//void grr_SendTrxUnlockAck (int src_module, MSG_Q_ID dst_q, int trx);
+//void grr_SendTrxShutdownAck (int src_module, MSG_Q_ID dst_q, int trx);
+
+void grr_SendTrxSlotLockReq (int src_module, MSG_Q_ID dst_q, int trx, int slot)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendTrxSlotLockReq", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_TRX_SLOT_LOCK_REQ, trx, slot, 0);
+
+ DBG_TRACE("grr_SendTrxSlotLockReq: src(%d) dst(%d) trx(%d) slot(%d) msg(%d)\n",
+ src_module, dst_q, trx, slot, GRR_TRX_SLOT_LOCK_REQ);
+
+ DBG_LEAVE();
+}
+
+void grr_SendTrxSlotShutdownReq(int src_module, MSG_Q_ID dst_q, int trx, int slot)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendTrxSlotShutdownReq", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_TRX_SLOT_SHUTDOWN_REQ, trx, slot, 0);
+
+ DBG_TRACE("grr_SendTrxSlotShutdownReq: src(%d) dst(%d) trx(%d) slot(%d) msg(%d)\n",
+ src_module, dst_q, trx, slot, GRR_TRX_SLOT_SHUTDOWN_REQ);
+
+ DBG_LEAVE();
+}
+
+void grr_SendTrxSlotLockAck(int src_module, MSG_Q_ID dst_q, int trx, int slot)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendTrxSlotLockAck", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_TRX_SLOT_LOCK_ACK, trx, slot, 0);
+
+ DBG_TRACE("grr_SendTrxSlotLockAck: src(%d) dst(%d) trx(%d) slot(%d) msg(%d)\n",
+ src_module, dst_q, trx, slot, GRR_TRX_SLOT_LOCK_ACK);
+
+ DBG_LEAVE();
+}
+
+void grr_SendTrxSlotShutdownAck (int src_module, MSG_Q_ID dst_q, int trx, int slot)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendTrxSlotShutdownAck", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_TRX_SLOT_SHUTDOWN_ACK, trx, slot, 0);
+
+ DBG_TRACE("grr_SendTrxSlotShutdownAck: src(%d) dst(%d) trx(%d) slot(%d) msg(%d)\n",
+ src_module, dst_q, trx, slot, GRR_TRX_SLOT_SHUTDOWN_ACK);
+
+ DBG_LEAVE();
+
+}
+
+//void grr_SendTrxSlotUnlockAck(int src_module, MSG_Q_ID dst_q, int trx, int slot);
+//void grr_SendTrxSlotUnlockReq(int src_module, MSG_Q_ID dst_q, int trx, int slot);
+
+void grr_SendCbCfgSetting(int src_module, MSG_Q_ID dst_q)
+{
+ DBG_FUNC("grr_SendCbCfgSetting", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ grr_SendMsg(src_module, dst_q, GRR_CB_FEATURE_CONTROL, 0, 0, OAMgrr_CB_FEATURE_SETTING);
+
+ DBG_TRACE("grr_SendCbCfgSetting: src(%d) dst(%d) msg(%d) setting(%d)\n",
+ src_module, dst_q, GRR_CB_FEATURE_CONTROL, OAMgrr_CB_FEATURE_SETTING);
+
+ DBG_LEAVE();
+}
+
+
+//Messaging related to radio resource scheduling
+//
+//void grr_ReportRadioResUsage (int src_module, MSG_Q_ID dst_q);
+//void grr_GetRadioResRelCandiate (int *trx, int *slot);
+
+//void grr_OverloadedCellBarOff(void)
+//{
+// DBG_FUNC("grr_OverloadedCellBarOff", GRR_LAYER_INTF);
+// DBG_ENTER();
+
+// if ( (OAMgrr_BTS_AMSTATE==unlocked) &&
+// (OAMgrr_TRX_AMSTATE(0)==unlocked) &&
+// (OAMgrr_CHN_AMSTATE(0,0)==unlocked) )
+// {
+// grr_PassOamMsSystemInformation2(0,GRR_L1SI_TYPE_2,OAMgrr_RA_CELL_BARRED_STATE);
+// grr_PassOamMsSystemInformation3(0,GRR_L1SI_TYPE_3,OAMgrr_RA_CELL_BARRED_STATE);
+// grr_PassOamMsSystemInformation4(0,GRR_L1SI_TYPE_4,OAMgrr_RA_CELL_BARRED_STATE);
+// }
+//
+// DBG_LEAVE();
+//}
+
+T_CNI_RIL3_ACCESS_TECHNOLOGY_TYPE grr_GetRadioAccessTechnology(void)
+{
+ T_CNI_RIL3_ACCESS_TECHNOLOGY_TYPE sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_UNKNOWN;
+
+ DBG_FUNC("grr_GetRadioAccessTechnology", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ switch(OAMgrr_GSMDCS_INDICATOR)
+ {
+ case gsm: //0
+ sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_GSM_P;
+ break;
+ case extendedgsm: //1
+ sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_GSM_E;
+ break;
+ case dcs: //2
+ sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_GSM_1800;
+ break;
+ case pcs1900: //3
+ sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_GSM_1900;
+ break;
+ //case gsmr: //4
+ // sys = CNI_RIL3_ACCESS_TECHNOLOGY_TYPE_GSM_R;
+ // break;
+ }
+ DBG_LEAVE();
+ return sys;
+}
+
+
+short grr_DecideCipherAlgo(
+ T_CNI_RIL3_IE_CIPHER_MODE_SETTING *setting,
+ T_CNI_RIL3_IE_MS_CLASSMARK_2 *classmark2)
+{
+ short algo = 0;
+
+ DBG_FUNC("grr_DecideCipherAlgo", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ setting->ciphering = CNI_RIl3_CIPHER_START_CIPHERING;
+
+ DBG_TRACE("grr_DecideCipherAlgo: dspCiphCap(%x)\n", grr_DspCiphCap);
+
+ if ( !classmark2->a51 && GRR_DSPA51(grr_DspCiphCap) )
+ {
+ algo = 1;
+ setting->algorithm = CNI_RIL3_CIPHER_ALGORITHM_A51;
+ } else if (classmark2->a52 && GRR_DSPA52(grr_DspCiphCap) )
+ {
+ algo = 2;
+ setting->algorithm = CNI_RIL3_CIPHER_ALGORITHM_A52;
+ } else
+ {
+ algo = 0;
+ setting->ciphering =CNI_RIl3_CIPHER_NO_CIPHERING;
+ }
+
+ DBG_LEAVE();
+ return (algo);
+}
+
+//GRR always call this func to submit alarms
+void grr_SubmitAlarm(Alarm_errorCode_t code)
+{
+ STATUS ret;
+ JC_STATUS jcRet;
+
+ DBG_FUNC("grr_SubmitAlarm", GRR_LAYER_ALARM);
+ DBG_ENTER();
+
+ DBG_TRACE("grr_SubmitAlarm: submit alarm code(%d)\n", code);
+
+ if (code != EC_NOERROR)
+ {
+ if (JC_OK!=alarm_raise(MODULE_GRR, MIB_errorCode_GRR, code))
+ {
+ //This is very critical, should abort GRR task here !
+ DBG_ERROR("grr_SubmitAlarm: alarm_raise failed to raise alarm(%d)\n", code);
+ printf("grr_SubmitAlarm: alarm_raise failed to raise alarm(%d)\n", code);
+ assert(0);
+ }
+ } else
+ {
+ if (JC_OK!=alarm_clear(MODULE_GRR, MIB_errorCode_GRR, code))
+ {
+ //This is very critical, should abort GRR task here <TBD>!!!
+ DBG_ERROR("grr_SubmitAlarm: alarm_clear failed to clear an alarm\n");
+ printf("grr_SubmitAlarm: alarm_clear failed to clear an alarm\n");
+ assert(0);
+ }
+ }
+
+ //Remember it if it is a critical alarm
+ if (code < EC_GRR_INFO_BASE)
+ {
+ //btsOpState goes disabled for a critical alarm
+ if (code == EC_NOERROR)
+ {
+ if (OAMgrr_BTS_OPSTATE == opStateDisabled)
+ {
+ DBG_TRACE("grr_SubmitAlarm: inform RLC_MAC of bts op enabled (op %d, alarm %d)\n",
+ OAMgrr_BTS_OPSTATE, code);
+ if (JC_OK != (jcRet=RlcMacGPOpState(opStateEnabled)))
+ DBG_ERROR("grr_SubmitAlarm: RlcMacGPOpState() err(%d)\n", jcRet);
+ }
+ OAMgrr_BTS_OPSTATEa = opStateEnabled;
+ } else
+ {
+ if (OAMgrr_BTS_OPSTATE == opStateEnabled)
+ {
+ DBG_TRACE("grr_SubmitAlarm: inform RLC_MAC of bts op disabled (op %d, alarm %d)\n",
+ OAMgrr_BTS_OPSTATE, code);
+ if (JC_OK != (jcRet=RlcMacGPOpState(opStateDisabled)))
+ DBG_ERROR("grr_SubmitAlarm: RlcMacGPOpState() err(%d)\n", jcRet);
+ }
+ OAMgrr_BTS_OPSTATEa = opStateDisabled;
+ }
+ }
+
+ DBG_LEAVE();
+}
+
+void grr_SendMsg(int src_module, MSG_Q_ID dst_q, grr_MessageType_t msgType,
+ int trx, int slot, int ctrl)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+
+ DBG_FUNC("grr_SendMsg", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ msg.module_id = (unsigned char) src_module;
+ msg.message_type = msgType;
+ msg.trx = (unsigned char) trx;
+ msg.slot = (unsigned char) slot;
+ msg.feat_ctrl = (unsigned char) ctrl;
+
+ //
+ if (STATUS_OK != (ret = msgQSend(dst_q, (char*)&msg,
+ sizeof(grr_ItcMsg_t), NO_WAIT, MSG_PRI_NORMAL) ) )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQSEND_FAILED);
+ DBG_ERROR(" grr_SendMsg: msgQSend failed Q(%x) ret(%d) errno(%d)\n",
+ dst_q, ret, errno);
+ printf(" grr_SendMsg: msgQSend failed Q(%x) ret(%d) errno(%d)\n",
+ dst_q, ret, errno);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+
+}
+
+void grr_SendMsgFromL1ToGrr(unsigned short length, unsigned char* buf)
+{
+ STATUS ret;
+ grr_ItcMsg_t msg;
+
+ DBG_FUNC("grr_SendMsgFromL1ToGrr", GRR_LAYER_INTF);
+ DBG_ENTER();
+
+ //Check if buf[3] i.e. trx and length valid
+ if ( (buf[3]>=OAMgrr_MAX_TRXS) || (length<4) )
+ {
+ DBG_WARNING("grr_SendMsgFromL1ToGrr: invalid trx(%d) or length(%d)\n",
+ buf[3], length);
+ return;
+ }
+
+ msg.module_id = MODULE_L1;
+ memcpy(msg.buffer, buf, length);
+
+ if (grr_DbgDump) DBG_HEXDUMP(buf, length);
+
+ if (STATUS_OK != (ret = msgQSend(grr_MsgQId, (char*) &msg, sizeof(grr_ItcMsg_t),
+ WAIT_FOREVER, MSG_PRI_NORMAL) ) )
+ {
+ grr_SubmitAlarm(EC_GRR_OS_CALL_MSGQSEND_FAILED);
+ DBG_ERROR("grr_SendMsgFromL1ToGrr: msgQSend failed, Queue(%p) ret(%d) errno(%d)\n",
+ grr_MsgQId, ret, errno);
+ printf("grr_SendMsgFromL1ToGrr: msgQSend failed, Queue(%p) ret(%d) errno(%d)\n",
+ grr_MsgQId, ret, errno);
+ assert(0);
+ }
+
+ DBG_LEAVE();
+}
+
+#endif //__GRR_INTF_CPP__
+
diff --git a/data/mnet/GP10/Host/grr/src_init/Makefile b/data/mnet/GP10/Host/grr/src_init/Makefile new file mode 100644 index 0000000..2733b91 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src_init/Makefile @@ -0,0 +1,52 @@ +##########################################################
+#
+# (c) Copyright Cisco 2000
+# All Rights Reserved
+#
+##########################################################
+
+# TOP_OF_VOB must be defined before including l3defs.mk
+TOP_OF_VOB = ..\..\..
+
+# These Must be Properly Defined
+THIS_APP_DIR = grr
+THIS_DIRECTORY = Src_init
+MY_OUTPUT = $(OBJDIR)\grr_init.out
+
+# Name(s) of Common VOB directories to include
+COMMON_BLD_DIR =
+
+include $(TOP_OF_VOB)\l3defs.mk
+
+all: makeCommonObjs $(MY_OUTPUT)
+
+# Adds the .o file(s) list needed from the Common VOB
+makeCommonObjs:
+ifneq ($(COMMON_BLD_DIR),)
+ @for %f in ($(COMMON_BLD_DIR)) do \
+ make -C $(COMMON_VOB_APP_DIR)\%f \
+ all VOB=$(VOBNAME) APPDIR=Host\$(THIS_APP_DIR)\$(THIS_DIRECTORY)
+endif
+
+# If Common VOB directories to include get the .o files from bin
+$(MY_OUTPUT): $(MODULE_OBJS)
+ifneq ($(COMMON_BLD_DIR),)
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS) $(wildcard ./bin/*.o)
+else
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS)
+endif
+ $(NM) $@.tmp | munch > _ctdt.c
+ $(CC) -traditional $(CC_ARCH_SPEC) -c _ctdt.c
+ $(LD) -r -o $@ _ctdt.o $@.tmp
+ $(RM)$(subst /,$(DIRCHAR), _ctdt.c _ctdt.o $@.tmp)
+
+cleanall:
+ @for %f in ($(notdir $(MODULE_OBJS))) do \
+ $(RM) ..\bin\%f
+
+ $(RM) $(MY_OUTPUT)
+
+ifneq ($(COMMON_BLD_DIR),)
+ $(RM) bin\*.o
+ $(RM) bin\*.out
+endif
\ No newline at end of file diff --git a/data/mnet/GP10/Host/grr/src_init/grr_glob.cpp b/data/mnet/GP10/Host/grr/src_init/grr_glob.cpp new file mode 100644 index 0000000..63432e8 --- /dev/null +++ b/data/mnet/GP10/Host/grr/src_init/grr_glob.cpp @@ -0,0 +1,206 @@ +/*
+********************************************************************
+**
+** (c) Copyright Cisco 2000
+** All Rights Reserved
+**
+*********************************************************************
+*/
+#ifndef __GRR_GLOB_CPP__
+#define __GRR_GLOB_CPP__
+
+#include "grr\grr_head.h"
+
+//G2TEST
+int grr_DbgDump=0;
+int grr_GprsCtrl=0;
+
+JCTask grrTaskObj("grrTask");
+JCTask grrMonTaskObj("grrMonTask");
+
+unsigned char grr_DspCiphCap=0;
+
+grr_OamData_t grr_OamData;
+grr_TrxMgmt_t grr_TrxMgmt[OAMgrr_MAX_TRXS];
+MSG_Q_ID grr_MsgQId;
+Alarm_errorCode_t grr_CurAlarm;
+
+unsigned char grr_ItcRxOrigin;
+grr_ItcRxMsg_t grr_ItcRxMsg;
+
+grr_ItcRxDspMsg_t *grr_pItcRxDspMsg;
+grr_ItcRxRlcMsg_t *grr_pItcRxRlcMsg;
+grr_ItcRxGrrMsg_t *grr_pItcRxGrrMsg;
+grr_ItcRxOamMsg_t *grr_pItcRxOamMsg;
+grr_ItcRxRrmMsg_t *grr_pItcRxRrmMsg;
+
+T_CNI_RIL3RRM_MSG grr_Msg;
+
+grr_Si2_t grr_Si2;
+grr_Si3_t grr_Si3;
+grr_Si4_t grr_Si4;
+grr_Si5_t grr_Si5;
+grr_Si6_t grr_Si6;
+grr_Si13_t grr_Si13;
+
+
+//OAM tables definitions
+//
+const unsigned short grr_phTrxSelectBit[2]= {0x0000,0x4000}; //b14
+const unsigned short grr_phTrxSynthSelectBit[2] = {0x0000,0x8000}; //b15
+const unsigned short grr_phTrxHoppingSelectBit[2] = {0x0000,0x2000}; //b13
+const unsigned short grr_phTrxPwrSelectBit[2] = {0x0000,0x1000}; //b12
+
+//Tables in Basic Package
+CellAllocationEntry cellAllocationTable[CellAllocationTableLimit];
+PlmnPermittedEntry plmnPermittedTable[PlmnPermittedTableLimit];
+
+//Table in Option Package
+NotAllowedAccessClassEntry notAllowedAccessClassTable[NotAllowedAccessClassTableLimit];
+
+//Table in TRX packages
+ChannelEntry firstTrxPackageChannelTable[ChannelTableLimit];
+ChannelEntry secondTrxPackageChannelTable[ChannelTableLimit];
+
+CarrierFrequencyEntry firstRadioCarrierPackageFrequencyListTable[CarrierFrequencyTableLimit];
+CarrierFrequencyEntry secondRadioCarrierPackageFrequencyListTable[CarrierFrequencyTableLimit];
+
+//Tables in AdjCell Packages
+AdjCell_HandoverEntry adjCell_HandoverTable[HandoverTableLimit];
+AdjCell_HandoverEntry adjCell_HandoverTable_t[HandoverTableLimit];
+AdjCell_ReselectionEntry adjCell_ReselectionTable[ReselectionTableLimit];
+
+//A complete list of GRR-raised alarms from reference
+
+//Section I: critical alarms
+
+//EC_GRR_BOOTING_UP
+
+//EC_GRR_OS_CALL_WDCREATE_FAILED
+//EC_GRR_OS_CALL_WDSTART_FAILED
+//EC_GRR_OS_CALL_MSGQCREATE_FAILED
+//EC_GRR_OS_CALL_MSGQRECEIVE_FAILED
+//EC_GRR_OS_CALL_MSGQSEND_FAILED
+
+//EC_GRR_OAM_CALL_SETMIBINTVAR_FAILED
+//EC_GRR_OAM_CALL_SETTBLENTRYFIELD_FAILED
+//EC_GRR_OAM_CALL_GETMIBSTRUCT_FAILED
+//EC_GRR_OAM_CALL_GETMIBTBL_FAILED
+//EC_GRR_OAM_CALL_UNSETTRAPBYMODULE_FAILED
+//EC_GRR_OAM_CALL_SETTRAP_FAILED
+
+//EC_GRR_RIL3_CALL_RRM_ENCODER_FAILED
+
+//EC_GRR_BTS_LOCKED
+//EC_GRR_BTS_UNLOCKED
+//EC_GRR_BTS_SHUTTINGDOWN
+//EC_GRR_MIB_INVALID_CB_CONFIG
+
+const Alarm_errorCode_t
+ grr_DspNotResponding[OAMgrr_MAX_TRXS]
+ = {EC_GRR_DSP_1_NOT_RESPONDING, EC_GRR_DSP_2_NOT_RESPONDING};
+
+const Alarm_errorCode_t
+ grr_DspNotTickingAnyMore[OAMgrr_MAX_TRXS]
+ = {EC_GRR_DSP_1_NOT_TICKING, EC_GRR_DSP_2_NOT_TICKING};
+
+const Alarm_errorCode_t
+ grr_DspInitWatchTimerExpiredAlarmCode[OAMgrr_MAX_TRXS]
+ = {EC_GRR_DSP_1_INIT_WATCH_TIMER_EXPIRED, EC_GRR_DSP_2_INIT_WATCH_TIMER_EXPIRED};
+
+const Alarm_errorCode_t
+ grr_TrxSlotActNackAlarmCode[OAMgrr_MAX_TRXS][8]
+ = { {EC_GRR_TRX_1_SLOT_1_ACT_NACK, EC_GRR_TRX_1_SLOT_2_ACT_NACK,
+ EC_GRR_TRX_1_SLOT_3_ACT_NACK, EC_GRR_TRX_1_SLOT_4_ACT_NACK,
+ EC_GRR_TRX_1_SLOT_5_ACT_NACK, EC_GRR_TRX_1_SLOT_6_ACT_NACK,
+ EC_GRR_TRX_1_SLOT_7_ACT_NACK, EC_GRR_TRX_1_SLOT_8_ACT_NACK
+ },
+
+ {EC_GRR_TRX_2_SLOT_1_ACT_NACK, EC_GRR_TRX_2_SLOT_2_ACT_NACK,
+ EC_GRR_TRX_2_SLOT_3_ACT_NACK, EC_GRR_TRX_2_SLOT_4_ACT_NACK,
+ EC_GRR_TRX_2_SLOT_5_ACT_NACK, EC_GRR_TRX_2_SLOT_6_ACT_NACK,
+ EC_GRR_TRX_2_SLOT_7_ACT_NACK, EC_GRR_TRX_2_SLOT_8_ACT_NACK
+ }
+ };
+
+
+//Section II: Informational Alarms
+
+//Informational alarms related to trx slot channel combination change
+const Alarm_errorCode_t
+ grr_TrxSlotChanCombChangeAlarmCode[OAMgrr_MAX_TRXS][8]
+ = { {EC_GRR_TRX_1_SLOT_1_CHANCOMB_CHANGED, EC_GRR_TRX_1_SLOT_2_CHANCOMB_CHANGED,
+ EC_GRR_TRX_1_SLOT_3_CHANCOMB_CHANGED, EC_GRR_TRX_1_SLOT_4_CHANCOMB_CHANGED,
+ EC_GRR_TRX_1_SLOT_5_CHANCOMB_CHANGED, EC_GRR_TRX_1_SLOT_6_CHANCOMB_CHANGED,
+ EC_GRR_TRX_1_SLOT_7_CHANCOMB_CHANGED, EC_GRR_TRX_1_SLOT_8_CHANCOMB_CHANGED
+ },
+
+ {EC_GRR_TRX_2_SLOT_1_CHANCOMB_CHANGED, EC_GRR_TRX_2_SLOT_2_CHANCOMB_CHANGED,
+ EC_GRR_TRX_2_SLOT_3_CHANCOMB_CHANGED, EC_GRR_TRX_2_SLOT_4_CHANCOMB_CHANGED,
+ EC_GRR_TRX_2_SLOT_5_CHANCOMB_CHANGED, EC_GRR_TRX_2_SLOT_6_CHANCOMB_CHANGED,
+ EC_GRR_TRX_2_SLOT_7_CHANCOMB_CHANGED, EC_GRR_TRX_2_SLOT_8_CHANCOMB_CHANGED
+ }
+ };
+
+
+//Informational alarm related to administrative state operations of radio resoureces
+const Alarm_errorCode_t
+ grr_TrxAmStateLockedAlarmCode[OAMgrr_MAX_TRXS]
+ = {EC_GRR_TRX_1_LOCKED,EC_GRR_TRX_2_LOCKED};
+
+const Alarm_errorCode_t
+ grr_TrxAmStateUnlockedAlarmCode[OAMgrr_MAX_TRXS]
+ = {EC_GRR_TRX_1_UNLOCKED,EC_GRR_TRX_2_UNLOCKED};
+
+const Alarm_errorCode_t
+ grr_TrxAmStateShuttingdownAlarmCode[OAMgrr_MAX_TRXS]
+ = {EC_GRR_TRX_1_SHUTTINGDOWN,EC_GRR_TRX_2_SHUTTINGDOWN};
+
+const Alarm_errorCode_t
+ grr_TrxAmStateInvalidAlarmCode[OAMgrr_MAX_TRXS]
+ = {EC_GRR_TRX_1_AMSTATE_INVALID,EC_GRR_TRX_2_AMSTATE_INVALID};
+
+const Alarm_errorCode_t
+ grr_TrxSlotAmStateLockedAlarmCode[OAMgrr_MAX_TRXS][8]
+ = {
+ {EC_GRR_TRX_1_SLOT_1_LOCKED, EC_GRR_TRX_1_SLOT_2_LOCKED,
+ EC_GRR_TRX_1_SLOT_3_LOCKED, EC_GRR_TRX_1_SLOT_4_LOCKED,
+ EC_GRR_TRX_1_SLOT_5_LOCKED, EC_GRR_TRX_1_SLOT_6_LOCKED,
+ EC_GRR_TRX_1_SLOT_7_LOCKED, EC_GRR_TRX_1_SLOT_8_LOCKED},
+
+ {EC_GRR_TRX_2_SLOT_1_LOCKED, EC_GRR_TRX_2_SLOT_2_LOCKED,
+ EC_GRR_TRX_2_SLOT_3_LOCKED, EC_GRR_TRX_2_SLOT_4_LOCKED,
+ EC_GRR_TRX_2_SLOT_5_LOCKED, EC_GRR_TRX_2_SLOT_6_LOCKED,
+ EC_GRR_TRX_2_SLOT_7_LOCKED, EC_GRR_TRX_2_SLOT_8_LOCKED}
+ };
+
+const Alarm_errorCode_t
+ grr_TrxSlotAmStateUnlockedAlarmCode[OAMgrr_MAX_TRXS][8]
+ = {
+ {EC_GRR_TRX_1_SLOT_1_UNLOCKED, EC_GRR_TRX_1_SLOT_2_UNLOCKED,
+ EC_GRR_TRX_1_SLOT_3_UNLOCKED, EC_GRR_TRX_1_SLOT_4_UNLOCKED,
+ EC_GRR_TRX_1_SLOT_5_UNLOCKED, EC_GRR_TRX_1_SLOT_6_UNLOCKED,
+ EC_GRR_TRX_1_SLOT_7_UNLOCKED, EC_GRR_TRX_1_SLOT_8_UNLOCKED},
+
+ {EC_GRR_TRX_2_SLOT_1_UNLOCKED, EC_GRR_TRX_2_SLOT_2_UNLOCKED,
+ EC_GRR_TRX_2_SLOT_3_UNLOCKED, EC_GRR_TRX_2_SLOT_4_UNLOCKED,
+ EC_GRR_TRX_2_SLOT_5_UNLOCKED, EC_GRR_TRX_2_SLOT_6_UNLOCKED,
+ EC_GRR_TRX_2_SLOT_7_UNLOCKED, EC_GRR_TRX_2_SLOT_8_UNLOCKED}
+ };
+
+const Alarm_errorCode_t
+ grr_TrxSlotAmStateShuttingdownAlarmCode[OAMgrr_MAX_TRXS][8]
+ = {
+ {EC_GRR_TRX_1_SLOT_1_SHUTTINGDOWN, EC_GRR_TRX_1_SLOT_2_SHUTTINGDOWN,
+ EC_GRR_TRX_1_SLOT_3_SHUTTINGDOWN, EC_GRR_TRX_1_SLOT_4_SHUTTINGDOWN,
+ EC_GRR_TRX_1_SLOT_5_SHUTTINGDOWN, EC_GRR_TRX_1_SLOT_6_SHUTTINGDOWN,
+ EC_GRR_TRX_1_SLOT_7_SHUTTINGDOWN, EC_GRR_TRX_1_SLOT_8_SHUTTINGDOWN},
+
+ {EC_GRR_TRX_2_SLOT_1_SHUTTINGDOWN, EC_GRR_TRX_2_SLOT_2_SHUTTINGDOWN,
+ EC_GRR_TRX_2_SLOT_3_SHUTTINGDOWN, EC_GRR_TRX_2_SLOT_4_SHUTTINGDOWN,
+ EC_GRR_TRX_2_SLOT_5_SHUTTINGDOWN, EC_GRR_TRX_2_SLOT_6_SHUTTINGDOWN,
+ EC_GRR_TRX_2_SLOT_7_SHUTTINGDOWN, EC_GRR_TRX_2_SLOT_8_SHUTTINGDOWN}
+ };
+
+
+#endif //__GRR_GLOB_CPP__
|