diff --git a/internal/pkg/onuadaptercore/device_handler.go b/internal/pkg/onuadaptercore/device_handler.go
index ae7a593..379daa0 100644
--- a/internal/pkg/onuadaptercore/device_handler.go
+++ b/internal/pkg/onuadaptercore/device_handler.go
@@ -90,8 +90,8 @@
 	cOnuActivatedEvent = "ONU_ACTIVATED"
 )
 
-//DeviceHandler will interact with the ONU ? device.
-type DeviceHandler struct {
+//deviceHandler will interact with the ONU ? device.
+type deviceHandler struct {
 	deviceID         string
 	DeviceType       string
 	adminState       string
@@ -111,13 +111,13 @@
 	//pPonPort        *voltha.Port
 	deviceEntrySet  chan bool //channel for DeviceEntry set event
 	pOnuOmciDevice  *OnuDeviceEntry
-	pOnuTP          *OnuUniTechProf
+	pOnuTP          *onuUniTechProf
 	exitChannel     chan int
 	lockDevice      sync.RWMutex
 	pOnuIndication  *oop.OnuIndication
 	deviceReason    string
-	pLockStateFsm   *LockStateFsm
-	pUnlockStateFsm *LockStateFsm
+	pLockStateFsm   *lockStateFsm
+	pUnlockStateFsm *lockStateFsm
 
 	//flowMgr       *OpenOltFlowMgr
 	//eventMgr      *OpenOltEventMgr
@@ -130,14 +130,14 @@
 	stopCollector       chan bool
 	stopHeartbeatCheck  chan bool
 	activePorts         sync.Map
-	uniEntityMap        map[uint32]*OnuUniPort
+	uniEntityMap        map[uint32]*onuUniPort
 	UniVlanConfigFsmMap map[uint8]*UniVlanConfigFsm
 	reconciling         bool
 }
 
-//NewDeviceHandler creates a new device handler
-func NewDeviceHandler(cp adapterif.CoreProxy, ap adapterif.AdapterProxy, ep adapterif.EventProxy, device *voltha.Device, adapter *OpenONUAC) *DeviceHandler {
-	var dh DeviceHandler
+//newDeviceHandler creates a new device handler
+func newDeviceHandler(cp adapterif.CoreProxy, ap adapterif.AdapterProxy, ep adapterif.EventProxy, device *voltha.Device, adapter *OpenONUAC) *deviceHandler {
+	var dh deviceHandler
 	dh.coreProxy = cp
 	dh.AdapterProxy = ap
 	dh.EventProxy = ep
@@ -155,7 +155,7 @@
 	//dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
 	dh.activePorts = sync.Map{}
 	//TODO initialize the support classes.
-	dh.uniEntityMap = make(map[uint32]*OnuUniPort)
+	dh.uniEntityMap = make(map[uint32]*onuUniPort)
 	dh.UniVlanConfigFsmMap = make(map[uint8]*UniVlanConfigFsm)
 	dh.reconciling = false
 
@@ -184,8 +184,8 @@
 	return &dh
 }
 
-// Start save the device to the data model
-func (dh *DeviceHandler) Start(ctx context.Context) {
+// start save the device to the data model
+func (dh *deviceHandler) start(ctx context.Context) {
 	logger.Debugw("starting-device-handler", log.Fields{"device": dh.device, "device-id": dh.deviceID})
 	// Add the initial device to the local model
 	logger.Debug("device-handler-started")
@@ -193,17 +193,17 @@
 
 /*
 // stop stops the device dh.  Not much to do for now
-func (dh *DeviceHandler) stop(ctx context.Context) {
+func (dh *deviceHandler) stop(ctx context.Context) {
 	logger.Debug("stopping-device-handler")
 	dh.exitChannel <- 1
 }
 */
 
 // ##########################################################################################
-// DeviceHandler methods that implement the adapters interface requests ##### begin #########
+// deviceHandler methods that implement the adapters interface requests ##### begin #########
 
-//AdoptOrReconcileDevice adopts the OLT device
-func (dh *DeviceHandler) AdoptOrReconcileDevice(ctx context.Context, device *voltha.Device) {
+//adoptOrReconcileDevice adopts the OLT device
+func (dh *deviceHandler) adoptOrReconcileDevice(ctx context.Context, device *voltha.Device) {
 	logger.Debugw("Adopt_or_reconcile_device", log.Fields{"device-id": device.Id, "Address": device.GetHostAndPort()})
 
 	logger.Debugw("Device FSM: ", log.Fields{"state": string(dh.pDeviceStateFsm.Current())})
@@ -218,7 +218,7 @@
 
 }
 
-func (dh *DeviceHandler) processInterAdapterOMCIReqMessage(msg *ic.InterAdapterMessage) error {
+func (dh *deviceHandler) processInterAdapterOMCIReqMessage(msg *ic.InterAdapterMessage) error {
 	msgBody := msg.GetBody()
 	omciMsg := &ic.InterAdapterOmciMessage{}
 	if err := ptypes.UnmarshalAny(msgBody, omciMsg); err != nil {
@@ -232,15 +232,15 @@
 	logger.Debugw("inter-adapter-recv-omci", log.Fields{
 		"device-id": dh.deviceID, "RxOmciMessage": hex.EncodeToString(omciMsg.Message)})
 	//receive_message(omci_msg.message)
-	pDevEntry := dh.GetOnuDeviceEntry(true)
+	pDevEntry := dh.getOnuDeviceEntry(true)
 	if pDevEntry != nil {
-		return pDevEntry.PDevOmciCC.ReceiveMessage(context.TODO(), omciMsg.Message)
+		return pDevEntry.PDevOmciCC.receiveMessage(context.TODO(), omciMsg.Message)
 	}
 	logger.Errorw("No valid OnuDevice -aborting", log.Fields{"device-id": dh.deviceID})
 	return errors.New("no valid OnuDevice")
 }
 
-func (dh *DeviceHandler) processInterAdapterONUIndReqMessage(msg *ic.InterAdapterMessage) error {
+func (dh *deviceHandler) processInterAdapterONUIndReqMessage(msg *ic.InterAdapterMessage) error {
 	msgBody := msg.GetBody()
 	onuIndication := &oop.OnuIndication{}
 	if err := ptypes.UnmarshalAny(msgBody, onuIndication); err != nil {
@@ -266,7 +266,7 @@
 	return nil
 }
 
-func (dh *DeviceHandler) processInterAdapterTechProfileDownloadReqMessage(
+func (dh *deviceHandler) processInterAdapterTechProfileDownloadReqMessage(
 	msg *ic.InterAdapterMessage) error {
 	if dh.pOnuTP == nil {
 		//should normally not happen ...
@@ -321,7 +321,7 @@
 	return nil
 }
 
-func (dh *DeviceHandler) processInterAdapterDeleteGemPortReqMessage(
+func (dh *deviceHandler) processInterAdapterDeleteGemPortReqMessage(
 	msg *ic.InterAdapterMessage) error {
 
 	if dh.pOnuTP == nil {
@@ -356,7 +356,7 @@
 	return err
 }
 
-func (dh *DeviceHandler) processInterAdapterDeleteTcontReqMessage(
+func (dh *deviceHandler) processInterAdapterDeleteTcontReqMessage(
 	msg *ic.InterAdapterMessage) error {
 	if dh.pOnuTP == nil {
 		//should normally not happen ...
@@ -396,10 +396,10 @@
 	return nil
 }
 
-//ProcessInterAdapterMessage sends the proxied messages to the target device
+//processInterAdapterMessage sends the proxied messages to the target device
 // If the proxy address is not found in the unmarshalled message, it first fetches the onu device for which the message
 // is meant, and then send the unmarshalled omci message to this onu
-func (dh *DeviceHandler) ProcessInterAdapterMessage(msg *ic.InterAdapterMessage) error {
+func (dh *deviceHandler) processInterAdapterMessage(msg *ic.InterAdapterMessage) error {
 	msgID := msg.Header.Id
 	msgType := msg.Header.Type
 	fromTopic := msg.Header.FromTopic
@@ -441,7 +441,7 @@
 }
 
 //FlowUpdateIncremental removes and/or adds the flow changes on a given device
-func (dh *DeviceHandler) FlowUpdateIncremental(apOfFlowChanges *openflow_13.FlowChanges,
+func (dh *deviceHandler) FlowUpdateIncremental(apOfFlowChanges *openflow_13.FlowChanges,
 	apOfGroupChanges *openflow_13.FlowGroupChanges, apFlowMetaData *voltha.FlowMetadata) error {
 
 	//Remove flows
@@ -469,7 +469,7 @@
 				continue
 			} else {
 				// this is the relevant upstream flow
-				var loUniPort *OnuUniPort
+				var loUniPort *onuUniPort
 				if uniPort, exist := dh.uniEntityMap[flowInPort]; exist {
 					loUniPort = uniPort
 				} else {
@@ -492,10 +492,10 @@
 	return nil
 }
 
-//DisableDevice locks the ONU and its UNI/VEIP ports (admin lock via OMCI)
+//disableDevice locks the ONU and its UNI/VEIP ports (admin lock via OMCI)
 // TODO!!! Clarify usage of this method, it is for sure not used within ONOS (OLT) device disable
 //         maybe it is obsolete by now
-func (dh *DeviceHandler) DisableDevice(device *voltha.Device) {
+func (dh *deviceHandler) disableDevice(device *voltha.Device) {
 	logger.Debugw("disable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
 
 	//admin-lock reason can also be used uniquely for setting the DeviceState accordingly - inblock
@@ -507,7 +507,7 @@
 		if dh.pLockStateFsm == nil {
 			dh.createUniLockFsm(true, UniAdminStateDone)
 		} else { //LockStateFSM already init
-			dh.pLockStateFsm.SetSuccessEvent(UniAdminStateDone)
+			dh.pLockStateFsm.setSuccessEvent(UniAdminStateDone)
 			dh.runUniLockFsm(true)
 		}
 
@@ -525,10 +525,10 @@
 	}
 }
 
-//ReenableDevice unlocks the ONU and its UNI/VEIP ports (admin unlock via OMCI)
+//reEnableDevice unlocks the ONU and its UNI/VEIP ports (admin unlock via OMCI)
 // TODO!!! Clarify usage of this method, compare above DisableDevice, usage may clarify resulting states
 //         maybe it is obsolete by now
-func (dh *DeviceHandler) ReenableDevice(device *voltha.Device) {
+func (dh *deviceHandler) reEnableDevice(device *voltha.Device) {
 	logger.Debugw("reenable-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
 
 	// TODO!!! ConnectStatus and OperStatus to be set here could be more accurate, for now just ...(like python code)
@@ -551,12 +551,12 @@
 	if dh.pUnlockStateFsm == nil {
 		dh.createUniLockFsm(false, UniAdminStateDone)
 	} else { //UnlockStateFSM already init
-		dh.pUnlockStateFsm.SetSuccessEvent(UniAdminStateDone)
+		dh.pUnlockStateFsm.setSuccessEvent(UniAdminStateDone)
 		dh.runUniLockFsm(false)
 	}
 }
 
-func (dh *DeviceHandler) ReconcileDeviceOnuInd() {
+func (dh *deviceHandler) reconcileDeviceOnuInd() {
 	logger.Debugw("reconciling - simulate onu indication", log.Fields{"device-id": dh.deviceID})
 
 	if err := dh.pOnuTP.restoreFromOnuTpPathKvStore(context.TODO()); err != nil {
@@ -572,7 +572,7 @@
 	_ = dh.createInterface(&onuIndication)
 }
 
-func (dh *DeviceHandler) ReconcileDeviceTechProf() {
+func (dh *deviceHandler) reconcileDeviceTechProf() {
 	logger.Debugw("reconciling - trigger tech profile config", log.Fields{"device-id": dh.deviceID})
 
 	dh.pOnuTP.lockTpProcMutex()
@@ -603,7 +603,7 @@
 	dh.reconciling = false
 }
 
-func (dh *DeviceHandler) DeleteDevice(device *voltha.Device) error {
+func (dh *deviceHandler) deleteDevice(device *voltha.Device) error {
 	logger.Debugw("delete-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
 	if err := dh.pOnuTP.deleteOnuTpPathKvStore(context.TODO()); err != nil {
 		return err
@@ -612,13 +612,13 @@
 	return nil
 }
 
-func (dh *DeviceHandler) RebootDevice(device *voltha.Device) error {
+func (dh *deviceHandler) rebootDevice(device *voltha.Device) error {
 	logger.Debugw("reboot-device", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
 	if device.ConnectStatus != voltha.ConnectStatus_REACHABLE {
 		logger.Errorw("device-unreachable", log.Fields{"device-id": device.Id, "SerialNumber": device.SerialNumber})
 		return errors.New("device-unreachable")
 	}
-	if err := dh.pOnuOmciDevice.Reboot(context.TODO()); err != nil {
+	if err := dh.pOnuOmciDevice.reboot(context.TODO()); err != nil {
 		//TODO with VOL-3045/VOL-3046: return the error and stop further processing
 		logger.Errorw("error-rebooting-device", log.Fields{"device-id": dh.deviceID, "error": err})
 		return err
@@ -638,18 +638,18 @@
 	return nil
 }
 
-//  DeviceHandler methods that implement the adapters interface requests## end #########
+//  deviceHandler methods that implement the adapters interface requests## end #########
 // #####################################################################################
 
 // ################  to be updated acc. needs of ONU Device ########################
-// DeviceHandler StateMachine related state transition methods ##### begin #########
+// deviceHandler StateMachine related state transition methods ##### begin #########
 
-func (dh *DeviceHandler) logStateChange(e *fsm.Event) {
+func (dh *deviceHandler) logStateChange(e *fsm.Event) {
 	logger.Debugw("Device FSM: ", log.Fields{"event name": string(e.Event), "src state": string(e.Src), "dst state": string(e.Dst), "device-id": dh.deviceID})
 }
 
 // doStateInit provides the device update to the core
-func (dh *DeviceHandler) doStateInit(e *fsm.Event) {
+func (dh *deviceHandler) doStateInit(e *fsm.Event) {
 
 	logger.Debug("doStateInit-started")
 	var err error
@@ -716,7 +716,7 @@
 }
 
 // postInit setups the DeviceEntry for the conerned device
-func (dh *DeviceHandler) postInit(e *fsm.Event) {
+func (dh *deviceHandler) postInit(e *fsm.Event) {
 
 	logger.Debug("postInit-started")
 	var err error
@@ -725,14 +725,14 @@
 		dh.pTransitionMap.Handle(ctx, GrpcConnected)
 		return nil
 	*/
-	if err = dh.AddOnuDeviceEntry(context.TODO()); err != nil {
-		logger.Fatalf("Device FSM: AddOnuDeviceEntry-failed-%s", err)
+	if err = dh.addOnuDeviceEntry(context.TODO()); err != nil {
+		logger.Fatalf("Device FSM: addOnuDeviceEntry-failed-%s", err)
 		e.Cancel(err)
 		return
 	}
 
 	if dh.reconciling {
-		go dh.ReconcileDeviceOnuInd()
+		go dh.reconcileDeviceOnuInd()
 		// reconcilement will be continued after mib download is done
 	}
 	/*
@@ -785,7 +785,7 @@
 // for comparison of the original method (not that easy to uncomment): compare here:
 //  voltha-openolt-adapter/adaptercore/device_handler.go
 //  -> this one obviously initiates all communication interfaces of the device ...?
-func (dh *DeviceHandler) doStateConnected(e *fsm.Event) {
+func (dh *deviceHandler) doStateConnected(e *fsm.Event) {
 
 	logger.Debug("doStateConnected-started")
 	err := errors.New("device FSM: function not implemented yet")
@@ -794,7 +794,7 @@
 }
 
 // doStateUp handle the onu up indication and update to voltha core
-func (dh *DeviceHandler) doStateUp(e *fsm.Event) {
+func (dh *deviceHandler) doStateUp(e *fsm.Event) {
 
 	logger.Debug("doStateUp-started")
 	err := errors.New("device FSM: function not implemented yet")
@@ -813,7 +813,7 @@
 }
 
 // doStateDown handle the onu down indication
-func (dh *DeviceHandler) doStateDown(e *fsm.Event) {
+func (dh *deviceHandler) doStateDown(e *fsm.Event) {
 
 	logger.Debug("doStateDown-started")
 	var err error
@@ -875,14 +875,14 @@
 	logger.Debug("doStateDown-done")
 }
 
-// DeviceHandler StateMachine related state transition methods ##### end #########
+// deviceHandler StateMachine related state transition methods ##### end #########
 // #################################################################################
 
 // ###################################################
-// DeviceHandler utility methods ##### begin #########
+// deviceHandler utility methods ##### begin #########
 
-//GetOnuDeviceEntry getsthe  ONU device entry and may wait until its value is defined
-func (dh *DeviceHandler) GetOnuDeviceEntry(aWait bool) *OnuDeviceEntry {
+//getOnuDeviceEntry getsthe  ONU device entry and may wait until its value is defined
+func (dh *deviceHandler) getOnuDeviceEntry(aWait bool) *OnuDeviceEntry {
 	dh.lockDevice.RLock()
 	pOnuDeviceEntry := dh.pOnuOmciDevice
 	if aWait && pOnuDeviceEntry == nil {
@@ -905,32 +905,32 @@
 	return pOnuDeviceEntry
 }
 
-//SetOnuDeviceEntry sets the ONU device entry within the handler
-func (dh *DeviceHandler) SetOnuDeviceEntry(
-	apDeviceEntry *OnuDeviceEntry, apOnuTp *OnuUniTechProf) {
+//setOnuDeviceEntry sets the ONU device entry within the handler
+func (dh *deviceHandler) setOnuDeviceEntry(
+	apDeviceEntry *OnuDeviceEntry, apOnuTp *onuUniTechProf) {
 	dh.lockDevice.Lock()
 	defer dh.lockDevice.Unlock()
 	dh.pOnuOmciDevice = apDeviceEntry
 	dh.pOnuTP = apOnuTp
 }
 
-//AddOnuDeviceEntry creates a new ONU device or returns the existing
-func (dh *DeviceHandler) AddOnuDeviceEntry(ctx context.Context) error {
+//addOnuDeviceEntry creates a new ONU device or returns the existing
+func (dh *deviceHandler) addOnuDeviceEntry(ctx context.Context) error {
 	logger.Debugw("adding-deviceEntry", log.Fields{"device-id": dh.deviceID})
 
-	deviceEntry := dh.GetOnuDeviceEntry(false)
+	deviceEntry := dh.getOnuDeviceEntry(false)
 	if deviceEntry == nil {
 		/* costum_me_map in python code seems always to be None,
 		   we omit that here first (declaration unclear) -> todo at Adapter specialization ...*/
 		/* also no 'clock' argument - usage open ...*/
 		/* and no alarm_db yet (oo.alarm_db)  */
-		deviceEntry = NewOnuDeviceEntry(ctx, dh.deviceID, dh.pOpenOnuAc.KVStoreHost,
+		deviceEntry = newOnuDeviceEntry(ctx, dh.deviceID, dh.pOpenOnuAc.KVStoreHost,
 			dh.pOpenOnuAc.KVStorePort, dh.pOpenOnuAc.KVStoreType,
 			dh, dh.coreProxy, dh.AdapterProxy,
 			dh.pOpenOnuAc.pSupportedFsms) //nil as FSM pointer would yield deviceEntry internal defaults ...
-		onuTechProfProc := NewOnuUniTechProf(ctx, dh.deviceID, dh)
+		onuTechProfProc := newOnuUniTechProf(ctx, dh.deviceID, dh)
 		//error treatment possible //TODO!!!
-		dh.SetOnuDeviceEntry(deviceEntry, onuTechProfProc)
+		dh.setOnuDeviceEntry(deviceEntry, onuTechProfProc)
 		// fire deviceEntry ready event to spread to possibly waiting processing
 		dh.deviceEntrySet <- true
 		logger.Infow("onuDeviceEntry-added", log.Fields{"device-id": dh.deviceID})
@@ -942,7 +942,7 @@
 }
 
 // doStateInit provides the device update to the core
-func (dh *DeviceHandler) createInterface(onuind *oop.OnuIndication) error {
+func (dh *deviceHandler) createInterface(onuind *oop.OnuIndication) error {
 	logger.Debugw("create_interface-started", log.Fields{"OnuId": onuind.GetOnuId(),
 		"OnuIntfId": onuind.GetIntfId(), "OnuSerialNumber": onuind.GetSerialNumber()})
 
@@ -972,9 +972,9 @@
 			}
 	*/
 
-	pDevEntry := dh.GetOnuDeviceEntry(true)
+	pDevEntry := dh.getOnuDeviceEntry(true)
 	if pDevEntry != nil {
-		if err := pDevEntry.Start(context.TODO()); err != nil {
+		if err := pDevEntry.start(context.TODO()); err != nil {
 			return err
 		}
 	} else {
@@ -994,10 +994,10 @@
 
 	/* this might be a good time for Omci Verify message?  */
 	verifyExec := make(chan bool)
-	omciVerify := NewOmciTestRequest(context.TODO(),
+	omciVerify := newOmciTestRequest(context.TODO(),
 		dh.device.Id, pDevEntry.PDevOmciCC,
 		true, true) //eclusive and allowFailure (anyway not yet checked)
-	omciVerify.PerformOmciTest(context.TODO(), verifyExec)
+	omciVerify.performOmciTest(context.TODO(), verifyExec)
 
 	/* 	give the handler some time here to wait for the OMCi verification result
 	after Timeout start and try MibUpload FSM anyway
@@ -1126,12 +1126,12 @@
 	return nil
 }
 
-func (dh *DeviceHandler) updateInterface(onuind *oop.OnuIndication) error {
+func (dh *deviceHandler) updateInterface(onuind *oop.OnuIndication) error {
 	//state checking to prevent unneeded processing (eg. on ONU 'unreachable' and 'down')
 	if dh.deviceReason != "stopping-openomci" {
 		logger.Debugw("updateInterface-started - stopping-device", log.Fields{"device-id": dh.deviceID})
 		//stop all running SM processing - make use of the DH-state as mirrored in the deviceReason
-		pDevEntry := dh.GetOnuDeviceEntry(false)
+		pDevEntry := dh.getOnuDeviceEntry(false)
 		if pDevEntry == nil {
 			logger.Errorw("No valid OnuDevice -aborting", log.Fields{"device-id": dh.deviceID})
 			return errors.New("no valid OnuDevice")
@@ -1187,7 +1187,7 @@
 		//  assumption there is obviously, that the system may continue with some 'after "mib-download-done" state'
 
 		//stop/remove(?) the device entry
-		_ = pDevEntry.Stop(context.TODO()) //maybe some more sophisticated context treatment should be used here?
+		_ = pDevEntry.stop(context.TODO()) //maybe some more sophisticated context treatment should be used here?
 
 		//TODO!!! remove existing traffic profiles
 		/* from py code, if TP's exist, remove them - not yet implemented
@@ -1224,7 +1224,7 @@
 	return nil
 }
 
-func (dh *DeviceHandler) processMibDatabaseSyncEvent(devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) processMibDatabaseSyncEvent(devEvent OnuDeviceEvent) {
 	logger.Debugw("MibInSync event received", log.Fields{"device-id": dh.deviceID})
 	if !dh.reconciling {
 		//initiate DevStateUpdate
@@ -1243,22 +1243,22 @@
 	dh.deviceReason = "discovery-mibsync-complete"
 
 	i := uint8(0) //UNI Port limit: see MaxUnisPerOnu (by now 16) (OMCI supports max 255 p.b.)
-	pDevEntry := dh.GetOnuDeviceEntry(false)
-	if unigInstKeys := pDevEntry.pOnuDB.GetSortedInstKeys(me.UniGClassID); len(unigInstKeys) > 0 {
+	pDevEntry := dh.getOnuDeviceEntry(false)
+	if unigInstKeys := pDevEntry.pOnuDB.getSortedInstKeys(me.UniGClassID); len(unigInstKeys) > 0 {
 		for _, mgmtEntityID := range unigInstKeys {
 			logger.Debugw("Add UNI port for stored UniG instance:", log.Fields{
 				"device-id": dh.deviceID, "UnigMe EntityID": mgmtEntityID})
-			dh.addUniPort(mgmtEntityID, i, UniPPTP)
+			dh.addUniPort(mgmtEntityID, i, uniPPTP)
 			i++
 		}
 	} else {
 		logger.Debugw("No UniG instances found", log.Fields{"device-id": dh.deviceID})
 	}
-	if veipInstKeys := pDevEntry.pOnuDB.GetSortedInstKeys(me.VirtualEthernetInterfacePointClassID); len(veipInstKeys) > 0 {
+	if veipInstKeys := pDevEntry.pOnuDB.getSortedInstKeys(me.VirtualEthernetInterfacePointClassID); len(veipInstKeys) > 0 {
 		for _, mgmtEntityID := range veipInstKeys {
 			logger.Debugw("Add VEIP acc. to stored VEIP instance:", log.Fields{
 				"device-id": dh.deviceID, "VEIP EntityID": mgmtEntityID})
-			dh.addUniPort(mgmtEntityID, i, UniVEIP)
+			dh.addUniPort(mgmtEntityID, i, uniVEIP)
 			i++
 		}
 	} else {
@@ -1314,7 +1314,7 @@
 	}
 }
 
-func (dh *DeviceHandler) processMibDownloadDoneEvent(devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) processMibDownloadDoneEvent(devEvent OnuDeviceEvent) {
 	logger.Debugw("MibDownloadDone event received", log.Fields{"device-id": dh.deviceID})
 	//initiate DevStateUpdate
 	if !dh.reconciling {
@@ -1347,12 +1347,12 @@
 	if dh.pUnlockStateFsm == nil {
 		dh.createUniLockFsm(false, UniUnlockStateDone)
 	} else { //UnlockStateFSM already init
-		dh.pUnlockStateFsm.SetSuccessEvent(UniUnlockStateDone)
+		dh.pUnlockStateFsm.setSuccessEvent(UniUnlockStateDone)
 		dh.runUniLockFsm(false)
 	}
 }
 
-func (dh *DeviceHandler) processUniUnlockStateDoneEvent(devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) processUniUnlockStateDoneEvent(devEvent OnuDeviceEvent) {
 	go dh.enableUniPortStateUpdate() //cmp python yield self.enable_ports()
 
 	if !dh.reconciling {
@@ -1362,12 +1362,12 @@
 	} else {
 		logger.Debugw("reconciling - don't notify core that onu went to active but trigger tech profile config",
 			log.Fields{"device-id": dh.deviceID})
-		go dh.ReconcileDeviceTechProf()
+		go dh.reconcileDeviceTechProf()
 		//TODO: further actions e.g. restore flows, metrics, ...
 	}
 }
 
-func (dh *DeviceHandler) processOmciAniConfigDoneEvent(devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) processOmciAniConfigDoneEvent(devEvent OnuDeviceEvent) {
 	logger.Debugw("OmciAniConfigDone event received", log.Fields{"device-id": dh.deviceID})
 	// attention: the device reason update is done based on ONU-UNI-Port related activity
 	//  - which may cause some inconsistency
@@ -1391,7 +1391,7 @@
 	}
 }
 
-func (dh *DeviceHandler) processOmciVlanFilterDoneEvent(devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) processOmciVlanFilterDoneEvent(devEvent OnuDeviceEvent) {
 	logger.Debugw("OmciVlanFilterDone event received",
 		log.Fields{"device-id": dh.deviceID})
 	// attention: the device reason update is done based on ONU-UNI-Port related activity
@@ -1413,8 +1413,8 @@
 	}
 }
 
-//DeviceProcStatusUpdate evaluates possible processing events and initiates according next activities
-func (dh *DeviceHandler) DeviceProcStatusUpdate(devEvent OnuDeviceEvent) {
+//deviceProcStatusUpdate evaluates possible processing events and initiates according next activities
+func (dh *deviceHandler) deviceProcStatusUpdate(devEvent OnuDeviceEvent) {
 	switch devEvent {
 	case MibDatabaseSync:
 		{
@@ -1447,15 +1447,15 @@
 	} //switch
 }
 
-func (dh *DeviceHandler) addUniPort(aUniInstNo uint16, aUniID uint8, aPortType UniPortType) {
+func (dh *deviceHandler) addUniPort(aUniInstNo uint16, aUniID uint8, aPortType uniPortType) {
 	// parameters are IntfId, OnuId, uniId
-	uniNo := MkUniPortNum(dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(),
+	uniNo := mkUniPortNum(dh.pOnuIndication.GetIntfId(), dh.pOnuIndication.GetOnuId(),
 		uint32(aUniID))
 	if _, present := dh.uniEntityMap[uniNo]; present {
 		logger.Warnw("onuUniPort-add: Port already exists", log.Fields{"for InstanceId": aUniInstNo})
 	} else {
 		//with arguments aUniID, a_portNo, aPortType
-		pUniPort := NewOnuUniPort(aUniID, uniNo, aUniInstNo, aPortType)
+		pUniPort := newOnuUniPort(aUniID, uniNo, aUniInstNo, aPortType)
 		if pUniPort == nil {
 			logger.Warnw("onuUniPort-add: Could not create Port", log.Fields{"for InstanceId": aUniInstNo})
 		} else {
@@ -1463,7 +1463,7 @@
 			dh.uniEntityMap[uniNo] = pUniPort
 			if !dh.reconciling {
 				// create announce the UniPort to the core as VOLTHA Port object
-				if err := pUniPort.CreateVolthaPort(dh); err == nil {
+				if err := pUniPort.createVolthaPort(dh); err == nil {
 					logger.Infow("onuUniPort-added", log.Fields{"for PortNo": uniNo})
 				} //error logging already within UniPort method
 			} else {
@@ -1474,7 +1474,7 @@
 }
 
 // enableUniPortStateUpdate enables UniPortState and update core port state accordingly
-func (dh *DeviceHandler) enableUniPortStateUpdate() {
+func (dh *deviceHandler) enableUniPortStateUpdate() {
 	//  py code was updated 2003xx to activate the real ONU UNI ports per OMCI (VEIP or PPTP)
 	//    but towards core only the first port active state is signaled
 	//    with following remark:
@@ -1485,9 +1485,9 @@
 
 	for uniNo, uniPort := range dh.uniEntityMap {
 		// only if this port is validated for operState transfer
-		if (1<<uniPort.uniID)&ActiveUniPortStateUpdateMask == (1 << uniPort.uniID) {
+		if (1<<uniPort.uniID)&activeUniPortStateUpdateMask == (1 << uniPort.uniID) {
 			logger.Infow("onuUniPort-forced-OperState-ACTIVE", log.Fields{"for PortNo": uniNo})
-			uniPort.SetOperState(vc.OperStatus_ACTIVE)
+			uniPort.setOperState(vc.OperStatus_ACTIVE)
 			if !dh.reconciling {
 				//maybe also use getter functions on uniPort - perhaps later ...
 				go dh.coreProxy.PortStateUpdate(context.TODO(), dh.deviceID, voltha.Port_ETHERNET_UNI, uniPort.portNo, uniPort.operState)
@@ -1499,14 +1499,14 @@
 }
 
 // Disable UniPortState and update core port state accordingly
-func (dh *DeviceHandler) disableUniPortStateUpdate() {
+func (dh *deviceHandler) disableUniPortStateUpdate() {
 	// compare enableUniPortStateUpdate() above
 	//   -> use current restriction to operate only on first UNI port as inherited from actual Py code
 	for uniNo, uniPort := range dh.uniEntityMap {
 		// only if this port is validated for operState transfer
-		if (1<<uniPort.uniID)&ActiveUniPortStateUpdateMask == (1 << uniPort.uniID) {
+		if (1<<uniPort.uniID)&activeUniPortStateUpdateMask == (1 << uniPort.uniID) {
 			logger.Infow("onuUniPort-forced-OperState-UNKNOWN", log.Fields{"for PortNo": uniNo})
-			uniPort.SetOperState(vc.OperStatus_UNKNOWN)
+			uniPort.setOperState(vc.OperStatus_UNKNOWN)
 			//maybe also use getter functions on uniPort - perhaps later ...
 			go dh.coreProxy.PortStateUpdate(context.TODO(), dh.deviceID, voltha.Port_ETHERNET_UNI, uniPort.portNo, uniPort.operState)
 		}
@@ -1515,7 +1515,7 @@
 
 // ONU_Active/Inactive announcement on system KAFKA bus
 // tried to re-use procedure of oltUpDownIndication from openolt_eventmgr.go with used values from Py code
-func (dh *DeviceHandler) sendOnuOperStateEvent(aOperState vc.OperStatus_Types, aDeviceID string, raisedTs int64) {
+func (dh *deviceHandler) sendOnuOperStateEvent(aOperState vc.OperStatus_Types, aDeviceID string, raisedTs int64) {
 	var de voltha.DeviceEvent
 	eventContext := make(map[string]string)
 	//Populating event context
@@ -1558,7 +1558,7 @@
 }
 
 // createUniLockFsm initializes and runs the UniLock FSM to transfer the OMCI related commands for port lock/unlock
-func (dh *DeviceHandler) createUniLockFsm(aAdminState bool, devEvent OnuDeviceEvent) {
+func (dh *deviceHandler) createUniLockFsm(aAdminState bool, devEvent OnuDeviceEvent) {
 	chLSFsm := make(chan Message, 2048)
 	var sFsmName string
 	if aAdminState {
@@ -1569,12 +1569,12 @@
 		sFsmName = "UnLockStateFSM"
 	}
 
-	pDevEntry := dh.GetOnuDeviceEntry(true)
+	pDevEntry := dh.getOnuDeviceEntry(true)
 	if pDevEntry == nil {
 		logger.Errorw("No valid OnuDevice -aborting", log.Fields{"device-id": dh.deviceID})
 		return
 	}
-	pLSFsm := NewLockStateFsm(pDevEntry.PDevOmciCC, aAdminState, devEvent,
+	pLSFsm := newLockStateFsm(pDevEntry.PDevOmciCC, aAdminState, devEvent,
 		sFsmName, dh.deviceID, chLSFsm)
 	if pLSFsm != nil {
 		if aAdminState {
@@ -1589,7 +1589,7 @@
 }
 
 // runUniLockFsm starts the UniLock FSM to transfer the OMCI related commands for port lock/unlock
-func (dh *DeviceHandler) runUniLockFsm(aAdminState bool) {
+func (dh *deviceHandler) runUniLockFsm(aAdminState bool) {
 	/*  Uni Port lock/unlock procedure -
 	 ***** should run via 'adminDone' state and generate the argument requested event *****
 	 */
@@ -1630,8 +1630,8 @@
 	}
 }
 
-//SetBackend provides a DB backend for the specified path on the existing KV client
-func (dh *DeviceHandler) SetBackend(aBasePathKvStore string) *db.Backend {
+//setBackend provides a DB backend for the specified path on the existing KV client
+func (dh *deviceHandler) setBackend(aBasePathKvStore string) *db.Backend {
 	addr := dh.pOpenOnuAc.KVStoreHost + ":" + strconv.Itoa(dh.pOpenOnuAc.KVStorePort)
 	logger.Debugw("SetKVStoreBackend", log.Fields{"IpTarget": addr,
 		"BasePathKvStore": aBasePathKvStore, "device-id": dh.deviceID})
@@ -1645,7 +1645,7 @@
 
 	return kvbackend
 }
-func (dh *DeviceHandler) getFlowOfbFields(apFlowItem *ofp.OfpFlowStats, loMatchVlan *uint16,
+func (dh *deviceHandler) getFlowOfbFields(apFlowItem *ofp.OfpFlowStats, loMatchVlan *uint16,
 	loAddPcp *uint8, loIPProto *uint32) {
 
 	for _, field := range flow.GetOfbFields(apFlowItem) {
@@ -1721,7 +1721,7 @@
 	} //for all OfbFields
 }
 
-func (dh *DeviceHandler) getFlowActions(apFlowItem *ofp.OfpFlowStats, loSetPcp *uint8, loSetVlan *uint16) {
+func (dh *deviceHandler) getFlowActions(apFlowItem *ofp.OfpFlowStats, loSetPcp *uint8, loSetVlan *uint16) {
 	for _, action := range flow.GetActions(apFlowItem) {
 		switch action.Type {
 		/* not used:
@@ -1767,7 +1767,7 @@
 }
 
 //addFlowItemToUniPort parses the actual flow item to add it to the UniPort
-func (dh *DeviceHandler) addFlowItemToUniPort(apFlowItem *ofp.OfpFlowStats, apUniPort *OnuUniPort) error {
+func (dh *deviceHandler) addFlowItemToUniPort(apFlowItem *ofp.OfpFlowStats, apUniPort *onuUniPort) error {
 	var loSetVlan uint16 = uint16(of.OfpVlanId_OFPVID_NONE)      //noValidEntry
 	var loMatchVlan uint16 = uint16(of.OfpVlanId_OFPVID_PRESENT) //reserved VLANID entry
 	var loAddPcp, loSetPcp uint8
@@ -1834,11 +1834,11 @@
 }
 
 // createVlanFilterFsm initializes and runs the VlanFilter FSM to transfer OMCI related VLAN config
-func (dh *DeviceHandler) createVlanFilterFsm(apUniPort *OnuUniPort,
+func (dh *deviceHandler) createVlanFilterFsm(apUniPort *onuUniPort,
 	aTpID uint16, aMatchVlan uint16, aSetVlan uint16, aSetPcp uint8, aDevEvent OnuDeviceEvent) error {
 	chVlanFilterFsm := make(chan Message, 2048)
 
-	pDevEntry := dh.GetOnuDeviceEntry(true)
+	pDevEntry := dh.getOnuDeviceEntry(true)
 	if pDevEntry == nil {
 		logger.Errorw("No valid OnuDevice -aborting", log.Fields{"device-id": dh.deviceID})
 		return fmt.Errorf("no valid OnuDevice for device-id %x - aborting", dh.deviceID)
@@ -1879,7 +1879,7 @@
 }
 
 //verifyUniVlanConfigRequest checks on existence of flow configuration and starts it accordingly
-func (dh *DeviceHandler) verifyUniVlanConfigRequest(apUniPort *OnuUniPort) {
+func (dh *deviceHandler) verifyUniVlanConfigRequest(apUniPort *onuUniPort) {
 	//TODO!! verify and start pending flow configuration
 	//some pending config request my exist in case the UniVlanConfig FSM was already started - with internal data -
 	//but execution was set to 'on hold' as first the TechProfile config had to be applied
@@ -1910,7 +1910,7 @@
 
 //RemoveVlanFilterFsm deletes the stored pointer to the VlanConfigFsm
 // intention is to provide this method to be called from VlanConfigFsm itself, when resources (and methods!) are cleaned up
-func (dh *DeviceHandler) RemoveVlanFilterFsm(apUniPort *OnuUniPort) {
+func (dh *deviceHandler) RemoveVlanFilterFsm(apUniPort *onuUniPort) {
 	logger.Debugw("remove UniVlanConfigFsm StateMachine", log.Fields{
 		"device-id": dh.deviceID, "uniPort": apUniPort.portNo})
 	//save to do, even if entry dows not exist
diff --git a/internal/pkg/onuadaptercore/messageTypes.go b/internal/pkg/onuadaptercore/messageTypes.go
index 69b69d5..2f5bac6 100644
--- a/internal/pkg/onuadaptercore/messageTypes.go
+++ b/internal/pkg/onuadaptercore/messageTypes.go
@@ -22,13 +22,17 @@
 	"github.com/opencord/omci-lib-go"
 )
 
+// MessageType - Message Protocol Type
 type MessageType uint8
 
 const (
+	// TestMsg - Message type for non OMCI messages
 	TestMsg MessageType = iota
+	//OMCI - OMCI protocol type msg
 	OMCI
 )
 
+// String - Return the text representation of the message type based on integer
 func (m MessageType) String() string {
 	names := [...]string{
 		"TestMsg",
@@ -37,25 +41,33 @@
 	return names[m]
 }
 
+// Message - message type and data(OMCI)
 type Message struct {
 	Type MessageType
 	Data interface{}
 }
 
+//TestMessageType - message data for various events
 type TestMessageType uint8
 
 const (
+	// LoadMibTemplateOk - message data for getting mib template successfully
 	LoadMibTemplateOk TestMessageType = iota + 1
+	// LoadMibTemplateFailed - message data for failure for getting mib template
 	LoadMibTemplateFailed
+	// TimeOutOccurred - message data for timeout
 	TimeOutOccurred
+	// AbortMessageProcessing - message data for aborting running message
 	AbortMessageProcessing
 )
 
+//TestMessage - Struct to hold the message data
 //TODO: place holder to have a second interface variant - to be replaced by real variant later on
 type TestMessage struct {
 	TestMessageVal TestMessageType
 }
 
+//OmciMessage - OMCI protocol messages for managing and monitoring ONUs
 type OmciMessage struct {
 	//OnuSN   *openolt.SerialNumber
 	//OnuID   uint32
diff --git a/internal/pkg/onuadaptercore/mib_download.go b/internal/pkg/onuadaptercore/mib_download.go
index a2e485e..95a406d 100644
--- a/internal/pkg/onuadaptercore/mib_download.go
+++ b/internal/pkg/onuadaptercore/mib_download.go
@@ -40,7 +40,7 @@
 		logger.Debug("MibDownload FSM - defining the BridgeInit RxChannel")
 	}
 	// start go routine for processing of MibDownload messages
-	go onuDeviceEntry.ProcessMibDownloadMessages()
+	go onuDeviceEntry.processMibDownloadMessages()
 }
 
 func (onuDeviceEntry *OnuDeviceEntry) enterCreatingGalState(e *fsm.Event) {
@@ -103,7 +103,7 @@
 	}
 }
 
-func (onuDeviceEntry *OnuDeviceEntry) ProcessMibDownloadMessages( /*ctx context.Context*/ ) {
+func (onuDeviceEntry *OnuDeviceEntry) processMibDownloadMessages( /*ctx context.Context*/ ) {
 	logger.Debugw("Start MibDownload Msg processing", log.Fields{"for device-id": onuDeviceEntry.deviceID})
 loop:
 	for {
diff --git a/internal/pkg/onuadaptercore/mib_sync.go b/internal/pkg/onuadaptercore/mib_sync.go
index bf31079..f3e677a 100644
--- a/internal/pkg/onuadaptercore/mib_sync.go
+++ b/internal/pkg/onuadaptercore/mib_sync.go
@@ -66,8 +66,8 @@
 
 func (onuDeviceEntry *OnuDeviceEntry) enterStartingState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start processing MibSync-msgs in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
-	onuDeviceEntry.pOnuDB = NewOnuDeviceDB(context.TODO(), onuDeviceEntry)
-	go onuDeviceEntry.ProcessMibSyncMessages()
+	onuDeviceEntry.pOnuDB = newOnuDeviceDB(context.TODO(), onuDeviceEntry)
+	go onuDeviceEntry.processMibSyncMessages()
 }
 
 func (onuDeviceEntry *OnuDeviceEntry) enterResettingMibState(e *fsm.Event) {
@@ -82,7 +82,7 @@
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingVendorAndSerialState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start getting VendorId and SerialNumber in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
 	requestedAttributes := me.AttributeValueMap{"VendorId": "", "SerialNumber": 0}
-	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.OnuGClassID, OnugMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
+	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.OnuGClassID, onugMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
@@ -91,7 +91,7 @@
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingEquipmentIDState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start getting EquipmentId in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
 	requestedAttributes := me.AttributeValueMap{"EquipmentId": ""}
-	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.Onu2GClassID, Onu2gMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
+	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.Onu2GClassID, onu2gMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
@@ -100,7 +100,7 @@
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingFirstSwVersionState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start getting IsActive and Version of first SW-image in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
 	requestedAttributes := me.AttributeValueMap{"IsActive": 0, "Version": ""}
-	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.SoftwareImageClassID, FirstSwImageMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
+	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.SoftwareImageClassID, firstSwImageMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
@@ -109,7 +109,7 @@
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingSecondSwVersionState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start getting IsActive and Version of second SW-image in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
 	requestedAttributes := me.AttributeValueMap{"IsActive": 0, "Version": ""}
-	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.SoftwareImageClassID, SecondSwImageMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
+	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.SoftwareImageClassID, secondSwImageMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
@@ -118,7 +118,7 @@
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingMacAddressState(e *fsm.Event) {
 	logger.Debugw("MibSync FSM", log.Fields{"Start getting MacAddress in State": e.FSM.Current(), "device-id": onuDeviceEntry.deviceID})
 	requestedAttributes := me.AttributeValueMap{"MacAddress": ""}
-	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.IpHostConfigDataClassID, IPHostConfigDataMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
+	meInstance := onuDeviceEntry.PDevOmciCC.sendGetMe(context.TODO(), me.IpHostConfigDataClassID, ipHostConfigDataMeID, requestedAttributes, ConstDefaultOmciTimeout, true)
 	//accept also nil as (error) return value for writing to LastTx
 	//  - this avoids misinterpretation of new received OMCI messages
 	onuDeviceEntry.PDevOmciCC.pLastTxMeInstance = meInstance
@@ -126,7 +126,7 @@
 
 func (onuDeviceEntry *OnuDeviceEntry) enterGettingMibTemplate(e *fsm.Event) {
 
-	for i := FirstSwImageMeID; i <= SecondSwImageMeID; i++ {
+	for i := firstSwImageMeID; i <= secondSwImageMeID; i++ {
 		if onuDeviceEntry.swImages[i].isActive > 0 {
 			onuDeviceEntry.activeSwVersion = onuDeviceEntry.swImages[i].version
 		}
@@ -156,7 +156,7 @@
 					if uint16ValidNumber, err := strconv.ParseUint(fistLevelKey, 10, 16); err == nil {
 						meClassID := me.ClassID(uint16ValidNumber)
 						logger.Debugw("MibSync FSM - fistLevelKey is a number in uint16-range", log.Fields{"uint16ValidNumber": uint16ValidNumber})
-						if IsSupportedClassID(meClassID) {
+						if isSupportedClassID(meClassID) {
 							logger.Debugw("MibSync FSM - fistLevelKey is a supported classID", log.Fields{"meClassID": meClassID})
 							secondLevelMap := firstLevelValue.(map[string]interface{})
 							for secondLevelKey, secondLevelValue := range secondLevelMap {
@@ -188,7 +188,7 @@
 	}
 	if meStoredFromTemplate {
 		logger.Debug("MibSync FSM - valid MEs stored from template")
-		onuDeviceEntry.pOnuDB.LogMeDb()
+		onuDeviceEntry.pOnuDB.logMeDb()
 		fsmMsg = LoadMibTemplateOk
 	} else {
 		logger.Debug("MibSync FSM - no valid MEs stored from template - perform MIB-upload!")
@@ -234,7 +234,7 @@
 	logger.Debug("function not implemented yet")
 }
 
-func (onuDeviceEntry *OnuDeviceEntry) ProcessMibSyncMessages( /*ctx context.Context*/ ) {
+func (onuDeviceEntry *OnuDeviceEntry) processMibSyncMessages( /*ctx context.Context*/ ) {
 	logger.Debugw("MibSync Msg", log.Fields{"Start routine to process OMCI-messages for device-id": onuDeviceEntry.deviceID})
 loop:
 	for {
@@ -353,8 +353,8 @@
 	if onuDeviceEntry.PDevOmciCC.uploadSequNo < onuDeviceEntry.PDevOmciCC.uploadNoOfCmds {
 		_ = onuDeviceEntry.PDevOmciCC.sendMibUploadNext(context.TODO(), ConstDefaultOmciTimeout, true)
 	} else {
-		onuDeviceEntry.pOnuDB.LogMeDb()
-		err := onuDeviceEntry.CreateAndPersistMibTemplate()
+		onuDeviceEntry.pOnuDB.logMeDb()
+		err := onuDeviceEntry.createAndPersistMibTemplate()
 		if err != nil {
 			logger.Errorw("MibSync - MibTemplate - Failed to create and persist the mib template", log.Fields{"error": err, "device-id": onuDeviceEntry.deviceID})
 		}
@@ -381,7 +381,7 @@
 					case "OnuG":
 						onuDeviceEntry.vendorID = fmt.Sprintf("%s", meAttributes["VendorId"])
 						snBytes, _ := me.InterfaceToOctets(meAttributes["SerialNumber"])
-						if OnugSerialNumberLen == len(snBytes) {
+						if onugSerialNumberLen == len(snBytes) {
 							snVendorPart := fmt.Sprintf("%s", snBytes[:4])
 							snNumberPart := hex.EncodeToString(snBytes[4:])
 							onuDeviceEntry.serialNumber = snVendorPart + snNumberPart
@@ -401,7 +401,7 @@
 						_ = onuDeviceEntry.pMibUploadFsm.pFsm.Event(ulEvGetFirstSwVersion)
 						return
 					case "SoftwareImage":
-						if entityID <= SecondSwImageMeID {
+						if entityID <= secondSwImageMeID {
 							onuDeviceEntry.swImages[entityID].version = fmt.Sprintf("%s", meAttributes["Version"])
 							onuDeviceEntry.swImages[entityID].isActive = meAttributes["IsActive"].(uint8)
 							logger.Debugw("MibSync FSM - GetResponse Data for SoftwareImage - Version/IsActive",
@@ -412,16 +412,16 @@
 							logger.Errorw("MibSync FSM - Failed to GetResponse Data for SoftwareImage", log.Fields{"deviceId": onuDeviceEntry.deviceID})
 
 						}
-						if FirstSwImageMeID == entityID {
+						if firstSwImageMeID == entityID {
 							_ = onuDeviceEntry.pMibUploadFsm.pFsm.Event(ulEvGetSecondSwVersion)
 							return
-						} else if SecondSwImageMeID == entityID {
+						} else if secondSwImageMeID == entityID {
 							_ = onuDeviceEntry.pMibUploadFsm.pFsm.Event(ulEvGetMacAddress)
 							return
 						}
 					case "IpHostConfigData":
 						macBytes, _ := me.InterfaceToOctets(meAttributes["MacAddress"])
-						if OmciMacAddressLen == len(macBytes) {
+						if omciMacAddressLen == len(macBytes) {
 							onuDeviceEntry.macAddress = hex.EncodeToString(macBytes[:])
 							logger.Debugw("MibSync FSM - GetResponse Data for IpHostConfigData - MacAddress", log.Fields{"deviceId": onuDeviceEntry.deviceID,
 								"onuDeviceEntry.macAddress": onuDeviceEntry.macAddress})
@@ -468,7 +468,7 @@
 	}
 }
 
-func IsSupportedClassID(meClassID me.ClassID) bool {
+func isSupportedClassID(meClassID me.ClassID) bool {
 	for _, v := range supportedClassIds {
 		if v == meClassID {
 			return true
@@ -477,15 +477,15 @@
 	return false
 }
 
-func (onuDeviceEntry *OnuDeviceEntry) MibDbVolatileDict() error {
+func (onuDeviceEntry *OnuDeviceEntry) mibDbVolatileDict() error {
 	logger.Debug("MibVolatileDict- running from default Entry code")
 	return errors.New("not_implemented")
 }
 
-// CreateAndPersistMibTemplate method creates a mib template for the device id when operator enables the ONU device for the first time.
+// createAndPersistMibTemplate method creates a mib template for the device id when operator enables the ONU device for the first time.
 // We are creating a placeholder for "SerialNumber" for ME Class ID 6 and 256 and "MacAddress" for ME Class ID 134 in the template
 // and then storing the template into etcd "service/voltha/omci_mibs/templates/verdor_id/equipment_id/software_version" path.
-func (onuDeviceEntry *OnuDeviceEntry) CreateAndPersistMibTemplate() error {
+func (onuDeviceEntry *OnuDeviceEntry) createAndPersistMibTemplate() error {
 	path := fmt.Sprintf(cSuffixMibTemplateKvStore, onuDeviceEntry.vendorID, onuDeviceEntry.equipmentID, onuDeviceEntry.activeSwVersion)
 	logger.Debugw("MibSync - MibTemplate - key name", log.Fields{"path": path})
 	currentTime := time.Now()
diff --git a/internal/pkg/onuadaptercore/omci_ani_config.go b/internal/pkg/onuadaptercore/omci_ani_config.go
index 105dd7b..0103788 100644
--- a/internal/pkg/onuadaptercore/omci_ani_config.go
+++ b/internal/pkg/onuadaptercore/omci_ani_config.go
@@ -75,12 +75,12 @@
 	pbitString  string
 }
 
-//UniPonAniConfigFsm defines the structure for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
-type UniPonAniConfigFsm struct {
-	pOmciCC                  *OmciCC
-	pOnuUniPort              *OnuUniPort
-	pUniTechProf             *OnuUniTechProf
-	pOnuDB                   *OnuDeviceDB
+//uniPonAniConfigFsm defines the structure for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
+type uniPonAniConfigFsm struct {
+	pOmciCC                  *omciCC
+	pOnuUniPort              *onuUniPort
+	pUniTechProf             *onuUniTechProf
+	pOnuDB                   *onuDeviceDB
 	techProfileID            uint16
 	requestEvent             OnuDeviceEvent
 	omciMIdsResponseReceived chan bool //separate channel needed for checking multiInstance OMCI message responses
@@ -96,11 +96,11 @@
 	gemPortAttribsSlice      []ponAniGemPortAttribs
 }
 
-//NewUniPonAniConfigFsm is the 'constructor' for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
-func NewUniPonAniConfigFsm(apDevOmciCC *OmciCC, apUniPort *OnuUniPort, apUniTechProf *OnuUniTechProf,
-	apOnuDB *OnuDeviceDB, aTechProfileID uint16, aRequestEvent OnuDeviceEvent, aName string,
-	aDeviceID string, aCommChannel chan Message) *UniPonAniConfigFsm {
-	instFsm := &UniPonAniConfigFsm{
+//newUniPonAniConfigFsm is the 'constructor' for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
+func newUniPonAniConfigFsm(apDevOmciCC *omciCC, apUniPort *onuUniPort, apUniTechProf *onuUniTechProf,
+	apOnuDB *onuDeviceDB, aTechProfileID uint16, aRequestEvent OnuDeviceEvent, aName string,
+	aDeviceID string, aCommChannel chan Message) *uniPonAniConfigFsm {
+	instFsm := &uniPonAniConfigFsm{
 		pOmciCC:            apDevOmciCC,
 		pOnuUniPort:        apUniPort,
 		pUniTechProf:       apUniTechProf,
@@ -112,7 +112,7 @@
 	}
 	instFsm.pAdaptFsm = NewAdapterFsm(aName, aDeviceID, aCommChannel)
 	if instFsm.pAdaptFsm == nil {
-		logger.Errorw("UniPonAniConfigFsm's AdapterFsm could not be instantiated!!", log.Fields{
+		logger.Errorw("uniPonAniConfigFsm's AdapterFsm could not be instantiated!!", log.Fields{
 			"device-id": aDeviceID})
 		return nil
 	}
@@ -165,23 +165,23 @@
 		},
 	)
 	if instFsm.pAdaptFsm.pFsm == nil {
-		logger.Errorw("UniPonAniConfigFsm's Base FSM could not be instantiated!!", log.Fields{
+		logger.Errorw("uniPonAniConfigFsm's Base FSM could not be instantiated!!", log.Fields{
 			"device-id": aDeviceID})
 		return nil
 	}
 
-	logger.Infow("UniPonAniConfigFsm created", log.Fields{"device-id": aDeviceID})
+	logger.Infow("uniPonAniConfigFsm created", log.Fields{"device-id": aDeviceID})
 	return instFsm
 }
 
-//SetFsmCompleteChannel sets the requested channel and channel result for transfer on success
-func (oFsm *UniPonAniConfigFsm) SetFsmCompleteChannel(aChSuccess chan<- uint8, aProcStep uint8) {
+//setFsmCompleteChannel sets the requested channel and channel result for transfer on success
+func (oFsm *uniPonAniConfigFsm) setFsmCompleteChannel(aChSuccess chan<- uint8, aProcStep uint8) {
 	oFsm.chSuccess = aChSuccess
 	oFsm.procStep = aProcStep
 	oFsm.chanSet = true
 }
 
-func (oFsm *UniPonAniConfigFsm) prepareAndEnterConfigState(aPAFsm *AdapterFsm) {
+func (oFsm *uniPonAniConfigFsm) prepareAndEnterConfigState(aPAFsm *AdapterFsm) {
 	if aPAFsm != nil && aPAFsm.pFsm != nil {
 		//stick to pythonAdapter numbering scheme
 		//index 0 in naming refers to possible usage of multiple instances (later)
@@ -195,7 +195,7 @@
 		// so this approach would search the (sorted) upstream PrioQueue list and use the T-Cont (if available) from highest Bytes
 		// or sndHighByte of relatedPort Attribute (T-Cont Reference) and in case of multiple TConts find the next free TContIndex
 		// that way from PrioQueue.relatedPort list
-		if tcontInstKeys := oFsm.pOnuDB.GetSortedInstKeys(me.TContClassID); len(tcontInstKeys) > 0 {
+		if tcontInstKeys := oFsm.pOnuDB.getSortedInstKeys(me.TContClassID); len(tcontInstKeys) > 0 {
 			oFsm.tcont0ID = tcontInstKeys[0]
 			logger.Debugw("Used TcontId:", log.Fields{"TcontId": strconv.FormatInt(int64(oFsm.tcont0ID), 16),
 				"device-id": oFsm.pAdaptFsm.deviceID})
@@ -208,7 +208,7 @@
 		for _, gemEntry := range (*(oFsm.pUniTechProf.mapPonAniConfig[oFsm.pOnuUniPort.uniID]))[0].mapGemPortParams {
 			//collect all GemConfigData in a separate Fsm related slice (needed also to avoid mix-up with unsorted mapPonAniConfig)
 
-			if queueInstKeys := oFsm.pOnuDB.GetSortedInstKeys(me.PriorityQueueClassID); len(queueInstKeys) > 0 {
+			if queueInstKeys := oFsm.pOnuDB.getSortedInstKeys(me.PriorityQueueClassID); len(queueInstKeys) > 0 {
 
 				loGemPortAttribs.gemPortID = gemEntry.gemPortID
 				// MibDb usage: upstream PrioQueue.RelatedPort = xxxxyyyy with xxxx=TCont.Entity(incl. slot) and yyyy=prio
@@ -229,7 +229,7 @@
 					if meAttributes := oFsm.pOnuDB.GetMe(me.PriorityQueueClassID, mgmtEntityID); meAttributes != nil {
 						returnVal := meAttributes["RelatedPort"]
 						if returnVal != nil {
-							if relatedPort, err := oFsm.pOnuDB.GetUint32Attrib(returnVal); err == nil {
+							if relatedPort, err := oFsm.pOnuDB.getUint32Attrib(returnVal); err == nil {
 								if relatedPort == usQrelPortMask {
 									loGemPortAttribs.upQueueID = mgmtEntityID
 									logger.Debugw("UpQueue for GemPort found:", log.Fields{"gemPortID": loGemPortAttribs.gemPortID,
@@ -277,13 +277,13 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) enterConfigStartingState(e *fsm.Event) {
+func (oFsm *uniPonAniConfigFsm) enterConfigStartingState(e *fsm.Event) {
 	logger.Debugw("UniPonAniConfigFsm start", log.Fields{"in state": e.FSM.Current(),
 		"device-id": oFsm.pAdaptFsm.deviceID})
 	// in case the used channel is not yet defined (can be re-used after restarts)
 	if oFsm.omciMIdsResponseReceived == nil {
 		oFsm.omciMIdsResponseReceived = make(chan bool)
-		logger.Debug("UniPonAniConfigFsm - OMCI multiInstance RxChannel defined")
+		logger.Debug("uniPonAniConfigFsm - OMCI multiInstance RxChannel defined")
 	} else {
 		// as we may 're-use' this instance of FSM and the connected channel
 		// make sure there is no 'lingering' request in the already existing channel:
@@ -307,8 +307,8 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) enterCreatingDot1PMapper(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm Tx Create::Dot1PMapper", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterCreatingDot1PMapper(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm Tx Create::Dot1PMapper", log.Fields{
 		"EntitytId": strconv.FormatInt(int64(oFsm.mapperSP0ID), 16),
 		"in state":  e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	meInstance := oFsm.pOmciCC.sendCreateDot1PMapper(context.TODO(), ConstDefaultOmciTimeout, true,
@@ -318,8 +318,8 @@
 	oFsm.pOmciCC.pLastTxMeInstance = meInstance
 }
 
-func (oFsm *UniPonAniConfigFsm) enterCreatingMBPCD(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm Tx Create::MBPCD", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterCreatingMBPCD(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm Tx Create::MBPCD", log.Fields{
 		"EntitytId": strconv.FormatInt(int64(oFsm.macBPCD0ID), 16),
 		"TPPtr":     strconv.FormatInt(int64(oFsm.mapperSP0ID), 16),
 		"in state":  e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
@@ -341,8 +341,8 @@
 
 }
 
-func (oFsm *UniPonAniConfigFsm) enterSettingTconts(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm Tx Set::Tcont", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterSettingTconts(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm Tx Set::Tcont", log.Fields{
 		"EntitytId": strconv.FormatInt(int64(oFsm.tcont0ID), 16),
 		"AllocId":   strconv.FormatInt(int64(oFsm.alloc0ID), 16),
 		"in state":  e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
@@ -359,29 +359,29 @@
 	oFsm.pOmciCC.pLastTxMeInstance = meInstance
 }
 
-func (oFsm *UniPonAniConfigFsm) enterCreatingGemNCTPs(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm - start creating GemNWCtp loop", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterCreatingGemNCTPs(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm - start creating GemNWCtp loop", log.Fields{
 		"in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	go oFsm.performCreatingGemNCTPs()
 }
 
-func (oFsm *UniPonAniConfigFsm) enterCreatingGemIWs(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm - start creating GemIwTP loop", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterCreatingGemIWs(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm - start creating GemIwTP loop", log.Fields{
 		"in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	go oFsm.performCreatingGemIWs()
 }
 
-func (oFsm *UniPonAniConfigFsm) enterSettingPQs(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm - start setting PrioQueue loop", log.Fields{
+func (oFsm *uniPonAniConfigFsm) enterSettingPQs(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm - start setting PrioQueue loop", log.Fields{
 		"in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	go oFsm.performSettingPQs()
 }
 
-func (oFsm *UniPonAniConfigFsm) enterSettingDot1PMapper(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm Tx Set::.1pMapper with all PBits set", log.Fields{"EntitytId": 0x8042, /*cmp above*/
+func (oFsm *uniPonAniConfigFsm) enterSettingDot1PMapper(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm Tx Set::.1pMapper with all PBits set", log.Fields{"EntitytId": 0x8042, /*cmp above*/
 		"toGemIw": 1024 /* cmp above */, "in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 
-	logger.Debugw("UniPonAniConfigFsm Tx Set::1pMapper", log.Fields{
+	logger.Debugw("uniPonAniConfigFsm Tx Set::1pMapper", log.Fields{
 		"EntitytId": strconv.FormatInt(int64(oFsm.mapperSP0ID), 16),
 		"in state":  e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 
@@ -400,13 +400,13 @@
 					if loPrioGemPortArray[i] == 0 {
 						loPrioGemPortArray[i] = gemPortAttribs.gemPortID //gemPortId=EntityID and unique
 					} else {
-						logger.Warnw("UniPonAniConfigFsm PrioString not unique", log.Fields{
+						logger.Warnw("uniPonAniConfigFsm PrioString not unique", log.Fields{
 							"device-id": oFsm.pAdaptFsm.deviceID, "IgnoredGemPort": gemPortAttribs.gemPortID,
 							"SetGemPort": loPrioGemPortArray[i]})
 					}
 				}
 			} else {
-				logger.Warnw("UniPonAniConfigFsm PrioString evaluation error", log.Fields{
+				logger.Warnw("uniPonAniConfigFsm PrioString evaluation error", log.Fields{
 					"device-id": oFsm.pAdaptFsm.deviceID, "GemPort": gemPortAttribs.gemPortID,
 					"prioString": gemPortAttribs.pbitString, "position": i})
 			}
@@ -447,7 +447,7 @@
 	oFsm.pOmciCC.pLastTxMeInstance = meInstance
 }
 
-func (oFsm *UniPonAniConfigFsm) enterAniConfigDone(e *fsm.Event) {
+func (oFsm *uniPonAniConfigFsm) enterAniConfigDone(e *fsm.Event) {
 
 	oFsm.aniConfigCompleted = true
 
@@ -463,8 +463,8 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) enterResettingState(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm resetting", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
+func (oFsm *uniPonAniConfigFsm) enterResettingState(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm resetting", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
 
 	pConfigAniStateAFsm := oFsm.pAdaptFsm
 	if pConfigAniStateAFsm != nil {
@@ -486,14 +486,14 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) enterDisabledState(e *fsm.Event) {
-	logger.Debugw("UniPonAniConfigFsm enters disabled state", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
+func (oFsm *uniPonAniConfigFsm) enterDisabledState(e *fsm.Event) {
+	logger.Debugw("uniPonAniConfigFsm enters disabled state", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
 
 	if oFsm.aniConfigCompleted {
-		logger.Debugw("UniPonAniConfigFsm send dh event notification", log.Fields{
+		logger.Debugw("uniPonAniConfigFsm send dh event notification", log.Fields{
 			"from_State": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 		//use DeviceHandler event notification directly
-		oFsm.pOmciCC.pBaseDeviceHandler.DeviceProcStatusUpdate(oFsm.requestEvent)
+		oFsm.pOmciCC.pBaseDeviceHandler.deviceProcStatusUpdate(oFsm.requestEvent)
 		oFsm.aniConfigCompleted = false
 	}
 	//store that the UNI related techProfile processing is done for the given Profile and Uni
@@ -503,7 +503,7 @@
 
 	if oFsm.chanSet {
 		// indicate processing done to the caller
-		logger.Debugw("UniPonAniConfigFsm processingDone on channel", log.Fields{
+		logger.Debugw("uniPonAniConfigFsm processingDone on channel", log.Fields{
 			"ProcessingStep": oFsm.procStep, "from_State": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 		oFsm.chSuccess <- oFsm.procStep
 		oFsm.chanSet = false //reset the internal channel state
@@ -511,8 +511,8 @@
 
 }
 
-func (oFsm *UniPonAniConfigFsm) processOmciAniMessages( /*ctx context.Context*/ ) {
-	logger.Debugw("Start UniPonAniConfigFsm Msg processing", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
+func (oFsm *uniPonAniConfigFsm) processOmciAniMessages( /*ctx context.Context*/ ) {
+	logger.Debugw("Start uniPonAniConfigFsm Msg processing", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
 loop:
 	for {
 		// case <-ctx.Done():
@@ -544,10 +544,10 @@
 		}
 
 	}
-	logger.Infow("End UniPonAniConfigFsm Msg processing", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
+	logger.Infow("End uniPonAniConfigFsm Msg processing", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
 }
 
-func (oFsm *UniPonAniConfigFsm) handleOmciAniConfigCreateResponseMessage(msg OmciMessage) {
+func (oFsm *uniPonAniConfigFsm) handleOmciAniConfigCreateResponseMessage(msg OmciMessage) {
 	msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeCreateResponse)
 	if msgLayer == nil {
 		logger.Error("Omci Msg layer could not be detected for CreateResponse")
@@ -585,7 +585,7 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) handleOmciAniConfigSetResponseMessage(msg OmciMessage) {
+func (oFsm *uniPonAniConfigFsm) handleOmciAniConfigSetResponseMessage(msg OmciMessage) {
 	msgLayer := (*msg.OmciPacket).Layer(omci.LayerTypeSetResponse)
 	if msgLayer == nil {
 		logger.Error("UniPonAniConfigFsm - Omci Msg layer could not be detected for SetResponse")
@@ -625,7 +625,7 @@
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) handleOmciAniConfigMessage(msg OmciMessage) {
+func (oFsm *uniPonAniConfigFsm) handleOmciAniConfigMessage(msg OmciMessage) {
 	logger.Debugw("Rx OMCI UniPonAniConfigFsm Msg", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID,
 		"msgType": msg.OmciMsg.MessageType})
 
@@ -642,16 +642,16 @@
 		} //SetResponseType
 	default:
 		{
-			logger.Errorw("UniPonAniConfigFsm - Rx OMCI unhandled MsgType", log.Fields{"omciMsgType": msg.OmciMsg.MessageType})
+			logger.Errorw("uniPonAniConfigFsm - Rx OMCI unhandled MsgType", log.Fields{"omciMsgType": msg.OmciMsg.MessageType})
 			return
 		}
 	}
 }
 
-func (oFsm *UniPonAniConfigFsm) performCreatingGemNCTPs() {
+func (oFsm *uniPonAniConfigFsm) performCreatingGemNCTPs() {
 	// for all GemPorts of this T-Cont as given by the size of set gemPortAttribsSlice
 	for gemIndex, gemPortAttribs := range oFsm.gemPortAttribsSlice {
-		logger.Debugw("UniPonAniConfigFsm Tx Create::GemNWCtp", log.Fields{
+		logger.Debugw("uniPonAniConfigFsm Tx Create::GemNWCtp", log.Fields{
 			"EntitytId": strconv.FormatInt(int64(gemPortAttribs.gemPortID), 16),
 			"TcontId":   strconv.FormatInt(int64(oFsm.tcont0ID), 16),
 			"device-id": oFsm.pAdaptFsm.deviceID})
@@ -688,10 +688,10 @@
 	_ = oFsm.pAdaptFsm.pFsm.Event(aniEvRxGemntcpsResp)
 }
 
-func (oFsm *UniPonAniConfigFsm) performCreatingGemIWs() {
+func (oFsm *uniPonAniConfigFsm) performCreatingGemIWs() {
 	// for all GemPorts of this T-Cont as given by the size of set gemPortAttribsSlice
 	for gemIndex, gemPortAttribs := range oFsm.gemPortAttribsSlice {
-		logger.Debugw("UniPonAniConfigFsm Tx Create::GemIwTp", log.Fields{
+		logger.Debugw("uniPonAniConfigFsm Tx Create::GemIwTp", log.Fields{
 			"EntitytId": strconv.FormatInt(int64(gemPortAttribs.gemPortID), 16),
 			"SPPtr":     strconv.FormatInt(int64(oFsm.mapperSP0ID), 16),
 			"device-id": oFsm.pAdaptFsm.deviceID})
@@ -726,7 +726,7 @@
 	_ = oFsm.pAdaptFsm.pFsm.Event(aniEvRxGemiwsResp)
 }
 
-func (oFsm *UniPonAniConfigFsm) performSettingPQs() {
+func (oFsm *uniPonAniConfigFsm) performSettingPQs() {
 	const cu16StrictPrioWeight uint16 = 0xFFFF
 	//find all upstream PrioQueues related to this T-Cont
 	loQueueMap := ordered_map.NewOrderedMap()
@@ -760,13 +760,13 @@
 		}
 		if (kv.Value).(uint16) == cu16StrictPrioWeight {
 			//StrictPrio indication
-			logger.Debugw("UniPonAniConfigFsm Tx Set::PrioQueue to StrictPrio", log.Fields{
+			logger.Debugw("uniPonAniConfigFsm Tx Set::PrioQueue to StrictPrio", log.Fields{
 				"EntitytId": strconv.FormatInt(int64(queueIndex), 16),
 				"device-id": oFsm.pAdaptFsm.deviceID})
 			meParams.Attributes["TrafficSchedulerPointer"] = 0 //ensure T-Cont defined StrictPrio scheduling
 		} else {
 			//WRR indication
-			logger.Debugw("UniPonAniConfigFsm Tx Set::PrioQueue to WRR", log.Fields{
+			logger.Debugw("uniPonAniConfigFsm Tx Set::PrioQueue to WRR", log.Fields{
 				"EntitytId": strconv.FormatInt(int64(queueIndex), 16),
 				"Weight":    kv.Value,
 				"device-id": oFsm.pAdaptFsm.deviceID})
@@ -800,7 +800,7 @@
 	_ = oFsm.pAdaptFsm.pFsm.Event(aniEvRxPrioqsResp)
 }
 
-func (oFsm *UniPonAniConfigFsm) waitforOmciResponse() error {
+func (oFsm *uniPonAniConfigFsm) waitforOmciResponse() error {
 	select {
 	// maybe be also some outside cancel (but no context modeled for the moment ...)
 	// case <-ctx.Done():
@@ -810,11 +810,11 @@
 		return errors.New("uniPonAniConfigFsm multi entity timeout")
 	case success := <-oFsm.omciMIdsResponseReceived:
 		if success {
-			logger.Debug("UniPonAniConfigFsm multi entity response received")
+			logger.Debug("uniPonAniConfigFsm multi entity response received")
 			return nil
 		}
 		// should not happen so far
-		logger.Warnw("UniPonAniConfigFsm multi entity response error", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
+		logger.Warnw("uniPonAniConfigFsm multi entity response error", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
 		return errors.New("uniPonAniConfigFsm multi entity responseError")
 	}
 }
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index 7efdc37..f49a370 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -44,6 +44,8 @@
 )
 
 // ### OMCI related definitions - retrieved from Python adapter code/trace ####
+
+//ConstDefaultOmciTimeout - Default OMCI Timeout
 const ConstDefaultOmciTimeout = 10 // ( 3 ?) Seconds
 
 const galEthernetEID = uint16(1)
@@ -58,16 +60,16 @@
 
 // ### OMCI related definitions - end
 
-//CallbackPairEntry to be used for OMCI send/receive correlation
-type CallbackPairEntry struct {
+//callbackPairEntry to be used for OMCI send/receive correlation
+type callbackPairEntry struct {
 	cbRespChannel chan Message
 	cbFunction    func(*omci.OMCI, *gp.Packet, chan Message) error
 }
 
-//CallbackPair to be used for ReceiveCallback init
-type CallbackPair struct {
+//callbackPair to be used for ReceiveCallback init
+type callbackPair struct {
 	cbKey   uint16
-	cbEntry CallbackPairEntry
+	cbEntry callbackPairEntry
 }
 
 type omciTransferStructure struct {
@@ -77,12 +79,12 @@
 	highPrio bool
 }
 
-//OmciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
-type OmciCC struct {
+//omciCC structure holds information needed for OMCI communication (to/from OLT Adapter)
+type omciCC struct {
 	enabled            bool
 	pOnuDeviceEntry    *OnuDeviceEntry
 	deviceID           string
-	pBaseDeviceHandler *DeviceHandler
+	pBaseDeviceHandler *deviceHandler
 	coreProxy          adapterif.CoreProxy
 	adapterProxy       adapterif.AdapterProxy
 	supportExtMsg      bool
@@ -103,17 +105,17 @@
 	mutexTxQueue      sync.Mutex
 	txQueue           *list.List
 	mutexRxSchedMap   sync.Mutex
-	rxSchedulerMap    map[uint16]CallbackPairEntry
+	rxSchedulerMap    map[uint16]callbackPairEntry
 	pLastTxMeInstance *me.ManagedEntity
 }
 
-//NewOmciCC constructor returns a new instance of a OmciCC
+//newOmciCC constructor returns a new instance of a OmciCC
 //mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
-func NewOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
-	deviceID string, deviceHandler *DeviceHandler,
-	coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *OmciCC {
+func newOmciCC(ctx context.Context, onuDeviceEntry *OnuDeviceEntry,
+	deviceID string, deviceHandler *deviceHandler,
+	coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy) *omciCC {
 	logger.Infow("init-omciCC", log.Fields{"device-id": deviceID})
-	var omciCC OmciCC
+	var omciCC omciCC
 	omciCC.enabled = false
 	omciCC.pOnuDeviceEntry = onuDeviceEntry
 	omciCC.deviceID = deviceID
@@ -132,13 +134,13 @@
 	omciCC.uploadNoOfCmds = 0
 
 	omciCC.txQueue = list.New()
-	omciCC.rxSchedulerMap = make(map[uint16]CallbackPairEntry)
+	omciCC.rxSchedulerMap = make(map[uint16]callbackPairEntry)
 
 	return &omciCC
 }
 
 // Rx handler for omci messages
-func (oo *OmciCC) ReceiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI) error {
+func (oo *omciCC) receiveOnuMessage(ctx context.Context, omciMsg *omci.OMCI) error {
 	logger.Debugw("rx-onu-autonomous-message", log.Fields{"omciMsgType": omciMsg.MessageType,
 		"payload": hex.EncodeToString(omciMsg.Payload)})
 	/*
@@ -189,7 +191,7 @@
 
 // Rx handler for onu messages
 //    e.g. would call ReceiveOnuMessage() in case of TID=0 or Action=test ...
-func (oo *OmciCC) ReceiveMessage(ctx context.Context, rxMsg []byte) error {
+func (oo *omciCC) receiveMessage(ctx context.Context, rxMsg []byte) error {
 	//logger.Debugw("cc-receive-omci-message", log.Fields{"RxOmciMessage-x2s": hex.EncodeToString(rxMsg)})
 	if len(rxMsg) >= 44 { // then it should normally include the BaseFormat trailer Len
 		// NOTE: autocorrection only valid for OmciBaseFormat, which is not specifically verified here!!!
@@ -227,7 +229,7 @@
 		// Not a response
 		logger.Debug("RxMsg is no Omci Response Message")
 		if omciMsg.TransactionID == 0 {
-			return oo.ReceiveOnuMessage(ctx, omciMsg)
+			return oo.receiveOnuMessage(ctx, omciMsg)
 		}
 		logger.Errorw("Unexpected TransCorrId != 0  not accepted for autonomous messages",
 			log.Fields{"msgType": omciMsg.MessageType, "payload": hex.EncodeToString(omciMsg.Payload)})
@@ -354,16 +356,16 @@
 	*/
 }
 
-func (oo *OmciCC) PublishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
+/*
+func (oo *omciCC) publishRxResponseFrame(ctx context.Context, txFrame []byte, rxFrame []byte) error {
 	return errors.New("publishRxResponseFrame unimplemented")
-	/*
-		def _publish_rx_frame(self, tx_frame, rx_frame):
-	*/
+		//def _publish_rx_frame(self, tx_frame, rx_frame):
 }
+*/
 
 //Queue the OMCI Frame for a transmit to the ONU via the proxy_channel
-func (oo *OmciCC) Send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
-	receiveCallbackPair CallbackPair) error {
+func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
+	receiveCallbackPair callbackPair) error {
 
 	logger.Debugw("register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
 	// it could be checked, if the callback keay is already registered - but simply overwrite may be acceptable ...
@@ -388,7 +390,7 @@
 }
 
 //Pull next tx request and send it
-func (oo *OmciCC) sendNextRequest(ctx context.Context) error {
+func (oo *omciCC) sendNextRequest(ctx context.Context) error {
 	//	return errors.New("sendNextRequest unimplemented")
 
 	// just try to get something transferred !!
@@ -481,7 +483,7 @@
 	return nil
 }
 
-func (oo *OmciCC) GetNextTid(highPriority bool) uint16 {
+func (oo *omciCC) getNextTid(highPriority bool) uint16 {
 	var next uint16
 	if highPriority {
 		oo.mutexTid.Lock()
@@ -535,7 +537,7 @@
 */
 
 //supply a response handler for omci response messages to be transferred to the requested FSM
-func (oo *OmciCC) receiveOmciResponse(omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
+func (oo *omciCC) receiveOmciResponse(omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
 
 	logger.Debugw("omci-message-response - transfer on omciRespChannel", log.Fields{"omciMsgType": omciMsg.MessageType,
 		"transCorrId": strconv.FormatInt(int64(omciMsg.TransactionID), 16), "device-id": oo.deviceID})
@@ -561,7 +563,7 @@
 	return nil
 }
 
-func (oo *OmciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
+func (oo *omciCC) sendMibReset(ctx context.Context, timeout int, highPrio bool) error {
 
 	logger.Debugw("send MibReset-msg to:", log.Fields{"device-id": oo.deviceID})
 	request := &omci.MibResetRequest{
@@ -569,40 +571,40 @@
 			EntityClass: me.OnuDataClassID,
 		},
 	}
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	pkt, err := serialize(omci.MibResetRequestType, request, tid)
 	if err != nil {
 		logger.Errorw("Cannot serialize MibResetRequest", log.Fields{
 			"Err": err, "device-id": oo.deviceID})
 		return err
 	}
-	omciRxCallbackPair := CallbackPair{
+	omciRxCallbackPair := callbackPair{
 		cbKey:   tid,
-		cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
+		cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
 	}
-	return oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+	return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 }
 
-func (oo *OmciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
+func (oo *omciCC) sendReboot(ctx context.Context, timeout int, highPrio bool, responseChannel chan Message) error {
 	logger.Debugw("send Reboot-msg to:", log.Fields{"device-id": oo.deviceID})
 	request := &omci.RebootRequest{
 		MeBasePacket: omci.MeBasePacket{
 			EntityClass: me.OnuGClassID,
 		},
 	}
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	pkt, err := serialize(omci.RebootRequestType, request, tid)
 	if err != nil {
 		logger.Errorw("Cannot serialize RebootRequest", log.Fields{
 			"Err": err, "device-id": oo.deviceID})
 		return err
 	}
-	omciRxCallbackPair := CallbackPair{
+	omciRxCallbackPair := callbackPair{
 		cbKey:   tid,
-		cbEntry: CallbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse},
+		cbEntry: callbackPairEntry{oo.pOnuDeviceEntry.omciRebootMessageReceivedChannel, oo.receiveOmciResponse},
 	}
 
-	err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+	err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 	if err != nil {
 		logger.Errorw("Cannot send RebootRequest", log.Fields{
 			"Err": err, "device-id": oo.deviceID})
@@ -617,14 +619,14 @@
 	return nil
 }
 
-func (oo *OmciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
+func (oo *omciCC) sendMibUpload(ctx context.Context, timeout int, highPrio bool) error {
 	logger.Debugw("send MibUpload-msg to:", log.Fields{"device-id": oo.deviceID})
 	request := &omci.MibUploadRequest{
 		MeBasePacket: omci.MeBasePacket{
 			EntityClass: me.OnuDataClassID,
 		},
 	}
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	pkt, err := serialize(omci.MibUploadRequestType, request, tid)
 	if err != nil {
 		logger.Errorw("Cannot serialize MibUploadRequest", log.Fields{
@@ -634,14 +636,14 @@
 	oo.uploadSequNo = 0
 	oo.uploadNoOfCmds = 0
 
-	omciRxCallbackPair := CallbackPair{
+	omciRxCallbackPair := callbackPair{
 		cbKey:   tid,
-		cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
+		cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
 	}
-	return oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+	return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 }
 
-func (oo *OmciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
+func (oo *omciCC) sendMibUploadNext(ctx context.Context, timeout int, highPrio bool) error {
 	logger.Debugw("send MibUploadNext-msg to:", log.Fields{"device-id": oo.deviceID, "uploadSequNo": oo.uploadSequNo})
 	request := &omci.MibUploadNextRequest{
 		MeBasePacket: omci.MeBasePacket{
@@ -649,7 +651,7 @@
 		},
 		CommandSequenceNumber: oo.uploadSequNo,
 	}
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	pkt, err := serialize(omci.MibUploadNextRequestType, request, tid)
 	if err != nil {
 		logger.Errorw("Cannot serialize MibUploadNextRequest", log.Fields{
@@ -658,15 +660,15 @@
 	}
 	oo.uploadSequNo++
 
-	omciRxCallbackPair := CallbackPair{
+	omciRxCallbackPair := callbackPair{
 		cbKey:   tid,
-		cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
+		cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
 	}
-	return oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+	return oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 }
 
-func (oo *OmciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+func (oo *omciCC) sendCreateGalEthernetProfile(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send GalEnetProfile-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -691,11 +693,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send GalEnetProfile create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -710,8 +712,8 @@
 }
 
 // might be needed to extend for parameter arguments, here just for setting the ConnectivityMode!!
-func (oo *OmciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+func (oo *omciCC) sendSetOnu2g(ctx context.Context, timeout int, highPrio bool) *me.ManagedEntity {
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send ONU2-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -739,11 +741,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send ONU2-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -757,9 +759,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateMBServiceProfile(ctx context.Context,
-	aPUniPort *OnuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+func (oo *omciCC) sendCreateMBServiceProfile(ctx context.Context,
+	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	tid := oo.getNextTid(highPrio)
 	instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
 	logger.Debugw("send MBSP-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
@@ -795,11 +797,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send MBSP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -813,9 +815,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateMBPConfigData(ctx context.Context,
-	aPUniPort *OnuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+func (oo *omciCC) sendCreateMBPConfigData(ctx context.Context,
+	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	tid := oo.getNextTid(highPrio)
 	instID := macBridgePortAniEID + aPUniPort.entityID
 	logger.Debugw("send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(instID), 16)})
@@ -847,11 +849,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -865,9 +867,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateEVTOConfigData(ctx context.Context,
-	aPUniPort *OnuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+func (oo *omciCC) sendCreateEVTOConfigData(ctx context.Context,
+	aPUniPort *onuUniPort, timeout int, highPrio bool) *me.ManagedEntity {
+	tid := oo.getNextTid(highPrio)
 	//same entityId is used as for MBSP (see there), but just arbitrary ...
 	instID := macBridgeServiceProfileEID + uint16(aPUniPort.macBpNo)
 	logger.Debugw("send EVTOCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
@@ -877,7 +879,7 @@
 	//   (setting TPID values for the create would probably anyway be ignored by the omci lib)
 	//    but perhaps we have to be aware of possible problems at get(Next) Request handling for EVTOOCD tables later ...
 	assType := uint8(2) // default AssociationType is PPTPEthUni
-	if aPUniPort.portType == UniVEIP {
+	if aPUniPort.portType == uniVEIP {
 		assType = uint8(10) // for VEIP
 	}
 	meParams := me.ParamData{
@@ -904,11 +906,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibDownloadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send EVTOCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -922,9 +924,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetOnuGLS(ctx context.Context, timeout int,
+func (oo *omciCC) sendSetOnuGLS(ctx context.Context, timeout int,
 	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send ONU-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -949,11 +951,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send ONU-G set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -967,9 +969,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
+func (oo *omciCC) sendSetUniGLS(ctx context.Context, aInstNo uint16, timeout int,
 	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send UNI-G-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -994,11 +996,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send UNIG-G-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1012,9 +1014,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
+func (oo *omciCC) sendSetVeipLS(ctx context.Context, aInstNo uint16, timeout int,
 	highPrio bool, requestedAttributes me.AttributeValueMap, rxChan chan Message) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send VEIP-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -1039,11 +1041,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send VEIP-Set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1057,10 +1059,10 @@
 	return nil
 }
 
-func (oo *OmciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
+func (oo *omciCC) sendGetMe(ctx context.Context, classID me.ClassID, entityID uint16, requestedAttributes me.AttributeValueMap,
 	timeout int, highPrio bool) *me.ManagedEntity {
 
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send get-request-msg", log.Fields{"classID": classID, "device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16)})
 
@@ -1081,11 +1083,11 @@
 			logger.Errorw("Cannot serialize get-request", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
 			return nil
 		}
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{(*oo.pOnuDeviceEntry).pMibUploadFsm.commChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send get-request-msg", log.Fields{"meClassIDName": meClassIDName, "Err": err, "device-id": oo.deviceID})
 			return nil
@@ -1097,9 +1099,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendCreateDot1PMapper(ctx context.Context, timeout int, highPrio bool,
 	aInstID uint16, rxChan chan Message) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send .1pMapper-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16), "InstId": strconv.FormatInt(int64(aInstID), 16)})
 
@@ -1125,11 +1127,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send .1pMapper create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1143,9 +1145,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendCreateMBPConfigDataVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send MBPCD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1168,11 +1170,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send MBPCD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1186,9 +1188,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendCreateGemNCTPVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send GemNCTP-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1211,11 +1213,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send GemNCTP create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1229,9 +1231,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendCreateGemIWTPVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send GemIwTp-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1254,11 +1256,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send GemIwTp create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1272,9 +1274,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendSetTcontVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send TCont-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1295,11 +1297,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send TCont set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1313,9 +1315,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendSetPrioQueueVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send PrioQueue-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1336,11 +1338,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send PrioQueue set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1354,9 +1356,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendSetDot1PMapperVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send 1PMapper-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1377,11 +1379,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send 1PMapper set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1395,9 +1397,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendCreateVtfdVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send VTFD-Create-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1423,11 +1425,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send VTFD create", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
@@ -1441,9 +1443,9 @@
 	return nil
 }
 
-func (oo *OmciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendSetEvtocdVar(ctx context.Context, timeout int, highPrio bool,
 	rxChan chan Message, params ...me.ParamData) *me.ManagedEntity {
-	tid := oo.GetNextTid(highPrio)
+	tid := oo.getNextTid(highPrio)
 	logger.Debugw("send EVTOCD-Set-msg:", log.Fields{"device-id": oo.deviceID,
 		"SequNo": strconv.FormatInt(int64(tid), 16),
 		"InstId": strconv.FormatInt(int64(params[0].EntityID), 16)})
@@ -1464,11 +1466,11 @@
 			return nil
 		}
 
-		omciRxCallbackPair := CallbackPair{
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{rxChan, oo.receiveOmciResponse},
+			cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse},
 		}
-		err = oo.Send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
+		err = oo.send(ctx, pkt, timeout, 0, highPrio, omciRxCallbackPair)
 		if err != nil {
 			logger.Errorw("Cannot send EVTOCD set", log.Fields{
 				"Err": err, "device-id": oo.deviceID})
diff --git a/internal/pkg/onuadaptercore/omci_test_request.go b/internal/pkg/onuadaptercore/omci_test_request.go
index 859dd9c..6449760 100644
--- a/internal/pkg/onuadaptercore/omci_test_request.go
+++ b/internal/pkg/onuadaptercore/omci_test_request.go
@@ -35,10 +35,10 @@
 	//"github.com/opencord/voltha-protos/v3/go/voltha"
 )
 
-//OmciTestRequest structure holds the information for the OMCI test
-type OmciTestRequest struct {
+//omciTestRequest structure holds the information for the OMCI test
+type omciTestRequest struct {
 	deviceID     string
-	pDevOmciCC   *OmciCC
+	pDevOmciCC   *omciCC
 	started      bool
 	result       bool
 	exclusiveCc  bool
@@ -47,12 +47,12 @@
 	verifyDone   chan<- bool
 }
 
-//NewOmciTestRequest returns a new instance of OmciTestRequest
-func NewOmciTestRequest(ctx context.Context,
-	deviceID string, omciCc *OmciCC,
-	exclusive bool, allowFailure bool) *OmciTestRequest {
+//newOmciTestRequest returns a new instance of OmciTestRequest
+func newOmciTestRequest(ctx context.Context,
+	deviceID string, omciCc *omciCC,
+	exclusive bool, allowFailure bool) *omciTestRequest {
 	logger.Debug("omciTestRequest-init")
-	var omciTestRequest OmciTestRequest
+	var omciTestRequest omciTestRequest
 	omciTestRequest.deviceID = deviceID
 	omciTestRequest.pDevOmciCC = omciCc
 	omciTestRequest.started = false
@@ -64,23 +64,23 @@
 }
 
 //
-func (oo *OmciTestRequest) PerformOmciTest(ctx context.Context, execChannel chan<- bool) {
+func (oo *omciTestRequest) performOmciTest(ctx context.Context, execChannel chan<- bool) {
 	logger.Debug("omciTestRequest-start-test")
 
 	if oo.pDevOmciCC != nil {
 		oo.verifyDone = execChannel
 		// test functionality is limited to ONU-2G get request for the moment
 		// without yet checking the received response automatically here (might be improved ??)
-		tid := oo.pDevOmciCC.GetNextTid(false)
-		onu2gBaseGet, _ := oo.CreateOnu2gBaseGet(tid)
-		omciRxCallbackPair := CallbackPair{
+		tid := oo.pDevOmciCC.getNextTid(false)
+		onu2gBaseGet, _ := oo.createOnu2gBaseGet(tid)
+		omciRxCallbackPair := callbackPair{
 			cbKey:   tid,
-			cbEntry: CallbackPairEntry{nil, oo.ReceiveOmciVerifyResponse},
+			cbEntry: callbackPairEntry{nil, oo.receiveOmciVerifyResponse},
 		}
 
 		logger.Debugw("performOmciTest-start sending frame", log.Fields{"for device-id": oo.deviceID})
 		// send with default timeout and normal prio
-		go oo.pDevOmciCC.Send(ctx, onu2gBaseGet, ConstDefaultOmciTimeout, 0, false, omciRxCallbackPair)
+		go oo.pDevOmciCC.send(ctx, onu2gBaseGet, ConstDefaultOmciTimeout, 0, false, omciRxCallbackPair)
 
 	} else {
 		logger.Errorw("performOmciTest: Device does not exist", log.Fields{"for device-id": oo.deviceID})
@@ -90,7 +90,7 @@
 // these are OMCI related functions, could/should be collected in a separate file? TODO!!!
 // for a simple start just included in here
 //basic approach copied from bbsim, cmp /devices/onu.go and /internal/common/omci/mibpackets.go
-func (oo *OmciTestRequest) CreateOnu2gBaseGet(tid uint16) ([]byte, error) {
+func (oo *omciTestRequest) createOnu2gBaseGet(tid uint16) ([]byte, error) {
 
 	request := &omci.GetRequest{
 		MeBasePacket: omci.MeBasePacket{
@@ -113,7 +113,7 @@
 }
 
 //supply a response handler - in this testobject the message is evaluated directly, no response channel used
-func (oo *OmciTestRequest) ReceiveOmciVerifyResponse(omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
+func (oo *omciTestRequest) receiveOmciVerifyResponse(omciMsg *omci.OMCI, packet *gp.Packet, respChan chan Message) error {
 
 	logger.Debugw("verify-omci-message-response received:", log.Fields{"omciMsgType": omciMsg.MessageType,
 		"transCorrId": omciMsg.TransactionID, "DeviceIdent": omciMsg.DeviceIdentifier})
diff --git a/internal/pkg/onuadaptercore/omci_vlan_config.go b/internal/pkg/onuadaptercore/omci_vlan_config.go
index deebdb3..3421f30 100644
--- a/internal/pkg/onuadaptercore/omci_vlan_config.go
+++ b/internal/pkg/onuadaptercore/omci_vlan_config.go
@@ -103,11 +103,11 @@
 
 //UniVlanConfigFsm defines the structure for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
 type UniVlanConfigFsm struct {
-	pDeviceHandler              *DeviceHandler
-	pOmciCC                     *OmciCC
-	pOnuUniPort                 *OnuUniPort
-	pUniTechProf                *OnuUniTechProf
-	pOnuDB                      *OnuDeviceDB
+	pDeviceHandler              *deviceHandler
+	pOmciCC                     *omciCC
+	pOnuUniPort                 *onuUniPort
+	pUniTechProf                *onuUniTechProf
+	pOnuDB                      *onuDeviceDB
 	techProfileID               uint16
 	requestEvent                OnuDeviceEvent
 	omciMIdsResponseReceived    chan bool //seperate channel needed for checking multiInstance OMCI message responses
@@ -124,8 +124,8 @@
 }
 
 //NewUniVlanConfigFsm is the 'constructor' for the state machine to config the PON ANI ports of ONU UNI ports via OMCI
-func NewUniVlanConfigFsm(apDeviceHandler *DeviceHandler, apDevOmciCC *OmciCC, apUniPort *OnuUniPort, apUniTechProf *OnuUniTechProf,
-	apOnuDB *OnuDeviceDB, aTechProfileID uint16, aRequestEvent OnuDeviceEvent, aName string,
+func NewUniVlanConfigFsm(apDeviceHandler *deviceHandler, apDevOmciCC *omciCC, apUniPort *onuUniPort, apUniTechProf *onuUniTechProf,
+	apOnuDB *onuDeviceDB, aTechProfileID uint16, aRequestEvent OnuDeviceEvent, aName string,
 	aDeviceID string, aCommChannel chan Message,
 	aAcceptIncrementalEvto bool, aMatchVlan uint16, aSetVlan uint16, aSetPcp uint8) *UniVlanConfigFsm {
 	instFsm := &UniVlanConfigFsm{
@@ -293,7 +293,7 @@
 	logger.Debugw("UniVlanConfigFsm - VLAN config done: send dh event notification", log.Fields{
 		"in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	if oFsm.pDeviceHandler != nil {
-		oFsm.pDeviceHandler.DeviceProcStatusUpdate(oFsm.requestEvent)
+		oFsm.pDeviceHandler.deviceProcStatusUpdate(oFsm.requestEvent)
 	}
 }
 
diff --git a/internal/pkg/onuadaptercore/onu_device_db.go b/internal/pkg/onuadaptercore/onu_device_db.go
index def0dc3..db5a84b 100644
--- a/internal/pkg/onuadaptercore/onu_device_db.go
+++ b/internal/pkg/onuadaptercore/onu_device_db.go
@@ -27,27 +27,27 @@
 	"github.com/opencord/voltha-lib-go/v3/pkg/log"
 )
 
-type MeDbMap map[me.ClassID]map[uint16]me.AttributeValueMap
+type meDbMap map[me.ClassID]map[uint16]me.AttributeValueMap
 
-//OnuDeviceDB structure holds information about known ME's
-type OnuDeviceDB struct {
+//onuDeviceDB structure holds information about known ME's
+type onuDeviceDB struct {
 	ctx             context.Context
 	pOnuDeviceEntry *OnuDeviceEntry
-	meDb            MeDbMap
+	meDb            meDbMap
 }
 
-//OnuDeviceDB returns a new instance for a specific ONU_Device_Entry
-func NewOnuDeviceDB(ctx context.Context, aPOnuDeviceEntry *OnuDeviceEntry) *OnuDeviceDB {
+//newOnuDeviceDB returns a new instance for a specific ONU_Device_Entry
+func newOnuDeviceDB(ctx context.Context, aPOnuDeviceEntry *OnuDeviceEntry) *onuDeviceDB {
 	logger.Debugw("Init OnuDeviceDB for:", log.Fields{"device-id": aPOnuDeviceEntry.deviceID})
-	var onuDeviceDB OnuDeviceDB
+	var onuDeviceDB onuDeviceDB
 	onuDeviceDB.ctx = ctx
 	onuDeviceDB.pOnuDeviceEntry = aPOnuDeviceEntry
-	onuDeviceDB.meDb = make(MeDbMap)
+	onuDeviceDB.meDb = make(meDbMap)
 
 	return &onuDeviceDB
 }
 
-func (onuDeviceDB *OnuDeviceDB) PutMe(meClassID me.ClassID, meEntityID uint16, meAttributes me.AttributeValueMap) {
+func (onuDeviceDB *onuDeviceDB) PutMe(meClassID me.ClassID, meEntityID uint16, meAttributes me.AttributeValueMap) {
 
 	//filter out the OnuData
 	if me.OnuDataClassID == meClassID {
@@ -83,7 +83,7 @@
 	}
 }
 
-func (onuDeviceDB *OnuDeviceDB) GetMe(meClassID me.ClassID, meEntityID uint16) me.AttributeValueMap {
+func (onuDeviceDB *onuDeviceDB) GetMe(meClassID me.ClassID, meEntityID uint16) me.AttributeValueMap {
 
 	if meAttributes, present := onuDeviceDB.meDb[meClassID][meEntityID]; present {
 		/* verbose logging, avoid in >= debug level
@@ -95,7 +95,7 @@
 	return nil
 }
 
-func (onuDeviceDB *OnuDeviceDB) GetUint32Attrib(meAttribute interface{}) (uint32, error) {
+func (onuDeviceDB *onuDeviceDB) getUint32Attrib(meAttribute interface{}) (uint32, error) {
 
 	switch reflect.TypeOf(meAttribute).Kind() {
 	case reflect.Float64:
@@ -108,7 +108,7 @@
 	}
 }
 
-func (onuDeviceDB *OnuDeviceDB) GetSortedInstKeys(meClassID me.ClassID) []uint16 {
+func (onuDeviceDB *onuDeviceDB) getSortedInstKeys(meClassID me.ClassID) []uint16 {
 
 	var meInstKeys []uint16
 
@@ -123,7 +123,7 @@
 	return meInstKeys
 }
 
-func (onuDeviceDB *OnuDeviceDB) LogMeDb() {
+func (onuDeviceDB *onuDeviceDB) logMeDb() {
 	logger.Debugw("ME instances stored for :", log.Fields{"device-id": onuDeviceDB.pOnuDeviceEntry.deviceID})
 	for meClassID, meInstMap := range onuDeviceDB.meDb {
 		for meEntityID, meAttribs := range meInstMap {
diff --git a/internal/pkg/onuadaptercore/onu_device_entry.go b/internal/pkg/onuadaptercore/onu_device_entry.go
index 259d6d9..382984c 100644
--- a/internal/pkg/onuadaptercore/onu_device_entry.go
+++ b/internal/pkg/onuadaptercore/onu_device_entry.go
@@ -106,21 +106,34 @@
 	cSuffixMibTemplateKvStore   = "%s/%s/%s"
 )
 
+// OnuDeviceEvent - event of interest to Device Adapters and OpenOMCI State Machines
 type OnuDeviceEvent int
 
 const (
 	// Events of interest to Device Adapters and OpenOMCI State Machines
-	DeviceStatusInit     OnuDeviceEvent = 0  // OnuDeviceEntry default start state
-	MibDatabaseSync      OnuDeviceEvent = 1  // MIB database sync (upload done)
-	OmciCapabilitiesDone OnuDeviceEvent = 2  // OMCI ME and message type capabilities known
-	MibDownloadDone      OnuDeviceEvent = 3  // MIB database sync (upload done)
-	UniLockStateDone     OnuDeviceEvent = 4  // Uni ports admin set to lock
-	UniUnlockStateDone   OnuDeviceEvent = 5  // Uni ports admin set to unlock
-	UniAdminStateDone    OnuDeviceEvent = 6  // Uni ports admin set done - general
-	PortLinkUp           OnuDeviceEvent = 7  // Port link state change
-	PortLinkDw           OnuDeviceEvent = 8  // Port link state change
-	OmciAniConfigDone    OnuDeviceEvent = 9  // AniSide config according to TechProfile done
-	OmciVlanFilterDone   OnuDeviceEvent = 10 // Omci Vlan config according to flowConfig done
+
+	// DeviceStatusInit - default start state
+	DeviceStatusInit OnuDeviceEvent = 0
+	// MibDatabaseSync - MIB database sync (upload done)
+	MibDatabaseSync OnuDeviceEvent = 1
+	// OmciCapabilitiesDone - OMCI ME and message type capabilities known
+	OmciCapabilitiesDone OnuDeviceEvent = 2
+	// MibDownloadDone - // MIB download done
+	MibDownloadDone OnuDeviceEvent = 3
+	// UniLockStateDone - Uni ports admin set to lock
+	UniLockStateDone OnuDeviceEvent = 4
+	// UniUnlockStateDone - Uni ports admin set to unlock
+	UniUnlockStateDone OnuDeviceEvent = 5
+	// UniAdminStateDone - Uni ports admin set done - general
+	UniAdminStateDone OnuDeviceEvent = 6
+	// PortLinkUp - Port link state change
+	PortLinkUp OnuDeviceEvent = 7
+	// PortLinkDw - Port link state change
+	PortLinkDw OnuDeviceEvent = 8
+	// OmciAniConfigDone -  AniSide config according to TechProfile done
+	OmciAniConfigDone OnuDeviceEvent = 9
+	// OmciVlanFilterDone - Omci Vlan config according to flowConfig done
+	OmciVlanFilterDone OnuDeviceEvent = 10
 	// Add other events here as needed (alarms separate???)
 )
 
@@ -130,8 +143,11 @@
 	auditDelay uint16
 	//tasks           map[string]func() error
 }
+
+// OmciDeviceFsms - FSM event mapping to database class and time to wait between audits
 type OmciDeviceFsms map[string]activityDescr
 
+// AdapterFsm - Adapter FSM details including channel, event and  device
 type AdapterFsm struct {
 	fsmName  string
 	deviceID string
@@ -139,11 +155,12 @@
 	pFsm     *fsm.FSM
 }
 
-func NewAdapterFsm(a_name string, a_deviceID string, a_commChannel chan Message) *AdapterFsm {
+//NewAdapterFsm - FSM details including event, device and channel.
+func NewAdapterFsm(aName string, aDeviceID string, aCommChannel chan Message) *AdapterFsm {
 	aFsm := &AdapterFsm{
-		fsmName:  a_name,
-		deviceID: a_deviceID,
-		commChan: a_commChannel,
+		fsmName:  aName,
+		deviceID: aDeviceID,
+		commChan: aCommChannel,
 	}
 	return aFsm
 }
@@ -157,33 +174,34 @@
 //OntDeviceEntry structure holds information about the attached FSM'as and their communication
 
 const (
-	FirstSwImageMeID  = 0
-	SecondSwImageMeID = 1
+	firstSwImageMeID  = 0
+	secondSwImageMeID = 1
 )
-const OnugMeID = 0
-const Onu2gMeID = 0
-const IPHostConfigDataMeID = 1
-const OnugSerialNumberLen = 8
-const OmciMacAddressLen = 6
+const onugMeID = 0
+const onu2gMeID = 0
+const ipHostConfigDataMeID = 1
+const onugSerialNumberLen = 8
+const omciMacAddressLen = 6
 
-type SwImages struct {
+type swImages struct {
 	version  string
 	isActive uint8
 }
 
+// OnuDeviceEntry - ONU device info and FSM events.
 type OnuDeviceEntry struct {
 	deviceID           string
-	baseDeviceHandler  *DeviceHandler
+	baseDeviceHandler  *deviceHandler
 	coreProxy          adapterif.CoreProxy
 	adapterProxy       adapterif.AdapterProxy
 	started            bool
-	PDevOmciCC         *OmciCC
-	pOnuDB             *OnuDeviceDB
+	PDevOmciCC         *omciCC
+	pOnuDB             *onuDeviceDB
 	mibTemplateKVStore *db.Backend
 	vendorID           string
 	serialNumber       string
 	equipmentID        string
-	swImages           [SecondSwImageMeID + 1]SwImages
+	swImages           [secondSwImageMeID + 1]swImages
 	activeSwVersion    string
 	macAddress         string
 	//lockDeviceEntries           sync.RWMutex
@@ -204,9 +222,9 @@
 	omciRebootMessageReceivedChannel chan Message // channel needed by Reboot request
 }
 
-//OnuDeviceEntry returns a new instance of a OnuDeviceEntry
+//newOnuDeviceEntry returns a new instance of a OnuDeviceEntry
 //mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
-func NewOnuDeviceEntry(ctx context.Context, deviceID string, kVStoreHost string, kVStorePort int, kvStoreType string, deviceHandler *DeviceHandler,
+func newOnuDeviceEntry(ctx context.Context, deviceID string, kVStoreHost string, kVStorePort int, kvStoreType string, deviceHandler *deviceHandler,
 	coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy,
 	supportedFsmsPtr *OmciDeviceFsms) *OnuDeviceEntry {
 	logger.Infow("init-onuDeviceEntry", log.Fields{"device-id": deviceID})
@@ -231,7 +249,7 @@
 		onuDeviceEntry.supportedFsms = OmciDeviceFsms{
 			"mib-synchronizer": {
 				//mibSyncFsm,        // Implements the MIB synchronization state machine
-				onuDeviceEntry.MibDbVolatileDict, // Implements volatile ME MIB database
+				onuDeviceEntry.mibDbVolatileDict, // Implements volatile ME MIB database
 				//true,                             // Advertise events on OpenOMCI event bus
 				60, // Time to wait between MIB audits.  0 to disable audits.
 				// map[string]func() error{
@@ -359,7 +377,7 @@
 		// some specifc error treatment - or waiting for crash ???
 	}
 
-	onuDeviceEntry.mibTemplateKVStore = onuDeviceEntry.baseDeviceHandler.SetBackend(cBasePathMibTemplateKvStore)
+	onuDeviceEntry.mibTemplateKVStore = onuDeviceEntry.baseDeviceHandler.setBackend(cBasePathMibTemplateKvStore)
 	if onuDeviceEntry.mibTemplateKVStore == nil {
 		logger.Errorw("Failed to setup mibTemplateKVStore", log.Fields{"device-id": deviceID})
 	}
@@ -370,11 +388,11 @@
 	return &onuDeviceEntry
 }
 
-//Start starts (logs) the omci agent
-func (oo *OnuDeviceEntry) Start(ctx context.Context) error {
+//start starts (logs) the omci agent
+func (oo *OnuDeviceEntry) start(ctx context.Context) error {
 	logger.Info("starting-OnuDeviceEntry")
 
-	oo.PDevOmciCC = NewOmciCC(ctx, oo, oo.deviceID, oo.baseDeviceHandler,
+	oo.PDevOmciCC = newOmciCC(ctx, oo, oo.deviceID, oo.baseDeviceHandler,
 		oo.coreProxy, oo.adapterProxy)
 	if oo.PDevOmciCC == nil {
 		logger.Errorw("Could not create devOmciCc - abort", log.Fields{"for device-id": oo.deviceID})
@@ -386,8 +404,8 @@
 	return nil
 }
 
-//Stop terminates the session
-func (oo *OnuDeviceEntry) Stop(ctx context.Context) error {
+//stop terminates the session
+func (oo *OnuDeviceEntry) stop(ctx context.Context) error {
 	logger.Info("stopping-OnuDeviceEntry")
 	oo.started = false
 	//oo.exitChannel <- 1
@@ -396,7 +414,7 @@
 	return nil
 }
 
-func (oo *OnuDeviceEntry) Reboot(ctx context.Context) error {
+func (oo *OnuDeviceEntry) reboot(ctx context.Context) error {
 	logger.Info("reboot-OnuDeviceEntry")
 	if err := oo.PDevOmciCC.sendReboot(context.TODO(), ConstDefaultOmciTimeout, true, oo.omciRebootMessageReceivedChannel); err != nil {
 		logger.Errorw("onu didn't reboot", log.Fields{"for device-id": oo.deviceID})
@@ -445,7 +463,7 @@
 	if devEvent == MibDatabaseSync {
 		if oo.devState < MibDatabaseSync { //devState has not been synced yet
 			oo.devState = MibDatabaseSync
-			go oo.baseDeviceHandler.DeviceProcStatusUpdate(devEvent)
+			go oo.baseDeviceHandler.deviceProcStatusUpdate(devEvent)
 			//TODO!!! device control: next step: start MIB capability verification from here ?!!!
 		} else {
 			logger.Debugw("mibinsync-event in some already synced state - ignored", log.Fields{"state": oo.devState})
@@ -453,7 +471,7 @@
 	} else if devEvent == MibDownloadDone {
 		if oo.devState < MibDownloadDone { //devState has not been synced yet
 			oo.devState = MibDownloadDone
-			go oo.baseDeviceHandler.DeviceProcStatusUpdate(devEvent)
+			go oo.baseDeviceHandler.deviceProcStatusUpdate(devEvent)
 		} else {
 			logger.Debugw("mibdownloaddone-event was already seen - ignored", log.Fields{"state": oo.devState})
 		}
diff --git a/internal/pkg/onuadaptercore/onu_uni_port.go b/internal/pkg/onuadaptercore/onu_uni_port.go
index 7ce362f..0406cc9 100644
--- a/internal/pkg/onuadaptercore/onu_uni_port.go
+++ b/internal/pkg/onuadaptercore/onu_uni_port.go
@@ -34,22 +34,22 @@
 	"github.com/opencord/voltha-protos/v3/go/voltha"
 )
 
-type UniPortType uint8
+type uniPortType uint8
 
 // UniPPTP Interface type - re-use values from G.988 TP type definition (directly used in OMCI!)
 const (
-	// UniPPTP relates to PPTP
-	UniPPTP UniPortType = 1 // relates to PPTP
-	// UniPPTP relates to VEIP
-	UniVEIP UniPortType = 11 // relates to VEIP
+	// uniPPTP relates to PPTP
+	uniPPTP uniPortType = 1 // relates to PPTP
+	// uniVEIP relates to VEIP
+	uniVEIP uniPortType = 11 // relates to VEIP
 )
 
-//OnuUniPort structure holds information about the ONU attached Uni Ports
-type OnuUniPort struct {
+//onuUniPort structure holds information about the ONU attached Uni Ports
+type onuUniPort struct {
 	enabled    bool
 	name       string
 	portNo     uint32
-	portType   UniPortType
+	portType   uniPortType
 	ofpPortNo  string
 	uniID      uint8
 	macBpNo    uint8
@@ -59,12 +59,12 @@
 	pPort      *voltha.Port
 }
 
-//NewOnuUniPort returns a new instance of a OnuUniPort
-func NewOnuUniPort(aUniID uint8, aPortNo uint32, aInstNo uint16,
-	aPortType UniPortType) *OnuUniPort {
+//newOnuUniPort returns a new instance of a OnuUniPort
+func newOnuUniPort(aUniID uint8, aPortNo uint32, aInstNo uint16,
+	aPortType uniPortType) *onuUniPort {
 	logger.Infow("init-onuUniPort", log.Fields{"uniID": aUniID,
 		"portNo": aPortNo, "InstNo": aInstNo, "type": aPortType})
-	var onuUniPort OnuUniPort
+	var onuUniPort onuUniPort
 	onuUniPort.enabled = false
 	onuUniPort.name = "uni-" + strconv.FormatUint(uint64(aPortNo), 10)
 	onuUniPort.portNo = aPortNo
@@ -80,8 +80,8 @@
 	return &onuUniPort
 }
 
-//CreateVolthaPort creates the Voltha port based on ONU UNI Port and informs the core about it
-func (oo *OnuUniPort) CreateVolthaPort(apDeviceHandler *DeviceHandler) error {
+//createVolthaPort creates the Voltha port based on ONU UNI Port and informs the core about it
+func (oo *onuUniPort) createVolthaPort(apDeviceHandler *deviceHandler) error {
 	logger.Debugw("creating-voltha-uni-port", log.Fields{
 		"device-id": apDeviceHandler.device.Id, "portNo": oo.portNo})
 	//200630: per [VOL-3202] OF port info is now to be delivered within UniPort create
@@ -148,8 +148,8 @@
 	return nil
 }
 
-//SetOperState modifies OperState of the the UniPort
-func (oo *OnuUniPort) SetOperState(aNewOperState vc.OperStatus_Types) {
+//setOperState modifies OperState of the the UniPort
+func (oo *onuUniPort) setOperState(aNewOperState vc.OperStatus_Types) {
 	oo.operState = aNewOperState
 }
 
diff --git a/internal/pkg/onuadaptercore/onu_uni_tp.go b/internal/pkg/onuadaptercore/onu_uni_tp.go
index 5780308..4f452a7 100644
--- a/internal/pkg/onuadaptercore/onu_uni_tp.go
+++ b/internal/pkg/onuadaptercore/onu_uni_tp.go
@@ -38,10 +38,10 @@
 //definitions for TechProfileProcessing - copied from OltAdapter:openolt_flowmgr.go
 //  could perhaps be defined more globally
 const (
-	// BinaryStringPrefix is binary string prefix
-	BinaryStringPrefix = "0b"
-	// BinaryBit1 is binary bit 1 expressed as a character
-	BinaryBit1 = '1'
+	// binaryStringPrefix is binary string prefix
+	binaryStringPrefix = "0b"
+	// binaryBit1 is binary bit 1 expressed as a character
+	//binaryBit1 = '1'
 )
 
 type resourceEntry int
@@ -98,10 +98,10 @@
 //refers to all tcont and their Tcont/GemPort Parameters
 type tMapPonAniConfig map[uint16]*tcontGemList
 
-//OnuUniTechProf structure holds information about the TechProfiles attached to Uni Ports of the ONU
-type OnuUniTechProf struct {
+//onuUniTechProf structure holds information about the TechProfiles attached to Uni Ports of the ONU
+type onuUniTechProf struct {
 	deviceID                 string
-	baseDeviceHandler        *DeviceHandler
+	baseDeviceHandler        *deviceHandler
 	tpProcMutex              sync.RWMutex
 	mapUniTpPath             map[uint32]string
 	sOnuPersistentData       onuPersistentData
@@ -112,16 +112,16 @@
 	chTpKvProcessingStep     chan uint8
 	mapUniTpIndication       map[uint8]*tTechProfileIndication //use pointer values to ease assignments to the map
 	mapPonAniConfig          map[uint8]*tMapPonAniConfig       //per UNI: use pointer values to ease assignments to the map
-	pAniConfigFsm            *UniPonAniConfigFsm
+	pAniConfigFsm            *uniPonAniConfigFsm
 	procResult               error //error indication of processing
 	mutexTPState             sync.Mutex
 }
 
-//NewOnuUniTechProf returns the instance of a OnuUniTechProf
+//newOnuUniTechProf returns the instance of a OnuUniTechProf
 //(one instance per ONU/deviceHandler for all possible UNI's)
-func NewOnuUniTechProf(ctx context.Context, aDeviceID string, aDeviceHandler *DeviceHandler) *OnuUniTechProf {
+func newOnuUniTechProf(ctx context.Context, aDeviceID string, aDeviceHandler *deviceHandler) *onuUniTechProf {
 	logger.Infow("init-OnuUniTechProf", log.Fields{"device-id": aDeviceID})
-	var onuTP OnuUniTechProf
+	var onuTP onuUniTechProf
 	onuTP.deviceID = aDeviceID
 	onuTP.baseDeviceHandler = aDeviceHandler
 	onuTP.tpProcMutex = sync.RWMutex{}
@@ -133,14 +133,14 @@
 	onuTP.mapPonAniConfig = make(map[uint8]*tMapPonAniConfig)
 	onuTP.procResult = nil //default assumption processing done with success
 
-	onuTP.techProfileKVStore = aDeviceHandler.SetBackend(cBasePathTechProfileKVStore)
+	onuTP.techProfileKVStore = aDeviceHandler.setBackend(cBasePathTechProfileKVStore)
 	if onuTP.techProfileKVStore == nil {
 		logger.Errorw("Can't access techProfileKVStore - no backend connection to service",
 			log.Fields{"device-id": aDeviceID, "service": cBasePathTechProfileKVStore})
 	}
 
 	onuTP.onuKVStorePath = onuTP.deviceID
-	onuTP.onuKVStore = aDeviceHandler.SetBackend(cBasePathOnuKVStore)
+	onuTP.onuKVStore = aDeviceHandler.setBackend(cBasePathOnuKVStore)
 	if onuTP.onuKVStore == nil {
 		logger.Errorw("Can't access onuKVStore - no backend connection to service",
 			log.Fields{"device-id": aDeviceID, "service": cBasePathOnuKVStore})
@@ -149,23 +149,23 @@
 }
 
 // lockTpProcMutex locks OnuUniTechProf processing mutex
-func (onuTP *OnuUniTechProf) lockTpProcMutex() {
+func (onuTP *onuUniTechProf) lockTpProcMutex() {
 	onuTP.tpProcMutex.Lock()
 }
 
 // unlockTpProcMutex unlocks OnuUniTechProf processing mutex
-func (onuTP *OnuUniTechProf) unlockTpProcMutex() {
+func (onuTP *onuUniTechProf) unlockTpProcMutex() {
 	onuTP.tpProcMutex.Unlock()
 }
 
 // resetProcessingErrorIndication resets the internal error indication
 // need to be called before evaluation of any subsequent processing (given by waitForTpCompletion())
-func (onuTP *OnuUniTechProf) resetProcessingErrorIndication() {
+func (onuTP *onuUniTechProf) resetProcessingErrorIndication() {
 	onuTP.procResult = nil
 }
 
 // updateOnuUniTpPath verifies and updates changes in the kvStore onuUniTpPath
-func (onuTP *OnuUniTechProf) updateOnuUniTpPath(aUniID uint32, aPathString string) bool {
+func (onuTP *onuUniTechProf) updateOnuUniTpPath(aUniID uint32, aPathString string) bool {
 	/* within some specific InterAdapter processing request write/read access to data is ensured to be sequentially,
 	   as also the complete sequence is ensured to 'run to  completion' before some new request is accepted
 	   no specific concurrency protection to sOnuPersistentData is required here
@@ -206,7 +206,7 @@
 	return true
 }
 
-func (onuTP *OnuUniTechProf) waitForTpCompletion(cancel context.CancelFunc, wg *sync.WaitGroup) error {
+func (onuTP *onuUniTechProf) waitForTpCompletion(cancel context.CancelFunc, wg *sync.WaitGroup) error {
 	defer cancel() //ensure termination of context (may be pro forma)
 	wg.Wait()
 	logger.Debug("some TechProfile Processing completed")
@@ -218,7 +218,7 @@
 // all possibly blocking processing must be run in background to allow for deadline supervision!
 // but take care on sequential background processing when needed (logical dependencies)
 //   use waitForTimeoutOrCompletion(ctx, chTpConfigProcessingStep, processingStep) for internal synchronization
-func (onuTP *OnuUniTechProf) configureUniTp(ctx context.Context,
+func (onuTP *onuUniTechProf) configureUniTp(ctx context.Context,
 	aUniID uint8, aPathString string, wg *sync.WaitGroup) {
 	defer wg.Done() //always decrement the waitGroup on return
 	logger.Debugw("configure the Uni according to TpPath", log.Fields{
@@ -231,7 +231,7 @@
 	}
 
 	//ensure that the given uniID is available (configured) in the UniPort class (used for OMCI entities)
-	var pCurrentUniPort *OnuUniPort
+	var pCurrentUniPort *onuUniPort
 	for _, uniPort := range onuTP.baseDeviceHandler.uniEntityMap {
 		// only if this port is validated for operState transfer
 		if uniPort.uniID == uint8(aUniID) {
@@ -306,7 +306,7 @@
 	}
 }
 
-func (onuTP *OnuUniTechProf) updateOnuTpPathKvStore(ctx context.Context, wg *sync.WaitGroup) {
+func (onuTP *onuUniTechProf) updateOnuTpPathKvStore(ctx context.Context, wg *sync.WaitGroup) {
 	defer wg.Done()
 
 	if onuTP.onuKVStore == nil {
@@ -324,7 +324,7 @@
 	}
 }
 
-func (onuTP *OnuUniTechProf) restoreFromOnuTpPathKvStore(ctx context.Context) error {
+func (onuTP *onuUniTechProf) restoreFromOnuTpPathKvStore(ctx context.Context) error {
 	if onuTP.onuKVStore == nil {
 		logger.Debugw("onuKVStore not set - abort", log.Fields{"device-id": onuTP.deviceID})
 		return fmt.Errorf(fmt.Sprintf("onuKVStore-not-set-abort-%s", onuTP.deviceID))
@@ -336,7 +336,7 @@
 	return nil
 }
 
-func (onuTP *OnuUniTechProf) deleteOnuTpPathKvStore(ctx context.Context) error {
+func (onuTP *onuUniTechProf) deleteOnuTpPathKvStore(ctx context.Context) error {
 	if onuTP.onuKVStore == nil {
 		logger.Debugw("onuKVStore not set - abort", log.Fields{"device-id": onuTP.deviceID})
 		return fmt.Errorf(fmt.Sprintf("onuKVStore-not-set-abort-%s", onuTP.deviceID))
@@ -349,7 +349,7 @@
 }
 
 // deleteTpResource removes Resources from the ONU's specified Uni
-func (onuTP *OnuUniTechProf) deleteTpResource(ctx context.Context,
+func (onuTP *onuUniTechProf) deleteTpResource(ctx context.Context,
 	aUniID uint32, aPathString string, aResource resourceEntry, aEntryID uint32,
 	wg *sync.WaitGroup) {
 	defer wg.Done()
@@ -369,7 +369,7 @@
 
 /* internal methods *********************/
 
-func (onuTP *OnuUniTechProf) storePersistentData(ctx context.Context, aProcessingStep uint8) {
+func (onuTP *onuUniTechProf) storePersistentData(ctx context.Context, aProcessingStep uint8) {
 
 	onuTP.sOnuPersistentData.PersOnuID = onuTP.baseDeviceHandler.pOnuIndication.OnuId
 	onuTP.sOnuPersistentData.PersIntfID = onuTP.baseDeviceHandler.pOnuIndication.IntfId
@@ -402,7 +402,7 @@
 	onuTP.chTpKvProcessingStep <- aProcessingStep //done
 }
 
-func (onuTP *OnuUniTechProf) restorePersistentData(ctx context.Context) error {
+func (onuTP *onuUniTechProf) restorePersistentData(ctx context.Context) error {
 
 	onuTP.mapUniTpPath = make(map[uint32]string)
 	onuTP.sOnuPersistentData = onuPersistentData{0, 0, "", "", "", make([]uniPersData, 0)}
@@ -437,7 +437,7 @@
 	return nil
 }
 
-func (onuTP *OnuUniTechProf) deletePersistentData(ctx context.Context) error {
+func (onuTP *onuUniTechProf) deletePersistentData(ctx context.Context) error {
 
 	logger.Debugw("delete ONU/TP-data in KVStore", log.Fields{"device-id": onuTP.deviceID})
 	err := onuTP.onuKVStore.Delete(ctx, onuTP.onuKVStorePath)
@@ -448,7 +448,7 @@
 	return nil
 }
 
-func (onuTP *OnuUniTechProf) readAniSideConfigFromTechProfile(
+func (onuTP *onuUniTechProf) readAniSideConfigFromTechProfile(
 	ctx context.Context, aUniID uint8, aPathString string, aProcessingStep uint8) {
 	var tpInst tp.TechProfile
 
@@ -578,7 +578,7 @@
 		(*(onuTP.mapPonAniConfig[aUniID]))[0].mapGemPortParams[uint16(pos)].prioQueueIndex =
 			uint8(content.PriorityQueue)
 		(*(onuTP.mapPonAniConfig[aUniID]))[0].mapGemPortParams[uint16(pos)].pbitString =
-			strings.TrimPrefix(content.PbitMap, BinaryStringPrefix)
+			strings.TrimPrefix(content.PbitMap, binaryStringPrefix)
 		if content.AesEncryption == "True" {
 			(*(onuTP.mapPonAniConfig[aUniID]))[0].mapGemPortParams[uint16(pos)].gemPortEncState = 1
 		} else {
@@ -616,8 +616,8 @@
 	onuTP.chTpConfigProcessingStep <- aProcessingStep //done
 }
 
-func (onuTP *OnuUniTechProf) setAniSideConfigFromTechProfile(
-	ctx context.Context, aUniID uint8, apCurrentUniPort *OnuUniPort, aProcessingStep uint8) {
+func (onuTP *onuUniTechProf) setAniSideConfigFromTechProfile(
+	ctx context.Context, aUniID uint8, apCurrentUniPort *onuUniPort, aProcessingStep uint8) {
 
 	//OMCI transfer of ANI data acc. to mapPonAniConfig
 	// also the FSM's are running in background,
@@ -629,7 +629,7 @@
 	}
 }
 
-func (onuTP *OnuUniTechProf) waitForTimeoutOrCompletion(
+func (onuTP *onuUniTechProf) waitForTimeoutOrCompletion(
 	ctx context.Context, aChTpProcessingStep <-chan uint8, aProcessingStep uint8) bool {
 	select {
 	case <-ctx.Done():
@@ -649,16 +649,16 @@
 }
 
 // createUniLockFsm initializes and runs the AniConfig FSM to transfer the OMCI related commands for ANI side configuration
-func (onuTP *OnuUniTechProf) createAniConfigFsm(aUniID uint8,
-	apCurrentUniPort *OnuUniPort, devEvent OnuDeviceEvent, aProcessingStep uint8) {
+func (onuTP *onuUniTechProf) createAniConfigFsm(aUniID uint8,
+	apCurrentUniPort *onuUniPort, devEvent OnuDeviceEvent, aProcessingStep uint8) {
 	logger.Debugw("createAniConfigFsm", log.Fields{"device-id": onuTP.deviceID})
 	chAniConfigFsm := make(chan Message, 2048)
-	pDevEntry := onuTP.baseDeviceHandler.GetOnuDeviceEntry(true)
+	pDevEntry := onuTP.baseDeviceHandler.getOnuDeviceEntry(true)
 	if pDevEntry == nil {
 		logger.Errorw("No valid OnuDevice - aborting", log.Fields{"device-id": onuTP.deviceID})
 		return
 	}
-	pAniCfgFsm := NewUniPonAniConfigFsm(pDevEntry.PDevOmciCC, apCurrentUniPort, onuTP,
+	pAniCfgFsm := newUniPonAniConfigFsm(pDevEntry.PDevOmciCC, apCurrentUniPort, onuTP,
 		pDevEntry.pOnuDB, onuTP.mapUniTpIndication[aUniID].techProfileID, devEvent,
 		"AniConfigFsm", onuTP.deviceID, chAniConfigFsm)
 	if pAniCfgFsm != nil {
@@ -670,7 +670,7 @@
 }
 
 // runAniConfigFsm starts the AniConfig FSM to transfer the OMCI related commands for  ANI side configuration
-func (onuTP *OnuUniTechProf) runAniConfigFsm(aProcessingStep uint8) {
+func (onuTP *onuUniTechProf) runAniConfigFsm(aProcessingStep uint8) {
 	/*  Uni related ANI config procedure -
 	 ***** should run via 'aniConfigDone' state and generate the argument requested event *****
 	 */
@@ -678,7 +678,7 @@
 	if pACStatemachine != nil {
 		if pACStatemachine.Is(aniStDisabled) {
 			//FSM init requirement to get informed abou FSM completion! (otherwise timeout of the TechProf config)
-			onuTP.pAniConfigFsm.SetFsmCompleteChannel(onuTP.chTpConfigProcessingStep, aProcessingStep)
+			onuTP.pAniConfigFsm.setFsmCompleteChannel(onuTP.chTpConfigProcessingStep, aProcessingStep)
 			if err := pACStatemachine.Event(aniEvStart); err != nil {
 				logger.Warnw("AniConfigFSM: can't start", log.Fields{"err": err})
 				// maybe try a FSM reset and then again ... - TODO!!!
@@ -699,7 +699,7 @@
 }
 
 // setConfigDone sets the requested techProfile config state (if possible)
-func (onuTP *OnuUniTechProf) setConfigDone(aUniID uint8, aState bool) {
+func (onuTP *onuUniTechProf) setConfigDone(aUniID uint8, aState bool) {
 	if _, existTP := onuTP.mapUniTpIndication[aUniID]; existTP {
 		onuTP.mutexTPState.Lock()
 		onuTP.mapUniTpIndication[aUniID].techProfileConfigDone = aState
@@ -708,7 +708,7 @@
 }
 
 // getTechProfileDone checks if the Techprofile processing with the requested TechProfile ID was done
-func (onuTP *OnuUniTechProf) getTechProfileDone(aUniID uint8, aTpID uint16) bool {
+func (onuTP *onuUniTechProf) getTechProfileDone(aUniID uint8, aTpID uint16) bool {
 	if _, existTP := onuTP.mapUniTpIndication[aUniID]; existTP {
 		if onuTP.mapUniTpIndication[aUniID].techProfileID == aTpID {
 			onuTP.mutexTPState.Lock()
diff --git a/internal/pkg/onuadaptercore/openonu.go b/internal/pkg/onuadaptercore/openonu.go
index 28d124d..61b52f3 100644
--- a/internal/pkg/onuadaptercore/openonu.go
+++ b/internal/pkg/onuadaptercore/openonu.go
@@ -37,7 +37,7 @@
 
 //OpenONUAC structure holds the ONU core information
 type OpenONUAC struct {
-	deviceHandlers              map[string]*DeviceHandler
+	deviceHandlers              map[string]*deviceHandler
 	coreProxy                   adapterif.CoreProxy
 	adapterProxy                adapterif.AdapterProxy
 	eventProxy                  adapterif.EventProxy
@@ -64,7 +64,7 @@
 	eventProxy adapterif.EventProxy, kvClient kvstore.Client, cfg *config.AdapterFlags) *OpenONUAC {
 	var openOnuAc OpenONUAC
 	openOnuAc.exitChannel = make(chan int, 1)
-	openOnuAc.deviceHandlers = make(map[string]*DeviceHandler)
+	openOnuAc.deviceHandlers = make(map[string]*deviceHandler)
 	openOnuAc.kafkaICProxy = kafkaICProxy
 	openOnuAc.config = cfg
 	openOnuAc.numOnus = cfg.OnuNumber
@@ -85,7 +85,7 @@
 	openOnuAc.pSupportedFsms = &OmciDeviceFsms{
 		"mib-synchronizer": {
 			//mibSyncFsm,        // Implements the MIB synchronization state machine
-			MibDbVolatileDictImpl, // Implements volatile ME MIB database
+			mibDbVolatileDictImpl, // Implements volatile ME MIB database
 			//true,                  // Advertise events on OpenOMCI event bus
 			cMibAuditDelayImpl, // Time to wait between MIB audits.  0 to disable audits.
 			// map[string]func() error{
@@ -109,32 +109,34 @@
 	return nil
 }
 
-//Stop terminates the session
-func (oo *OpenONUAC) Stop(ctx context.Context) error {
+/*
+//stop terminates the session
+func (oo *OpenONUAC) stop(ctx context.Context) error {
 	logger.Info("stopping-device-manager")
 	oo.exitChannel <- 1
 	logger.Info("device-manager-stopped")
 	return nil
 }
+*/
 
-func (oo *OpenONUAC) addDeviceHandlerToMap(ctx context.Context, agent *DeviceHandler) {
+func (oo *OpenONUAC) addDeviceHandlerToMap(ctx context.Context, agent *deviceHandler) {
 	oo.lockDeviceHandlersMap.Lock()
 	defer oo.lockDeviceHandlersMap.Unlock()
 	if _, exist := oo.deviceHandlers[agent.deviceID]; !exist {
 		oo.deviceHandlers[agent.deviceID] = agent
-		oo.deviceHandlers[agent.deviceID].Start(ctx)
+		oo.deviceHandlers[agent.deviceID].start(ctx)
 	}
 }
 
 /*
-func (oo *OpenONUAC) deleteDeviceHandlerToMap(agent *DeviceHandler) {
+func (oo *OpenONUAC) deleteDeviceHandlerToMap(agent *deviceHandler) {
 	oo.lockDeviceHandlersMap.Lock()
 	defer oo.lockDeviceHandlersMap.Unlock()
 	delete(oo.deviceHandlers, agent.deviceID)
 }
 */
 
-func (oo *OpenONUAC) getDeviceHandler(deviceID string) *DeviceHandler {
+func (oo *OpenONUAC) getDeviceHandler(deviceID string) *deviceHandler {
 	oo.lockDeviceHandlersMap.Lock()
 	defer oo.lockDeviceHandlersMap.Unlock()
 	if agent, ok := oo.deviceHandlers[deviceID]; ok {
@@ -157,11 +159,11 @@
 	}
 	ctx := context.Background()
 	logger.Infow("adopt-device", log.Fields{"device-id": device.Id})
-	var handler *DeviceHandler
+	var handler *deviceHandler
 	if handler = oo.getDeviceHandler(device.Id); handler == nil {
-		handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
+		handler := newDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
 		oo.addDeviceHandlerToMap(ctx, handler)
-		go handler.AdoptOrReconcileDevice(ctx, device)
+		go handler.adoptOrReconcileDevice(ctx, device)
 		// Launch the creation of the device topic
 		// go oo.createDeviceTopic(device)
 	}
@@ -189,7 +191,7 @@
 		/* 200724: modification towards synchronous implementation - possible errors within processing shall be
 		 * 	 in the accordingly delayed response, some timing effect might result in Techprofile processing for multiple UNI's
 		 */
-		return handler.ProcessInterAdapterMessage(msg)
+		return handler.processInterAdapterMessage(msg)
 		/* so far the processing has been in background with according commented error treatment restrictions:
 		go handler.ProcessInterAdapterMessage(msg)
 		// error treatment might be more sophisticated
@@ -227,13 +229,13 @@
 	}
 	ctx := context.Background()
 	logger.Infow("Reconcile_device", log.Fields{"device-id": device.Id})
-	var handler *DeviceHandler
+	var handler *deviceHandler
 	if handler = oo.getDeviceHandler(device.Id); handler == nil {
-		handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
+		handler := newDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
 		oo.addDeviceHandlerToMap(ctx, handler)
 		handler.device = device
 		handler.reconciling = true
-		go handler.AdoptOrReconcileDevice(ctx, handler.device)
+		go handler.adoptOrReconcileDevice(ctx, handler.device)
 		// reconcilement will be continued after onu-device entry is added
 	} else {
 		return fmt.Errorf(fmt.Sprintf("device-already-reconciled-or-active-%s", device.Id))
@@ -250,7 +252,7 @@
 func (oo *OpenONUAC) Disable_device(device *voltha.Device) error {
 	logger.Debugw("Disable_device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
-		go handler.DisableDevice(device)
+		go handler.disableDevice(device)
 		return nil
 	}
 	logger.Warnw("no handler found for device-disable", log.Fields{"device-id": device.Id})
@@ -261,7 +263,7 @@
 func (oo *OpenONUAC) Reenable_device(device *voltha.Device) error {
 	logger.Debugw("Reenable_device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
-		go handler.ReenableDevice(device)
+		go handler.reEnableDevice(device)
 		return nil
 	}
 	logger.Warnw("no handler found for device-reenable", log.Fields{"device-id": device.Id})
@@ -272,7 +274,7 @@
 func (oo *OpenONUAC) Reboot_device(device *voltha.Device) error {
 	logger.Debugw("Reboot-device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
-		go handler.RebootDevice(device)
+		go handler.rebootDevice(device)
 		return nil
 	}
 	logger.Warnw("no handler found for device-reboot", log.Fields{"device-id": device.Id})
@@ -284,10 +286,11 @@
 	return errors.New("unImplemented")
 }
 
+// Delete_device deletes the given device
 func (oo *OpenONUAC) Delete_device(device *voltha.Device) error {
 	logger.Debugw("Delete_device", log.Fields{"device-id": device.Id})
 	if handler := oo.getDeviceHandler(device.Id); handler != nil {
-		if err := handler.DeleteDevice(device); err != nil {
+		if err := handler.deleteDevice(device); err != nil {
 			return err
 		}
 	} else {
@@ -391,15 +394,18 @@
 	return errors.New("unImplemented")
 }
 
+//Child_device_lost - unimplemented
 //needed for if update >= 3.1.x
 func (oo *OpenONUAC) Child_device_lost(deviceID string, pPortNo uint32, onuID uint32) error {
 	return errors.New("unImplemented")
 }
 
+// Start_omci_test unimplemented
 func (oo *OpenONUAC) Start_omci_test(device *voltha.Device, request *voltha.OmciTestRequest) (*voltha.TestResponse, error) {
 	return nil, errors.New("unImplemented")
 }
 
+// Get_ext_value - unimplemented
 func (oo *OpenONUAC) Get_ext_value(deviceID string, device *voltha.Device, valueparam voltha.ValueType_Type) (*voltha.ReturnValues, error) {
 	return nil, errors.New("unImplemented")
 }
diff --git a/internal/pkg/onuadaptercore/openonuimpl.go b/internal/pkg/onuadaptercore/openonuimpl.go
index 0678c0c..a3e3780 100644
--- a/internal/pkg/onuadaptercore/openonuimpl.go
+++ b/internal/pkg/onuadaptercore/openonuimpl.go
@@ -89,12 +89,14 @@
 const cMibAuditDelayImpl = 0
 
 //suppose global methods per adapter ...
-func MibDbVolatileDictImpl() error {
+func mibDbVolatileDictImpl() error {
 	logger.Debug("MibVolatileDict-called")
 	return errors.New("not_implemented")
 }
 
-func AlarmDbDictImpl() error {
+/*
+func alarmDbDictImpl() error {
 	logger.Debug("AlarmDb-called")
 	return errors.New("not_implemented")
 }
+*/
diff --git a/internal/pkg/onuadaptercore/platform.go b/internal/pkg/onuadaptercore/platform.go
index 7e6469c..3430247 100644
--- a/internal/pkg/onuadaptercore/platform.go
+++ b/internal/pkg/onuadaptercore/platform.go
@@ -20,17 +20,6 @@
 //Attention: this file is more or less a coopy of file olt_platform.go from the voltha-openolt-adapter
 // which includes system wide definitions and thus normally should be stored more centrally (within some voltha libs)!!
 
-import (
-	"errors"
-
-	"github.com/opencord/voltha-lib-go/v3/pkg/flows"
-	"github.com/opencord/voltha-lib-go/v3/pkg/log"
-
-	//"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
-	ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
-	"github.com/opencord/voltha-protos/v3/go/voltha"
-)
-
 /*=====================================================================
 
 @TODO: Looks like this Flow id concept below is not used anywhere
@@ -102,75 +91,79 @@
 		// Number of bits to differentiate between UNI and NNI Logical Port
 		bitsForUNINNIDiff = 1
 	*/
-
-	//MaxOnusPerPon is Max number of ONUs on any PON port
-	MaxOnusPerPon = (1 << bitsForONUID)
-	//MaxPonsPerOlt is Max number of PON ports on any OLT
-	MaxPonsPerOlt = (1 << bitsForPONID)
-	//MaxUnisPerOnu is the Max number of UNI ports on any ONU
-	MaxUnisPerOnu = (1 << bitsForUniID)
-	//Bit position where the differentiation bit is located
-	nniUniDiffPos = (bitsForUniID + bitsForONUID + bitsForPONID)
-	//Bit position where the marker for PON port type of OF port is present
-	ponIntfMarkerPos = 28
-	//Value of marker used to distinguish PON port type of OF port
-	ponIntfMarkerValue = 0x2
-	// Number of bits for NNI ID
-	bitsforNNIID = 20
-	// minNniIntPortNum is used to store start range of nni port number (1 << 20) 1048576
-	minNniIntPortNum = (1 << bitsforNNIID)
-	// maxNniPortNum is used to store the maximum range of nni port number ((1 << 21)-1) 2097151
-	maxNniPortNum = ((1 << (bitsforNNIID + 1)) - 1)
+	//maxOnusPerPon is Max number of ONUs on any PON port
+	maxOnusPerPon = (1 << bitsForONUID)
+	//maxPonsPerOlt is Max number of PON ports on any OLT
+	maxPonsPerOlt = (1 << bitsForPONID)
+	//maxUnisPerOnu is the Max number of UNI ports on any ONU
+	maxUnisPerOnu = (1 << bitsForUniID)
+	/*
+		//Bit position where the differentiation bit is located
+		nniUniDiffPos = (bitsForUniID + bitsForONUID + bitsForPONID)
+		//Bit position where the marker for PON port type of OF port is present
+		ponIntfMarkerPos = 28
+		//Value of marker used to distinguish PON port type of OF port
+		ponIntfMarkerValue = 0x2
+		// Number of bits for NNI ID
+		bitsforNNIID = 20
+		// minNniIntPortNum is used to store start range of nni port number (1 << 20) 1048576
+		minNniIntPortNum = (1 << bitsforNNIID)
+		// maxNniPortNum is used to store the maximum range of nni port number ((1 << 21)-1) 2097151
+		maxNniPortNum = ((1 << (bitsforNNIID + 1)) - 1)
+	*/
 )
 
 //Mask to indicate which possibly active ONU UNI state  is really reported to the core
 // compare python code - at the moment restrict active state to the first ONU UNI port
 // check is limited to max 16 uni ports - cmp above UNI limit!!!
-var ActiveUniPortStateUpdateMask = 0x0001
+var activeUniPortStateUpdateMask = 0x0001
 
+/*
 //MinUpstreamPortID value
-var MinUpstreamPortID = 0xfffd
+var minUpstreamPortID = 0xfffd
 
 //MaxUpstreamPortID value
-var MaxUpstreamPortID = 0xfffffffd
+var maxUpstreamPortID = 0xfffffffd
 
 var controllerPorts = []uint32{0xfffd, 0x7ffffffd, 0xfffffffd}
+*/
 
-//MkUniPortNum returns new UNIportNum based on intfID, inuID and uniID
-func MkUniPortNum(intfID, onuID, uniID uint32) uint32 {
+//mkUniPortNum returns new UNIportNum based on intfID, inuID and uniID
+func mkUniPortNum(intfID, onuID, uniID uint32) uint32 {
 	//extended for checks available in the python onu adapter:!!
 	var limit = int(intfID)
-	if limit > MaxPonsPerOlt {
+	if limit > maxPonsPerOlt {
 		logger.Warn("Warning: exceeded the MAX pons per OLT")
 	}
 	limit = int(onuID)
-	if limit > MaxOnusPerPon {
+	if limit > maxOnusPerPon {
 		logger.Warn("Warning: exceeded the MAX ONUS per PON")
 	}
 	limit = int(uniID)
-	if limit > MaxUnisPerOnu {
+	if limit > maxUnisPerOnu {
 		logger.Warn("Warning: exceeded the MAX UNIS per ONU")
 	}
 	return (intfID << (bitsForUniID + bitsForONUID)) | (onuID << bitsForUniID) | uniID
 }
 
-//OnuIDFromPortNum returns ONUID derived from portNumber
-func OnuIDFromPortNum(portNum uint32) uint32 {
-	return (portNum >> bitsForUniID) & (MaxOnusPerPon - 1)
+/*
+//onuIDFromPortNum returns ONUID derived from portNumber
+func onuIDFromPortNum(portNum uint32) uint32 {
+	return (portNum >> bitsForUniID) & (maxOnusPerPon - 1)
 }
 
-//IntfIDFromUniPortNum returns IntfID derived from portNum
-func IntfIDFromUniPortNum(portNum uint32) uint32 {
-	return (portNum >> (bitsForUniID + bitsForONUID)) & (MaxPonsPerOlt - 1)
+//intfIDFromUniPortNum returns IntfID derived from portNum
+func intfIDFromUniPortNum(portNum uint32) uint32 {
+	return (portNum >> (bitsForUniID + bitsForONUID)) & (maxPonsPerOlt - 1)
 }
 
-//UniIDFromPortNum return UniID derived from portNum
-func UniIDFromPortNum(portNum uint32) uint32 {
-	return (portNum) & (MaxUnisPerOnu - 1)
+//uniIDFromPortNum return UniID derived from portNum
+func uniIDFromPortNum(portNum uint32) uint32 {
+	return (portNum) & (maxUnisPerOnu - 1)
 }
 
-//IntfIDToPortNo returns portId derived from intftype, intfId and portType
-func IntfIDToPortNo(intfID uint32, intfType voltha.Port_PortType) uint32 {
+//intfIDToPortNo returns portId derived from intftype, intfId and portType
+func intfIDToPortNo(intfID uint32, intfType voltha.Port_PortType) uint32 {
 	if (intfType) == voltha.Port_ETHERNET_NNI {
 		return (1 << nniUniDiffPos) | intfID
 	}
@@ -180,8 +173,8 @@
 	return 0
 }
 
-//PortNoToIntfID returns portnumber derived from interfaceID
-func PortNoToIntfID(portno uint32, intfType voltha.Port_PortType) uint32 {
+//portNoToIntfID returns portnumber derived from interfaceID
+func portNoToIntfID(portno uint32, intfType voltha.Port_PortType) uint32 {
 	if (intfType) == voltha.Port_ETHERNET_NNI {
 		return (1 << nniUniDiffPos) ^ portno
 	}
@@ -191,8 +184,8 @@
 	return 0
 }
 
-//IntfIDFromNniPortNum returns Intf ID derived from portNum
-func IntfIDFromNniPortNum(portNum uint32) (uint32, error) {
+//intfIDFromNniPortNum returns Intf ID derived from portNum
+func intfIDFromNniPortNum(portNum uint32) (uint32, error) {
 	if portNum < minNniIntPortNum || portNum > maxNniPortNum {
 		logger.Errorw("NNIPortNumber is not in valid range", log.Fields{"portNum": portNum})
 		return uint32(0), errors.New("invalid-port-range") //olterrors.ErrInvalidPortRange
@@ -200,9 +193,9 @@
 	return (portNum & 0xFFFF), nil
 }
 
-//IntfIDToPortTypeName returns port type derived from the intfId
-func IntfIDToPortTypeName(intfID uint32) voltha.Port_PortType {
-	if ((ponIntfMarkerValue << ponIntfMarkerPos) ^ intfID) < MaxPonsPerOlt {
+//intfIDToPortTypeName returns port type derived from the intfId
+func intfIDToPortTypeName(intfID uint32) voltha.Port_PortType {
+	if ((ponIntfMarkerValue << ponIntfMarkerPos) ^ intfID) < maxPonsPerOlt {
 		return voltha.Port_PON_OLT
 	}
 	if (intfID & (1 << nniUniDiffPos)) == (1 << nniUniDiffPos) {
@@ -211,16 +204,16 @@
 	return voltha.Port_ETHERNET_UNI
 }
 
-//ExtractAccessFromFlow returns AccessDevice information
-func ExtractAccessFromFlow(inPort, outPort uint32) (uint32, uint32, uint32, uint32) {
-	if IsUpstream(outPort) {
-		return inPort, IntfIDFromUniPortNum(inPort), OnuIDFromPortNum(inPort), UniIDFromPortNum(inPort)
+//extractAccessFromFlow returns AccessDevice information
+func extractAccessFromFlow(inPort, outPort uint32) (uint32, uint32, uint32, uint32) {
+	if isUpstream(outPort) {
+		return inPort, intfIDFromUniPortNum(inPort), onuIDFromPortNum(inPort), uniIDFromPortNum(inPort)
 	}
-	return outPort, IntfIDFromUniPortNum(outPort), OnuIDFromPortNum(outPort), UniIDFromPortNum(outPort)
+	return outPort, intfIDFromUniPortNum(outPort), onuIDFromPortNum(outPort), uniIDFromPortNum(outPort)
 }
 
-//IsUpstream returns true for Upstream and false for downstream
-func IsUpstream(outPort uint32) bool {
+//isUpstream returns true for Upstream and false for downstream
+func isUpstream(outPort uint32) bool {
 	for _, port := range controllerPorts {
 		if port == outPort {
 			return true
@@ -229,8 +222,8 @@
 	return (outPort & (1 << nniUniDiffPos)) == (1 << nniUniDiffPos)
 }
 
-//IsControllerBoundFlow returns true/false
-func IsControllerBoundFlow(outPort uint32) bool {
+//isControllerBoundFlow returns true/false
+func isControllerBoundFlow(outPort uint32) bool {
 	for _, port := range controllerPorts {
 		if port == outPort {
 			return true
@@ -239,13 +232,13 @@
 	return false
 }
 
-//OnuIDFromUniPortNum returns onuId from give portNum information.
-func OnuIDFromUniPortNum(portNum uint32) uint32 {
-	return (portNum >> bitsForUniID) & (MaxOnusPerPon - 1)
+//onuIDFromUniPortNum returns onuId from give portNum information.
+func onuIDFromUniPortNum(portNum uint32) uint32 {
+	return (portNum >> bitsForUniID) & (maxOnusPerPon - 1)
 }
 
-//FlowExtractInfo fetches uniport from the flow, based on which it gets and returns ponInf, onuID, uniID, inPort and ethType
-func FlowExtractInfo(flow *ofp.OfpFlowStats, flowDirection string) (uint32, uint32, uint32, uint32, uint32, uint32, error) {
+//flowExtractInfo fetches uniport from the flow, based on which it gets and returns ponInf, onuID, uniID, inPort and ethType
+func flowExtractInfo(flow *ofp.OfpFlowStats, flowDirection string) (uint32, uint32, uint32, uint32, uint32, uint32, error) {
 	var uniPortNo uint32
 	var ponIntf uint32
 	var onuID uint32
@@ -284,13 +277,13 @@
 	}
 
 	if uniPortNo == 0 {
-		return 0, 0, 0, 0, 0, 0, errors.New("NotFound: pon-interface (flowDirection)")
+		return 0, 0, 0, 0, 0, 0, errors.New("notFound: pon-interface (flowDirection)")
 		// olterrors.NewErrNotFound("pon-interface", log.Fields{"flow-direction": flowDirection}, nil)
 	}
 
-	ponIntf = IntfIDFromUniPortNum(uniPortNo)
-	onuID = OnuIDFromUniPortNum(uniPortNo)
-	uniID = UniIDFromPortNum(uniPortNo)
+	ponIntf = intfIDFromUniPortNum(uniPortNo)
+	onuID = onuIDFromUniPortNum(uniPortNo)
+	uniID = uniIDFromPortNum(uniPortNo)
 
 	logger.Debugw("flow extract info result",
 		log.Fields{"uniPortNo": uniPortNo, "ponIntf": ponIntf,
@@ -298,3 +291,4 @@
 
 	return uniPortNo, ponIntf, onuID, uniID, inPort, ethType, nil
 }
+*/
diff --git a/internal/pkg/onuadaptercore/uniportadmin.go b/internal/pkg/onuadaptercore/uniportadmin.go
index dcedd57..d196b73 100644
--- a/internal/pkg/onuadaptercore/uniportadmin.go
+++ b/internal/pkg/onuadaptercore/uniportadmin.go
@@ -32,9 +32,9 @@
 	//"github.com/opencord/voltha-protos/v3/go/voltha"
 )
 
-//LockStateFsm defines the structure for the state machine to lock/unlock the ONU UNI ports via OMCI
-type LockStateFsm struct {
-	pOmciCC                  *OmciCC
+//lockStateFsm defines the structure for the state machine to lock/unlock the ONU UNI ports via OMCI
+type lockStateFsm struct {
+	pOmciCC                  *omciCC
 	adminState               bool
 	requestEvent             OnuDeviceEvent
 	omciLockResponseReceived chan bool //seperate channel needed for checking UNI port OMCi message responses
@@ -62,10 +62,10 @@
 	uniStResetting   = "uniStResetting"
 )
 
-//NewLockStateFsm is the 'constructor' for the state machine to lock/unlock the ONU UNI ports via OMCI
-func NewLockStateFsm(apDevOmciCC *OmciCC, aAdminState bool, aRequestEvent OnuDeviceEvent,
-	aName string, aDeviceID string, aCommChannel chan Message) *LockStateFsm {
-	instFsm := &LockStateFsm{
+//newLockStateFsm is the 'constructor' for the state machine to lock/unlock the ONU UNI ports via OMCI
+func newLockStateFsm(apDevOmciCC *omciCC, aAdminState bool, aRequestEvent OnuDeviceEvent,
+	aName string, aDeviceID string, aCommChannel chan Message) *lockStateFsm {
+	instFsm := &lockStateFsm{
 		pOmciCC:      apDevOmciCC,
 		adminState:   aAdminState,
 		requestEvent: aRequestEvent,
@@ -153,13 +153,13 @@
 	return instFsm
 }
 
-//SetSuccessEvent modifies the requested event notified on success
+//setSuccessEvent modifies the requested event notified on success
 //assumption is that this is only called in the disabled (idle) state of the FSM, hence no sem protection required
-func (oFsm *LockStateFsm) SetSuccessEvent(aEvent OnuDeviceEvent) {
+func (oFsm *lockStateFsm) setSuccessEvent(aEvent OnuDeviceEvent) {
 	oFsm.requestEvent = aEvent
 }
 
-func (oFsm *LockStateFsm) enterAdminStartingState(e *fsm.Event) {
+func (oFsm *lockStateFsm) enterAdminStartingState(e *fsm.Event) {
 	logger.Debugw("LockStateFSM start", log.Fields{"in state": e.FSM.Current(),
 		"device-id": oFsm.pAdaptFsm.deviceID})
 	// in case the used channel is not yet defined (can be re-used after restarts)
@@ -175,7 +175,7 @@
 		}
 	}
 	// start go routine for processing of LockState messages
-	go oFsm.ProcessOmciLockMessages()
+	go oFsm.processOmciLockMessages()
 
 	//let the state machine run forward from here directly
 	pLockStateAFsm := oFsm.pAdaptFsm
@@ -189,7 +189,7 @@
 	}
 }
 
-func (oFsm *LockStateFsm) enterSettingOnuGState(e *fsm.Event) {
+func (oFsm *lockStateFsm) enterSettingOnuGState(e *fsm.Event) {
 	var omciAdminState uint8 = 1 //default locked
 	if !oFsm.adminState {
 		omciAdminState = 0
@@ -206,16 +206,16 @@
 	oFsm.pOmciCC.pLastTxMeInstance = meInstance
 }
 
-func (oFsm *LockStateFsm) enterSettingUnisState(e *fsm.Event) {
+func (oFsm *lockStateFsm) enterSettingUnisState(e *fsm.Event) {
 	logger.Infow("LockStateFSM - starting PPTP config loop", log.Fields{
 		"in state": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID, "LockState": oFsm.adminState})
 	go oFsm.performUniPortAdminSet()
 }
 
-func (oFsm *LockStateFsm) enterAdminDoneState(e *fsm.Event) {
+func (oFsm *lockStateFsm) enterAdminDoneState(e *fsm.Event) {
 	logger.Debugw("LockStateFSM", log.Fields{"send notification to core in State": e.FSM.Current(), "device-id": oFsm.pAdaptFsm.deviceID})
 	//use DeviceHandler event notification directly, no need/support to update DeviceEntryState for lock/unlock
-	oFsm.pOmciCC.pBaseDeviceHandler.DeviceProcStatusUpdate(oFsm.requestEvent)
+	oFsm.pOmciCC.pBaseDeviceHandler.deviceProcStatusUpdate(oFsm.requestEvent)
 	//let's reset the state machine in order to release all resources now
 	pLockStateAFsm := oFsm.pAdaptFsm
 	if pLockStateAFsm != nil {
@@ -228,7 +228,7 @@
 	}
 }
 
-func (oFsm *LockStateFsm) enterResettingState(e *fsm.Event) {
+func (oFsm *lockStateFsm) enterResettingState(e *fsm.Event) {
 	logger.Debugw("LockStateFSM resetting", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
 	pLockStateAFsm := oFsm.pAdaptFsm
 	if pLockStateAFsm != nil {
@@ -251,7 +251,7 @@
 	}
 }
 
-func (oFsm *LockStateFsm) ProcessOmciLockMessages( /*ctx context.Context*/ ) {
+func (oFsm *lockStateFsm) processOmciLockMessages( /*ctx context.Context*/ ) {
 	logger.Debugw("Start LockStateFsm Msg processing", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
 loop:
 	for {
@@ -286,7 +286,7 @@
 	logger.Infow("End LockStateFsm Msg processing", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID})
 }
 
-func (oFsm *LockStateFsm) handleOmciLockStateMessage(msg OmciMessage) {
+func (oFsm *lockStateFsm) handleOmciLockStateMessage(msg OmciMessage) {
 	logger.Debugw("Rx OMCI LockStateFsm Msg", log.Fields{"device-id": oFsm.pAdaptFsm.deviceID,
 		"msgType": msg.OmciMsg.MessageType})
 
@@ -331,7 +331,7 @@
 	}
 }
 
-func (oFsm *LockStateFsm) performUniPortAdminSet() {
+func (oFsm *lockStateFsm) performUniPortAdminSet() {
 	var omciAdminState uint8 = 1 //default locked
 	if !oFsm.adminState {
 		omciAdminState = 0
@@ -344,11 +344,11 @@
 			"device-id": oFsm.pAdaptFsm.deviceID, "for PortNo": uniNo})
 
 		var meInstance *me.ManagedEntity
-		if uniPort.portType == UniPPTP {
+		if uniPort.portType == uniPPTP {
 			meInstance = oFsm.pOmciCC.sendSetUniGLS(context.TODO(), uniPort.entityID, ConstDefaultOmciTimeout,
 				true, requestedAttributes, oFsm.pAdaptFsm.commChan)
 			oFsm.pOmciCC.pLastTxMeInstance = meInstance
-		} else if uniPort.portType == UniVEIP {
+		} else if uniPort.portType == uniVEIP {
 			meInstance = oFsm.pOmciCC.sendSetVeipLS(context.TODO(), uniPort.entityID, ConstDefaultOmciTimeout,
 				true, requestedAttributes, oFsm.pAdaptFsm.commChan)
 			oFsm.pOmciCC.pLastTxMeInstance = meInstance
@@ -373,14 +373,14 @@
 	_ = oFsm.pAdaptFsm.pFsm.Event(uniEvRxUnisResp)
 }
 
-func (oFsm *LockStateFsm) waitforOmciResponse(apMeInstance *me.ManagedEntity) error {
+func (oFsm *lockStateFsm) waitforOmciResponse(apMeInstance *me.ManagedEntity) error {
 	select {
 	// maybe be also some outside cancel (but no context modeled for the moment ...)
 	// case <-ctx.Done():
 	// 		logger.Infow("LockState-bridge-init message reception canceled", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
 	case <-time.After(30 * time.Second): //3s was detected to be to less in 8*8 bbsim test with debug Info/Debug
 		logger.Warnw("LockStateFSM uni-set timeout", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
-		return errors.New("LockStateFsm uni-set timeout")
+		return errors.New("lockStateFsm uni-set timeout")
 	case success := <-oFsm.omciLockResponseReceived:
 		if success {
 			logger.Debug("LockStateFSM uni-set response received")
@@ -388,6 +388,6 @@
 		}
 		// should not happen so far
 		logger.Warnw("LockStateFSM uni-set response error", log.Fields{"for device-id": oFsm.pAdaptFsm.deviceID})
-		return errors.New("LockStateFsm uni-set responseError")
+		return errors.New("lockStateFsm uni-set responseError")
 	}
 }