diff --git a/internal/pkg/core/common.go b/internal/pkg/core/common.go
new file mode 100644
index 0000000..88b9cab
--- /dev/null
+++ b/internal/pkg/core/common.go
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core Common Logger initialization
+package core
+
+import (
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+var logger log.CLogger
+
+func init() {
+	var err error
+	logger, err = log.RegisterPackage(log.JSON, log.ErrorLevel, log.Fields{})
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/internal/pkg/core/device_handler.go b/internal/pkg/core/device_handler.go
new file mode 100644
index 0000000..6b29558
--- /dev/null
+++ b/internal/pkg/core/device_handler.go
@@ -0,0 +1,2608 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/cenkalti/backoff/v3"
+	"github.com/gogo/protobuf/proto"
+	"github.com/golang/protobuf/ptypes"
+	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
+	grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
+	"github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
+	"github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-lib-go/v3/pkg/pmmetrics"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/core/l2oam"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	rsrcMgr "github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
+	"github.com/opencord/voltha-openolt-adapter/pkg/mocks"
+	"github.com/opencord/voltha-protos/v3/go/common"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	of "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+	"github.com/opentracing/opentracing-go"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// Constants for number of retries and for timeout
+const (
+	MaxRetry       = 10
+	MaxTimeOutInMs = 500
+	InvalidPort    = 0xffffffff
+)
+
+// pendingFlowRemoveDataKey is key to pendingFlowRemoveDataPerSubscriber map
+type pendingFlowRemoveDataKey struct {
+	intfID uint32
+	onuID  uint32
+	uniID  uint32
+}
+
+// pendingFlowRemoveData is value stored in pendingFlowRemoveDataPerSubscriber map
+// This holds the number of pending flow removes and also a signal channel to
+// to indicate the receiver when all flow removes are handled
+type pendingFlowRemoveData struct {
+	pendingFlowRemoveCount uint32
+	allFlowsRemoved        chan struct{}
+}
+
+//DeviceHandler will interact with the OLT device.
+type DeviceHandler struct {
+	device        *voltha.Device
+	coreProxy     adapterif.CoreProxy
+	AdapterProxy  adapterif.AdapterProxy
+	EventProxy    adapterif.EventProxy
+	openOLT       *OpenOLT
+	exitChannel   chan int
+	lockDevice    sync.RWMutex
+	Client        oop.OpenoltClient
+	transitionMap *TransitionMap
+	clientCon     *grpc.ClientConn
+	flowMgr       *OpenOltFlowMgr
+	eventMgr      *OpenOltEventMgr
+	resourceMgr   *rsrcMgr.OpenOltResourceMgr
+
+	discOnus                      sync.Map
+	onus                          sync.Map
+	portStats                     *OpenOltStatisticsMgr
+	metrics                       *pmmetrics.PmMetrics
+	stopCollector                 chan bool
+	stopHeartbeatCheck            chan bool
+	activePorts                   sync.Map
+	stopIndications               chan bool
+	isReadIndicationRoutineActive bool
+
+	pendingFlowRemoveDataPerSubscriber map[pendingFlowRemoveDataKey]pendingFlowRemoveData
+}
+
+//OnuDevice represents ONU related info
+type OnuDevice struct {
+	deviceID      string
+	deviceType    string
+	serialNumber  string
+	onuID         uint32
+	intfID        uint32
+	proxyDeviceID string
+	losRaised     bool
+	rdiRaised     bool
+}
+
+var pmNames = []string{
+	"rx_bytes",
+	"rx_packets",
+	"rx_mcast_packets",
+	"rx_bcast_packets",
+	"tx_bytes",
+	"tx_packets",
+	"tx_mcast_packets",
+	"tx_bcast_packets",
+}
+
+// set true if you want to disable BBSim function
+var disableBBSim bool = true
+
+//NewOnuDevice creates a new Onu Device
+func NewOnuDevice(devID, deviceTp, serialNum string, onuID, intfID uint32, proxyDevID string, losRaised bool) *OnuDevice {
+	var device OnuDevice
+	device.deviceID = devID
+	device.deviceType = deviceTp
+	device.serialNumber = serialNum
+	device.onuID = onuID
+	device.intfID = intfID
+	device.proxyDeviceID = proxyDevID
+	device.losRaised = losRaised
+	return &device
+}
+
+//NewDeviceHandler creates a new device handler
+func NewDeviceHandler(cp adapterif.CoreProxy, ap adapterif.AdapterProxy, ep adapterif.EventProxy, device *voltha.Device, adapter *OpenOLT) *DeviceHandler {
+	var dh DeviceHandler
+	dh.coreProxy = cp
+	dh.AdapterProxy = ap
+	dh.EventProxy = ep
+	cloned := (proto.Clone(device)).(*voltha.Device)
+	dh.device = cloned
+	dh.openOLT = adapter
+	dh.exitChannel = make(chan int, 1)
+	dh.lockDevice = sync.RWMutex{}
+	dh.stopCollector = make(chan bool, 2)
+	dh.stopHeartbeatCheck = make(chan bool, 2)
+	dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
+	dh.activePorts = sync.Map{}
+	dh.stopIndications = make(chan bool, 1)
+	dh.pendingFlowRemoveDataPerSubscriber = make(map[pendingFlowRemoveDataKey]pendingFlowRemoveData)
+
+	if dh.openOLT.config != nil {
+		NewL2oamHandle(context.Background(), dh.openOLT.config.InterfaceName, dh.openOLT.config.SrcMac)
+	}
+
+	return &dh
+}
+
+// start save the device to the data model
+func (dh *DeviceHandler) start(ctx context.Context) {
+	dh.lockDevice.Lock()
+	defer dh.lockDevice.Unlock()
+	logger.Debugw(ctx, "starting-device-agent", log.Fields{"device": dh.device})
+	logger.Debug(ctx, "device-agent-started")
+}
+
+// stop stops the device dh.  Not much to do for now
+func (dh *DeviceHandler) stop(ctx context.Context) {
+	dh.lockDevice.Lock()
+	defer dh.lockDevice.Unlock()
+	logger.Debug(ctx, "stopping-device-agent")
+	dh.exitChannel <- 1
+	logger.Debug(ctx, "device-agent-stopped")
+}
+
+func macifyIP(ip net.IP) string {
+	if len(ip) > 0 {
+		oct1 := strconv.FormatInt(int64(ip[12]), 16)
+		oct2 := strconv.FormatInt(int64(ip[13]), 16)
+		oct3 := strconv.FormatInt(int64(ip[14]), 16)
+		oct4 := strconv.FormatInt(int64(ip[15]), 16)
+		return fmt.Sprintf("00:00:%02v:%02v:%02v:%02v", oct1, oct2, oct3, oct4)
+	}
+	return ""
+}
+
+func generateMacFromHost(ctx context.Context, host string) (string, error) {
+	var genmac string
+	var addr net.IP
+	var ips []string
+	var err error
+
+	logger.Debugw(ctx, "generating-mac-from-host", log.Fields{"host": host})
+
+	if addr = net.ParseIP(host); addr == nil {
+		logger.Debugw(ctx, "looking-up-hostname", log.Fields{"host": host})
+
+		if ips, err = net.LookupHost(host); err == nil {
+			logger.Debugw(ctx, "dns-result-ips", log.Fields{"ips": ips})
+			if addr = net.ParseIP(ips[0]); addr == nil {
+				return "", olterrors.NewErrInvalidValue(log.Fields{"ip": ips[0]}, nil)
+			}
+			genmac = macifyIP(addr)
+			logger.Debugw(ctx, "using-ip-as-mac",
+				log.Fields{"host": ips[0],
+					"mac": genmac})
+			return genmac, nil
+		}
+		return "", olterrors.NewErrAdapter("cannot-resolve-hostname-to-ip", log.Fields{"host": host}, err)
+	}
+
+	genmac = macifyIP(addr)
+	logger.Debugw(ctx, "using-ip-as-mac",
+		log.Fields{"host": host,
+			"mac": genmac})
+	return genmac, nil
+}
+
+func macAddressToUint32Array(mac string) []uint32 {
+	slist := strings.Split(mac, ":")
+	result := make([]uint32, len(slist))
+	var err error
+	var tmp int64
+	for index, val := range slist {
+		if tmp, err = strconv.ParseInt(val, 16, 32); err != nil {
+			return []uint32{1, 2, 3, 4, 5, 6}
+		}
+		result[index] = uint32(tmp)
+	}
+	return result
+}
+
+//GetportLabel returns the label for the NNI and the PON port based on port number and port type
+func GetportLabel(portNum uint32, portType voltha.Port_PortType) (string, error) {
+
+	switch portType {
+	case voltha.Port_ETHERNET_NNI:
+		return fmt.Sprintf("nni-%d", portNum), nil
+	case voltha.Port_PON_OLT:
+		return fmt.Sprintf("pon-%d", portNum), nil
+	}
+
+	return "", olterrors.NewErrInvalidValue(log.Fields{"port-type": portType}, nil)
+}
+
+func (dh *DeviceHandler) addPort(ctx context.Context, intfID uint32, portType voltha.Port_PortType, state string) error {
+	var operStatus common.OperStatus_Types
+	if state == "up" {
+		operStatus = voltha.OperStatus_ACTIVE
+		//populating the intfStatus map
+		dh.activePorts.Store(intfID, true)
+	} else {
+		operStatus = voltha.OperStatus_DISCOVERED
+		dh.activePorts.Store(intfID, false)
+	}
+	portNum := IntfIDToPortNo(intfID, portType)
+	label, err := GetportLabel(portNum, portType)
+	if err != nil {
+		return olterrors.NewErrNotFound("port-label", log.Fields{"port-number": portNum, "port-type": portType}, err)
+	}
+
+	if port, err := dh.coreProxy.GetDevicePort(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, portNum); err == nil && port.Type == portType {
+		logger.Debug(ctx, "port-already-exists-updating-oper-status-of-port")
+		if err := dh.coreProxy.PortStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, portType, portNum, operStatus); err != nil {
+			return olterrors.NewErrAdapter("failed-to-update-port-state", log.Fields{
+				"device-id":   dh.device.Id,
+				"port-type":   portType,
+				"port-number": portNum,
+				"oper-status": operStatus}, err).Log()
+		}
+		return nil
+	}
+	capacity := uint32(of.OfpPortFeatures_OFPPF_1GB_FD | of.OfpPortFeatures_OFPPF_FIBER)
+	port := &voltha.Port{
+		PortNo:     portNum,
+		Label:      label,
+		Type:       portType,
+		OperStatus: operStatus,
+		OfpPort: &of.OfpPort{
+			HwAddr:     macAddressToUint32Array(dh.device.MacAddress),
+			Config:     0,
+			State:      uint32(of.OfpPortState_OFPPS_LIVE),
+			Curr:       capacity,
+			Advertised: capacity,
+			Peer:       capacity,
+			CurrSpeed:  uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
+			MaxSpeed:   uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
+		},
+	}
+	logger.Debugw(ctx, "sending-port-update-to-core", log.Fields{"port": port})
+	if err := dh.coreProxy.PortCreated(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, port); err != nil {
+		return olterrors.NewErrAdapter("error-creating-port", log.Fields{
+			"device-id": dh.device.Id,
+			"port-type": portType}, err)
+	}
+	go dh.updateLocalDevice(ctx)
+	return nil
+}
+
+func (dh *DeviceHandler) updateLocalDevice(ctx context.Context) {
+	dh.lockDevice.Lock()
+	defer dh.lockDevice.Unlock()
+	device, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, dh.device.Id)
+	if err != nil || device == nil {
+		logger.Errorf(ctx, "device-not-found", log.Fields{"device-id": dh.device.Id}, err)
+		return
+	}
+	dh.device = device
+}
+
+// nolint: gocyclo
+// readIndications to read the indications from the OLT device
+func (dh *DeviceHandler) readIndications(ctx context.Context) error {
+	defer logger.Debugw(ctx, "indications-ended", log.Fields{"device-id": dh.device.Id})
+	defer func() {
+		dh.lockDevice.Lock()
+		dh.isReadIndicationRoutineActive = false
+		dh.lockDevice.Unlock()
+	}()
+	indications, err := dh.startOpenOltIndicationStream(ctx)
+	if err != nil {
+		return err
+	}
+	if disableBBSim {
+		return nil
+	}
+	/* get device state */
+	device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
+	if err != nil || device == nil {
+		/*TODO: needs to handle error scenarios */
+		return olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err)
+	}
+
+	indicationBackoff := backoff.NewExponentialBackOff()
+	indicationBackoff.MaxElapsedTime = 0
+	indicationBackoff.MaxInterval = 1 * time.Minute
+
+	dh.lockDevice.Lock()
+	dh.isReadIndicationRoutineActive = true
+	dh.lockDevice.Unlock()
+
+Loop:
+	for {
+		select {
+		case <-dh.stopIndications:
+			logger.Debugw(ctx, "stopping-collecting-indications-for-olt", log.Fields{"deviceID:": dh.device.Id})
+			break Loop
+		default:
+			indication, err := indications.Recv()
+			if err == io.EOF {
+				logger.Infow(ctx, "eof-for-indications",
+					log.Fields{"err": err,
+						"device-id": dh.device.Id})
+				// Use an exponential back off to prevent getting into a tight loop
+				duration := indicationBackoff.NextBackOff()
+				if duration == backoff.Stop {
+					// If we reach a maximum then warn and reset the backoff
+					// timer and keep attempting.
+					logger.Warnw(ctx, "maximum-indication-backoff-reached--resetting-backoff-timer",
+						log.Fields{"max-indication-backoff": indicationBackoff.MaxElapsedTime,
+							"device-id": dh.device.Id})
+					indicationBackoff.Reset()
+				}
+
+				// On failure process a backoff timer while watching for stopIndications
+				// events
+				backoff := time.NewTimer(indicationBackoff.NextBackOff())
+				select {
+				case <-dh.stopIndications:
+					logger.Debugw(ctx, "stopping-collecting-indications-for-olt", log.Fields{"deviceID:": dh.device.Id})
+					if !backoff.Stop() {
+						<-backoff.C
+					}
+					break Loop
+				case <-backoff.C:
+					// backoff expired continue
+				}
+				if indications, err = dh.startOpenOltIndicationStream(ctx); err != nil {
+					return err
+				}
+				continue
+			}
+			if err != nil {
+				logger.Errorw(ctx, "read-indication-error",
+					log.Fields{"err": err,
+						"device-id": dh.device.Id})
+				if device.AdminState == voltha.AdminState_DELETED {
+					logger.Debug(ctx, "device-deleted--stopping-the-read-indication-thread")
+					break Loop
+				}
+				// Close the stream, and re-initialize it
+				if err = indications.CloseSend(); err != nil {
+					// Ok to ignore here, because we landed here due to a problem on the stream
+					// In all probability, the closeSend call may fail
+					logger.Debugw(ctx, "error-closing-send stream--error-ignored",
+						log.Fields{"err": err,
+							"device-id": dh.device.Id})
+				}
+				if indications, err = dh.startOpenOltIndicationStream(ctx); err != nil {
+					return err
+				}
+				// once we re-initialized the indication stream, continue to read indications
+				continue
+			}
+			// Reset backoff if we have a successful receive
+			indicationBackoff.Reset()
+			// When OLT is admin down, ignore all indications.
+			if device.AdminState == voltha.AdminState_DISABLED && !isIndicationAllowedDuringOltAdminDown(indication) {
+				logger.Debugw(ctx, "olt-is-admin-down, ignore indication",
+					log.Fields{"indication": indication,
+						"device-id": dh.device.Id})
+				continue
+			}
+			dh.handleIndication(ctx, indication)
+		}
+	}
+	_ = indications.CloseSend() // Ok to ignore error, as we stopping the readIndication anyway
+
+	return nil
+}
+
+func (dh *DeviceHandler) startOpenOltIndicationStream(ctx context.Context) (oop.Openolt_EnableIndicationClient, error) {
+	L2oamEnableIndication(ctx, dh)
+
+	indications, err := dh.Client.EnableIndication(ctx, new(oop.Empty))
+	if err != nil {
+		return nil, olterrors.NewErrCommunication("indication-read-failure", log.Fields{"device-id": dh.device.Id}, err).Log()
+	}
+	if indications == nil {
+		return nil, olterrors.NewErrInvalidValue(log.Fields{"indications": nil, "device-id": dh.device.Id}, nil).Log()
+	}
+
+	return indications, nil
+}
+
+// isIndicationAllowedDuringOltAdminDown returns true if the indication is allowed during OLT Admin down, else false
+func isIndicationAllowedDuringOltAdminDown(indication *oop.Indication) bool {
+	switch indication.Data.(type) {
+	case *oop.Indication_OltInd, *oop.Indication_IntfInd, *oop.Indication_IntfOperInd:
+		return true
+
+	default:
+		return false
+	}
+}
+
+func (dh *DeviceHandler) handleOltIndication(ctx context.Context, oltIndication *oop.OltIndication) error {
+	raisedTs := time.Now().UnixNano()
+	if oltIndication.OperState == "up" && dh.transitionMap.currentDeviceState != deviceStateUp {
+		dh.transitionMap.Handle(ctx, DeviceUpInd)
+	} else if oltIndication.OperState == "down" {
+		dh.transitionMap.Handle(ctx, DeviceDownInd)
+	}
+	if err := dh.eventMgr.oltUpDownIndication(ctx, oltIndication, dh.device.Id, raisedTs); err != nil {
+		return olterrors.NewErrAdapter("failed-indication", log.Fields{
+			"device_id":  dh.device.Id,
+			"indication": oltIndication,
+			"timestamp":  raisedTs}, err)
+	}
+	return nil
+}
+
+// nolint: gocyclo
+func (dh *DeviceHandler) handleIndication(ctx context.Context, indication *oop.Indication) {
+	raisedTs := time.Now().UnixNano()
+	switch indication.Data.(type) {
+	case *oop.Indication_OltInd:
+		span, ctx := log.CreateChildSpan(ctx, "olt-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		if err := dh.handleOltIndication(ctx, indication.GetOltInd()); err != nil {
+			_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "olt", "device-id": dh.device.Id}, err).Log()
+		}
+	case *oop.Indication_IntfInd:
+		span, ctx := log.CreateChildSpan(ctx, "interface-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		intfInd := indication.GetIntfInd()
+		go func() {
+			if err := dh.addPort(ctx, intfInd.GetIntfId(), voltha.Port_PON_OLT, intfInd.GetOperState()); err != nil {
+				_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface", "device-id": dh.device.Id}, err).Log()
+			}
+		}()
+		logger.Infow(ctx, "received-interface-indication", log.Fields{"InterfaceInd": intfInd, "device-id": dh.device.Id})
+	case *oop.Indication_IntfOperInd:
+		span, ctx := log.CreateChildSpan(ctx, "interface-oper-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		intfOperInd := indication.GetIntfOperInd()
+		if intfOperInd.GetType() == "nni" {
+			go func() {
+				if err := dh.addPort(ctx, intfOperInd.GetIntfId(), voltha.Port_ETHERNET_NNI, intfOperInd.GetOperState()); err != nil {
+					_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface-oper-nni", "device-id": dh.device.Id}, err).Log()
+				}
+			}()
+			if err := dh.resourceMgr.AddNNIToKVStore(ctx, intfOperInd.GetIntfId()); err != nil {
+				logger.Warn(ctx, err)
+			}
+		} else if intfOperInd.GetType() == "pon" {
+			// TODO: Check what needs to be handled here for When PON PORT down, ONU will be down
+			// Handle pon port update
+			go func() {
+				if err := dh.addPort(ctx, intfOperInd.GetIntfId(), voltha.Port_PON_OLT, intfOperInd.GetOperState()); err != nil {
+					_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface-oper-pon", "device-id": dh.device.Id}, err).Log()
+				}
+			}()
+			go dh.eventMgr.oltIntfOperIndication(ctx, indication.GetIntfOperInd(), dh.device.Id, raisedTs)
+		}
+		logger.Infow(ctx, "received-interface-oper-indication",
+			log.Fields{"interfaceOperInd": intfOperInd,
+				"device-id": dh.device.Id})
+	case *oop.Indication_OnuDiscInd:
+		span, ctx := log.CreateChildSpan(ctx, "onu-discovery-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		onuDiscInd := indication.GetOnuDiscInd()
+		logger.Infow(ctx, "received-onu-discovery-indication", log.Fields{"OnuDiscInd": onuDiscInd, "device-id": dh.device.Id})
+		sn := dh.stringifySerialNumber(onuDiscInd.SerialNumber)
+		go func() {
+			if err := dh.onuDiscIndication(ctx, onuDiscInd, sn); err != nil {
+				_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "onu-discovery", "device-id": dh.device.Id}, err).Log()
+			}
+		}()
+	case *oop.Indication_OnuInd:
+		span, ctx := log.CreateChildSpan(ctx, "onu-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		onuInd := indication.GetOnuInd()
+		logger.Infow(ctx, "received-onu-indication", log.Fields{"OnuInd": onuInd, "device-id": dh.device.Id})
+		go func() {
+			if err := dh.onuIndication(ctx, onuInd); err != nil {
+				_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "onu", "device-id": dh.device.Id}, err).Log()
+			}
+		}()
+	case *oop.Indication_OmciInd:
+		span, ctx := log.CreateChildSpan(ctx, "omci-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		omciInd := indication.GetOmciInd()
+		logger.Debugw(ctx, "received-omci-indication", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
+		go func() {
+			if err := dh.omciIndication(ctx, omciInd); err != nil {
+				_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "omci", "device-id": dh.device.Id}, err).Log()
+			}
+		}()
+	case *oop.Indication_PktInd:
+		span, ctx := log.CreateChildSpan(ctx, "packet-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		pktInd := indication.GetPktInd()
+		logger.Debugw(ctx, "received-packet-indication", log.Fields{
+			"intf-type":   pktInd.IntfId,
+			"intf-id":     pktInd.IntfId,
+			"gem-port-id": pktInd.GemportId,
+			"port-no":     pktInd.PortNo,
+			"device-id":   dh.device.Id,
+		})
+
+		if logger.V(log.DebugLevel) {
+			logger.Debugw(ctx, "received-packet-indication-packet", log.Fields{
+				"intf-type":   pktInd.IntfId,
+				"intf-id":     pktInd.IntfId,
+				"gem-port-id": pktInd.GemportId,
+				"port-no":     pktInd.PortNo,
+				"packet":      hex.EncodeToString(pktInd.Pkt),
+				"device-id":   dh.device.Id,
+			})
+		}
+
+		go func() {
+			if err := dh.handlePacketIndication(ctx, pktInd); err != nil {
+				_ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "packet", "device-id": dh.device.Id}, err).Log()
+			}
+		}()
+	case *oop.Indication_PortStats:
+		span, ctx := log.CreateChildSpan(ctx, "port-statistics-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		portStats := indication.GetPortStats()
+		go dh.portStats.PortStatisticsIndication(ctx, portStats, dh.resourceMgr.DevInfo.GetPonPorts())
+	case *oop.Indication_FlowStats:
+		span, ctx := log.CreateChildSpan(ctx, "flow-stats-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		flowStats := indication.GetFlowStats()
+		logger.Infow(ctx, "received-flow-stats", log.Fields{"FlowStats": flowStats, "device-id": dh.device.Id})
+	case *oop.Indication_AlarmInd:
+		span, ctx := log.CreateChildSpan(ctx, "alarm-indication", log.Fields{"device-id": dh.device.Id})
+		defer span.Finish()
+
+		alarmInd := indication.GetAlarmInd()
+		logger.Infow(ctx, "received-alarm-indication", log.Fields{"AlarmInd": alarmInd, "device-id": dh.device.Id})
+		go dh.eventMgr.ProcessEvents(ctx, alarmInd, dh.device.Id, raisedTs)
+	}
+}
+
+// doStateUp handle the olt up indication and update to voltha core
+func (dh *DeviceHandler) doStateUp(ctx context.Context) error {
+	go startCollector(ctx, dh)
+
+	if err := dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_REACHABLE,
+		voltha.OperStatus_ACTIVE); err != nil {
+		return olterrors.NewErrAdapter("device-update-failed", log.Fields{"device-id": dh.device.Id}, err)
+	}
+	return nil
+}
+
+// doStateDown handle the olt down indication
+func (dh *DeviceHandler) doStateDown(ctx context.Context) error {
+	dh.lockDevice.Lock()
+	defer dh.lockDevice.Unlock()
+	logger.Debugw(ctx, "do-state-down-start", log.Fields{"device-id": dh.device.Id})
+
+	device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
+	if err != nil || device == nil {
+		/*TODO: needs to handle error scenarios */
+		return olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err)
+	}
+
+	cloned := proto.Clone(device).(*voltha.Device)
+
+	cloned.OperStatus = voltha.OperStatus_UNKNOWN
+	dh.device = cloned
+
+	if err = dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
+		return olterrors.NewErrAdapter("state-update-failed", log.Fields{"device-id": device.Id}, err)
+	}
+
+	onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
+	if err != nil {
+		return olterrors.NewErrAdapter("child-device-fetch-failed", log.Fields{"device-id": dh.device.Id}, err)
+	}
+	for _, onuDevice := range onuDevices.Items {
+
+		// Update onu state as down in onu adapter
+		onuInd := oop.OnuIndication{}
+		onuInd.OperState = "down"
+		err := dh.AdapterProxy.SendInterAdapterMessage(ctx, &onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
+			"openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
+		if err != nil {
+			_ = olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
+				"source":        "openolt",
+				"onu-indicator": onuInd,
+				"device-type":   onuDevice.Type,
+				"device-id":     onuDevice.Id}, err).LogAt(log.ErrorLevel)
+			//Do not return here and continue to process other ONUs
+		}
+	}
+	/* Discovered ONUs entries need to be cleared , since after OLT
+	   is up, it starts sending discovery indications again*/
+	dh.discOnus = sync.Map{}
+	logger.Debugw(ctx, "do-state-down-end", log.Fields{"device-id": device.Id})
+	return nil
+}
+
+// doStateInit dial the grpc before going to init state
+func (dh *DeviceHandler) doStateInit(ctx context.Context) error {
+	if disableBBSim {
+		return nil
+	}
+	var err error
+	dh.clientCon, err = grpc.Dial(dh.device.GetHostAndPort(),
+		grpc.WithInsecure(),
+		grpc.WithBlock(),
+		grpc.WithStreamInterceptor(grpc_middleware.ChainStreamClient(
+			grpc_opentracing.StreamClientInterceptor(grpc_opentracing.WithTracer(opentracing.GlobalTracer())),
+		)),
+		grpc.WithUnaryInterceptor(grpc_middleware.ChainUnaryClient(
+			grpc_opentracing.UnaryClientInterceptor(grpc_opentracing.WithTracer(opentracing.GlobalTracer())),
+		)))
+
+	if err != nil {
+		return olterrors.NewErrCommunication("dial-failure", log.Fields{
+			"device-id":     dh.device.Id,
+			"host-and-port": dh.device.GetHostAndPort()}, err)
+	}
+	return nil
+}
+
+// postInit create olt client instance to invoke RPC on the olt device
+func (dh *DeviceHandler) postInit(ctx context.Context) error {
+	if disableBBSim {
+		dh.Client = &mocks.MockOpenoltClient{}
+	} else {
+		dh.Client = oop.NewOpenoltClient(dh.clientCon)
+	}
+	dh.transitionMap.Handle(ctx, GrpcConnected)
+	return nil
+}
+
+// doStateConnected get the device info and update to voltha core
+func (dh *DeviceHandler) doStateConnected(ctx context.Context) error {
+	var err error
+	logger.Debugw(ctx, "olt-device-connected", log.Fields{"device-id": dh.device.Id})
+
+	device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
+	if err != nil || device == nil {
+		/*TODO: needs to handle error scenarios */
+		return olterrors.NewErrAdapter("device-fetch-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+	}
+	if device.AdminState == voltha.AdminState_DISABLED {
+		logger.Debugln(ctx, "do-state-connected--device-admin-state-down")
+
+		cloned := proto.Clone(device).(*voltha.Device)
+		cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
+		cloned.OperStatus = voltha.OperStatus_UNKNOWN
+		dh.device = cloned
+		if err = dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
+			return olterrors.NewErrAdapter("device-state-update-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+		}
+
+		// Since the device was disabled before the OLT was rebooted, enforce the OLT to be Disabled after re-connection.
+		_, err = dh.Client.DisableOlt(ctx, new(oop.Empty))
+		if err != nil {
+			return olterrors.NewErrAdapter("olt-disable-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+		}
+		// We should still go ahead an initialize various device handler modules so that when OLT is re-enabled, we have
+		// all the modules initialized and ready to handle incoming ONUs.
+
+		err = dh.initializeDeviceHandlerModules(ctx)
+		if err != nil {
+			return olterrors.NewErrAdapter("device-handler-initialization-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+		}
+
+		// Start reading indications
+		go func() {
+			if err = dh.readIndications(ctx); err != nil {
+				_ = olterrors.NewErrAdapter("indication-read-failure", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+			}
+		}()
+		return nil
+	}
+
+	ports, err := dh.coreProxy.ListDevicePorts(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id)
+	if err != nil {
+		/*TODO: needs to handle error scenarios */
+		return olterrors.NewErrAdapter("fetch-ports-failed", log.Fields{"device-id": dh.device.Id}, err)
+	}
+	dh.populateActivePorts(ctx, ports)
+	if err := dh.disableAdminDownPorts(ctx, ports); err != nil {
+		return olterrors.NewErrAdapter("port-status-update-failed", log.Fields{"ports": ports}, err)
+	}
+
+	if err := dh.initializeDeviceHandlerModules(ctx); err != nil {
+		return olterrors.NewErrAdapter("device-handler-initialization-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+	}
+
+	go func() {
+		if err := dh.readIndications(ctx); err != nil {
+			_ = olterrors.NewErrAdapter("read-indications-failure", log.Fields{"device-id": dh.device.Id}, err).Log()
+		}
+	}()
+	go dh.updateLocalDevice(ctx)
+
+	if device.PmConfigs != nil {
+		dh.UpdatePmConfig(ctx, device.PmConfigs)
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) initializeDeviceHandlerModules(ctx context.Context) error {
+	deviceInfo, err := dh.populateDeviceInfo(ctx)
+
+	if err != nil {
+		return olterrors.NewErrAdapter("populate-device-info-failed", log.Fields{"device-id": dh.device.Id}, err)
+	}
+	if dh.resourceMgr = rsrcMgr.NewResourceMgr(ctx, dh.device.Id, dh.openOLT.KVStoreAddress, dh.openOLT.KVStoreType, dh.device.Type, deviceInfo); dh.resourceMgr == nil {
+		return olterrors.ErrResourceManagerInstantiating
+	}
+
+	if dh.flowMgr = NewFlowManager(ctx, dh, dh.resourceMgr); dh.flowMgr == nil {
+		return olterrors.ErrResourceManagerInstantiating
+
+	}
+	/* TODO: Instantiate Alarm , stats , BW managers */
+	/* Instantiating Event Manager to handle Alarms and KPIs */
+	dh.eventMgr = NewEventMgr(dh.EventProxy, dh)
+
+	dh.portStats = NewOpenOltStatsMgr(ctx, dh)
+
+	return nil
+
+}
+
+func (dh *DeviceHandler) populateDeviceInfo(ctx context.Context) (*oop.DeviceInfo, error) {
+	var err error
+	var deviceInfo *oop.DeviceInfo
+
+	if disableBBSim {
+		deviceInfo, err = L2oamGetDeviceInfo(log.WithSpanFromContext(context.Background(), ctx), dh)
+	} else {
+		deviceInfo, err = dh.Client.GetDeviceInfo(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty))
+	}
+
+	if err != nil {
+		return nil, olterrors.NewErrPersistence("get", "device", 0, nil, err)
+	}
+	if deviceInfo == nil {
+		return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
+	}
+
+	logger.Debugw(ctx, "fetched-device-info", log.Fields{"deviceInfo": deviceInfo, "device-id": dh.device.Id})
+	dh.device.Root = true
+	dh.device.Vendor = deviceInfo.Vendor
+	dh.device.Model = deviceInfo.Model
+	dh.device.SerialNumber = deviceInfo.DeviceSerialNumber
+	dh.device.HardwareVersion = deviceInfo.HardwareVersion
+	dh.device.FirmwareVersion = deviceInfo.FirmwareVersion
+
+	if deviceInfo.DeviceId == "" {
+		logger.Warnw(ctx, "no-device-id-provided-using-host", log.Fields{"hostport": dh.device.GetHostAndPort()})
+		host := strings.Split(dh.device.GetHostAndPort(), ":")[0]
+		genmac, err := generateMacFromHost(ctx, host)
+		if err != nil {
+			return nil, olterrors.NewErrAdapter("failed-to-generate-mac-host", log.Fields{"host": host}, err)
+		}
+		logger.Debugw(ctx, "using-host-for-mac-address", log.Fields{"host": host, "mac": genmac})
+		dh.device.MacAddress = genmac
+	} else {
+		dh.device.MacAddress = deviceInfo.DeviceId
+	}
+
+	if err := dh.coreProxy.DeviceUpdate(log.WithSpanFromContext(context.TODO(), ctx), dh.device); err != nil {
+		return nil, olterrors.NewErrAdapter("device-update-failed", log.Fields{"device-id": dh.device.Id}, err)
+	}
+
+	return deviceInfo, nil
+}
+
+func startCollector(ctx context.Context, dh *DeviceHandler) {
+	logger.Debugf(ctx, "starting-collector")
+	for {
+		select {
+		case <-dh.stopCollector:
+			logger.Debugw(ctx, "stopping-collector-for-olt", log.Fields{"deviceID:": dh.device.Id})
+			return
+		case <-time.After(time.Duration(dh.metrics.ToPmConfigs().DefaultFreq) * time.Second):
+
+			ports, err := dh.coreProxy.ListDevicePorts(log.WithSpanFromContext(context.Background(), ctx), dh.device.Id)
+			if err != nil {
+				logger.Warnw(ctx, "failed-to-list-ports", log.Fields{"device-id": dh.device.Id, "error": err})
+				continue
+			}
+			for _, port := range ports {
+				// NNI Stats
+				if port.Type == voltha.Port_ETHERNET_NNI {
+					intfID := PortNoToIntfID(port.PortNo, voltha.Port_ETHERNET_NNI)
+					cmnni := dh.portStats.collectNNIMetrics(intfID)
+					logger.Debugw(ctx, "collect-nni-metrics", log.Fields{"metrics": cmnni})
+					go dh.portStats.publishMetrics(ctx, cmnni, port, dh.device.Id, dh.device.Type)
+					logger.Debugw(ctx, "publish-nni-metrics", log.Fields{"nni-port": port.Label})
+				}
+				// PON Stats
+				if port.Type == voltha.Port_PON_OLT {
+					intfID := PortNoToIntfID(port.PortNo, voltha.Port_PON_OLT)
+					if val, ok := dh.activePorts.Load(intfID); ok && val == true {
+						cmpon := dh.portStats.collectPONMetrics(intfID)
+						logger.Debugw(ctx, "collect-pon-metrics", log.Fields{"metrics": cmpon})
+						go dh.portStats.publishMetrics(ctx, cmpon, port, dh.device.Id, dh.device.Type)
+					}
+					logger.Debugw(ctx, "publish-pon-metrics", log.Fields{"pon-port": port.Label})
+				}
+			}
+		}
+	}
+}
+
+//AdoptDevice adopts the OLT device
+func (dh *DeviceHandler) AdoptDevice(ctx context.Context, device *voltha.Device) {
+	dh.transitionMap = NewTransitionMap(dh)
+	logger.Infow(ctx, "adopt-device", log.Fields{"device-id": device.Id, "Address": device.GetHostAndPort()})
+	dh.transitionMap.Handle(ctx, DeviceInit)
+
+	if err := dh.coreProxy.DevicePMConfigUpdate(ctx, dh.metrics.ToPmConfigs()); err != nil {
+		_ = olterrors.NewErrAdapter("error-updating-performance-metrics", log.Fields{"device-id": device.Id}, err).LogAt(log.ErrorLevel)
+	}
+
+	go startHeartbeatCheck(ctx, dh)
+}
+
+//GetOfpDeviceInfo Gets the Ofp information of the given device
+func (dh *DeviceHandler) GetOfpDeviceInfo(device *voltha.Device) (*ic.SwitchCapability, error) {
+	return &ic.SwitchCapability{
+		Desc: &of.OfpDesc{
+			MfrDesc:   "VOLTHA Project",
+			HwDesc:    "open_pon",
+			SwDesc:    "open_pon",
+			SerialNum: dh.device.SerialNumber,
+		},
+		SwitchFeatures: &of.OfpSwitchFeatures{
+			NBuffers: 256,
+			NTables:  2,
+			Capabilities: uint32(of.OfpCapabilities_OFPC_FLOW_STATS |
+				of.OfpCapabilities_OFPC_TABLE_STATS |
+				of.OfpCapabilities_OFPC_PORT_STATS |
+				of.OfpCapabilities_OFPC_GROUP_STATS),
+		},
+	}, nil
+}
+
+func (dh *DeviceHandler) omciIndication(ctx context.Context, omciInd *oop.OmciIndication) error {
+	logger.Debugw(ctx, "omci-indication", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
+	var deviceType string
+	var deviceID string
+	var proxyDeviceID string
+
+	transid := extractOmciTransactionID(omciInd.Pkt)
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "recv-omci-msg", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id,
+			"omci-transaction-id": transid, "omci-msg": hex.EncodeToString(omciInd.Pkt)})
+	}
+
+	onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
+
+	if onuInCache, ok := dh.onus.Load(onuKey); !ok {
+
+		logger.Debugw(ctx, "omci-indication-for-a-device-not-in-cache.", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
+		ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
+		kwargs := make(map[string]interface{})
+		kwargs["onu_id"] = omciInd.OnuId
+		kwargs["parent_port_no"] = ponPort
+
+		onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
+		if err != nil {
+			return olterrors.NewErrNotFound("onu", log.Fields{
+				"intf-id": omciInd.IntfId,
+				"onu-id":  omciInd.OnuId}, err)
+		}
+		deviceType = onuDevice.Type
+		deviceID = onuDevice.Id
+		proxyDeviceID = onuDevice.ProxyAddress.DeviceId
+		//if not exist in cache, then add to cache.
+		dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID, false))
+	} else {
+		//found in cache
+		logger.Debugw(ctx, "omci-indication-for-a-device-in-cache.", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
+		deviceType = onuInCache.(*OnuDevice).deviceType
+		deviceID = onuInCache.(*OnuDevice).deviceID
+		proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
+	}
+
+	omciMsg := &ic.InterAdapterOmciMessage{Message: omciInd.Pkt}
+	if err := dh.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx), omciMsg,
+		ic.InterAdapterMessageType_OMCI_REQUEST, dh.device.Type, deviceType,
+		deviceID, proxyDeviceID, ""); err != nil {
+		return olterrors.NewErrCommunication("omci-request", log.Fields{
+			"source":          dh.device.Type,
+			"destination":     deviceType,
+			"onu-id":          deviceID,
+			"proxy-device-id": proxyDeviceID}, err)
+	}
+	return nil
+}
+
+//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(ctx context.Context, msg *ic.InterAdapterMessage) error {
+	logger.Debugw(ctx, "process-inter-adapter-message", log.Fields{"msgID": msg.Header.Id})
+	if msg.Header.Type == ic.InterAdapterMessageType_OMCI_REQUEST {
+		msgID := msg.Header.Id
+		fromTopic := msg.Header.FromTopic
+		toTopic := msg.Header.ToTopic
+		toDeviceID := msg.Header.ToDeviceId
+		proxyDeviceID := msg.Header.ProxyDeviceId
+
+		logger.Debugw(ctx, "omci-request-message-header", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
+
+		msgBody := msg.GetBody()
+
+		omciMsg := &ic.InterAdapterOmciMessage{}
+		if err := ptypes.UnmarshalAny(msgBody, omciMsg); err != nil {
+			return olterrors.NewErrAdapter("cannot-unmarshal-omci-msg-body", log.Fields{"msgbody": msgBody}, err)
+		}
+
+		if omciMsg.GetProxyAddress() == nil {
+			onuDevice, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, toDeviceID)
+			if err != nil {
+				return olterrors.NewErrNotFound("onu", log.Fields{
+					"device-id":     dh.device.Id,
+					"onu-device-id": toDeviceID}, err)
+			}
+			logger.Debugw(ctx, "device-retrieved-from-core", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
+			if err := dh.sendProxiedMessage(ctx, onuDevice, omciMsg); err != nil {
+				return olterrors.NewErrCommunication("send-failed", log.Fields{
+					"device-id":     dh.device.Id,
+					"onu-device-id": toDeviceID}, err)
+			}
+		} else {
+			logger.Debugw(ctx, "proxy-address-found-in-omci-message", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
+			if err := dh.sendProxiedMessage(ctx, nil, omciMsg); err != nil {
+				return olterrors.NewErrCommunication("send-failed", log.Fields{
+					"device-id":     dh.device.Id,
+					"onu-device-id": toDeviceID}, err)
+			}
+		}
+	} else if msg.Header.Type == ic.InterAdapterMessageType_ONU_IND_REQUEST {
+		logger.Debugw(ctx, "got-message-from-onu", log.Fields{"message": msg.Header.Id})
+		if err := dh.receivedMsgFromOnu(ctx, msg); err != nil {
+			return err
+		}
+	} else {
+		return olterrors.NewErrInvalidValue(log.Fields{"inter-adapter-message-type": msg.Header.Type}, nil)
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) sendProxiedMessage(ctx context.Context, onuDevice *voltha.Device, omciMsg *ic.InterAdapterOmciMessage) error {
+	var intfID uint32
+	var onuID uint32
+	var connectStatus common.ConnectStatus_Types
+	if onuDevice != nil {
+		intfID = onuDevice.ProxyAddress.GetChannelId()
+		onuID = onuDevice.ProxyAddress.GetOnuId()
+		connectStatus = onuDevice.ConnectStatus
+	} else {
+		intfID = omciMsg.GetProxyAddress().GetChannelId()
+		onuID = omciMsg.GetProxyAddress().GetOnuId()
+		connectStatus = omciMsg.GetConnectStatus()
+	}
+	if connectStatus != voltha.ConnectStatus_REACHABLE {
+		logger.Debugw(ctx, "onu-not-reachable--cannot-send-omci", log.Fields{"intf-id": intfID, "onu-id": onuID})
+
+		return olterrors.NewErrCommunication("unreachable", log.Fields{
+			"intf-id": intfID,
+			"onu-id":  onuID}, nil)
+	}
+
+	var omciMessage *oop.OmciMsg
+	hexPkt := make([]byte, hex.EncodedLen(len(omciMsg.Message)))
+	hex.Encode(hexPkt, omciMsg.Message)
+	omciMessage = &oop.OmciMsg{IntfId: intfID, OnuId: onuID, Pkt: hexPkt}
+
+	transid := extractOmciTransactionID(omciMsg.Message)
+	logger.Debugw(ctx, "sent-omci-msg", log.Fields{"intf-id": intfID, "onu-id": onuID,
+		"omciTransactionID": transid, "omciMsg": string(omciMessage.Pkt)})
+
+	_, err := dh.Client.OmciMsgOut(log.WithSpanFromContext(context.Background(), ctx), omciMessage)
+	if err != nil {
+		return olterrors.NewErrCommunication("omci-send-failed", log.Fields{
+			"intf-id": intfID,
+			"onu-id":  onuID,
+			"message": omciMessage}, err)
+	}
+
+	if disableBBSim {
+		if err = dh.fakeOmciIndication(ctx, intfID, onuID, omciMsg.Message); err != nil {
+			return nil
+		}
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) activateONU(ctx context.Context, intfID uint32, onuID int64, serialNum *oop.SerialNumber, serialNumber string) error {
+	logger.Debugw(ctx, "activate-onu", log.Fields{"intf-id": intfID, "onu-id": onuID, "serialNum": serialNum, "serialNumber": serialNumber, "device-id": dh.device.Id})
+	if err := dh.flowMgr.UpdateOnuInfo(ctx, intfID, uint32(onuID), serialNumber); err != nil {
+		return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu": onuID, "intf-id": intfID}, err)
+	}
+	var pir uint32 = 1000000
+	Onu := oop.Onu{IntfId: intfID, OnuId: uint32(onuID), SerialNumber: serialNum, Pir: pir}
+	if _, err := dh.Client.ActivateOnu(ctx, &Onu); err != nil {
+		st, _ := status.FromError(err)
+		if st.Code() == codes.AlreadyExists {
+			logger.Debugw(ctx, "onu-activation-in-progress", log.Fields{"SerialNumber": serialNumber, "onu-id": onuID, "device-id": dh.device.Id})
+
+		} else {
+			return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu": Onu, "device-id": dh.device.Id}, err)
+		}
+	} else {
+		logger.Infow(ctx, "activated-onu", log.Fields{"SerialNumber": serialNumber, "device-id": dh.device.Id})
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) onuDiscIndication(ctx context.Context, onuDiscInd *oop.OnuDiscIndication, sn string) error {
+	channelID := onuDiscInd.GetIntfId()
+	parentPortNo := IntfIDToPortNo(onuDiscInd.GetIntfId(), voltha.Port_PON_OLT)
+
+	logger.Infow(ctx, "new-discovery-indication", log.Fields{"sn": sn})
+
+	kwargs := make(map[string]interface{})
+	if sn != "" {
+		kwargs["serial_number"] = sn
+	} else {
+		return olterrors.NewErrInvalidValue(log.Fields{"serial-number": sn}, nil)
+	}
+
+	var alarmInd oop.OnuAlarmIndication
+	raisedTs := time.Now().UnixNano()
+	if _, loaded := dh.discOnus.LoadOrStore(sn, true); loaded {
+
+		/* When PON cable disconnected and connected back from OLT, it was expected OnuAlarmIndication
+		   with "los_status: off" should be raised but BAL does not raise this Alarm hence manually sending
+		   OnuLosClear event on receiving OnuDiscoveryIndication for the Onu after checking whether
+		   OnuLosRaise event sent for it */
+		dh.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
+			if onuInCache.(*OnuDevice).serialNumber == sn && onuInCache.(*OnuDevice).losRaised {
+				if onuDiscInd.GetIntfId() != onuInCache.(*OnuDevice).intfID {
+					logger.Warnw(ctx, "onu-is-on-a-different-intf-id-now", log.Fields{
+						"previousIntfId": onuInCache.(*OnuDevice).intfID,
+						"currentIntfId":  onuDiscInd.GetIntfId()})
+					// TODO:: Should we need to ignore raising OnuLosClear event
+					// when onu connected to different PON?
+				}
+				alarmInd.IntfId = onuInCache.(*OnuDevice).intfID
+				alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
+				alarmInd.LosStatus = statusCheckOff
+				go func() {
+					if err := dh.eventMgr.onuAlarmIndication(ctx, &alarmInd, onuInCache.(*OnuDevice).deviceID, raisedTs); err != nil {
+						logger.Debugw(ctx, "indication-failed", log.Fields{"error": err})
+					}
+				}()
+			}
+			return true
+		})
+
+		logger.Warnw(ctx, "onu-sn-is-already-being-processed", log.Fields{"sn": sn})
+		return nil
+	}
+
+	var onuID uint32
+
+	onuDevice, err := dh.coreProxy.GetChildDevice(ctx, dh.device.Id, kwargs)
+
+	if err != nil {
+		logger.Debugw(ctx, "core-proxy-get-child-device-failed", log.Fields{"parentDevice": dh.device.Id, "err": err, "sn": sn})
+		if e, ok := status.FromError(err); ok {
+			logger.Debugw(ctx, "core-proxy-get-child-device-failed-with-code", log.Fields{"errCode": e.Code(), "sn": sn})
+			switch e.Code() {
+			case codes.Internal:
+				// this probably means NOT FOUND, so just create a new device
+				onuDevice = nil
+			case codes.DeadlineExceeded:
+				// if the call times out, cleanup and exit
+				dh.discOnus.Delete(sn)
+				return olterrors.NewErrTimeout("get-child-device", log.Fields{"device-id": dh.device.Id}, err)
+			}
+		}
+	}
+
+	if onuDevice == nil {
+		// NOTE this should happen a single time, and only if GetChildDevice returns NotFound
+		logger.Debugw(ctx, "creating-new-onu", log.Fields{"sn": sn})
+		// we need to create a new ChildDevice
+		ponintfid := onuDiscInd.GetIntfId()
+		dh.lockDevice.Lock()
+		onuID, err = dh.resourceMgr.GetONUID(ctx, ponintfid)
+		dh.lockDevice.Unlock()
+
+		logger.Infow(ctx, "creating-new-onu-got-onu-id", log.Fields{"sn": sn, "onuId": onuID})
+
+		if err != nil {
+			// if we can't create an ID in resource manager,
+			// cleanup and exit
+			dh.discOnus.Delete(sn)
+			return olterrors.NewErrAdapter("resource-manager-get-onu-id-failed", log.Fields{
+				"pon-intf-id":   ponintfid,
+				"serial-number": sn}, err)
+		}
+
+		if onuDevice, err = dh.coreProxy.ChildDeviceDetected(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, int(parentPortNo),
+			"", int(channelID), string(onuDiscInd.SerialNumber.GetVendorId()), sn, int64(onuID)); err != nil {
+			dh.discOnus.Delete(sn)
+			dh.resourceMgr.FreeonuID(ctx, ponintfid, []uint32{onuID}) // NOTE I'm not sure this method is actually cleaning up the right thing
+			return olterrors.NewErrAdapter("core-proxy-child-device-detected-failed", log.Fields{
+				"pon-intf-id":   ponintfid,
+				"serial-number": sn}, err)
+		}
+		if err := dh.eventMgr.OnuDiscoveryIndication(ctx, onuDiscInd, dh.device.Id, onuDevice.Id, onuID, sn, time.Now().UnixNano()); err != nil {
+			logger.Warnw(ctx, "discovery-indication-failed", log.Fields{"error": err})
+		}
+		logger.Infow(ctx, "onu-child-device-added",
+			log.Fields{"onuDevice": onuDevice,
+				"sn":        sn,
+				"onu-id":    onuID,
+				"device-id": dh.device.Id})
+	}
+
+	onuID = onuDevice.ProxyAddress.OnuId
+	logger.Debugw(ctx, "onu-discovery-indication-key-create",
+		log.Fields{"onu-id": onuID,
+			"intfId": onuDiscInd.GetIntfId(),
+			"sn":     sn})
+	onuKey := dh.formOnuKey(onuDiscInd.GetIntfId(), onuID)
+
+	onuDev := NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuID, onuDiscInd.GetIntfId(), onuDevice.ProxyAddress.DeviceId, false)
+	dh.onus.Store(onuKey, onuDev)
+	logger.Debugw(ctx, "new-onu-device-discovered",
+		log.Fields{"onu": onuDev,
+			"sn": sn})
+
+	if err := dh.coreProxy.DeviceStateUpdate(ctx, onuDevice.Id, common.ConnectStatus_REACHABLE, common.OperStatus_DISCOVERED); err != nil {
+		return olterrors.NewErrAdapter("failed-to-update-device-state", log.Fields{
+			"device-id":     onuDevice.Id,
+			"serial-number": sn}, err)
+	}
+	logger.Infow(ctx, "onu-discovered-reachable", log.Fields{"device-id": onuDevice.Id, "sn": sn})
+	if err := dh.activateONU(ctx, onuDiscInd.IntfId, int64(onuID), onuDiscInd.SerialNumber, sn); err != nil {
+		return olterrors.NewErrAdapter("onu-activation-failed", log.Fields{
+			"device-id":     onuDevice.Id,
+			"serial-number": sn}, err)
+	}
+	return nil
+}
+func (dh *DeviceHandler) onuDiscIndication2(ctx context.Context, onuDiscInd *oop.OnuDiscIndication, sn string, macAddress string) error {
+	channelID := onuDiscInd.GetIntfId()
+	parentPortNo := IntfIDToPortNo(onuDiscInd.GetIntfId(), voltha.Port_PON_OLT)
+
+	logger.Infow(ctx, "new-discovery-indication", log.Fields{"sn": sn})
+
+	kwargs := make(map[string]interface{})
+	if sn != "" {
+		kwargs["serial_number"] = sn
+	} else {
+		return olterrors.NewErrInvalidValue(log.Fields{"serial-number": sn}, nil)
+	}
+
+	var alarmInd oop.OnuAlarmIndication
+	raisedTs := time.Now().UnixNano()
+	if _, loaded := dh.discOnus.LoadOrStore(sn, true); loaded {
+
+		/* When PON cable disconnected and connected back from OLT, it was expected OnuAlarmIndication
+		   with "los_status: off" should be raised but BAL does not raise this Alarm hence manually sending
+		   OnuLosClear event on receiving OnuDiscoveryIndication for the Onu after checking whether
+		   OnuLosRaise event sent for it */
+		dh.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
+			if onuInCache.(*OnuDevice).serialNumber == sn && onuInCache.(*OnuDevice).losRaised {
+				if onuDiscInd.GetIntfId() != onuInCache.(*OnuDevice).intfID {
+					logger.Warnw(ctx, "onu-is-on-a-different-intf-id-now", log.Fields{
+						"previousIntfId": onuInCache.(*OnuDevice).intfID,
+						"currentIntfId":  onuDiscInd.GetIntfId()})
+					// TODO:: Should we need to ignore raising OnuLosClear event
+					// when onu connected to different PON?
+				}
+				alarmInd.IntfId = onuInCache.(*OnuDevice).intfID
+				alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
+				alarmInd.LosStatus = statusCheckOff
+				go func() {
+					if err := dh.eventMgr.onuAlarmIndication(ctx, &alarmInd, onuInCache.(*OnuDevice).deviceID, raisedTs); err != nil {
+						logger.Debugw(ctx, "indication-failed", log.Fields{"error": err})
+					}
+				}()
+			}
+			return true
+		})
+
+		logger.Warnw(ctx, "onu-sn-is-already-being-processed", log.Fields{"sn": sn})
+		return nil
+	}
+
+	var onuID uint32
+
+	onuDevice, err := dh.coreProxy.GetChildDevice(ctx, dh.device.Id, kwargs)
+
+	if err != nil {
+		logger.Debugw(ctx, "core-proxy-get-child-device-failed", log.Fields{"parentDevice": dh.device.Id, "err": err, "sn": sn})
+		if e, ok := status.FromError(err); ok {
+			logger.Debugw(ctx, "core-proxy-get-child-device-failed-with-code", log.Fields{"errCode": e.Code(), "sn": sn})
+			switch e.Code() {
+			case codes.Internal:
+				// this probably means NOT FOUND, so just create a new device
+				onuDevice = nil
+			case codes.DeadlineExceeded:
+				// if the call times out, cleanup and exit
+				dh.discOnus.Delete(sn)
+				return olterrors.NewErrTimeout("get-child-device", log.Fields{"device-id": dh.device.Id}, err)
+			}
+		}
+	}
+
+	if onuDevice == nil {
+		// NOTE this should happen a single time, and only if GetChildDevice returns NotFound
+		logger.Debugw(ctx, "creating-new-onu", log.Fields{"sn": sn})
+		// we need to create a new ChildDevice
+		ponintfid := onuDiscInd.GetIntfId()
+		dh.lockDevice.Lock()
+		onuID, err = dh.resourceMgr.GetONUID(ctx, ponintfid)
+		dh.lockDevice.Unlock()
+
+		logger.Infow(ctx, "creating-new-onu-got-onu-id", log.Fields{"sn": sn, "onuId": onuID})
+
+		if err != nil {
+			// if we can't create an ID in resource manager,
+			// cleanup and exit
+			dh.discOnus.Delete(sn)
+			return olterrors.NewErrAdapter("resource-manager-get-onu-id-failed", log.Fields{
+				"pon-intf-id":   ponintfid,
+				"serial-number": sn}, err)
+		}
+
+		if onuDevice, err = dh.coreProxy.ChildDeviceDetected(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, int(parentPortNo),
+			"", int(channelID), string(onuDiscInd.SerialNumber.GetVendorId()), sn, int64(onuID)); err != nil {
+			dh.discOnus.Delete(sn)
+			dh.resourceMgr.FreeonuID(ctx, ponintfid, []uint32{onuID}) // NOTE I'm not sure this method is actually cleaning up the right thing
+			return olterrors.NewErrAdapter("core-proxy-child-device-detected-failed", log.Fields{
+				"pon-intf-id":   ponintfid,
+				"serial-number": sn}, err)
+		}
+		if err := dh.eventMgr.OnuDiscoveryIndication(ctx, onuDiscInd, dh.device.Id, onuDevice.Id, onuID, sn, time.Now().UnixNano()); err != nil {
+			logger.Warnw(ctx, "discovery-indication-failed", log.Fields{"error": err})
+		}
+		logger.Infow(ctx, "onu-child-device-added",
+			log.Fields{"onuDevice": onuDevice,
+				"sn":        sn,
+				"onu-id":    onuID,
+				"device-id": dh.device.Id})
+	}
+
+	onuID = onuDevice.ProxyAddress.OnuId
+	logger.Debugw(ctx, "onu-discovery-indication-key-create",
+		log.Fields{"onu-id": onuID,
+			"intfId": onuDiscInd.GetIntfId(),
+			"sn":     sn})
+	onuKey := dh.formOnuKey(onuDiscInd.GetIntfId(), onuID)
+
+	onuDev := NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuID, onuDiscInd.GetIntfId(), onuDevice.ProxyAddress.DeviceId, false)
+	dh.onus.Store(onuKey, onuDev)
+	logger.Debugw(ctx, "new-onu-device-discovered",
+		log.Fields{"onu": onuDev,
+			"sn": sn})
+
+	if err := dh.coreProxy.DeviceStateUpdate(ctx, onuDevice.Id, common.ConnectStatus_REACHABLE, common.OperStatus_DISCOVERED); err != nil {
+		return olterrors.NewErrAdapter("failed-to-update-device-state", log.Fields{
+			"device-id":     onuDevice.Id,
+			"serial-number": sn}, err)
+	}
+	logger.Infow(ctx, "onu-discovered-reachable", log.Fields{"device-id": onuDevice.Id, "sn": sn})
+	if err := dh.activateONU(ctx, onuDiscInd.IntfId, int64(onuID), onuDiscInd.SerialNumber, sn); err != nil {
+		return olterrors.NewErrAdapter("onu-activation-failed", log.Fields{
+			"device-id":     onuDevice.Id,
+			"serial-number": sn}, err)
+	}
+
+	device := FindL2oamDevice(macAddress)
+	if device != nil {
+		logger.Debug(ctx, fmt.Sprintf("onuDiscIndication2() onu.initialize() called. deviceId=%s, onuId=%d", onuDevice.Id, onuID))
+		onu := device.(*L2oamOnuDevice)
+		onu.update(macAddress, onuDevice.Id, onuID)
+		onu.setActiveState(ctx, true)
+	}
+	onuDevice.MacAddress = macAddress
+	onuDevice.Vendor = string(onuDiscInd.SerialNumber.VendorSpecific)
+	if err := dh.coreProxy.DeviceUpdate(log.WithSpanFromContext(context.TODO(), ctx), onuDevice); err != nil {
+		logger.Error(ctx, fmt.Sprintf("onuDiscIndication2() DeviceUpdate() failed. macAddress=%s, deviceId=%s", macAddress, onuDevice.Id))
+	}
+
+	return nil
+}
+func (dh *DeviceHandler) onuIndication(ctx context.Context, onuInd *oop.OnuIndication) error {
+	serialNumber := dh.stringifySerialNumber(onuInd.SerialNumber)
+
+	kwargs := make(map[string]interface{})
+	ponPort := IntfIDToPortNo(onuInd.GetIntfId(), voltha.Port_PON_OLT)
+	var onuDevice *voltha.Device
+	var err error
+	foundInCache := false
+	logger.Debugw(ctx, "onu-indication-key-create",
+		log.Fields{"onuId": onuInd.OnuId,
+			"intfId":    onuInd.GetIntfId(),
+			"device-id": dh.device.Id})
+	onuKey := dh.formOnuKey(onuInd.GetIntfId(), onuInd.OnuId)
+
+	errFields := log.Fields{"device-id": dh.device.Id}
+
+	if onuInCache, ok := dh.onus.Load(onuKey); ok {
+
+		//If ONU id is discovered before then use GetDevice to get onuDevice because it is cheaper.
+		foundInCache = true
+		errFields["onu-id"] = onuInCache.(*OnuDevice).deviceID
+		onuDevice, err = dh.coreProxy.GetDevice(ctx, dh.device.Id, onuInCache.(*OnuDevice).deviceID)
+	} else {
+		//If ONU not found in adapter cache then we have to use GetChildDevice to get onuDevice
+		if serialNumber != "" {
+			kwargs["serial_number"] = serialNumber
+			errFields["serial-number"] = serialNumber
+		} else {
+			kwargs["onu_id"] = onuInd.OnuId
+			kwargs["parent_port_no"] = ponPort
+			errFields["onu-id"] = onuInd.OnuId
+			errFields["parent-port-no"] = ponPort
+		}
+		onuDevice, err = dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
+	}
+
+	if err != nil || onuDevice == nil {
+		return olterrors.NewErrNotFound("onu-device", errFields, err)
+	}
+
+	if onuDevice.ParentPortNo != ponPort {
+		logger.Warnw(ctx, "onu-is-on-a-different-intf-id-now", log.Fields{
+			"previousIntfId": onuDevice.ParentPortNo,
+			"currentIntfId":  ponPort})
+	}
+
+	if onuDevice.ProxyAddress.OnuId != onuInd.OnuId {
+		logger.Warnw(ctx, "onu-id-mismatch-possible-if-voltha-and-olt-rebooted", log.Fields{
+			"expected-onu-id": onuDevice.ProxyAddress.OnuId,
+			"received-onu-id": onuInd.OnuId,
+			"device-id":       dh.device.Id})
+	}
+	if !foundInCache {
+		onuKey := dh.formOnuKey(onuInd.GetIntfId(), onuInd.GetOnuId())
+
+		dh.onus.Store(onuKey, NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuInd.GetOnuId(), onuInd.GetIntfId(), onuDevice.ProxyAddress.DeviceId, false))
+
+	}
+	if err := dh.updateOnuStates(ctx, onuDevice, onuInd); err != nil {
+		return olterrors.NewErrCommunication("state-update-failed", errFields, err)
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) updateOnuStates(ctx context.Context, onuDevice *voltha.Device, onuInd *oop.OnuIndication) error {
+	logger.Debugw(ctx, "onu-indication-for-state", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
+	if onuInd.AdminState == "down" || onuInd.OperState == "down" {
+		// The ONU has gone admin_state "down" or oper_state "down" - we expect the ONU to send discovery again
+		// The ONU admin_state is "up" while "oper_state" is down in cases where ONU activation fails. In this case
+		// the ONU sends Discovery again.
+		dh.discOnus.Delete(onuDevice.SerialNumber)
+		// Tests have shown that we sometimes get OperState as NOT down even if AdminState is down, forcing it
+		if onuInd.OperState != "down" {
+			logger.Warnw(ctx, "onu-admin-state-down", log.Fields{"operState": onuInd.OperState})
+			onuInd.OperState = "down"
+		}
+	}
+
+	switch onuInd.OperState {
+	case "down":
+		logger.Debugw(ctx, "sending-interadapter-onu-indication", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
+		// TODO NEW CORE do not hardcode adapter name. Handler needs Adapter reference
+		err := dh.AdapterProxy.SendInterAdapterMessage(ctx, onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
+			"openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
+		if err != nil {
+			return olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
+				"onu-indicator": onuInd,
+				"source":        "openolt",
+				"device-type":   onuDevice.Type,
+				"device-id":     onuDevice.Id}, err)
+		}
+	case "up":
+		logger.Debugw(ctx, "sending-interadapter-onu-indication", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
+		// TODO NEW CORE do not hardcode adapter name. Handler needs Adapter reference
+		err := dh.AdapterProxy.SendInterAdapterMessage(ctx, onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
+			"openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
+		if err != nil {
+			return olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
+				"onu-indicator": onuInd,
+				"source":        "openolt",
+				"device-type":   onuDevice.Type,
+				"device-id":     onuDevice.Id}, err)
+		}
+	default:
+		return olterrors.NewErrInvalidValue(log.Fields{"oper-state": onuInd.OperState}, nil)
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) stringifySerialNumber(serialNum *oop.SerialNumber) string {
+	if serialNum != nil {
+		return string(serialNum.VendorId) + dh.stringifyVendorSpecific(serialNum.VendorSpecific)
+	}
+	return ""
+}
+func (dh *DeviceHandler) deStringifySerialNumber(serialNum string) (*oop.SerialNumber, error) {
+	decodedStr, err := hex.DecodeString(serialNum[4:])
+	if err != nil {
+		return nil, err
+	}
+	return &oop.SerialNumber{
+		VendorId:       []byte(serialNum[:4]),
+		VendorSpecific: []byte(decodedStr),
+	}, nil
+}
+
+func (dh *DeviceHandler) stringifyVendorSpecific(vendorSpecific []byte) string {
+	tmp := fmt.Sprintf("%x", (uint32(vendorSpecific[0])>>4)&0x0f) +
+		fmt.Sprintf("%x", uint32(vendorSpecific[0]&0x0f)) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[1])>>4)&0x0f) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[1]))&0x0f) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[2])>>4)&0x0f) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[2]))&0x0f) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[3])>>4)&0x0f) +
+		fmt.Sprintf("%x", (uint32(vendorSpecific[3]))&0x0f)
+	return tmp
+}
+
+//UpdateFlowsBulk upates the bulk flow
+func (dh *DeviceHandler) UpdateFlowsBulk() error {
+	return olterrors.ErrNotImplemented
+}
+
+//GetChildDevice returns the child device for given parent port and onu id
+func (dh *DeviceHandler) GetChildDevice(ctx context.Context, parentPort, onuID uint32) (*voltha.Device, error) {
+	logger.Debugw(ctx, "getchilddevice",
+		log.Fields{"pon-port": parentPort,
+			"onu-id":    onuID,
+			"device-id": dh.device.Id})
+	kwargs := make(map[string]interface{})
+	kwargs["onu_id"] = onuID
+	kwargs["parent_port_no"] = parentPort
+	onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
+	if err != nil {
+		return nil, olterrors.NewErrNotFound("onu-device", log.Fields{
+			"intf-id": parentPort,
+			"onu-id":  onuID}, err)
+	}
+	logger.Debugw(ctx, "successfully-received-child-device-from-core", log.Fields{"child-device-id": onuDevice.Id, "child-device-sn": onuDevice.SerialNumber})
+	return onuDevice, nil
+}
+
+// SendPacketInToCore sends packet-in to core
+// For this, it calls SendPacketIn of the core-proxy which uses a device specific topic to send the request.
+// The adapter handling the device creates a device specific topic
+func (dh *DeviceHandler) SendPacketInToCore(ctx context.Context, logicalPort uint32, packetPayload []byte) error {
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "send-packet-in-to-core", log.Fields{
+			"port":      logicalPort,
+			"packet":    hex.EncodeToString(packetPayload),
+			"device-id": dh.device.Id,
+		})
+	}
+	if err := dh.coreProxy.SendPacketIn(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, logicalPort, packetPayload); err != nil {
+		return olterrors.NewErrCommunication("packet-send-failed", log.Fields{
+			"source":       "adapter",
+			"destination":  "core",
+			"device-id":    dh.device.Id,
+			"logical-port": logicalPort,
+			"packet":       hex.EncodeToString(packetPayload)}, err)
+	}
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "sent-packet-in-to-core-successfully", log.Fields{
+			"packet":    hex.EncodeToString(packetPayload),
+			"device-id": dh.device.Id,
+		})
+	}
+	return nil
+}
+
+// UpdatePmConfig updates the pm metrics.
+func (dh *DeviceHandler) UpdatePmConfig(ctx context.Context, pmConfigs *voltha.PmConfigs) {
+	logger.Infow(ctx, "update-pm-configs", log.Fields{"device-id": dh.device.Id, "pm-configs": pmConfigs})
+
+	if pmConfigs.DefaultFreq != dh.metrics.ToPmConfigs().DefaultFreq {
+		dh.metrics.UpdateFrequency(pmConfigs.DefaultFreq)
+		logger.Debugf(ctx, "frequency-updated")
+	}
+
+	if !pmConfigs.Grouped {
+		metrics := dh.metrics.GetSubscriberMetrics()
+		for _, m := range pmConfigs.Metrics {
+			metrics[m.Name].Enabled = m.Enabled
+
+		}
+	}
+}
+
+//UpdateFlowsIncrementally updates the device flow
+func (dh *DeviceHandler) UpdateFlowsIncrementally(ctx context.Context, device *voltha.Device, flows *of.FlowChanges, groups *of.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
+	logger.Debugw(ctx, "received-incremental-flowupdate-in-device-handler", log.Fields{"device-id": device.Id, "flows": flows, "groups": groups, "flowMetadata": flowMetadata})
+
+	var errorsList []error
+
+	if flows != nil {
+		for _, flow := range flows.ToRemove.Items {
+			dh.incrementActiveFlowRemoveCount(ctx, flow)
+
+			logger.Debugw(ctx, "removing-flow",
+				log.Fields{"device-id": device.Id,
+					"flowToRemove": flow})
+			err := dh.flowMgr.RemoveFlow(ctx, flow)
+			if err != nil {
+				errorsList = append(errorsList, err)
+			}
+
+			dh.decrementActiveFlowRemoveCount(ctx, flow)
+		}
+
+		for _, flow := range flows.ToAdd.Items {
+			logger.Debugw(ctx, "adding-flow",
+				log.Fields{"device-id": device.Id,
+					"flowToAdd": flow})
+			// If there are active Flow Remove in progress for a given subscriber, wait until it completes
+			dh.waitForFlowRemoveToFinish(ctx, flow)
+			err := dh.flowMgr.AddFlow(ctx, flow, flowMetadata)
+			if err != nil {
+				errorsList = append(errorsList, err)
+			}
+		}
+	}
+
+	if groups != nil {
+		for _, group := range groups.ToAdd.Items {
+			err := dh.flowMgr.AddGroup(ctx, group)
+			if err != nil {
+				errorsList = append(errorsList, err)
+			}
+		}
+		for _, group := range groups.ToUpdate.Items {
+			err := dh.flowMgr.ModifyGroup(ctx, group)
+			if err != nil {
+				errorsList = append(errorsList, err)
+			}
+		}
+		for _, group := range groups.ToRemove.Items {
+			err := dh.flowMgr.DeleteGroup(ctx, group)
+			if err != nil {
+				errorsList = append(errorsList, err)
+			}
+		}
+	}
+	if len(errorsList) > 0 {
+		return fmt.Errorf("errors-installing-flows-groups, errors:%v", errorsList)
+	}
+	logger.Debugw(ctx, "updated-flows-incrementally-successfully", log.Fields{"device-id": dh.device.Id})
+	return nil
+}
+
+//DisableDevice disables the given device
+//It marks the following for the given device:
+//Device-Handler Admin-State : down
+//Device Port-State: UNKNOWN
+//Device Oper-State: UNKNOWN
+func (dh *DeviceHandler) DisableDevice(ctx context.Context, device *voltha.Device) error {
+	/* On device disable ,admin state update has to be done prior sending request to agent since
+	   the indication thread may processes invalid  indications of ONU and OLT*/
+	if dh.Client != nil {
+		if _, err := dh.Client.DisableOlt(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty)); err != nil {
+			if e, ok := status.FromError(err); ok && e.Code() == codes.Internal {
+				return olterrors.NewErrAdapter("olt-disable-failed", log.Fields{"device-id": device.Id}, err)
+			}
+		}
+	}
+	L2oamDisableOlt(ctx, dh)
+	logger.Debugw(ctx, "olt-disabled", log.Fields{"device-id": device.Id})
+	/* Discovered ONUs entries need to be cleared , since on device disable the child devices goes to
+	UNREACHABLE state which needs to be configured again*/
+
+	dh.discOnus = sync.Map{}
+	dh.onus = sync.Map{}
+
+	dh.stopCollector <- true
+
+	go dh.notifyChildDevices(ctx, "unreachable")
+	cloned := proto.Clone(device).(*voltha.Device)
+	dh.device = cloned
+	if err := dh.coreProxy.PortsStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), cloned.Id, ^uint32(1<<voltha.Port_PON_OLT), voltha.OperStatus_UNKNOWN); err != nil {
+		return olterrors.NewErrAdapter("ports-state-update-failed", log.Fields{"device-id": device.Id}, err)
+	}
+	logger.Debugw(ctx, "disable-device-end", log.Fields{"device-id": device.Id})
+	return nil
+}
+
+func (dh *DeviceHandler) notifyChildDevices(ctx context.Context, state string) {
+	onuInd := oop.OnuIndication{}
+	onuInd.OperState = state
+	onuDevices, err := dh.coreProxy.GetChildDevices(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id)
+	if err != nil {
+		logger.Errorw(ctx, "failed-to-get-child-devices-information", log.Fields{"device-id": dh.device.Id, "error": err})
+	}
+	if onuDevices != nil {
+		for _, onuDevice := range onuDevices.Items {
+			err := dh.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.TODO(), ctx), &onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
+				"openolt", onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
+			if err != nil {
+				logger.Errorw(ctx, "failed-to-send-inter-adapter-message", log.Fields{"OnuInd": onuInd,
+					"From Adapter": "openolt", "DeviceType": onuDevice.Type, "device-id": onuDevice.Id})
+			}
+
+		}
+	}
+
+}
+
+//ReenableDevice re-enables the olt device after disable
+//It marks the following for the given device:
+//Device-Handler Admin-State : up
+//Device Port-State: ACTIVE
+//Device Oper-State: ACTIVE
+func (dh *DeviceHandler) ReenableDevice(ctx context.Context, device *voltha.Device) error {
+	if _, err := dh.Client.ReenableOlt(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty)); err != nil {
+		if e, ok := status.FromError(err); ok && e.Code() == codes.Internal {
+			return olterrors.NewErrAdapter("olt-reenable-failed", log.Fields{"device-id": dh.device.Id}, err)
+		}
+	}
+	logger.Debug(ctx, "olt-reenabled")
+
+
+	ports, err := dh.coreProxy.ListDevicePorts(ctx, device.Id)
+	if err != nil {
+		return olterrors.NewErrAdapter("list-ports-failed", log.Fields{"device": device.Id}, err)
+	}
+	if err := dh.disableAdminDownPorts(ctx, ports); err != nil {
+		return olterrors.NewErrAdapter("port-status-update-failed-after-olt-reenable", log.Fields{"device": device}, err)
+	}
+	device.OperStatus = voltha.OperStatus_ACTIVE
+	dh.device = device
+
+	if err := dh.coreProxy.DeviceStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), device.Id, device.ConnectStatus, device.OperStatus); err != nil {
+		return olterrors.NewErrAdapter("state-update-failed", log.Fields{
+			"device-id":      device.Id,
+			"connect-status": device.ConnectStatus,
+			"oper-status":    device.OperStatus}, err)
+	}
+
+	logger.Debugw(ctx, "reenabledevice-end", log.Fields{"device-id": device.Id})
+
+	return nil
+}
+
+func (dh *DeviceHandler) clearUNIData(ctx context.Context, onu *rsrcMgr.OnuGemInfo) error {
+	var uniID uint32
+	var err error
+	for _, port := range onu.UniPorts {
+		uniID = UniIDFromPortNum(uint32(port))
+		logger.Debugw(ctx, "clearing-resource-data-for-uni-port", log.Fields{"port": port, "uni-id": uniID})
+		/* Delete tech-profile instance from the KV store */
+		if err = dh.flowMgr.DeleteTechProfileInstances(ctx, onu.IntfID, onu.OnuID, uniID, onu.SerialNumber); err != nil {
+			logger.Debugw(ctx, "failed-to-remove-tech-profile-instance-for-onu", log.Fields{"onu-id": onu.OnuID})
+		}
+		logger.Debugw(ctx, "deleted-tech-profile-instance-for-onu", log.Fields{"onu-id": onu.OnuID})
+		flowIDs := dh.resourceMgr.GetCurrentFlowIDsForOnu(ctx, onu.IntfID, int32(onu.OnuID), int32(uniID))
+		for _, flowID := range flowIDs {
+			dh.resourceMgr.FreeFlowID(ctx, onu.IntfID, int32(onu.OnuID), int32(uniID), flowID)
+		}
+		tpIDList := dh.resourceMgr.GetTechProfileIDForOnu(ctx, onu.IntfID, onu.OnuID, uniID)
+		for _, tpID := range tpIDList {
+			if err = dh.resourceMgr.RemoveMeterIDForOnu(ctx, "upstream", onu.IntfID, onu.OnuID, uniID, tpID); err != nil {
+				logger.Debugw(ctx, "failed-to-remove-meter-id-for-onu-upstream", log.Fields{"onu-id": onu.OnuID})
+			}
+			logger.Debugw(ctx, "removed-meter-id-for-onu-upstream", log.Fields{"onu-id": onu.OnuID})
+			if err = dh.resourceMgr.RemoveMeterIDForOnu(ctx, "downstream", onu.IntfID, onu.OnuID, uniID, tpID); err != nil {
+				logger.Debugw(ctx, "failed-to-remove-meter-id-for-onu-downstream", log.Fields{"onu-id": onu.OnuID})
+			}
+			logger.Debugw(ctx, "removed-meter-id-for-onu-downstream", log.Fields{"onu-id": onu.OnuID})
+		}
+		dh.resourceMgr.FreePONResourcesForONU(ctx, onu.IntfID, onu.OnuID, uniID)
+		if err = dh.resourceMgr.RemoveTechProfileIDsForOnu(ctx, onu.IntfID, onu.OnuID, uniID); err != nil {
+			logger.Debugw(ctx, "failed-to-remove-tech-profile-id-for-onu", log.Fields{"onu-id": onu.OnuID})
+		}
+		logger.Debugw(ctx, "removed-tech-profile-id-for-onu", log.Fields{"onu-id": onu.OnuID})
+		if err = dh.resourceMgr.DelGemPortPktInOfAllServices(ctx, onu.IntfID, onu.OnuID, uint32(port)); err != nil {
+			logger.Debugw(ctx, "failed-to-remove-gemport-pkt-in", log.Fields{"intfid": onu.IntfID, "onuid": onu.OnuID, "uniId": uniID})
+		}
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) clearNNIData(ctx context.Context) error {
+	nniUniID := -1
+	nniOnuID := -1
+
+	if dh.resourceMgr == nil {
+		return olterrors.NewErrNotFound("resource-manager", log.Fields{"device-id": dh.device.Id}, nil)
+	}
+	nni, err := dh.resourceMgr.GetNNIFromKVStore(ctx)
+	if err != nil {
+		return olterrors.NewErrPersistence("get", "nni", 0, nil, err)
+	}
+	logger.Debugw(ctx, "nni-", log.Fields{"nni": nni})
+	for _, nniIntfID := range nni {
+		flowIDs := dh.resourceMgr.GetCurrentFlowIDsForOnu(ctx, uint32(nniIntfID), int32(nniOnuID), int32(nniUniID))
+		logger.Debugw(ctx, "current-flow-ids-for-nni", log.Fields{"flow-ids": flowIDs})
+		for _, flowID := range flowIDs {
+			dh.resourceMgr.FreeFlowID(ctx, uint32(nniIntfID), -1, -1, uint32(flowID))
+		}
+		dh.resourceMgr.RemoveResourceMap(ctx, nniIntfID, int32(nniOnuID), int32(nniUniID))
+	}
+	if err = dh.resourceMgr.DelNNiFromKVStore(ctx); err != nil {
+		return olterrors.NewErrPersistence("clear", "nni", 0, nil, err)
+	}
+	return nil
+}
+
+// DeleteDevice deletes the device instance from openolt handler array.  Also clears allocated resource manager resources.  Also reboots the OLT hardware!
+func (dh *DeviceHandler) DeleteDevice(ctx context.Context, device *voltha.Device) error {
+	logger.Debug(ctx, "function-entry-delete-device")
+	/* Clear the KV store data associated with the all the UNI ports
+	   This clears up flow data and also resource map data for various
+	   other pon resources like alloc_id and gemport_id
+	*/
+	L2oamDeleteOlt(ctx, dh)
+	go dh.cleanupDeviceResources(ctx)
+	logger.Debug(ctx, "removed-device-from-Resource-manager-KV-store")
+	dh.stopCollector <- true
+	dh.stopHeartbeatCheck <- true
+	if dh.Client != nil {
+		if _, err := dh.Client.Reboot(ctx, new(oop.Empty)); err != nil {
+			return olterrors.NewErrAdapter("olt-reboot-failed", log.Fields{"device-id": dh.device.Id}, err).Log()
+		}
+	}
+	cloned := proto.Clone(device).(*voltha.Device)
+	cloned.OperStatus = voltha.OperStatus_UNKNOWN
+	cloned.ConnectStatus = voltha.ConnectStatus_UNREACHABLE
+	if err := dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
+		return olterrors.NewErrAdapter("device-state-update-failed", log.Fields{
+			"device-id":      device.Id,
+			"connect-status": cloned.ConnectStatus,
+			"oper-status":    cloned.OperStatus}, err).Log()
+	}
+	return nil
+}
+func (dh *DeviceHandler) cleanupDeviceResources(ctx context.Context) {
+
+	if dh.resourceMgr != nil {
+		noOfPonPorts := dh.resourceMgr.DevInfo.GetPonPorts()
+		var ponPort uint32
+		for ponPort = 0; ponPort < noOfPonPorts; ponPort++ {
+			var onuGemData []rsrcMgr.OnuGemInfo
+			err := dh.resourceMgr.ResourceMgrs[ponPort].GetOnuGemInfo(ctx, ponPort, &onuGemData)
+			if err != nil {
+				_ = olterrors.NewErrNotFound("onu", log.Fields{
+					"device-id": dh.device.Id,
+					"pon-port":  ponPort}, err).Log()
+			}
+			for _, onu := range onuGemData {
+				onuID := make([]uint32, 1)
+				logger.Debugw(ctx, "onu-data", log.Fields{"onu": onu})
+				if err = dh.clearUNIData(ctx, &onu); err != nil {
+					logger.Errorw(ctx, "failed-to-clear-data-for-onu", log.Fields{"onu-device": onu})
+				}
+				// Clear flowids for gem cache.
+				for _, gem := range onu.GemPorts {
+					dh.resourceMgr.DeleteFlowIDsForGem(ctx, ponPort, gem)
+				}
+				onuID[0] = onu.OnuID
+				dh.resourceMgr.FreeonuID(ctx, ponPort, onuID)
+			}
+			dh.resourceMgr.DeleteIntfIDGempMapPath(ctx, ponPort)
+			onuGemData = nil
+			err = dh.resourceMgr.DelOnuGemInfoForIntf(ctx, ponPort)
+			if err != nil {
+				logger.Errorw(ctx, "failed-to-update-onugem-info", log.Fields{"intfid": ponPort, "onugeminfo": onuGemData})
+			}
+		}
+		/* Clear the flows from KV store associated with NNI port.
+		   There are mostly trap rules from NNI port (like LLDP)
+		*/
+		if err := dh.clearNNIData(ctx); err != nil {
+			logger.Errorw(ctx, "failed-to-clear-data-for-NNI-port", log.Fields{"device-id": dh.device.Id})
+		}
+
+		/* Clear the resource pool for each PON port in the background */
+		go func() {
+			if err := dh.resourceMgr.Delete(ctx); err != nil {
+				logger.Debug(ctx, err)
+			}
+		}()
+	}
+
+	/*Delete ONU map for the device*/
+	dh.onus.Range(func(key interface{}, value interface{}) bool {
+		dh.onus.Delete(key)
+		return true
+	})
+
+	/*Delete discovered ONU map for the device*/
+	dh.discOnus.Range(func(key interface{}, value interface{}) bool {
+		dh.discOnus.Delete(key)
+		return true
+	})
+}
+
+//RebootDevice reboots the given device
+func (dh *DeviceHandler) RebootDevice(ctx context.Context, device *voltha.Device) error {
+	L2oamRebootDevice(ctx, dh, device)
+	logger.Debugw(ctx, "rebooted-device-successfully", log.Fields{"device-id": device.Id})
+	return nil
+}
+
+func (dh *DeviceHandler) handlePacketIndication(ctx context.Context, packetIn *oop.PacketIndication) error {
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "received-packet-in", log.Fields{
+			"packet-indication": *packetIn,
+			"device-id":         dh.device.Id,
+			"packet":            hex.EncodeToString(packetIn.Pkt),
+		})
+	}
+	logicalPortNum, err := dh.flowMgr.GetLogicalPortFromPacketIn(ctx, packetIn)
+	if err != nil {
+		return olterrors.NewErrNotFound("logical-port", log.Fields{"packet": hex.EncodeToString(packetIn.Pkt)}, err)
+	}
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "sending-packet-in-to-core", log.Fields{
+			"logical-port-num": logicalPortNum,
+			"device-id":        dh.device.Id,
+			"packet":           hex.EncodeToString(packetIn.Pkt),
+		})
+	}
+
+	if err := dh.coreProxy.SendPacketIn(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, logicalPortNum, packetIn.Pkt); err != nil {
+		return olterrors.NewErrCommunication("send-packet-in", log.Fields{
+			"destination": "core",
+			"source":      dh.device.Type,
+			"device-id":   dh.device.Id,
+			"packet":      hex.EncodeToString(packetIn.Pkt),
+		}, err)
+	}
+
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "success-sending-packet-in-to-core!", log.Fields{
+			"packet":    hex.EncodeToString(packetIn.Pkt),
+			"device-id": dh.device.Id,
+		})
+	}
+	return nil
+}
+
+// PacketOut sends packet-out from VOLTHA to OLT on the egress port provided
+func (dh *DeviceHandler) PacketOut(ctx context.Context, egressPortNo int, packet *of.OfpPacketOut) error {
+	if logger.V(log.DebugLevel) {
+		logger.Debugw(ctx, "incoming-packet-out", log.Fields{
+			"device-id":      dh.device.Id,
+			"egress-port-no": egressPortNo,
+			"pkt-length":     len(packet.Data),
+			"packet":         hex.EncodeToString(packet.Data),
+		})
+	}
+
+	if disableBBSim {
+		if vlanEnable {
+			byteString := string(packet.Data)
+			searchByteString := string([]byte{0x88, 0x8e, 0x03, 0x00, 0x00, 0x04, 0x03})
+			//if strings.Index(byteString, searchByteString) != -1 {
+			if strings.Contains(byteString, searchByteString) {
+				device := FindL2oamDevice(hex.EncodeToString(packet.Data[:6]))
+				if onu, ok := device.(*L2oamOnuDevice); ok {
+					onu.Base.EapFlag = true
+				}
+			}
+
+			// add s-vlan tag
+			sendPacket := make([]byte, len(packet.Data)+4)
+			copy(sendPacket, packet.Data[:12])
+			copy(sendPacket[12:], svlanTagAuth)
+			copy(sendPacket[16:], packet.Data[12:])
+			GetL2oamHandle().send(sendPacket)
+		} else {
+			GetL2oamHandle().send(packet.Data)
+		}
+		return nil
+	}
+
+	egressPortType := IntfIDToPortTypeName(uint32(egressPortNo))
+	if egressPortType == voltha.Port_ETHERNET_UNI {
+		outerEthType := (uint16(packet.Data[12]) << 8) | uint16(packet.Data[13])
+		innerEthType := (uint16(packet.Data[16]) << 8) | uint16(packet.Data[17])
+		if outerEthType == 0x8942 || outerEthType == 0x88cc {
+			// Do not packet-out lldp packets on uni port.
+			// ONOS has no clue about uni/nni ports, it just packets out on all
+			// available ports on the Logical Switch. It should not be interested
+			// in the UNI links.
+			logger.Debugw(ctx, "dropping-lldp-packet-out-on-uni", log.Fields{
+				"device-id": dh.device.Id,
+			})
+			return nil
+		}
+		if outerEthType == 0x88a8 || outerEthType == 0x8100 {
+			if innerEthType == 0x8100 {
+				// q-in-q 802.1ad or 802.1q double tagged packet.
+				// slice out the outer tag.
+				packet.Data = append(packet.Data[:12], packet.Data[16:]...)
+				if logger.V(log.DebugLevel) {
+					logger.Debugw(ctx, "packet-now-single-tagged", log.Fields{
+						"packet-data": hex.EncodeToString(packet.Data),
+						"device-id":   dh.device.Id,
+					})
+				}
+			}
+		}
+		intfID := IntfIDFromUniPortNum(uint32(egressPortNo))
+		onuID := OnuIDFromPortNum(uint32(egressPortNo))
+		uniID := UniIDFromPortNum(uint32(egressPortNo))
+
+		gemPortID, err := dh.flowMgr.GetPacketOutGemPortID(ctx, intfID, onuID, uint32(egressPortNo), packet.Data)
+		if err != nil {
+			// In this case the openolt agent will receive the gemPortID as 0.
+			// The agent tries to retrieve the gemPortID in this case.
+			// This may not always succeed at the agent and packetOut may fail.
+			logger.Errorw(ctx, "failed-to-retrieve-gemport-id-for-packet-out", log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"uni-id":    uniID,
+				"packet":    hex.EncodeToString(packet.Data),
+				"device-id": dh.device.Id,
+			})
+		}
+
+		onuPkt := oop.OnuPacket{IntfId: intfID, OnuId: onuID, PortNo: uint32(egressPortNo), GemportId: gemPortID, Pkt: packet.Data}
+
+		if logger.V(log.DebugLevel) {
+			logger.Debugw(ctx, "sending-packet-to-onu", log.Fields{
+				"egress-port-no": egressPortNo,
+				"intf-id":        intfID,
+				"onu-id":         onuID,
+				"uni-id":         uniID,
+				"gem-port-id":    gemPortID,
+				"packet":         hex.EncodeToString(packet.Data),
+				"device-id":      dh.device.Id,
+			})
+		}
+
+		if _, err := dh.Client.OnuPacketOut(ctx, &onuPkt); err != nil {
+			return olterrors.NewErrCommunication("packet-out-send", log.Fields{
+				"source":             "adapter",
+				"destination":        "onu",
+				"egress-port-number": egressPortNo,
+				"intf-id":            intfID,
+				"oni-id":             onuID,
+				"uni-id":             uniID,
+				"gem-port-id":        gemPortID,
+				"packet":             hex.EncodeToString(packet.Data),
+				"device-id":          dh.device.Id,
+			}, err)
+		}
+	} else if egressPortType == voltha.Port_ETHERNET_NNI {
+		nniIntfID, err := IntfIDFromNniPortNum(ctx, uint32(egressPortNo))
+		if err != nil {
+			return olterrors.NewErrInvalidValue(log.Fields{
+				"egress-nni-port": egressPortNo,
+				"device-id":       dh.device.Id,
+			}, err)
+		}
+		uplinkPkt := oop.UplinkPacket{IntfId: nniIntfID, Pkt: packet.Data}
+
+		if logger.V(log.DebugLevel) {
+			logger.Debugw(ctx, "sending-packet-to-nni", log.Fields{
+				"uplink-pkt": uplinkPkt,
+				"packet":     hex.EncodeToString(packet.Data),
+				"device-id":  dh.device.Id,
+			})
+		}
+
+		if _, err := dh.Client.UplinkPacketOut(ctx, &uplinkPkt); err != nil {
+			return olterrors.NewErrCommunication("packet-out-to-nni", log.Fields{
+				"packet":    hex.EncodeToString(packet.Data),
+				"device-id": dh.device.Id,
+			}, err)
+		}
+	} else {
+		logger.Warnw(ctx, "packet-out-to-this-interface-type-not-implemented", log.Fields{
+			"egress-port-no": egressPortNo,
+			"egressPortType": egressPortType,
+			"packet":         hex.EncodeToString(packet.Data),
+			"device-id":      dh.device.Id,
+		})
+	}
+	return nil
+}
+
+func (dh *DeviceHandler) formOnuKey(intfID, onuID uint32) string {
+	return "" + strconv.Itoa(int(intfID)) + "." + strconv.Itoa(int(onuID))
+}
+
+func startHeartbeatCheck(ctx context.Context, dh *DeviceHandler) {
+
+	var timerCheck *time.Timer
+
+	for {
+		heartbeatTimer := time.NewTimer(dh.openOLT.HeartbeatCheckInterval)
+		select {
+		case <-heartbeatTimer.C:
+			ctxWithTimeout, cancel := context.WithTimeout(log.WithSpanFromContext(context.Background(), ctx), dh.openOLT.GrpcTimeoutInterval)
+			if heartBeat, err := dh.Client.HeartbeatCheck(ctxWithTimeout, new(oop.Empty)); err != nil {
+				logger.Warnw(ctx, "hearbeat-failed", log.Fields{"device-id": dh.device.Id})
+				if timerCheck == nil {
+					// start a after func, when expired will update the state to the core
+					timerCheck = time.AfterFunc(dh.openOLT.HeartbeatFailReportInterval, func() { dh.updateStateUnreachable(ctx) })
+				}
+			} else {
+				if timerCheck != nil {
+					if timerCheck.Stop() {
+						logger.Debugw(ctx, "got-hearbeat-within-timeout", log.Fields{"device-id": dh.device.Id})
+					}
+					timerCheck = nil
+				}
+				logger.Debugw(ctx, "hearbeat",
+					log.Fields{"signature": heartBeat,
+						"device-id": dh.device.Id})
+			}
+			cancel()
+		case <-dh.stopHeartbeatCheck:
+			logger.Debugw(ctx, "stopping-heart-beat-check", log.Fields{"device-id": dh.device.Id})
+			return
+		}
+	}
+}
+
+func (dh *DeviceHandler) updateStateUnreachable(ctx context.Context) {
+	device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
+	if err != nil || device == nil {
+		_ = olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err).Log()
+	}
+
+	if device.ConnectStatus == voltha.ConnectStatus_REACHABLE {
+		if err = dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_UNREACHABLE, voltha.OperStatus_UNKNOWN); err != nil {
+			_ = olterrors.NewErrAdapter("device-state-update-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
+		}
+		if err = dh.coreProxy.PortsStateUpdate(ctx, dh.device.Id, 0, voltha.OperStatus_UNKNOWN); err != nil {
+			_ = olterrors.NewErrAdapter("port-update-failed", log.Fields{"device-id": dh.device.Id}, err).Log()
+		}
+		go dh.cleanupDeviceResources(ctx)
+
+		dh.lockDevice.RLock()
+		// Stop the read indication only if it the routine is active
+		// The read indication would have already stopped due to failure on the gRPC stream following OLT going unreachable
+		// Sending message on the 'stopIndication' channel again will cause the readIndication routine to immediately stop
+		// on next execution of the readIndication routine.
+		if dh.isReadIndicationRoutineActive {
+			dh.stopIndications <- true
+		}
+		dh.lockDevice.RUnlock()
+
+		dh.transitionMap.Handle(ctx, DeviceInit)
+
+	}
+}
+
+// EnablePort to enable Pon interface
+func (dh *DeviceHandler) EnablePort(ctx context.Context, port *voltha.Port) error {
+	logger.Debugw(ctx, "enable-port", log.Fields{"Device": dh.device, "port": port})
+	return dh.modifyPhyPort(ctx, port, true)
+}
+
+// DisablePort to disable pon interface
+func (dh *DeviceHandler) DisablePort(ctx context.Context, port *voltha.Port) error {
+	logger.Debugw(ctx, "disable-port", log.Fields{"Device": dh.device, "port": port})
+	return dh.modifyPhyPort(ctx, port, false)
+}
+
+//modifyPhyPort is common function to enable and disable the port. parm :enablePort, true to enablePort and false to disablePort.
+func (dh *DeviceHandler) modifyPhyPort(ctx context.Context, port *voltha.Port, enablePort bool) error {
+	logger.Infow(ctx, "modifyPhyPort", log.Fields{"port": port, "Enable": enablePort, "device-id": dh.device.Id})
+	if port.GetType() == voltha.Port_ETHERNET_NNI {
+		// Bug is opened for VOL-2505 to support NNI disable feature.
+		logger.Infow(ctx, "voltha-supports-single-nni-hence-disable-of-nni-not-allowed",
+			log.Fields{"device": dh.device, "port": port})
+		return olterrors.NewErrAdapter("illegal-port-request", log.Fields{
+			"port-type":    port.GetType,
+			"enable-state": enablePort}, nil)
+	}
+	ponID := PortNoToIntfID(port.GetPortNo(), voltha.Port_PON_OLT)
+	ponIntf := &oop.Interface{IntfId: ponID}
+	var operStatus voltha.OperStatus_Types
+	if enablePort {
+		operStatus = voltha.OperStatus_ACTIVE
+		out, err := dh.Client.EnablePonIf(ctx, ponIntf)
+
+		if err != nil {
+			return olterrors.NewErrAdapter("pon-port-enable-failed", log.Fields{
+				"device-id": dh.device.Id,
+				"port":      port}, err)
+		}
+		// updating interface local cache for collecting stats
+		dh.activePorts.Store(ponID, true)
+		logger.Infow(ctx, "enabled-pon-port", log.Fields{"out": out, "device-id": dh.device, "Port": port})
+	} else {
+		operStatus = voltha.OperStatus_UNKNOWN
+		out, err := dh.Client.DisablePonIf(ctx, ponIntf)
+		if err != nil {
+			return olterrors.NewErrAdapter("pon-port-disable-failed", log.Fields{
+				"device-id": dh.device.Id,
+				"port":      port}, err)
+		}
+		// updating interface local cache for collecting stats
+		dh.activePorts.Store(ponID, false)
+		logger.Infow(ctx, "disabled-pon-port", log.Fields{"out": out, "device-id": dh.device, "Port": port})
+	}
+	if err := dh.coreProxy.PortStateUpdate(ctx, dh.device.Id, voltha.Port_PON_OLT, port.PortNo, operStatus); err != nil {
+		return olterrors.NewErrAdapter("port-state-update-failed", log.Fields{
+			"device-id": dh.device.Id,
+			"port":      port.PortNo}, err)
+	}
+	return nil
+}
+
+//disableAdminDownPorts disables the ports, if the corresponding port Adminstate is disabled on reboot and Renable device.
+func (dh *DeviceHandler) disableAdminDownPorts(ctx context.Context, ports []*voltha.Port) error {
+	for _, port := range ports {
+		if port.AdminState == common.AdminState_DISABLED {
+			if err := dh.DisablePort(ctx, port); err != nil {
+				return olterrors.NewErrAdapter("port-disable-failed", log.Fields{
+					"device-id": dh.device.Id,
+					"port":      port}, err)
+			}
+		}
+	}
+	return nil
+}
+
+//populateActivePorts to populate activePorts map
+func (dh *DeviceHandler) populateActivePorts(ctx context.Context, ports []*voltha.Port) {
+	logger.Infow(ctx, "populateActivePorts", log.Fields{"device-id": dh.device.Id})
+	for _, port := range ports {
+		if port.Type == voltha.Port_ETHERNET_NNI {
+			if port.OperStatus == voltha.OperStatus_ACTIVE {
+				dh.activePorts.Store(PortNoToIntfID(port.PortNo, voltha.Port_ETHERNET_NNI), true)
+			} else {
+				dh.activePorts.Store(PortNoToIntfID(port.PortNo, voltha.Port_ETHERNET_NNI), false)
+			}
+		}
+		if port.Type == voltha.Port_PON_OLT {
+			if port.OperStatus == voltha.OperStatus_ACTIVE {
+				dh.activePorts.Store(PortNoToIntfID(port.PortNo, voltha.Port_PON_OLT), true)
+			} else {
+				dh.activePorts.Store(PortNoToIntfID(port.PortNo, voltha.Port_PON_OLT), false)
+			}
+		}
+	}
+}
+
+// ChildDeviceLost deletes ONU and clears pon resources related to it.
+func (dh *DeviceHandler) ChildDeviceLost(ctx context.Context, pPortNo uint32, onuID uint32) error {
+	logger.Debugw(ctx, "child-device-lost", log.Fields{"pdeviceID": dh.device.Id})
+	intfID := PortNoToIntfID(pPortNo, voltha.Port_PON_OLT)
+	onuKey := dh.formOnuKey(intfID, onuID)
+	onuDevice, ok := dh.onus.Load(onuKey)
+	if !ok {
+		return olterrors.NewErrAdapter("failed-to-load-onu-details",
+			log.Fields{
+				"device-id": dh.device.Id,
+				"onu-id":    onuID,
+				"intf-id":   intfID}, nil).Log()
+	}
+	var sn *oop.SerialNumber
+	var err error
+	if sn, err = dh.deStringifySerialNumber(onuDevice.(*OnuDevice).serialNumber); err != nil {
+		return olterrors.NewErrAdapter("failed-to-destringify-serial-number",
+			log.Fields{
+				"devicer-id":    dh.device.Id,
+				"serial-number": onuDevice.(*OnuDevice).serialNumber}, err).Log()
+	}
+
+	for uniID := 0; uniID < MaxUnisPerOnu; uniID++ {
+		var flowRemoveData pendingFlowRemoveData
+		key := pendingFlowRemoveDataKey{intfID: intfID, onuID: onuID, uniID: uint32(uniID)}
+		dh.lockDevice.RLock()
+		if flowRemoveData, ok = dh.pendingFlowRemoveDataPerSubscriber[key]; !ok {
+			dh.lockDevice.RUnlock()
+			continue
+		}
+		dh.lockDevice.RUnlock()
+
+		logger.Debugw(ctx, "wait-for-flow-remove-complete-before-processing-child-device-lost",
+			log.Fields{"int-id": intfID, "onu-id": onuID, "uni-id": uniID})
+		// Wait for all flow removes to finish first
+		<-flowRemoveData.allFlowsRemoved
+		logger.Debugw(ctx, "flow-removes-complete-for-subscriber",
+			log.Fields{"int-id": intfID, "onu-id": onuID, "uni-id": uniID})
+	}
+
+	onu := &oop.Onu{IntfId: intfID, OnuId: onuID, SerialNumber: sn}
+	if _, err := dh.Client.DeleteOnu(log.WithSpanFromContext(context.Background(), ctx), onu); err != nil {
+		return olterrors.NewErrAdapter("failed-to-delete-onu", log.Fields{
+			"device-id": dh.device.Id,
+			"onu-id":    onuID}, err).Log()
+	}
+	var onuGemData []rsrcMgr.OnuGemInfo
+	if onuMgr, ok := dh.resourceMgr.ResourceMgrs[intfID]; !ok {
+		logger.Warnw(ctx, "failed-to-get-resource-manager-for-interface-Id", log.Fields{
+			"device-id": dh.device.Id,
+			"intf-id":   intfID})
+	} else {
+		if err := onuMgr.GetOnuGemInfo(ctx, intfID, &onuGemData); err != nil {
+			logger.Warnw(ctx, "failed-to-get-onu-info-for-pon-port", log.Fields{
+				"device-id": dh.device.Id,
+				"intf-id":   intfID,
+				"error":     err})
+		} else {
+			for i, onu := range onuGemData {
+				if onu.OnuID == onuID && onu.SerialNumber == onuDevice.(*OnuDevice).serialNumber {
+					logger.Debugw(ctx, "onu-data", log.Fields{"onu": onu})
+					if err := dh.clearUNIData(ctx, &onu); err != nil {
+						logger.Warnw(ctx, "failed-to-clear-uni-data-for-onu", log.Fields{
+							"device-id":  dh.device.Id,
+							"onu-device": onu,
+							"error":      err})
+					}
+					// Clear flowids for gem cache.
+					for _, gem := range onu.GemPorts {
+						dh.resourceMgr.DeleteFlowIDsForGem(ctx, intfID, gem)
+					}
+					onuGemData = append(onuGemData[:i], onuGemData[i+1:]...)
+					err := onuMgr.AddOnuGemInfo(ctx, intfID, onuGemData)
+					if err != nil {
+						logger.Warnw(ctx, "persistence-update-onu-gem-info-failed", log.Fields{
+							"intf-id":    intfID,
+							"onu-device": onu,
+							"onu-gem":    onuGemData,
+							"error":      err})
+						//Not returning error on cleanup.
+					}
+					logger.Debugw(ctx, "removed-onu-gem-info", log.Fields{"intf": intfID, "onu-device": onu, "onugem": onuGemData})
+					dh.resourceMgr.FreeonuID(ctx, intfID, []uint32{onu.OnuID})
+					break
+				}
+			}
+		}
+	}
+	dh.onus.Delete(onuKey)
+	dh.discOnus.Delete(onuDevice.(*OnuDevice).serialNumber)
+	return nil
+}
+
+func getInPortFromFlow(flow *of.OfpFlowStats) uint32 {
+	for _, field := range flows.GetOfbFields(flow) {
+		if field.Type == flows.IN_PORT {
+			return field.GetPort()
+		}
+	}
+	return InvalidPort
+}
+
+func getOutPortFromFlow(flow *of.OfpFlowStats) uint32 {
+	for _, action := range flows.GetActions(flow) {
+		if action.Type == flows.OUTPUT {
+			if out := action.GetOutput(); out != nil {
+				return out.GetPort()
+			}
+		}
+	}
+	return InvalidPort
+}
+
+func (dh *DeviceHandler) incrementActiveFlowRemoveCount(ctx context.Context, flow *of.OfpFlowStats) {
+	inPort, outPort := getPorts(flow)
+	logger.Debugw(ctx, "increment-flow-remove-count-for-inPort-out-port", log.Fields{"inPort": inPort, "out-port": outPort})
+	if inPort != InvalidPort && outPort != InvalidPort {
+		_, intfID, onuID, uniID := ExtractAccessFromFlow(inPort, outPort)
+		key := pendingFlowRemoveDataKey{intfID: intfID, onuID: onuID, uniID: uniID}
+		logger.Debugw(ctx, "increment-flow-remove-count-for-subscriber", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+
+		dh.lockDevice.Lock()
+		defer dh.lockDevice.Unlock()
+		flowRemoveData, ok := dh.pendingFlowRemoveDataPerSubscriber[key]
+		if !ok {
+			flowRemoveData = pendingFlowRemoveData{
+				pendingFlowRemoveCount: 0,
+				allFlowsRemoved:        make(chan struct{}),
+			}
+		}
+		flowRemoveData.pendingFlowRemoveCount++
+		dh.pendingFlowRemoveDataPerSubscriber[key] = flowRemoveData
+
+		logger.Debugw(ctx, "current-flow-remove-count窶妬ncrement",
+			log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID,
+				"currCnt": dh.pendingFlowRemoveDataPerSubscriber[key].pendingFlowRemoveCount})
+	}
+}
+
+func (dh *DeviceHandler) decrementActiveFlowRemoveCount(ctx context.Context, flow *of.OfpFlowStats) {
+	inPort, outPort := getPorts(flow)
+	logger.Debugw(ctx, "decrement-flow-remove-count-for-inPort-out-port", log.Fields{"inPort": inPort, "out-port": outPort})
+	if inPort != InvalidPort && outPort != InvalidPort {
+		_, intfID, onuID, uniID := ExtractAccessFromFlow(uint32(inPort), uint32(outPort))
+		key := pendingFlowRemoveDataKey{intfID: intfID, onuID: onuID, uniID: uniID}
+		logger.Debugw(ctx, "decrement-flow-remove-count-for-subscriber", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+
+		dh.lockDevice.Lock()
+		defer dh.lockDevice.Unlock()
+		if val, ok := dh.pendingFlowRemoveDataPerSubscriber[key]; !ok {
+			logger.Fatalf(ctx, "flow-remove-key-not-found", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+		} else {
+			if val.pendingFlowRemoveCount > 0 {
+				val.pendingFlowRemoveCount--
+			}
+			logger.Debugw(ctx, "current-flow-remove-count-after-decrement",
+				log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID,
+					"currCnt": dh.pendingFlowRemoveDataPerSubscriber[key].pendingFlowRemoveCount})
+			// If all flow removes have finished, then close the channel to signal the receiver
+			// to go ahead with flow adds.
+			if val.pendingFlowRemoveCount == 0 {
+				close(val.allFlowsRemoved)
+				delete(dh.pendingFlowRemoveDataPerSubscriber, key)
+				return
+			}
+			dh.pendingFlowRemoveDataPerSubscriber[key] = val
+		}
+	}
+}
+
+func (dh *DeviceHandler) waitForFlowRemoveToFinish(ctx context.Context, flow *of.OfpFlowStats) {
+	var flowRemoveData pendingFlowRemoveData
+	var ok bool
+	inPort, outPort := getPorts(flow)
+	logger.Debugw(ctx, "wait-for-flow-remove-to-finish-for-inPort-out-port", log.Fields{"inPort": inPort, "out-port": outPort})
+	if inPort != InvalidPort && outPort != InvalidPort {
+		_, intfID, onuID, uniID := ExtractAccessFromFlow(inPort, outPort)
+		key := pendingFlowRemoveDataKey{intfID: intfID, onuID: onuID, uniID: uniID}
+		logger.Debugw(ctx, "wait-for-flow-remove-to-finish-for-subscriber", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+
+		dh.lockDevice.RLock()
+		if flowRemoveData, ok = dh.pendingFlowRemoveDataPerSubscriber[key]; !ok {
+			logger.Debugw(ctx, "no-pending-flow-to-remove", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+			dh.lockDevice.RUnlock()
+			return
+		}
+		dh.lockDevice.RUnlock()
+
+		// Wait for all flow removes to finish first
+		<-flowRemoveData.allFlowsRemoved
+
+		logger.Debugw(ctx, "all-flows-cleared--handling-flow-add-now", log.Fields{"intf-id": intfID, "onu-id": onuID, "uni-id": uniID})
+	}
+}
+
+func getPorts(flow *of.OfpFlowStats) (uint32, uint32) {
+	inPort := getInPortFromFlow(flow)
+	outPort := getOutPortFromFlow(flow)
+
+	if inPort == InvalidPort || outPort == InvalidPort {
+		return inPort, outPort
+	}
+
+	if isControllerFlow := IsControllerBoundFlow(outPort); isControllerFlow {
+		/* Get UNI port/ IN Port from tunnel ID field for upstream controller bound flows  */
+		if portType := IntfIDToPortTypeName(inPort); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				return uniPort, outPort
+			}
+		}
+	} else {
+		// Downstream flow from NNI to PON port , Use tunnel ID as new OUT port / UNI port
+		if portType := IntfIDToPortTypeName(outPort); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				return inPort, uniPort
+			}
+			// Upstream flow from PON to NNI port , Use tunnel ID as new IN port / UNI port
+		} else if portType := IntfIDToPortTypeName(inPort); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				return uniPort, outPort
+			}
+		}
+	}
+
+	return InvalidPort, InvalidPort
+}
+
+func extractOmciTransactionID(omciPkt []byte) uint16 {
+	if len(omciPkt) > 3 {
+		d := omciPkt[0:2]
+		transid := binary.BigEndian.Uint16(d)
+		return transid
+	}
+	return 0
+}
+
+// StoreOnuDevice stores the onu parameters to the local cache.
+func (dh *DeviceHandler) StoreOnuDevice(onuDevice *OnuDevice) {
+	onuKey := dh.formOnuKey(onuDevice.intfID, onuDevice.onuID)
+	dh.onus.Store(onuKey, onuDevice)
+}
+
+func (dh *DeviceHandler) getExtValue(ctx context.Context, device *voltha.Device, value voltha.ValueType_Type) (*voltha.ReturnValues, error) {
+	var err error
+	var sn *oop.SerialNumber
+	var ID uint32
+	resp := new(voltha.ReturnValues)
+	valueparam := new(oop.ValueParam)
+	ctx = log.WithSpanFromContext(context.Background(), ctx)
+	logger.Infow(ctx, "getExtValue", log.Fields{"onu-id": device.Id, "pon-intf": device.ParentPortNo})
+	if sn, err = dh.deStringifySerialNumber(device.SerialNumber); err != nil {
+		return nil, err
+	}
+	ID = device.ProxyAddress.GetOnuId()
+	Onu := oop.Onu{IntfId: device.ParentPortNo, OnuId: ID, SerialNumber: sn}
+	valueparam.Onu = &Onu
+	valueparam.Value = value
+
+	resp.Unsupported = uint32(value)
+	_ = ctx
+
+	/*
+		resp, err = dh.Client.GetValue(ctx, valueparam)
+		if err != nil {
+			logger.Errorw("error-while-getValue", log.Fields{"DeviceID": dh.device, "onu-id": onuid, "error": err})
+			return nil, err
+		}
+	*/
+
+	logger.Infow(ctx, "get-ext-value", log.Fields{"resp": resp, "device-id": dh.device, "onu-id": device.Id, "pon-intf": device.ParentPortNo})
+	return resp, nil
+}
+
+// func (dh *DeviceHandler) L2oamCmdRequest2(ctx context.Context, device *voltha.Device, request *voltha.SimulateAlarmRequest) error {
+// 	logger.Infow(ctx, "L2oamRequest", log.Fields{"device-id": device.Id})
+
+// 	switch request.Drift {
+// 	case 0: // add-flow
+// 		L2oamAfterKeepAlive(ctx, dh)
+// 		L2oamAddFlow(ctx, dh)
+
+// 	case 1: // add-flow-dev
+// 		tomiObjContext := L2oamAddFlowToDeviceDS(ctx, dh)
+// 		if tomiObjContext != nil {
+// 			L2oamAddFlowToDeviceUS(ctx, dh, tomiObjContext)
+// 		}
+// 	}
+
+// 	return nil
+// }
+
+// L2oamCmdRequest executes some commands for L2OAM
+func (dh *DeviceHandler) L2oamCmdRequest(ctx context.Context, device *voltha.Device, request *voltha.SimulateAlarmRequest) error {
+	logger.Infow(ctx, "L2oamCmdRequest()", log.Fields{"device-id": device.Id})
+
+	cmd := parseL2oamCmd(request)
+	logger.Info(ctx, "parseL2oamCmd() request=%v, cmd=%v", request, cmd)
+
+	switch cmd.Type {
+	case "add-flow":
+		//L2oamAfterKeepAlive(ctx, dh)
+		L2oamAddFlow(ctx, dh, cmd)
+
+	case "add-flow-dev":
+		err := L2oamAddFlowToDeviceAll(ctx, dh, cmd)
+		if err == nil {
+			onu := FindL2oamDeviceByDeviceID(cmd.OnuDeviceID)
+			if onu == nil {
+				logger.Debug(ctx, fmt.Sprintf("L2oamCmdRequest() FindL2oamDevice() onu not found. deviceId=%s", cmd.OnuDeviceID))
+			} else {
+				// start ONU mount sequence
+				onu.startMountSequence(context.Background(), l2oam.OnuPkgType, cmd)
+			}
+		}
+	default:
+		logger.Error(ctx, "L2oamCmdRequest() cmd.Type error. request=%v, cmd=%v", request, cmd)
+	}
+
+	return nil
+}
+
+// L2oamCmd contains command arguments for L2OAM command
+type L2oamCmd struct {
+	Type        string
+	Cir         []byte
+	Pir         []byte
+	Tpid        []byte
+	Vid         []byte
+	Itpid       []byte
+	Ivid        []byte
+	OnuDeviceID string
+}
+
+func parseL2oamCmd(request *voltha.SimulateAlarmRequest) *L2oamCmd {
+	l2oamCmd := &L2oamCmd{
+		Type:        "unknown",
+		Cir:         []byte{0x00, 0x00, 0x03, 0xe8},
+		Pir:         []byte{0x00, 0x98, 0x96, 0x80},
+		Tpid:        []byte{0x88, 0xa8},
+		Vid:         []byte{0x00, 0x64},
+		Itpid:       []byte{0x81, 0x00},
+		Ivid:        []byte{0x00, 0x0a},
+		OnuDeviceID: "",
+	}
+
+	if request.Indicator == "" {
+		return l2oamCmd
+	}
+	cmdStr := strings.Replace(request.Indicator, "\"", "", -1)
+	if request.Drift == 0 {
+		l2oamCmd.Type = "add-flow"
+	} else {
+		l2oamCmd.Type = "add-flow-dev"
+	}
+
+	cmds := strings.Split(cmdStr, ",")
+	for _, cmd := range cmds {
+		kv := strings.Split(cmd, "=")
+		key := kv[0]
+		value := kv[1]
+		switch key {
+		case "cir":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Cir = bytes
+		case "pir":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Pir = bytes
+		case "tpid":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Tpid = bytes
+		case "vid":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Vid = bytes
+		case "itpid":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Itpid = bytes
+		case "ivid":
+			bytes, _ := hex.DecodeString(value)
+			l2oamCmd.Ivid = bytes
+		case "onudeviceid":
+			l2oamCmd.OnuDeviceID = value
+		default:
+		}
+	}
+	return l2oamCmd
+}
diff --git a/internal/pkg/core/device_handler_test.go b/internal/pkg/core/device_handler_test.go
new file mode 100644
index 0000000..70b92bb
--- /dev/null
+++ b/internal/pkg/core/device_handler_test.go
@@ -0,0 +1,1184 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"net"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/golang/protobuf/ptypes"
+	"github.com/golang/protobuf/ptypes/any"
+	"github.com/opencord/voltha-lib-go/v3/pkg/db"
+	fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-lib-go/v3/pkg/pmmetrics"
+	ponrmgr "github.com/opencord/voltha-lib-go/v3/pkg/ponresourcemanager"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/config"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
+	"github.com/opencord/voltha-openolt-adapter/pkg/mocks"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	of "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+func newMockCoreProxy() *mocks.MockCoreProxy {
+	mcp := mocks.MockCoreProxy{
+		Devices:     make(map[string]*voltha.Device),
+		DevicePorts: make(map[string][]*voltha.Port),
+	}
+	var pm []*voltha.PmConfig
+	mcp.Devices["olt"] = &voltha.Device{
+		Id:           "olt",
+		Root:         true,
+		ParentId:     "logical_device",
+		ParentPortNo: 1,
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "olt",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+		PmConfigs: &voltha.PmConfigs{
+			DefaultFreq:  10,
+			Id:           "olt",
+			FreqOverride: false,
+			Grouped:      false,
+			Metrics:      pm,
+		},
+	}
+	mcp.DevicePorts["olt"] = []*voltha.Port{
+		{PortNo: 1, Label: "pon"},
+		{PortNo: 2, Label: "nni"},
+	}
+
+	mcp.Devices["onu1"] = &voltha.Device{
+		Id:           "1",
+		Root:         false,
+		ParentId:     "olt",
+		ParentPortNo: 1,
+
+		OperStatus: 4,
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			OnuId:          1,
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+		PmConfigs: &voltha.PmConfigs{
+			DefaultFreq:  10,
+			Id:           "olt",
+			FreqOverride: false,
+			Grouped:      false,
+			Metrics:      pm,
+		},
+	}
+	mcp.DevicePorts["onu1"] = []*voltha.Port{
+		{PortNo: 1, Label: "pon"},
+		{PortNo: 2, Label: "uni"},
+	}
+
+	mcp.Devices["onu2"] = &voltha.Device{
+		Id:         "2",
+		Root:       false,
+		ParentId:   "olt",
+		OperStatus: 2,
+
+		ParentPortNo: 1,
+
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			OnuId:          2,
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+		PmConfigs: &voltha.PmConfigs{
+			DefaultFreq:  10,
+			Id:           "olt",
+			FreqOverride: false,
+			Grouped:      false,
+			Metrics:      pm,
+		},
+	}
+	mcp.DevicePorts["onu2"] = []*voltha.Port{
+		{PortNo: 1, Label: "pon"},
+		{PortNo: 2, Label: "uni"},
+	}
+	return &mcp
+}
+
+func newMockDeviceHandler() *DeviceHandler {
+	device := &voltha.Device{
+		Id:       "olt",
+		Root:     true,
+		ParentId: "logical_device",
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "olt",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+		MacAddress:    "08:00:27:1c:18:55",
+	}
+	cp := newMockCoreProxy()
+	ap := &mocks.MockAdapterProxy{}
+	ep := &mocks.MockEventProxy{}
+	cnf := &config.AdapterFlags{
+		InterfaceName: "enp0s3",
+		SrcMac:        "08:00:27:1c:18:9a",
+	}
+	openOLT := &OpenOLT{
+		coreProxy:    cp,
+		adapterProxy: ap,
+		eventProxy:   ep,
+		config:       cnf,
+	}
+	dh := NewDeviceHandler(cp, ap, ep, device, openOLT)
+	oopRanges := []*oop.DeviceInfo_DeviceResourceRanges{{
+		IntfIds:    []uint32{0, 1},
+		Technology: "xgs-pon",
+		Pools:      []*oop.DeviceInfo_DeviceResourceRanges_Pool{{}},
+	}}
+
+	deviceInf := &oop.DeviceInfo{Vendor: "openolt", Ranges: oopRanges, Model: "openolt", DeviceId: dh.device.Id, PonPorts: 2}
+	rsrMgr := resourcemanager.OpenOltResourceMgr{DeviceID: dh.device.Id, DeviceType: dh.device.Type, DevInfo: deviceInf,
+		KVStore: &db.Backend{
+			Client: &mocks.MockKVClient{},
+		}}
+	rsrMgr.AllocIDMgmtLock = make([]sync.RWMutex, deviceInf.PonPorts)
+	rsrMgr.GemPortIDMgmtLock = make([]sync.RWMutex, deviceInf.PonPorts)
+	rsrMgr.OnuIDMgmtLock = make([]sync.RWMutex, deviceInf.PonPorts)
+
+	dh.resourceMgr = &rsrMgr
+	dh.resourceMgr.ResourceMgrs = make(map[uint32]*ponrmgr.PONResourceManager)
+	ranges := make(map[string]interface{})
+	sharedIdxByType := make(map[string]string)
+	sharedIdxByType["ALLOC_ID"] = "ALLOC_ID"
+	sharedIdxByType["ONU_ID"] = "ONU_ID"
+	sharedIdxByType["GEMPORT_ID"] = "GEMPORT_ID"
+	sharedIdxByType["FLOW_ID"] = "FLOW_ID"
+	ranges["ONU_ID"] = uint32(0)
+	ranges["GEMPORT_ID"] = uint32(0)
+	ranges["ALLOC_ID"] = uint32(0)
+	ranges["FLOW_ID"] = uint32(0)
+	ranges["onu_id_shared"] = uint32(0)
+	ranges["alloc_id_shared"] = uint32(0)
+	ranges["gemport_id_shared"] = uint32(0)
+	ranges["flow_id_shared"] = uint32(0)
+
+	ponmgr := &ponrmgr.PONResourceManager{
+		DeviceID: "onu-1",
+		IntfIDs:  []uint32{0, 1},
+		KVStore: &db.Backend{
+			Client: &mocks.MockKVClient{},
+		},
+		PonResourceRanges: ranges,
+		SharedIdxByType:   sharedIdxByType,
+	}
+	dh.resourceMgr.ResourceMgrs[0] = ponmgr
+	dh.resourceMgr.ResourceMgrs[1] = ponmgr
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	dh.flowMgr = NewFlowManager(ctx, dh, dh.resourceMgr)
+	dh.Client = &mocks.MockOpenoltClient{}
+	dh.eventMgr = &OpenOltEventMgr{eventProxy: &mocks.MockEventProxy{}, handler: dh}
+	dh.transitionMap = &TransitionMap{}
+	dh.portStats = &OpenOltStatisticsMgr{}
+
+	var pmNames = []string{
+		"rx_bytes",
+		"rx_packets",
+		"rx_mcast_packets",
+		"rx_bcast_packets",
+		"tx_bytes",
+		"tx_packets",
+		"tx_mcast_packets",
+		"tx_bcast_packets",
+	}
+
+	dh.metrics = pmmetrics.NewPmMetrics(device.Id, pmmetrics.Frequency(2), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
+	return dh
+}
+
+func negativeDeviceHandler() *DeviceHandler {
+	dh := newMockDeviceHandler()
+	device := dh.device
+	device.Id = ""
+	return dh
+}
+
+func Test_generateMacFromHost(t *testing.T) {
+
+	ctx := context.Background()
+	type args struct {
+		host string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{"generateMacFromHost-1", args{host: "localhost"}, "00:00:7f:00:00:01", false},
+		{"generateMacFromHost-2", args{host: "10.10.10.10"}, "00:00:0a:0a:0a:0a", false},
+		//{"generateMacFromHost-3", args{host: "google.com"}, "00:00:d8:3a:c8:8e", false},
+		{"generateMacFromHost-4", args{host: "testing3"}, "", true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := generateMacFromHost(ctx, tt.args.host)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("generateMacFromHost() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("generateMacFromHost() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+func Test_macifyIP(t *testing.T) {
+	type args struct {
+		ip net.IP
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{{
+		"macifyIP-1",
+		args{ip: net.ParseIP("10.10.10.10")},
+		"00:00:0a:0a:0a:0a",
+	},
+		{
+			"macifyIP-2",
+			args{ip: net.ParseIP("127.0.0.1")},
+			"00:00:7f:00:00:01",
+		},
+		{
+			"macifyIP-3",
+			args{ip: net.ParseIP("127.0.0.1/24")},
+			"",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := macifyIP(tt.args.ip); got != tt.want {
+				t.Errorf("macifyIP() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func sparseCompare(keys []string, spec, target interface{}) bool {
+	if spec == target {
+		return true
+	}
+	if spec == nil || target == nil {
+		return false
+	}
+	typeSpec := reflect.TypeOf(spec)
+	typeTarget := reflect.TypeOf(target)
+	if typeSpec != typeTarget {
+		return false
+	}
+
+	vSpec := reflect.ValueOf(spec)
+	vTarget := reflect.ValueOf(target)
+	if vSpec.Kind() == reflect.Ptr {
+		vSpec = vSpec.Elem()
+		vTarget = vTarget.Elem()
+	}
+
+	for _, key := range keys {
+		fSpec := vSpec.FieldByName(key)
+		fTarget := vTarget.FieldByName(key)
+		if !reflect.DeepEqual(fSpec.Interface(), fTarget.Interface()) {
+			return false
+		}
+	}
+	return true
+}
+
+func TestDeviceHandler_GetChildDevice(t *testing.T) {
+	ctx := context.Background()
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		parentPort uint32
+		onuID      uint32
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+		want          *voltha.Device
+		errType       reflect.Type
+	}{
+		{"GetChildDevice-1", dh1,
+			args{parentPort: 1,
+				onuID: 1},
+			&voltha.Device{
+				Id:           "1",
+				ParentId:     "olt",
+				ParentPortNo: 1,
+			},
+			nil,
+		},
+		{"GetChildDevice-2", dh2,
+			args{parentPort: 1,
+				onuID: 1},
+			nil,
+			reflect.TypeOf(&olterrors.ErrNotFound{}),
+		},
+	}
+
+	/*
+	   --- FAIL: TestDeviceHandler_GetChildDevice/GetChildDevice-1 (0.00s)
+	       device_handler_test.go:309: GetportLabel() => want=(, <nil>) got=(id:"1" parent_id:"olt" parent_port_no:1 proxy_address:<channel_id:1 channel_group_id:1 onu_id:1 > oper_status:ACTIVE connect_status:UNREACHABLE ports:<port_no:1 label:"pon" > ports:<port_no:2 label:"uni" > pm_configs:<id:"olt" default_freq:10 > , <nil>)
+	   --- FAIL: TestDeviceHandler_GetChildDevice/GetChildDevice-2 (0.00s)
+	*/
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.devicehandler.GetChildDevice(ctx, tt.args.parentPort, tt.args.onuID)
+			if reflect.TypeOf(err) != tt.errType || !sparseCompare([]string{"Id", "ParentId", "ParentPortNo"}, tt.want, got) {
+				t.Errorf("GetportLabel() => want=(%v, %v) got=(%v, %v)",
+					tt.want, tt.errType, got, reflect.TypeOf(err))
+				return
+			}
+			t.Log("onu device id", got)
+		})
+	}
+}
+
+func TestGetportLabel(t *testing.T) {
+	invalid := reflect.TypeOf(&olterrors.ErrInvalidValue{})
+	type args struct {
+		portNum  uint32
+		portType voltha.Port_PortType
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		errType reflect.Type
+	}{
+		{"GetportLabel-1", args{portNum: 0, portType: 0}, "", invalid},
+		{"GetportLabel-2", args{portNum: 1, portType: 1}, "nni-1", nil},
+		{"GetportLabel-3", args{portNum: 2, portType: 2}, "", invalid},
+		{"GetportLabel-4", args{portNum: 3, portType: 3}, "pon-3", nil},
+		{"GetportLabel-5", args{portNum: 4, portType: 4}, "", invalid},
+		{"GetportLabel-6", args{portNum: 5, portType: 5}, "", invalid},
+		{"GetportLabel-7", args{portNum: 6, portType: 6}, "", invalid},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetportLabel(tt.args.portNum, tt.args.portType)
+			if reflect.TypeOf(err) != tt.errType || got != tt.want {
+				t.Errorf("GetportLabel() => want=(%v, %v) got=(%v, %v)",
+					tt.want, tt.errType, got, reflect.TypeOf(err))
+			}
+
+		})
+	}
+}
+
+func TestDeviceHandler_ProcessInterAdapterMessage(t *testing.T) {
+	ctx := context.Background()
+	dh := newMockDeviceHandler()
+	proxyAddr := dh.device.ProxyAddress
+	body := &ic.InterAdapterOmciMessage{
+		Message:      []byte("asdfasdfasdfasdfas"),
+		ProxyAddress: proxyAddr,
+	}
+	body2 := &ic.InterAdapterOmciMessage{
+		Message: []byte("asdfasdfasdfasdfas"),
+		//ProxyAddress: &voltha.Device_ProxyAddress{},
+	}
+	body3 := &ic.InterAdapterTechProfileDownloadMessage{}
+	var marshalledData *any.Any
+	var err error
+
+	if marshalledData, err = ptypes.MarshalAny(body); err != nil {
+		logger.Errorw(ctx, "cannot-marshal-request", log.Fields{"error": err})
+	}
+
+	var marshalledData1 *any.Any
+
+	if marshalledData1, err = ptypes.MarshalAny(body2); err != nil {
+		logger.Errorw(ctx, "cannot-marshal-request", log.Fields{"error": err})
+	}
+	var marshalledData2 *any.Any
+
+	if marshalledData2, err = ptypes.MarshalAny(body3); err != nil {
+		logger.Errorw(ctx, "cannot-marshal-request", log.Fields{"error": err})
+	}
+	type args struct {
+		msg *ic.InterAdapterMessage
+	}
+	invalid := reflect.TypeOf(&olterrors.ErrInvalidValue{})
+	tests := []struct {
+		name    string
+		args    args
+		wantErr reflect.Type
+	}{
+		{"ProcessInterAdapterMessage-1", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_FLOW_REQUEST,
+			},
+			Body: marshalledData,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-2", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_FLOW_RESPONSE,
+			},
+			Body: marshalledData1,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-3", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_OMCI_REQUEST,
+			},
+			Body: marshalledData,
+		}}, reflect.TypeOf(&olterrors.ErrCommunication{})},
+		{"ProcessInterAdapterMessage-4", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_OMCI_RESPONSE,
+			}, Body: marshalledData,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-5", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_METRICS_REQUEST,
+			}, Body: marshalledData1,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-6", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_METRICS_RESPONSE,
+			}, Body: marshalledData,
+		}}, invalid},
+		/*
+			{"ProcessInterAdapterMessage-7", args{msg: &ic.InterAdapterMessage{
+				Header: &ic.InterAdapterHeader{
+					Id:   "012345",
+					Type: ic.InterAdapterMessageType_ONU_IND_REQUEST,
+				}, Body: marshalledData,
+			}}, nil},
+		*/
+		{"ProcessInterAdapterMessage-8", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_ONU_IND_RESPONSE,
+			}, Body: marshalledData,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-9", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_TECH_PROFILE_DOWNLOAD_REQUEST,
+			}, Body: marshalledData,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-10", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_DELETE_GEM_PORT_REQUEST,
+			}, Body: marshalledData2,
+		}}, invalid},
+		{"ProcessInterAdapterMessage-11", args{msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:   "012345",
+				Type: ic.InterAdapterMessageType_DELETE_TCONT_REQUEST,
+			}, Body: marshalledData2,
+		}}, invalid},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			if err := dh.ProcessInterAdapterMessage(ctx, tt.args.msg); reflect.TypeOf(err) != tt.wantErr {
+				t.Errorf("DeviceHandler.ProcessInterAdapterMessage() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_sendProxiedMessage(t *testing.T) {
+	ctx := context.Background()
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	device1 := &voltha.Device{
+		Id:       "onu1",
+		Root:     false,
+		ParentId: "logical_device",
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "onu1",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+	}
+	device2 := device1
+	device2.ConnectStatus = 2
+	iaomciMsg1 := &ic.InterAdapterOmciMessage{
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "onu2",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+			//OnuId:          2,
+		},
+		ConnectStatus: 1,
+	}
+	iaomciMsg2 := &ic.InterAdapterOmciMessage{
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "onu3",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+	}
+	type args struct {
+		onuDevice *voltha.Device
+		omciMsg   *ic.InterAdapterOmciMessage
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		{"sendProxiedMessage-1", dh1, args{onuDevice: device1, omciMsg: &ic.InterAdapterOmciMessage{}}},
+		{"sendProxiedMessage-2", dh1, args{onuDevice: device2, omciMsg: &ic.InterAdapterOmciMessage{}}},
+		{"sendProxiedMessage-3", dh1, args{onuDevice: nil, omciMsg: iaomciMsg1}},
+		{"sendProxiedMessage-4", dh1, args{onuDevice: nil, omciMsg: iaomciMsg2}},
+		{"sendProxiedMessage-5", dh2, args{onuDevice: nil, omciMsg: iaomciMsg2}},
+		{"sendProxiedMessage-6", dh2, args{onuDevice: device1, omciMsg: &ic.InterAdapterOmciMessage{}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_ = tt.devicehandler.sendProxiedMessage(ctx, tt.args.onuDevice, tt.args.omciMsg)
+			//TODO: actually verify test cases
+		})
+	}
+}
+
+func TestDeviceHandler_SendPacketInToCore(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+
+	type args struct {
+		logicalPort   uint32
+		packetPayload []byte
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		{"SendPacketInToCore-1", dh1, args{logicalPort: 1, packetPayload: []byte("test1")}},
+		{"SendPacketInToCore-2", dh1, args{logicalPort: 1, packetPayload: []byte("")}},
+		{"SendPacketInToCore-3", dh2, args{logicalPort: 1, packetPayload: []byte("test1")}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_ = tt.devicehandler.SendPacketInToCore(context.Background(), tt.args.logicalPort, tt.args.packetPayload)
+			//TODO: actually verify test cases
+		})
+	}
+}
+
+func TestDeviceHandler_DisableDevice(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+		wantErr       bool
+	}{
+		{"DisableDevice-1", dh1, args{device: dh1.device}, false},
+		{"DisableDevice-2", dh1, args{device: dh2.device}, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := tt.devicehandler.DisableDevice(context.Background(), tt.args.device); (err != nil) != tt.wantErr {
+				t.Errorf("DeviceHandler.DisableDevice() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_ReenableDevice(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+		wantErr       bool
+	}{
+		{"ReenableDevice-1", dh1, args{device: dh1.device}, false},
+		{"ReenableDevice-2", dh1, args{device: &voltha.Device{}}, true},
+		{"ReenableDevice-3", dh2, args{device: dh1.device}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dh := tt.devicehandler
+			if err := dh.ReenableDevice(context.Background(), tt.args.device); (err != nil) != tt.wantErr {
+				t.Errorf("DeviceHandler.ReenableDevice() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_RebootDevice(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := newMockDeviceHandler()
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		// TODO: Add test cases.
+		{"RebootDevice-1", dh1, args{device: dh1.device}},
+		{"RebootDevice-2", dh1, args{device: dh2.device}},
+		{"RebootDevice-3", dh2, args{device: dh2.device}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			if err := tt.devicehandler.RebootDevice(context.Background(), tt.args.device); err != nil {
+				t.Errorf("DeviceHandler.RebootDevice() error = %v", err)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_handleIndication(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	dh3 := newMockDeviceHandler()
+	dh3.onus = sync.Map{}
+	dh3.onus.Store("onu1", NewOnuDevice("onu1", "onu1", "onu1", 1, 1, "onu1", false))
+	dh3.onus.Store("onu2", NewOnuDevice("onu2", "onu2", "onu2", 2, 2, "onu2", false))
+
+	type args struct {
+		indication *oop.Indication
+	}
+	tests := []struct {
+		name          string
+		deviceHandler *DeviceHandler
+		args          args
+	}{
+		// TODO: Add test cases.
+		{"handleIndication-1", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "up"}}}}},
+		{"handleIndication-2", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "down"}}}}},
+		{"handleIndication-3", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-4", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "down"}}}}},
+		{"handleIndication-5", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "nni", IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-6", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "pon", IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-7", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuDiscInd{OnuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}}}},
+		{"handleIndication-8", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
+		{"handleIndication-9", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
+		{"handleIndication-10", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
+		{"handleIndication-11", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
+		{"handleIndication-12", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 1, Pkt: []byte("onu123-random value")}}}}},
+		{"handleIndication-13", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", IntfId: 1, GemportId: 1, FlowId: 1234, PortNo: 1}}}}},
+		{"handleIndication-14", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PortStats{PortStats: &oop.PortStatistics{IntfId: 1, RxBytes: 100, RxPackets: 100, RxUcastPackets: 100, RxMcastPackets: 100, RxBcastPackets: 100, RxErrorPackets: 100, TxBytes: 100, TxPackets: 100, TxUcastPackets: 100, TxMcastPackets: 100, TxBcastPackets: 100, TxErrorPackets: 100, RxCrcErrors: 100, BipErrors: 100, Timestamp: 1000}}}}},
+		{"handleIndication-15", dh1, args{indication: &oop.Indication{Data: &oop.Indication_FlowStats{FlowStats: &oop.FlowStatistics{RxBytes: 100, RxPackets: 100, TxBytes: 100, TxPackets: 100, Timestamp: 1000}}}}},
+		{"handleIndication-16", dh1, args{indication: &oop.Indication{Data: &oop.Indication_AlarmInd{AlarmInd: &oop.AlarmIndication{}}}}},
+		{"handleIndication-17", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", FlowId: 1234, PortNo: 1}}}}},
+		{"handleIndication-18", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{}}}}},
+
+		// Negative testcases
+		{"handleIndication-19", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "up"}}}}},
+		{"handleIndication-20", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "down"}}}}},
+		{"handleIndication-21", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-22", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "down"}}}}},
+		{"handleIndication-23", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "nni", IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-24", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "pon", IntfId: 1, OperState: "up"}}}}},
+		{"handleIndication-25", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuDiscInd{OnuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}}}},
+		{"handleIndication-26", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
+		{"handleIndication-27", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
+		{"handleIndication-28", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
+		{"handleIndication-29", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
+		{"handleIndication-30", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 1, Pkt: []byte("onu123-random value")}}}}},
+		{"handleIndication-31", dh2, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", IntfId: 1, GemportId: 1, FlowId: 1234, PortNo: 1}}}}},
+		{"handleIndication-32", dh2, args{indication: &oop.Indication{Data: &oop.Indication_PortStats{PortStats: &oop.PortStatistics{IntfId: 1, RxBytes: 100, RxPackets: 100, RxUcastPackets: 100, RxMcastPackets: 100, RxBcastPackets: 100, RxErrorPackets: 100, TxBytes: 100, TxPackets: 100, TxUcastPackets: 100, TxMcastPackets: 100, TxBcastPackets: 100, TxErrorPackets: 100, RxCrcErrors: 100, BipErrors: 100, Timestamp: 1000}}}}},
+		{"handleIndication-33", dh2, args{indication: &oop.Indication{Data: &oop.Indication_FlowStats{FlowStats: &oop.FlowStatistics{RxBytes: 100, RxPackets: 100, TxBytes: 100, TxPackets: 100, Timestamp: 1000}}}}},
+		{"handleIndication-34", dh2, args{indication: &oop.Indication{Data: &oop.Indication_AlarmInd{AlarmInd: &oop.AlarmIndication{}}}}},
+		//
+		{"handleIndication-35", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
+		{"handleIndication-36", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
+		{"handleIndication-37", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
+		{"handleIndication-38", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
+		{"handleIndication-30", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 4, Pkt: []byte("onu123-random value")}}}}},
+		{"handleIndication-30", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 4, Pkt: []byte("onu123-random value")}}}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dh := tt.deviceHandler
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			dh.handleIndication(ctx, tt.args.indication)
+		})
+	}
+}
+
+func TestDeviceHandler_addPort(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		intfID   uint32
+		portType voltha.Port_PortType
+		state    string
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		// State up
+		{"addPort.1", dh1, args{intfID: 1, portType: voltha.Port_UNKNOWN, state: "up"}},
+		{"addPort.2", dh1, args{intfID: 1, portType: voltha.Port_VENET_OLT, state: "up"}},
+		{"addPort.3", dh1, args{intfID: 1, portType: voltha.Port_VENET_ONU, state: "up"}},
+		{"addPort.4", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "up"}},
+		{"addPort.5", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "up"}},
+		{"addPort.6", dh1, args{intfID: 1, portType: voltha.Port_PON_OLT, state: "up"}},
+		{"addPort.7", dh1, args{intfID: 1, portType: voltha.Port_PON_ONU, state: "up"}},
+		{"addPort.8", dh1, args{intfID: 1, portType: 8, state: "up"}},
+		// state discovery
+		{"addPort.9", dh1, args{intfID: 1, portType: voltha.Port_UNKNOWN, state: "down"}},
+		{"addPort.10", dh1, args{intfID: 1, portType: voltha.Port_VENET_OLT, state: "down"}},
+		{"addPort.11", dh1, args{intfID: 1, portType: voltha.Port_VENET_ONU, state: "down"}},
+		{"addPort.12", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "down"}},
+		{"addPort.13", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "down"}},
+		{"addPort.14", dh1, args{intfID: 1, portType: voltha.Port_PON_OLT, state: "down"}},
+		{"addPort.15", dh1, args{intfID: 1, portType: voltha.Port_PON_ONU, state: "down"}},
+		{"addPort.16", dh1, args{intfID: 1, portType: 8, state: "down"}},
+
+		{"addPort.17", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "up"}},
+		{"addPort.18", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "up"}},
+		{"addPort.19", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "down"}},
+		{"addPort.20", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "down"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_ = tt.devicehandler.addPort(context.Background(), tt.args.intfID, tt.args.portType, tt.args.state)
+			//TODO: actually verify test cases
+		})
+	}
+}
+
+func Test_macAddressToUint32Array(t *testing.T) {
+	type args struct {
+		mac string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []uint32
+	}{
+		// TODO: Add test cases.
+		{"macAddressToUint32Array-1", args{mac: "00:00:00:00:00:01"}, []uint32{0, 0, 0, 0, 0, 1}},
+		{"macAddressToUint32Array-2", args{mac: "0abcdef"}, []uint32{11259375}},
+		{"macAddressToUint32Array-3", args{mac: "testing"}, []uint32{1, 2, 3, 4, 5, 6}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := macAddressToUint32Array(tt.args.mac); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("macAddressToUint32Array() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_handleOltIndication(t *testing.T) {
+
+	type args struct {
+		oltIndication *oop.OltIndication
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{"handleOltIndication-1", args{oltIndication: &oop.OltIndication{OperState: "up"}}},
+		{"handleOltIndication-2", args{oltIndication: &oop.OltIndication{OperState: "down"}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dh := newMockDeviceHandler()
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := dh.handleOltIndication(ctx, tt.args.oltIndication); err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_AdoptDevice(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		// TODO: Add test cases.
+		{"AdoptDevice-1", dh1, args{device: dh1.device}},
+		{"AdoptDevice-2", dh2, args{device: dh2.device}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			//dh.doStateInit()
+			//	context.
+			//dh.AdoptDevice(tt.args.device)
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := tt.devicehandler.postInit(ctx); err != nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_activateONU(t *testing.T) {
+	dh := newMockDeviceHandler()
+	dh1 := negativeDeviceHandler()
+	type args struct {
+		intfID       uint32
+		onuID        int64
+		serialNum    *oop.SerialNumber
+		serialNumber string
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		{"activateONU-1", dh, args{intfID: 0, onuID: 1, serialNum: &oop.SerialNumber{VendorId: []byte("onu1")}}},
+		{"activateONU-2", dh, args{intfID: 1, onuID: 2, serialNum: &oop.SerialNumber{VendorId: []byte("onu2")}}},
+		{"activateONU-3", dh1, args{intfID: 0, onuID: 1, serialNum: &oop.SerialNumber{VendorId: []byte("onu1")}}},
+		{"activateONU-4", dh1, args{intfID: 1, onuID: 2, serialNum: &oop.SerialNumber{VendorId: []byte("onu2")}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			_ = tt.devicehandler.activateONU(ctx, tt.args.intfID, tt.args.onuID, tt.args.serialNum, tt.args.serialNumber)
+			//TODO: actually verify test cases
+		})
+	}
+}
+
+func TestDeviceHandler_start(t *testing.T) {
+	dh := newMockDeviceHandler()
+	dh1 := negativeDeviceHandler()
+	dh.start(context.Background())
+	dh.stop(context.Background())
+
+	dh1.start(context.Background())
+	dh1.stop(context.Background())
+
+}
+
+func TestDeviceHandler_PacketOut(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	acts := []*ofp.OfpAction{
+		fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA))),
+		fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+		fu.Output(1),
+	}
+	pktout := &ofp.OfpPacketOut{BufferId: 0, InPort: 1, Actions: acts, Data: []byte("AYDCAAAOAODsSE5TiMwCBwQA4OxITlIEBQUwLzUxBgIAFAgEMC81MQoJbG9jYWxob3N0EBwFAawbqqACAAAAoRAxLjMuNi4xLjQuMS40NDEz/gYAgMILAgD+GQCAwgkDAAAAAGQAAAAAAAAAAgICAgICAgL+GQCAwgoDAAAAAGQAAAAAAAAAAgICAgICAgIAAA==")}
+	type args struct {
+		egressPortNo int
+		packet       *of.OfpPacketOut
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+		wantErr       bool
+	}{
+		// TODO: Add test cases.
+		//{"test1", args{egressPortNo: 0, packet: &ofp.OfpPacketOut{}}, true},
+		{"PacketOut-1", dh1, args{egressPortNo: 0, packet: pktout}, false},
+		{"PacketOut-2", dh2, args{egressPortNo: 1, packet: pktout}, false},
+		{"PacketOut-3", dh2, args{egressPortNo: 4112, packet: pktout}, false},
+		{"PacketOut-4", dh1, args{egressPortNo: 1048577, packet: pktout}, false},
+		{"PacketOut-5", dh2, args{egressPortNo: 1048576, packet: pktout}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dh := tt.devicehandler
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := dh.PacketOut(ctx, tt.args.egressPortNo, tt.args.packet); (err != nil) != tt.wantErr {
+				t.Errorf("DeviceHandler.PacketOut() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+//
+func TestDeviceHandler_doStateUp(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := newMockDeviceHandler()
+
+	dh2.device.Id = ""
+	dh3 := negativeDeviceHandler()
+
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		wantErr       bool
+	}{
+		{"dostateup-1", dh1, false},
+		{"dostateup-2", dh2, false},
+		{"dostateup-3", dh3, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := tt.devicehandler.doStateUp(ctx); (err != nil) != tt.wantErr {
+				t.Logf("DeviceHandler.doStateUp() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			tt.devicehandler.stopCollector <- true //stop the stat collector invoked from doStateUp
+		})
+	}
+}
+func TestDeviceHandler_doStateDown(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	dh3 := newMockDeviceHandler()
+	dh3.device.OperStatus = voltha.OperStatus_UNKNOWN
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		wantErr       bool
+	}{
+		{"dostatedown-1", dh1, false},
+		{"dostatedown-2", dh2, true},
+		{"dostatedown-2", dh3, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := tt.devicehandler.doStateDown(ctx); (err != nil) != tt.wantErr {
+				t.Logf("DeviceHandler.doStateDown() error = %v", err)
+				//TODO: should fail this test case (Errorf) if result is not as expected
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_GetOfpDeviceInfo(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+		wantErr       bool
+	}{
+		// TODO: Add test cases.
+		{"GetOfpDeviceInfo-1", dh1, args{dh1.device}, false},
+		{"GetOfpDeviceInfo-2", dh1, args{&voltha.Device{}}, false},
+		{"GetOfpDeviceInfo-3", dh2, args{dh1.device}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dh := tt.devicehandler
+			_, err := dh.GetOfpDeviceInfo(tt.args.device)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("DeviceHandler.GetOfpDeviceInfo() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}
+
+func TestDeviceHandler_onuDiscIndication(t *testing.T) {
+
+	dh1 := newMockDeviceHandler()
+	dh1.discOnus = sync.Map{}
+	dh1.discOnus.Store("onu1", true)
+	dh1.discOnus.Store("onu2", false)
+	dh1.discOnus.Store("onu3", true)
+	dh1.discOnus.Store("onu4", true)
+	dh1.onus = sync.Map{}
+	dh1.onus.Store("onu3", NewOnuDevice("onu3", "onu3", "onu3", 3, 3, "onu3", true))
+	dh1.onus.Store("onu4", NewOnuDevice("onu4", "onu4", "onu4", 4, 4, "onu4", true))
+	dh2 := negativeDeviceHandler()
+	type args struct {
+		onuDiscInd *oop.OnuDiscIndication
+		sn         string
+	}
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+		args          args
+	}{
+		// TODO: Add test cases.
+		{"onuDiscIndication-1", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}},
+		{"onuDiscIndication-2", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{}}}},
+		{"onuDiscIndication-3", dh1, args{onuDiscInd: &oop.OnuDiscIndication{SerialNumber: &oop.SerialNumber{}}}},
+		{"onuDiscIndication-4", dh1, args{onuDiscInd: &oop.OnuDiscIndication{}}},
+		{"onuDiscIndication-5", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu1"}},
+		{"onuDiscIndication-6", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu2"}},
+		{"onuDiscIndication-7", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 3, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu3"}},
+		{"onuDiscIndication-8", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 3, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu4"}},
+		{"onuDiscIndication-9", dh2, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			_ = tt.devicehandler.onuDiscIndication(ctx, tt.args.onuDiscInd, tt.args.sn)
+			//TODO: actually verify test cases
+		})
+	}
+}
+
+func TestDeviceHandler_populateDeviceInfo(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := negativeDeviceHandler()
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"populateDeviceInfo-1", dh1, true},
+		{"populateDeviceInfo-2", dh1, true},
+		{"populateDeviceInfo-3", dh1, true},
+		{"populateDeviceInfo-4", dh1, true},
+		{"populateDeviceInfo-5", dh2, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			_, err := tt.devicehandler.populateDeviceInfo(context.Background())
+			if (err != nil) != tt.wantErr {
+				t.Errorf("DeviceHandler.populateDeviceInfo() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+		})
+	}
+}
+
+func TestDeviceHandler_readIndications(t *testing.T) {
+	dh1 := newMockDeviceHandler()
+	dh2 := newMockDeviceHandler()
+	dh3 := newMockDeviceHandler()
+	dh3.device.AdminState = voltha.AdminState_DISABLED
+	dh4 := negativeDeviceHandler()
+	tests := []struct {
+		name          string
+		devicehandler *DeviceHandler
+	}{
+		// TODO: Add test cases.
+		{"readIndications-1", dh1},
+		{"readIndications-2", dh2},
+		{"readIndications-3", dh2},
+		{"readIndications-4", dh2},
+		{"readIndications-5", dh2},
+		{"readIndications-6", dh3},
+		{"readIndications-7", dh3},
+		{"readIndications-8", dh4},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			_ = tt.devicehandler.readIndications(ctx)
+			// TODO: actually verify test cases
+		})
+	}
+}
+
+func Test_startCollector(t *testing.T) {
+	type args struct {
+		dh *DeviceHandler
+	}
+	dh := newMockDeviceHandler()
+	dh.coreProxy.(*mocks.MockCoreProxy).DevicePorts[dh.device.Id] = []*voltha.Port{
+		{PortNo: 1, Label: "pon", Type: voltha.Port_PON_OLT},
+		{PortNo: 1048577, Label: "nni", Type: voltha.Port_ETHERNET_NNI},
+		{PortNo: 1048578, Label: "nni", Type: voltha.Port_ETHERNET_NNI},
+	}
+	dh.portStats.NorthBoundPort = make(map[uint32]*NniPort)
+	dh.portStats.NorthBoundPort[1] = &NniPort{Name: "OLT-1"}
+	dh.portStats.NorthBoundPort[2] = &NniPort{Name: "OLT-1"}
+	dh.portStats.SouthBoundPort = make(map[uint32]*PonPort)
+	dh.portStats.Device = dh
+	for i := 0; i < 16; i++ {
+		dh.portStats.SouthBoundPort[uint32(i)] = &PonPort{DeviceID: "OLT-1"}
+	}
+	dh1 := newMockDeviceHandler()
+	dh1.coreProxy.(*mocks.MockCoreProxy).DevicePorts[dh.device.Id] = []*voltha.Port{}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"StartCollector-1", args{dh}},
+		{"StartCollector-2", args{dh1}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			go func() {
+				time.Sleep(1 * time.Second) // simulated wait time to stop startCollector
+				tt.args.dh.stopCollector <- true
+			}()
+			startCollector(context.Background(), tt.args.dh)
+		})
+	}
+}
diff --git a/internal/pkg/core/l2oam/common.go b/internal/pkg/core/l2oam/common.go
new file mode 100644
index 0000000..b77cf3d
--- /dev/null
+++ b/internal/pkg/core/l2oam/common.go
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package l2oam Common Logger initialization
+package l2oam
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+//var logger log.CLogger
+var logger l2OAMLogger
+
+// func init() {
+// 	// Setup this package so that it's log level can be modified at run time
+// 	var err error
+// 	logger, err = log.RegisterPackage(log.JSON, log.ErrorLevel, log.Fields{})
+// 	if err != nil {
+// 		panic(err)
+// 	}
+// }
+
+func init() {
+	logger = l2OAMLogger{}
+	logger.Debug(context.Background(), "initialize l2oam logger")
+}
+
+//l2OAMLogger ...
+type l2OAMLogger struct {
+}
+
+//Debug ...
+func (l *l2OAMLogger) Debug(ctx context.Context, message string) {
+	fmt.Printf("%v:%s\n", time.Now(), message)
+}
diff --git a/internal/pkg/core/l2oam/message.go b/internal/pkg/core/l2oam/message.go
new file mode 100644
index 0000000..dd092da
--- /dev/null
+++ b/internal/pkg/core/l2oam/message.go
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"net"
+	"sync"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// OnuPkgType describes target package type
+var OnuPkgType = "PkgB"
+
+// OnuPkgTypeA is a constant of package
+const OnuPkgTypeA = "PkgA"
+
+// OnuPkgTypeB is a constant of package
+const OnuPkgTypeB = "PkgB"
+
+// TibitFrame is a typical structure of a frame
+type TibitFrame struct {
+	layers.BaseLayer
+	Data []byte
+}
+
+// LayerType returns ethernet layer type
+func (t *TibitFrame) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (t *TibitFrame) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	length := len(t.Data)
+	bytes, err := b.PrependBytes(length)
+	if err != nil {
+		return err
+	}
+	copy(bytes, t.Data)
+	return nil
+}
+
+// TomiObjectContext is a structure for tomi object
+type TomiObjectContext struct {
+	Branch   uint8
+	Type     uint16
+	Length   uint8
+	Instance uint32
+}
+
+// CreateMessage creates l2 message
+func CreateMessage(srcMac string, dstMac string, ethernetType layers.EthernetType, tibitData gopacket.SerializableLayer) []byte {
+	srcMAC, _ := net.ParseMAC(srcMac)
+	dstMAC, _ := net.ParseMAC(dstMac)
+
+	ethernetLayer := &layers.Ethernet{
+		SrcMAC:       srcMAC,
+		DstMAC:       dstMAC,
+		EthernetType: ethernetType,
+	}
+
+	buf := gopacket.NewSerializeBuffer()
+	if err := gopacket.SerializeLayers(
+		buf,
+		gopacket.SerializeOptions{
+			ComputeChecksums: true,
+			FixLengths:       true,
+		},
+		ethernetLayer,
+		tibitData,
+	); err != nil {
+		return buf.Bytes()
+	}
+	return buf.Bytes()
+}
+
+// CreateMessage creates vlan message
+func CreateMessageVlan(srcMac string, dstMac string, ethernetType layers.EthernetType, tibitData gopacket.SerializableLayer, vlanLayer *layers.Dot1Q) []byte {
+	srcMAC, _ := net.ParseMAC(srcMac)
+	dstMAC, _ := net.ParseMAC(dstMac)
+
+	ethernetLayer := &layers.Ethernet{
+		SrcMAC:       srcMAC,
+		DstMAC:       dstMAC,
+		EthernetType: ethernetType,
+	}
+
+	buf := gopacket.NewSerializeBuffer()
+	if err := gopacket.SerializeLayers(
+		buf,
+		gopacket.SerializeOptions{
+			ComputeChecksums: true,
+			FixLengths:       true,
+		},
+		ethernetLayer,
+		vlanLayer,
+		tibitData,
+	); err != nil {
+		return buf.Bytes()
+	}
+	return buf.Bytes()
+}
+
+// CorrelationTag instance ID
+// It is incremented automatically for each TOMI message with OLT
+var instance uint32 = 0x5c1f6a60
+var instanceMutex sync.Mutex
+
+func getOltInstance() uint32 {
+	instanceMutex.Lock()
+	defer instanceMutex.Unlock()
+	instance = instance + 1
+
+	return instance
+
+}
diff --git a/internal/pkg/core/l2oam/msg_after_keep_alive.go b/internal/pkg/core/l2oam/msg_after_keep_alive.go
new file mode 100644
index 0000000..4772e11
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_after_keep_alive.go
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+func GeneratePcscompuTibitcom() gopacket.SerializableLayer {
+
+	data := &TibitFrame{
+		Data: []byte{0x03, 0x00, 0x50, 0xfe, 0x2a, 0xea, 0x15, 0x01, 0x0c, 0x0c, 0x7a, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x11, 0x04, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x07, 0x00, 0x00},
+	}
+
+	binary.BigEndian.PutUint32(data.Data[12:16], getOltInstance())
+
+	return data
+
+}
diff --git a/internal/pkg/core/l2oam/msg_autonomous.go b/internal/pkg/core/l2oam/msg_autonomous.go
new file mode 100644
index 0000000..dff723d
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_autonomous.go
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// AutonomousEvent is a structure for Autonomous Event
+type AutonomousEvent struct {
+	ComResp TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of AutonomousEvent
+func (d *AutonomousEvent) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%v, EcValue:%v, EndBranch:%v", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of AutonomousEvent
+func (d *AutonomousEvent) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// LayerType returns the ethernet type of AutonomousEvent
+func (d *AutonomousEvent) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *AutonomousEvent) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	return nil
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *AutonomousEvent) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i = i + int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// IsRegistrationStatusMessage returns true if the message is for ONU registration
+func (d *AutonomousEvent) IsRegistrationStatusMessage() bool {
+	return d.ComResp.VcBranch == 0x01 && d.ComResp.VcLeaf == 0x0009
+}
diff --git a/internal/pkg/core/l2oam/msg_best_effort_mbs.go b/internal/pkg/core/l2oam/msg_best_effort_mbs.go
new file mode 100644
index 0000000..fe63edf
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_best_effort_mbs.go
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateBestEffortMbs generates "Traffic Profile/Best Effort MBS" message
+func GenerateBestEffortMbs() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x070f,
+		OCLength:   4,
+		OCInstance: 0x00000002,
+		// Vc
+		VcBranch: 0x7f,
+		VcLeaf:   0x0009,
+		VcLength: 5,
+		// EC
+		ECLength: 4,
+		ECValue:  []byte{0x00, 0x06, 0x40, 0x00},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_best_effort_rate.go b/internal/pkg/core/l2oam/msg_best_effort_rate.go
new file mode 100644
index 0000000..42ccd43
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_best_effort_rate.go
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateBestEffortRate generates "Traffic Profile/Best Effort Rate" message
+func GenerateBestEffortRate(ecvalue []byte, trafficProfile []byte) gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x070f,
+		OCLength:   4,
+		OCInstance: binary.BigEndian.Uint32(trafficProfile),
+		// Vc
+		VcBranch: 0x7f,
+		VcLeaf:   0x0008,
+		VcLength: uint8(1 + len(ecvalue)), //5
+		// EC
+		ECLength: uint8(len(ecvalue)), //4
+		ECValue:  ecvalue,             //[]byte{0x00, 0x4c, 0x4b, 0x40}
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_best_effort_rate_test.go b/internal/pkg/core/l2oam/msg_best_effort_rate_test.go
new file mode 100644
index 0000000..25bfb49
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_best_effort_rate_test.go
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package l2oam
+
+import (
+	"encoding/binary"
+	"reflect"
+	"testing"
+
+	"github.com/google/gopacket"
+)
+
+func TestGenerateBestEffortRate(t *testing.T) {
+	type args struct {
+		ecvalue        []byte
+		trafficProfile []byte
+	}
+	tests := []struct {
+		name string
+		args args
+		want gopacket.SerializableLayer
+	}{
+		// TODO: Add test cases.
+		{
+			name: "GenerateBestEffortRate-1",
+			args: args{
+				ecvalue:        []byte{0x00, 0x4c, 0x4b, 0x40},
+				trafficProfile: []byte{0x00, 0x00, 0x00, 0x01},
+			},
+			want: &TOAMSetRequest{
+				// IEEE 1904.2
+				Opcode: 0x03,
+				// OAM Protocol
+				Flags:      0x0050,
+				OAMPDUCode: 0xfe,
+				OUId:       []byte{0x2a, 0xea, 0x15},
+				// TiBit OLT Management Interface
+				TOMIOpcode: 0x03,
+				// Correlation Tag
+				CTBranch:   0x0c,
+				CTType:     0x0c7a,
+				CTLength:   4,
+				CTInstance: getOltInstance() + 1,
+				// Object Context
+				OCBranch:   0x0c,
+				OCType:     0x070f,
+				OCLength:   4,
+				OCInstance: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x00, 0x01}),
+				// Vc
+				VcBranch: 0x7f,
+				VcLeaf:   0x0008,
+				VcLength: 5, //5
+				// EC
+				ECLength: 4,                              //4
+				ECValue:  []byte{0x00, 0x4c, 0x4b, 0x40}, //[]byte{0x00, 0x4c, 0x4b, 0x40}
+				// End
+				EndBranch: 0x00,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GenerateBestEffortRate(tt.args.ecvalue, tt.args.trafficProfile); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GenerateBestEffortRate() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/l2oam/msg_discovery.go b/internal/pkg/core/l2oam/msg_discovery.go
new file mode 100644
index 0000000..ab104bc
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_discovery.go
@@ -0,0 +1,396 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateDiscoverySOLICIT generates "Discovery: SOLICIT" message
+func GenerateDiscoverySOLICIT() gopacket.SerializableLayer {
+
+	tibitData := &DiscoverySolicit{
+		// IEEE 1904.2
+		Opcode:        0xfd,
+		DiscoveryType: 0x01,
+		// Vendor-specific
+		VendorType: 0xfe,
+		Length:     37,
+		// Vendor ID
+		VendorIDType:   0xfd,
+		VendorIDLength: 3,
+		VendorID:       []byte{0x2a, 0xea, 0x15},
+		// Controller Priority
+		CPType:   0x05,
+		CPLength: 1,
+		CPValue:  []byte{128},
+		//NetworkID
+		NWType:   0x06,
+		NWLength: 16,
+		NWValue:  []byte("tibitcom.com"),
+		//Device Type
+		DVType:   0x07,
+		DVLength: 1,
+		DVValue:  []byte{1},
+		//Supported CLient Protocols
+		SCPType:   0x08,
+		SCPLength: 1,
+		SCPValue:  []byte{0x03},
+		//Padding
+		PadType:   0xff,
+		PadLength: 1,
+		PadValue:  []byte{0},
+	}
+
+	return tibitData
+}
+
+// DiscoverySolicit is a structure for Discovery message
+type DiscoverySolicit struct {
+	layers.BaseLayer
+	Opcode        uint8
+	DiscoveryType uint8
+	VendorType uint8
+	Length     uint16 // length of after this data without Padding
+	VendorIDType   uint8
+	VendorIDLength uint16
+	VendorID       []byte
+	CPType   uint8
+	CPLength uint16
+	CPValue  []byte
+	NWType   uint8
+	NWLength uint16
+	NWValue  []byte
+	DVType   uint8
+	DVLength uint16
+	DVValue  []byte
+	SCPType   uint8
+	SCPLength uint16
+	SCPValue  []byte
+	PadType   uint8
+	PadLength uint16
+	PadValue  []byte
+}
+
+// String returns the string expression of DiscoverySolicit
+func (d *DiscoverySolicit) String() string {
+	message := fmt.Sprintf("Opcode:%v, DiscoveryType:%v, VendorType:%v, Length:%v", d.Opcode, d.DiscoveryType, d.VendorType, d.Length)
+	message = fmt.Sprintf("%s, VendorIDType:%v, VendorIDLength:%v, VendorID:%v", message, d.VendorIDType, d.VendorIDLength, hex.EncodeToString(d.VendorID))
+	message = fmt.Sprintf("%s, CPType:%v, CPLength:%v, CPValue:%v", message, d.CPType, d.CPLength, hex.EncodeToString(d.CPValue))
+	message = fmt.Sprintf("%s, NWType:%v, NWLength:%v, NWValue:%v", message, d.NWType, d.NWLength, hex.EncodeToString(d.NWValue))
+	message = fmt.Sprintf("%s, DVType:%v, DVLength:%v, DVValue:%v", message, d.DVType, d.DVLength, hex.EncodeToString(d.DVValue))
+	message = fmt.Sprintf("%s, SCPType:%v, SCPLength:%v, SCPValue:%v", message, d.SCPType, d.SCPLength, hex.EncodeToString(d.SCPValue))
+	return message
+}
+
+// Len returns the length of DiscoverySolicit
+func (d *DiscoverySolicit) Len() int {
+	len := (2) + (3) + int(d.Length) + (int(d.PadLength) + 3)
+	return len
+}
+
+// LayerType returns the ethernet type of DiscoverySolicit
+func (d *DiscoverySolicit) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *DiscoverySolicit) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	data[i] = byte(d.DiscoveryType)
+	i++
+	data[i] = byte(d.VendorType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Length)
+	i = i + 2
+
+	data[i] = byte(d.VendorIDType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VendorIDLength)
+	i = i + 2
+	copy(data[i:i+int(d.VendorIDLength)], d.VendorID)
+	i = i + int(d.VendorIDLength)
+
+	data[i] = byte(d.CPType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CPLength)
+	i = i + 2
+	copy(data[i:i+int(d.CPLength)], d.CPValue)
+	i = i + int(d.CPLength)
+
+	data[i] = byte(d.NWType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.NWLength)
+	i = i + 2
+	copy(data[i:i+int(d.NWLength)], d.NWValue)
+	i = i + int(d.NWLength)
+
+	data[i] = byte(d.DVType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.DVLength)
+	i = i + 2
+	copy(data[i:i+int(d.DVLength)], d.DVValue)
+	i = i + int(d.DVLength)
+
+	data[i] = byte(d.SCPType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.SCPLength)
+	i = i + 2
+	copy(data[i:i+int(d.SCPLength)], d.SCPValue)
+	i = i + int(d.SCPLength)
+
+	data[i] = byte(d.PadType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.PadLength)
+	i = i + 2
+	copy(data[i:i+int(d.PadLength)], d.PadValue)
+
+	return nil
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *DiscoverySolicit) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.DiscoveryType = data[i]
+	i++
+	d.VendorType = data[i]
+	i++
+	d.Length = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+
+	d.VendorIDType = data[i]
+	i++
+	d.VendorIDLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.VendorID = data[i : i+int(d.VendorIDLength)]
+	i = i + int(d.VendorIDLength)
+
+	d.CPType = data[i]
+	i++
+	d.CPLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.CPValue = data[i : i+int(d.CPLength)]
+	i = i + int(d.CPLength)
+
+	d.NWType = data[i]
+	i++
+	d.NWLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.NWValue = data[i : i+int(d.NWLength)]
+	i = i + int(d.NWLength)
+
+	d.DVType = data[i]
+	i++
+	d.DVLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.DVValue = data[i : i+int(d.DVLength)]
+	i = i + int(d.DVLength)
+
+	d.SCPType = data[i]
+	i++
+	d.SCPLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.SCPValue = data[i : i+int(d.SCPLength)]
+	i = i + int(d.SCPLength)
+
+	d.PadType = data[i]
+	i++
+	d.PadLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.PadValue = data[i : i+int(d.PadLength)]
+
+	return nil
+}
+
+// DiscoveryHello is a structure for Discovery message
+type DiscoveryHello struct {
+	layers.BaseLayer
+	Opcode        uint8
+	DiscoveryType uint8
+	VendorType uint8
+	Length     uint16 // length of after this data without Padding
+	VendorIDType   uint8
+	VendorIDLength uint16
+	VendorID       []byte
+	NWType   uint8
+	NWLength uint16
+	NWValue  []byte
+	DVType   uint8
+	DVLength uint16
+	DVValue  []byte
+	SCPType   uint8
+	SCPLength uint16
+	SCPValue  []byte
+	TunnelType   uint8
+	TunnelLength uint16
+	TunnelValue  []byte
+	PadType   uint8
+	PadLength uint16
+	PadValue  []byte
+}
+
+// String returns the string expression of DiscoveryHello
+func (d *DiscoveryHello) String() string {
+	message := fmt.Sprintf("Opcode:%v, DiscoveryType:%v, VendorType:%v, Length:%v", d.Opcode, d.DiscoveryType, d.VendorType, d.Length)
+	message = fmt.Sprintf("%s, VendorIDType:%v, VendorIDLength:%v, VendorID:%v", message, d.VendorIDType, d.VendorIDLength, hex.EncodeToString(d.VendorID))
+	message = fmt.Sprintf("%s, NWType:%v, NWLength:%v, NWValue:%v", message, d.NWType, d.NWLength, hex.EncodeToString(d.NWValue))
+	message = fmt.Sprintf("%s, DVType:%v, DVLength:%v, DVValue:%v", message, d.DVType, d.DVLength, hex.EncodeToString(d.DVValue))
+	message = fmt.Sprintf("%s, SCPType:%v, SCPLength:%v, SCPValue:%v", message, d.SCPType, d.SCPLength, hex.EncodeToString(d.SCPValue))
+	message = fmt.Sprintf("%s, TunnelType:%v, TunnelLength:%v, TunnelValue:%v", message, d.TunnelType, d.TunnelLength, hex.EncodeToString(d.TunnelValue))
+	message = fmt.Sprintf("%s, PadType:%v, PadLength:%v, PadValue:%v", message, d.PadType, d.PadLength, hex.EncodeToString(d.PadValue))
+	return message
+}
+
+// Len returns the length of DiscoveryHello
+func (d *DiscoveryHello) Len() int {
+	len := (2) + (3) + int(d.Length) + (int(d.PadLength) + 3)
+	return len
+}
+
+// LayerType returns the ethernet type of DiscoveryHello
+func (d *DiscoveryHello) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *DiscoveryHello) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	data[i] = byte(d.DiscoveryType)
+	i++
+	data[i] = byte(d.VendorType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Length)
+	i = i + 2
+
+	data[i] = byte(d.VendorIDType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VendorIDLength)
+	i = i + 2
+	copy(data[i:i+int(d.VendorIDLength)], d.VendorID)
+	i = i + int(d.VendorIDLength)
+
+	data[i] = byte(d.NWType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.NWLength)
+	i = i + 2
+	copy(data[i:i+int(d.NWLength)], d.NWValue)
+	i = i + int(d.NWLength)
+
+	data[i] = byte(d.DVType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.DVLength)
+	i = i + 2
+	copy(data[i:i+int(d.DVLength)], d.DVValue)
+	i = i + int(d.DVLength)
+
+	data[i] = byte(d.SCPType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.SCPLength)
+	i = i + 2
+	copy(data[i:i+int(d.SCPLength)], d.SCPValue)
+	i = i + int(d.SCPLength)
+
+	data[i] = byte(d.TunnelType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.TunnelLength)
+	i = i + 2
+	copy(data[i:i+int(d.TunnelLength)], d.TunnelValue)
+	i = i + int(d.TunnelLength)
+
+	data[i] = byte(d.PadType)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.PadLength)
+	i = i + 2
+	copy(data[i:i+int(d.PadLength)], d.PadValue)
+
+	return nil
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *DiscoveryHello) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.DiscoveryType = data[i]
+	i++
+	d.VendorType = data[i]
+	i++
+	d.Length = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+
+	d.VendorIDType = data[i]
+	i++
+	d.VendorIDLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.VendorID = data[i : i+int(d.VendorIDLength)]
+	i = i + int(d.VendorIDLength)
+
+	d.NWType = data[i]
+	i++
+	d.NWLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.NWValue = data[i : i+int(d.NWLength)]
+	i = i + int(d.NWLength)
+
+	d.DVType = data[i]
+	i++
+	d.DVLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.DVValue = data[i : i+int(d.DVLength)]
+	i = i + int(d.DVLength)
+
+	d.SCPType = data[i]
+	i++
+	d.SCPLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.SCPValue = data[i : i+int(d.SCPLength)]
+	i = i + int(d.SCPLength)
+
+	d.TunnelType = data[i]
+	i++
+	d.TunnelLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.TunnelValue = data[i : i+int(d.TunnelLength)]
+	i = i + int(d.TunnelLength)
+
+	d.PadType = data[i]
+	i++
+	d.PadLength = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.PadValue = data[i : i+int(d.PadLength)]
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/msg_discovery_test.go b/internal/pkg/core/l2oam/msg_discovery_test.go
new file mode 100644
index 0000000..618c81a
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_discovery_test.go
@@ -0,0 +1,1409 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+func TestGenerateDiscoverySOLICIT(t *testing.T) {
+	tests := []struct {
+		name string
+		want gopacket.SerializableLayer
+	}{
+		// TODO: Add test cases.
+		{
+			name: "GenerateDiscoverySOLICIT-1",
+			want: &DiscoverySolicit{
+				// IEEE 1904.2
+				Opcode:        0xfd,
+				DiscoveryType: 0x01,
+				// Vendor-specific
+				VendorType: 0xfe,
+				Length:     37,
+				// Vendor ID
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				// Controller Priority
+				CPType:   0x05,
+				CPLength: 1,
+				CPValue:  []byte{128},
+				//NetworkID
+				NWType:   0x06,
+				NWLength: 16,
+				NWValue:  []byte("tibitcom.com"),
+				//Device Type
+				DVType:   0x07,
+				DVLength: 1,
+				DVValue:  []byte{1},
+				//Supported CLient Protocols
+				SCPType:   0x08,
+				SCPLength: 1,
+				SCPValue:  []byte{0x03},
+				//Padding
+				PadType:   0xff,
+				PadLength: 1,
+				PadValue:  []byte{0},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GenerateDiscoverySOLICIT(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GenerateDiscoverySOLICIT() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoverySolicit_String(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		CPType         uint8
+		CPLength       uint16
+		CPValue        []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		// TODO: Add test cases.
+		{
+			name: "String-1",
+			fields: fields{
+				// IEEE 1904.2
+				Opcode:        0xfd,
+				DiscoveryType: 0x01,
+				// Vendor-specific
+				VendorType: 0xfe,
+				Length:     37,
+				// Vendor ID
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				// Controller Priority
+				CPType:   0x05,
+				CPLength: 1,
+				CPValue:  []byte{128},
+				//NetworkID
+				NWType:   0x06,
+				NWLength: 16,
+				NWValue:  []byte("tibitcom.com"),
+				//Device Type
+				DVType:   0x07,
+				DVLength: 1,
+				DVValue:  []byte{1},
+				//Supported CLient Protocols
+				SCPType:   0x08,
+				SCPLength: 1,
+				SCPValue:  []byte{0x03},
+				//Padding
+				PadType:   0xff,
+				PadLength: 1,
+				PadValue:  []byte{0},
+			},
+			want: fmt.Sprintf("Opcode:253, DiscoveryType:1, VendorType:254, Length:37, VendorIDType:253, VendorIDLength:3, VendorID:2aea15, CPType:5, CPLength:1, CPValue:80, NWType:6, NWLength:16, NWValue:%v, DVType:7, DVLength:1, DVValue:01, SCPType:8, SCPLength:1, SCPValue:03", hex.EncodeToString([]byte("tibitcom.com"))),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoverySolicit{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				CPType:         tt.fields.CPType,
+				CPLength:       tt.fields.CPLength,
+				CPValue:        tt.fields.CPValue,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.String(); got != tt.want {
+				t.Errorf("DiscoverySolicit.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoverySolicit_Len(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		CPType         uint8
+		CPLength       uint16
+		CPValue        []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   int
+	}{
+		// TODO: Add test cases.
+		{
+			name: "Len-1",
+			fields: fields{
+				// IEEE 1904.2
+				Opcode:        0xfd,
+				DiscoveryType: 0x01,
+				// Vendor-specific
+				VendorType: 0xfe,
+				Length:     37,
+				// Vendor ID
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				// Controller Priority
+				CPType:   0x05,
+				CPLength: 1,
+				CPValue:  []byte{128},
+				//NetworkID
+				NWType:   0x06,
+				NWLength: 16,
+				NWValue:  []byte("tibitcom.com"),
+				//Device Type
+				DVType:   0x07,
+				DVLength: 1,
+				DVValue:  []byte{1},
+				//Supported CLient Protocols
+				SCPType:   0x08,
+				SCPLength: 1,
+				SCPValue:  []byte{0x03},
+				//Padding
+				PadType:   0xff,
+				PadLength: 1,
+				PadValue:  []byte{0},
+			},
+			want: 46,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoverySolicit{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				CPType:         tt.fields.CPType,
+				CPLength:       tt.fields.CPLength,
+				CPValue:        tt.fields.CPValue,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.Len(); got != tt.want {
+				t.Errorf("DiscoverySolicit.Len() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoverySolicit_LayerType(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		CPType         uint8
+		CPLength       uint16
+		CPValue        []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   gopacket.LayerType
+	}{
+		// TODO: Add test cases.
+		{
+			name: "LayerType-1",
+			want: layers.LayerTypeEthernet,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoverySolicit{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				CPType:         tt.fields.CPType,
+				CPLength:       tt.fields.CPLength,
+				CPValue:        tt.fields.CPValue,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.LayerType(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("DiscoverySolicit.LayerType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoverySolicit_SerializeTo(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		CPType         uint8
+		CPLength       uint16
+		CPValue        []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	type args struct {
+		b    gopacket.SerializeBuffer
+		opts gopacket.SerializeOptions
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "SerializeTo-1",
+			fields: fields{
+				// IEEE 1904.2
+				Opcode:        0xfd,
+				DiscoveryType: 0x01,
+				// Vendor-specific
+				VendorType: 0xfe,
+				Length:     37,
+				// Vendor ID
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				// Controller Priority
+				CPType:   0x05,
+				CPLength: 1,
+				CPValue:  []byte{128},
+				//NetworkID
+				NWType:   0x06,
+				NWLength: 16,
+				NWValue:  []byte("tibitcom.com"),
+				//Device Type
+				DVType:   0x07,
+				DVLength: 1,
+				DVValue:  []byte{1},
+				//Supported CLient Protocols
+				SCPType:   0x08,
+				SCPLength: 1,
+				SCPValue:  []byte{0x03},
+				//Padding
+				PadType:   0xff,
+				PadLength: 1,
+				PadValue:  []byte{0},
+			},
+			args: args{
+				b:    gopacket.NewSerializeBufferExpectedSize(0, 36),
+				opts: gopacket.SerializeOptions{},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoverySolicit{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				CPType:         tt.fields.CPType,
+				CPLength:       tt.fields.CPLength,
+				CPValue:        tt.fields.CPValue,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if err := d.SerializeTo(tt.args.b, tt.args.opts); (err != nil) != tt.wantErr {
+				t.Errorf("DiscoverySolicit.SerializeTo error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			data := tt.args.b.Bytes()
+			cnt := 0
+			digits := 0
+			if !reflect.DeepEqual(d.Opcode, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo Opcode error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DiscoveryType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo DiscoveryType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo VendorType error")
+			}
+			cnt++
+
+			if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo Length error")
+			}
+			cnt += 2
+
+			if !reflect.DeepEqual(d.VendorIDType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo VendorIDType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo VendorIDLength error")
+			}
+			cnt += 2
+			digits = int(d.VendorIDLength)
+			if !reflect.DeepEqual(d.VendorID, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo VendorID error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.CPType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo CPType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.CPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo CPLength error")
+			}
+			cnt += 2
+			digits = int(d.CPLength)
+			if !reflect.DeepEqual(d.CPValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo CPValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.NWType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo NWType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo NWLength error")
+			}
+			cnt += 2
+			//digits = int(d.NWLength)
+			for _, dvalue := range d.NWValue {
+				if !reflect.DeepEqual(dvalue, data[cnt]) {
+					t.Error("DiscoverySolicit.SerializeTo NWValue error")
+				}
+				cnt++
+			}
+			// if !reflect.DeepEqual(string(d.NWValue), string(data[cnt:cnt+digits])) {
+			// 	t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", d.NWValue, data[cnt:cnt+digits])
+			// }
+			cnt += 4
+			if !reflect.DeepEqual(d.DVType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo DVType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo DVLength error")
+			}
+			cnt += 2
+			digits = int(d.DVLength)
+			if !reflect.DeepEqual(d.DVValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo DVValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.SCPType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo SCPType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo SCPLength error")
+			}
+			cnt += 2
+			digits = int(d.SCPLength)
+			if !reflect.DeepEqual(d.SCPValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo SCPValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.PadType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo PadType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo PadLength error")
+			}
+			cnt += 2
+			digits = int(d.PadLength)
+			if !reflect.DeepEqual(d.PadValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo PadValue error")
+			}
+
+		})
+	}
+}
+
+func TestDiscoverySolicit_Decode(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		CPType         uint8
+		CPLength       uint16
+		CPValue        []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	type args struct {
+		data []byte
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "Decode-1",
+			args: args{
+				data: []byte{0xfd, 0x01, 0xfe, 0x00, 0x25, 0xfd, 0x00, 0x03, 0x2a, 0xea, 0x15, 0x05, 0x00, 0x01, 0x80, 0x06, 0x00, 0x10, 0x74, 0x69, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x01, 0x01, 0x08, 0x00, 0x01, 0x03, 0xff, 0x00, 0x01, 0x00},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoverySolicit{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				CPType:         tt.fields.CPType,
+				CPLength:       tt.fields.CPLength,
+				CPValue:        tt.fields.CPValue,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if err := d.Decode(tt.args.data); (err != nil) != tt.wantErr {
+				t.Errorf("DiscoverySolicit.Decode error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			cnt := 0
+			digits := 0
+
+			if !reflect.DeepEqual(d.Opcode, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, tt.args.data[cnt:], cnt)
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DiscoveryType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, tt.args.data[cnt:cnt+1])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode VendorType error %x %x", tt.args.data[cnt], d.VendorType)
+			}
+			cnt++
+
+			if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.Decode Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])))
+			}
+			cnt += 2
+
+			if !reflect.DeepEqual(d.VendorIDType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, tt.args.data[cnt])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.Decode VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, tt.args.data[cnt:cnt+2])
+			}
+			cnt += 2
+			digits = int(d.VendorIDLength)
+			if !reflect.DeepEqual(d.VendorID, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode VendorID error %v %v", d.VendorID, tt.args.data[cnt:cnt+3])
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.CPType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode CPType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.CPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode CPLength error")
+			}
+			cnt += 2
+			digits = int(d.CPLength)
+			if !reflect.DeepEqual(d.CPValue, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode CPValue error %x %x", tt.args.data[14:15], d.CPValue)
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.NWType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode NWType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode NWLength error")
+			}
+			cnt += 2
+			//digits = int(d.NWLength)
+			for _, dvalue := range d.NWValue {
+				if !reflect.DeepEqual(dvalue, tt.args.data[cnt]) {
+					t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", dvalue, tt.args.data[cnt])
+				}
+				cnt++
+			}
+			// if !reflect.DeepEqual(string(d.NWValue), string(tt.args.data[cnt:cnt+digits])) {
+			// 	t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", d.NWValue, tt.args.data[cnt:cnt+digits])
+			// }
+			// cnt += 4
+			if !reflect.DeepEqual(d.DVType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode DVType error %x %x", d.DVType, tt.args.data[cnt])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.Decode DVLength error %x %x", d.DVLength, tt.args.data[cnt:cnt+2])
+			}
+			cnt += 2
+			digits = int(d.DVLength)
+			if !reflect.DeepEqual(d.DVValue, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode DVValue error %x %x", d.DVValue, tt.args.data[cnt:cnt+digits])
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.SCPType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode SCPType error %x %x", d.SCPType, tt.args.data[cnt])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode SCPLength error")
+			}
+			cnt += 2
+			digits = int(d.SCPLength)
+			if !reflect.DeepEqual(d.SCPValue, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode SCPValue error cnt= %x digits=%x", cnt, digits)
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.PadType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode PadType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode PadLength error")
+			}
+			cnt += 2
+			digits = int(d.PadLength)
+			if !reflect.DeepEqual(d.PadValue, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode PadValue error %x %x", d.PadValue, tt.args.data[cnt:cnt+digits])
+			}
+
+		})
+	}
+}
+
+func TestDiscoveryHello_String(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		TunnelType     uint8
+		TunnelLength   uint16
+		TunnelValue    []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		// TODO: Add test cases.
+		{
+			name: "String-1",
+			fields: fields{
+				Opcode:         0xfd,
+				DiscoveryType:  0x01,
+				VendorType:     0xfe,
+				Length:         0x25,
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				NWType:         0x06,
+				NWLength:       16,
+				NWValue:        []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16},
+				DVType:         0x07,
+				DVLength:       1,
+				DVValue:        []byte{2},
+				SCPType:        0x08,
+				SCPLength:      1,
+				SCPValue:       []byte{0x03},
+				TunnelType:     0x0a,
+				TunnelLength:   2,
+				TunnelValue:    []byte{0x00, 0x01},
+				PadType:        0xff,
+				PadLength:      1,
+				PadValue:       []byte{0},
+			},
+			want: "Opcode:253, DiscoveryType:1, VendorType:254, Length:37, VendorIDType:253, VendorIDLength:3, VendorID:2aea15, NWType:6, NWLength:16, NWValue:01020304050607080910111213141516, DVType:7, DVLength:1, DVValue:02, SCPType:8, SCPLength:1, SCPValue:03, TunnelType:10, TunnelLength:2, TunnelValue:0001, PadType:255, PadLength:1, PadValue:00",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoveryHello{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				TunnelType:     tt.fields.TunnelType,
+				TunnelLength:   tt.fields.TunnelLength,
+				TunnelValue:    tt.fields.TunnelValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.String(); got != tt.want {
+				t.Errorf("DiscoveryHello.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoveryHello_Len(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		TunnelType     uint8
+		TunnelLength   uint16
+		TunnelValue    []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   int
+	}{
+		// TODO: Add test cases.
+		{
+			name: "Len-1",
+			fields: fields{
+				Opcode:         0xfd,
+				DiscoveryType:  0x01,
+				VendorType:     0xfe,
+				Length:         0x25,
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				NWType:         0x06,
+				NWLength:       16,
+				NWValue:        []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16},
+				DVType:         0x07,
+				DVLength:       1,
+				DVValue:        []byte{2},
+				SCPType:        0x08,
+				SCPLength:      1,
+				SCPValue:       []byte{0x03},
+				TunnelType:     0x0a,
+				TunnelLength:   2,
+				TunnelValue:    []byte{0x00, 0x01},
+				PadType:        0xff,
+				PadLength:      1,
+				PadValue:       []byte{0},
+			},
+			want: 46,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoveryHello{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				TunnelType:     tt.fields.TunnelType,
+				TunnelLength:   tt.fields.TunnelLength,
+				TunnelValue:    tt.fields.TunnelValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.Len(); got != tt.want {
+				t.Errorf("DiscoveryHello.Len() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoveryHello_LayerType(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		TunnelType     uint8
+		TunnelLength   uint16
+		TunnelValue    []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   gopacket.LayerType
+	}{
+		// TODO: Add test cases.
+		{
+			name: "LayerType-1",
+			want: layers.LayerTypeEthernet,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoveryHello{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				TunnelType:     tt.fields.TunnelType,
+				TunnelLength:   tt.fields.TunnelLength,
+				TunnelValue:    tt.fields.TunnelValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if got := d.LayerType(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("DiscoveryHello.LayerType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDiscoveryHello_SerializeTo(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		TunnelType     uint8
+		TunnelLength   uint16
+		TunnelValue    []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	type args struct {
+		b    gopacket.SerializeBuffer
+		opts gopacket.SerializeOptions
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "SerializeTo-1",
+			fields: fields{
+				Opcode:         0xfd,
+				DiscoveryType:  0x01,
+				VendorType:     0xfe,
+				Length:         0x25,
+				VendorIDType:   0xfd,
+				VendorIDLength: 3,
+				VendorID:       []byte{0x2a, 0xea, 0x15},
+				NWType:         0x06,
+				NWLength:       16,
+				NWValue:        []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16},
+				DVType:         0x07,
+				DVLength:       1,
+				DVValue:        []byte{2},
+				SCPType:        0x08,
+				SCPLength:      1,
+				SCPValue:       []byte{0x03},
+				TunnelType:     0x0a,
+				TunnelLength:   2,
+				TunnelValue:    []byte{0x00, 0x01},
+				PadType:        0xff,
+				PadLength:      1,
+				PadValue:       []byte{0},
+			},
+			args: args{
+				b:    gopacket.NewSerializeBufferExpectedSize(0, 46),
+				opts: gopacket.SerializeOptions{},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoveryHello{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				TunnelType:     tt.fields.TunnelType,
+				TunnelLength:   tt.fields.TunnelLength,
+				TunnelValue:    tt.fields.TunnelValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if err := d.SerializeTo(tt.args.b, tt.args.opts); (err != nil) != tt.wantErr {
+				t.Errorf("DiscoveryHello.SerializeTo() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			data := tt.args.b.Bytes()
+			cnt := 0
+			digits := 0
+			if !reflect.DeepEqual(d.Opcode, data[cnt]) {
+				t.Errorf("DiscoverySolicit.SerializeTo Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, data[cnt:], cnt)
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DiscoveryType, data[cnt]) {
+				t.Errorf("DiscoverySolicit.SerializeTo DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, data[cnt:cnt+1])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorType, data[cnt]) {
+				t.Errorf("DiscoverySolicit.SerializeTo VendorType error %x %x", data[cnt], d.VendorType)
+			}
+			cnt++
+
+			if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.SerializeTo Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(data[cnt:cnt+2])))
+			}
+			cnt += 2
+
+			if !reflect.DeepEqual(d.VendorIDType, data[cnt]) {
+				t.Errorf("DiscoverySolicit.SerializeTo VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, data[cnt])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.SerializeTo VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, data[cnt:cnt+2])
+			}
+			cnt += 2
+			digits = int(d.VendorIDLength)
+			if !reflect.DeepEqual(d.VendorID, data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.SerializeTo VendorID error %v %v", d.VendorID, data[cnt:cnt+3])
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.NWType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo NWType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo NWLength error")
+			}
+			cnt += 2
+			//digits = int(d.NWLength)
+			for _, dvalue := range d.NWValue {
+				if !reflect.DeepEqual(dvalue, data[cnt]) {
+					t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", dvalue, data[cnt])
+				}
+				cnt++
+			}
+			// if !reflect.DeepEqual(string(d.NWValue), string(data[cnt:cnt+digits])) {
+			// 	t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", d.NWValue, data[cnt:cnt+digits])
+			// }
+			// cnt += 16
+			if !reflect.DeepEqual(d.DVType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo DVType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo DVLength error")
+			}
+			cnt += 2
+			digits = int(d.DVLength)
+			if !reflect.DeepEqual(d.DVValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo DVValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.SCPType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo SCPType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo SCPLength error")
+			}
+			cnt += 2
+			digits = int(d.SCPLength)
+			if !reflect.DeepEqual(d.SCPValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo SCPValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.TunnelType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo TunnelType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.TunnelLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo TunnelLength error")
+			}
+			cnt += 2
+			digits = int(d.TunnelLength)
+			if !reflect.DeepEqual(d.TunnelValue, data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.SerializeTo TunnelValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.PadType, data[cnt]) {
+				t.Error("DiscoverySolicit.SerializeTo PadType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.SerializeTo PadLength error")
+			}
+			cnt += 2
+			digits = int(d.PadLength)
+			if !reflect.DeepEqual(d.PadValue, data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.SerializeTo PadValue error %x %x", d.PadValue, data[cnt:cnt+digits])
+			}
+		})
+	}
+}
+
+func TestDiscoveryHello_Decode(t *testing.T) {
+	type fields struct {
+		BaseLayer      layers.BaseLayer
+		Opcode         uint8
+		DiscoveryType  uint8
+		VendorType     uint8
+		Length         uint16
+		VendorIDType   uint8
+		VendorIDLength uint16
+		VendorID       []byte
+		NWType         uint8
+		NWLength       uint16
+		NWValue        []byte
+		DVType         uint8
+		DVLength       uint16
+		DVValue        []byte
+		SCPType        uint8
+		SCPLength      uint16
+		SCPValue       []byte
+		TunnelType     uint8
+		TunnelLength   uint16
+		TunnelValue    []byte
+		PadType        uint8
+		PadLength      uint16
+		PadValue       []byte
+	}
+	type args struct {
+		data []byte
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{
+			name: "Decode-1",
+			args: args{
+				data: []byte{0xfd, 0x02, 0xfe, 0x00, 0x26, 0xfd, 0x00, 0x03, 0x2a, 0xea, 0x15, 0x06, 0x00, 0x10, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x07, 0x00, 0x01, 0x02, 0x08, 0x00, 0x01, 0x03, 0x0a, 0x00, 0x02, 0x00, 0x01, 0xff, 0x00, 0x01, 0x00},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &DiscoveryHello{
+				BaseLayer:      tt.fields.BaseLayer,
+				Opcode:         tt.fields.Opcode,
+				DiscoveryType:  tt.fields.DiscoveryType,
+				VendorType:     tt.fields.VendorType,
+				Length:         tt.fields.Length,
+				VendorIDType:   tt.fields.VendorIDType,
+				VendorIDLength: tt.fields.VendorIDLength,
+				VendorID:       tt.fields.VendorID,
+				NWType:         tt.fields.NWType,
+				NWLength:       tt.fields.NWLength,
+				NWValue:        tt.fields.NWValue,
+				DVType:         tt.fields.DVType,
+				DVLength:       tt.fields.DVLength,
+				DVValue:        tt.fields.DVValue,
+				SCPType:        tt.fields.SCPType,
+				SCPLength:      tt.fields.SCPLength,
+				SCPValue:       tt.fields.SCPValue,
+				TunnelType:     tt.fields.TunnelType,
+				TunnelLength:   tt.fields.TunnelLength,
+				TunnelValue:    tt.fields.TunnelValue,
+				PadType:        tt.fields.PadType,
+				PadLength:      tt.fields.PadLength,
+				PadValue:       tt.fields.PadValue,
+			}
+			if err := d.Decode(tt.args.data); (err != nil) != tt.wantErr {
+				t.Errorf("DiscoveryHello.Decode() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			cnt := 0
+			digits := 0
+			if !reflect.DeepEqual(d.Opcode, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, tt.args.data[cnt:], cnt)
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DiscoveryType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, tt.args.data[cnt:cnt+1])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode VendorType error %x %x", tt.args.data[cnt], d.VendorType)
+			}
+			cnt++
+
+			if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.Decode Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])))
+			}
+			cnt += 2
+
+			if !reflect.DeepEqual(d.VendorIDType, tt.args.data[cnt]) {
+				t.Errorf("DiscoverySolicit.Decode VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, tt.args.data[cnt])
+			}
+			cnt++
+			if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Errorf("DiscoverySolicit.Decode VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, tt.args.data[cnt:cnt+2])
+			}
+			cnt += 2
+			digits = int(d.VendorIDLength)
+			if !reflect.DeepEqual(d.VendorID, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode VendorID error %v %v", d.VendorID, tt.args.data[cnt:cnt+3])
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.NWType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode NWType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode NWLength error")
+			}
+			cnt += 2
+			//digits = int(d.NWLength)
+			for _, dvalue := range d.NWValue {
+				if !reflect.DeepEqual(dvalue, tt.args.data[cnt]) {
+					t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", dvalue, tt.args.data[cnt])
+				}
+				cnt++
+			}
+			// if !reflect.DeepEqual(string(d.NWValue), string(tt.args.data[cnt:cnt+digits])) {
+			// 	t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", d.NWValue, tt.args.data[cnt:cnt+digits])
+			// }
+			// cnt += 16
+			if !reflect.DeepEqual(d.DVType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode DVType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode DVLength error")
+			}
+			cnt += 2
+			digits = int(d.DVLength)
+			if !reflect.DeepEqual(d.DVValue, tt.args.data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.Decode DVValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.SCPType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode SCPType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode SCPLength error")
+			}
+			cnt += 2
+			digits = int(d.SCPLength)
+			if !reflect.DeepEqual(d.SCPValue, tt.args.data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.Decode SCPValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.TunnelType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode TunnelType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.TunnelLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode TunnelLength error")
+			}
+			cnt += 2
+			digits = int(d.TunnelLength)
+			if !reflect.DeepEqual(d.TunnelValue, tt.args.data[cnt:cnt+digits]) {
+				t.Error("DiscoverySolicit.Decode TunnelValue error")
+			}
+			cnt += digits
+			if !reflect.DeepEqual(d.PadType, tt.args.data[cnt]) {
+				t.Error("DiscoverySolicit.Decode PadType error")
+			}
+			cnt++
+			if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) {
+				t.Error("DiscoverySolicit.Decode PadLength error")
+			}
+			cnt += 2
+			digits = int(d.PadLength)
+			if !reflect.DeepEqual(d.PadValue, tt.args.data[cnt:cnt+digits]) {
+				t.Errorf("DiscoverySolicit.Decode PadValue error %x %x", d.PadValue, tt.args.data[cnt:cnt+digits])
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/l2oam/msg_generic_action_create.go b/internal/pkg/core/l2oam/msg_generic_action_create.go
new file mode 100644
index 0000000..a50c6a5
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_generic_action_create.go
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+const (
+	ActionTypeProtocolFilter = 1
+
+	ActionTypeTrafficProfile = 2
+)
+
+// GenerateGenericActionCreate generates "Generic/Action Create" message
+func GenerateGenericActionCreate(actionType int) gopacket.SerializableLayer {
+	tibitData := &setGenericActionCreateReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 00000000,
+		//Vc
+		VcBranch: 0x6e,
+		VcLeaf:   0x7001,
+		VcLength: 4,
+		//OT
+		OT: []OTGenericActionCreate{{OTLength: 3, OTValue: getObjectType(actionType)}},
+		// End
+		EndBranch: 0,
+	}
+
+	return tibitData
+}
+
+func getObjectType(actionType int) []byte {
+	switch actionType {
+	case ActionTypeProtocolFilter:
+		return []byte{0x0c, 0x0c, 0xff}
+	case ActionTypeTrafficProfile:
+		return []byte{0x0c, 0x07, 0x0f}
+	default:
+		return []byte{0x00, 0x00, 0x00}
+	}
+}
+
+type setGenericActionCreateReq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	OT []OTGenericActionCreate
+	EndBranch uint8
+}
+
+// OTGenericActionCreate is a structure for "Object Type"
+type OTGenericActionCreate struct {
+	OTLength uint8
+	OTValue  []byte
+}
+
+// String returns the string expression of setGenericActionCreateReq
+func (d *setGenericActionCreateReq) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	for _, ot := range d.OT {
+		message = fmt.Sprintf("%s, OTLength:%x, OTValue:%v", message, ot.OTLength, hex.EncodeToString(ot.OTValue))
+	}
+	message = fmt.Sprintf("%s, EndBranch:%x", message, d.EndBranch)
+	return message
+}
+
+// Len returns the length of setGenericActionCreateReq
+func (d *setGenericActionCreateReq) Len() int {
+	return 21 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength)
+
+}
+
+// LayerType returns the ethernet type of setGenericActionCreateReq
+func (d *setGenericActionCreateReq) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *setGenericActionCreateReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	for _, ot := range d.OT {
+		nextIndex := serializeObjectType(&ot, data, i)
+		i = nextIndex
+	}
+
+	data[i] = byte(d.EndBranch)
+
+	return nil
+
+}
+
+func serializeObjectType(ot *OTGenericActionCreate, data []byte, startIndex int) int {
+	i := startIndex
+	data[i] = ot.OTLength
+	i++
+	copy(data[i:i+int(ot.OTLength)], ot.OTValue)
+	i += int(ot.OTLength)
+
+	return i
+
+}
+
+// SetGenericActionCreateRes is a structure for a response of "Generic/Action Create"
+type SetGenericActionCreateRes struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+
+	ObOCLength   uint8
+	ObOCBranch   uint8
+	ObOCType     uint16
+	ObOCLength2  uint8
+	ObOCInstance []byte
+
+	EndBranch uint8
+}
+
+// ObOC is a structure for "Object OC"
+type ObOC struct {
+	ObOCLength   uint8
+	ObOCBranch   uint8
+	ObOCType     uint16
+	ObOCLength2  uint8
+	ObOCInstance []byte
+}
+
+// String returns the string expression of SetGenericActionCreateRes
+func (d *SetGenericActionCreateRes) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, ObOCLength:%x, ObOCBranch:%x, ObOCType:%x, ObOCLength2:%x, ObOCInstance:%x, EndBranch:%x",
+		message, d.ObOCLength, d.ObOCBranch, d.ObOCType, d.ObOCLength2, d.ObOCInstance, d.EndBranch)
+	return message
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *SetGenericActionCreateRes) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+
+	d.ObOCLength = data[i]
+	i++
+	d.ObOCBranch = data[i]
+	i++
+	d.ObOCType = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.ObOCLength2 = data[i]
+	i++
+	d.ObOCInstance = data[i : i+int(d.ObOCLength2)]
+	i = i + int(d.ObOCLength2)
+
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetTrafficProfile returns the traffic profile of this message
+func (d *SetGenericActionCreateRes) GetTrafficProfile() []byte {
+	return d.ObOCInstance
+}
diff --git a/internal/pkg/core/l2oam/msg_generic_action_create_ds.go b/internal/pkg/core/l2oam/msg_generic_action_create_ds.go
new file mode 100644
index 0000000..40356d3
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_generic_action_create_ds.go
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateGenericActionCreateDs generates "Generic/Action Create" message
+func GenerateGenericActionCreateDs() gopacket.SerializableLayer {
+
+	tibitData := &setGenericActionCreateReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		//Vc
+		VcBranch: 0x6e,
+		VcLeaf:   0x7001,
+		VcLength: 4,
+		//OT
+		OT: []OTGenericActionCreate{{OTLength: 3, OTValue: []byte{0x0c, 0x02, 0x5d}}},
+		// End
+		EndBranch: 0,
+	}
+
+	return tibitData
+
+}
diff --git a/internal/pkg/core/l2oam/msg_generic_action_create_req.go b/internal/pkg/core/l2oam/msg_generic_action_create_req.go
new file mode 100644
index 0000000..766d1a1
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_generic_action_create_req.go
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+func GenerateGenericActionCreateReq() gopacket.SerializableLayer {
+
+	data := &TibitFrame{
+		Data: []byte{0x03, 0x00, 0x50, 0xfe, 0x2a, 0xea, 0x15, 0x03, 0x0c, 0x0c, 0x7a, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0d, 0xce, 0x04, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x70, 0x01, 0x04, 0x03, 0x0c, 0x02, 0x5d, 0x00, 0x00},
+	}
+
+	binary.BigEndian.PutUint32(data.Data[12:16], getOltInstance())
+
+	return data
+
+}
diff --git a/internal/pkg/core/l2oam/msg_get_firmware_version.go b/internal/pkg/core/l2oam/msg_get_firmware_version.go
new file mode 100644
index 0000000..82995a7
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_firmware_version.go
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGetFirmwareVersion generates "Running Firmware Version" message
+func GenerateGetFirmwareVersion() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x001b,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// GetFirmwareVersionRes is a structure for a response of "Running Firmware Version"
+type GetFirmwareVersionRes struct {
+	ComResp   TOAMGetResponse
+	AKLength  uint8
+	AKValue   []byte
+	RVLength  uint8
+	RVValue   []byte
+	BSLength  uint8
+	BSValue   []byte
+	RNLength  uint8
+	RNValue   []byte
+	BDLength  uint8
+	BDValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetFirmwareVersionRes
+func (d *GetFirmwareVersionRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, AKLength:%02x, AKValue:%s, RVLength:%02x, RVValue:%s", message, d.AKLength, hex.EncodeToString(d.AKValue), d.RVLength, hex.EncodeToString(d.RVValue))
+	message = fmt.Sprintf("%s, BSLength:%02x, BSValue:%s, RNLength:%02x, RNValue:%s", message, d.BSLength, hex.EncodeToString(d.BSValue), d.RNLength, hex.EncodeToString(d.RNValue))
+	message = fmt.Sprintf("%s, BDLength:%02x, BDValue:%s, EndBranch:%02x", message, d.BDLength, hex.EncodeToString(d.BDValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetFirmwareVersionRes
+func (d *GetFirmwareVersionRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetFirmwareVersionRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.AKLength = data[i]
+	i++
+	d.AKValue = data[i : i+int(d.AKLength)]
+	i += int(d.AKLength)
+	d.RVLength = data[i]
+	i++
+	d.RVValue = data[i : i+int(d.RVLength)]
+	i += int(d.RVLength)
+	d.BSLength = data[i]
+	i++
+	d.BSValue = data[i : i+int(d.BSLength)]
+	i += int(d.BSLength)
+	d.RNLength = data[i]
+	i++
+	d.RNValue = data[i : i+int(d.RNLength)]
+	i += int(d.RNLength)
+	d.BDLength = data[i]
+	i++
+	d.BDValue = data[i : i+int(d.BDLength)]
+	i += int(d.BDLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetFirmwareVersionNumber returns a firmware version number
+func (d *GetFirmwareVersionRes) GetFirmwareVersionNumber() string {
+	return string(d.RVValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_mac_address.go b/internal/pkg/core/l2oam/msg_get_mac_address.go
new file mode 100644
index 0000000..e1df063
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_mac_address.go
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGetMacAddress generates "PON Port/MAC Address" message
+func GenerateGetMacAddress() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0x07,
+		VdLeaf:   0x0004,
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
+
+// GetMacAddressRes is a structure for a toam response
+type GetMacAddressRes struct {
+	ComResp TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetMacAddressRes
+func (d *GetMacAddressRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%x, EcValue:%v, EndBranch:%x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetMacAddressRes
+func (d *GetMacAddressRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetMacAddressRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i = i + int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetMacAddress returns a MAC address
+func (d *GetMacAddressRes) GetMacAddress() string {
+	var buf []string
+	for _, b := range d.EcValue {
+		buf = append(buf, fmt.Sprintf("%02x", b))
+	}
+	return strings.Join(buf, ":")
+}
diff --git a/internal/pkg/core/l2oam/msg_get_manufacturer.go b/internal/pkg/core/l2oam/msg_get_manufacturer.go
new file mode 100644
index 0000000..74aa268
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_manufacturer.go
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateManuFacturerInfo generates "Device/Manufacturer Info" message
+func GenerateManuFacturerInfo() gopacket.SerializableLayer {
+
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		//OAMPrtocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		//TiBitT OLT Management
+		TOMIOpcode: 0x01,
+		//Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		//Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		//Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x0006,
+		//End
+		EndBranch: 0x00,
+	}
+	return tibitData
+
+}
+
+// GetManufacturerRes is a structure for a toam response
+type GetManufacturerRes struct {
+	ComResp TOAMGetResponse
+	ECLength uint8
+	ECValue  []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetManufacturerRes
+func (d *GetManufacturerRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, ECLength:%02x, ECValue:%v,EndBranch:%02x", message, d.ECLength, hex.EncodeToString(d.ECValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetManufacturerRes
+func (d *GetManufacturerRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetManufacturerRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.ECLength = data[i]
+	i++
+	d.ECValue = data[i : i+int(d.ECLength)]
+	i = i + int(d.ECLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetManufacturer returns a manufacturer info.
+func (d *GetManufacturerRes) GetManufacturer() string {
+	return string(d.ECValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_module_number.go b/internal/pkg/core/l2oam/msg_get_module_number.go
new file mode 100644
index 0000000..b256acd
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_module_number.go
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGetModuleNumber generates "Device/Model Number" message
+func GenerateGetModuleNumber() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x81,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x000a,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// GetModuleNumberRes is a structure for toam message
+type GetModuleNumberRes struct {
+	ComResp   TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetModuleNumberRes
+func (d *GetModuleNumberRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%02x, EcValue:%s EndBranch:%02x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetModuleNumberRes
+func (d *GetModuleNumberRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetModuleNumberRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i += int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetModuleNumber returns a module number
+func (d *GetModuleNumberRes) GetModuleNumber() string {
+	return string(d.EcValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_mpcp_llid.go b/internal/pkg/core/l2oam/msg_get_mpcp_llid.go
new file mode 100644
index 0000000..f1f7a10
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_mpcp_llid.go
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GetMpcpLLIdReq is a structure for "MPCP/LLID" message
+type GetMpcpLLIdReq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VdBranch uint8
+	VdLeaf   uint16
+	EndBranch uint8
+}
+
+// GenerateGetMpcpLLId generates "MPCP/LLID" message
+func GenerateGetMpcpLLId(oc *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &GetMpcpLLIdReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vd
+		VdBranch: 0xcc,
+		VdLeaf:   0x0007,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// String returns the string expression of GetMpcpLLIdReq
+func (d *GetMpcpLLIdReq) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VdBranch:%02x, VdLeaf:%04x, EndBranch:%02x", message, d.VdBranch, d.VdLeaf, d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetMpcpLLIdReq
+func (d *GetMpcpLLIdReq) Len() int {
+	return 21
+}
+
+// LayerType returns the ethernet type of GetMpcpLLIdReq
+func (d *GetMpcpLLIdReq) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *GetMpcpLLIdReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VdBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VdLeaf)
+	i += 2
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+// GetMpcpLLIdRes is a structure for a response of "MPCP/LLID" message
+type GetMpcpLLIdRes struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	EcLength uint8
+	EcValue  []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetMpcpLLIdRes
+func (d *GetMpcpLLIdRes) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%02x, VcLeaf:%04x, VcLength:%02x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, EcLength:%02x, EcValue:%v, EndBranch:%02x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetMpcpLLIdRes
+func (d *GetMpcpLLIdRes) Len() int {
+	return 20 + int(d.VcLength) + 1
+}
+
+// LayerType returns the ethernet type of GetMpcpLLIdRes
+func (d *GetMpcpLLIdRes) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// Decode decodes byte arrays to a data structure
+func (d *GetMpcpLLIdRes) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i += int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetLLID returns a LLID
+func (d *GetMpcpLLIdRes) GetLLID() uint16 {
+	return binary.BigEndian.Uint16(d.EcValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_mpcp_mac_address.go b/internal/pkg/core/l2oam/msg_get_mpcp_mac_address.go
new file mode 100644
index 0000000..7d9313c
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_mpcp_mac_address.go
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GetMpcpMacAddressReq is a structure for "MPCP/MAC Address" message
+type GetMpcpMacAddressReq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VdBranch uint8
+	VdLeaf   uint16
+	EndBranch uint8
+}
+
+// GenerateGetMpcpMacAddress generates "MPCP/MAC Address" message
+func GenerateGetMpcpMacAddress(oc *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &GetMpcpMacAddressReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vd
+		VdBranch: 0xcc,
+		VdLeaf:   0x0008,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// String returns the string expression of GetMpcpMacAddressReq
+func (d *GetMpcpMacAddressReq) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VdBranch:%02x, VdLeaf:%04x, EndBranch:%02x", message, d.VdBranch, d.VdLeaf, d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetModuleNumberRes
+func (d *GetMpcpMacAddressReq) Len() int {
+	return 21
+}
+
+// LayerType returns the ethernet type of GetMpcpMacAddressReq
+func (d *GetMpcpMacAddressReq) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *GetMpcpMacAddressReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VdBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VdLeaf)
+	i += 2
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+// GetMpcpMacAddressRes is a structure for a response of "MPCP/MAC Address" message
+type GetMpcpMacAddressRes struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	EcLength uint8
+	EcValue  []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetMpcpMacAddressRes
+func (d *GetMpcpMacAddressRes) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%02x, VcLeaf:%04x, VcLength:%02x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, EcLength:%02x, EcValue:%v, EndBranch:%02x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetMpcpMacAddressRes
+func (d *GetMpcpMacAddressRes) Len() int {
+	return 20 + int(d.VcLength) + 1
+}
+
+// LayerType returns the ethernet type of GetMpcpMacAddressRes
+func (d *GetMpcpMacAddressRes) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// Decode decodes byte arrays to a data structure
+func (d *GetMpcpMacAddressRes) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i += int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetMacAddress returns a MAC address
+func (d *GetMpcpMacAddressRes) GetMacAddress() string {
+	var buf []string
+	for _, b := range d.EcValue {
+		buf = append(buf, fmt.Sprintf("%02x", b))
+	}
+	return strings.Join(buf, ":")
+}
diff --git a/internal/pkg/core/l2oam/msg_get_pon_mode.go b/internal/pkg/core/l2oam/msg_get_pon_mode.go
new file mode 100644
index 0000000..74f8e00
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_pon_mode.go
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGetPonMode generates "Device/PON Mode" message
+func GenerateGetPonMode() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x0002,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// GetPonMode is a structure for toam message
+type GetPonMode struct {
+	ComResp   TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetPonMode
+func (d *GetPonMode) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%02x, EcValue:%s EndBranch:%02x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetPonMode
+func (d *GetPonMode) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetPonMode) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i += int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetPonMode returns a PON mode
+func (d *GetPonMode) GetPonMode() string {
+	return string(d.EcValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_serial_number.go b/internal/pkg/core/l2oam/msg_get_serial_number.go
new file mode 100644
index 0000000..73c662d
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_serial_number.go
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGetSerialNumber generates "Device/Vendor Serial Number" message
+func GenerateGetSerialNumber() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x0012,
+		// End
+		EndBranch: 0,
+	}
+	return tibitData
+}
+
+// GetSerialNumberRes is a structure for toam message
+type GetSerialNumberRes struct {
+	ComResp   TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetSerialNumberRes
+func (d *GetSerialNumberRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%02x, EcValue:%s EndBranch:%02x", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetSerialNumberRes
+func (d *GetSerialNumberRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetSerialNumberRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i += int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetSerialNumber returns a serial number
+func (d *GetSerialNumberRes) GetSerialNumber() string {
+	return string(d.EcValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_get_traffic_control_reference_table.go b/internal/pkg/core/l2oam/msg_get_traffic_control_reference_table.go
new file mode 100644
index 0000000..96b8c72
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_traffic_control_reference_table.go
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateGetTrafficControlReferenceTableReq generates "PON Link/Traffic Control Reference Table" message
+func GenerateGetTrafficControlReferenceTableReq(oc *TomiObjectContext) gopacket.SerializableLayer {
+	data := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vd
+		VdBranch: 0x01,
+		VdLeaf:   0x0007,
+		// End
+		EndBranch: 0x00,
+	}
+
+	return data
+}
+
+// GetTrafficControlReferenceTableRes is a structure for a response of "Traffic Control Reference Table" message
+type GetTrafficControlReferenceTableRes struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+
+	EcOcLengthDown   uint8
+	EcOcBranchDown   uint8
+	EcOcTypeDown     uint16
+	EcOcLength2Down  uint8
+	EcOcInstanceDown []byte
+
+	EcOcLengthUp   uint8
+	EcOcBranchUp   uint8
+	EcOcTypeUp     uint16
+	EcOcLength2Up  uint8
+	EcOcInstanceUp []byte
+
+	EndBranch uint8
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetTrafficControlReferenceTableRes) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+
+	d.EcOcLengthDown = data[i]
+	i++
+	d.EcOcBranchDown = data[i]
+	i++
+	d.EcOcTypeDown = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.EcOcLength2Down = data[i]
+	i++
+	d.EcOcInstanceDown = data[i : i+int(d.EcOcLength2Down)]
+	i += int(d.EcOcLength2Down)
+
+	d.EcOcLengthUp = data[i]
+	i++
+	d.EcOcBranchUp = data[i]
+	i++
+	d.EcOcTypeUp = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.EcOcLength2Up = data[i]
+	i++
+	d.EcOcInstanceUp = data[i : i+int(d.EcOcLength2Up)]
+	i += int(d.EcOcLength2Up)
+
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetReferenceControlDown returns a link id for downstream
+func (d *GetTrafficControlReferenceTableRes) GetReferenceControlDown() []byte {
+	return d.EcOcInstanceDown
+}
+
+// GetReferenceControlUp returns a link id for upstream
+func (d *GetTrafficControlReferenceTableRes) GetReferenceControlUp() []byte {
+	return d.EcOcInstanceUp
+}
diff --git a/internal/pkg/core/l2oam/msg_get_vendor_name.go b/internal/pkg/core/l2oam/msg_get_vendor_name.go
new file mode 100644
index 0000000..aa80fcd
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_get_vendor_name.go
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+// GnerateGetVendorName generates "Device/Vendor Name"
+func GnerateGetVendorName() gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x01,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vd
+		VdBranch: 0xde,
+		VdLeaf:   0x0009,
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
+
+// GetVendorNameRes is a structure for a response of "Device/Vendor Name" message
+type GetVendorNameRes struct {
+	ComResp TOAMGetResponse
+	EcLength  uint8
+	EcValue   []byte
+	EndBranch uint8
+}
+
+// String returns the string expression of GetVendorNameRes
+func (d *GetVendorNameRes) String() string {
+	message := d.ComResp.String()
+	message = fmt.Sprintf("%s, EcLength:%v, EcValue:%v, EndBranch:%v", message, d.EcLength, hex.EncodeToString(d.EcValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of GetVendorNameRes
+func (d *GetVendorNameRes) Len() int {
+	return d.ComResp.Len() + int(d.ComResp.VcLength) + 1
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *GetVendorNameRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	d.EcLength = data[i]
+	i++
+	d.EcValue = data[i : i+int(d.EcLength)]
+	i = i + int(d.EcLength)
+	d.EndBranch = data[i]
+
+	return nil
+}
+
+// GetVendorName returns a vendor name
+func (d *GetVendorNameRes) GetVendorName() string {
+	return string(d.EcValue)
+}
diff --git a/internal/pkg/core/l2oam/msg_guaranteed_mbs.go b/internal/pkg/core/l2oam/msg_guaranteed_mbs.go
new file mode 100644
index 0000000..675e44e
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_guaranteed_mbs.go
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateGuaranteedMbs generates "Traffic Profile/Guaranteed MBS" message
+func GenerateGuaranteedMbs() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x070f,
+		OCLength:   4,
+		OCInstance: 0x00000002,
+		// Vc
+		VcBranch: 0x7f,
+		VcLeaf:   0x0007,
+		VcLength: 5,
+		// EC
+		ECLength: 4,
+		ECValue:  []byte{0x00, 0x06, 0x40, 0x00},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_guaranteed_rate.go b/internal/pkg/core/l2oam/msg_guaranteed_rate.go
new file mode 100644
index 0000000..c26825d
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_guaranteed_rate.go
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateGuaranteedRate generates "Traffic Profile/Guaranteed Rate" message
+func GenerateGuaranteedRate(ecvalue []byte, trafficProfile []byte) gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x070f,
+		OCLength:   4,
+		OCInstance: binary.BigEndian.Uint32(trafficProfile),
+		// Vc
+		VcBranch: 0x7f,
+		VcLeaf:   0x0006,
+		VcLength: uint8(1 + len(ecvalue)), //
+		// EC
+		ECLength: uint8(len(ecvalue)), //
+		ECValue:  ecvalue,             //0x80
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_l2switching_domain_action_Inlet_entry_del.go b/internal/pkg/core/l2oam/msg_l2switching_domain_action_Inlet_entry_del.go
new file mode 100644
index 0000000..667fb7f
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_l2switching_domain_action_Inlet_entry_del.go
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateL2switchingDomainActionInletEntryUsDel generates "L2 Switching Domain/Action Delete Inlet entry(for upstream)"
+func GenerateL2switchingDomainActionInletEntryUsDel(oc *TomiObjectContext,
+	tpid []byte, vid []byte, onuID *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &L2switchingDomainRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x5d,
+		VcLeaf:   0x7002,
+		VcLength: 21 + uint8(1+1+len(tpid)+1+len(vid)),
+		// Source OC
+		SOLength:    5,
+		SOBranch:    0x0c,
+		SOType:      0x0011,
+		SOValLength: 1,
+		SOInstance:  uint8(onuID.Instance),
+		// TagMatchList
+		TMLLength: 7,
+		TMLList: []TpidVid{
+			{
+				Length:     3,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  1,
+				VIdValue:   []byte{0x00},
+			},
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  0x80,
+				VIdValue:   []byte{},
+			},
+		},
+		// TagOpPop(UI)
+		TOPopLength: 1,
+		TOPopValue:  0x00,
+		// TagOpSetList
+		TOSLength: 3,
+		TOSList: []TpidVid{
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  0x80,
+				VIdValue:   []byte{},
+			},
+		},
+		// TagOpPushList
+		TOPushLength: uint8(1 + 1 + len(tpid) + 1 + len(vid)),
+		TOPushList: []TpidVid{
+			{
+				Length:     uint8(1 + len(tpid) + 1 + len(vid)),
+				TpIDLength: uint8(len(tpid)),
+				TpIDValue:  tpid,
+				VIdLength:  uint8(len(vid)),
+				VIdValue:   vid,
+			},
+		},
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
+
+// GenerateL2switchingDomainActionInletEntryDsDel generates "L2 Switching Domain/Action Delete Inlet entry(for downstream)"
+func GenerateL2switchingDomainActionInletEntryDsDel(oc *TomiObjectContext, tpid []byte, vid []byte) gopacket.SerializableLayer {
+	tibitData := &L2switchingDomainRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x5d,
+		VcLeaf:   0x7002,
+		VcLength: 16 + uint8(1+1+len(tpid)+1+len(vid)+4),
+		// Source OC
+		SOLength:    5,
+		SOBranch:    0x0c,
+		SOType:      0x0eca,
+		SOValLength: 1,
+		SOInstance:  0x00,
+		// TagMatchList
+		TMLLength: uint8(1 + 1 + len(tpid) + 1 + len(vid) + 3),
+		TMLList: []TpidVid{
+			{
+				Length:     uint8(1 + len(tpid) + 1 + len(vid)),
+				TpIDLength: uint8(len(tpid)),
+				TpIDValue:  tpid,
+				VIdLength:  uint8(len(vid)),
+				VIdValue:   vid,
+			},
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  0x80,
+				VIdValue:   []byte{},
+			},
+		},
+		// TagOpPop(UI)
+		TOPopLength: 1,
+		TOPopValue:  0x01,
+		// TagOpSetList
+		TOSLength: 3,
+		TOSList: []TpidVid{
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  0x80,
+				VIdValue:   []byte{},
+			},
+		},
+		// TagOpPushList
+		TOPushLength: 3,
+		TOPushList: []TpidVid{
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{},
+				VIdLength:  0x80,
+				VIdValue:   []byte{},
+			},
+		},
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry.go b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry.go
new file mode 100644
index 0000000..b826292
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry.go
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// L2switchingDomainRequest is a structure for a request of "L2 Switching Domain/Action Inlet entry" message
+type L2switchingDomainRequest struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	SOLength    uint8
+	SOBranch    uint8
+	SOType      uint16
+	SOValLength uint8
+	SOInstance  uint8
+	TMLLength uint8
+	TMLList   []TpidVid
+	TOPopLength uint8
+	TOPopValue  uint8
+	TOSLength uint8
+	TOSList   []TpidVid
+	TOPushLength uint8
+	TOPushList   []TpidVid
+	EndBranch  uint8
+	SizeMargin uint8
+}
+
+// TpidVid is a structure for TPID/VID set
+type TpidVid struct {
+	Length     uint8
+	TpIDLength uint8
+	TpIDValue  []byte
+	VIdLength  uint8
+	VIdValue   []byte
+}
+
+// String returns the string expression of L2switchingDomainRequest
+func (d *L2switchingDomainRequest) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, SOLength:%x, SOBranch:%x, SOType:%x, SOValLength:%x, SOInstance:%x", message, d.SOLength, d.SOBranch, d.SOType, d.SOValLength, d.SOInstance)
+	message = fmt.Sprintf("%s, TMLLength:%x", message, d.TMLLength)
+	for i, tagMatch := range d.TMLList {
+		message = fmt.Sprintf("%s, %s", message, stringToTpidVid(&tagMatch, i))
+	}
+	message = fmt.Sprintf("%s, TOPopLength:%x, TOPopValue:%x", message, d.TOPopLength, d.TOPopValue)
+	message = fmt.Sprintf("%s, TOSLength:%x", message, d.TOSLength)
+	for i, tagOpSet := range d.TOSList {
+		message = fmt.Sprintf("%s, %s", message, stringToTpidVid(&tagOpSet, i))
+	}
+	message = fmt.Sprintf("%s, TOPushLength:%x", message, d.TOPushLength)
+	for i, tagOpPush := range d.TOPushList {
+		message = fmt.Sprintf("%s, %s", message, stringToTpidVid(&tagOpPush, i))
+	}
+	return message
+}
+
+func stringToTpidVid(tpidVid *TpidVid, index int) string {
+	message := fmt.Sprintf("EC[%v]:{Length:%x, TpIdLength:%x", index, tpidVid.Length, tpidVid.TpIDLength)
+	if tpidVid.TpIDLength != 128 {
+		message = fmt.Sprintf("%s, TpIdValue:%v", message, hex.EncodeToString(tpidVid.TpIDValue))
+	}
+	message = fmt.Sprintf("%s, VIdLength:%x", message, tpidVid.VIdLength)
+	if tpidVid.VIdLength != 128 {
+		message = fmt.Sprintf("%s, VIdValue:%v", message, hex.EncodeToString(tpidVid.VIdValue))
+	}
+	message = fmt.Sprintf("%s}", message)
+	return message
+}
+
+// Len returns the length of L2switchingDomainRequest
+func (d *L2switchingDomainRequest) Len() int {
+	return 22 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength) + int(d.SizeMargin)
+}
+
+// LayerType returns the ethernet type of L2switchingDomainRequest
+func (d *L2switchingDomainRequest) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *L2switchingDomainRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	data[i] = byte(d.SOLength)
+	i++
+	data[i] = byte(d.SOBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.SOType)
+	i += 2
+	data[i] = byte(d.SOValLength)
+	i++
+	data[i] = byte(d.SOInstance)
+	i++
+	data[i] = byte(d.TMLLength)
+	i++
+	for _, tagMatch := range d.TMLList {
+		nextIndex := serializeTpidVid(&tagMatch, data, i)
+		i = nextIndex
+	}
+	data[i] = byte(d.TOPopLength)
+	i++
+	data[i] = byte(d.TOPopValue)
+	i++
+	data[i] = byte(d.TOSLength)
+	i++
+	for _, tagOpSet := range d.TOSList {
+		nextIndex := serializeTpidVid(&tagOpSet, data, i)
+		i = nextIndex
+	}
+	data[i] = d.TOPushLength
+	i++
+	for _, tagOpPush := range d.TOPushList {
+		nextIndex := serializeTpidVid(&tagOpPush, data, i)
+		i = nextIndex
+	}
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+func serializeTpidVid(tpidVid *TpidVid, data []byte, startIndex int) int {
+	i := startIndex
+	data[i] = tpidVid.Length
+	i++
+	ln := tpidVid.TpIDLength
+	data[i] = ln
+	i++
+	if ln != 128 { // !Empty?
+		copy(data[i:i+int(ln)], tpidVid.TpIDValue)
+		i += int(ln)
+	}
+	ln = tpidVid.VIdLength
+	data[i] = ln
+	i++
+	if ln != 128 { // !Empty?
+		copy(data[i:i+int(ln)], tpidVid.VIdValue)
+		i += int(ln)
+	}
+	return i
+}
diff --git a/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_ds.go b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_ds.go
new file mode 100644
index 0000000..6013ce3
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_ds.go
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateL2switchingDomainActionLnletEntryDs generates "L2 Switching Domain/Action Add Inlet entry(for downstream)"
+func GenerateL2switchingDomainActionLnletEntryDs(oc *TomiObjectContext, tmTpidValue []byte, tmVidValue []byte) gopacket.SerializableLayer {
+
+	tibitData := &L2switchingDomainRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x5d,
+		VcLeaf:   0x7001,
+		//VcLength: uint8(24 + len(tmTpidValue) + len(tmVidValue)), //27
+		VcLength: uint8(23 + len(tmTpidValue) + len(tmVidValue)), //26
+		// Source OC
+		SOLength:    5,
+		SOBranch:    0x0c,
+		SOType:      0x0eca,
+		SOValLength: 1,
+		SOInstance:  0x00,
+		// TagMatchList
+		//TMLLength: uint8(7 + len(tmTpidValue) + len(tmVidValue)), //10
+		TMLLength: uint8(6 + len(tmTpidValue) + len(tmVidValue)), //9
+		TMLList: []TpidVid{
+			{Length: uint8(2 + len(tmTpidValue) + len(tmVidValue)),
+				TpIDLength: uint8(len(tmTpidValue)),
+				TpIDValue:  tmTpidValue,
+				VIdLength:  uint8(len(tmVidValue)),
+				VIdValue:   tmVidValue},
+			////{Length: 5, TpIdLength: 2, TpIdValue: []byte{0x88, 0xa8}, VIdLength: 1, VIdValue: []byte{0x64}}
+
+			//{Length: 3, TpIdLength: 128, TpIdValue: []byte{0}, VIdLength: 1, VIdValue: []byte{0x00}}},
+			{Length: 2, TpIDLength: 128, TpIDValue: []byte{0}, VIdLength: 128, VIdValue: []byte{0x00}}},
+		// TagOpPop(UI)
+		TOPopLength: 1,
+		TOPopValue:  0x01,
+		// TagOpSetList
+		TOSLength: 3,
+		TOSList: []TpidVid{
+			{Length: 2, TpIDLength: 128, TpIDValue: []byte{0}, VIdLength: 128, VIdValue: []byte{0}}},
+		// TagOpPushList
+		TOPushLength: 3,
+		TOPushList: []TpidVid{
+			{Length: 2, TpIDLength: 128, TpIDValue: []byte{0}, VIdLength: 128, VIdValue: []byte{0}}},
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_us.go b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_us.go
new file mode 100644
index 0000000..5f07c98
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_l2switching_domain_action_lnlet_entry_us.go
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateL2switchingDomainActionLnletEntryUs generates "L2 Switching Domain/Action Add Inlet entry(upstream)" message
+func GenerateL2switchingDomainActionLnletEntryUs(oc *TomiObjectContext,
+	pushTpidValue []byte, pushVidValue []byte, onuID *TomiObjectContext) gopacket.SerializableLayer {
+
+	tibitData := &L2switchingDomainRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x5d,
+		VcLeaf:   0x7001,
+		VcLength: uint8(24 + len(pushTpidValue) + len(pushVidValue)), //27
+		// Source OC
+		SOLength:    5,
+		SOBranch:    0x0c,
+		SOType:      0x0011,
+		SOValLength: 1,
+		SOInstance:  uint8(onuID.Instance),
+		// TagMatchList
+		TMLLength: 7,
+		TMLList: []TpidVid{
+			{
+				Length:     3,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{0},
+				VIdLength:  1,
+				VIdValue:   []byte{0x00},
+			},
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{0},
+				VIdLength:  0x80,
+				VIdValue:   []byte{0},
+			}},
+		// TagOpPop(UI)
+		TOPopLength: 1,
+		TOPopValue:  0x00,
+		// TagOpSetList
+		TOSLength: 3,
+		TOSList: []TpidVid{
+			{
+				Length:     2,
+				TpIDLength: 0x80,
+				TpIDValue:  []byte{0},
+				VIdLength:  0x80,
+				VIdValue:   []byte{0},
+			}},
+		// TagOpPushList
+		TOPushLength: uint8(3 + len(pushTpidValue) + len(pushVidValue)), //6
+		TOPushList: []TpidVid{
+			{Length: uint8(2 + len(pushTpidValue) + len(pushVidValue)),
+				TpIDLength: uint8(len(pushTpidValue)),
+				TpIDValue:  pushTpidValue,
+				VIdLength:  uint8(len(pushVidValue)),
+				VIdValue:   pushVidValue}}, ///{Length: 5, TpIdLength: 2, TpIdValue: []byte{0x88, 0xa8}, VIdLength: 1, VIdValue: []byte{0x64}}
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_oampdu_information.go b/internal/pkg/core/l2oam/msg_oampdu_information.go
new file mode 100644
index 0000000..6d7a9f8
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_oampdu_information.go
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// OampduTlvTypeLocalInfo means that TLV type is "Local Information"
+var OampduTlvTypeLocalInfo uint8 = 0x01
+
+// OampduTlvTypeRemoteInfo means that TLV type is "Remote Information"
+var OampduTlvTypeRemoteInfo uint8 = 0x02
+
+// OampduTlvTypeOrganizationSpecificInfo means that TLV type is "Organization Specific Information"
+var OampduTlvTypeOrganizationSpecificInfo uint8 = 0xfe
+
+// GeneateKeepAlive1 generates "OAMPDU Information(first)"
+func GeneateKeepAlive1(isOnuPkgA bool) gopacket.SerializableLayer {
+	var osiLength uint8
+	var osiValue []byte
+	if isOnuPkgA {
+		osiLength = 7
+		osiValue = []byte{0x00, 0x10, 0x00, 0x00, 0x23}
+	} else {
+		osiLength = 8
+		osiValue = []byte{0x90, 0x82, 0x60, 0x02, 0x01, 0x01}
+	}
+	tibitData := &OAMPDUInformation{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags: 0x0008,
+		Code:  0x00,
+		// Local Information TLV
+		LIType:   OampduTlvTypeLocalInfo,
+		LILength: 16,
+		LIValue:  []byte{0x01, 0x00, 0x00, 0x00, 0x1b, 0x04, 0xb0, 0x2a, 0xea, 0x15, 0x00, 0x00, 0x00, 0x23},
+		// Organization Specific Information TLV
+		OSIType:   OampduTlvTypeOrganizationSpecificInfo,
+		OSILength: osiLength,
+		OSIValue:  osiValue,
+	}
+
+	return tibitData
+}
+
+// GeneateKeepAlive2 generates "OAMPDU Information(second)"
+func GeneateKeepAlive2(riValue []byte, isOnuPkgA bool) gopacket.SerializableLayer {
+	var osiLength uint8
+	var osiValue []byte
+	if isOnuPkgA {
+		osiLength = 7
+		osiValue = []byte{0x00, 0x10, 0x00, 0x00, 0x23}
+	} else {
+		osiLength = 8
+		osiValue = []byte{0x90, 0x82, 0x60, 0x02, 0x01, 0x01}
+	}
+	tibitData := &OAMPDUInformation{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags: 0x0030,
+		Code:  0x00,
+		// Local Information TLV
+		LIType:   OampduTlvTypeLocalInfo,
+		LILength: 16,
+		LIValue:  []byte{0x01, 0x00, 0x00, 0x00, 0x1b, 0x04, 0xb0, 0x2a, 0xea, 0x15, 0x00, 0x00, 0x00, 0x23},
+		// Remote Information TLV
+		RIType:   OampduTlvTypeRemoteInfo,
+		RILength: 16,
+		RIValue:  riValue,
+		// Organization Specific Information TLV
+		OSIType:   OampduTlvTypeOrganizationSpecificInfo,
+		OSILength: osiLength,
+		OSIValue:  osiValue,
+	}
+
+	return tibitData
+
+}
+
+// GeneateKeepAlive3 generates "OAMPDU Information(third)"
+func GeneateKeepAlive3(riValue []byte) gopacket.SerializableLayer {
+	tibitData := &OAMPDUInformation{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags: 0x0050,
+		Code:  0x00,
+		// Local Information TLV
+		LIType:   OampduTlvTypeLocalInfo,
+		LILength: 16,
+		LIValue:  []byte{0x01, 0x00, 0x00, 0x00, 0x1b, 0x04, 0xb0, 0x2a, 0xea, 0x15, 0x00, 0x00, 0x00, 0x23},
+		// Remote Information TLV
+		RIType:   OampduTlvTypeRemoteInfo,
+		RILength: 16,
+		RIValue:  riValue,
+	}
+
+	return tibitData
+
+}
+
+// OAMPDUInformation is a structure for "OAMPDU Information" message
+type OAMPDUInformation struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags uint16
+	Code  uint8
+	LIType   uint8
+	LILength uint8
+	LIValue  []byte
+	RIType   uint8
+	RILength uint8
+	RIValue  []byte
+	OSIType   uint8
+	OSILength uint8
+	OSIValue  []byte
+}
+
+// String returns the string expression of OAMPDUInformation
+func (d *OAMPDUInformation) String() string {
+	message := fmt.Sprintf("Opcode:%v, Flags:%v, Code:%v", d.Opcode, d.Flags, d.Code)
+	message = fmt.Sprintf("%s, LIType:%v, LILength:%v, LIValue:%v", message, d.LIType, d.LILength, hex.EncodeToString(d.LIValue))
+	message = fmt.Sprintf("%s, RIType:%v, RILength:%v, RIValue:%v", message, d.RIType, d.RILength, hex.EncodeToString(d.RIValue))
+	message = fmt.Sprintf("%s, OSIType:%v, OSILength:%v, OSIValue:%v", message, d.OSIType, d.OSILength, hex.EncodeToString(d.OSIValue))
+	return message
+}
+
+// Len returns the length of OAMPDUInformation
+func (d *OAMPDUInformation) Len() int {
+	len := (1) + (3) + int(d.LILength) + int(d.RILength) + int(d.OSILength)
+	return len
+}
+
+// LayerType returns the ethernet type of OAMPDUInformation
+func (d *OAMPDUInformation) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *OAMPDUInformation) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i = i + 2
+	data[i] = byte(d.Code)
+	i++
+
+	if d.LILength != 0 {
+		data[i] = byte(d.LIType)
+		data[i+1] = byte(d.LILength)
+		copy(data[i+2:i+int(d.LILength)], d.LIValue)
+		i = i + int(d.LILength)
+	}
+
+	if d.RILength != 0 {
+		data[i] = byte(d.RIType)
+		data[i+1] = byte(d.RILength)
+		copy(data[i+2:i+int(d.RILength)], d.RIValue)
+		i = i + int(d.RILength)
+	}
+
+	if d.OSILength != 0 {
+		data[i] = byte(d.OSIType)
+		data[i+1] = byte(d.OSILength)
+		copy(data[i+2:i+int(d.OSILength)], d.OSIValue)
+		//i = i + int(d.OSILength)
+	}
+
+	return nil
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *OAMPDUInformation) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i = i + 2
+	d.Code = data[i]
+	i++
+
+	for {
+		if len(data) <= i {
+			break
+		}
+		tlvType := data[i]
+		tlvLength := data[i+1]
+		if tlvLength == 0 {
+			break
+		}
+		tlvValue := data[i+2 : i+int(tlvLength)]
+		i = i + int(tlvLength)
+
+		switch tlvType {
+		case OampduTlvTypeLocalInfo:
+			d.LIType = tlvType
+			d.LILength = tlvLength
+			d.LIValue = tlvValue
+		case OampduTlvTypeRemoteInfo:
+			d.RIType = tlvType
+			d.RILength = tlvLength
+			d.RIValue = tlvValue
+		case OampduTlvTypeOrganizationSpecificInfo:
+			d.OSIType = tlvType
+			d.OSILength = tlvLength
+			d.OSIValue = tlvValue
+		default:
+			return fmt.Errorf("tlvType Error: %v", tlvType)
+		}
+	}
+
+	return nil
+}
+
+// IsOnuPkgA returns true if message type of OAMPDUInformation is PkgA
+func (d *OAMPDUInformation) IsOnuPkgA() bool {
+	if d.OSILength == 0 {
+		// return true if OSILength is 0, this means the message is KeepAlive3
+		return true
+	} else if d.OSILength == 7 {
+		return (d.OSIValue[0] == 0x00 && d.OSIValue[1] == 0x10 && d.OSIValue[2] == 0x00)
+	}
+	return false
+}
+
+// IsOnuPkgB returns true if message type of OAMPDUInformation is PkgA
+func (d *OAMPDUInformation) IsOnuPkgB() bool {
+	if d.OSILength == 0 {
+		// return true if OSILength is 0, this means the message is KeepAlive3
+		return true
+	} else if d.OSILength == 7 {
+		return (d.OSIValue[0] == 0x90 && d.OSIValue[1] == 0x82 && d.OSIValue[2] == 0x60)
+	}
+	return false
+}
diff --git a/internal/pkg/core/l2oam/msg_pcscompu_tibitcom.go b/internal/pkg/core/l2oam/msg_pcscompu_tibitcom.go
new file mode 100644
index 0000000..80e7d18
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_pcscompu_tibitcom.go
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+)
+
+func GeneratePcscompuTivitcom(oc *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &TOAMGetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x81,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: 0x00000003,
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vd
+		VdBranch: 0x01,
+		VdLeaf:   0x0007,
+		// End
+		EndBranch: 0,
+	}
+
+	return tibitData
+}
+
+type GetTrafficControlRefTableRes struct {
+	ComResp TOAMGetResponse
+
+	ECOC      []EcOcPONLinkTrafficControlReferenceTable
+	EndBranch uint8
+}
+
+type EcOcPONLinkTrafficControlReferenceTable struct {
+	EcOcLength   uint8
+	EcOcBranch   uint8
+	EcOcType     uint16
+	EcOcLength2  uint8
+	EcOcInstance []byte
+}
+
+func (d *GetTrafficControlRefTableRes) String() string {
+	message := d.ComResp.String()
+	for k, ec := range d.ECOC {
+		message = message + "EC[" + string(k) + "],EcOcLength:" + string(ec.EcOcLength) + ",EcOcBranch:" + string(ec.EcOcBranch) + ",EcOcType:" + string(ec.EcOcType) + ",EcOcLength2" + string(ec.EcOcLength2) + ",EcOcInstance:" + hex.EncodeToString(ec.EcOcInstance)
+	}
+	message = fmt.Sprintf("%s", message)
+	return message
+
+}
+
+func (d *GetTrafficControlRefTableRes) Decode(data []byte) error {
+	d.ComResp.Decode(data)
+	i := d.ComResp.Len()
+	for _, ec := range d.ECOC {
+		ec.EcOcLength = data[i]
+		i++
+		ec.EcOcBranch = data[i]
+		i++
+		binary.BigEndian.PutUint16(data[i:i+2], ec.EcOcType)
+		i = i + 2
+		ec.EcOcLength2 = data[i]
+		i++
+		copy(data[i:i+int(ec.EcOcLength2)], ec.EcOcInstance)
+		i = i + int(ec.EcOcLength2)
+	}
+
+	d.EndBranch = data[i]
+	i++
+
+	return nil
+
+}
diff --git a/internal/pkg/core/l2oam/msg_priority.go b/internal/pkg/core/l2oam/msg_priority.go
new file mode 100644
index 0000000..cbfff24
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_priority.go
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+// GeneratePriority generates "Traffic Profile/Priority" message
+func GeneratePriority(trafficProfile []byte) gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x070f,
+		OCLength:   4,
+		OCInstance: binary.BigEndian.Uint32(trafficProfile),
+		// Vc
+		VcBranch: 0x7f,
+		VcLeaf:   0x000a,
+		VcLength: 2,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x04},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_action_delete.go b/internal/pkg/core/l2oam/msg_set_action_delete.go
new file mode 100644
index 0000000..b05f661
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_action_delete.go
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateSetActionDelete generates "Generic/Action Delete" message
+func GenerateSetActionDelete(trafficProfile []byte, actionType int) gopacket.SerializableLayer {
+	ocInstance := binary.BigEndian.Uint32(trafficProfile)
+	objectType := getObjectType(actionType)
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   objectType[0],
+		OCType:     binary.BigEndian.Uint16(objectType[1:3]),
+		OCLength:   4,
+		OCInstance: ocInstance,
+		// Vc
+		VcBranch: 0x6e,
+		VcLeaf:   0x7002,
+		VcLength: 0x80,
+		// EC
+		ECLength: 0,
+		ECValue:  []byte{},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
+
+// GenerateSetActionDeleteStream generates "Generic/Action Delete(for stream)" message
+func GenerateSetActionDeleteStream(oc *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x6e,
+		VcLeaf:   0x7002,
+		VcLength: 0x80,
+		// EC
+		ECLength: 0,
+		ECValue:  []byte{},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_action_delete_onu.go b/internal/pkg/core/l2oam/msg_set_action_delete_onu.go
new file mode 100644
index 0000000..fe8a728
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_action_delete_onu.go
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetActionDeleteOnu generates "Generic/Action Delete" message
+func GenerateSetActionDeleteOnu(oc *TomiObjectContext) gopacket.SerializableLayer {
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x6e,
+		VcLeaf:   0x7002,
+		VcLength: 0x80,
+		// EC
+		ECLength: 0,
+		ECValue:  []byte{},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_action_reset.go b/internal/pkg/core/l2oam/msg_set_action_reset.go
new file mode 100644
index 0000000..0dc4a28
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_action_reset.go
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+)
+
+// GenerateSetActionReset generates "Device/Action Reset" message
+func GenerateSetActionReset() gopacket.SerializableLayer {
+
+	data := &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x2a, 0xea, 0x15, 0x03,
+			0x0c, 0x0c, 0x7a, 0x04, 0x00, 0x00, 0x00, 0x00,
+			0x0c, 0x0d, 0xce, 0x04, 0x00, 0x00, 0x00, 0x00,
+			0xde, 0x70, 0x01, 0x80, 0x00, 0x00},
+	}
+
+	binary.BigEndian.PutUint32(data.Data[12:16], getOltInstance())
+
+	return data
+
+}
diff --git a/internal/pkg/core/l2oam/msg_set_admin_state.go b/internal/pkg/core/l2oam/msg_set_admin_state.go
new file mode 100644
index 0000000..aae58ab
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_admin_state.go
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetAdminState generates "PON Port/Admin State" message
+func GenerateSetAdminState() gopacket.SerializableLayer {
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0x07,
+		VcLeaf:   0x0001,
+		VcLength: 2,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x01},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+
+}
+
+// GenerateSetAdminStateDelete generates "PON Port/Admin State(for delete)" message
+func GenerateSetAdminStateDelete() gopacket.SerializableLayer {
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0x07,
+		VcLeaf:   0x0001,
+		VcLength: 2,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x02},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+
+}
diff --git a/internal/pkg/core/l2oam/msg_set_capture_protocols.go b/internal/pkg/core/l2oam/msg_set_capture_protocols.go
new file mode 100644
index 0000000..49c335a
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_capture_protocols.go
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateCaptureProtocols generates "Protocol Filter/Capture Protocols" message
+func GenerateCaptureProtocols(ocInstance uint32) gopacket.SerializableLayer {
+
+	return &SetGenerteCaptureProtocolsreq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0cff,
+		OCLength:   4,
+		OCInstance: ocInstance,
+		// Vc
+		VcBranch: 0xcf,
+		VcLeaf:   0x0003,
+		VcLength: 5,
+		// EC
+		ECLength: 4,
+		//Protocol
+		ProtocolLength: 1,
+		ProtocolValue:  0x01,
+		//Action
+		ActionLength: 1,
+		ActionValue:  0x01,
+		// End
+		EndBranch: 0x00,
+	}
+
+}
+
+// SetGenerteCaptureProtocolsreq is a structure for a request of "Protocol Filter/Capture Protocols" message
+type SetGenerteCaptureProtocolsreq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	ECLength uint8
+	ProtocolLength uint8
+	ProtocolValue  uint8
+	ActionLength uint8
+	ActionValue  uint8
+	EndBranch uint8
+}
+
+// Len returns the length of SetGenerteCaptureProtocolsreq
+func (d *SetGenerteCaptureProtocolsreq) Len() int {
+	return 21 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength)
+}
+
+// LayerType returns the ethernet type of SetGenerteCaptureProtocolsreq
+func (d *SetGenerteCaptureProtocolsreq) LayerType() gopacket.LayerType {
+	return layers.LayerTypeEthernet
+}
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *SetGenerteCaptureProtocolsreq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	data[i] = byte(d.ECLength)
+	i++
+	data[i] = byte(d.ProtocolLength)
+	i++
+	data[i] = byte(d.ProtocolValue)
+	i++
+	data[i] = byte(d.ActionLength)
+	i++
+	data[i] = byte(d.ActionValue)
+	i++
+	data[i] = byte(d.EndBranch)
+
+	return nil
+
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *SetGenerteCaptureProtocolsreq) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+	d.ECLength = data[i]
+	i++
+	d.ProtocolLength = data[i]
+	i++
+	d.ProtocolValue = data[i]
+	i++
+	d.ActionLength = data[i]
+	i++
+	d.ActionValue = data[i]
+	i++
+	d.EndBranch = data[i]
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/msg_set_default_outlet.go b/internal/pkg/core/l2oam/msg_set_default_outlet.go
new file mode 100644
index 0000000..a794903
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_default_outlet.go
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateSetDefaultOutlet generates "Default Outlet" message
+func GenerateSetDefaultOutlet(oc *TomiObjectContext, onuID *TomiObjectContext) gopacket.SerializableLayer {
+
+	tibitData := &DefaultOutletRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   oc.Branch,
+		OCType:     oc.Type,
+		OCLength:   oc.Length,
+		OCInstance: oc.Instance,
+		// Vc
+		VcBranch: 0x5d,
+		VcLeaf:   0x0003,
+		VcLength: 0x09,
+		// Default Outlet
+		DOLength:    8,
+		DOBranch:    0x0c,
+		DOType:      0x0011,
+		DOValLength: 4,
+		DOInstance:  onuID.Instance,
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
+
+// DefaultOutletRequest is a structure for a request of "Default Outlet" message
+type DefaultOutletRequest struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	DOLength    uint8
+	DOBranch    uint8
+	DOType      uint16
+	DOValLength uint8
+	DOInstance  uint32
+	EndBranch uint8
+}
+
+// String returns the string expression of DefaultOutletRequest
+func (d *DefaultOutletRequest) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, DOLength:%x, DOBranch:%x, DOType:%x, DOValLength:%x, DOInstance:%x", message, d.DOLength, d.DOBranch, d.DOType, d.DOValLength, d.DOInstance)
+
+	return message
+}
+
+// Len returns the length of DefaultOutletRequest
+func (d *DefaultOutletRequest) Len() int {
+	return 38
+}
+
+// LayerType returns the ethernet type of DefaultOutletRequest
+func (d *DefaultOutletRequest) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *DefaultOutletRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	data[i] = byte(d.DOLength)
+	i++
+	data[i] = byte(d.DOBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.DOType)
+	i += 2
+	data[i] = byte(d.DOValLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.DOInstance)
+	i += 4
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/msg_set_hbtx_period.go b/internal/pkg/core/l2oam/msg_set_hbtx_period.go
new file mode 100644
index 0000000..f2b784a
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_hbtx_period.go
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetHbtxPeriod generates "OAM/HBTx Period"
+func GenerateSetHbtxPeriod() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0x0a,
+		VcLeaf:   0x0002,
+		VcLength: 3,
+		// EC
+		ECLength: 2,
+		ECValue:  []byte{0x03, 0xe8},
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_hbtx_template.go b/internal/pkg/core/l2oam/msg_set_hbtx_template.go
new file mode 100644
index 0000000..f319e52
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_hbtx_template.go
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+//GenerateSetHbtxTemplate generates "OAM/HBTx Template" message
+func GenerateSetHbtxTemplate() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0x0a,
+		VcLeaf:   0x0003,
+		VcLength: 35,
+		// EC
+		ECLength: 34,
+		ECValue: []byte{
+			0x01, 0x80, 0xc2, 0x00, 0x00, 0x02, 0xe8, 0xb4,
+			0x70, 0x70, 0x04, 0x07, 0x88, 0x09, 0x03, 0x00,
+			0x50, 0x00, 0x01, 0x10, 0x01, 0x00, 0x00, 0x00,
+			0x1b, 0x04, 0xb0, 0x2a, 0xea, 0x15, 0x00, 0x00,
+			0x00, 0x23},
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_ingress_port.go b/internal/pkg/core/l2oam/msg_set_ingress_port.go
new file mode 100644
index 0000000..d55efdc
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_ingress_port.go
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateIngressPort generates "Protocol Filter/Ingress Port" message
+func GenerateIngressPort(OCInstance uint32, isponport bool) gopacket.SerializableLayer {
+
+	var ponPort uint16 = 0x0007
+
+	if !isponport {
+		ponPort = 0x0e07
+	}
+
+	return &SetGenerteIngressPortreq{
+		//IEEE 1904.2
+		Opcode:     0x03,
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		//TiBiT OLT Management Interface
+		TOMIOpcode: 0x03,
+		//Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		//Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0cff,
+		OCLength:   4,
+		OCInstance: OCInstance,
+		//Vc
+		VcBranch: 0xcf,
+		VcLeaf:   0x0002,
+		VcLength: 9,
+		//EC OC
+		ECOCLength1:  8,
+		ECOCBranch:   0x0c,
+		ECOCType:     ponPort,
+		ECOCLength2:  4,
+		ECOCInstance: 0x00000000,
+		//End
+		EndBranch: 0x00,
+	}
+
+}
+
+// SetGenerteIngressPortreq is a structure for a reqest of "Protocol Filter/Ingress Port" message
+type SetGenerteIngressPortreq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	ECOCLength1  uint8
+	ECOCBranch   uint8
+	ECOCType     uint16
+	ECOCLength2  uint8
+	ECOCInstance uint32
+	EndBranch uint8
+}
+
+// Len returns the length of SetGenerteIngressPortreq
+func (d *SetGenerteIngressPortreq) Len() int {
+	return 21 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength)
+}
+
+// LayerType returns the ethernet type of SetGenerteIngressPortreq
+func (d *SetGenerteIngressPortreq) LayerType() gopacket.LayerType {
+	return layers.LayerTypeEthernet
+}
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *SetGenerteIngressPortreq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	data[i] = byte(d.ECOCLength1)
+	i++
+	data[i] = byte(d.ECOCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.ECOCType)
+	i += 2
+	data[i] = byte(d.ECOCLength2)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.ECOCInstance)
+	i += 4
+	data[i] = byte(d.EndBranch)
+
+	return nil
+
+}
+
+// Decode decodes byte arrays to a data structure
+func (d *SetGenerteIngressPortreq) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+	i++
+	d.ECOCLength1 = data[i]
+	i++
+	d.ECOCBranch = data[i]
+	i++
+	d.ECOCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.ECOCLength2 = data[i]
+	i++
+	d.ECOCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.EndBranch = data[i]
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/msg_set_management_lock.go b/internal/pkg/core/l2oam/msg_set_management_lock.go
new file mode 100644
index 0000000..c1490cf
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_management_lock.go
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetManagementLock generates "Device/ManagementLock" message
+func GenerateSetManagementLock() gopacket.SerializableLayer {
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0dce,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0xde,
+		VcLeaf:   0x002e,
+		VcLength: 0x04,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x00},
+		ECList: []ECValueSet{
+			{
+				Length: 0x01,
+				Value:  []byte{0x02},
+			},
+		},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_mpcp_sync.go b/internal/pkg/core/l2oam/msg_set_mpcp_sync.go
new file mode 100644
index 0000000..bfa1d4d
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_mpcp_sync.go
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetMPCPSync generates "MPCP/Sync Type" message
+func GenerateSetMPCPSync() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x43,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0xcc,
+		VcLeaf:   0x0004,
+		VcLength: 2,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x20},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_request_saved.go b/internal/pkg/core/l2oam/msg_set_request_saved.go
new file mode 100644
index 0000000..6869a79
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_request_saved.go
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+//
+func GenerateSetRequestSaved() gopacket.SerializableLayer {
+
+	tibitData := &TOAMSetRequest{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x43,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x0007,
+		OCLength:   4,
+		OCInstance: 0x00000000,
+		// Vc
+		VcBranch: 0xcc,
+		VcLeaf:   0x0004,
+		VcLength: 2,
+		// EC
+		ECLength: 1,
+		ECValue:  []byte{0x20},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_set_traffic_profile.go b/internal/pkg/core/l2oam/msg_set_traffic_profile.go
new file mode 100644
index 0000000..af11a66
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_set_traffic_profile.go
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetTrafficProfile generates "Traffic Control/Traffic Profile" message
+func GenerateSetTrafficProfile(trafficControl []byte, trafficProfile []byte) gopacket.SerializableLayer {
+	tibitData := &setTrafficControlTrafficProfileReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OAM Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15},
+		// TiBit OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x07c0,
+		OCLength:   4,
+		OCInstance: trafficControl,
+		// Vc
+		VcBranch: 0x7c,
+		VcLeaf:   0x0002,
+		VcLength: 9,
+		// EC OC
+		ECOC: []ECOCTrafficControlTrafficProfile{
+			{
+				EcOcLength:   8,
+				EcOcBranch:   0x0c,
+				EcOcType:     0x070f,
+				EcOcLength2:  4,
+				EcOcInstance: trafficProfile,
+			},
+		},
+		// End
+		EndBranch: 0x00,
+	}
+	return tibitData
+}
diff --git a/internal/pkg/core/l2oam/msg_toam_get.go b/internal/pkg/core/l2oam/msg_toam_get.go
new file mode 100644
index 0000000..f831aa0
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_toam_get.go
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// TOAMGetRequest is a structure for GET request of TOAM message
+type TOAMGetRequest struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VdBranch uint8
+	VdLeaf   uint16
+	EndBranch uint8
+}
+
+// String returns the string expression of TOAMGetRequest
+func (d *TOAMGetRequest) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%02x, CTType:%04x, CTLength:%02x, CTInstance:%08x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VdBranch:%02x, VdLeaf:%04x, EndBranch:%02x", message, d.VdBranch, d.VdLeaf, d.EndBranch)
+	return message
+}
+
+// Len returns the length of TOAMGetRequest
+func (d *TOAMGetRequest) Len() int {
+	return 29
+}
+
+// LayerType returns the ethernet type of TOAMGetRequest
+func (d *TOAMGetRequest) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *TOAMGetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VdBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VdLeaf)
+	i += 2
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+// TOAMGetResponse is a structure for GET response of TOAM message
+type TOAMGetResponse struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+}
+
+// String returns the string expression of TOAMGetResponse
+func (d *TOAMGetResponse) String() string {
+	message := fmt.Sprintf("Opcode:%02x, Flags:%04x, OAMPDUCode:%02x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%02x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%02x, CTType:%04x, CTLength:%02x, CTInstance:%08x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%02x, OCType:%04x, OCLength:%02x, OCInstance:%08x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%02x, VcLeaf:%04x, VcLength:%02x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	return message
+}
+
+// Len returns the length of TOAMGetResponse
+func (d *TOAMGetResponse) Len() int {
+	return 28
+}
+
+// LayerType returns the ethernet type of TOAMGetResponse
+func (d *TOAMGetResponse) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// Decode decodes byte arrays to a data structure
+func (d *TOAMGetResponse) Decode(data []byte) {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcLength = data[i]
+}
diff --git a/internal/pkg/core/l2oam/msg_toam_set.go b/internal/pkg/core/l2oam/msg_toam_set.go
new file mode 100644
index 0000000..7aa6bec
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_toam_set.go
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// TOAMSetRequest is a structure for SET request of TOAM message
+type TOAMSetRequest struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+	ECLength uint8
+	ECValue  []byte
+	ECList []ECValueSet
+	EndBranch uint8
+}
+
+// ECValueSet is a structure for Vc-EC object
+type ECValueSet struct {
+	Length uint8
+	Value  []byte
+}
+
+// String returns the string expression of TOAMSetRequest
+func (d *TOAMSetRequest) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	message = fmt.Sprintf("%s, ECLength:%x, ECValue:%v, EndBranch:%x", message, d.ECLength, hex.EncodeToString(d.ECValue), d.EndBranch)
+	return message
+}
+
+// Len returns the length of TOAMSetRequest
+func (d *TOAMSetRequest) Len() int {
+	if d.VcLength != 0x80 {
+		return 22 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength)
+	}
+	return 22 + int(d.CTLength) + int(d.OCLength)
+
+}
+
+// LayerType returns the ethernet type of TOAMSetRequest
+func (d *TOAMSetRequest) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *TOAMSetRequest) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	if d.VcLength != 0x80 {
+		// EC
+		data[i] = byte(d.ECLength)
+		i++
+		copy(data[i:i+int(d.ECLength)], d.ECValue)
+		i += int(d.ECLength)
+	}
+	if d.ECList != nil {
+		for _, ecSet := range d.ECList {
+			data[i] = byte(ecSet.Length)
+			i++
+			copy(data[i:i+int(ecSet.Length)], ecSet.Value)
+			i += int(ecSet.Length)
+		}
+	}
+
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+// TOAMSetResponse is a structure for SET response of TOAM message
+type TOAMSetResponse struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance uint32
+	VcBranch      uint8
+	VcLeaf        uint16
+	VcTOMIResCode uint8
+	EndBranch uint8
+}
+
+// String returns the string expression of TOAMSetResponse
+func (d *TOAMSetResponse) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcTOMIResCode:%x, EndBranch:%x", message, d.VcBranch, d.VcLeaf, d.VcTOMIResCode, d.EndBranch)
+	return message
+}
+
+// Len returns the length of TOAMSetResponse
+func (d *TOAMSetResponse) Len() int {
+	return 34 + int(d.CTLength) + int(d.OCLength)
+}
+
+// LayerType returns the ethernet type of TOAMSetResponse
+func (d *TOAMSetResponse) LayerType() gopacket.LayerType { return layers.LayerTypeEthernet }
+
+// Decode decodes byte arrays to a data structure
+func (d *TOAMSetResponse) Decode(data []byte) error {
+	i := 0
+	d.Opcode = data[i]
+	i++
+	d.Flags = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OAMPDUCode = data[i]
+	i++
+	d.OUId = data[i : i+3]
+	i += len(d.OUId)
+	d.TOMIOpcode = data[i]
+	i++
+	d.CTBranch = data[i]
+	i++
+	d.CTType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.CTLength = data[i]
+	i++
+	d.CTInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.OCBranch = data[i]
+	i++
+	d.OCType = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.OCLength = data[i]
+	i++
+	d.OCInstance = binary.BigEndian.Uint32(data[i : i+4])
+	i += 4
+	d.VcBranch = data[i]
+	i++
+	d.VcLeaf = binary.BigEndian.Uint16(data[i : i+2])
+	i += 2
+	d.VcTOMIResCode = data[i]
+	i++
+	d.EndBranch = data[i]
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/msg_traffic_control_traffic_profile.go b/internal/pkg/core/l2oam/msg_traffic_control_traffic_profile.go
new file mode 100644
index 0000000..84a325a
--- /dev/null
+++ b/internal/pkg/core/l2oam/msg_traffic_control_traffic_profile.go
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+)
+
+// GenerateTrafficControlTrafficProfile generates "Traffic Control/Traffic Profile" message
+func GenerateTrafficControlTrafficProfile(trafficControl []byte, trafficProfile []byte) gopacket.SerializableLayer {
+
+	tibitData := &setTrafficControlTrafficProfileReq{
+		// IEEE 1904.2
+		Opcode: 0x03,
+		// OMI Protocol
+		Flags:      0x0050,
+		OAMPDUCode: 0xfe,
+		OUId:       []byte{0x2a, 0xea, 0x15}, // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+		// TiBiT OLT Management Interface
+		TOMIOpcode: 0x03,
+		// Correlation Tag
+		CTBranch:   0x0c,
+		CTType:     0x0c7a,
+		CTLength:   4,
+		CTInstance: getOltInstance(),
+		// Object Context
+		OCBranch:   0x0c,
+		OCType:     0x07c0,
+		OCLength:   4,
+		OCInstance: trafficControl,
+		// Vc
+		VcBranch: 0x7c,
+		VcLeaf:   0x0002,
+		VcLength: 0x09,
+
+		//EC OC
+		ECOC: []ECOCTrafficControlTrafficProfile{{EcOcLength: 8, EcOcBranch: 0x0c, EcOcType: 0x070f, EcOcLength2: 4, EcOcInstance: trafficProfile}},
+
+		// End
+		EndBranch: 0x00,
+	}
+
+	return tibitData
+}
+
+type setTrafficControlTrafficProfileReq struct {
+	layers.BaseLayer
+	Opcode uint8
+	Flags      uint16
+	OAMPDUCode uint8
+	OUId       []byte // Organizationally Unique Identifier: 2a:ea:15 (Tibit Communications)
+	TOMIOpcode uint8
+	CTBranch   uint8
+	CTType     uint16
+	CTLength   uint8
+	CTInstance uint32
+	OCBranch   uint8
+	OCType     uint16
+	OCLength   uint8
+	OCInstance []byte
+	VcBranch uint8
+	VcLeaf   uint16
+	VcLength uint8
+
+	ECOC []ECOCTrafficControlTrafficProfile
+
+	EndBranch uint8
+}
+
+// ECOCTrafficControlTrafficProfile is a structure for Vc-EC OC object
+type ECOCTrafficControlTrafficProfile struct {
+	EcOcLength   uint8
+	EcOcBranch   uint8
+	EcOcType     uint16
+	EcOcLength2  uint8
+	EcOcInstance []byte
+}
+
+// String returns the string expression of setTrafficControlTrafficProfileReq
+func (d *setTrafficControlTrafficProfileReq) String() string {
+	message := fmt.Sprintf("Opcode:%x, Flags:%x, OAMPDUCode:%x, OUId:%v", d.Opcode, d.Flags, d.OAMPDUCode, hex.EncodeToString(d.OUId))
+	message = fmt.Sprintf("%s, TOMIOpcode:%x", message, d.TOMIOpcode)
+	message = fmt.Sprintf("%s, CTBranch:%x, CTType:%x, CTLength:%x, CTInstance:%x", message, d.CTBranch, d.CTType, d.CTLength, d.CTInstance)
+	message = fmt.Sprintf("%s, OCBranch:%x, OCType:%x, OCLength:%x, OCInstance:%x", message, d.OCBranch, d.OCType, d.OCLength, d.OCInstance)
+	message = fmt.Sprintf("%s, VcBranch:%x, VcLeaf:%x, VcLength:%x", message, d.VcBranch, d.VcLeaf, d.VcLength)
+	for _, ecoc := range d.ECOC {
+		message = fmt.Sprintf("%s, EcOcLength:%x, EcOcBranch:%v, EcOcType:%x, EcOcLength2:%x, EcOcInstance:%x, ", message, ecoc.EcOcLength, ecoc.EcOcBranch, ecoc.EcOcType, ecoc.EcOcLength2, hex.EncodeToString(ecoc.EcOcInstance))
+	}
+	message = fmt.Sprintf("%s, EndBranch:%x", message, d.EndBranch)
+	return message
+}
+
+// Len returns the length of setTrafficControlTrafficProfileReq
+func (d *setTrafficControlTrafficProfileReq) Len() int {
+	return 21 + int(d.CTLength) + int(d.OCLength) + int(d.VcLength)
+}
+
+// LayerType returns the ethernet type of setTrafficControlTrafficProfileReq
+func (d *setTrafficControlTrafficProfileReq) LayerType() gopacket.LayerType {
+	return layers.LayerTypeEthernet
+}
+
+// SerializeTo serializes a data structure to byte arrays
+func (d *setTrafficControlTrafficProfileReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+	plen := int(d.Len())
+	data, err := b.PrependBytes(plen)
+	if err != nil {
+		return err
+	}
+
+	i := 0
+	data[i] = byte(d.Opcode)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.Flags)
+	i += 2
+	data[i] = byte(d.OAMPDUCode)
+	i++
+	copy(data[i:i+len(d.OUId)], d.OUId)
+	i += len(d.OUId)
+	data[i] = byte(d.TOMIOpcode)
+	i++
+	data[i] = byte(d.CTBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.CTType)
+	i += 2
+	data[i] = byte(d.CTLength)
+	i++
+	binary.BigEndian.PutUint32(data[i:i+4], d.CTInstance)
+	i += 4
+	data[i] = byte(d.OCBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.OCType)
+	i += 2
+	data[i] = byte(d.OCLength)
+	i++
+	copy(data[i:i+4], d.OCInstance)
+	i += 4
+	data[i] = byte(d.VcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], d.VcLeaf)
+	i += 2
+	data[i] = byte(d.VcLength)
+	i++
+	for _, ecoc := range d.ECOC {
+		nextIndex := SerializeECOC(&ecoc, data, i)
+		i = nextIndex
+	}
+
+	data[i] = byte(d.EndBranch)
+
+	return nil
+}
+
+// SerializeECOC serializes a "EC OC" structure to byte arrays
+func SerializeECOC(ecoc *ECOCTrafficControlTrafficProfile, data []byte, startIndex int) int {
+	i := startIndex
+	data[i] = byte(ecoc.EcOcLength)
+	i++
+	data[i] = byte(ecoc.EcOcBranch)
+	i++
+	binary.BigEndian.PutUint16(data[i:i+2], ecoc.EcOcType)
+	i += 2
+	data[i] = byte(ecoc.EcOcLength2)
+	i++
+	copy(data[i:i+int(ecoc.EcOcLength2)], ecoc.EcOcInstance)
+	i += int(ecoc.EcOcLength2)
+
+	return i
+}
diff --git a/internal/pkg/core/l2oam/onu_list_access.go b/internal/pkg/core/l2oam/onu_list_access.go
new file mode 100644
index 0000000..0ca4714
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_list_access.go
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+)
+
+// JSON file name
+const jsonname = "/onu_list.json"
+
+// OnuStatus has ONU status
+type OnuStatus struct {
+	ID           string `json:"id"`
+	AdminState   string `json:"admin_state"`
+	OpeState     string `json:"ope_state"`
+	ConnectState string `json:"con_state"`
+	MacAddress   string `json:"mac_addr"`
+	RebootState  string `json:"reboot_state"`
+}
+
+// ReadOnuStatusList reads JSON file
+func ReadOnuStatusList() ([]OnuStatus, error) {
+	bytes, err := ioutil.ReadFile(os.Getenv("HOME") + jsonname)
+	if err != nil && os.IsNotExist(err) {
+		return nil, nil
+	}
+	var onuList []OnuStatus
+	if err := json.Unmarshal(bytes, &onuList); err != nil {
+		return nil, err
+	}
+	return onuList, nil
+}
+
+// WriteOnuStatusList writes JSON file
+func WriteOnuStatusList(list []OnuStatus) error {
+	bytes, err := json.Marshal(list)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(os.Getenv("HOME")+jsonname, bytes, 0644)
+}
+
+// AddOnu adds ONU to ONU status list
+func AddOnu(sts *OnuStatus) error {
+	list, err := ReadOnuStatusList()
+	if err != nil {
+		return err
+	}
+	if list == nil {
+		newList := []OnuStatus{*sts}
+		return WriteOnuStatusList(newList)
+	}
+	return WriteOnuStatusList(append(list, *sts))
+}
+
+// UpdateOnu updates ONU status
+func UpdateOnu(upSts *OnuStatus) error {
+	list, err := ReadOnuStatusList()
+	if (err != nil) || (list == nil) {
+		return err
+	}
+	newList := []OnuStatus{}
+	for _, sts := range list {
+		if sts.ID == upSts.ID {
+			newList = append(newList, *upSts)
+		} else {
+			newList = append(newList, sts)
+		}
+	}
+	return WriteOnuStatusList(newList)
+}
+
+// RemoveOnu removes ONU from ONU status list
+func RemoveOnu(id string) error {
+	list, err := ReadOnuStatusList()
+	if (err != nil) || (list == nil) {
+		return err
+	}
+	newList := []OnuStatus{}
+	for _, sts := range list {
+		if sts.ID != id {
+			newList = append(newList, sts)
+		}
+	}
+	return WriteOnuStatusList(newList)
+}
+
+// GetOnuFromDeviceID returns ONU status from ONU status list using its device ID
+func GetOnuFromDeviceID(id string) (*OnuStatus, error) {
+	list, err := ReadOnuStatusList()
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		return nil, nil
+	}
+	for _, sts := range list {
+		if sts.ID != id {
+			return &sts, nil
+		}
+	}
+	return nil, nil
+}
+
+// GetOnuFromMacAddr returns ONU status from ONU status list using its MAC address
+func GetOnuFromMacAddr(addr string) (*OnuStatus, error) {
+	list, err := ReadOnuStatusList()
+	if err != nil {
+		return nil, err
+	}
+	if list == nil {
+		return nil, nil
+	}
+	for _, sts := range list {
+		if sts.MacAddress == addr {
+			return &sts, nil
+		}
+	}
+	return nil, nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_get_onu_system_info.go b/internal/pkg/core/l2oam/onu_msg_get_onu_system_info.go
new file mode 100644
index 0000000..6dd13d8
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_get_onu_system_info.go
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateOnuSystemInfo generates "ONU System Information" message
+func GenerateOnuSystemInfo(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x01,
+				0xd7, 0x00, 0x06, 0x00, 0x00,
+			},
+		}
+
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x40, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
+
+// GetOnuSerialNo returns a serial number
+func GetOnuSerialNo(pkgType string, data []byte) string {
+	if pkgType == OnuPkgTypeA {
+		// 030050fe00100002 00 - 07
+		// d70006404d493920 08 - 15
+		// 32304b2042303041 16 - 23
+		// 3730204130302031 24 - 31
+		// 3730382020202020
+		// 2000000030313233
+		// 3435363730313233
+		// 3435363738394041
+		// 42434445
+		return string(data[20:26])
+	}
+	return ""
+}
+
+// GetOnuManufacture returns a manufacture information
+func GetOnuManufacture(pkgType string, data []byte) string {
+	if pkgType == OnuPkgTypeA {
+		if data[16] == 0x32 && data[17] == 0x30 && data[18] == 0x4b {
+			return "FURUKAWA"
+		}
+	}
+	return ""
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_get_unip_info.go b/internal/pkg/core/l2oam/onu_msg_get_unip_info.go
new file mode 100644
index 0000000..f3efa24
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_get_unip_info.go
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateGetUnipInfo generates UnipInfo message
+func GenerateGetUnipInfo(pkgType string) gopacket.SerializableLayer {
+	if pkgType == OnuPkgTypeB {
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x00,
+				0x00, 0x00, 0x00, 0xb7, 0x00, 0x41,
+			},
+		}
+	}
+	return &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x01,
+			0xd6, 0x00, 0x03, 0x01, 0x00, 0x07, 0x00, 0x20,
+			0x07, 0x00, 0x5d, 0x07, 0x00, 0x5a, 0x07, 0x00,
+			0x4f, 0x07, 0x00, 0xa3, 0x07, 0x00, 0x1a, 0x07,
+			0x00, 0x47, 0x07, 0x00, 0xb0, 0x00, 0x00,
+		},
+	}
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_dyn_learning_mode.go b/internal/pkg/core/l2oam/onu_msg_set_dyn_learning_mode.go
new file mode 100644
index 0000000..33c7a00
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_dyn_learning_mode.go
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateDynLearningMode generates "Dyn Learning Mode" message
+func GenerateDynLearningMode(PkgType string, index int) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		if index == 1 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x01,
+					0xd6, 0x00, 0x03, 0x01, 0x00, 0xd7, 0x01, 0x01,
+					0x00, 0x00,
+				},
+			}
+			return data
+		} else if index == 2 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+					0xd6, 0x00, 0x03, 0x01, 0x00, 0xd7, 0x01, 0x02,
+					0x07, 0xd0, 0x00, 0x00,
+				},
+			}
+			return data
+		} else if index == 3 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x01,
+					0xd6, 0x00, 0x03, 0x01, 0x00, 0xd7, 0x01, 0x03,
+					0x00, 0x00,
+				},
+			}
+			return data
+		}
+
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x01,
+				0x00, 0x00, 0x01, 0xb7, 0x00, 0x1c, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_encryption_mode.go b/internal/pkg/core/l2oam/onu_msg_set_encryption_mode.go
new file mode 100644
index 0000000..599e8d4
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_encryption_mode.go
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateEncryptionMode generates "Encryption Mode" message
+func GenerateEncryptionMode(PkgType string, index int) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		if index == 1 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+					0xd6, 0x00, 0x02, 0x01, 0x00, 0xd7, 0x04, 0x01,
+					0x02, 0x01, 0x2c, 0x00, 0x00,
+				},
+			}
+			return data
+		} else if index == 2 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+					0xd6, 0x00, 0x02, 0x01, 0x00, 0xd7, 0x04, 0x02,
+					0x01, 0x02, 0x00, 0x00,
+				},
+			}
+			return data
+		}
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		if index == 1 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+					0xca, 0xfe, 0x00, 0xb7, 0x00, 0x01, 0x01, 0x02,
+				},
+			}
+			return data
+		}
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_fec_mode.go b/internal/pkg/core/l2oam/onu_msg_set_fec_mode.go
new file mode 100644
index 0000000..22712ad
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_fec_mode.go
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateFecMode generates "FEC Mode" message
+func GenerateFecMode(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+				0xD6, 0x00, 0x02, 0x01, 0x00, 0xD7, 0x06, 0x05,
+				0x02, 0x01, 0x01,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x16, 0x01, 0x01,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_onu_config.go b/internal/pkg/core/l2oam/onu_msg_set_onu_config.go
new file mode 100644
index 0000000..e648138
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_onu_config.go
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateOnuConfig generates "ONU Config" message
+func GenerateOnuConfig(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+
+		return nil
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x45, 0x00, 0x00,
+			},
+		}
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_threshold.go b/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_threshold.go
new file mode 100644
index 0000000..2649171
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_threshold.go
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateOnuErroredFrameThreshold generates "Errored Frame Threshold" message
+func GenerateOnuErroredFrameThreshold(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+
+		return nil
+
+	} else if PkgType == OnuPkgTypeB {
+
+		return &TibitFrame{Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+			0xca, 0xfe, 0x00, 0xb7, 0x00, 0x0d, 0x04, 0x00,
+			0x00, 0xff, 0xff,
+		}}
+
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_window.go b/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_window.go
new file mode 100644
index 0000000..fa02acd
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_onu_errored_frame_window.go
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateOnuErroredFrameWindow generates "Errored Frame Window" message
+func GenerateOnuErroredFrameWindow(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+
+		return nil
+
+	} else if PkgType == OnuPkgTypeB {
+
+		return &TibitFrame{Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+			0xca, 0xfe, 0x00, 0xb7, 0x00, 0x0c, 0x02, 0x00,
+			0x0a,
+		}}
+
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_onu_priority_queue_count.go b/internal/pkg/core/l2oam/onu_msg_set_onu_priority_queue_count.go
new file mode 100644
index 0000000..e868f9c
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_onu_priority_queue_count.go
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateOnuPriorityQueueCount generates "Priority Queue Count" message
+func GenerateOnuPriorityQueueCount(PkgType string, index int) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		if index == 1 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x01,
+					0xd7, 0x00, 0x0a, 0x00, 0x00,
+				},
+			}
+			return data
+		} else if index == 2 {
+			data := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+					0xd6, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+					0xd7, 0x01, 0x0d, 0x08, 0x01, 0x01, 0xd0, 0x02,
+					0x01, 0xd0, 0x01, 0x32, 0x00, 0x00,
+				},
+			}
+			return data
+		}
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x01, 0x01, 0x02,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_rx_input_power.go b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_rx_input_power.go
new file mode 100644
index 0000000..8c498f2
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_rx_input_power.go
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GeneratePonpOptRxInputPower generates "Ponp Optical Rx Input Power" message
+func GeneratePonpOptRxInputPower(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x01,
+				0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x02, 0x21,
+				0x00, 0x00,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x01,
+				0x00, 0x00, 0x01, 0xb7, 0x00, 0x34, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_trx_supply_voltage.go b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_trx_supply_voltage.go
new file mode 100644
index 0000000..0fd9d15
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_trx_supply_voltage.go
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GeneratePonpOptTRxSupplyVoltage generates "Ponp Optical TRx Supply Voltage" message
+func GeneratePonpOptTRxSupplyVoltage(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x01,
+				0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x02, 0x1E,
+				0x00, 0x00,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x31, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_bias_current.go b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_bias_current.go
new file mode 100644
index 0000000..e0edf9b
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_bias_current.go
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GeneratePonpOptTxBiasCurrent generates "Ponp Optical Tx Bias Current" message
+func GeneratePonpOptTxBiasCurrent(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x01,
+				0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x02, 0x1F,
+				0x00, 0x00,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x01,
+				0x00, 0x00, 0x01, 0xb7, 0x00, 0x32, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_output_power.go b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_output_power.go
new file mode 100644
index 0000000..7112c7d
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_ponp_opt_tx_output_power.go
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GeneratePonpOptTxOutputPower generates "Ponp Optical Tx Output Power" message
+func GeneratePonpOptTxOutputPower(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x01,
+				0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x02, 0x20,
+				0x00, 0x00,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x01,
+				0x00, 0x00, 0x01, 0xb7, 0x00, 0x33, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_ponp_temperature.go b/internal/pkg/core/l2oam/onu_msg_set_ponp_temperature.go
new file mode 100644
index 0000000..2f9064c
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_ponp_temperature.go
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GeneratePonpTemperature generates "Ponp Temerature" message
+func GeneratePonpTemperature(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA 最後尾に０追加
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x01,
+				0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x02, 0x1D,
+				0x00, 0x00,
+			},
+		}
+		return data
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x00,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x01,
+				0x00, 0x00, 0x01, 0xb7, 0x00, 0x30, 0x00, 0x00,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_qos_policer_burst.go b/internal/pkg/core/l2oam/onu_msg_set_qos_policer_burst.go
new file mode 100644
index 0000000..ce83c6e
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_qos_policer_burst.go
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetQosPolicerBurst generates QosPolicerBurst message
+func GenerateSetQosPolicerBurst(pkgType string) gopacket.SerializableLayer {
+	if pkgType == OnuPkgTypeB {
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x10, 0x08, 0x40,
+				0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+			},
+		}
+	}
+	return &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+			0xD6, 0x00, 0x01, 0x01, 0x00, 0xD7, 0x06, 0x01,
+			0x00, 0x00, 0x4E, 0x20, 0x00, 0x00,
+		},
+	}
+
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_qos_policer_rate.go b/internal/pkg/core/l2oam/onu_msg_set_qos_policer_rate.go
new file mode 100644
index 0000000..d343366
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_qos_policer_rate.go
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetQosPolicerRate generates QosPolicerRate message
+func GenerateSetQosPolicerRate(pkgType string, idx int) gopacket.SerializableLayer {
+	if pkgType == OnuPkgTypeB {
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x0F, 0x20, 0x00,
+				0x01, 0x86, 0xa0, 0x00, 0x01, 0x86, 0xa0, 0x00,
+				0x01, 0x86, 0xa0, 0x00, 0x01, 0x86, 0xa0, 0x00,
+				0x01, 0x86, 0xa0, 0x00, 0x01, 0x86, 0xa0, 0x00,
+				0x01, 0x86, 0xa0, 0x00, 0x01, 0x86, 0xa0,
+			},
+		}
+	}
+	switch idx {
+	case 1:
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+				0xd6, 0x00, 0x03, 0x01, 0x00, 0xd7, 0x06, 0x02,
+				0x0a, 0xff, 0x00, 0x01, 0x00, 0x00, 0x04,
+			},
+		}
+	case 2:
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+				0xD6, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xD7,
+				0x00, 0x24,
+			},
+		}
+	case 3:
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+				0xD6, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0xD7,
+				0x00, 0x25,
+			},
+		}
+	case 4:
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+				0xD6, 0x00, 0x03, 0x00, 0xD7, 0x06, 0x02, 0x0A,
+				0xFF, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00,
+			},
+		}
+	case 5:
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+				0xD6, 0x00, 0x03, 0x00, 0xD7, 0x06, 0x03, 0x07,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+		}
+	default:
+		return &TibitFrame{
+			Data: []byte{},
+		}
+	}
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_reset_onu.go b/internal/pkg/core/l2oam/onu_msg_set_reset_onu.go
new file mode 100644
index 0000000..f204ba7
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_reset_onu.go
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetResetOnu generates reset ONU message
+func GenerateSetResetOnu(pkgType string) gopacket.SerializableLayer {
+	if pkgType == OnuPkgTypeB {
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb9, 0x00, 0x0e, 0x01, 0x01,
+				0x00, 0x00,
+			},
+		}
+	}
+	return &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+			0xd6, 0x00, 0x00, 0xd9, 0x00, 0x01, 0x80, 0x00,
+			0x00,
+		},
+	}
+
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_traffic_enable.go b/internal/pkg/core/l2oam/onu_msg_set_traffic_enable.go
new file mode 100644
index 0000000..bdfdeed
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_traffic_enable.go
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetTrafficEnable generates "Traffic Enable" message
+func GenerateSetTrafficEnable(pkgType string) gopacket.SerializableLayer {
+	return &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+			0xd6, 0x00, 0x02, 0x01, 0x00, 0xd9, 0x06, 0x01,
+			0x80,
+		},
+	}
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_unip_link_mode.go b/internal/pkg/core/l2oam/onu_msg_set_unip_link_mode.go
new file mode 100644
index 0000000..7054436
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_unip_link_mode.go
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetUnipLinkMode generates UnipLinkMode message
+func GenerateSetUnipLinkMode(pkgType string) gopacket.SerializableLayer {
+	if pkgType == OnuPkgTypeB {
+		return &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb6, 0x00, 0x01, 0x04, 0x00,
+				0x00, 0x00, 0x00, 0xb7, 0x00, 0x11, 0x01, 0x24,
+			},
+		}
+	}
+	return &TibitFrame{
+		Data: []byte{
+			0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+			0xD6, 0x00, 0x03, 0x01, 0x00, 0xD7, 0x01, 0x05,
+			0x04, 0x00, 0xDF,
+		},
+	}
+
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_unip_target_queue_priority.go b/internal/pkg/core/l2oam/onu_msg_set_unip_target_queue_priority.go
new file mode 100644
index 0000000..0947405
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_unip_target_queue_priority.go
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateUnipTargetQueuePriority generates "UnipTargetQueuePriority" message
+func GenerateUnipTargetQueuePriority(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+		//TypeA
+
+		return nil
+	} else if PkgType == OnuPkgTypeB {
+		//TypeB
+
+		data := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x43, 0x08, 0x00,
+				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+			},
+		}
+
+		return data
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_unip_toscos_conversion.go b/internal/pkg/core/l2oam/onu_msg_set_unip_toscos_conversion.go
new file mode 100644
index 0000000..a1f3abe
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_unip_toscos_conversion.go
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateUnipTOSCOSConversion generates "Unip TOSCOS Conversion" message
+func GenerateUnipTOSCOSConversion(PkgType string) gopacket.SerializableLayer {
+
+	if PkgType == OnuPkgTypeA {
+
+		return nil
+
+	} else if PkgType == OnuPkgTypeB {
+
+		return &TibitFrame{Data: []byte{
+			0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+			0xca, 0xfe, 0x00, 0xb7, 0x00, 0x35, 0x08, 0x00,
+			0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+		}}
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_vlan_pon_vid_value.go b/internal/pkg/core/l2oam/onu_msg_set_vlan_pon_vid_value.go
new file mode 100644
index 0000000..416dd69
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_vlan_pon_vid_value.go
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetVlanPonVIDValue generates VlanPonVIDValue message
+func GenerateSetVlanPonVIDValue(pkgType string, idx int, iTpidValue []byte, iVidValue []byte) gopacket.SerializableLayer {
+
+	if pkgType == OnuPkgTypeB {
+		tibitData := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+				0xca, 0xfe, 0x00, 0xb7, 0x00, 0x15, 0x02,
+			},
+		}
+
+		tibitData.Data = append(tibitData.Data, iVidValue...)
+
+		return tibitData
+	}
+	switch idx {
+	case 1: // Downstream Rule
+		tibitData := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+				0xd6, 0x00, 0x03, 0x01, 0x00, 0xd7, 0x05, 0x01,
+				0x02, 0x01, 0x0a, 0xd7, 0x05, 0x01, 0x07, 0x02,
+				0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0xd7, 0x05,
+				0x01, 0x02, 0x03, 0x02, 0xd7, 0x05, 0x01, 0x0b,
+				0x03, 0x04, 0x08, 0x00, 0x00, 0x00, 0x04,
+			},
+		}
+
+		// itpid must be 4 bytes length
+		tibitData.Data = append(tibitData.Data, iTpidValue...)
+		// ivid must be 2 bytes length
+		tibitData.Data = append(tibitData.Data, iVidValue...)
+
+		bytes := []byte{
+			0xd7, 0x05, 0x01, 0x04, 0x03, 0x07, 0x08, 0x00,
+			0xd7, 0x05, 0x01, 0x01, 0x00, 0xd9, 0x05, 0x02,
+			0x80, 0x00,
+		}
+
+		tibitData.Data = append(tibitData.Data, bytes...)
+
+		return tibitData
+
+	case 2: // Upstream Rule
+		tibitData := &TibitFrame{
+			Data: []byte{
+				0x03, 0x00, 0x50, 0xfe, 0x00, 0x10, 0x00, 0x03,
+				0xd6, 0x00, 0x01, 0x01, 0x00, 0xd7, 0x05, 0x01,
+				0x02, 0x01, 0x0a, 0xd7, 0x05, 0x01, 0x07, 0x02,
+				0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0xd7, 0x05,
+				0x01, 0x02, 0x03, 0x02, 0xd7, 0x05, 0x01, 0x0b,
+				0x03, 0x04, 0x08, 0x00, 0x00, 0x00, 0x04,
+			},
+		}
+
+		// itpid must be 4 bytes length
+		tibitData.Data = append(tibitData.Data, iTpidValue...)
+		// ivid must be 2 bytes length
+		tibitData.Data = append(tibitData.Data, iVidValue...)
+
+		bytes := []byte{
+			0xd7, 0x05, 0x01, 0x04, 0x03, 0x07, 0x08, 0x00,
+			0xd7, 0x05, 0x01, 0x01, 0x00, 0xd9, 0x05, 0x02,
+			0x80, 0x00,
+		}
+
+		tibitData.Data = append(tibitData.Data, bytes...)
+
+		return tibitData
+
+	default:
+		return &TibitFrame{
+			Data: []byte{},
+		}
+	}
+}
diff --git a/internal/pkg/core/l2oam/onu_msg_set_vlan_tag_filter.go b/internal/pkg/core/l2oam/onu_msg_set_vlan_tag_filter.go
new file mode 100644
index 0000000..980f444
--- /dev/null
+++ b/internal/pkg/core/l2oam/onu_msg_set_vlan_tag_filter.go
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package l2oam
+
+import (
+	"github.com/google/gopacket"
+)
+
+// GenerateSetVlanTagFilter generates VlanTagFilter message
+func GenerateSetVlanTagFilter(pkgType string, idx int, value []byte) gopacket.SerializableLayer {
+
+	if pkgType == OnuPkgTypeB {
+		switch idx {
+		case 1:
+			tibitData := &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+					0xca, 0xfe, 0x00, 0xb7, 0x00, 0x13, 0x03, 0x03,
+				}, //,0x81,0x00
+			}
+
+			tibitData.Data = append(tibitData.Data, value...)
+
+			return tibitData
+		case 2:
+			return &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xfe, 0x90, 0x82, 0x60, 0x03,
+					0xca, 0xfe, 0x00, 0xb7, 0x00, 0x14, 0x03, 0x01,
+					0x00, 0x64,
+				},
+			}
+		default:
+			return &TibitFrame{
+				Data: []byte{},
+			}
+		}
+	} else {
+		switch idx {
+		case 1:
+			return &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+					0xD6, 0x00, 0x00, 0xD7, 0x05, 0x03, 0x03, 0x81,
+					0x00, 0x01,
+				},
+			}
+		case 2:
+			return &TibitFrame{
+				Data: []byte{
+					0x03, 0x00, 0x50, 0xFE, 0x00, 0x10, 0x00, 0x03,
+					0xD6, 0x00, 0x00, 0xD7, 0x05, 0x04, 0x03, 0x88,
+					0xa8, 0x00,
+				},
+			}
+		default:
+			return &TibitFrame{
+				Data: []byte{},
+			}
+		}
+	}
+}
diff --git a/internal/pkg/core/l2oam_device.go b/internal/pkg/core/l2oam_device.go
new file mode 100644
index 0000000..76b548f
--- /dev/null
+++ b/internal/pkg/core/l2oam_device.go
@@ -0,0 +1,3936 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/core/l2oam"
+	"github.com/opencord/voltha-protos/v3/go/common"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+// DeviceNameOlt is a constant for OLT
+const DeviceNameOlt = "L2oamOltDevice"
+
+// DeviceNameOnu is a constant for ONU
+const DeviceNameOnu = "L2oamOnuDevice"
+
+// KeepAliveInterval is an interval time for keep-alive
+const KeepAliveInterval = 800
+
+// KeepAliveCounter is max count of not receiving keep-alive response
+const KeepAliveCounter = 10
+
+// ResponseTimer is wait time for receiving response message(seconds)
+const ResponseTimer = 20
+
+//KeepAliveStatusE is state of keep-alive message
+type KeepAliveStatusE int
+
+const (
+	KeepAliveDisable KeepAliveStatusE = iota
+	KeepAliveStep1
+	KeepAliveStep2
+	KeepAliveStep3
+)
+
+// map for L2oamDevice, its key is MAC address without colon
+var deviceMap map[string]L2oamDevice
+
+// map for L2oamDevice, its key is device-ID
+var deviceMacMap map[string]string
+
+var mapMutex sync.Mutex
+
+var l2oamDeviceHandler *DeviceHandler
+
+func init() {
+	deviceMap = map[string]L2oamDevice{}
+	deviceMacMap = map[string]string{}
+	monitoringOnuStatus()
+}
+
+// FindL2oamDevice returns a L2oamDevice using MAC address
+func FindL2oamDevice(macAddress string) L2oamDevice {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+	mac := strings.Replace(macAddress, ":", "", -1)
+	onu, ok := deviceMap[mac]
+	if !ok {
+		return nil
+	}
+	return onu
+
+}
+
+// FindL2oamDeviceByDeviceID returns a L2oamDevice using device-ID
+func FindL2oamDeviceByDeviceID(deviceID string) L2oamDevice {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+	mac, ok := deviceMacMap[deviceID]
+	if !ok {
+		return nil
+	}
+	onu, ok := deviceMap[mac]
+	if !ok {
+		return nil
+	}
+	return onu
+}
+
+// SetupL2oamDeleteFlag sets delete flag
+func SetupL2oamDeleteFlag(deviceID string) bool {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	mac, ok := deviceMacMap[deviceID]
+	if !ok {
+		return false
+	}
+	device, ok := deviceMap[mac]
+	if !ok {
+		return false
+	}
+	if device.getDeleteFlag() {
+		return false
+	}
+	device.setDeleteFlag()
+	deviceMap[mac] = device
+
+	return true
+}
+
+// NewL2oamOltDevice creates a new OLT device
+func NewL2oamOltDevice(macAddress string, dh *DeviceHandler) (L2oamDevice, error) {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	l2oamDeviceHandler = dh
+
+	mac := strings.Replace(macAddress, ":", "", -1)
+	_, ok := deviceMap[mac]
+	if !ok {
+		device := &L2oamOltDevice{
+			Base: DeviceBase{
+				ResCh:          nil,
+				KeepAliveResCh: make(chan *layers.Ethernet, 100),
+				DstMac:         mac,
+				DH:             dh,
+				DeviceID:       dh.device.Id,
+				StopCh:         make(chan string, 1),
+				ActiveState:    false,
+				Name:           DeviceNameOlt,
+			},
+			L2SwitchDomainMap: map[uint32]*l2SwitchDomain{},
+		}
+		deviceMap[mac] = device
+		deviceMacMap[dh.device.Id] = mac
+		return device, nil
+	}
+	return nil, fmt.Errorf("NewL2oamOltDevice() Already registered. mac=%s", mac)
+}
+
+// NewL2oamOnuDevice creates a new ONU device
+func NewL2oamOnuDevice(macAddress string, dh *DeviceHandler) (L2oamDevice, error) {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	mac := strings.Replace(macAddress, ":", "", -1)
+	_, ok := deviceMap[mac]
+	if !ok {
+		device := &L2oamOnuDevice{
+			Base: DeviceBase{
+				ResCh:          nil,
+				KeepAliveResCh: make(chan *layers.Ethernet, 100),
+				DstMac:         mac,
+				DH:             dh,
+				StopCh:         make(chan string, 1),
+				ActiveState:    true,
+				Name:           DeviceNameOnu,
+			},
+			keepAliveResponse: make(chan string, 1),
+			MacAddress:        mac,
+		}
+		deviceMap[mac] = device
+		return device, nil
+	}
+	return nil, fmt.Errorf("NewL2oamOnuDevice() Already registered. mac=%s", mac)
+}
+
+// DeleteAllDevice deletes all devices
+func DeleteAllDevice() {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	for _, value := range deviceMap {
+		value.delete(context.Background())
+	}
+	deviceMap = map[string]L2oamDevice{}
+	deviceMacMap = map[string]string{}
+}
+
+// DeleteDevice deletes device
+func DeleteDevice(deviceId string, deviceMac string) {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	_, ok := deviceMacMap[deviceId]
+	if ok {
+		delete(deviceMacMap, deviceId)
+		logger.Info(context.Background(), fmt.Sprintf("DeleteDevice() deviceMacMap. deviceid=%s, ", deviceId))
+	}
+	mac := strings.Replace(deviceMac, ":", "", -1)
+	_, ok = deviceMap[mac]
+	if ok {
+		delete(deviceMap, mac)
+		logger.Info(context.Background(), fmt.Sprintf("DeleteDevice() deviceMap. mac=%s, ", mac))
+	}
+}
+
+// L2oamDevice interface provides some methods for device
+// OLT and ONU implement each functions
+type L2oamDevice interface {
+	getDeviceName() string
+	send(message gopacket.SerializableLayer) error
+	waitResponse(timeoutSecond int) (*layers.Ethernet, error)
+	sendAndWait(message gopacket.SerializableLayer, timeoutSecond int) (*layers.Ethernet, error)
+	recieve(etherPacket *layers.Ethernet)
+	recieveKeepAlive(etherPacket *layers.Ethernet)
+	startKeepAlive()
+	stopKeepAlive()
+	setActiveState(ctx context.Context, isActive bool)
+	startMountSequence(ctx context.Context, pkgType string, cmd *L2oamCmd)
+	reboot(ctx context.Context)
+	setL2oamCmd(*L2oamCmd)
+	getL2oamCmd() *L2oamCmd
+	setObjectContext(*l2oam.TomiObjectContext)
+	getObjectContext() *l2oam.TomiObjectContext
+	setReferenceTable(*l2oam.GetTrafficControlReferenceTableRes)
+	getReferenceTable() *l2oam.GetTrafficControlReferenceTableRes
+	setProfile(*l2oam.SetGenericActionCreateRes, *l2oam.SetGenericActionCreateRes)
+	getProfile() (*l2oam.SetGenericActionCreateRes, *l2oam.SetGenericActionCreateRes)
+	delete(ctx context.Context)
+	setDeleteFlag()
+	getDeleteFlag() bool
+	setAutonomousFlag(bool)
+	getAutonomousFlag() bool
+	updateMap()
+	receiveEapol(etherPacket *layers.Ethernet)
+	addFlow(ctx context.Context, cmd *L2oamCmd) error
+	updateFlow(ctx context.Context, cmd *L2oamCmd) error
+	removeFlow(ctx context.Context) error
+}
+
+type l2SwitchDomain struct {
+	OcAction *l2oam.TomiObjectContext
+	Tpid     []byte
+	Vid      []byte
+	Onus     map[string]bool
+}
+
+// DeviceBase ====================================
+// DeviceBase contains common functions
+// ===============================================
+type DeviceBase struct {
+	ResCh                chan *layers.Ethernet
+	KeepAliveResCh       chan *layers.Ethernet
+	DstMac               string
+	DH                   *DeviceHandler
+	DeviceID             string
+	mu                   sync.Mutex
+	muResponse           sync.Mutex
+	muResCh              sync.Mutex
+	StopCh               chan string
+	ActiveState          bool
+	KeepAliveStatus      KeepAliveStatusE
+	KeepAliveRemoteValue []byte
+	KeepAliveSendCounter int
+	Name                 string
+	DeleteFlag           bool
+	AutonomousFlag       bool
+	FlowAdded            bool
+	ActionIds            map[int]uint32
+	EapFlag              bool
+}
+
+const (
+	ActionIDFilterPonPort = 1
+	ActionIDFilterEthPort = 2
+)
+
+func (d *DeviceBase) getDeviceName() string {
+	return d.Name
+}
+
+func (d *DeviceBase) send(message gopacket.SerializableLayer) error {
+	var bytes []byte
+	if vlanEnable {
+		vlanLayer := &layers.Dot1Q{
+			VLANIdentifier: vlanIdManagement,
+			Type:           0xa8c8,
+		}
+		bytes = l2oam.CreateMessageVlan(
+			SrcMac,
+			convertMacString(d.DstMac),
+			0x88a8,
+			message,
+			vlanLayer,
+		)
+	} else {
+		bytes = l2oam.CreateMessage(
+			SrcMac,
+			convertMacString(d.DstMac),
+			0xa8c8,
+			message,
+		)
+
+	}
+	GetL2oamHandle().send(bytes)
+	return nil
+}
+
+func (d *DeviceBase) waitResponse(timeoutSecond int) (*layers.Ethernet, error) {
+	d.muResponse.Lock()
+	defer d.muResponse.Unlock()
+
+	d.ResCh = make(chan *layers.Ethernet, 1)
+	defer func() {
+		d.muResCh.Lock()
+		close(d.ResCh)
+		d.ResCh = nil
+		d.muResCh.Unlock()
+	}()
+	ctx := context.Background()
+	var res *layers.Ethernet
+	var err error
+	select {
+	case res = <-d.ResCh:
+		// DeviceBase do nothing
+		logger.Debug(ctx, fmt.Sprintf("[%s] DeviceBase.waitResponse() received", d.getDeviceName()))
+	case <-time.After(time.Duration(timeoutSecond) * time.Second):
+		err = fmt.Errorf("DeviceBase.waitResponse().ResCh receive timeout")
+	}
+	return res, err
+}
+
+func (d *DeviceBase) sendAndWait(message gopacket.SerializableLayer, timeoutSecond int) (*layers.Ethernet, error) {
+	if err := d.send(message); err != nil {
+		return nil, err
+	}
+
+	return d.waitResponse(timeoutSecond)
+}
+
+func (d *DeviceBase) recieve(etherPacket *layers.Ethernet) {
+	d.muResCh.Lock()
+	defer d.muResCh.Unlock()
+
+	if d.ResCh != nil {
+		if len(d.ResCh) == cap(d.ResCh) {
+			logger.Error(context.Background(), fmt.Sprintf("[%s] recieve() ResCh channel is full. MacAddress=%s", d.getDeviceName(), d.DstMac))
+		} else {
+			d.ResCh <- etherPacket
+		}
+	}
+}
+
+func (d *DeviceBase) recieveKeepAlive(etherPacket *layers.Ethernet) {
+	d.KeepAliveResCh <- etherPacket
+}
+
+func (d *DeviceBase) startKeepAlive() {
+	go func() {
+		ctx := context.Background()
+		d.KeepAliveStatus = KeepAliveStep1
+		d.countClearKeepAliveCounter()
+		logger.Debug(ctx, fmt.Sprintf("[%s] startKeepAlive(). MacAddress=%s, %v", d.getDeviceName(), d.DstMac, d))
+
+		for {
+			select {
+			case <-d.StopCh:
+				logger.Debug(ctx, fmt.Sprintf("[%s] startKeepAlive() StopCh request. MacAddress=%s", d.getDeviceName(), d.DstMac))
+				return
+			case etherPacket := <-d.KeepAliveResCh:
+				packet := &l2oam.OAMPDUInformation{}
+				if err := packet.Decode(etherPacket.Payload); err != nil {
+					break
+				}
+				logger.Debug(ctx, fmt.Sprintf("[%s] receive KeepAlive() mac=%s", d.getDeviceName(), d.DstMac))
+
+				// discards received packet if the device is not active
+				if d.isEnable() {
+					// keep received LIValue for sending next messages
+					d.KeepAliveRemoteValue = packet.LIValue
+					if packet.Flags == 0x0028 {
+						d.KeepAliveStatus = KeepAliveStep2
+					} else {
+						d.KeepAliveStatus = KeepAliveStep3
+					}
+					d.setActiveState(ctx, true)
+					d.countClearKeepAliveCounter()
+				}
+
+			case <-time.After(KeepAliveInterval * time.Millisecond):
+
+				if !d.isActive() {
+					d.countClearKeepAliveCounter()
+				} else {
+					logger.Debug(ctx, fmt.Sprintf("[%s] KeepAlive timer expired. MacAddress=%s", d.getDeviceName(), d.DstMac))
+					// First three messages are sent each messages.
+					// After that, third message will be sent repeatedly
+					var err error = nil
+					if d.KeepAliveStatus == KeepAliveStep1 {
+						err = d.send(l2oam.GeneateKeepAlive1(l2oam.OnuPkgType == l2oam.OnuPkgTypeA))
+					} else if d.KeepAliveStatus == KeepAliveStep2 {
+						err = d.send(l2oam.GeneateKeepAlive2(d.KeepAliveRemoteValue, l2oam.OnuPkgType == l2oam.OnuPkgTypeA))
+					} else if d.KeepAliveStatus == KeepAliveStep3 {
+						err = d.send(l2oam.GeneateKeepAlive3(d.KeepAliveRemoteValue))
+					}
+					if err != nil {
+						break
+					}
+					d.countUpKeepAliveCounter()
+
+					if d.isKeepAliveLimitOver() {
+						d.setActiveState(ctx, false)
+					}
+				}
+
+				if d.EapFlag {
+					logger.Debug(ctx, fmt.Sprintf("[%s] EapFlag == true. MacAddress=%s", d.getDeviceName(), d.DstMac))
+					/*
+						onu := FindL2oamDevice(d.DstMac)
+						if onu == nil {
+							logger.Debug(ctx, "onu not found.")
+						} else {
+							go d.DH.L2oamAddFlowAndMount(ctx, d.DeviceID, []byte{0x64}, []byte{0x00, 0x64})
+						}
+					*/
+					d.EapFlag = false
+				}
+			}
+		}
+	}()
+}
+
+func (d *DeviceBase) stopKeepAlive() {
+	if len(d.StopCh) == cap(d.StopCh) {
+		logger.Error(context.Background(), fmt.Sprintf("[%s] stopKeepAlive stop channel is full. MacAddress=%s", d.getDeviceName(), d.DstMac))
+	} else {
+		d.StopCh <- "Stop"
+	}
+}
+
+func (d *DeviceBase) countUpKeepAliveCounter() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.KeepAliveSendCounter++
+}
+
+func (d *DeviceBase) countClearKeepAliveCounter() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.KeepAliveSendCounter = 0
+}
+
+func (d *DeviceBase) isKeepAliveLimitOver() bool {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	return KeepAliveCounter <= d.KeepAliveSendCounter
+}
+
+func (d *DeviceBase) isActive() bool {
+	if !d.isEnable() {
+		return false
+	}
+	return d.ActiveState
+}
+
+func (d *DeviceBase) isEnable() bool {
+	if d.DeviceID == "" {
+		return true
+	}
+	device, err := d.DH.coreProxy.GetDevice(context.Background(), d.DeviceID, d.DeviceID)
+	if err != nil || device == nil {
+		logger.Debug(context.Background(), fmt.Sprintf("[%s] isEnable() coreProxy.GetDevice() deviceid=%s, error. %v", d.getDeviceName(), d.DeviceID, err))
+		return false
+	}
+	return device.AdminState == common.AdminState_ENABLED
+}
+
+func (d *DeviceBase) setActiveState(ctx context.Context, isActive bool) {
+	d.ActiveState = isActive
+
+	switch d.getDeviceName() {
+	case DeviceNameOlt:
+		if !isActive {
+			d.ActiveState = true
+		}
+		updateOltActiveStatus(ctx, d.DH, isActive)
+
+	case DeviceNameOnu:
+		// updateOnuActiveStatus(ctx, d.DstMac, isActive, d.DH)
+		updateOnuActiveStatus2(ctx, d.DH, isActive, d.DeviceID)
+	}
+}
+
+/*
+func (d *DeviceBase) startMountSequence(ctx context.Context, pkgType string, cmd *L2oamCmd) {
+}
+
+func (d *DeviceBase) reboot(ctx context.Context) {
+}
+*/
+
+func (d *DeviceBase) delete(ctx context.Context) {
+	logger.Info(ctx, fmt.Sprintf("[%s] delete() deviceid=%s, mac=%s", d.getDeviceName(), d.DeviceID, d.DstMac))
+	d.stopKeepAlive()
+}
+
+func (d *DeviceBase) setDeleteFlag() {
+	d.DeleteFlag = true
+}
+
+func (d *DeviceBase) getDeleteFlag() bool {
+	return d.DeleteFlag
+}
+
+func (d *DeviceBase) setAutonomousFlag(flag bool) {
+	d.AutonomousFlag = flag
+}
+
+func (d *DeviceBase) getAutonomousFlag() bool {
+	return d.AutonomousFlag
+}
+
+func (d *DeviceBase) receiveEapol(etherPacket *layers.Ethernet) {
+	go func() {
+		packetBytes := append(etherPacket.Contents, etherPacket.Payload...)
+		pktInd := &oop.PacketIndication{
+			IntfId:    0,
+			GemportId: 1,
+			PortNo:    16,
+			Pkt:       packetBytes,
+			IntfType:  "pon",
+		}
+		logger.Info(context.Background(), fmt.Sprintf("[%s] receiveEapol() deviceid=%s, pktInd=%x", d.getDeviceName(), d.DeviceID, pktInd))
+
+		if err := d.DH.handlePacketIndication(context.Background(), pktInd); err != nil {
+			logger.Error(context.Background(), fmt.Sprintf("[%s] receiveEapol() error. deviceid=%s, ", d.getDeviceName(), d.DeviceID))
+		}
+	}()
+}
+
+// L2oamOltDevice =================================
+// L2oamOltDevice provides functions for OLT device
+// ================================================
+type L2oamOltDevice struct {
+	Base                DeviceBase
+	autonomousExecMutex sync.Mutex
+	L2oamCmd            *L2oamCmd
+	ObjectContext       *l2oam.TomiObjectContext
+	ReferenceTable      *l2oam.GetTrafficControlReferenceTableRes
+	DownProfile         *l2oam.SetGenericActionCreateRes
+	UpProfile           *l2oam.SetGenericActionCreateRes
+	L2SwitchDomainMap   map[uint32]*l2SwitchDomain
+}
+
+func (d *L2oamOltDevice) getDeviceName() string {
+	return d.Base.getDeviceName()
+}
+func (d *L2oamOltDevice) send(message gopacket.SerializableLayer) error {
+	return d.Base.send(message)
+}
+func (d *L2oamOltDevice) waitResponse(timeoutSecond int) (*layers.Ethernet, error) {
+	return d.Base.waitResponse(timeoutSecond)
+}
+func (d *L2oamOltDevice) sendAndWait(message gopacket.SerializableLayer, timeoutSecond int) (*layers.Ethernet, error) {
+	return d.Base.sendAndWait(message, timeoutSecond)
+}
+
+func (d *L2oamOltDevice) recieve(etherPacket *layers.Ethernet) {
+	bytes := etherPacket.Payload
+	opcode := bytes[0]
+	oampduCode := bytes[3]
+	tomiOpCode := bytes[7]
+	logger.Debug(context.Background(), fmt.Sprintf("[%s] recieve. opcode=%v oampduCode=%v,  %x", d.getDeviceName(), opcode, oampduCode, bytes))
+
+	if opcode == 0x03 && oampduCode == 0xfe {
+		// Autonomous message
+		if tomiOpCode == 0xae {
+			go d.receiveAutonomounsEvent(etherPacket)
+		} else {
+			d.Base.recieve(etherPacket)
+		}
+	} else if opcode == 0xfd {
+		// other messages
+		d.Base.recieve(etherPacket)
+	} else {
+		logger.Error(context.Background(), fmt.Sprintf("[%s] receive error. invalid message %v", d.getDeviceName(), etherPacket))
+	}
+
+}
+func (d *L2oamOltDevice) recieveKeepAlive(etherPacket *layers.Ethernet) {
+	d.Base.recieveKeepAlive(etherPacket)
+}
+func (d *L2oamOltDevice) startKeepAlive() {
+	d.Base.startKeepAlive()
+}
+func (d *L2oamOltDevice) stopKeepAlive() {
+	d.Base.stopKeepAlive()
+}
+func (d *L2oamOltDevice) receiveAutonomounsEvent(etherPacket *layers.Ethernet) {
+	d.autonomousExecMutex.Lock()
+	defer d.autonomousExecMutex.Unlock()
+
+	packet := &l2oam.AutonomousEvent{}
+	if err := packet.Decode(etherPacket.Payload); err != nil {
+		return
+	}
+
+	if packet.IsRegistrationStatusMessage() {
+		if d.getAutonomousFlag() {
+			d.addOnu(packet)
+		} else {
+			logger.Debug(context.Background(), fmt.Sprintf("[%s] receiveAutonomounsEvent() skip. AutonomousFlag is false. ", d.getDeviceName()))
+		}
+	}
+}
+func (d *L2oamOltDevice) addOnu(packet *l2oam.AutonomousEvent) {
+	ctx := context.Background()
+	logger.Debug(ctx, fmt.Sprintf("[%s] addOnu() Start. ", d.getDeviceName()))
+	operIndication := &oop.Indication_IntfOperInd{
+		IntfOperInd: &oop.IntfOperIndication{
+			Type:      "nni",
+			IntfId:    0,
+			OperState: "up",
+		},
+	}
+	indication := &oop.Indication{
+		Data: operIndication,
+	}
+	d.Base.DH.handleIndication(ctx, indication)
+	operIndication.IntfOperInd.Type = "pon"
+	d.Base.DH.handleIndication(ctx, indication)
+
+	oc := &l2oam.TomiObjectContext{
+		Branch:   packet.ComResp.OCBranch,
+		Type:     packet.ComResp.OCType,
+		Length:   packet.ComResp.OCLength,
+		Instance: packet.ComResp.OCInstance,
+	}
+
+	ether, err := d.sendAndWait(l2oam.GenerateGetMpcpMacAddress(oc), ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("[%s] addOnu() GetMpcpMacAddress Send Error: %v", d.getDeviceName(), err))
+		return
+	}
+	macPacket := &l2oam.GetMpcpMacAddressRes{}
+	if err = macPacket.Decode(ether.Payload); err != nil {
+		return
+	}
+	macAddress := macPacket.GetMacAddress()
+	logger.Debug(ctx, fmt.Sprintf("[%s] addOnu() GetMpcpMacAddress Success: macAddress=%s, response=%x:%s", d.getDeviceName(), macAddress, ether.Payload, macPacket))
+
+	var onu *L2oamOnuDevice
+	device := FindL2oamDevice(macAddress)
+	if device != nil {
+		logger.Debug(ctx, fmt.Sprintf("addOnu() FindL2oamDevice() is find. macAddress=%s", macAddress))
+		onu = device.(*L2oamOnuDevice)
+		if onu != nil {
+			logger.Debug(ctx, fmt.Sprintf("addOnu() assertion success. macAddress=%s, deviceId=%s", macAddress, onu.Base.DeviceID))
+			onu.setActiveState(ctx, true)
+		}
+		return
+	}
+
+	logger.Debug(ctx, fmt.Sprintf("addOnu() NewL2oamOnuDevice() called. macAddress=%s", macAddress))
+	device, _ = NewL2oamOnuDevice(macAddress, d.Base.DH)
+	onu = device.(*L2oamOnuDevice)
+
+	ether, err = d.sendAndWait(l2oam.GenerateGetMpcpLLId(oc), ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("[%s] addOnu() GetMpcpLLId Send Error: %v", d.getDeviceName(), err))
+		return
+	}
+
+	llidPacket := &l2oam.GetMpcpLLIdRes{}
+	if err = llidPacket.Decode(ether.Payload); err != nil {
+		return
+	}
+	llid := llidPacket.GetLLID()
+	logger.Debug(ctx, fmt.Sprintf("[%s] addOnu() GetMpcpLLId Success: LLID=%d, response=%x:%s", d.getDeviceName(), llid, ether.Payload, llidPacket))
+
+	vendorID := ""
+	VendorSpecific := ""
+	serialNumber := ""
+	onu.setActiveState(ctx, false)
+
+	if err := onu.send(l2oam.GeneateKeepAlive1(l2oam.OnuPkgType == l2oam.OnuPkgTypeA)); err != nil {
+		logger.Debug(ctx, fmt.Sprintf("error: %v", err))
+	}
+	go func() {
+
+		err = onu.waitKeepALiveResponse()
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] addOnu() onu keep alive error. %s", d.getDeviceName(), err))
+			DeleteDevice(onu.Base.DeviceID, onu.Base.DstMac)
+			return
+		}
+		onu.keepAliveResponse = nil
+		logger.Info(ctx, fmt.Sprintf("[%s] addOnu() onu keep alive success.", d.getDeviceName()))
+		onu.startKeepAlive()
+		vendorID = "FEC"
+		VendorSpecific = "EponONU"
+		//serialNumber = macAddress[6:12]
+		serialNumber = strings.Replace(macAddress, ":", "", -1)[6:12]
+
+		onuDiscInd := &oop.OnuDiscIndication{
+			IntfId: 0,
+			SerialNumber: &oop.SerialNumber{
+				VendorId:       []byte(vendorID),
+				VendorSpecific: []byte(VendorSpecific),
+			},
+		}
+		if err = d.Base.DH.onuDiscIndication2(ctx, onuDiscInd, serialNumber, macAddress); err != nil {
+			return
+		}
+
+		onu.setObjectContext(oc)
+		onu.updateMap()
+		// onu := FindL2oamDevice(macAddress)
+		// if onu == nil {
+		// 	logger.Debug(ctx, fmt.Sprintf("[%s] addOnu() NewL2oamOnuDevice() called. macAddress=%s", d.getDeviceName(), macAddress))
+		// 	onu, _ = NewL2oamOnuDevice(macAddress, d.Base.DH, deviceId)
+		// 	onu.startKeepAlive()
+		// }
+		// onu.setActiveState(ctx, true)
+		device = FindL2oamDevice(macAddress)
+		onuInd := &oop.OnuIndication{
+			IntfId:       0,
+			OnuId:        device.(*L2oamOnuDevice).OnuID,
+			OperState:    "up",
+			AdminState:   "up",
+			SerialNumber: onuDiscInd.SerialNumber,
+		}
+		if err := d.Base.DH.onuIndication(ctx, onuInd); err != nil {
+			return
+		}
+	}()
+}
+
+func (dh *DeviceHandler) fakeOmciIndication(ctx context.Context, intfID uint32, onuID uint32, pkt []byte) error {
+	omciInd := &oop.OmciIndication{
+		IntfId: intfID,
+		OnuId:  onuID,
+		Pkt:    make([]byte, 48),
+	}
+
+	onuKey := dh.formOnuKey(intfID, onuID)
+	onuDev, ok := dh.onus.Load(onuKey)
+	if !ok {
+		logger.Errorf(ctx, "not-found-onu-device. intf-id:%d, onu-id:%d", intfID, onuID)
+		return nil
+	}
+	onuDeviceID := (onuDev.(*OnuDevice)).deviceID
+	onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+	if onu == nil {
+		logger.Errorf(ctx, "not-found-l2oam-onu-device. onu-device-id:%s", onuDeviceID)
+		return nil
+	}
+
+
+	if len(pkt) < 11 {
+		return nil
+	}
+	messageType := uint8(pkt[2])
+	meID := binary.BigEndian.Uint16(pkt[4:6])
+	meSubID := binary.BigEndian.Uint16(pkt[6:8])
+	omciInd.Pkt[0] = pkt[0]
+	omciInd.Pkt[1] = pkt[1]
+	omciInd.Pkt[2] = (pkt[2] & 0xbf) | 0x20 // AR -> AK
+	copy(omciInd.Pkt[3:8], pkt[3:8])
+	contentIdx := 8
+
+	switch messageType {
+	case 0x49: // Get
+		if meID == 0x0101 { // ONU2-G
+			if pkt[contentIdx] == 0xe0 {
+				copy(omciInd.Pkt[contentIdx:], []byte{
+					0x00, 0xe0, 0x00, 0x31, 0x32, 0x33, 0x34, 0x35,
+					0x31, 0x32, 0x33, 0x34, 0x35, 0x31, 0x32, 0x33,
+					0x34, 0x35, 0x31, 0x32, 0x33, 0x34, 0x35, 0xb4,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				})
+			} else if pkt[contentIdx] == 0x80 {
+				copy(omciInd.Pkt[contentIdx:], []byte{
+					0x00, 0x80, 0x00, 0x31, 0x32, 0x33, 0x34, 0x35,
+					0x31, 0x32, 0x33, 0x34, 0x35, 0x31, 0x32, 0x33,
+					0x34, 0x35, 0x31, 0x32, 0x33, 0x34, 0x35, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				})
+			} else {
+				logger.Error(ctx, fmt.Sprintf("fakeOmciIndication() unknown-format:message-type:%x, me-id:%x",
+					messageType, meID))
+			}
+		} else if meID == 0x0100 { // ONU-G
+			copy(omciInd.Pkt[contentIdx:], []byte{
+				0x00, 0xa0, 0x00, 0x45, 0x50, 0x4f, 0x4e, 0x45,
+				0x50, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x01, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			})
+		} else if meID == 0x0007 { // Software image
+			if meSubID == 0 {
+				copy(omciInd.Pkt[contentIdx:], []byte{
+					0x00, 0xa0, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
+					0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+					0x31, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				})
+			} else {
+				copy(omciInd.Pkt[contentIdx:], []byte{
+					0x00, 0xa0, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30,
+					0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+					0x31, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				})
+			}
+		} else if meID == 0x0086 { // IP host config data
+			var macOctets [6]byte
+			onuDev := onu.(*L2oamOnuDevice)
+			if len(onuDev.MacAddress) == 12 {
+				for idx := 0; idx < 6; idx++ {
+					if v, err := strconv.ParseInt(onuDev.MacAddress[idx*2:(idx*2)+2], 16, 8); err == nil {
+						macOctets[idx] = byte(v)
+					}
+				}
+			}
+			// 0x09-0a: Mask
+			// 0x0b-10: MAC Address
+			copy(omciInd.Pkt[contentIdx:], []byte{
+				0x00, 0x40, 0x00, macOctets[0], macOctets[1], macOctets[2], macOctets[3], macOctets[4],
+				macOctets[5], 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			})
+		} else {
+			logger.Error(ctx, fmt.Sprintf("fakeOmciIndication() unknown-format:message-type:%x, me-id:%x",
+				messageType, meID))
+		}
+	case 0x4f: // MIB reset
+		copy(omciInd.Pkt[contentIdx:], []byte{
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		})
+	case 0x4d: // MIB upload
+		copy(omciInd.Pkt[contentIdx:], []byte{
+			// first 2 bytes: the number of upload message
+			// upload messages are sent specified number of times
+			// following this message
+			0x01, 0x23 - 3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		})
+	case 0x4e: // MIB upload next
+		uploadIdx := binary.BigEndian.Uint16(pkt[contentIdx : contentIdx+2])
+		copy(omciInd.Pkt[contentIdx:], [][]byte{
+			{
+				0x00, 0x02, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				// addr: memo
+				// 0x08-09: Class ID(#6 Circuit Pack)
+				// 0x0a-0b: Managed entity ID(#257 ONU2-G)
+				// 0x0c-0d: field mask, 0xf000 means first 4 fields
+				// are stored in this message
+				// 0x0e: Type, 0x2f means 10/100/1000 BASE-T
+				// 0x0f: Number of ports
+				// 0x10-17: Serial Number
+				// 0x18-25: Version
+				0x00, 0x06, 0x01, 0x01, 0xf0, 0x00, 0x2f, 0x04, // 0x08 - 0x0f
+				0x49, 0x53, 0x4b, 0x54, 0x71, 0xe8, 0x00, 0x80, // 0x10 - 0x17
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 - 0x1f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{
+				// addr: memo
+				// 0x08-09: Class ID(#6 Circuit Pack)
+				// 0x0a-0b: Managed entity ID(#257 ONU2-G)
+				// 0x0c-0d: field mask, 0x0f00 means from 5th to 8th fields
+				// are stored in this message
+				// 0x0e-11: Vendor ID
+				// 0x12: Administrative state
+				// 0x13: Operational state
+				// 0x14: Bridged or IP ind
+				0x00, 0x06, 0x01, 0x01, 0x0f, 0x00, 0x42, 0x52, // 0x08 - 0x0f
+				0x43, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 - 0x17
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 - 0x1f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{
+				// addr: memo
+				// 0x08-09: Class ID(#6 Circuit Pack)
+				// 0x0a-0b: Managed entity ID(#257 ONU2-G)
+				// 0x0c-0d: field mask, 0x00f8 means from 9th to 13th fields
+				// are stored in this message
+				// 0x0e-21: Equipment ID
+				// 0x22: Card configuration
+				// 0x23: Total T-CONT buffer number
+				// 0x24: Total priority queue number
+				// 0x25: Total traffic scheduler number
+				0x00, 0x06, 0x01, 0x01, 0x00, 0xf8, 0x20, 0x20, // 0x08 - 0x0f
+				0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, // 0x10 - 0x17
+				0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, // 0x18 - 0x1f
+				0x20, 0x20, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{
+				// addr: memo
+				// 0x08-09: Class ID(#6 Circuit Pack)
+				// 0x0a-0b: Managed entity ID(#257 ONU2-G)
+				// 0x0c-0d: field mask, 0x0004 means from 14th field
+				// is stored in this message
+				// 0x0e-0x11: Power shed override
+				0x00, 0x06, 0x01, 0x01, 0x00, 0x04, 0x00, 0x00, // 0x08 - 0x0f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 - 0x17
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 - 0x1f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{
+				// addr: memo
+				// 0x08-09: Class ID(#6 Circuit Pack)
+				// 0x0a-0b: Managed entity ID(#384)
+				// 0x0c-0d: field mask, 0xf000 means first 4 fields
+				// are stored in this message
+				// 0x0e: Type, 0xee means XG-PON10G10
+				// 0x0f: Number of ports
+				// 0x10-17: Serial Number
+				// 0x18-25: Version
+				0x00, 0x06, 0x01, 0x80, 0xf0, 0x00, 0xee, 0x01,
+				0x49, 0x53, 0x4b, 0x54, 0x71, 0xe8, 0x00, 0x80,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Circuit Pack-#384
+				0x00, 0x06, 0x01, 0x80, 0x0f, 0x00, 0x42, 0x52,
+				0x43, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Circuit Pack-#384
+				0x00, 0x06, 0x01, 0x80, 0x00, 0xf8, 0x20, 0x20,
+				0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+				0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+				0x20, 0x20, 0x00, 0x08, 0x40, 0x10, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Circuit Pack-#384
+				0x00, 0x06, 0x01, 0x80, 0x00, 0x04, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Physical Path Termination Point Ethernet UNI(port#1)
+				// addr: memo
+				// 0x08-09: Class ID(#11 Physical Path Termination Point Ethernet UNI)
+				// 0x0a: slot ID
+				// 0x0b: port ID
+				// 0x0c-0d: field mask, 0xfffe means first 15 fields
+				// are stored in this message
+				// 0x0e: Expected type
+				// 0x0f: Sensed type, 0x2f means 10/100/1000 BASE-T
+				// 0x10: Auto detection configuration, 0x00 means Rate/Duplex = Auto/Auto
+				// 0x11: Ethernet loopback configulation
+				// 0x12: Administrative state(0: unlocks, 1: locks)
+				// 0x13: Operational state(0: enabled, 1: disabled)
+				// 0x14: Configuration ind, 0x03 means Gigabit Ethernet full duplex
+				// 0x15-16: Max frame size
+				// 0x17: DTE or DCE ind, 0x00 means DCE or MDI-X
+				// 0x18-19: Pause time
+				// 0x1a: Bridged or IP ind, 0x02 means Depends on the parent circuit pack
+				// 0x1b: ARC
+				// 0x1c: ARC interval
+				// 0x1d: PPPoE filter
+				// 0x1e: Power control
+				0x00, 0x0b, 0x01, 0x01, 0xff, 0xfe, 0x00, 0x2f, // 0x08 - 0x0f
+				0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xee, 0x00, // 0x10 - 0x17
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 - 0x1f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{ // Physical Path Termination Point Ethernet UNI(port#2)
+				0x00, 0x0b, 0x01, 0x02, 0xff, 0xfe, 0x00, 0x2f,
+				0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xee, 0x00,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Physical Path Termination Point Ethernet UNI(port#3)
+				0x00, 0x0b, 0x01, 0x03, 0xff, 0xfe, 0x00, 0x2f,
+				0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xee, 0x00,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Physical Path Termination Point Ethernet UNI(port#4)
+				0x00, 0x0b, 0x01, 0x04, 0xff, 0xfe, 0x00, 0x2f,
+				0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xee, 0x00,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#1)
+				// addr: memo
+				// 0x08-09: Class ID(#262 T-CONT)
+				// 0x0a: slot ID
+				// 0x0b: T-CONT ID
+				// 0x0c-0d: field mask, 0xe000 means first 3 fields
+				// are stored in this message
+				// 0x0e-0f: Alloc-ID
+				// 0x10: Deprecated
+				// 0x11: Policy
+				0x01, 0x06, 0x80, 0x01, 0xe0, 0x00, 0xff, 0xff, // 0x08 - 0x0f
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 - 0x17
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#2)
+				0x01, 0x06, 0x80, 0x02, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#3)
+				0x01, 0x06, 0x80, 0x03, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#4)
+				0x01, 0x06, 0x80, 0x04, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#5)
+				0x01, 0x06, 0x80, 0x05, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#6)
+				0x01, 0x06, 0x80, 0x06, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#7)
+				0x01, 0x06, 0x80, 0x07, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // T-CONT(T-CONT#8)
+				0x01, 0x06, 0x80, 0x08, 0xe0, 0x00, 0xff, 0xff,
+				0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // ANI-G(port#1)
+				// addr: memo
+				// 0x08-09: Class ID(#263 ANI-G)
+				// 0x0a: slot ID
+				// 0x0b: port ID
+				// 0x0c-0d: field mask, 0xffff means first 16 fields
+				// are stored in this message
+				// 0x0e: SR indication
+				// 0x0f-10: Total T-CONT number
+				// 0x11-12: GEM block length
+				// 0x13: Piggyback DBA reporting
+				// 0x14: Deprecated
+				// 0x15: SF threshold
+				// 0x16: SD threshold
+				// 0x17: ARC
+				// 0x18: ARC interval
+				// 0x19-0x1a: Optical signal level
+				// 0x1b: Lower optical threshold
+				// 0x1c: Upper optical threshold
+				// 0x1d-0x1e: ONU response time
+				// 0x1f-0x20: Transmit optical level
+				// 0x21: Lower transmit power threshold
+				// 0x22: Upper transmit power threshold
+				0x01, 0x07, 0x80, 0x01, 0xff, 0xff, 0x01, 0x00, // 0x08 - 0x0f
+				0x08, 0x00, 0x30, 0x00, 0x00, 0x05, 0x09, 0x00, // 0x10 - 0x17
+				0x00, 0xe0, 0x54, 0xff, 0xff, 0x00, 0x00, 0x0c, // 0x18 - 0x1f
+				0x63, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			{ // UNI-G(port#1)
+				// addr: memo
+				// 0x08-09: Class ID(#264 UNI-G)
+				// 0x0a-0b: Managed entity ID
+				// 0x0c-0d: field mask, 0xf800 means first 5 fields
+				// are stored in this message
+				// 0x0e-0f: Deprecated
+				// 0x10: Administrative state(0: unlocks, 1: locks)
+				// 0x11: Management capability
+				// 0x12-13: Non-OMCI management identifier
+				// 0x14-15: Relay agent options
+				0x01, 0x08, 0x01, 0x01, 0xf8, 0x00, 0x00, 0x00, // 0x08 - 0x0f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 - 0x17
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 - 0x1f
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 - 0x27
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 - 0x2f
+			},
+			/*
+				{ // UNI-G(port#2)
+					0x01, 0x08, 0x01, 0x02, 0xf8, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				},
+				{ // UNI-G(port#3)
+					0x01, 0x08, 0x01, 0x03, 0xf8, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				},
+				{ // UNI-G(port#4)
+					0x01, 0x08, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				},
+			*/
+			{ // Priority Queue(downstream-queue#1)
+				// addr: memo
+				// 0x08-09: Class ID(#277 Priority Queue)
+				// 0x0a-0b: Managed entity ID(most significant bit represents the direction (1: upstream, 0: downstream))
+				// 0x0c-0d: field mask, 0x000f means from 13th to 16th fields
+				// are stored in this message
+				// 0x0e-0f: Deprecated
+				0x01, 0x15, 0x00, 0x01, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#1)
+				0x01, 0x15, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#1)
+				0x01, 0x15, 0x80, 0x01, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#1)
+				0x01, 0x15, 0x80, 0x01, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#2)
+				0x01, 0x15, 0x00, 0x02, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#2)
+				0x01, 0x15, 0x00, 0x02, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#2)
+				0x01, 0x15, 0x80, 0x02, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#2)
+				0x01, 0x15, 0x80, 0x02, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#3)
+				0x01, 0x15, 0x00, 0x03, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#3)
+				0x01, 0x15, 0x00, 0x03, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#3)
+				0x01, 0x15, 0x80, 0x03, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#3)
+				0x01, 0x15, 0x80, 0x03, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#4)
+				0x01, 0x15, 0x00, 0x04, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#4)
+				0x01, 0x15, 0x00, 0x04, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#4)
+				0x01, 0x15, 0x80, 0x04, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#4)
+				0x01, 0x15, 0x80, 0x04, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#5)
+				0x01, 0x15, 0x00, 0x05, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#5)
+				0x01, 0x15, 0x00, 0x05, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#5)
+				0x01, 0x15, 0x80, 0x05, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#5)
+				0x01, 0x15, 0x80, 0x05, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#6)
+				0x01, 0x15, 0x00, 0x06, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#6)
+				0x01, 0x15, 0x00, 0x06, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#6)
+				0x01, 0x15, 0x80, 0x06, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#6)
+				0x01, 0x15, 0x80, 0x06, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#7)
+				0x01, 0x15, 0x00, 0x07, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#7)
+				0x01, 0x15, 0x00, 0x07, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#7)
+				0x01, 0x15, 0x80, 0x07, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#7)
+				0x01, 0x15, 0x80, 0x07, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#8)
+				0x01, 0x15, 0x00, 0x08, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#8)
+				0x01, 0x15, 0x00, 0x08, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#8)
+				0x01, 0x15, 0x80, 0x08, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#8)
+				0x01, 0x15, 0x80, 0x08, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x01, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#9)
+				0x01, 0x15, 0x00, 0x09, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#9)
+				0x01, 0x15, 0x00, 0x09, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#9)
+				0x01, 0x15, 0x80, 0x09, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#9)
+				0x01, 0x15, 0x80, 0x09, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#10)
+				0x01, 0x15, 0x00, 0x0a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#10)
+				0x01, 0x15, 0x00, 0x0a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#10)
+				0x01, 0x15, 0x80, 0x0a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#10)
+				0x01, 0x15, 0x80, 0x0a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#11)
+				0x01, 0x15, 0x00, 0x0b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#11)
+				0x01, 0x15, 0x00, 0x0b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#11)
+				0x01, 0x15, 0x80, 0x0b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#11)
+				0x01, 0x15, 0x80, 0x0b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#12)
+				0x01, 0x15, 0x00, 0x0c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#12)
+				0x01, 0x15, 0x00, 0x0c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#12)
+				0x01, 0x15, 0x80, 0x0c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#12)
+				0x01, 0x15, 0x80, 0x0c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#13)
+				0x01, 0x15, 0x00, 0x0d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#13)
+				0x01, 0x15, 0x00, 0x0d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#13)
+				0x01, 0x15, 0x80, 0x0d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#13)
+				0x01, 0x15, 0x80, 0x0d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#14)
+				0x01, 0x15, 0x00, 0x0e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#14)
+				0x01, 0x15, 0x00, 0x0e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#14)
+				0x01, 0x15, 0x80, 0x0e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#14)
+				0x01, 0x15, 0x80, 0x0e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#15)
+				0x01, 0x15, 0x00, 0x0f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#15)
+				0x01, 0x15, 0x00, 0x0f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#15)
+				0x01, 0x15, 0x80, 0x0f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#15)
+				0x01, 0x15, 0x80, 0x0f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#16)
+				0x01, 0x15, 0x00, 0x10, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(downstream-queue#16)
+				0x01, 0x15, 0x00, 0x10, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x02, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(upstream-queue#16)
+				0x01, 0x15, 0x80, 0x10, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Priority Queue(uptream-queue#16)
+				0x01, 0x15, 0x80, 0x10, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x02, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x11, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x11, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x11, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x11, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x12, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x12, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x12, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x12, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x13, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x13, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x13, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x13, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x14, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x14, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x14, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x14, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x15, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x15, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x15, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x15, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x16, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x16, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x16, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x16, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x17, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x17, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x17, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x17, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x18, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x18, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x03, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x18, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x18, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x03, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x19, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x19, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x19, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x19, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x1f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x1f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x20, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x20, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x04, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x20, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x20, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x04, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x21, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x21, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x21, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x21, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x22, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x22, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x22, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x22, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x23, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x23, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x23, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x23, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x24, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x24, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x24, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x24, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x25, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x25, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x25, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x25, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x26, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x26, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x26, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x26, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x27, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x27, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x27, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x27, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x28, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x28, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x05, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x28, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x28, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x05, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x29, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x29, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x29, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x29, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x2f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x2f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x30, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x30, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x06, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x30, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x30, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x06, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x31, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x31, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x31, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x31, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x32, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x32, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x32, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x32, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x33, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x33, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x33, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x33, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x34, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x34, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x34, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x34, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x35, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x35, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x35, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x35, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x36, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x36, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x36, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x36, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x37, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x37, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x37, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x37, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x38, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x38, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x07, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x38, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x38, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x07, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x39, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x39, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x39, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x39, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x00, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x01, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3a, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3a, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x01, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x02, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3b, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3b, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x02, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x03, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3c, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3c, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x03, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3d, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3d, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x04, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x05, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3e, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3e, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x05, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x3f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x06, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3f, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x3f, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x06, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x40, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x00, 0x40, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+				0x08, 0x00, 0x07, 0x01, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x40, 0x00, 0x0f, 0xff, 0xff,
+				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+				0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{
+				0x01, 0x15, 0x80, 0x40, 0xff, 0xf0, 0x00, 0x01,
+				0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+				0x08, 0x00, 0x07, 0x80, 0x08, 0x01, 0x00, 0x01,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x08,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x09,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0a,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0b,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0c,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0d,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0e,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // Traffic Scheduler
+				0x01, 0x16, 0x80, 0x00, 0xf0, 0x00, 0x80, 0x0f,
+				0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			{ // ONU2-G
+				0x01, 0x01, 0x00, 0x00, 0x07, 0xfc, 0x00, 0x40,
+				0x08, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x7f, 0x00, 0x00, 0x3f, 0x00, 0x01, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+		}[uploadIdx][:])
+	case 0x44: // Create
+		// meID
+		// 0x0110: GAL Ethernet profile
+		// 0x002d: MAC bridge service profile
+		// 0x002f: MAC brige port configuration data
+		// 0x00ab: Extended VLAN tagging operation configuration data
+		// 0x0082: IEEE 802.1p mapper service profile
+		// 0x010c: GEM port network CTP
+		// 0x010a: GEM interworking termination point
+		copy(omciInd.Pkt[contentIdx:], []byte{
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		})
+	case 0x48: // Set
+		// meID
+		// 0x0101: ONU2-G
+		// 0x0100: ONU-G
+		// 0x0108: UNI-G
+		// 0x0106: T-CONT
+		// 0x0115: Priority queue
+		// 0x0082: IEEE 802.1p mapper service profile
+		copy(omciInd.Pkt[contentIdx:], []byte{
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		})
+	}
+	go func() {
+		if err := dh.omciIndication(ctx, omciInd); err != nil {
+			return
+		}
+	}()
+
+	return nil
+}
+
+func (d *L2oamOltDevice) setActiveState(ctx context.Context, isActive bool) {
+	d.Base.setActiveState(ctx, isActive)
+}
+func (d *L2oamOltDevice) startMountSequence(ctx context.Context, pkgType string, cmd *L2oamCmd) {
+}
+func (d *L2oamOltDevice) reboot(ctx context.Context) {
+}
+func (d *L2oamOltDevice) updateMap() {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+	_, ok := deviceMap[d.Base.DstMac]
+	if ok {
+		deviceMap[d.Base.DstMac] = d
+	}
+}
+func (d *L2oamOltDevice) setL2oamCmd(cmd *L2oamCmd) {
+	d.L2oamCmd = cmd
+}
+func (d *L2oamOltDevice) getL2oamCmd() *L2oamCmd {
+	return d.L2oamCmd
+}
+func (d *L2oamOltDevice) setObjectContext(oc *l2oam.TomiObjectContext) {
+	d.ObjectContext = oc
+}
+func (d *L2oamOltDevice) getObjectContext() *l2oam.TomiObjectContext {
+	return d.ObjectContext
+}
+func (d *L2oamOltDevice) setReferenceTable(tbl *l2oam.GetTrafficControlReferenceTableRes) {
+	d.ReferenceTable = tbl
+}
+func (d *L2oamOltDevice) getReferenceTable() *l2oam.GetTrafficControlReferenceTableRes {
+	return d.ReferenceTable
+}
+func (d *L2oamOltDevice) setProfile(down *l2oam.SetGenericActionCreateRes, up *l2oam.SetGenericActionCreateRes) {
+	d.DownProfile = down
+	d.UpProfile = up
+}
+func (d *L2oamOltDevice) getProfile() (*l2oam.SetGenericActionCreateRes, *l2oam.SetGenericActionCreateRes) {
+	return d.DownProfile, d.UpProfile
+}
+func (d *L2oamOltDevice) delete(ctx context.Context) {
+	d.Base.delete(ctx)
+}
+func (d *L2oamOltDevice) setDeleteFlag() {
+	d.Base.setDeleteFlag()
+}
+func (d *L2oamOltDevice) getDeleteFlag() bool {
+	return d.Base.getDeleteFlag()
+}
+func (d *L2oamOltDevice) setAutonomousFlag(flag bool) {
+	d.Base.setAutonomousFlag(flag)
+	d.updateMap()
+}
+func (d *L2oamOltDevice) getAutonomousFlag() bool {
+	return d.Base.getAutonomousFlag()
+}
+func (d *L2oamOltDevice) receiveEapol(etherPacket *layers.Ethernet) {
+	d.Base.receiveEapol(etherPacket)
+}
+
+func (d *L2oamOltDevice) addFlow(ctx context.Context, cmd *L2oamCmd) error {
+	d.autonomousExecMutex.Lock()
+	defer d.autonomousExecMutex.Unlock()
+
+	onu := FindL2oamDeviceByDeviceID(cmd.OnuDeviceID)
+	if onu == nil {
+		return fmt.Errorf(fmt.Sprintf("catnnot-get-onu-device. device-id:%s", cmd.OnuDeviceID))
+	} else if !(onu.(*L2oamOnuDevice)).Base.isActive() {
+		logger.Debug(ctx, fmt.Sprintf("onu is not active. device-id:%s", cmd.OnuDeviceID))
+	} else {
+		logger.Debug(ctx, fmt.Sprintf("add-flow-for-onu. device-id:%s", cmd.OnuDeviceID))
+
+		oc := onu.getObjectContext()
+		if oc == nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-object-context. device-id:%s", cmd.OnuDeviceID))
+		} else {
+			getTrafficControl := onu.getReferenceTable()
+			if getTrafficControl == nil {
+				getTrafficControl = sendGetTrafficControlReferenceTable(ctx, d, oc)
+				if getTrafficControl == nil {
+					return errors.New("L2oamAddFlow() sendGetTrafficControlReferenceTable() error. ")
+				}
+			}
+			downProfile, upProfile := onu.getProfile()
+			// if profiles are created, remove these profiles.
+			if downProfile != nil {
+				if err := sendSetActionDelete(ctx, d, downProfile.GetTrafficProfile(), l2oam.ActionTypeTrafficProfile); err != nil {
+					logger.Error(ctx,
+						fmt.Sprintf("L2oamAddFlow() Generic/Action Delete(downstream) error. %v", err))
+				}
+			}
+			if upProfile != nil {
+				if err := sendSetActionDelete(ctx, d, upProfile.GetTrafficProfile(), l2oam.ActionTypeTrafficProfile); err != nil {
+					logger.Error(ctx,
+						fmt.Sprintf("L2oamAddFlow() Generic/Action Delete(upstream) error. %v", err))
+				}
+			}
+			downProfile = sendSetGenericActionCreate(ctx, d, l2oam.ActionTypeTrafficProfile)
+			if downProfile == nil {
+				return errors.New("L2oamAddFlow() Generic/Action Create(downstream) error")
+			}
+			upProfile = sendSetGenericActionCreate(ctx, d, l2oam.ActionTypeTrafficProfile)
+			if upProfile == nil {
+				return errors.New("L2oamAddFlow() Generic/Action Create(upstream) error")
+			}
+			onu.setReferenceTable(getTrafficControl)
+			onu.setProfile(downProfile, upProfile)
+			onu.updateMap()
+
+			err01 := sendSetTrafficControl(ctx, d, getTrafficControl.GetReferenceControlDown(), downProfile.GetTrafficProfile())
+			err02 := sendSetTrafficControl(ctx, d, getTrafficControl.GetReferenceControlUp(), upProfile.GetTrafficProfile())
+			logger.Debug(ctx, fmt.Sprintf("traffic-control/traffic-profile results: %v, %v", err01, err02))
+
+			err03 := sendSetPriority(ctx, d, downProfile.GetTrafficProfile())
+			err04 := sendSetGuranteedRate(ctx, d, cmd.Cir, downProfile.GetTrafficProfile())
+			err05 := sendSetGuranteedRate(ctx, d, cmd.Cir, upProfile.GetTrafficProfile())
+			err06 := sendSetBestEffortRate(ctx, d, cmd.Pir, downProfile.GetTrafficProfile())
+			err07 := sendSetBestEffortRate(ctx, d, cmd.Pir, upProfile.GetTrafficProfile())
+			logger.Debug(ctx, fmt.Sprintf("traffic-profile-settings-results: %v, %v, %v, %v, %v",
+				err03, err04, err05, err06, err07))
+		}
+	}
+
+	return nil
+}
+
+func (d *L2oamOltDevice) updateFlow(ctx context.Context, cmd *L2oamCmd) error {
+	d.autonomousExecMutex.Lock()
+	defer d.autonomousExecMutex.Unlock()
+
+	onuDeviceID := cmd.OnuDeviceID
+	logger.Debugf(ctx, "updateFlow() Start. onu-device-id:%s, tpid:%x, vid%x",
+		onuDeviceID, cmd.Tpid, cmd.Vid)
+
+	onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+	if onu == nil {
+		return errors.New("L2oamUpdateFlow() FindL2oamDeviceByDeviceId() error. onu not found")
+	}
+	var action *l2oam.TomiObjectContext
+	var err error
+	onuID := onu.getObjectContext()
+	for _, settings := range d.L2SwitchDomainMap {
+		if _, exists := settings.Onus[onuDeviceID]; exists {
+			if err = sendSetActionInletEntryUsDel(ctx,
+				d, settings.OcAction, settings.Tpid, settings.Vid, onuID); err != nil {
+				logger.Errorf(ctx, "error:%v", err)
+			}
+			delete(settings.Onus, onuDeviceID)
+		}
+	}
+	vidValue := byte2Int(cmd.Vid)
+	settings, exists := d.L2SwitchDomainMap[vidValue]
+	if !exists {
+		action, err = sendSetGenericActionCreateForDS(ctx, d)
+		if err != nil {
+			logger.Errorf(ctx, "error:%v", err)
+		}
+		settings = &l2SwitchDomain{
+			OcAction: action,
+			Tpid:     cmd.Tpid,
+			Vid:      cmd.Vid,
+			Onus:     map[string]bool{},
+		}
+		d.L2SwitchDomainMap[vidValue] = settings
+		if err := sendSetL2SwitchingDomainForDS(ctx, d, action, cmd.Tpid, cmd.Vid); err != nil {
+			logger.Errorf(ctx, "error:%v", err)
+		}
+	} else {
+		action = settings.OcAction
+	}
+	if err := sendSetDefaultOutlet(ctx, d, action, onuID); err != nil {
+		logger.Errorf(ctx, "error:%v", err)
+	}
+	if err := sendSetL2SwitchingDomainForUS(ctx, d, action, cmd.Tpid, cmd.Vid, onuID); err != nil {
+		logger.Errorf(ctx, "error:%v", err)
+	}
+	settings.Onus[onuDeviceID] = true
+
+	logger.Debugf(ctx, "updateFlow() end. onu-device-id:%s, tpid:%x, vid%x",
+		onuDeviceID, cmd.Tpid, cmd.Vid)
+
+	return nil
+}
+
+func (d *L2oamOltDevice) removeFlow(ctx context.Context) error {
+	logger.Debugf(ctx, "removeFlow() Start. device-id:%s", d.Base.DeviceID)
+
+	for _, settings := range d.L2SwitchDomainMap {
+		for onuDeviceID := range settings.Onus {
+			onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+			if onu == nil {
+				logger.Errorf(ctx, "onu not found. device-id:%s", onuDeviceID)
+				continue
+			}
+			onuID := onu.getObjectContext()
+			if err := sendSetActionInletEntryUsDel(ctx,
+				d, settings.OcAction, settings.Tpid, settings.Vid, onuID); err != nil {
+				logger.Errorf(ctx, "error:%v", err)
+			}
+		}
+		settings.Onus = map[string]bool{}
+
+		if err := sendSetActionInletEntryDsDel(ctx, d, settings.OcAction, settings.Tpid, settings.Vid); err != nil {
+			logger.Errorf(ctx, "error:%v", err)
+		}
+		if err := sendSetActionDeleteStream(ctx, d, settings.OcAction); err != nil {
+			logger.Errorf(ctx, "error:%v", err)
+		}
+	}
+	d.L2SwitchDomainMap = map[uint32]*l2SwitchDomain{}
+
+	return nil
+}
+
+// L2oamOnuDevice =================================
+// L2oamOnuDevice provides functions for OLT device
+// ================================================
+type L2oamOnuDevice struct {
+	Base              DeviceBase
+	OnuID             uint32
+	ObjectContext     *l2oam.TomiObjectContext
+	ReferenceTable    *l2oam.GetTrafficControlReferenceTableRes
+	DownProfile       *l2oam.SetGenericActionCreateRes
+	UpProfile         *l2oam.SetGenericActionCreateRes
+	PkgType           string
+	keepAliveResponse chan string
+	MacAddress        string
+}
+
+func (d *L2oamOnuDevice) getDeviceName() string {
+	return d.Base.getDeviceName()
+}
+func (d *L2oamOnuDevice) send(message gopacket.SerializableLayer) error {
+	return d.Base.send(message)
+}
+func (d *L2oamOnuDevice) waitResponse(timeoutSecond int) (*layers.Ethernet, error) {
+	return d.Base.waitResponse(timeoutSecond)
+}
+func (d *L2oamOnuDevice) sendAndWait(message gopacket.SerializableLayer, timeoutSecond int) (*layers.Ethernet, error) {
+	return d.Base.sendAndWait(message, timeoutSecond)
+}
+func (d *L2oamOnuDevice) recieve(etherPacket *layers.Ethernet) {
+	d.Base.recieve(etherPacket)
+}
+func (d *L2oamOnuDevice) recieveKeepAlive(etherPacket *layers.Ethernet) {
+	packet := &l2oam.OAMPDUInformation{}
+	if err := packet.Decode(etherPacket.Payload); err != nil {
+		return
+	}
+	if (l2oam.OnuPkgType == l2oam.OnuPkgTypeA) && (packet.IsOnuPkgA()) {
+		logger.Info(context.Background(), fmt.Sprintf("[%s] recieveKeepAlive() Pkg type A.", d.getDeviceName()))
+		if d.keepAliveResponse != nil {
+			d.keepAliveResponse <- "PkgTypeError"
+		}
+		// d.Base.recieveKeepAlive(etherPacket)
+		d.PkgType = l2oam.OnuPkgTypeA
+	} else if (l2oam.OnuPkgType == l2oam.OnuPkgTypeB) && (packet.IsOnuPkgB()) {
+		logger.Info(context.Background(), fmt.Sprintf("[%s] recieveKeepAlive() Pkg type B.", d.getDeviceName()))
+		if d.keepAliveResponse != nil {
+			d.keepAliveResponse <- "success"
+		}
+		d.Base.recieveKeepAlive(etherPacket)
+		d.PkgType = l2oam.OnuPkgTypeB
+	} else {
+		logger.Error(context.Background(), fmt.Sprintf("[%s] recieveKeepAlive() Pkg type error. support type=%s, isOnuPkgA=%v, isOnuPkgB=%v", d.getDeviceName(), l2oam.OnuPkgType, packet.IsOnuPkgA(), packet.IsOnuPkgB()))
+		if d.keepAliveResponse != nil {
+			d.keepAliveResponse <- "PkgTypeError"
+		}
+	}
+}
+
+func (d *L2oamOnuDevice) startKeepAlive() {
+	d.Base.startKeepAlive()
+}
+func (d *L2oamOnuDevice) stopKeepAlive() {
+	d.Base.stopKeepAlive()
+}
+func (d *L2oamOnuDevice) setActiveState(ctx context.Context, isActive bool) {
+	d.Base.setActiveState(ctx, isActive)
+}
+func (d *L2oamOnuDevice) update(mac string, deviceID string, onuID uint32) {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+	d.OnuID = onuID
+	d.Base.DeviceID = deviceID
+	deviceMap[mac] = d
+	deviceMacMap[deviceID] = mac
+}
+
+func (d *L2oamOnuDevice) startMountSequence(ctx context.Context, pkgType string, cmd *L2oamCmd) {
+	if pkgType == l2oam.OnuPkgTypeA {
+		d.startMountSequencePkgA(ctx, pkgType, cmd)
+		return
+	}
+	go func() {
+		logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). MacAddress=%s", d.getDeviceName(), d.Base.DstMac))
+		// wait until the onu keep-alive state transits to step3
+		for {
+			if d.Base.KeepAliveStatus != KeepAliveStep3 {
+				time.Sleep(1 * time.Second)
+			} else {
+				logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). onu active status. start sequence. MacAddress=%s", d.getDeviceName(), d.Base.DstMac))
+				break
+			}
+		}
+
+		// ONU System Info(get request)
+		_, err := d.sendAndWait(l2oam.GenerateOnuSystemInfo(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuSystemInfo() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// ONU Config
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateOnuConfig(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuConfig() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// FEC Mode
+		_, err = d.sendAndWait(l2oam.GenerateFecMode(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateFecMode() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Encryption Mode
+		max := 2
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateEncryptionMode(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateEncryptionMode(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+
+		// Dyn Learning Mode
+		max = 3
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateDynLearningMode(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateDynLearningMode(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Ponp Temperature
+		_, err = d.sendAndWait(l2oam.GeneratePonpTemperature(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpTemperature() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical TRx Supply Voltage
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTRxSupplyVoltage(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTRxSupplyVoltage() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Tx Bias Current
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTxBiasCurrent(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTxBiasCurrent() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Tx Output Power
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTxOutputPower(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTxOutputPower() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Rx Output Power
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptRxInputPower(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptRxInputPower() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+
+		// Onu Priority Queue Count
+		max = 2
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateOnuPriorityQueueCount(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuPriorityQueueCount(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Unip Target Queue Priority
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateUnipTargetQueuePriority(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateUnipTargetQueuePriority() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// Vlan Pon VID Value
+		max = 2
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetVlanPonVIDValue(pkgType, index+1, cmd.Itpid, cmd.Ivid), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetVlanPonVIDValue(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Vlan Tag Filter
+		max = 0
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 2
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetVlanTagFilter(pkgType, index+1, cmd.Itpid), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetVlanTagFilter(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Frame Processing
+		/*if pkgType == ONU_PKG_TYPE_A {
+			_, err = d.sendAndWait(l2oam.GeneateSetFrameProcessing(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GeneateOnuSysInfo() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}*/
+		// Qos Policer Rate
+		max = 1
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetQosPolicerRate(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetQosPolicerRate(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Qos Policer Burst
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateSetQosPolicerBurst(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetQosPolicerBurst() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// Unip Info
+		_, err = d.sendAndWait(l2oam.GenerateGetUnipInfo(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateGetUnipInfo() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Unip Link Mode
+		_, err = d.sendAndWait(l2oam.GenerateSetUnipLinkMode(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetUnipLinkMode() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Unip TOSCOS Conversion
+		_, err = d.sendAndWait(l2oam.GenerateUnipTOSCOSConversion(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateUnipTOSCOSConversion() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// ONU Errored Frame Window
+		_, err = d.sendAndWait(l2oam.GenerateOnuErroredFrameWindow(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuErroredFrameWindow() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// ONU Errord Frame Threshold
+		_, err = d.sendAndWait(l2oam.GenerateOnuErroredFrameWindow(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuErroredFrameWindow() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). Normal End.", d.getDeviceName()))
+	}()
+}
+func (d *L2oamOnuDevice) startMountSequencePkgA(ctx context.Context, pkgType string, cmd *L2oamCmd) {
+	go func() {
+		logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). MacAddress=%s", d.getDeviceName(), d.Base.DstMac))
+		// wait until the onu keep-alive state transits to step3
+		for {
+			if d.Base.KeepAliveStatus != KeepAliveStep3 {
+				time.Sleep(1 * time.Second)
+			} else {
+				logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). onu active status. start sequence. MacAddress=%s", d.getDeviceName(), d.Base.DstMac))
+				break
+			}
+		}
+
+		// // Encryption Mode
+		// _, err := d.sendAndWait(l2oam.GenerateEncryptionMode(pkgType, 1), ResponseTimer)
+		// if err != nil {
+		// 	logger.Error(ctx, fmt.Sprintf("[%s] GenerateEncryptionMode(%v) Send Error: %v", d.getDeviceName(), 1, err))
+		// 	return
+		// }
+
+		// ONU System Info(get request)
+		_, err := d.sendAndWait(l2oam.GenerateOnuSystemInfo(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuSystemInfo() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// ONU Config
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateOnuConfig(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuConfig() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// FEC Mode
+		_, err = d.sendAndWait(l2oam.GenerateFecMode(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateFecMode() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Encryption Mode
+		_, err = d.sendAndWait(l2oam.GenerateEncryptionMode(pkgType, 2), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateEncryptionMode(%v) Send Error: %v", d.getDeviceName(), 2, err))
+			return
+		}
+
+		// Dyn Learning Mode
+		max := 3
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateDynLearningMode(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateDynLearningMode(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Ponp Temperature
+		_, err = d.sendAndWait(l2oam.GeneratePonpTemperature(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpTemperature() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical TRx Supply Voltage
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTRxSupplyVoltage(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTRxSupplyVoltage() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Tx Bias Current
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTxBiasCurrent(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTxBiasCurrent() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Tx Output Power
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptTxOutputPower(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptTxOutputPower() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Ponp Optical Rx Output Power
+		_, err = d.sendAndWait(l2oam.GeneratePonpOptRxInputPower(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GeneratePonpOptRxInputPower() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+
+		// Onu Priority Queue Count
+		max = 2
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateOnuPriorityQueueCount(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateOnuPriorityQueueCount(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Unip Target Queue Priority
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateUnipTargetQueuePriority(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateUnipTargetQueuePriority() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// Vlan Pon VID Value
+		max = 2
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetVlanPonVIDValue(pkgType, index+1, cmd.Itpid, cmd.Ivid), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetVlanPonVIDValue(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Vlan Tag Filter
+		max = 0
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 2
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetVlanTagFilter(pkgType, index+1, cmd.Itpid), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetVlanTagFilter(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Frame Processing
+		/*if pkgType == ONU_PKG_TYPE_A {
+			_, err = d.sendAndWait(l2oam.GeneateSetFrameProcessing(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GeneateOnuSysInfo() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}*/
+		// Qos Policer Rate
+		max = 1
+		if pkgType == l2oam.OnuPkgTypeB {
+			max = 1
+		}
+		for index := 0; index < max; index++ {
+			_, err = d.sendAndWait(l2oam.GenerateSetQosPolicerRate(pkgType, index+1), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetQosPolicerRate(%v) Send Error: %v", d.getDeviceName(), index+1, err))
+				return
+			}
+		}
+		// Qos Policer Burst
+		if pkgType == l2oam.OnuPkgTypeB {
+			_, err = d.sendAndWait(l2oam.GenerateSetQosPolicerBurst(pkgType), ResponseTimer)
+			if err != nil {
+				logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetQosPolicerBurst() Send Error: %v", d.getDeviceName(), err))
+				return
+			}
+		}
+		// Unip Info
+		_, err = d.sendAndWait(l2oam.GenerateGetUnipInfo(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateGetUnipInfo() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		// Traffic Enable
+		_, err = d.sendAndWait(l2oam.GenerateSetTrafficEnable(pkgType), ResponseTimer)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("[%s] GenerateSetTrafficEnable() Send Error: %v", d.getDeviceName(), err))
+			return
+		}
+		logger.Debug(ctx, fmt.Sprintf("[%s] startMountSequence(). Normal End.", d.getDeviceName()))
+	}()
+}
+
+func (d *L2oamOnuDevice) reboot(ctx context.Context) {
+	_, err := d.sendAndWait(l2oam.GenerateSetResetOnu(l2oam.OnuPkgType), ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("[%s] reboot() Send Error: %v", d.getDeviceName(), err))
+		return
+	}
+}
+
+func (d *L2oamOnuDevice) updateMap() {
+	mapMutex.Lock()
+	defer mapMutex.Unlock()
+
+	_, ok := deviceMap[d.Base.DstMac]
+	if ok {
+		deviceMap[d.Base.DstMac] = d
+	}
+}
+func (d *L2oamOnuDevice) setL2oamCmd(cmd *L2oamCmd) {
+}
+func (d *L2oamOnuDevice) getL2oamCmd() *L2oamCmd {
+	return nil
+}
+func (d *L2oamOnuDevice) setObjectContext(oc *l2oam.TomiObjectContext) {
+	d.ObjectContext = oc
+}
+func (d *L2oamOnuDevice) getObjectContext() *l2oam.TomiObjectContext {
+	return d.ObjectContext
+}
+func (d *L2oamOnuDevice) setReferenceTable(tbl *l2oam.GetTrafficControlReferenceTableRes) {
+	d.ReferenceTable = tbl
+}
+func (d *L2oamOnuDevice) getReferenceTable() *l2oam.GetTrafficControlReferenceTableRes {
+	return d.ReferenceTable
+}
+func (d *L2oamOnuDevice) setProfile(down *l2oam.SetGenericActionCreateRes, up *l2oam.SetGenericActionCreateRes) {
+	d.DownProfile = down
+	d.UpProfile = up
+}
+func (d *L2oamOnuDevice) getProfile() (*l2oam.SetGenericActionCreateRes, *l2oam.SetGenericActionCreateRes) {
+	return d.DownProfile, d.UpProfile
+}
+func (d *L2oamOnuDevice) delete(ctx context.Context) {
+	d.Base.delete(ctx)
+}
+func (d *L2oamOnuDevice) setDeleteFlag() {
+	d.Base.setDeleteFlag()
+}
+func (d *L2oamOnuDevice) getDeleteFlag() bool {
+	return d.Base.getDeleteFlag()
+}
+func (d *L2oamOnuDevice) setAutonomousFlag(flag bool) {
+	d.Base.setAutonomousFlag(flag)
+	d.updateMap()
+}
+func (d *L2oamOnuDevice) getAutonomousFlag() bool {
+	return d.Base.getAutonomousFlag()
+}
+func (d *L2oamOnuDevice) receiveEapol(etherPacket *layers.Ethernet) {
+	d.Base.receiveEapol(etherPacket)
+}
+func (d *L2oamOnuDevice) waitKeepALiveResponse() error {
+	select {
+	case result := <-d.keepAliveResponse:
+		if result == "success" {
+			return nil
+		}
+		return fmt.Errorf("waitKeepALiveResponse() error. reason=%s", result)
+
+	case <-time.After(ResponseTimer * time.Second):
+		return fmt.Errorf("waitKeepALiveResponse() error. reason=%s", "timeout")
+	}
+}
+
+func (d *L2oamOnuDevice) addFlow(ctx context.Context, cmd *L2oamCmd) error {
+	return errors.New("onu.addFlow: not implemented")
+}
+
+func (d *L2oamOnuDevice) updateFlow(ctx context.Context, cmd *L2oamCmd) error {
+	return errors.New("onu.updateFlow: not implemented")
+}
+
+func (d *L2oamOnuDevice) removeFlow(ctx context.Context) error {
+	return errors.New("onu.removeFlow: not implemented")
+}
+
+// macAddress must not have colons
+/*
+func isOnuEnable(ctx context.Context, macAddress string) (bool, string) {
+	mac := convertMacString(macAddress)
+	onulist, err := l2oam.ReadOnuStatusList()
+	if err != nil {
+		return false, ""
+	}
+	for _, v := range onulist {
+		if v.MacAddress == mac {
+			if v.AdminState == "ENABLED" {
+				return true, v.ID
+			}
+		}
+	}
+
+	return false, ""
+}
+*/
+
+func updateOltActiveStatus(ctx context.Context, dh *DeviceHandler, isActive bool) {
+	logger.Debug(ctx, fmt.Sprintf("updateOltActiveStatus() isActive=%v", isActive))
+	if dh != nil && dh.coreProxy != nil {
+		var err error
+		if isActive {
+			err = dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_REACHABLE, voltha.OperStatus_ACTIVE)
+		} else {
+			err = dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_UNREACHABLE, voltha.OperStatus_ACTIVATING)
+		}
+		if err != nil {
+			logger.Debug(ctx, fmt.Sprintf("updateOltActiveStatus() error=%v", err))
+		}
+	} else {
+		logger.Debug(ctx, fmt.Sprintf("updateOltActiveStatus() deviceId=%s, isActive=%v", dh.device.Id, isActive))
+	}
+}
+
+// macAddress must not have colons
+/*
+func updateOnuActiveStatus(ctx context.Context, macAddress string, isActive bool, dh *DeviceHandler) {
+	mac := convertMacString(macAddress)
+	onulist, err := l2oam.ReadOnuStatusList()
+	logger.Debug(ctx, fmt.Sprintf("updateOnuActiveStatus() ReadOnuList() onulist=%v, err=%s, macAddress=%s, mac=%s, isActive=%v", onulist, err, macAddress, mac, isActive))
+	if err != nil {
+		return
+	}
+	for i, v := range onulist {
+		if v.MacAddress == mac {
+			if isActive {
+				onulist[i].OpeState = "ACTIVE"
+				onulist[i].ConnectState = "REACHABLE"
+				dh.coreProxy.DeviceStateUpdate(ctx, v.ID, voltha.ConnectStatus_REACHABLE, voltha.OperStatus_ACTIVE)
+			} else {
+				onulist[i].OpeState = "FAILED"
+				onulist[i].ConnectState = "UNREACHABLE"
+				dh.coreProxy.DeviceStateUpdate(ctx, v.ID, voltha.ConnectStatus_UNREACHABLE, voltha.OperStatus_FAILED)
+			}
+			logger.Debug(ctx, fmt.Sprintf("updateOnuActiveStatus() WriteOnuList() macaddress=%s list=%v", mac, onulist))
+			//l2oam.WriteOnuStatusList(onulist)
+			break
+		}
+	}
+}
+*/
+
+func updateOnuActiveStatus2(ctx context.Context, dh *DeviceHandler, isActive bool, deviceID string) {
+	logger.Debug(ctx, fmt.Sprintf("updateOnuActiveStatus2() deviceId=%s, isActive=%v", deviceID, isActive))
+	if dh != nil && dh.coreProxy != nil {
+		var err error
+		if isActive {
+			err = dh.coreProxy.DeviceStateUpdate(ctx, deviceID, voltha.ConnectStatus_REACHABLE, voltha.OperStatus_ACTIVE)
+		} else {
+			err = dh.coreProxy.DeviceStateUpdate(ctx, deviceID, voltha.ConnectStatus_UNREACHABLE, voltha.OperStatus_ACTIVATING)
+		}
+		if err != nil {
+			logger.Debug(ctx, fmt.Sprintf("updateOnuActiveStatus2() error=%v", err))
+		}
+	} else {
+		logger.Debug(ctx, fmt.Sprintf("updateOnuActiveStatus2() deviceId=%s, isActive=%v", deviceID, isActive))
+	}
+}
+func convertMacString(mac string) string {
+	macbytes := []byte(mac)
+	colonbytes := []byte(":")
+	colon := colonbytes[0]
+
+	resbytes := []byte{}
+	resbytes = append(resbytes, macbytes[0])
+	resbytes = append(resbytes, macbytes[1])
+	resbytes = append(resbytes, colon)
+	resbytes = append(resbytes, macbytes[2])
+	resbytes = append(resbytes, macbytes[3])
+	resbytes = append(resbytes, colon)
+	resbytes = append(resbytes, macbytes[4])
+	resbytes = append(resbytes, macbytes[5])
+	resbytes = append(resbytes, colon)
+	resbytes = append(resbytes, macbytes[6])
+	resbytes = append(resbytes, macbytes[7])
+	resbytes = append(resbytes, colon)
+	resbytes = append(resbytes, macbytes[8])
+	resbytes = append(resbytes, macbytes[9])
+	resbytes = append(resbytes, colon)
+	resbytes = append(resbytes, macbytes[10])
+	resbytes = append(resbytes, macbytes[11])
+	return string(resbytes)
+
+}
+func monitoringOnuStatus() {
+	go WatchStatus(context.Background(), nil)
+}
+func byte2Int(v []byte) uint32 {
+	switch len(v) {
+	case 1:
+		return uint32(v[0])
+	case 2:
+		return uint32(binary.BigEndian.Uint16(v[:]))
+	case 4:
+		return binary.BigEndian.Uint32(v[:])
+	default:
+		return 0
+	}
+}
diff --git a/internal/pkg/core/l2oam_handle.go b/internal/pkg/core/l2oam_handle.go
new file mode 100644
index 0000000..eb8ebb3
--- /dev/null
+++ b/internal/pkg/core/l2oam_handle.go
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"time"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+)
+
+const vlanEnable = true
+const vlanIdManagement = 4090
+
+var svlanTagAuth = []byte{0x88, 0xa8, 0x0f, 0xfb}
+
+// IfName is a Interface Name of this device
+var IfName string
+
+// SrcMac is a MAC address of this device
+var SrcMac string
+
+var l2oamHandle *L2oamHandle
+
+// GetL2oamHandle returns my handle
+func GetL2oamHandle() *L2oamHandle {
+	return l2oamHandle
+}
+
+// L2oamHandle contains handle information
+type L2oamHandle struct {
+	Handle *pcap.Handle
+	ReqCh  chan []byte
+}
+
+// NewL2oamHandle L2oamHandle created
+func NewL2oamHandle(ctx context.Context, ifname string, srcMac string) {
+	logger.Debug(ctx, fmt.Sprintf("L2oamHandle start. ifname=%s, srcMac=%s", ifname, srcMac))
+	IfName = ifname
+	SrcMac = srcMac
+	if GetL2oamHandle() == nil {
+		handle, _ := pcap.OpenLive(IfName, int32(1500), false, time.Millisecond*1000)
+		l2oamHandle = &L2oamHandle{
+			Handle: handle,
+			ReqCh:  make(chan []byte),
+		}
+		if handle == nil {
+			logger.Debug(ctx, "could not get pcap handle.")
+		} else {
+			go l2oamHandle.startThread(context.Background())
+		}
+	}
+}
+
+// because of each handle object that is provided for a device receive messages respectively,
+// call this method using goroutine
+func (h *L2oamHandle) startThread(ctx context.Context) {
+	logger.Debug(ctx, "L2oamHandle thread start. ")
+
+	var filter string = "ether proto 0xa8c8 or 0x888e or 0x8100 or 0x88a8"
+	err := h.Handle.SetBPFFilter(filter)
+	if err != nil {
+		logger.Error(ctx, "Error: Handle.SetBPFFilter")
+	}
+
+	packetSource := gopacket.NewPacketSource(h.Handle, h.Handle.LinkType())
+
+	for {
+		select {
+		// send a message directly using send method, not sending it via channels
+		case message := <-h.ReqCh:
+			logger.Debug(ctx, fmt.Sprintf("gopacket send. %x", message))
+			if err := h.Handle.WritePacketData(message); err != nil {
+				logger.Debug(ctx, "write-packet-error")
+			}
+		// Packets are received
+		case packet := <-packetSource.Packets():
+			etherLayer := packet.Layer(layers.LayerTypeEthernet)
+			logger.Debug(ctx, fmt.Sprintf("gopacket receive. %x", etherLayer))
+			if etherLayer != nil {
+				// type assertion
+				etherPacket, _ := etherLayer.(*layers.Ethernet)
+				packetBytes := append(etherPacket.Contents, etherPacket.Payload...)
+				logger.Debug(ctx, fmt.Sprintf("gopacket ether receive. %x", packetBytes))
+				if vlanEnable {
+					h.dispatchVlan(ctx, etherPacket)
+				} else {
+					h.dispatch(ctx, etherPacket)
+				}
+			}
+		}
+	}
+}
+func (h *L2oamHandle) dispatch(ctx context.Context, etherPacket *layers.Ethernet) {
+	logger.Debug(ctx, fmt.Sprintf("dispatch(). %x", etherPacket))
+
+	etherType := uint16(etherPacket.EthernetType)
+	if etherType == uint16(layers.EthernetTypeEAPOL) {
+		logger.Debug(ctx, fmt.Sprintf("receive message = EAPOL, Contents=%x, Payload=%x", etherPacket.Contents, etherPacket.Payload))
+		device := FindL2oamDevice(hex.EncodeToString(etherPacket.SrcMAC))
+		if device == nil {
+			// unregisterd device
+			logger.Error(ctx, fmt.Sprintf("Received from an unregistered device. macAddr=%s", etherPacket.SrcMAC))
+			h.packetIn(etherPacket)
+		} else {
+			device.receiveEapol(etherPacket)
+		}
+
+	} else if etherType == 0xa8c8 {
+		bytes := etherPacket.Payload
+		opcode := bytes[0]
+		oampduCode := bytes[3]
+		logger.Debug(ctx, fmt.Sprintf("receive message = 1904.2 OAM opcode=%v oampduCode=%v,  %x", opcode, oampduCode, bytes))
+
+		device := FindL2oamDevice(hex.EncodeToString(etherPacket.SrcMAC))
+		if device == nil {
+			// unregisterd device
+			logger.Error(ctx, fmt.Sprintf("Received from an unregistered device. macAddr=%s", etherPacket.SrcMAC))
+			return
+		}
+
+		// OAM: keep-alive message
+		if opcode == 0x03 && oampduCode == 0x00 {
+			device.recieveKeepAlive(etherPacket)
+
+		} else {
+			device.recieve(etherPacket)
+		}
+	} else if etherType == uint16(layers.EthernetTypeDot1Q) {
+		device := FindL2oamDevice(hex.EncodeToString(etherPacket.SrcMAC))
+		if device == nil {
+			// unregisterd device
+			logger.Error(ctx, fmt.Sprintf("Received from an unregistered device. macAddr=%s", etherPacket.SrcMAC))
+			h.packetIn(etherPacket)
+		} else {
+			device.receiveEapol(etherPacket)
+		}
+
+	} else {
+		logger.Error(ctx, fmt.Sprintf("unknown etherType = 0x%X", etherType))
+	}
+}
+func (h *L2oamHandle) dispatchVlan(ctx context.Context, etherPacket *layers.Ethernet) {
+	logger.Debug(ctx, fmt.Sprintf("dispatchVlan(). %x", etherPacket))
+
+	etherType := uint16(etherPacket.EthernetType)
+	if etherType == uint16(layers.EthernetTypeQinQ) {
+		// Remove the VLAN tag
+		vlanPacket := &layers.Dot1Q{}
+		if err := vlanPacket.DecodeFromBytes(etherPacket.Payload, nil); err != nil {
+			logger.Debug(ctx, fmt.Sprintf("error:%v", err))
+		}
+		etherBytes := etherPacket.Contents
+		binary.BigEndian.PutUint16(etherBytes[12:], uint16(vlanPacket.Type))
+		packetBytes := append(etherBytes, vlanPacket.Payload...)
+		etherPacket = &layers.Ethernet{}
+		if err := etherPacket.DecodeFromBytes(packetBytes, nil); err != nil {
+			logger.Debug(ctx, fmt.Sprintf("error:%v", err))
+		}
+		h.dispatch(ctx, etherPacket)
+	} else {
+		logger.Error(ctx, fmt.Sprintf("Discard unsupported etherType. 0x%X", etherType))
+	}
+}
+
+func (h *L2oamHandle) send(message []byte) {
+	if h.Handle != nil {
+		h.ReqCh <- message
+	}
+}
+func (h *L2oamHandle) packetIn(etherPacket *layers.Ethernet) {
+	packetBytes := append(etherPacket.Contents, etherPacket.Payload...)
+	pktInd := &oop.PacketIndication{
+		IntfId:    0,
+		GemportId: 1,
+		PortNo:    16,
+		Pkt:       packetBytes,
+		IntfType:  "pon",
+	}
+	logger.Info(context.Background(), fmt.Sprintf("L2oamHandle.packetIn() pktInd=%x", pktInd))
+
+	if err := l2oamDeviceHandler.handlePacketIndication(context.Background(), pktInd); err != nil {
+		logger.Error(context.Background(), "L2oamHandle.packetIn() error. ")
+	}
+}
diff --git a/internal/pkg/core/l2oam_if.go b/internal/pkg/core/l2oam_if.go
new file mode 100644
index 0000000..87daab5
--- /dev/null
+++ b/internal/pkg/core/l2oam_if.go
@@ -0,0 +1,1339 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/db/kvstore"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/core/l2oam"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+func readTechProfile() {
+	address := "172.17.0.1:2379"
+	timeout := time.Second * 10
+
+	client, err := kvstore.NewEtcdClient(context.Background(), address, timeout, log.FatalLevel)
+	if err != nil {
+		return
+	}
+	defer client.Close(context.Background())
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	resp, err := client.Get(ctx, "service/voltha/technology_profiles/EPON/64")
+	cancel()
+	if resp == nil || err != nil {
+		l2oam.OnuPkgType = l2oam.OnuPkgTypeB
+		logger.Error(ctx, fmt.Sprintf("readTechProfile() etcd get error. resp=%v, err=%v", resp, err))
+		return
+	}
+	bytes := resp.Value.([]byte)
+	bytesString := string(bytes)
+	logger.Debug(ctx, fmt.Sprintf("readTechProfile() bytes string=%s", bytesString))
+	if strings.Index(bytesString, "\"profile_type\":\"EPON\"") > 0 && strings.Index(bytesString, "\"package_type\":\"B\"") > 0 {
+		l2oam.OnuPkgType = l2oam.OnuPkgTypeB
+	} else {
+		l2oam.OnuPkgType = l2oam.OnuPkgTypeA
+	}
+	logger.Debug(ctx, fmt.Sprintf("readTechProfile() onu package=%s", l2oam.OnuPkgType))
+
+}
+
+// L2oamGetDeviceInfo provides GetDeviceInfo for L2OAM
+func L2oamGetDeviceInfo(ctx context.Context, dh *DeviceHandler) (*oop.DeviceInfo, error) {
+	logger.Debug(ctx, "GetDeviceInfo() Start.")
+	readTechProfile()
+
+	dstMac := dh.device.MacAddress
+	deviceInfo := &oop.DeviceInfo{
+		Vendor: "Tibit",
+		// Model				string	`protobuf:"bytes,2,opt,name=model,proto3" json:"model,omitempty"`
+		// HardwareVersion		string	`protobuf:"bytes,3,opt,name=hardware_version,json=hardwareVersion,proto3" json:"hardware_version,omitempty"`
+		// FirmwareVersion		string	`protobuf:"bytes,4,opt,name=firmware_version,json=firmwareVersion,proto3" json:"firmware_version,omitempty"`
+		DeviceId: dstMac,
+		// DeviceSerialNumber	string	`protobuf:"bytes,17,opt,name=device_serial_number,json=deviceSerialNumber,proto3" json:"device_serial_number,omitempty"`
+		PonPorts:       1,
+		Technology:     "EPON",
+		OnuIdStart:     1,
+		OnuIdEnd:       128,
+		AllocIdStart:   5121,
+		AllocIdEnd:     9216,
+		GemportIdStart: 1,
+		GemportIdEnd:   65535,
+		FlowIdStart:    1,
+		FlowIdEnd:      16383,
+		// Ranges				[]*DeviceInfo_DeviceResourceRanges	protobuf:"bytes,15,rep,name=ranges,proto3" json:"ranges,omitempty"`
+	}
+	olt := FindL2oamDevice(dstMac)
+	if olt == nil {
+		olt, _ = NewL2oamOltDevice(dstMac, dh)
+		olt.startKeepAlive()
+	}
+
+	err00 := sendDiscoverySOLICIT(ctx, olt)
+	logger.Debug(ctx, fmt.Sprintf("Sequence returts: %v", err00))
+	vendorName, err01 := sendGetVendorName(ctx, olt)
+	moduleNumber, err02 := sendGetModuleNumber(ctx, olt)
+	manuFacturer, err03 := sendManuFacturerInfo(ctx, olt)
+	firmwareVersion, err04 := sendGetFirmwareVersion(ctx, olt)
+	macAddress, err05 := sendGetMacAddress(ctx, olt)
+	serialNumber, err06 := sendGetSerialNumber(ctx, olt)
+	deviceInfo.Vendor = vendorName
+	deviceInfo.Model = moduleNumber
+	deviceInfo.HardwareVersion = manuFacturer
+	deviceInfo.FirmwareVersion = firmwareVersion
+	deviceInfo.DeviceId = macAddress
+	deviceInfo.DeviceSerialNumber = serialNumber
+	logger.Debug(ctx, fmt.Sprintf("Sequence returts: deviceInfo=%v, %v, %v, %v, %v, %v, %v, %v", deviceInfo, err00, err01, err02, err03, err04, err05, err06))
+
+	dh.device.SerialNumber = deviceInfo.DeviceSerialNumber
+	olt.setActiveState(ctx, true)
+	return deviceInfo, nil
+}
+
+// L2oamEnableIndication runs EnableIndication sequence
+func L2oamEnableIndication(ctx context.Context, dh *DeviceHandler) {
+	logger.Debug(ctx, "L2oamEnableIndication() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamEnableIndication() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return
+	}
+
+	err01 := sendSetHbtxPeriod(ctx, olt)
+	err02 := sendSetHbtxTemplate(ctx, olt)
+	ponMode, err03 := sendGetPonMode(ctx, olt)
+	err04 := sendSetMPCPSync(ctx, olt)
+	err05 := sendSetAdminState(ctx, olt, true)
+	ponPortAction := sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeProtocolFilter)
+	if ponPortAction == nil {
+		return
+	}
+	actionIDPonPort := binary.BigEndian.Uint32(ponPortAction.GetTrafficProfile())
+	err07 := sendSetIngressPort(ctx, olt, actionIDPonPort, true)
+	err08 := sendSetCaptureProtocols(ctx, olt, actionIDPonPort)
+	ethPortAction := sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeProtocolFilter)
+	if ethPortAction == nil {
+		return
+	}
+	actionIDEthPort := binary.BigEndian.Uint32(ethPortAction.GetTrafficProfile())
+	err09 := sendSetIngressPort(ctx, olt, actionIDEthPort, false)
+	err10 := sendSetCaptureProtocols(ctx, olt, actionIDEthPort)
+
+	oltDev := olt.(*L2oamOltDevice)
+	oltDev.Base.ActionIds = make(map[int]uint32)
+	oltDev.Base.ActionIds[ActionIDFilterPonPort] = actionIDPonPort
+	oltDev.Base.ActionIds[ActionIDFilterEthPort] = actionIDEthPort
+	olt.updateMap()
+
+	err06 := sendSetAdminState(ctx, olt, false)
+	olt.setAutonomousFlag(true)
+
+	logger.Debug(ctx, fmt.Sprintf("Sequence returns: ponMode=%s, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v",
+		ponMode, err01, err02, err03, err04, err05, err06, err07, err08, err09, err10))
+
+}
+
+// L2oamAfterKeepAlive ... [obsoluted]
+func L2oamAfterKeepAlive(ctx context.Context, dh *DeviceHandler) error {
+
+
+
+	return nil
+}
+
+//var flowVersion int = 1 // run add-flow each OLT
+//var flowVersion int = 2 // run add-flow each ONU
+var flowVersion int = 3 // run add-flow at specified ONU
+
+// L2oamAddFlow runs add-flow sequence
+func L2oamAddFlow(ctx context.Context, dh *DeviceHandler, cmd *L2oamCmd) {
+	logger.Debug(ctx, "L2oamAddFlow() Start.")
+	if cmd.OnuDeviceID == "" {
+		flowVersion = 2
+	} else {
+		flowVersion = 3
+	}
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamAddFlow() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return
+	}
+
+	if flowVersion == 1 {
+		oc := &l2oam.TomiObjectContext{
+			Branch:   0x0c,
+			Type:     0x0011,
+			Length:   4,
+			Instance: 0x00000002,
+		}
+		getTrafficControl := sendGetTrafficControlReferenceTable(ctx, olt, oc)
+		if getTrafficControl == nil {
+			logger.Error(ctx, "L2oamAddFlow() sendGetTrafficControlReferenceTable() error. ")
+			return
+		}
+		downProfile := sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeTrafficProfile)
+		if downProfile == nil {
+			logger.Error(ctx, "L2oamAddFlow() sendSetGenericActionCreate(down) error. ")
+			return
+		}
+		upProfile := sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeTrafficProfile)
+		if upProfile == nil {
+			logger.Error(ctx, "L2oamAddFlow() sendSetGenericActionCreate(up) error. ")
+			return
+		}
+		olt.setReferenceTable(getTrafficControl)
+		olt.setProfile(downProfile, upProfile)
+		olt.updateMap()
+
+		err01 := sendSetTrafficControl(ctx, olt, getTrafficControl.GetReferenceControlDown(), downProfile.GetTrafficProfile())
+		err02 := sendSetTrafficControl(ctx, olt, getTrafficControl.GetReferenceControlUp(), upProfile.GetTrafficProfile())
+
+		err03 := sendSetPriority(ctx, olt, downProfile.GetTrafficProfile())
+		err04 := sendSetGuranteedRate(ctx, olt, cmd.Cir, downProfile.GetTrafficProfile())
+		err05 := sendSetGuranteedRate(ctx, olt, cmd.Cir, upProfile.GetTrafficProfile())
+		err06 := sendSetBestEffortRate(ctx, olt, cmd.Pir, downProfile.GetTrafficProfile())
+		err07 := sendSetBestEffortRate(ctx, olt, cmd.Pir, upProfile.GetTrafficProfile())
+
+		logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v, %v, %v, %v, %v, %v", err01, err02, err03, err04, err05, err06, err07))
+	} else if flowVersion == 2 {
+		// add-flow to all ONUs
+		// Traffic Profile(priority, guranteed rate, best effort rate) are set as common settings
+		onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-child-devices: %v", err))
+			return
+		}
+
+		isFirst := true
+		var downProfile *l2oam.SetGenericActionCreateRes
+		var upProfile *l2oam.SetGenericActionCreateRes
+		for _, onuDevice := range onuDevices.Items {
+			//onu := FindL2oamDevice(onuDevice.MacAddress)
+			onu := FindL2oamDeviceByDeviceID(onuDevice.Id)
+			if onu == nil {
+				logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-device. device-id:%s, mac-address:%s",
+					onuDevice.Id, onuDevice.MacAddress))
+				continue
+			}
+			if !(onu.(*L2oamOnuDevice)).Base.isActive() {
+				logger.Debug(ctx, fmt.Sprintf("onu is not active. device-id:%s, mac-address:%s",
+					onuDevice.Id, onuDevice.MacAddress))
+				continue
+			}
+			logger.Debug(ctx, fmt.Sprintf("add-flow-for-onu. device-id:%s, mac-address:%s",
+				onuDevice.Id, onuDevice.MacAddress))
+
+			oc := onu.getObjectContext()
+			if oc == nil {
+				logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-object-context. device-id:%s, mac-address:%s",
+					onuDevice.Id, onuDevice.MacAddress))
+				continue
+			}
+			getTrafficControl := sendGetTrafficControlReferenceTable(ctx, olt, oc)
+			if getTrafficControl == nil {
+				logger.Error(ctx, "L2oamAddFlow() sendGetTrafficControlReferenceTable() error. ")
+				continue
+			}
+			onu.setReferenceTable(getTrafficControl)
+			onu.updateMap()
+
+			// create one Traffic Profile at OLT
+			if isFirst {
+				downProfile = sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeTrafficProfile)
+				if downProfile == nil {
+					logger.Error(ctx, "L2oamAddFlow() sendSetGenericActionCreate(down) error. ")
+					break
+				}
+				upProfile = sendSetGenericActionCreate(ctx, olt, l2oam.ActionTypeTrafficProfile)
+				if upProfile == nil {
+					logger.Error(ctx, "L2oamAddFlow() sendSetGenericActionCreate(up) error. ")
+					break
+				}
+				olt.setProfile(downProfile, upProfile)
+				olt.updateMap()
+			}
+
+			err01 := sendSetTrafficControl(ctx, olt, getTrafficControl.GetReferenceControlDown(), downProfile.GetTrafficProfile())
+			err02 := sendSetTrafficControl(ctx, olt, getTrafficControl.GetReferenceControlUp(), upProfile.GetTrafficProfile())
+			logger.Debug(ctx, fmt.Sprintf("traffic-control/traffic-profile results: %v, %v", err01, err02))
+
+			if isFirst {
+				err03 := sendSetPriority(ctx, olt, downProfile.GetTrafficProfile())
+				err04 := sendSetGuranteedRate(ctx, olt, cmd.Cir, downProfile.GetTrafficProfile())
+				err05 := sendSetGuranteedRate(ctx, olt, cmd.Cir, upProfile.GetTrafficProfile())
+				err06 := sendSetBestEffortRate(ctx, olt, cmd.Pir, downProfile.GetTrafficProfile())
+				err07 := sendSetBestEffortRate(ctx, olt, cmd.Pir, upProfile.GetTrafficProfile())
+				isFirst = false
+				logger.Debug(ctx, fmt.Sprintf("traffic-profile-settings-results: %v, %v, %v, %v, %v",
+					err03, err04, err05, err06, err07))
+			}
+		}
+	} else if flowVersion == 3 {
+		if err := olt.addFlow(ctx, cmd); err != nil {
+			logger.Errorf(ctx, "failed-to-add-flow: %v", err)
+		}
+	}
+}
+
+// L2oamAddFlowAndMount adds flow to device and start mount sequence
+func (d *DeviceHandler) L2oamAddFlowAndMount(ctx context.Context, onuDeviceID string, vid []byte, ivid []byte) {
+	l2oamCmd := &L2oamCmd{
+		Type:        "add-flow-dev",
+		Tpid:        []byte{0x88, 0xa8},
+		Vid:         vid,
+		Itpid:       []byte{0x81, 0x00},
+		Ivid:        ivid,
+		OnuDeviceID: onuDeviceID,
+	}
+	olt := FindL2oamDeviceByDeviceID(d.device.Id)
+	if olt == nil {
+		logger.Errorf(ctx, "olt not found.")
+	}
+	if err := olt.updateFlow(ctx, l2oamCmd); err != nil {
+		logger.Errorf(ctx, "failed-to-update-flow. %v", err)
+	} else {
+		onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+		if onu == nil {
+			logger.Debug(ctx, fmt.Sprintf("L2oamAddFlowAndMount() FindL2oamDevice() onu not found. deviceId=%s", onuDeviceID))
+		} else {
+			// start ONU mount sequence
+			onu.startMountSequence(ctx, l2oam.OnuPkgType, l2oamCmd)
+		}
+	}
+}
+
+// L2oamAddFlowToDeviceAll adds a flow to specified device.
+// If some flows are added already, all flows are removed from all devices before adding.
+func L2oamAddFlowToDeviceAll(ctx context.Context, dh *DeviceHandler, cmd *L2oamCmd) error {
+	logger.Debug(ctx, "L2oamAddFlowToDeviceAll() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamAddFlowToDeviceAll() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return nil
+	}
+
+	oc := olt.getObjectContext()
+	var onuList []*L2oamOnuDevice
+	onuDeviceID := cmd.OnuDeviceID
+	onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+	if onu == nil {
+		return nil
+	}
+	onuDev, ok := onu.(*L2oamOnuDevice)
+	if !ok {
+		return nil
+	}
+	if oc != nil {
+		onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
+		if err != nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-child-devices: %v", err))
+			return err
+		}
+		// create flow added onu list
+		reflow := false
+		for _, onuDevice := range onuDevices.Items {
+			//onu := FindL2oamDevice(onuDevice.MacAddress)
+			onu := FindL2oamDeviceByDeviceID(onuDevice.Id)
+			if onu != nil {
+				if onuDev, ok := onu.(*L2oamOnuDevice); ok {
+					if onuDev.Base.FlowAdded {
+						onuList = append(onuList, onuDev)
+						if onuDeviceID == onuDev.Base.DeviceID {
+							reflow = true
+						}
+					}
+				}
+			}
+		}
+		if !reflow {
+			onuList = append(onuList, onuDev)
+		}
+		L2oamRemoveFlowFromDevice(ctx, dh, onuDevices)
+	} else {
+		onuList = append(onuList, onuDev)
+	}
+	localCmd := *cmd
+	for _, onuDev := range onuList {
+		localCmd.OnuDeviceID = onuDev.Base.DeviceID
+		if err := L2oamAddFlowToDevice(ctx, dh, &localCmd); err != nil {
+			continue
+		}
+	}
+
+	return nil
+}
+
+// L2oamAddFlowToDevice runs add-flow-device sequence
+func L2oamAddFlowToDevice(ctx context.Context, dh *DeviceHandler, cmd *L2oamCmd) error {
+	if flowVersion == 1 {
+		oc := L2oamAddFlowToDeviceDS(ctx, dh, cmd)
+		if oc == nil {
+			return errors.New("failed-to-add-flow-to-device-for-down-stream")
+		}
+		L2oamAddFlowToDeviceUS(ctx, dh, oc, cmd)
+	} else if flowVersion > 1 {
+		logger.Debug(ctx, "L2oamAddFlowToDevice() Start.")
+
+		olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+		if olt == nil {
+			logger.Error(ctx, fmt.Sprintf("L2oamAddFlowToDevice() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+			return nil
+		}
+
+		// add flow for downstream
+		oc := olt.getObjectContext()
+		var err01 error
+		var err02 error
+		onuDeviceID := cmd.OnuDeviceID
+		// "Generic/Action Create, L2 Switching Domain/Action Inlet entry" is created only first
+		if oc == nil {
+			oc, err01 = sendSetGenericActionCreateForDS(ctx, olt)
+			if oc == nil {
+				logger.Error(ctx, fmt.Sprintf("error. %v", err01))
+				return errors.New("failed-to-add-flow-to-device-for-down-stream")
+			}
+			// TODO ignore tpid, vid after the second time
+			err02 = sendSetL2SwitchingDomainForDS(ctx, olt, oc, cmd.Tpid, cmd.Vid)
+			olt.setL2oamCmd(cmd)
+			olt.setObjectContext(oc)
+			if oltDev, ok := olt.(*L2oamOltDevice); ok {
+				oltDev.Base.FlowAdded = true
+			}
+			olt.updateMap()
+		} else {
+			cmd = olt.getL2oamCmd()
+		}
+
+		onu := FindL2oamDeviceByDeviceID(onuDeviceID)
+		if onu == nil {
+			logger.Debug(ctx, fmt.Sprintf("L2oamCmdRequest() FindL2oamDevice() onu not found. deviceId=%s", onuDeviceID))
+		} else {
+			onuID := onu.getObjectContext()
+			if onuID == nil {
+				logger.Error(ctx, "catnnot-get-onu-object-context.")
+			} else {
+				err03 := sendSetDefaultOutlet(ctx, olt, oc, onuID)
+				err04 := sendSetL2SwitchingDomainForUS(ctx, olt, oc, cmd.Tpid, cmd.Vid, onuID)
+
+				logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v, %v, %v", err01, err02, err03, err04))
+				if onuDev, ok := onu.(*L2oamOnuDevice); ok {
+					onuDev.Base.FlowAdded = true
+					onu.updateMap()
+				} else {
+					logger.Error(ctx, fmt.Sprintf("assertion failed. device-id:%s", onuDeviceID))
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// L2oamAddFlowToDeviceDS runs add-flow-device sequence for downstream
+func L2oamAddFlowToDeviceDS(ctx context.Context, dh *DeviceHandler, cmd *L2oamCmd) *l2oam.TomiObjectContext {
+	logger.Debug(ctx, "L2oamAddFlowToDeviceDS() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamAddFlowToDeviceDS() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+
+	oc, err01 := sendSetGenericActionCreateForDS(ctx, olt)
+	if oc != nil {
+		onuID := &l2oam.TomiObjectContext{
+			Branch:   0x0c,
+			Type:     0x0011,
+			Length:   4,
+			Instance: 0x00000001,
+		}
+		err02 := sendSetL2SwitchingDomainForDS(ctx, olt, oc, cmd.Tpid, cmd.Vid)
+		err03 := sendSetDefaultOutlet(ctx, olt, oc, onuID)
+		logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v, %v", err01, err02, err03))
+	} else {
+		logger.Debug(ctx, fmt.Sprintf("Sequence results: %v", err01))
+	}
+	olt.setL2oamCmd(cmd)
+	olt.setObjectContext(oc)
+	olt.updateMap()
+
+	return oc
+}
+
+// L2oamAddFlowToDeviceUS runs add-flow-device sequence for upstream
+func L2oamAddFlowToDeviceUS(ctx context.Context, dh *DeviceHandler, oc *l2oam.TomiObjectContext, cmd *L2oamCmd) {
+	logger.Debug(ctx, "L2oamAddFlowToDeviceUS() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamAddFlowToDeviceUS() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+
+	onuID := &l2oam.TomiObjectContext{
+		Branch:   0x0c,
+		Type:     0x0011,
+		Length:   4,
+		Instance: 0x00000002,
+	}
+	err01 := sendSetL2SwitchingDomainForUS(ctx, olt, oc, cmd.Tpid, cmd.Vid, onuID)
+
+	logger.Debug(ctx, fmt.Sprintf("Sequence results: %v", err01))
+}
+
+// L2oamRebootDevice reboots the device
+func L2oamRebootDevice(ctx context.Context, dh *DeviceHandler, device *voltha.Device) {
+	logger.Debug(ctx, "L2oamRebootDevice() Start.")
+
+	L2oamDisableOlt(ctx, dh)
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamRebootDevice() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return
+	}
+
+	err01 := sendSetActionReset(ctx, olt)
+
+	logger.Debug(ctx, fmt.Sprintf("Sequence results: %v", err01))
+
+}
+
+// L2oamDeleteOlt deletes the OLT device
+func L2oamDeleteOlt(ctx context.Context, dh *DeviceHandler) {
+	logger.Debug(ctx, fmt.Sprintf("L2oamDeleteOlt() Start. deviceId=%s", dh.device.Id))
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamDeleteOlt() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return
+	}
+	olt.setAutonomousFlag(false)
+	if !SetupL2oamDeleteFlag(dh.device.Id) {
+		logger.Warn(ctx, fmt.Sprintf("L2oamDeleteOlt() olt deleted deviceId=%s", dh.device.Id))
+		return
+	}
+	err01 := sendSetAdminState(ctx, olt, true)
+	DeleteAllDevice()
+
+	logger.Debug(ctx, fmt.Sprintf("L2oamDeleteOlt() End. deviceId=%s, %v", dh.device.Id, err01))
+}
+
+// L2oamDisableOlt disables the OLT device
+func L2oamDisableOlt(ctx context.Context, dh *DeviceHandler) {
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamDisableOlt() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+		return
+	}
+	olt.setAutonomousFlag(false)
+
+	onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("catnnot-get-child-devices: %v", err))
+	}
+
+	if err = olt.removeFlow(ctx); err != nil {
+		logger.Error(ctx, fmt.Sprintf("failed-to-remove-flows: %v", err))
+	}
+	L2oamRemoveFlow(ctx, dh, onuDevices)
+	L2oamChildDeviceLost(ctx, dh, onuDevices)
+	L2oamDisableDevice(ctx, dh)
+	resetFlowMap()
+}
+
+// L2oamRemoveFlowFromDevice removes flows from the device
+func L2oamRemoveFlowFromDevice(ctx context.Context, dh *DeviceHandler, onuDevices *voltha.Devices) {
+	logger.Debug(ctx, "L2oamRemoveFlowFromDeviceDS() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamRemoveFlowFromDeviceDS() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+	oc := olt.getObjectContext()
+	cmd := olt.getL2oamCmd()
+	if cmd == nil {
+		logger.Warn(ctx, fmt.Sprintf("L2oamRemoveFlowFromDeviceDS() tpid, vid are not specified. deviceId=%s",
+			dh.device.Id))
+		return
+	}
+	logger.Debug(ctx, fmt.Sprintf("TPID:%v, VID:%v", cmd.Tpid, cmd.Vid))
+
+	for _, onuDevice := range onuDevices.Items {
+		//onu := FindL2oamDevice(onuDevice.MacAddress)
+		onu := FindL2oamDeviceByDeviceID(onuDevice.Id)
+		if onu == nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-device. device-id:%s, mac-address:%s",
+				onuDevice.Id, onuDevice.MacAddress))
+			continue
+		}
+		var onuDev *L2oamOnuDevice
+		var ok bool
+		if onuDev, ok = onu.(*L2oamOnuDevice); ok {
+			if !onuDev.Base.FlowAdded {
+				logger.Error(ctx, fmt.Sprintf("flow is not added. device-id:%s, mac-address:%s",
+					onuDevice.Id, onuDevice.MacAddress))
+				continue
+			}
+		} else {
+			logger.Error(ctx, fmt.Sprintf("assertion failed. device-id:%s, mac-address:%s",
+				onuDevice.Id, onuDevice.MacAddress))
+			continue
+		}
+		onuID := onu.getObjectContext()
+		if onuID == nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-object-context. device-id:%s, mac-address:%s",
+				onuDevice.Id, onuDevice.MacAddress))
+			continue
+		}
+		logger.Debug(ctx, fmt.Sprintf("Switching Domain/Action Remove Inlet entry. device-id:%s, instance-id:%d",
+			onuDevice.Id, onuID.Instance))
+		err := sendSetActionInletEntryUsDel(ctx, olt, oc, cmd.Tpid, cmd.Vid, onuID)
+		logger.Debug(ctx, fmt.Sprintf("Sequence results: %v", err))
+		onuDev.Base.FlowAdded = false
+		onu.updateMap()
+	}
+
+	if oltDev, ok := olt.(*L2oamOltDevice); ok {
+		if oltDev.Base.FlowAdded {
+			err02 := sendSetActionInletEntryDsDel(ctx, olt, oc, cmd.Tpid, cmd.Vid)
+			err03 := sendSetActionDeleteStream(ctx, olt, oc)
+
+			logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v", err02, err03))
+			olt.setObjectContext(nil)
+			oltDev.Base.FlowAdded = false
+			olt.updateMap()
+		} else {
+			logger.Debug(ctx, fmt.Sprintf("flow is not added. device-id:%s", dh.device.Id))
+		}
+	} else {
+		logger.Debug(ctx, fmt.Sprintf("assersion failed. device-id:%s", dh.device.Id))
+	}
+}
+
+// L2oamRemoveFlow removes flows
+func L2oamRemoveFlow(ctx context.Context, dh *DeviceHandler, onuDevices *voltha.Devices) {
+	logger.Debug(ctx, "L2oamRemoveFlow() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamRemoveFlow() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+
+	if flowVersion == 2 {
+		//refTbl := olt.getReferenceTable()
+		downProfile, upProfile := olt.getProfile()
+		//if refTbl == nil || downProfile == nil || upProfile == nil {
+		if downProfile == nil || upProfile == nil {
+			logger.Warn(ctx, fmt.Sprintf("L2oamRemoveFlow() profiles are not specified. deviceId=%s",
+				dh.device.Id))
+			return
+		}
+		downInstanceID := downProfile.GetTrafficProfile()
+		upInstanceID := upProfile.GetTrafficProfile()
+		//err01 := sendSetTrafficProfile(ctx, olt,
+		//	refTbl.GetReferenceControlDown(), downInstanceId)
+		//err02 := sendSetTrafficProfile(ctx, olt,
+		//	refTbl.GetReferenceControlUp(), upInstanceId)
+		err03 := sendSetActionDelete(ctx, olt, downInstanceID, l2oam.ActionTypeTrafficProfile)
+		err04 := sendSetActionDelete(ctx, olt, upInstanceID, l2oam.ActionTypeTrafficProfile)
+		olt.setProfile(nil, nil)
+		olt.updateMap()
+
+		//logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v, %v, %v", err01, err02, err03, err04))
+		logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v", err03, err04))
+	} else if flowVersion == 3 {
+		for _, onuDevice := range onuDevices.Items {
+			logger.Debugf(ctx, "remove-traffic-schedule. onu-device-id:%s", onuDevice.Id)
+			onu := FindL2oamDeviceByDeviceID(onuDevice.Id)
+			if onu == nil {
+				logger.Errorf(ctx, "catnnot-get-onu-device")
+				continue
+			}
+			refTbl := onu.getReferenceTable()
+			if refTbl == nil {
+				logger.Debug(ctx, "traffic-profile-is-not-created")
+				continue
+			}
+			downProfile, upProfile := onu.getProfile()
+			if downProfile == nil || upProfile == nil {
+				logger.Debug(ctx, "flow is not added")
+				continue
+			}
+			downInstanceID := downProfile.GetTrafficProfile()
+			upInstanceID := upProfile.GetTrafficProfile()
+			err01 := sendSetTrafficProfile(ctx, olt,
+				refTbl.GetReferenceControlDown(), downInstanceID)
+			err02 := sendSetTrafficProfile(ctx, olt,
+				refTbl.GetReferenceControlUp(), upInstanceID)
+			err03 := sendSetActionDelete(ctx, olt, downInstanceID, l2oam.ActionTypeTrafficProfile)
+			err04 := sendSetActionDelete(ctx, olt, upInstanceID, l2oam.ActionTypeTrafficProfile)
+			onu.setReferenceTable(nil)
+			onu.setProfile(nil, nil)
+			onu.updateMap()
+			logger.Debug(ctx, fmt.Sprintf("remove-traffic-schedule-results: %v, %v, %v, %v", err01, err02, err03, err04))
+		}
+	}
+}
+
+// L2oamChildDeviceLost sends DeviceLost message
+func L2oamChildDeviceLost(ctx context.Context, dh *DeviceHandler, onuDevices *voltha.Devices) {
+	logger.Debug(ctx, "L2oamChildDeviceLost() Start.")
+	if onuDevices == nil {
+		return
+	}
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamChildDeviceLost() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+
+	for _, onuDevice := range onuDevices.Items {
+		//onu := FindL2oamDevice(onuDevice.MacAddress)
+		onu := FindL2oamDeviceByDeviceID(onuDevice.Id)
+		if onu == nil {
+			logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-device. device-id:%s, mac-address:%s",
+				onuDevice.Id, onuDevice.MacAddress))
+		} else {
+			oc := onu.getObjectContext()
+			if oc == nil {
+				logger.Error(ctx, fmt.Sprintf("catnnot-get-onu-object-context. device-id:%s, mac-address:%s",
+					onuDevice.Id, onuDevice.MacAddress))
+			} else {
+				logger.Debug(ctx, fmt.Sprintf("onu-object-context. instance-id:%x", oc.Instance))
+				err01 := sendSetActionDeleteOnu(ctx, olt, oc)
+
+				logger.Debug(ctx, fmt.Sprintf("Sequence results: %v", err01))
+			}
+		}
+	}
+}
+
+// L2oamDisableDevice disables the device
+func L2oamDisableDevice(ctx context.Context, dh *DeviceHandler) {
+	logger.Debug(ctx, "L2oamDisableDevice() Start.")
+
+	olt := FindL2oamDeviceByDeviceID(dh.device.Id)
+	if olt == nil {
+		logger.Error(ctx, fmt.Sprintf("L2oamDisableDevice() FindL2oamDeviceByDeviceId() error. olt not found. deviceId=%s", dh.device.Id))
+	}
+
+	oltDev := olt.(*L2oamOltDevice)
+	if oltDev.Base.ActionIds != nil {
+		var bytes [4]byte
+		if id, ok := oltDev.Base.ActionIds[ActionIDFilterPonPort]; ok {
+			binary.BigEndian.PutUint32(bytes[:], id)
+			if err := sendSetActionDelete(ctx, olt, bytes[:], l2oam.ActionTypeProtocolFilter); err != nil {
+				return
+			}
+		}
+		if id, ok := oltDev.Base.ActionIds[ActionIDFilterEthPort]; ok {
+			binary.BigEndian.PutUint32(bytes[:], id)
+			if err := sendSetActionDelete(ctx, olt, bytes[:], l2oam.ActionTypeProtocolFilter); err != nil {
+				return
+			}
+		}
+		oltDev.Base.ActionIds = nil
+		olt.updateMap()
+	}
+	err01 := sendSetAdminState(ctx, olt, true)
+	err02 := sendSetManagementLock(ctx, olt)
+
+	logger.Debug(ctx, fmt.Sprintf("Sequence results: %v, %v", err01, err02))
+}
+
+func sendDiscoverySOLICIT(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateDiscoverySOLICIT()); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendDiscoverySOLICIT() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.DiscoveryHello{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendDiscoverySOLICIT() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return nil
+}
+
+func sendGetVendorName(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GnerateGetVendorName()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetVendorName() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetVendorNameRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetVendorName() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetVendorName(), nil
+}
+
+func sendGetModuleNumber(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateGetModuleNumber()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetModuleNumber() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.GetModuleNumberRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetModuleNumber() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetModuleNumber(), nil
+}
+
+func sendManuFacturerInfo(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateManuFacturerInfo()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendManuFacturerInfo() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetManufacturerRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendManuFacturerInfo() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetManufacturer(), nil
+}
+
+func sendGetFirmwareVersion(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateGetFirmwareVersion()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetFirmwareVersion() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetFirmwareVersionRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetFirmwareVersion() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetFirmwareVersionNumber(), nil
+}
+
+func sendGetMacAddress(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateGetMacAddress()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetMacAddress() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetMacAddressRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetMacAddress() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetMacAddress(), nil
+}
+
+func sendGetSerialNumber(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateGetSerialNumber()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetSerialNumber() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetSerialNumberRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetSerialNumber() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetSerialNumber(), nil
+}
+
+func sendSetHbtxTemplate(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateSetHbtxTemplate()); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetHbtxTemplate() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetHbtxTemplate() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return nil
+}
+
+func sendGetPonMode(ctx context.Context, device L2oamDevice) (string, error) {
+	if err := device.send(l2oam.GenerateGetPonMode()); err != nil {
+		return "", nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return "", fmt.Errorf("[%s] sendGetPonMode() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.GetPonMode{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return "", nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendGetPonMode() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return packet.GetPonMode(), nil
+}
+
+func sendSetMPCPSync(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateSetMPCPSync()); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetMPCPSync() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetMPCPSync() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return nil
+}
+
+func sendSetAdminState(ctx context.Context, device L2oamDevice, isDelete bool) error {
+	if isDelete {
+		if err := device.send(l2oam.GenerateSetAdminStateDelete()); err != nil {
+			return nil
+		}
+	} else {
+		if err := device.send(l2oam.GenerateSetAdminState()); err != nil {
+			return nil
+		}
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetAdminState() Send Error: isDelete=%v, %v", device.getDeviceName(), isDelete, err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetAdminState() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return nil
+}
+
+func sendSetHbtxPeriod(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateSetHbtxPeriod()); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetHbtxPeriod() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.TOAMSetResponse{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetHbtxPeriod() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetIngressPort(ctx context.Context, device L2oamDevice, actionID uint32, isPonPort bool) error {
+	if err := device.send(l2oam.GenerateIngressPort(actionID, isPonPort)); err != nil {
+		return nil
+	}
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("sendSetIngressPort() send error. %s ", err))
+		return nil
+	}
+
+	return nil
+}
+
+func sendSetCaptureProtocols(ctx context.Context, device L2oamDevice, actionID uint32) error {
+	if err := device.send(l2oam.GenerateCaptureProtocols(actionID)); err != nil {
+		return nil
+	}
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("sendSetCaptureProtocols() send error. %s ", err))
+		return nil
+	}
+
+	return nil
+}
+
+func sendGetTrafficControlReferenceTable(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext) *l2oam.GetTrafficControlReferenceTableRes {
+	if err := device.send(l2oam.GenerateGetTrafficControlReferenceTableReq(oc)); err != nil {
+		return nil
+	}
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("sendGetTrafficControlReferenceTable() send error. %s ", err))
+		return nil
+	}
+	packet := &l2oam.GetTrafficControlReferenceTableRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	return packet
+}
+
+func sendSetGenericActionCreate(ctx context.Context, device L2oamDevice, actionType int) *l2oam.SetGenericActionCreateRes {
+	if err := device.send(l2oam.GenerateGenericActionCreate(actionType)); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		logger.Error(ctx, fmt.Sprintf("[%s] sendSetGenericActionCreate() Send Error: %v", device.getDeviceName(), err))
+		return nil
+	}
+	packet := &l2oam.SetGenericActionCreateRes{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetGenericActionCreate() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return packet
+}
+
+func sendSetTrafficControl(ctx context.Context, device L2oamDevice, trafficControl []byte, trafficProfile []byte) error {
+
+	if err := device.send(l2oam.GenerateTrafficControlTrafficProfile(trafficControl, trafficProfile)); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetTrafficControl() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetTrafficControl() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetPriority(ctx context.Context, device L2oamDevice, trafficProfile []byte) error {
+	if err := device.send(l2oam.GeneratePriority(trafficProfile)); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetPriority() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetPriority() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetGuranteedRate(ctx context.Context, device L2oamDevice, cir []byte, trafficProfile []byte) error {
+	if err := device.send(l2oam.GenerateGuaranteedRate(cir, trafficProfile)); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetGuranteedRate() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetGuranteedRate() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+// func sendSetGuranteedMbs(ctx context.Context, device L2oamDevice) error {
+// 	if err := device.send(l2oam.GenerateGuaranteedMbs()); err != nil {
+// 		return nil
+// 	}
+
+// 	ether, err := device.waitResponse(ResponseTimer)
+// 	if err != nil {
+// 		return fmt.Errorf("[%s] sendSetGuranteedMbs() Send Error: %v", device.getDeviceName(), err)
+// 	}
+// 	packet := &l2oam.TOAMSetResponse{}
+// 	//packet.Decode(ether.Payload)
+
+// 	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetGuranteedMbs() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+// 	return nil
+// }
+
+func sendSetBestEffortRate(ctx context.Context, device L2oamDevice, pir []byte, trafficProfile []byte) error {
+	if err := device.send(l2oam.GenerateBestEffortRate(pir, trafficProfile)); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetBestEffortRate() Send Error: %v", device.getDeviceName(), err)
+	}
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetBestEffortRate() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+// func sendSetBestEffortMbs(ctx context.Context, device L2oamDevice) error {
+// 	if err := device.send(l2oam.GenerateBestEffortMbs()); err != nil {
+// 		return nil
+// 	}
+
+// 	ether, err := device.waitResponse(ResponseTimer)
+// 	if err != nil {
+// 		return fmt.Errorf("[%s] sendSetBestEffortMbs() Send Error: %v", device.getDeviceName(), err)
+// 	}
+// 	packet := &l2oam.TOAMSetResponse{}
+// 	//packet.Decode(ether.Payload)
+
+// 	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetBestEffortMbs() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+// 	return nil
+// }
+
+func sendSetGenericActionCreateForDS(ctx context.Context, device L2oamDevice) (*l2oam.TomiObjectContext, error) {
+	if err := device.send(l2oam.GenerateGenericActionCreateDs()); err != nil {
+		return nil, nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return nil, fmt.Errorf("[%s] sendSetGenericActionCreateForDS() Send Error: %v", device.getDeviceName(), err)
+	}
+	oc := &l2oam.TomiObjectContext{}
+
+	i := 29
+	oc.Branch = ether.Payload[i]
+	i++
+	oc.Type = binary.BigEndian.Uint16(ether.Payload[i : i+2])
+	i += 2
+	oc.Length = ether.Payload[i]
+	i++
+	oc.Instance = binary.BigEndian.Uint32(ether.Payload[i : i+4])
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetGenericActionCreateForDS() Success, response=%x, branch=%x, type=%x, length=%x, instance=%x",
+		device.getDeviceName(), ether.Payload, oc.Branch, oc.Type, oc.Length, oc.Instance))
+
+	return oc, nil
+}
+
+func sendSetL2SwitchingDomainForDS(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext, tpid []byte, vid []byte) error {
+	tibitData := l2oam.GenerateL2switchingDomainActionLnletEntryDs(oc, tpid, vid)
+	if err := device.send(tibitData); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetL2SwitchingDomain() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetL2SwitchingDomain() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetDefaultOutlet(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext, onuID *l2oam.TomiObjectContext) error {
+	tibitData := l2oam.GenerateSetDefaultOutlet(oc, onuID)
+	if err := device.send(tibitData); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetDefaultOutlet() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetDefaultOutlet() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetL2SwitchingDomainForUS(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext,
+	tpid []byte, vid []byte, onuID *l2oam.TomiObjectContext) error {
+	tibitData := l2oam.GenerateL2switchingDomainActionLnletEntryUs(oc, tpid, vid, onuID)
+	if err := device.send(tibitData); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetL2SwitchingDomainForUS() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetL2SwitchingDomainForUS() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+
+	return nil
+}
+
+func sendSetActionReset(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateSetActionReset()); err != nil {
+		return nil
+	}
+
+	ether, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionReset() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	packet := &l2oam.TOAMSetResponse{}
+	if err := packet.Decode(ether.Payload); err != nil {
+		return nil
+	}
+	logger.Debug(ctx, fmt.Sprintf("[%s] sendSetActionReset() Success, response=%x:%s", device.getDeviceName(), ether.Payload, packet))
+	return nil
+}
+
+func sendSetTrafficProfile(ctx context.Context, device L2oamDevice,
+	trafficControl []byte, trafficProfile []byte) error {
+	if err := device.send(l2oam.GenerateSetTrafficProfile(trafficControl, trafficProfile)); err != nil {
+		return err
+	}
+
+	if _, err := device.waitResponse(ResponseTimer); err != nil {
+		return fmt.Errorf("[%s] sendSetTrafficProfile() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetActionDelete(ctx context.Context, device L2oamDevice, trafficProfile []byte, actionType int) error {
+	if err := device.send(l2oam.GenerateSetActionDelete(trafficProfile, actionType)); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionDelete() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetActionDeleteOnu(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext) error {
+	logger.Debug(ctx, "sendSetActionDeleteOnu() Start.")
+	if err := device.send(l2oam.GenerateSetActionDeleteOnu(oc)); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionDeleteOnu() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetManagementLock(ctx context.Context, device L2oamDevice) error {
+	if err := device.send(l2oam.GenerateSetManagementLock()); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetManagementLock() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetActionInletEntryDsDel(ctx context.Context, device L2oamDevice,
+	oc *l2oam.TomiObjectContext, tpid []byte, vid []byte) error {
+	if err := device.send(l2oam.GenerateL2switchingDomainActionInletEntryDsDel(oc, tpid, vid)); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionInletEntryDsDel() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetActionInletEntryUsDel(ctx context.Context, device L2oamDevice,
+	oc *l2oam.TomiObjectContext, tpid []byte, vid []byte, onuID *l2oam.TomiObjectContext) error {
+	if err := device.send(l2oam.GenerateL2switchingDomainActionInletEntryUsDel(oc, tpid, vid, onuID)); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionInletEntryUsDel() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
+
+func sendSetActionDeleteStream(ctx context.Context, device L2oamDevice, oc *l2oam.TomiObjectContext) error {
+	if err := device.send(l2oam.GenerateSetActionDeleteStream(oc)); err != nil {
+		return nil
+	}
+
+	_, err := device.waitResponse(ResponseTimer)
+	if err != nil {
+		return fmt.Errorf("[%s] sendSetActionDeleteStream() Send Error: %v", device.getDeviceName(), err)
+	}
+
+	return nil
+}
diff --git a/internal/pkg/core/l2oam_oltctl.go b/internal/pkg/core/l2oam_oltctl.go
new file mode 100644
index 0000000..10f9f76
--- /dev/null
+++ b/internal/pkg/core/l2oam_oltctl.go
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"time"
+)
+
+type AddFlowParam struct {
+	Value1 string `json:"value1"`
+	Value2 string `json:"value2"`
+	Value3 string `json:"value3"`
+}
+type AddFlowDownParam struct {
+	Value1 string `json:"value1"`
+	Value2 string `json:"value2"`
+	Value3 string `json:"value3"`
+}
+type AddFlowUpParam struct {
+	Value1 string `json:"value1"`
+	Value2 string `json:"value2"`
+	Value3 string `json:"value3"`
+}
+
+type OltCtlJson struct {
+	Command          string           `json:"command"`
+	Command_help     []string         `json:"command_help"`
+	AddFlowParam     AddFlowParam     `json:"addFlowParam"`
+	AddFlowDownParam AddFlowDownParam `json:"addFlowDownParam"`
+	AddFlowUpParam   AddFlowUpParam   `json:"addFlowUpParam"`
+}
+
+func init() {
+}
+
+func oltctl_main() {
+	for {
+		time.Sleep(1 * time.Second)
+		jsonData := readJson()
+		if jsonData == nil {
+			continue
+		}
+
+		switch jsonData.Command {
+		case "AddFlow":
+			oltctl_AddFlow(&jsonData.AddFlowParam)
+		case "AddFlowDown":
+			oltctl_AddFlowDown(&jsonData.AddFlowDownParam)
+		case "AddFlowUp":
+			oltctl_AddFlowUp(&jsonData.AddFlowUpParam)
+		default:
+
+		}
+		jsonData.Command = "None"
+		writeJson(jsonData)
+
+	}
+
+}
+func oltctl_AddFlow(param *AddFlowParam) {
+	logger.Debug(context.Background(), fmt.Sprintf("oltctl_AddFlow() %v", param))
+}
+func oltctl_AddFlowDown(param *AddFlowDownParam) {
+	logger.Debug(context.Background(), fmt.Sprintf("oltctl_AddFlowDown() %v", param))
+}
+func oltctl_AddFlowUp(param *AddFlowUpParam) {
+	logger.Debug(context.Background(), fmt.Sprintf("oltctl_AddFlowUp() %v", param))
+}
+
+func readJson() *OltCtlJson {
+	bytes, err := ioutil.ReadFile(os.Getenv("HOME") + "/oltctl.json")
+	if err != nil {
+		fmt.Printf("json read error. %v\n", err)
+		return nil
+	}
+	jsonData := &OltCtlJson{}
+	if err := json.Unmarshal(bytes, jsonData); err != nil {
+		fmt.Printf("json unmarshal error. %v\n", err)
+		return nil
+	}
+	return jsonData
+}
+func writeJson(jsonData *OltCtlJson) {
+
+	bytes, err := json.Marshal(jsonData)
+	if err != nil {
+		return
+	}
+	ioutil.WriteFile(os.Getenv("HOME")+"/oltctl.json", bytes, 0644)
+}
diff --git a/internal/pkg/core/olt_onu_msg.go b/internal/pkg/core/olt_onu_msg.go
new file mode 100644
index 0000000..10336b7
--- /dev/null
+++ b/internal/pkg/core/olt_onu_msg.go
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/golang/protobuf/ptypes"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+)
+
+// AdditionalMessage is used for something...
+type AdditionalMessage struct {
+}
+
+func (dh *DeviceHandler) receivedMsgFromOnu(ctx context.Context, msg *ic.InterAdapterMessage) error {
+	msgBody := msg.GetBody()
+	ind := &oop.OnuIndication{}
+
+	err := ptypes.UnmarshalAny(msgBody, ind)
+	if err != nil {
+		logger.Debugw(ctx, "cannot-unmarshal-onu-indication-body", log.Fields{"error": err})
+		return err
+	}
+
+	var info AdditionalMessage
+	err = json.Unmarshal(ind.SerialNumber.VendorSpecific, &info)
+	if err != nil {
+		logger.Debugw(ctx, "cannot-unmarshal-additional-message", log.Fields{"error": err})
+		return err
+	}
+
+	onuDevice := FindL2oamDeviceByDeviceID(msg.Header.ToDeviceId)
+	if onuDevice == nil {
+		logger.Error(ctx, "receivedMsgFromOnu() OnuDevice is not found. deviceId=%s", msg.Header.ToDeviceId)
+		return nil
+	}
+
+	id := msg.Header.Id
+	switch id {
+	case "reboot":
+		onuDevice.reboot(ctx)
+	case "disable":
+		logger.Warn(ctx, "unsupported message, Id=%s", id)
+	case "reenable":
+		logger.Warn(ctx, "unsupported message, Id=%s", id)
+	}
+	return nil
+}
+
+/*
+func (dh *DeviceHandler) sendMsgToOnu(ctx context.Context, deviceID string, topic string, msg string, option interface{}) error {
+	bytes, _ := json.Marshal(option)
+	info := oop.OnuIndication{
+		SerialNumber: &oop.SerialNumber{
+			VendorSpecific: bytes,
+		},
+	}
+
+	err := dh.AdapterProxy.SendInterAdapterMessage(ctx, &info,
+		ic.InterAdapterMessageType_ONU_IND_REQUEST,
+		dh.device.Type, topic,
+		deviceID, dh.device.Id, msg)
+
+	if err != nil {
+		logger.Debugw(ctx, "err-sending-message", log.Fields{"device-id": deviceID, "topic": topic, "error": err})
+	}
+	return err
+}
+*/
diff --git a/internal/pkg/core/olt_platform.go b/internal/pkg/core/olt_platform.go
new file mode 100644
index 0000000..9d4596b
--- /dev/null
+++ b/internal/pkg/core/olt_platform.go
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+
+	"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
+       Propose to remove the below documentation of Flow Id on confirmation
+       of the same
+
+Flow id
+
+    Identifies a flow within a single OLT
+    Flow Id is unique per OLT
+    Multiple GEM ports can map to same flow id
+
+     13    11              4      0
+    +--------+--------------+------+
+    | pon id |    onu id    | Flow |
+    |        |              | idx  |
+    +--------+--------------+------+
+
+    14 bits = 16384 flows (per OLT).
+
+    pon id = 4 bits = 16 PON ports
+    onu id = 7 bits = 128 ONUss per PON port
+    Flow index = 3 bits = 4 bi-directional flows per ONU
+                        = 8 uni-directional flows per ONU
+
+
+Logical (OF) UNI port number
+
+    OpenFlow port number corresponding to PON UNI
+
+     20        12              4      0
+    +--+--------+--------------+------+
+    |0 | pon id |    onu id    |uni id|
+    +--+--------+--------------+------+
+
+    pon id = 8 bits = 256 PON ports
+    onu id = 8 bits = 256 ONUs per PON port
+
+Logical (OF) NNI port number
+
+    OpenFlow port number corresponding to PON NNI
+
+     20                             0
+    +--+----------------------------+
+    |1 |                    intf_id |
+    +--+----------------------------+
+
+    No overlap with UNI port number space
+
+
+PON OLT (OF) port number
+
+    OpenFlow port number corresponding to PON OLT ports
+
+     31     28                                 0
+    +--------+------------------------~~~------+
+    |  0x2   |          pon intf id            |
+    +--------+------------------------~~~------+
+*/
+
+const (
+	bitsForUniID = 4
+	bitsForONUID = 8
+	bitsForPONID = 8
+	MaxOnusPerPon = (1 << bitsForONUID)
+	MaxPonsPerOlt = (1 << bitsForPONID)
+	MaxUnisPerOnu = (1 << bitsForUniID)
+	nniUniDiffPos = (bitsForUniID + bitsForONUID + bitsForPONID)
+	ponIntfMarkerPos = 28
+	ponIntfMarkerValue = 0x2
+	bitsforNNIID = 20
+	minNniIntPortNum = (1 << bitsforNNIID)
+	maxNniPortNum = ((1 << (bitsforNNIID + 1)) - 1)
+)
+
+//MinUpstreamPortID value
+var MinUpstreamPortID = 0xfffd
+
+//MaxUpstreamPortID value
+var MaxUpstreamPortID = 0xfffffffd
+
+var controllerPorts = []uint32{0xfffd, 0x7ffffffd, 0xfffffffd}
+
+//MkUniPortNum returns new UNIportNum based on intfID, inuID and uniID
+func MkUniPortNum(ctx context.Context, intfID, onuID, uniID uint32) uint32 {
+	var limit = int(onuID)
+	if limit > MaxOnusPerPon {
+		logger.Warn(ctx, "exceeded-the-max-onus-per-pon")
+	}
+	return (intfID << (bitsForUniID + bitsForONUID)) | (onuID << bitsForUniID) | uniID
+}
+
+//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)
+}
+
+//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 {
+	if (intfType) == voltha.Port_ETHERNET_NNI {
+		return (1 << nniUniDiffPos) | intfID
+	}
+	if (intfType) == voltha.Port_PON_OLT {
+		return (ponIntfMarkerValue << ponIntfMarkerPos) | intfID
+	}
+	return 0
+}
+
+//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
+	}
+	if (intfType) == voltha.Port_PON_OLT {
+		return (ponIntfMarkerValue << ponIntfMarkerPos) ^ portno
+	}
+	return 0
+}
+
+//IntfIDFromNniPortNum returns Intf ID derived from portNum
+func IntfIDFromNniPortNum(ctx context.Context, portNum uint32) (uint32, error) {
+	if portNum < minNniIntPortNum || portNum > maxNniPortNum {
+		logger.Errorw(ctx, "nniportnumber-is-not-in-valid-range", log.Fields{"portnum": portNum})
+		return uint32(0), olterrors.ErrInvalidPortRange
+	}
+	return (portNum & 0xFFFF), nil
+}
+
+//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) {
+		return voltha.Port_ETHERNET_NNI
+	}
+	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)
+	}
+	return outPort, IntfIDFromUniPortNum(outPort), OnuIDFromPortNum(outPort), UniIDFromPortNum(outPort)
+}
+
+//IsUpstream returns true for Upstream and false for downstream
+func IsUpstream(outPort uint32) bool {
+	for _, port := range controllerPorts {
+		if port == outPort {
+			return true
+		}
+	}
+	return (outPort & (1 << nniUniDiffPos)) == (1 << nniUniDiffPos)
+}
+
+//IsControllerBoundFlow returns true/false
+func IsControllerBoundFlow(outPort uint32) bool {
+	for _, port := range controllerPorts {
+		if port == outPort {
+			return true
+		}
+	}
+	return false
+}
+
+//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(ctx context.Context, flow *ofp.OfpFlowStats, flowDirection string) (uint32, uint32, uint32, uint32, uint32, uint32, error) {
+	var uniPortNo uint32
+	var ponIntf uint32
+	var onuID uint32
+	var uniID uint32
+	var inPort uint32
+	var ethType uint32
+
+	if flowDirection == "upstream" {
+		if uniPortNo = flows.GetChildPortFromTunnelId(flow); uniPortNo == 0 {
+			for _, field := range flows.GetOfbFields(flow) {
+				if field.GetType() == flows.IN_PORT {
+					uniPortNo = field.GetPort()
+					break
+				}
+			}
+		}
+	} else if flowDirection == "downstream" {
+		if uniPortNo = flows.GetChildPortFromTunnelId(flow); uniPortNo == 0 {
+			for _, field := range flows.GetOfbFields(flow) {
+				if field.GetType() == flows.METADATA {
+					for _, action := range flows.GetActions(flow) {
+						if action.Type == flows.OUTPUT {
+							if out := action.GetOutput(); out != nil {
+								uniPortNo = out.GetPort()
+							}
+							break
+						}
+					}
+				} else if field.GetType() == flows.IN_PORT {
+					inPort = field.GetPort()
+				} else if field.GetType() == flows.ETH_TYPE {
+					ethType = field.GetEthType()
+				}
+			}
+		}
+	}
+
+	if uniPortNo == 0 {
+		return 0, 0, 0, 0, 0, 0, olterrors.NewErrNotFound("pon-interface", log.Fields{"flow-direction": flowDirection}, nil)
+	}
+
+	ponIntf = IntfIDFromUniPortNum(uniPortNo)
+	onuID = OnuIDFromUniPortNum(uniPortNo)
+	uniID = UniIDFromPortNum(uniPortNo)
+
+	logger.Debugw(ctx, "flow-extract-info-result",
+		log.Fields{
+			"uniportno": uniPortNo,
+			"pon-intf":  ponIntf,
+			"onu-id":    onuID,
+			"uni-id":    uniID,
+			"inport":    inPort,
+			"ethtype":   ethType})
+
+	return uniPortNo, ponIntf, onuID, uniID, inPort, ethType, nil
+}
diff --git a/internal/pkg/core/olt_platform_test.go b/internal/pkg/core/olt_platform_test.go
new file mode 100644
index 0000000..c8e661c
--- /dev/null
+++ b/internal/pkg/core/olt_platform_test.go
@@ -0,0 +1,383 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"math"
+	"reflect"
+	"testing"
+
+	fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"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"
+)
+
+func TestMkUniPortNum(t *testing.T) {
+	type args struct {
+		intfID uint32
+		onuID  uint32
+		uniID  uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint32
+	}{
+		// TODO: Add test cases.
+		{"MkUniPortNum-1", args{1, 1, 1}, ((1 * 4096) + (1 * 16) + 1)},
+		{"MkUniPortNum-2", args{4, 5, 6}, ((4 * 4096) + (5 * 16) + 6)},
+		// Negative test cases to cover the log.warn
+		{"MkUniPortNum-3", args{4, 130, 6}, ((4 * 4096) + (130 * 16) + 6)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := MkUniPortNum(context.Background(), tt.args.intfID, tt.args.onuID, tt.args.uniID); got != tt.want {
+				t.Errorf("MkUniPortNum() = %v, want %v", got, tt.want)
+			} else {
+				t.Logf("Expected %v , Actual %v \n", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestOnuIDFromPortNum(t *testing.T) {
+	type args struct {
+		portNum uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint32
+	}{
+		// TODO: Add test cases.
+		{"OnuIDFromPortNum-1", args{portNum: 8096}, ((8096 / 16) & 255)},
+		{"OnuIDFromPortNum-2", args{portNum: 9095}, ((9095 / 16) & 255)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := OnuIDFromPortNum(tt.args.portNum); got != tt.want {
+				t.Errorf("OnuIDFromPortNum() = %v, want %v", got, tt.want)
+			} else {
+				t.Logf("Expected %v , Actual %v \n", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestIntfIDFromUniPortNum(t *testing.T) {
+	type args struct {
+		portNum uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint32
+	}{
+		// TODO: Add test cases.
+		{"IntfIDFromUniPortNum-1", args{portNum: 8096}, ((8096 / 4096) & 15)},
+		// Negative Testcase
+		{"IntfIDFromUniPortNum-2", args{portNum: 1024}, ((1024 / 4096) & 15)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IntfIDFromUniPortNum(tt.args.portNum); got != tt.want {
+				t.Errorf("IntfIDFromUniPortNum() = %v, want %v", got, tt.want)
+			} else {
+				t.Logf("Expected %v , Actual %v \n", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestUniIDFromPortNum(t *testing.T) {
+	type args struct {
+		portNum uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint32
+	}{
+
+		// TODO: Add test cases.
+		{"UniIDFromPortNum-1", args{portNum: 8096}, (8096 & 15)},
+		{"UniIDFromPortNum-2", args{portNum: 1024}, (1024 & 15)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := UniIDFromPortNum(tt.args.portNum); got != tt.want {
+				t.Errorf("UniIDFromPortNum() = %v, want %v", got, tt.want)
+			} else {
+				t.Logf("Expected %v , Actual %v \n", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestIntfIDToPortNo(t *testing.T) {
+	type args struct {
+		intfID   uint32
+		intfType voltha.Port_PortType
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint32
+	}{
+		// TODO: Add test cases.
+		{"IntfIDToPortNo-1", args{intfID: 120, intfType: voltha.Port_ETHERNET_NNI}, (uint32(math.Pow(2, 20)) + 120)},
+		{"IntfIDToPortNo-2", args{intfID: 1024, intfType: voltha.Port_ETHERNET_UNI}, 0},
+		{"IntfIDToPortNo-3", args{intfID: 456, intfType: voltha.Port_PON_OLT}, (uint32(2*math.Pow(2, 28)) + 456)},
+		{"IntfIDToPortNo-4", args{intfID: 28, intfType: voltha.Port_PON_ONU}, 0},
+		{"IntfIDToPortNo-5", args{intfID: 45, intfType: voltha.Port_UNKNOWN}, 0},
+		{"IntfIDToPortNo-6", args{intfID: 45, intfType: voltha.Port_VENET_OLT}, 0},
+		{"IntfIDToPortNo-7", args{intfID: 45, intfType: voltha.Port_VENET_ONU}, 0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IntfIDToPortNo(tt.args.intfID, tt.args.intfType); got != tt.want {
+				t.Errorf("IntfIDToPortNo() = %v, want %v", got, tt.want)
+			} else {
+				t.Logf("Expected %v , Actual %v \n", tt.want, got)
+			}
+		})
+	}
+}
+
+func TestIntfIDFromNniPortNum(t *testing.T) {
+	type args struct {
+		portNum uint32
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    uint32
+		wantErr error
+	}{
+		// TODO: Add test cases.
+		{"IntfIDFromNniPortNum-01", args{portNum: 8081}, 0, olterrors.ErrInvalidPortRange},
+		{"IntfIDFromNniPortNum-02", args{portNum: 9090}, 0, olterrors.ErrInvalidPortRange},
+		{"IntfIDFromNniPortNum-03", args{portNum: 0}, 0, olterrors.ErrInvalidPortRange},
+		{"IntfIDFromNniPortNum-04", args{portNum: 65535}, 0, olterrors.ErrInvalidPortRange},
+		{"IntfIDFromNniPortNum-05", args{portNum: 1048575}, 0, olterrors.ErrInvalidPortRange},
+		{"IntfIDFromNniPortNum-06", args{portNum: 1048576}, 0, nil},
+		{"IntfIDFromNniPortNum-07", args{portNum: 1048577}, 1, nil},
+		{"IntfIDFromNniPortNum-08", args{portNum: 1048578}, 2, nil},
+		{"IntfIDFromNniPortNum-09", args{portNum: 1048579}, 3, nil},
+		{"IntfIDFromNniPortNum-10", args{portNum: 2097150}, 65534, nil},
+		{"IntfIDFromNniPortNum-11", args{portNum: 2097151}, 65535, nil},
+		{"IntfIDFromNniPortNum-12", args{portNum: 3000000}, 0, olterrors.ErrInvalidPortRange},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IntfIDFromNniPortNum(context.Background(), tt.args.portNum)
+			if got != tt.want || err != tt.wantErr {
+				t.Errorf("IntfIDFromNniPortNum(): FOR[%v] WANT[%v and %v] GOT[%v and %v]",
+					tt.args.portNum, tt.want, tt.wantErr, got, err)
+			}
+		})
+	}
+}
+
+func TestIntfIDToPortTypeName(t *testing.T) {
+	type args struct {
+		intfID uint32
+	}
+	input := uint32(2*math.Pow(2, 28)) | 3
+	tests := []struct {
+		name string
+		args args
+		want voltha.Port_PortType
+	}{
+		// TODO: Add test cases.
+		{"IntfIDToPortTypeName-1", args{intfID: 1048576}, voltha.Port_ETHERNET_NNI},
+		{"IntfIDToPortTypeName-2", args{intfID: 1000}, voltha.Port_ETHERNET_UNI},
+		{"IntfIDToPortTypeName-2", args{intfID: input}, voltha.Port_PON_OLT},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IntfIDToPortTypeName(tt.args.intfID); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("IntfIDToPortTypeName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestExtractAccessFromFlow(t *testing.T) {
+	type args struct {
+		inPort  uint32
+		outPort uint32
+	}
+	tests := []struct {
+		name   string
+		args   args
+		port   uint32
+		IntfID uint32
+		onuID  uint32
+		uniID  uint32
+	}{
+		// TODO: Add test cases.
+		{"ExtractAccessFromFlow-1", args{inPort: 100, outPort: 1048576}, 100, 0, 6, 4},
+		{"ExtractAccessFromFlow-2", args{inPort: 1048576, outPort: 10}, 10, 0, 0, 10},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, got2, got3 := ExtractAccessFromFlow(tt.args.inPort, tt.args.outPort)
+			if got != tt.port {
+				t.Errorf("ExtractAccessFromFlow() got = %v, want %v", got, tt.port)
+			}
+			if got1 != tt.IntfID {
+				t.Errorf("ExtractAccessFromFlow() got1 = %v, want %v", got1, tt.IntfID)
+			}
+			if got2 != tt.onuID {
+				t.Errorf("ExtractAccessFromFlow() got2 = %v, want %v", got2, tt.onuID)
+			}
+			if got3 != tt.uniID {
+				t.Errorf("ExtractAccessFromFlow() got3 = %v, want %v", got3, tt.uniID)
+			}
+		})
+	}
+}
+
+func TestIsUpstream(t *testing.T) {
+	type args struct {
+		outPort uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		// TODO: Add test cases.
+		{"TestIsUpstream-1", args{outPort: 65533}, true},
+		{"TestIsUpstream-2", args{outPort: 1048576}, true},
+		{"TestIsUpstream-3", args{outPort: 1048577}, true},
+		{"TestIsUpstream-4", args{outPort: 1048578}, true},
+		{"TestIsUpstream-6", args{outPort: 1000}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IsUpstream(tt.args.outPort); got != tt.want {
+				t.Errorf("IsUpstream() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIsControllerBoundFlow(t *testing.T) {
+	type args struct {
+		outPort uint32
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		// TODO: Add test cases.
+		{"IsControllerBoundFlow-1", args{outPort: 65533}, true},
+		{"IsControllerBoundFlow-2", args{outPort: 65536}, false},
+		{"IsControllerBoundFlow-3", args{outPort: 65537}, false},
+		{"IsControllerBoundFlow-4", args{outPort: 65538}, false},
+		{"IsControllerBoundFlow-5", args{outPort: 65539}, false},
+		{"IsControllerBoundFlow-6", args{outPort: 1000}, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := IsControllerBoundFlow(tt.args.outPort); got != tt.want {
+				t.Errorf("IsControllerBoundFlow() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFlowExtractInfo(t *testing.T) {
+	fa := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(2),
+			fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2)),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+			fu.EthType(2048),
+		},
+
+		Actions: []*ofp.OfpAction{
+			fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+			fu.Output(1),
+		},
+	}
+	ofpstats, _ := fu.MkFlowStat(fa)
+	type args struct {
+		flow          *ofp.OfpFlowStats
+		flowDirection string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint32
+		want1   uint32
+		want2   uint32
+		want3   uint32
+		want4   uint32
+		want5   uint32
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"FlowExtractInfo-1", args{flow: ofpstats, flowDirection: "upstream"}, 2, 0, 0, 2, 0, 0, false},
+
+		// Negative Testcases
+		{"FlowExtractInfo-2", args{flow: ofpstats, flowDirection: "downstream"}, 1, 0, 0, 1, 2, 2048, false},
+		{"FlowExtractInfo-3", args{flow: nil, flowDirection: "downstream"}, 0, 0, 0, 0, 0, 0, true},
+		{"FlowExtractInfo-4", args{flow: &ofp.OfpFlowStats{}, flowDirection: "downstream"}, 0, 0, 0, 0, 0, 0, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1, got2, got3, got4, got5, err := FlowExtractInfo(context.Background(), tt.args.flow, tt.args.flowDirection)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("FlowExtractInfo() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("FlowExtractInfo() got = %v, want %v", got, tt.want)
+				return
+			}
+			if got1 != tt.want1 {
+				t.Errorf("FlowExtractInfo() got1 = %v, want %v", got1, tt.want1)
+				return
+			}
+			if got2 != tt.want2 {
+				t.Errorf("FlowExtractInfo() got2 = %v, want %v", got2, tt.want2)
+				return
+			}
+			if got3 != tt.want3 {
+				t.Errorf("FlowExtractInfo() got3 = %v, want %v", got3, tt.want3)
+				return
+			}
+			if got4 != tt.want4 {
+				t.Errorf("FlowExtractInfo() got4 = %v, want %v", got4, tt.want4)
+				return
+			}
+			if got5 != tt.want5 {
+				t.Errorf("FlowExtractInfo() got5 = %v, want %v", got5, tt.want5)
+				return
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/olt_state_transitions.go b/internal/pkg/core/olt_state_transitions.go
new file mode 100644
index 0000000..9a11a3b
--- /dev/null
+++ b/internal/pkg/core/olt_state_transitions.go
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"reflect"
+	"runtime"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+)
+
+// DeviceState OLT Device state
+type DeviceState int
+
+const (
+	deviceStateNull DeviceState = iota
+	deviceStateInit
+	deviceStateConnected
+	deviceStateUp
+	deviceStateDown
+)
+
+// Trigger for changing the state
+type Trigger int
+
+const (
+	DeviceInit Trigger = iota
+	GrpcConnected
+	DeviceUpInd
+	DeviceDownInd
+	GrpcDisconnected
+)
+
+// TransitionHandler function type for handling transition
+type TransitionHandler func(ctx context.Context) error
+
+// Transition to store state machine
+type Transition struct {
+	previousState []DeviceState
+	currentState  DeviceState
+	before        []TransitionHandler
+	after         []TransitionHandler
+}
+
+// TransitionMap to store all the states and current device state
+type TransitionMap struct {
+	transitions        map[Trigger]Transition
+	currentDeviceState DeviceState
+}
+
+//    OpenoltDevice state machine:
+//
+//        null ----> init ------> connected -----> up -----> down
+//                   ^ ^             |             ^         | |
+//                   | |             |             |         | |
+//                   | +-------------+             +---------+ |
+//                   |                                         |
+//                   +-----------------------------------------+
+
+// NewTransitionMap create a new state machine with all the transitions
+func NewTransitionMap(dh *DeviceHandler) *TransitionMap {
+	var transitionMap TransitionMap
+	transitionMap.currentDeviceState = deviceStateNull
+	transitionMap.transitions = make(map[Trigger]Transition)
+	transitionMap.transitions[DeviceInit] =
+		Transition{
+			previousState: []DeviceState{deviceStateNull, deviceStateUp, deviceStateDown},
+			currentState:  deviceStateInit,
+			before:        []TransitionHandler{dh.doStateInit},
+			after:         []TransitionHandler{dh.postInit}}
+	transitionMap.transitions[GrpcDisconnected] =
+		Transition{
+			previousState: []DeviceState{deviceStateConnected, deviceStateDown},
+			currentState:  deviceStateInit,
+			before:        []TransitionHandler{dh.doStateInit},
+			after:         []TransitionHandler{dh.postInit}}
+	transitionMap.transitions[GrpcConnected] =
+		Transition{
+			previousState: []DeviceState{deviceStateInit},
+			currentState:  deviceStateConnected,
+			before:        []TransitionHandler{dh.doStateConnected}}
+
+	transitionMap.transitions[DeviceUpInd] =
+		Transition{
+			previousState: []DeviceState{deviceStateConnected, deviceStateDown},
+			currentState:  deviceStateUp,
+			before:        []TransitionHandler{dh.doStateUp}}
+	transitionMap.transitions[DeviceDownInd] =
+		Transition{
+			previousState: []DeviceState{deviceStateUp},
+			currentState:  deviceStateDown,
+			before:        []TransitionHandler{dh.doStateDown}}
+
+	return &transitionMap
+}
+
+// funcName gets the handler function name
+func funcName(f interface{}) string {
+	p := reflect.ValueOf(f).Pointer()
+	rf := runtime.FuncForPC(p)
+	return rf.Name()
+}
+
+// isValidTransition checks for the new state transition is valid from current state
+func (tMap *TransitionMap) isValidTransition(trigger Trigger) bool {
+	for _, state := range tMap.transitions[trigger].previousState {
+		if tMap.currentDeviceState == state {
+			return true
+		}
+	}
+	return false
+}
+
+// Handle moves the state machine to next state based on the trigger and invokes the before and
+// after handlers if the transition is a valid transition
+func (tMap *TransitionMap) Handle(ctx context.Context, trigger Trigger) {
+
+	if !tMap.isValidTransition(trigger) {
+		logger.Errorw(ctx, "invalid-transition-triggered",
+			log.Fields{
+				"current-state": tMap.currentDeviceState,
+				"trigger":       trigger})
+		return
+	}
+
+	beforeHandlers := tMap.transitions[trigger].before
+	if beforeHandlers == nil {
+		logger.Debugw(ctx, "no-handlers-for-before", log.Fields{"trigger": trigger})
+	}
+	for _, handler := range beforeHandlers {
+		logger.Debugw(ctx, "running-before-handler", log.Fields{"handler": funcName(handler)})
+		if err := handler(ctx); err != nil {
+			// TODO handle error
+			logger.Error(ctx, err)
+			return
+		}
+	}
+
+	tMap.currentDeviceState = tMap.transitions[trigger].currentState
+	logger.Debugw(ctx, "updated-device-state ", log.Fields{"current-device-state": tMap.currentDeviceState})
+
+	afterHandlers := tMap.transitions[trigger].after
+	if afterHandlers == nil {
+		logger.Debugw(ctx, "no-handlers-for-after", log.Fields{"trigger": trigger})
+	}
+	for _, handler := range afterHandlers {
+		logger.Debugw(ctx, "running-after-handler", log.Fields{"handler": funcName(handler)})
+		if err := handler(ctx); err != nil {
+			// TODO handle error
+			logger.Error(ctx, err)
+			return
+		}
+	}
+}
diff --git a/internal/pkg/core/olt_state_transitions_test.go b/internal/pkg/core/olt_state_transitions_test.go
new file mode 100644
index 0000000..9c2be8d
--- /dev/null
+++ b/internal/pkg/core/olt_state_transitions_test.go
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package core
+
+import (
+	"context"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	"reflect"
+	"testing"
+	"time"
+)
+
+/**
+Get's the transition Map with current state of the device.
+*/
+func getTranisitions() map[Trigger]Transition {
+	transitions := make(map[Trigger]Transition)
+	transition := Transition{
+		previousState: []DeviceState{deviceStateConnected},
+		currentState:  deviceStateConnected,
+	}
+	transitions[DeviceInit] = transition
+	return transitions
+}
+
+/**
+Get's the transition Map with after Transition func added.
+*/
+func getTranisitionsAfter() map[Trigger]Transition {
+	transitions := make(map[Trigger]Transition)
+	transition := Transition{
+		previousState: []DeviceState{deviceStateConnected},
+		currentState:  deviceStateConnected,
+		after: []TransitionHandler{func(ctx context.Context) error {
+			return nil
+		}, func(ctx context.Context) error {
+			return olterrors.ErrStateTransition
+		}},
+	}
+	transitions[GrpcConnected] = transition
+	return transitions
+}
+
+/**
+Get's the transition Map with before Transition func added.
+*/
+func getTranisitionsBefore() map[Trigger]Transition {
+	transitions := make(map[Trigger]Transition)
+	transition := Transition{
+		previousState: []DeviceState{deviceStateConnected},
+		currentState:  deviceStateConnected,
+		before: []TransitionHandler{func(ctx context.Context) error {
+			return nil
+		}, func(ctx context.Context) error {
+			return olterrors.ErrStateTransition
+		}},
+	}
+	transitions[GrpcConnected] = transition
+	return transitions
+}
+
+/**
+Check's Creation of transition Map, return's NewTransitionMap.
+*/
+func TestNewTransitionMap(t *testing.T) {
+	type args struct {
+		dh *DeviceHandler
+	}
+	tests := []struct {
+		name string
+		args args
+		want *TransitionMap
+	}{
+		{"NewTransitionMap-1", args{newMockDeviceHandler()}, &TransitionMap{}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewTransitionMap(tt.args.dh); reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
+				t.Errorf("NewTransitionMap() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+/**
+Checks the different transition of the device handled properly.
+*/
+func TestTransitionMap_Handle(t *testing.T) {
+	type fields struct {
+		transitions        map[Trigger]Transition
+		currentDeviceState DeviceState
+	}
+	type args struct {
+		trigger Trigger
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		{"Handle-1", fields{getTranisitions(), deviceStateDown}, args{GrpcConnected}},
+		{"Handle-2", fields{getTranisitions(), deviceStateConnected}, args{GrpcConnected}},
+		{"Handle-3", fields{getTranisitionsBefore(), deviceStateConnected}, args{GrpcConnected}},
+		{"Handle-4", fields{getTranisitionsAfter(), deviceStateConnected}, args{GrpcConnected}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tMap := &TransitionMap{
+				transitions:        tt.fields.transitions,
+				currentDeviceState: tt.fields.currentDeviceState,
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			tMap.Handle(ctx, tt.args.trigger)
+		})
+	}
+}
+
+/**
+Check's if the transition is valid or not.
+*/
+func TestTransitionMap_isValidTransition(t *testing.T) {
+	type fields struct {
+		transitions        map[Trigger]Transition
+		currentDeviceState DeviceState
+	}
+	type args struct {
+		trigger Trigger
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{
+		{"isValidTransition-1", fields{getTranisitions(), deviceStateConnected}, args{DeviceInit},
+			true},
+		{"isValidTransition-2", fields{getTranisitions(), deviceStateDown}, args{GrpcConnected},
+			false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tMap := &TransitionMap{
+				transitions:        tt.fields.transitions,
+				currentDeviceState: tt.fields.currentDeviceState,
+			}
+			if got := tMap.isValidTransition(tt.args.trigger); reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
+				t.Errorf("isValidTransition() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+/**
+Get's the After/Before transition method's function name.
+*/
+func Test_funcName(t *testing.T) {
+	type args struct {
+		f interface{}
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{"FuncName-1", args{newMockDeviceHandler()}, ""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := funcName(tt.args.f); got != tt.want {
+				t.Errorf("funcName() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/openolt.go b/internal/pkg/core/openolt.go
new file mode 100644
index 0000000..58b18e5
--- /dev/null
+++ b/internal/pkg/core/openolt.go
@@ -0,0 +1,379 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
+	"github.com/opencord/voltha-lib-go/v3/pkg/kafka"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/config"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	"github.com/opencord/voltha-protos/v3/go/openflow_13"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+//OpenOLT structure holds the OLT information
+type OpenOLT struct {
+	deviceHandlers              map[string]*DeviceHandler
+	coreProxy                   adapterif.CoreProxy
+	adapterProxy                adapterif.AdapterProxy
+	eventProxy                  adapterif.EventProxy
+	kafkaICProxy                kafka.InterContainerProxy
+	config                      *config.AdapterFlags
+	numOnus                     int
+	KVStoreAddress              string
+	KVStoreType                 string
+	exitChannel                 chan int
+	HeartbeatCheckInterval      time.Duration
+	HeartbeatFailReportInterval time.Duration
+	GrpcTimeoutInterval         time.Duration
+	lockDeviceHandlersMap       sync.RWMutex
+}
+
+//NewOpenOLT returns a new instance of OpenOLT
+func NewOpenOLT(ctx context.Context, kafkaICProxy kafka.InterContainerProxy,
+	coreProxy adapterif.CoreProxy, adapterProxy adapterif.AdapterProxy,
+	eventProxy adapterif.EventProxy, cfg *config.AdapterFlags) *OpenOLT {
+	var openOLT OpenOLT
+	openOLT.exitChannel = make(chan int, 1)
+	openOLT.deviceHandlers = make(map[string]*DeviceHandler)
+	openOLT.kafkaICProxy = kafkaICProxy
+	openOLT.config = cfg
+	openOLT.numOnus = cfg.OnuNumber
+	openOLT.coreProxy = coreProxy
+	openOLT.adapterProxy = adapterProxy
+	openOLT.eventProxy = eventProxy
+	openOLT.KVStoreAddress = cfg.KVStoreAddress
+	openOLT.KVStoreType = cfg.KVStoreType
+	openOLT.HeartbeatCheckInterval = cfg.HeartbeatCheckInterval
+	openOLT.HeartbeatFailReportInterval = cfg.HeartbeatFailReportInterval
+	openOLT.GrpcTimeoutInterval = cfg.GrpcTimeoutInterval
+	openOLT.lockDeviceHandlersMap = sync.RWMutex{}
+	return &openOLT
+}
+
+//Start starts (logs) the device manager
+func (oo *OpenOLT) Start(ctx context.Context) error {
+	logger.Info(ctx, "starting-device-manager")
+	logger.Info(ctx, "device-manager-started")
+	return nil
+}
+
+//Stop terminates the session
+func (oo *OpenOLT) Stop(ctx context.Context) error {
+	logger.Info(ctx, "stopping-device-manager")
+	oo.exitChannel <- 1
+	logger.Info(ctx, "device-manager-stopped")
+	return nil
+}
+
+func (oo *OpenOLT) addDeviceHandlerToMap(agent *DeviceHandler) {
+	oo.lockDeviceHandlersMap.Lock()
+	defer oo.lockDeviceHandlersMap.Unlock()
+	if _, exist := oo.deviceHandlers[agent.device.Id]; !exist {
+		oo.deviceHandlers[agent.device.Id] = agent
+	}
+}
+
+func (oo *OpenOLT) deleteDeviceHandlerToMap(agent *DeviceHandler) {
+	oo.lockDeviceHandlersMap.Lock()
+	defer oo.lockDeviceHandlersMap.Unlock()
+	delete(oo.deviceHandlers, agent.device.Id)
+}
+
+func (oo *OpenOLT) getDeviceHandler(deviceID string) *DeviceHandler {
+	oo.lockDeviceHandlersMap.Lock()
+	defer oo.lockDeviceHandlersMap.Unlock()
+	if agent, ok := oo.deviceHandlers[deviceID]; ok {
+		return agent
+	}
+	return nil
+}
+
+// Adopt_device creates a new device handler if not present already and then adopts the device
+func (oo *OpenOLT) Adopt_device(ctx context.Context, device *voltha.Device) error {
+	if device == nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil).Log()
+	}
+	logger.Infow(ctx, "adopt-device", log.Fields{"deviceId": device.Id})
+	var handler *DeviceHandler
+	if handler = oo.getDeviceHandler(device.Id); handler == nil {
+		handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
+		oo.addDeviceHandlerToMap(handler)
+		go handler.AdoptDevice(ctx, device)
+		// Launch the creation of the device topic
+		// go oo.createDeviceTopic(device)
+	}
+	return nil
+}
+
+//Get_ofp_device_info returns OFP information for the given device
+func (oo *OpenOLT) Get_ofp_device_info(ctx context.Context, device *voltha.Device) (*ic.SwitchCapability, error) {
+	logger.Infow(ctx, "Get_ofp_device_info", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		return handler.GetOfpDeviceInfo(device)
+	}
+	return nil, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Process_inter_adapter_message sends messages to a target device (between adapters)
+func (oo *OpenOLT) Process_inter_adapter_message(ctx context.Context, msg *ic.InterAdapterMessage) error {
+	logger.Debugw(ctx, "Process_inter_adapter_message", log.Fields{"msgId": msg.Header.Id})
+	targetDevice := msg.Header.ProxyDeviceId // Request?
+	if targetDevice == "" && msg.Header.ToDeviceId != "" {
+		// Typical response
+		targetDevice = msg.Header.ToDeviceId
+	}
+	if handler := oo.getDeviceHandler(targetDevice); handler != nil {
+		return handler.ProcessInterAdapterMessage(ctx, msg)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": targetDevice}, nil)
+}
+
+//Adapter_descriptor not implemented
+func (oo *OpenOLT) Adapter_descriptor(ctx context.Context) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Device_types unimplemented
+func (oo *OpenOLT) Device_types(ctx context.Context) (*voltha.DeviceTypes, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Health  returns unimplemented
+func (oo *OpenOLT) Health(ctx context.Context) (*voltha.HealthStatus, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Reconcile_device unimplemented
+func (oo *OpenOLT) Reconcile_device(ctx context.Context, device *voltha.Device) error {
+	if device == nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
+	}
+	logger.Infow(ctx, "reconcile-device", log.Fields{"deviceId": device.Id})
+	var handler *DeviceHandler
+	if handler = oo.getDeviceHandler(device.Id); handler == nil {
+		handler := NewDeviceHandler(oo.coreProxy, oo.adapterProxy, oo.eventProxy, device, oo)
+		oo.addDeviceHandlerToMap(handler)
+		handler.transitionMap = NewTransitionMap(handler)
+		handler.transitionMap.Handle(ctx, DeviceInit)
+	}
+	return nil
+}
+
+//Abandon_device unimplemented
+func (oo *OpenOLT) Abandon_device(ctx context.Context, device *voltha.Device) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Disable_device disables the given device
+func (oo *OpenOLT) Disable_device(ctx context.Context, device *voltha.Device) error {
+	logger.Infow(ctx, "disable-device", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		return handler.DisableDevice(ctx, device)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Reenable_device enables the olt device after disable
+func (oo *OpenOLT) Reenable_device(ctx context.Context, device *voltha.Device) error {
+	logger.Infow(ctx, "reenable-device", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		return handler.ReenableDevice(ctx, device)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Reboot_device reboots the given device
+func (oo *OpenOLT) Reboot_device(ctx context.Context, device *voltha.Device) error {
+	logger.Infow(ctx, "reboot-device", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		return handler.RebootDevice(ctx, device)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Self_test_device unimplented
+func (oo *OpenOLT) Self_test_device(ctx context.Context, device *voltha.Device) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Delete_device unimplemented
+func (oo *OpenOLT) Delete_device(ctx context.Context, device *voltha.Device) error {
+	logger.Infow(ctx, "delete-device", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		if err := handler.DeleteDevice(ctx, device); err != nil {
+			logger.Errorw(ctx, "failed-to-handle-delete-device", log.Fields{"device-id": device.Id})
+		}
+		oo.deleteDeviceHandlerToMap(handler)
+		return nil
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Get_device_details unimplemented
+func (oo *OpenOLT) Get_device_details(ctx context.Context, device *voltha.Device) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Update_flows_bulk returns
+func (oo *OpenOLT) Update_flows_bulk(ctx context.Context, device *voltha.Device, flows *voltha.Flows, groups *voltha.FlowGroups, flowMetadata *voltha.FlowMetadata) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Update_flows_incrementally updates (add/remove) the flows on a given device
+func (oo *OpenOLT) Update_flows_incrementally(ctx context.Context, device *voltha.Device, flows *openflow_13.FlowChanges, groups *openflow_13.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
+	logger.Debugw(ctx, "Update_flows_incrementally", log.Fields{"deviceId": device.Id, "flows": flows, "flowMetadata": flowMetadata})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		return handler.UpdateFlowsIncrementally(ctx, device, flows, groups, flowMetadata)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Update_pm_config returns PmConfigs nil or error
+func (oo *OpenOLT) Update_pm_config(ctx context.Context, device *voltha.Device, pmConfigs *voltha.PmConfigs) error {
+	logger.Debugw(ctx, "Update_pm_config", log.Fields{"device-id": device.Id, "pm-configs": pmConfigs})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		handler.UpdatePmConfig(ctx, pmConfigs)
+		return nil
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
+
+//Receive_packet_out sends packet out to the device
+func (oo *OpenOLT) Receive_packet_out(ctx context.Context, deviceID string, egressPortNo int, packet *openflow_13.OfpPacketOut) error {
+	logger.Debugw(ctx, "Receive_packet_out", log.Fields{"deviceId": deviceID, "egress_port_no": egressPortNo, "pkt": packet})
+	if handler := oo.getDeviceHandler(deviceID); handler != nil {
+		return handler.PacketOut(ctx, egressPortNo, packet)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": deviceID}, nil)
+}
+
+//Suppress_event unimplemented
+func (oo *OpenOLT) Suppress_event(ctx context.Context, filter *voltha.EventFilter) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Unsuppress_event  unimplemented
+func (oo *OpenOLT) Unsuppress_event(ctx context.Context, filter *voltha.EventFilter) error {
+	return olterrors.ErrNotImplemented
+}
+
+//Download_image unimplemented
+func (oo *OpenOLT) Download_image(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Get_image_download_status unimplemented
+func (oo *OpenOLT) Get_image_download_status(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Cancel_image_download unimplemented
+func (oo *OpenOLT) Cancel_image_download(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Activate_image_update unimplemented
+func (oo *OpenOLT) Activate_image_update(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Revert_image_update unimplemented
+func (oo *OpenOLT) Revert_image_update(ctx context.Context, device *voltha.Device, request *voltha.ImageDownload) (*voltha.ImageDownload, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+// Enable_port to Enable PON/NNI interface
+func (oo *OpenOLT) Enable_port(ctx context.Context, deviceID string, port *voltha.Port) error {
+	logger.Infow(ctx, "Enable_port", log.Fields{"deviceId": deviceID, "port": port})
+	return oo.enableDisablePort(ctx, deviceID, port, true)
+}
+
+// Disable_port to Disable pon/nni interface
+func (oo *OpenOLT) Disable_port(ctx context.Context, deviceID string, port *voltha.Port) error {
+	logger.Infow(ctx, "Disable_port", log.Fields{"deviceId": deviceID, "port": port})
+	return oo.enableDisablePort(ctx, deviceID, port, false)
+}
+
+// enableDisablePort to Disable pon or Enable PON interface
+func (oo *OpenOLT) enableDisablePort(ctx context.Context, deviceID string, port *voltha.Port, enablePort bool) error {
+	logger.Infow(ctx, "enableDisablePort", log.Fields{"deviceId": deviceID, "port": port})
+	if port == nil {
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"reason":    "port cannot be nil",
+			"device-id": deviceID,
+			"port":      nil}, nil)
+	}
+	if handler := oo.getDeviceHandler(deviceID); handler != nil {
+		logger.Debugw(ctx, "Enable_Disable_Port", log.Fields{"deviceId": deviceID, "port": port})
+		if enablePort {
+			if err := handler.EnablePort(ctx, port); err != nil {
+				return olterrors.NewErrAdapter("error-occurred-during-enable-port", log.Fields{"deviceID": deviceID, "port": port}, err)
+			}
+		} else {
+			if err := handler.DisablePort(ctx, port); err != nil {
+				return olterrors.NewErrAdapter("error-occurred-during-disable-port", log.Fields{"deviceID": deviceID, "port": port}, err)
+			}
+		}
+	}
+	return nil
+}
+
+//Child_device_lost deletes the ONU and its references from PONResources
+func (oo *OpenOLT) Child_device_lost(ctx context.Context, deviceID string, pPortNo uint32, onuID uint32) error {
+	logger.Infow(ctx, "Child-device-lost", log.Fields{"parentId": deviceID})
+	if handler := oo.getDeviceHandler(deviceID); handler != nil {
+		return handler.ChildDeviceLost(ctx, pPortNo, onuID)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": deviceID}, nil).Log()
+}
+
+//Start_omci_test not implemented
+func (oo *OpenOLT) Start_omci_test(ctx context.Context, device *voltha.Device, request *voltha.OmciTestRequest) (*voltha.TestResponse, error) {
+	return nil, olterrors.ErrNotImplemented
+}
+
+//Get_ext_value retrieves a value on a particular ONU
+func (oo *OpenOLT) Get_ext_value(ctx context.Context, deviceID string, device *voltha.Device, valueparam voltha.ValueType_Type) (*voltha.ReturnValues, error) {
+	var err error
+	resp := new(voltha.ReturnValues)
+	logger.Infow(ctx, "Get_ext_value", log.Fields{"device-id": deviceID, "onu-id": device.Id})
+	if handler := oo.getDeviceHandler(deviceID); handler != nil {
+		if resp, err = handler.getExtValue(ctx, device, valueparam); err != nil {
+			logger.Errorw(ctx, "error-occurred-during-get-ext-value", log.Fields{"device-id": deviceID, "onu-id": device.Id,
+				"error": err})
+			return nil, err
+		}
+	}
+	return resp, nil
+}
+
+func (oo *OpenOLT) Simulate_alarm(ctx context.Context, device *voltha.Device, request *voltha.SimulateAlarmRequest) error {
+	logger.Infow(ctx, "Simulate_alarm", log.Fields{"deviceId": device.Id})
+	if handler := oo.getDeviceHandler(device.Id); handler != nil {
+		logger.Infow(ctx, "Simulate_alarm", log.Fields{"request": request})
+		return handler.L2oamCmdRequest(ctx, device, request)
+	}
+	return olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": device.Id}, nil)
+}
diff --git a/internal/pkg/core/openolt_eventmgr.go b/internal/pkg/core/openolt_eventmgr.go
new file mode 100644
index 0000000..f62f8a8
--- /dev/null
+++ b/internal/pkg/core/openolt_eventmgr.go
@@ -0,0 +1,788 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package core provides APIs for the openOLT adapter
+package core
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	"github.com/opencord/voltha-protos/v3/go/common"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+const (
+	onuDiscoveryEvent                   = "ONU_DISCOVERY"
+	onuLosEvent                         = "ONU_LOSS_OF_SIGNAL"
+	onuLobEvent                         = "ONU_LOSS_OF_BURST"
+	onuLopcMissEvent                    = "ONU_LOPC_MISS"
+	onuLopcMicErrorEvent                = "ONU_LOPC_MIC_ERROR"
+	oltLosEvent                         = "OLT_LOSS_OF_SIGNAL"
+	oltIndicationDown                   = "OLT_DOWN_INDICATION"
+	onuDyingGaspEvent                   = "ONU_DYING_GASP"
+	onuSignalsFailEvent                 = "ONU_SIGNALS_FAIL"
+	onuStartupFailEvent                 = "ONU_STARTUP_FAIL"
+	onuSignalDegradeEvent               = "ONU_SIGNAL_DEGRADE"
+	onuDriftOfWindowEvent               = "ONU_DRIFT_OF_WINDOW"
+	onuActivationFailEvent              = "ONU_ACTIVATION_FAIL"
+	onuLossOmciEvent                    = "ONU_LOSS_OF_OMCI_CHANNEL"
+	onuLossOfKeySyncEvent               = "ONU_LOSS_OF_KEY_SYNC"
+	onuLossOfFrameEvent                 = "ONU_LOSS_OF_FRAME"
+	onuLossOfPloamEvent                 = "ONU_LOSS_OF_PLOAM"
+	ponIntfDownIndiction                = "OLT_PON_INTERFACE_DOWN"
+	onuDeactivationFailureEvent         = "ONU_DEACTIVATION_FAILURE"
+	onuRemoteDefectIndication           = "ONU_REMOTE_DEFECT"
+	onuLossOfGEMChannelDelineationEvent = "ONU_LOSS_OF_GEM_CHANNEL_DELINEATION"
+	onuPhysicalEquipmentErrorEvent      = "ONU_PHYSICAL_EQUIPMENT_ERROR"
+	onuLossOfAcknowledgementEvent       = "ONU_LOSS_OF_ACKNOWLEDGEMENT"
+	onuDifferentialReachExceededEvent   = "ONU_DIFFERENTIAL_REACH_EXCEEDED"
+)
+
+const (
+	statusCheckOn = "on"
+	statusCheckOff = "off"
+	operationStateUp = "up"
+	operationStateDown = "down"
+	base10 = 10
+)
+
+const (
+	ContextOltOperState = "oper-state"
+	ContextOnuOnuID = "onu-id"
+	ContextOnuPonIntfID = "intf-id"
+	ContextOnuSerialNumber = "serial-number"
+	ContextOnuDeviceID = "onu-device-id"
+	ContextOltPonIntfID = "intf-id"
+	ContextOnuFailureReaseon = "fail-reason"
+	ContextOnuDrift = "drift"
+	ContextOnuNewEqd = "new-eqd"
+	ContextOnuInverseBitErrorRate = "inverse-bit-error-rate"
+	ContextOltPonIntfOperState = "oper-state"
+	ContextOnuRemoteDefectIndicatorCount = "rdi-count"
+	ContextOnuDelineationErrors = "delineation-errors"
+	ContextOnuDifferentialDistance = "differential-distance"
+)
+
+// OpenOltEventMgr struct contains
+type OpenOltEventMgr struct {
+	eventProxy adapterif.EventProxy
+	handler    *DeviceHandler
+}
+
+// NewEventMgr is a Function to get a new event manager struct for the OpenOLT to process and publish OpenOLT event
+func NewEventMgr(eventProxy adapterif.EventProxy, handler *DeviceHandler) *OpenOltEventMgr {
+	var em OpenOltEventMgr
+	em.eventProxy = eventProxy
+	em.handler = handler
+	return &em
+}
+
+// ProcessEvents is function to process and publish OpenOLT event
+// nolint: gocyclo
+func (em *OpenOltEventMgr) ProcessEvents(ctx context.Context, alarmInd *oop.AlarmIndication, deviceID string, raisedTs int64) {
+	var err error
+	switch alarmInd.Data.(type) {
+	case *oop.AlarmIndication_LosInd:
+		logger.Debugw(ctx, "received-los-indication", log.Fields{"alarm-ind": alarmInd})
+		err = em.oltLosIndication(ctx, alarmInd.GetLosInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuAlarmInd:
+		logger.Debugw(ctx, "received-onu-alarm-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuAlarmIndication(ctx, alarmInd.GetOnuAlarmInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_DyingGaspInd:
+		logger.Debugw(ctx, "received-dying-gasp-indication", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuDyingGaspIndication(ctx, alarmInd.GetDyingGaspInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuActivationFailInd:
+		logger.Debugw(ctx, "received-onu-activation-fail-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuActivationFailIndication(ctx, alarmInd.GetOnuActivationFailInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuLossOmciInd:
+		logger.Debugw(ctx, "received-onu-loss-omci-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuLossOmciIndication(ctx, alarmInd.GetOnuLossOmciInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuDriftOfWindowInd:
+		logger.Debugw(ctx, "received-onu-drift-of-window-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuDriftOfWindowIndication(ctx, alarmInd.GetOnuDriftOfWindowInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuSignalDegradeInd:
+		logger.Debugw(ctx, "received-onu-signal-degrade-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuSignalDegradeIndication(ctx, alarmInd.GetOnuSignalDegradeInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuSignalsFailInd:
+		logger.Debugw(ctx, "received-onu-signal-fail-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuSignalsFailIndication(ctx, alarmInd.GetOnuSignalsFailInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuStartupFailInd:
+		logger.Debugw(ctx, "received-onu-startup-fail-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuStartupFailedIndication(ctx, alarmInd.GetOnuStartupFailInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuTiwiInd:
+		logger.Debugw(ctx, "received-onu-transmission-warning-indication ", log.Fields{"alarm-ind": alarmInd})
+		logger.Warnw(ctx, "not-implemented-yet", log.Fields{"alarm-ind": "Onu-Transmission-indication"})
+	case *oop.AlarmIndication_OnuLossOfSyncFailInd:
+		logger.Debugw(ctx, "received-onu-loss-of-sync-fail-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuLossOfSyncIndication(ctx, alarmInd.GetOnuLossOfSyncFailInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuItuPonStatsInd:
+		logger.Debugw(ctx, "received-onu-itu-pon-stats-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuItuPonStatsIndication(ctx, alarmInd.GetOnuItuPonStatsInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuDeactivationFailureInd:
+		logger.Debugw(ctx, "received-onu-deactivation-failure-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuDeactivationFailureIndication(ctx, alarmInd.GetOnuDeactivationFailureInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuLossGemDelineationInd:
+		logger.Debugw(ctx, "received-onu-loss-of-gem-channel-delineation-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuLossOfGEMChannelDelineationIndication(ctx, alarmInd.GetOnuLossGemDelineationInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuPhysicalEquipmentErrorInd:
+		logger.Debugw(ctx, "received-onu-physical-equipment-error-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuPhysicalEquipmentErrorIndication(ctx, alarmInd.GetOnuPhysicalEquipmentErrorInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuLossOfAckInd:
+		logger.Debugw(ctx, "received-onu-loss-of-acknowledgement-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuLossOfAcknowledgementIndication(ctx, alarmInd.GetOnuLossOfAckInd(), deviceID, raisedTs)
+	case *oop.AlarmIndication_OnuDiffReachExceededInd:
+		logger.Debugw(ctx, "received-onu-differential-reach-exceeded-indication ", log.Fields{"alarm-ind": alarmInd})
+		err = em.onuDifferentialReachExceededIndication(ctx, alarmInd.GetOnuDiffReachExceededInd(), deviceID, raisedTs)
+	default:
+		err = olterrors.NewErrInvalidValue(log.Fields{"indication-type": alarmInd}, nil)
+	}
+	if err != nil {
+		_ = olterrors.NewErrCommunication("publish-message", log.Fields{"indication-type": alarmInd}, err).LogAt(log.WarnLevel)
+	}
+}
+
+// oltUpDownIndication handles Up and Down state of an OLT
+func (em *OpenOltEventMgr) oltUpDownIndication(ctx context.Context, oltIndication *oop.OltIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOltOperState] = oltIndication.OperState
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if oltIndication.OperState == operationStateDown {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "RAISE_EVENT")
+	} else if oltIndication.OperState == operationStateUp {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", oltIndicationDown, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
+		return olterrors.NewErrCommunication("send-olt-event", log.Fields{"device-id": deviceID}, err)
+	}
+	logger.Debugw(ctx, "olt-updown-event-sent-to-kafka", log.Fields{})
+	return nil
+}
+
+// OnuDiscoveryIndication is an exported method to handle ONU discovery event
+func (em *OpenOltEventMgr) OnuDiscoveryIndication(ctx context.Context, onuDisc *oop.OnuDiscIndication, oltDeviceID string, onuDeviceID string, OnuID uint32, serialNumber string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(OnuID), base10)
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDisc.IntfId), base10)
+	context[ContextOnuSerialNumber] = serialNumber
+	context[ContextOnuDeviceID] = onuDeviceID
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = oltDeviceID
+	de.DeviceEventName = fmt.Sprintf("%s_%s", onuDiscoveryEvent, "RAISE_EVENT")
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return olterrors.NewErrCommunication("send-onu-discovery-event",
+			log.Fields{
+				"serial-number": serialNumber,
+				"intf-id":       onuDisc.IntfId}, err)
+	}
+	logger.Debugw(ctx, "onu-discovery-event-sent-to-kafka",
+		log.Fields{
+			"serial-number": serialNumber,
+			"intf-id":       onuDisc.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) oltLosIndication(ctx context.Context, oltLos *oop.LosIndication, deviceID string, raisedTs int64) error {
+	var err error = nil
+	var de voltha.DeviceEvent
+	var alarmInd oop.OnuAlarmIndication
+	ponIntdID := PortNoToIntfID(oltLos.IntfId, voltha.Port_PON_OLT)
+
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOltPonIntfID] = strconv.FormatUint(uint64(oltLos.IntfId), base10)
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if oltLos.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "RAISE_EVENT")
+
+		/* When PON cable disconnected from OLT, it was expected OnuAlarmIndication
+		   with "los_status: on" should be raised for each Onu connected to the PON
+		   but BAL does not raise this Alarm hence manually sending OnuLosRaise event
+		   for all the ONU's connected to PON on receiving LoSIndication for PON */
+		em.handler.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
+			if onuInCache.(*OnuDevice).intfID == ponIntdID {
+				alarmInd.IntfId = ponIntdID
+				alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
+				alarmInd.LosStatus = statusCheckOn
+				err = em.onuAlarmIndication(ctx, &alarmInd, deviceID, raisedTs)
+			}
+			return true
+		})
+		if err != nil {
+			/* Return if any error encountered while processing ONU LoS Event*/
+			return err
+		}
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", oltLosEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "olt-los-event-sent-to-kafka", log.Fields{"intf-id": oltLos.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) populateContextWithSerialDeviceID(context map[string]string, intfID, onuID uint32) {
+	var serialNumber = ""
+	var onuDeviceID = ""
+	onu := em.handler.formOnuKey(intfID, onuID)
+	if onu, ok := em.handler.onus.Load(onu); ok {
+		serialNumber = onu.(*OnuDevice).serialNumber
+		onuDeviceID = onu.(*OnuDevice).deviceID
+	}
+
+	context[ContextOnuSerialNumber] = serialNumber
+	context[ContextOnuDeviceID] = onuDeviceID
+}
+
+func (em *OpenOltEventMgr) onuDyingGaspIndication(ctx context.Context, dgi *oop.DyingGaspIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	em.populateContextWithSerialDeviceID(context, dgi.IntfId, dgi.OnuId)
+
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(dgi.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(dgi.OnuId), base10)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	de.DeviceEventName = fmt.Sprintf("%s_%s", onuDyingGaspEvent, "EVENT")
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-dying-gasp-event-sent-to-kafka", log.Fields{"intf-id": dgi.IntfId})
+	return nil
+}
+
+//wasLosRaised checks whether los raised already. If already raised returns true else false
+func (em *OpenOltEventMgr) wasLosRaised(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
+	onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
+	if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
+		logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
+
+		if onuAlarm.LosStatus == statusCheckOn {
+			if onuInCache.(*OnuDevice).losRaised {
+				logger.Warnw(ctx, "onu-los-raised-already", log.Fields{"onu_id": onuAlarm.OnuId,
+					"intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
+				return true
+			}
+			return false
+		}
+	}
+	return true
+}
+
+//wasLosCleared checks whether los cleared already. If already cleared returns true else false
+func (em *OpenOltEventMgr) wasLosCleared(ctx context.Context, onuAlarm *oop.OnuAlarmIndication) bool {
+	onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
+	if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
+		logger.Debugw(ctx, "onu-device-found-in-cache.", log.Fields{"intfID": onuAlarm.IntfId, "onuID": onuAlarm.OnuId})
+
+		if onuAlarm.LosStatus == statusCheckOff {
+			if !onuInCache.(*OnuDevice).losRaised {
+				logger.Warnw(ctx, "onu-los-cleared-already", log.Fields{"onu_id": onuAlarm.OnuId,
+					"intf_id": onuAlarm.IntfId, "LosStatus": onuAlarm.LosStatus})
+				return true
+			}
+			return false
+		}
+	}
+	return true
+}
+
+func (em *OpenOltEventMgr) getDeviceEventName(onuAlarm *oop.OnuAlarmIndication) string {
+	var deviceEventName string
+	if onuAlarm.LosStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "RAISE_EVENT")
+	} else if onuAlarm.LosStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLosEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LobStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "RAISE_EVENT")
+	} else if onuAlarm.LobStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLobEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LopcMissStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "RAISE_EVENT")
+	} else if onuAlarm.LopcMissStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLopcMissEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LopcMicErrorStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "RAISE_EVENT")
+	} else if onuAlarm.LopcMicErrorStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLopcMicErrorEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LofiStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "RAISE_EVENT")
+	} else if onuAlarm.LofiStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLossOfFrameEvent, "CLEAR_EVENT")
+	} else if onuAlarm.LoamiStatus == statusCheckOn {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "RAISE_EVENT")
+	} else if onuAlarm.LoamiStatus == statusCheckOff {
+		deviceEventName = fmt.Sprintf("%s_%s", onuLossOfPloamEvent, "CLEAR_EVENT")
+	}
+	return deviceEventName
+}
+
+func (em *OpenOltEventMgr) onuAlarmIndication(ctx context.Context, onuAlarm *oop.OnuAlarmIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuAlarm.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuAlarm.OnuId), base10)
+	em.populateContextWithSerialDeviceID(context, onuAlarm.IntfId, onuAlarm.OnuId)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	de.DeviceEventName = em.getDeviceEventName(onuAlarm)
+
+	switch onuAlarm.LosStatus {
+	case statusCheckOn:
+		if em.wasLosRaised(ctx, onuAlarm) {
+			/* No need to raise Onu Los Event as it might have already raised
+			   or Onu might have deleted */
+			return nil
+		}
+		onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
+		if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
+			/* Update onu device with LoS raised state as true */
+			em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
+				onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
+				onuInCache.(*OnuDevice).proxyDeviceID, true))
+		}
+	case statusCheckOff:
+		if em.wasLosCleared(ctx, onuAlarm) {
+			/* No need to clear Onu Los Event as it might have already cleared
+			   or Onu might have deleted */
+			return nil
+		}
+		onuKey := em.handler.formOnuKey(onuAlarm.IntfId, onuAlarm.OnuId)
+		if onuInCache, ok := em.handler.onus.Load(onuKey); ok {
+			/* Update onu device with LoS raised state as false */
+			em.handler.onus.Store(onuKey, NewOnuDevice(onuInCache.(*OnuDevice).deviceID, onuInCache.(*OnuDevice).deviceType,
+				onuInCache.(*OnuDevice).serialNumber, onuInCache.(*OnuDevice).onuID, onuInCache.(*OnuDevice).intfID,
+				onuInCache.(*OnuDevice).proxyDeviceID, false))
+		}
+	}
+
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-los-event-sent-to-kafka", log.Fields{"onu-id": onuAlarm.OnuId, "intf-id": onuAlarm.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuActivationFailIndication(ctx context.Context, oaf *oop.OnuActivationFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(oaf.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(oaf.OnuId), base10)
+	context[ContextOnuFailureReaseon] = strconv.FormatUint(uint64(oaf.FailReason), base10)
+
+	em.populateContextWithSerialDeviceID(context, oaf.IntfId, oaf.OnuId)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	de.DeviceEventName = fmt.Sprintf("%s_%s", onuActivationFailEvent, "RAISE_EVENT")
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-activation-failure-event-sent-to-kafka", log.Fields{"onu-id": oaf.OnuId, "intf-id": oaf.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuLossOmciIndication(ctx context.Context, onuLossOmci *oop.OnuLossOfOmciChannelIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLossOmci.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLossOmci.OnuId), base10)
+
+	em.populateContextWithSerialDeviceID(context, onuLossOmci.IntfId, onuLossOmci.OnuId)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuLossOmci.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOmciEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-loss-of-omci-channel-event-sent-to-kafka", log.Fields{"onu-id": onuLossOmci.OnuId, "intf-id": onuLossOmci.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuDriftOfWindowIndication(ctx context.Context, onuDriftWindow *oop.OnuDriftOfWindowIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDriftWindow.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDriftWindow.OnuId), base10)
+	context[ContextOnuDrift] = strconv.FormatUint(uint64(onuDriftWindow.Drift), base10)
+	context[ContextOnuNewEqd] = strconv.FormatUint(uint64(onuDriftWindow.NewEqd), base10)
+
+	em.populateContextWithSerialDeviceID(context, onuDriftWindow.IntfId, onuDriftWindow.OnuId)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuDriftWindow.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDriftOfWindowEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-drift-of-window-event-sent-to-kafka", log.Fields{"onu-id": onuDriftWindow.OnuId, "intf-id": onuDriftWindow.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuSignalDegradeIndication(ctx context.Context, onuSignalDegrade *oop.OnuSignalDegradeIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalDegrade.IntfId), base10)
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalDegrade.OnuId), base10)
+	context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalDegrade.InverseBitErrorRate), base10)
+
+	em.populateContextWithSerialDeviceID(context, onuSignalDegrade.IntfId, onuSignalDegrade.OnuId)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuSignalDegrade.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalDegradeEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-signal-degrade-event-sent-to-kafka", log.Fields{"onu-id": onuSignalDegrade.OnuId, "intf-id": onuSignalDegrade.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuSignalsFailIndication(ctx context.Context, onuSignalsFail *oop.OnuSignalsFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	em.populateContextWithSerialDeviceID(context, onuSignalsFail.IntfId, onuSignalsFail.OnuId)
+
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuSignalsFail.OnuId), base10)
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuSignalsFail.IntfId), base10)
+	context[ContextOnuInverseBitErrorRate] = strconv.FormatUint(uint64(onuSignalsFail.InverseBitErrorRate), base10)
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuSignalsFail.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuSignalsFailEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-signals-fail-event-sent-to-kafka", log.Fields{"onu-id": onuSignalsFail.OnuId, "intf-id": onuSignalsFail.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuStartupFailedIndication(ctx context.Context, onuStartupFail *oop.OnuStartupFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	em.populateContextWithSerialDeviceID(context, onuStartupFail.IntfId, onuStartupFail.OnuId)
+
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuStartupFail.OnuId), base10)
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuStartupFail.IntfId), base10)
+
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuStartupFail.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuStartupFailEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_PON, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-startup-fail-event-sent-to-kafka", log.Fields{"onu-id": onuStartupFail.OnuId, "intf-id": onuStartupFail.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuLossOfSyncIndication(ctx context.Context, onuLOKI *oop.OnuLossOfKeySyncFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	em.populateContextWithSerialDeviceID(context, onuLOKI.IntfId, onuLOKI.OnuId)
+
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuLOKI.OnuId), base10)
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuLOKI.IntfId), base10)
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuLOKI.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfKeySyncEvent, "CLEAR_EVENT")
+	}
+
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_SECURITY, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-loss-of-key-sync-event-sent-to-kafka", log.Fields{"onu-id": onuLOKI.OnuId, "intf-id": onuLOKI.IntfId})
+	return nil
+}
+
+// oltIntfOperIndication handles Up and Down state of an OLT PON ports
+func (em *OpenOltEventMgr) oltIntfOperIndication(ctx context.Context, ifindication *oop.IntfOperIndication, deviceID string, raisedTs int64) {
+	portNo := IntfIDToPortNo(ifindication.IntfId, voltha.Port_PON_OLT)
+	if port, err := em.handler.coreProxy.GetDevicePort(ctx, deviceID, portNo); err != nil {
+		logger.Warnw(ctx, "Error while fetching port object", log.Fields{"device-id": deviceID, "error": err})
+	} else if port.AdminState != common.AdminState_ENABLED {
+		logger.Debugw(ctx, "port-disable/enable-event-not-generated--the-port-is-not-enabled-by-operator", log.Fields{"device-id": deviceID, "port": port})
+		return
+	}
+	/* Populating event context */
+	context := map[string]string{ContextOltPonIntfOperState: ifindication.GetOperState()}
+	/* Populating device event body */
+	var de voltha.DeviceEvent
+	de.Context = context
+	de.ResourceId = deviceID
+
+	if ifindication.GetOperState() == operationStateDown {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "RAISE_EVENT")
+	} else if ifindication.OperState == operationStateUp {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", ponIntfDownIndiction, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_OLT, raisedTs); err != nil {
+		_ = olterrors.NewErrCommunication("send-olt-intf-oper-status-event", log.Fields{"device-id": deviceID, "intf-id": ifindication.IntfId, "oper-state": ifindication.OperState}, err).LogAt(log.WarnLevel)
+		return
+	}
+	logger.Debug(ctx, "sent-olt-intf-oper-status-event-to-kafka")
+}
+
+func (em *OpenOltEventMgr) onuDeactivationFailureIndication(ctx context.Context, onuDFI *oop.OnuDeactivationFailureIndication, deviceID string, raisedTs int64) error {
+	var de voltha.DeviceEvent
+	context := make(map[string]string)
+	/* Populating event context */
+	em.populateContextWithSerialDeviceID(context, onuDFI.IntfId, onuDFI.OnuId)
+
+	context[ContextOnuOnuID] = strconv.FormatUint(uint64(onuDFI.OnuId), base10)
+	context[ContextOnuPonIntfID] = strconv.FormatUint(uint64(onuDFI.IntfId), base10)
+	/* Populating device event body */
+	de.Context = context
+	de.ResourceId = deviceID
+	if onuDFI.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDeactivationFailureEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, &de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-deactivation-failure-event-sent-to-kafka", log.Fields{"onu-id": onuDFI.OnuId, "intf-id": onuDFI.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuRemoteDefectIndication(ctx context.Context, onuID uint32, intfID uint32, rdiCount uint64, status string, deviceID string, raisedTs int64) error {
+	/* Populating event context */
+	context := map[string]string{
+		ContextOnuOnuID:                      strconv.FormatUint(uint64(onuID), base10),
+		ContextOnuPonIntfID:                  strconv.FormatUint(uint64(intfID), base10),
+		ContextOnuRemoteDefectIndicatorCount: strconv.FormatUint(rdiCount, base10),
+	}
+	em.populateContextWithSerialDeviceID(context, intfID, onuID)
+
+	/* Populating device event body */
+	de := &voltha.DeviceEvent{
+		Context:    context,
+		ResourceId: deviceID,
+	}
+	if status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuRemoteDefectIndication, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-remote-defect-event-sent-to-kafka", log.Fields{"onu-id": onuID, "intf-id": intfID})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuItuPonStatsIndication(ctx context.Context, onuIPS *oop.OnuItuPonStatsIndication, deviceID string, raisedTs int64) error {
+	onuDevice, found := em.handler.onus.Load(em.handler.formOnuKey(onuIPS.IntfId, onuIPS.OnuId))
+	if !found {
+		return errors.New("unknown-onu-device")
+	}
+	if onuIPS.GetRdiErrorInd().Status == statusCheckOn {
+		if !onuDevice.(*OnuDevice).rdiRaised {
+			if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOn, deviceID, raisedTs); err != nil {
+				return err
+			}
+			onuDevice.(*OnuDevice).rdiRaised = true
+			return nil
+		}
+		logger.Debugw(ctx, "onu-remote-defect-already-raised", log.Fields{"onu-id": onuIPS.OnuId, "intf-id": onuIPS.IntfId})
+	} else {
+		if err := em.onuRemoteDefectIndication(ctx, onuIPS.OnuId, onuIPS.IntfId, onuIPS.GetRdiErrorInd().RdiErrorCount, statusCheckOff, deviceID, raisedTs); err != nil {
+			return err
+		}
+		onuDevice.(*OnuDevice).rdiRaised = false
+	}
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuLossOfGEMChannelDelineationIndication(ctx context.Context, onuGCD *oop.OnuLossOfGEMChannelDelineationIndication, deviceID string, raisedTs int64) error {
+	/* Populating event context */
+	context := map[string]string{
+		ContextOnuOnuID:             strconv.FormatUint(uint64(onuGCD.OnuId), base10),
+		ContextOnuPonIntfID:         strconv.FormatUint(uint64(onuGCD.IntfId), base10),
+		ContextOnuDelineationErrors: strconv.FormatUint(uint64(onuGCD.DelineationErrors), base10),
+	}
+	em.populateContextWithSerialDeviceID(context, onuGCD.IntfId, onuGCD.OnuId)
+
+	/* Populating device event body */
+	de := &voltha.DeviceEvent{
+		Context:    context,
+		ResourceId: deviceID,
+	}
+	if onuGCD.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfGEMChannelDelineationEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_COMMUNICATION, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-loss-of-gem-channel-delineation-event-sent-to-kafka", log.Fields{"onu-id": onuGCD.OnuId, "intf-id": onuGCD.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuPhysicalEquipmentErrorIndication(ctx context.Context, onuErr *oop.OnuPhysicalEquipmentErrorIndication, deviceID string, raisedTs int64) error {
+	/* Populating event context */
+	context := map[string]string{
+		ContextOnuOnuID:     strconv.FormatUint(uint64(onuErr.OnuId), base10),
+		ContextOnuPonIntfID: strconv.FormatUint(uint64(onuErr.IntfId), base10),
+	}
+	em.populateContextWithSerialDeviceID(context, onuErr.IntfId, onuErr.OnuId)
+	/* Populating device event body */
+	de := &voltha.DeviceEvent{
+		Context:    context,
+		ResourceId: deviceID,
+	}
+	if onuErr.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuPhysicalEquipmentErrorEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-physical-equipment-error-event-sent-to-kafka", log.Fields{"onu-id": onuErr.OnuId, "intf-id": onuErr.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuLossOfAcknowledgementIndication(ctx context.Context, onuLOA *oop.OnuLossOfAcknowledgementIndication, deviceID string, raisedTs int64) error {
+	/* Populating event context */
+	context := map[string]string{
+		ContextOnuOnuID:     strconv.FormatUint(uint64(onuLOA.OnuId), base10),
+		ContextOnuPonIntfID: strconv.FormatUint(uint64(onuLOA.IntfId), base10),
+	}
+	em.populateContextWithSerialDeviceID(context, onuLOA.IntfId, onuLOA.OnuId)
+
+	/* Populating device event body */
+	de := &voltha.DeviceEvent{
+		Context:    context,
+		ResourceId: deviceID,
+	}
+	if onuLOA.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuLossOfAcknowledgementEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-physical-equipment-error-event-sent-to-kafka", log.Fields{"onu-id": onuLOA.OnuId, "intf-id": onuLOA.IntfId})
+	return nil
+}
+
+func (em *OpenOltEventMgr) onuDifferentialReachExceededIndication(ctx context.Context, onuDRE *oop.OnuDifferentialReachExceededIndication, deviceID string, raisedTs int64) error {
+	/* Populating event context */
+	context := map[string]string{
+		ContextOnuOnuID:                strconv.FormatUint(uint64(onuDRE.OnuId), base10),
+		ContextOnuPonIntfID:            strconv.FormatUint(uint64(onuDRE.IntfId), base10),
+		ContextOnuDifferentialDistance: strconv.FormatUint(uint64(onuDRE.Distance), base10),
+	}
+	em.populateContextWithSerialDeviceID(context, onuDRE.IntfId, onuDRE.OnuId)
+
+	/* Populating device event body */
+	de := &voltha.DeviceEvent{
+		Context:    context,
+		ResourceId: deviceID,
+	}
+	if onuDRE.Status == statusCheckOn {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "RAISE_EVENT")
+	} else {
+		de.DeviceEventName = fmt.Sprintf("%s_%s", onuDifferentialReachExceededEvent, "CLEAR_EVENT")
+	}
+	/* Send event to KAFKA */
+	if err := em.eventProxy.SendDeviceEvent(ctx, de, voltha.EventCategory_EQUIPMENT, voltha.EventSubCategory_ONU, raisedTs); err != nil {
+		return err
+	}
+	logger.Debugw(ctx, "onu-differential-reach-exceeded–event-sent-to-kafka", log.Fields{"onu-id": onuDRE.OnuId, "intf-id": onuDRE.IntfId})
+	return nil
+}
diff --git a/internal/pkg/core/openolt_eventmgr_test.go b/internal/pkg/core/openolt_eventmgr_test.go
new file mode 100644
index 0000000..84dff0b
--- /dev/null
+++ b/internal/pkg/core/openolt_eventmgr_test.go
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package core provides APIs for the openOLT adapter
+package core
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/opencord/voltha-openolt-adapter/pkg/mocks"
+	oop "github.com/opencord/voltha-protos/v3/go/openolt"
+)
+
+func mockEventMgr() *OpenOltEventMgr {
+	ep := &mocks.MockEventProxy{}
+	dh := newMockDeviceHandler()
+	dh.onus = sync.Map{}
+	dh.onus.Store(dh.formOnuKey(1, 1), &OnuDevice{deviceID: "TEST_ONU",
+		deviceType:   "ONU",
+		serialNumber: "TEST_ONU_123",
+		onuID:        1, intfID: 1})
+	dh.onus.Store("1.3", NewOnuDevice("onu3", "onu3", "onu3", 1, 3, "onu3", false))
+	dh.onus.Store("1.4", NewOnuDevice("onu4", "onu4", "onu4", 1, 4, "onu4", false))
+	return NewEventMgr(ep, dh)
+}
+func TestOpenOltEventMgr_ProcessEvents(t *testing.T) {
+	em := mockEventMgr()
+
+	type args struct {
+		alarmInd *oop.AlarmIndication
+		deviceID string
+		raisedTs int64
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		// LosIndication alarms
+		/* Pon Interface ID from Openolt agent is sent as port no while raising LoSIndication hence following same in test to have similar behavior
+		   0x2 << 28 ^ 536870913 = 1 --> pon Intf Id*/
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_LosInd{LosInd: &oop.LosIndication{IntfId: 536870913, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_LosInd{LosInd: &oop.LosIndication{IntfId: 536870913}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_LosInd{LosInd: &oop.LosIndication{IntfId: 536870913, Status: "on"}}}}},
+
+		// OnuAlarmIndication alams
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LosStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LosStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		// Duplicate test to get onu los already cleared result
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LosStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LobStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LobStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LopcMissStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LopcMissStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LopcMicErrorStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LopcMicErrorStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LofiStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LofiStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LoamiStatus: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LoamiStatus: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuAlarmInd{OnuAlarmInd: &oop.OnuAlarmIndication{IntfId: 1, OnuId: 3, LosStatus: "on"}}}}},
+
+		// AlarmIndication_DyingGaspInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_DyingGaspInd{DyingGaspInd: &oop.DyingGaspIndication{IntfId: 1, OnuId: 1, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_DyingGaspInd{DyingGaspInd: &oop.DyingGaspIndication{IntfId: 1, OnuId: 1, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_DyingGaspInd{DyingGaspInd: &oop.DyingGaspIndication{IntfId: 1, OnuId: 1}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_DyingGaspInd{DyingGaspInd: &oop.DyingGaspIndication{IntfId: 1, OnuId: 1}}}}},
+
+		// AlarmIndication_OnuActivationFailInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuActivationFailInd{OnuActivationFailInd: &oop.OnuActivationFailureIndication{IntfId: 1, OnuId: 3}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuActivationFailInd{OnuActivationFailInd: &oop.OnuActivationFailureIndication{IntfId: 1, OnuId: 3}}}}},
+
+		// AlarmIndication_OnuLossOmciInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuLossOmciInd{OnuLossOmciInd: &oop.OnuLossOfOmciChannelIndication{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuLossOmciInd{OnuLossOmciInd: &oop.OnuLossOfOmciChannelIndication{IntfId: 1, OnuId: 3, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuLossOmciInd{OnuLossOmciInd: &oop.OnuLossOfOmciChannelIndication{IntfId: 1, OnuId: 3, Status: "on"}}}}},
+
+		// AlarmIndication_OnuDriftOfWindowInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDriftOfWindowInd{OnuDriftOfWindowInd: &oop.OnuDriftOfWindowIndication{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDriftOfWindowInd{OnuDriftOfWindowInd: &oop.OnuDriftOfWindowIndication{IntfId: 1, OnuId: 3, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDriftOfWindowInd{OnuDriftOfWindowInd: &oop.OnuDriftOfWindowIndication{IntfId: 1, OnuId: 3, Drift: 10, NewEqd: 10}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDriftOfWindowInd{OnuDriftOfWindowInd: &oop.OnuDriftOfWindowIndication{IntfId: 1, OnuId: 3, Status: "on"}}}}},
+
+		// AlarmIndication_OnuSignalDegradeInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalDegradeInd{OnuSignalDegradeInd: &oop.OnuSignalDegradeIndication{IntfId: 1, OnuId: 3, Status: "on", InverseBitErrorRate: 100}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalDegradeInd{OnuSignalDegradeInd: &oop.OnuSignalDegradeIndication{IntfId: 1, OnuId: 3, Status: "off", InverseBitErrorRate: 100}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalDegradeInd{OnuSignalDegradeInd: &oop.OnuSignalDegradeIndication{IntfId: 1, OnuId: 3, InverseBitErrorRate: 100}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalDegradeInd{OnuSignalDegradeInd: &oop.OnuSignalDegradeIndication{IntfId: 1, OnuId: 3, InverseBitErrorRate: 100}}}}},
+
+		// AlarmIndication_OnuSignalsFailInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalsFailInd{OnuSignalsFailInd: &oop.OnuSignalsFailureIndication{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalsFailInd{OnuSignalsFailInd: &oop.OnuSignalsFailureIndication{IntfId: 1, OnuId: 3, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalsFailInd{OnuSignalsFailInd: &oop.OnuSignalsFailureIndication{IntfId: 1, OnuId: 3, InverseBitErrorRate: 100}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuSignalsFailInd{OnuSignalsFailInd: &oop.OnuSignalsFailureIndication{IntfId: 1, OnuId: 3, InverseBitErrorRate: 100}}}}},
+
+		// AlarmIndication_OnuProcessingErrorInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuProcessingErrorInd{OnuProcessingErrorInd: &oop.OnuProcessingErrorIndication{IntfId: 1, OnuId: 3}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuProcessingErrorInd{OnuProcessingErrorInd: &oop.OnuProcessingErrorIndication{IntfId: 1, OnuId: 3}}}}},
+
+		// AlarmIndication_OnuTiwiInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuTiwiInd{OnuTiwiInd: &oop.OnuTransmissionInterferenceWarning{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuTiwiInd{OnuTiwiInd: &oop.OnuTransmissionInterferenceWarning{IntfId: 1, OnuId: 3, Status: "on", Drift: 100}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuTiwiInd{OnuTiwiInd: &oop.OnuTransmissionInterferenceWarning{IntfId: 1, OnuId: 3}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuTiwiInd{OnuTiwiInd: &oop.OnuTransmissionInterferenceWarning{IntfId: 1, OnuId: 3}}}}},
+
+		// AlarmIndication_onuLossOfKeySyncInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuLossOfSyncFailInd{OnuLossOfSyncFailInd: &oop.OnuLossOfKeySyncFailureIndication{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuLossOfSyncFailInd{OnuLossOfSyncFailInd: &oop.OnuLossOfKeySyncFailureIndication{IntfId: 1, OnuId: 3, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+
+		// AlarmIndication_onuDeactivationFailureInd
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDeactivationFailureInd{OnuDeactivationFailureInd: &oop.OnuDeactivationFailureIndication{IntfId: 1, OnuId: 3, Status: "on"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuDeactivationFailureInd{OnuDeactivationFailureInd: &oop.OnuDeactivationFailureIndication{IntfId: 1, OnuId: 3, Status: "off"}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		// AlarmIndication_onuItuPonStatsIndication
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuItuPonStatsInd{OnuItuPonStatsInd: &oop.OnuItuPonStatsIndication{IntfId: 1, OnuId: 3, Stats: &oop.OnuItuPonStatsIndication_RdiErrorInd{RdiErrorInd: &oop.RdiErrorIndication{RdiErrorCount: 4, Status: "on"}}}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+		{"ProcessEvents-", args{alarmInd: &oop.AlarmIndication{Data: &oop.AlarmIndication_OnuItuPonStatsInd{OnuItuPonStatsInd: &oop.OnuItuPonStatsIndication{IntfId: 1, OnuId: 3, Stats: &oop.OnuItuPonStatsIndication_RdiErrorInd{RdiErrorInd: &oop.RdiErrorIndication{RdiErrorCount: 0, Status: "off"}}}}}, deviceID: "olt", raisedTs: time.Now().Unix()}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			em.ProcessEvents(context.Background(), tt.args.alarmInd, tt.args.deviceID, tt.args.raisedTs)
+		})
+	}
+}
+
+func TestOpenOltEventMgr_OnuDiscoveryIndication(t *testing.T) {
+	em := mockEventMgr()
+	type args struct {
+		onuDisc      *oop.OnuDiscIndication
+		oltDeviceID  string
+		onuDeviceID  string
+		OnuID        uint32
+		serialNumber string
+		raisedTs     int64
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"OnuDiscoveryIndication", args{onuDisc: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, oltDeviceID: "olt", onuDeviceID: "onu1", OnuID: 3, serialNumber: "1234", raisedTs: time.Now().Unix()}},
+		{"OnuDiscoveryIndication", args{onuDisc: &oop.OnuDiscIndication{}, raisedTs: time.Now().Unix()}},
+		{"OnuDiscoveryIndication", args{onuDisc: &oop.OnuDiscIndication{}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_ = em.OnuDiscoveryIndication(context.Background(), tt.args.onuDisc, tt.args.oltDeviceID, tt.args.onuDeviceID, tt.args.OnuID, tt.args.serialNumber, tt.args.raisedTs)
+			//TODO: actually verify test cases
+		})
+	}
+}
diff --git a/internal/pkg/core/openolt_flowmgr.go b/internal/pkg/core/openolt_flowmgr.go
new file mode 100644
index 0000000..449afe8
--- /dev/null
+++ b/internal/pkg/core/openolt_flowmgr.go
@@ -0,0 +1,4119 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	tp "github.com/opencord/voltha-lib-go/v3/pkg/techprofile"
+	rsrcMgr "github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
+	"github.com/opencord/voltha-protos/v3/go/common"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	openoltpb2 "github.com/opencord/voltha-protos/v3/go/openolt"
+	tp_pb "github.com/opencord/voltha-protos/v3/go/tech_profile"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+
+	"github.com/EagleChen/mapmutex"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+const (
+
+	HsiaFlow = "HSIA_FLOW"
+
+	EapolFlow = "EAPOL_FLOW"
+
+	DhcpFlow = "DHCP_FLOW"
+
+	MulticastFlow = "MULTICAST_FLOW"
+
+	IgmpFlow = "IGMP_FLOW"
+
+	IPProtoDhcp = 17
+
+	IPProtoIgmp = 2
+
+	EapEthType = 0x888e
+	LldpEthType = 0x88cc
+	IPv4EthType = 0x800
+
+	IgmpProto = 2
+
+	ReservedVlan = 4096
+
+	DefaultMgmtVlan = 4091
+
+
+	Upstream = "upstream"
+	Downstream = "downstream"
+	Multicast = "multicast"
+	PacketTagType = "pkt_tag_type"
+	Untagged = "untagged"
+	SingleTag = "single_tag"
+	DoubleTag = "double_tag"
+
+
+	EthType = "eth_type"
+	EthDst = "eth_dst"
+	TPID = "tpid"
+	IPProto = "ip_proto"
+	InPort = "in_port"
+	VlanVid = "vlan_vid"
+	VlanPcp = "vlan_pcp"
+
+	UDPDst = "udp_dst"
+	UDPSrc = "udp_src"
+	Ipv4Dst = "ipv4_dst"
+	Ipv4Src = "ipv4_src"
+	Metadata = "metadata"
+	TunnelID = "tunnel_id"
+	Output = "output"
+	GroupID = "group_id"
+
+	PopVlan = "pop_vlan"
+	PushVlan = "push_vlan"
+	TrapToHost = "trap_to_host"
+	MaxMeterBand = 2
+	VlanPCPMask = 0xFF
+	VlanvIDMask = 0xFFF
+	IntfID = "intfId"
+	OnuID = "onuId"
+	UniID = "uniId"
+	PortNo = "portNo"
+	AllocID = "allocId"
+
+	NoneOnuID = -1
+	NoneUniID = -1
+	NoneGemPortID = -1
+
+	BinaryStringPrefix = "0b"
+	BinaryBit1 = '1'
+
+	maxRetry  = 300
+	maxDelay  = 100000000
+	baseDelay = 10000000
+	factor    = 1.1
+	jitter    = 0.2
+)
+
+type gemPortKey struct {
+	intfID  uint32
+	gemPort uint32
+}
+
+type pendingFlowDeleteKey struct {
+	intfID uint32
+	onuID  uint32
+	uniID  uint32
+}
+
+type tpLockKey struct {
+	intfID uint32
+	onuID  uint32
+	uniID  uint32
+}
+
+type schedQueue struct {
+	direction    tp_pb.Direction
+	intfID       uint32
+	onuID        uint32
+	uniID        uint32
+	tpID         uint32
+	uniPort      uint32
+	tpInst       interface{}
+	meterID      uint32
+	flowMetadata *voltha.FlowMetadata
+}
+
+type queueInfoBrief struct {
+	gemPortID       uint32
+	servicePriority uint32
+}
+
+//OpenOltFlowMgr creates the Structure of OpenOltFlowMgr obj
+type OpenOltFlowMgr struct {
+	techprofile        map[uint32]tp.TechProfileIf
+	deviceHandler      *DeviceHandler
+	resourceMgr        *rsrcMgr.OpenOltResourceMgr
+	onuIdsLock         sync.RWMutex
+	perGemPortLock     *mapmutex.Mutex                    // lock to be used to access the flowsUsedByGemPort map
+	flowsUsedByGemPort map[gemPortKey][]uint32            //gem port id to flow ids
+	packetInGemPort    map[rsrcMgr.PacketInInfoKey]uint32 //packet in gem port local cache
+	onuGemInfo map[uint32][]rsrcMgr.OnuGemInfo //onu, gem and uni info local cache, indexed by IntfId
+	onuGemInfoLock    sync.RWMutex
+	pendingFlowDelete sync.Map
+	perUserFlowHandleLock    *mapmutex.Mutex
+	interfaceToMcastQueueMap map[uint32]*queueInfoBrief /*pon interface -> multicast queue map. Required to assign GEM to a bucket during group population*/
+}
+
+var autoAddFlow bool = true
+var noticeDownloadRequest bool = false
+var mapCreateScheduler map[string]bool = map[string]bool{}
+var mapAddFlow map[string]bool = map[string]bool{}
+
+func resetFlowMap() {
+	mapCreateScheduler = map[string]bool{}
+	mapAddFlow = map[string]bool{}
+}
+
+//NewFlowManager creates OpenOltFlowMgr object and initializes the parameters
+func NewFlowManager(ctx context.Context, dh *DeviceHandler, rMgr *rsrcMgr.OpenOltResourceMgr) *OpenOltFlowMgr {
+	logger.Infow(ctx, "initializing-flow-manager", log.Fields{"device-id": dh.device.Id})
+	var flowMgr OpenOltFlowMgr
+	var err error
+	var idx uint32
+
+	flowMgr.deviceHandler = dh
+	flowMgr.resourceMgr = rMgr
+	flowMgr.techprofile = make(map[uint32]tp.TechProfileIf)
+	if err = flowMgr.populateTechProfilePerPonPort(ctx); err != nil {
+		logger.Errorw(ctx, "error-while-populating-tech-profile-mgr", log.Fields{"error": err})
+		return nil
+	}
+	flowMgr.onuIdsLock = sync.RWMutex{}
+	flowMgr.flowsUsedByGemPort = make(map[gemPortKey][]uint32)
+	flowMgr.packetInGemPort = make(map[rsrcMgr.PacketInInfoKey]uint32)
+	ponPorts := rMgr.DevInfo.GetPonPorts()
+	flowMgr.onuGemInfo = make(map[uint32][]rsrcMgr.OnuGemInfo, ponPorts)
+	for idx = 0; idx < ponPorts; idx++ {
+		if flowMgr.onuGemInfo[idx], err = rMgr.GetOnuGemInfo(ctx, idx); err != nil {
+			logger.Error(ctx, "failed-to-load-onu-gem-info-cache")
+		}
+		//Load flowID list per gem map per interface from the kvstore.
+		flowMgr.loadFlowIDlistForGem(ctx, idx)
+	}
+	flowMgr.onuGemInfoLock = sync.RWMutex{}
+	flowMgr.pendingFlowDelete = sync.Map{}
+	flowMgr.perUserFlowHandleLock = mapmutex.NewCustomizedMapMutex(maxRetry, maxDelay, baseDelay, factor, jitter)
+	flowMgr.perGemPortLock = mapmutex.NewCustomizedMapMutex(maxRetry, maxDelay, baseDelay, factor, jitter)
+	flowMgr.interfaceToMcastQueueMap = make(map[uint32]*queueInfoBrief)
+	flowMgr.loadInterfaceToMulticastQueueMap(ctx)
+	logger.Info(ctx, "initialization-of-flow-manager-success")
+	return &flowMgr
+}
+
+func (f *OpenOltFlowMgr) registerFlow(ctx context.Context, flowFromCore *ofp.OfpFlowStats, deviceFlow *openoltpb2.Flow) error {
+	gemPK := gemPortKey{uint32(deviceFlow.AccessIntfId), uint32(deviceFlow.GemportId)}
+	if f.perGemPortLock.TryLock(gemPK) {
+		logger.Debugw(ctx, "registering-flow-for-device ",
+			log.Fields{
+				"flow":      flowFromCore,
+				"device-id": f.deviceHandler.device.Id})
+		flowIDList, ok := f.flowsUsedByGemPort[gemPK]
+		if !ok {
+			flowIDList = []uint32{deviceFlow.FlowId}
+		}
+		flowIDList = appendUnique(flowIDList, deviceFlow.FlowId)
+		f.flowsUsedByGemPort[gemPK] = flowIDList
+
+		f.perGemPortLock.Unlock(gemPK)
+
+		// update the flowids for a gem to the KVstore
+		return f.resourceMgr.UpdateFlowIDsForGem(ctx, uint32(deviceFlow.AccessIntfId), uint32(deviceFlow.GemportId), flowIDList)
+	}
+	logger.Error(ctx, "failed-to-acquire-per-gem-port-lock",
+		log.Fields{
+			"flow-from-core": flowFromCore,
+			"device-id":      f.deviceHandler.device.Id,
+			"key":            gemPK,
+		})
+	return olterrors.NewErrAdapter("failed-to-acquire-per-gem-port-lock", log.Fields{
+		"flow-from-core": flowFromCore,
+		"device-id":      f.deviceHandler.device.Id,
+		"key":            gemPK,
+	}, nil)
+}
+
+func (f *OpenOltFlowMgr) divideAndAddFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32,
+	classifierInfo map[string]interface{}, actionInfo map[string]interface{}, flow *ofp.OfpFlowStats, TpID uint32,
+	UsMeterID uint32, DsMeterID uint32, flowMetadata *voltha.FlowMetadata) {
+	var allocID uint32
+	var gemPorts []uint32
+	var TpInst interface{}
+
+	logger.Infow(ctx, "dividing-flow", log.Fields{
+		"device-id":  f.deviceHandler.device.Id,
+		"intf-id":    intfID,
+		"onu-id":     onuID,
+		"uni-id":     uniID,
+		"port-no":    portNo,
+		"classifier": classifierInfo,
+		"action":     actionInfo,
+		"usmeter-iD": UsMeterID,
+		"dsmeter-iD": DsMeterID,
+		"tp-id":      TpID})
+	if onuID == 0 {
+		logger.Errorw(ctx, "no-onu-id-for-flow",
+			log.Fields{
+				"port-no":   portNo,
+				"classifer": classifierInfo,
+				"action":    actionInfo,
+				"device-id": f.deviceHandler.device.Id})
+		return
+	}
+
+	uni := getUniPortPath(f.deviceHandler.device.Id, intfID, int32(onuID), int32(uniID))
+	logger.Debugw(ctx, "uni-port-path", log.Fields{
+		"uni":       uni,
+		"device-id": f.deviceHandler.device.Id})
+
+	tpLockMapKey := tpLockKey{intfID, onuID, uniID}
+	if f.perUserFlowHandleLock.TryLock(tpLockMapKey) {
+		logger.Debugw(ctx, "dividing-flow-create-tcont-gem-ports", log.Fields{
+			"device-id":  f.deviceHandler.device.Id,
+			"intf-id":    intfID,
+			"onu-id":     onuID,
+			"uni-id":     uniID,
+			"port-no":    portNo,
+			"classifier": classifierInfo,
+			"action":     actionInfo,
+			"usmeter-id": UsMeterID,
+			"dsmeter-id": DsMeterID,
+			"tp-id":      TpID})
+		allocID, gemPorts, TpInst = f.createTcontGemports(ctx, intfID, onuID, uniID, uni, portNo, TpID, UsMeterID, DsMeterID, flowMetadata)
+		if allocID == 0 || gemPorts == nil || TpInst == nil {
+			logger.Error(ctx, "alloc-id-gem-ports-tp-unavailable")
+			f.perUserFlowHandleLock.Unlock(tpLockMapKey)
+			return
+		}
+		args := make(map[string]uint32)
+		args[IntfID] = intfID
+		args[OnuID] = onuID
+		args[UniID] = uniID
+		args[PortNo] = portNo
+		args[AllocID] = allocID
+
+		/* Flows can be added specific to gemport if p-bits are received.
+		 * If no pbit mentioned then adding flows for all gemports
+		 */
+		f.checkAndAddFlow(ctx, args, classifierInfo, actionInfo, flow, TpInst, gemPorts, TpID, uni)
+		f.perUserFlowHandleLock.Unlock(tpLockMapKey)
+	} else {
+		logger.Errorw(ctx, "failed-to-acquire-per-user-flow-handle-lock",
+			log.Fields{
+				"intf-id":     intfID,
+				"onu-id":      onuID,
+				"uni-id":      uniID,
+				"flow-id":     flow.Id,
+				"flow-cookie": flow.Cookie,
+				"device-id":   f.deviceHandler.device.Id})
+		return
+	}
+}
+
+// CreateSchedulerQueues creates traffic schedulers on the device with the given scheduler configuration and traffic shaping info
+func (f *OpenOltFlowMgr) CreateSchedulerQueues(ctx context.Context, sq schedQueue) error {
+
+	logger.Debugw(ctx, "CreateSchedulerQueues",
+		log.Fields{"dir": sq.direction,
+			"intf-id":      sq.intfID,
+			"onu-id":       sq.onuID,
+			"uni-id":       sq.uniID,
+			"tp-id":        sq.tpID,
+			"meter-id":     sq.meterID,
+			"tp-inst":      sq.tpInst,
+			"flowmetadata": sq.flowMetadata,
+			"device-id":    f.deviceHandler.device.Id})
+
+	Direction, err := verifyMeterIDAndGetDirection(sq.meterID, sq.direction)
+	if err != nil {
+		return err
+	}
+
+	/* Lets make a simple assumption that if the meter-id is present on the KV store,
+	 * then the scheduler and queues configuration is applied on the OLT device
+	 * in the given direction.
+	 */
+
+	var SchedCfg *tp_pb.SchedulerConfig
+	KvStoreMeter, err := f.resourceMgr.GetMeterIDForOnu(ctx, Direction, sq.intfID, sq.onuID, sq.uniID, sq.tpID)
+	if err != nil {
+		return olterrors.NewErrNotFound("meter",
+			log.Fields{"intf-id": sq.intfID,
+				"onu-id":    sq.onuID,
+				"uni-id":    sq.uniID,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	if KvStoreMeter != nil {
+		if KvStoreMeter.MeterId == sq.meterID {
+			logger.Debugw(ctx, "scheduler-already-created-for-upstream", log.Fields{"device-id": f.deviceHandler.device.Id})
+			return nil
+		}
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"unsupported":       "meter-id",
+			"kv-store-meter-id": KvStoreMeter.MeterId,
+			"meter-id-in-flow":  sq.meterID,
+			"device-id":         f.deviceHandler.device.Id}, nil)
+	}
+
+	logger.Debugw(ctx, "meter-does-not-exist-creating-new",
+		log.Fields{
+			"meter-id":  sq.meterID,
+			"direction": Direction,
+			"device-id": f.deviceHandler.device.Id})
+
+	if sq.direction == tp_pb.Direction_UPSTREAM {
+		SchedCfg, err = f.techprofile[sq.intfID].GetUsScheduler(ctx, sq.tpInst.(*tp.TechProfile))
+	} else if sq.direction == tp_pb.Direction_DOWNSTREAM {
+		SchedCfg, err = f.techprofile[sq.intfID].GetDsScheduler(ctx, sq.tpInst.(*tp.TechProfile))
+	}
+
+	if err != nil {
+		return olterrors.NewErrNotFound("scheduler-config",
+			log.Fields{
+				"intf-id":   sq.intfID,
+				"direction": sq.direction,
+				"tp-inst":   sq.tpInst,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	var meterConfig *ofp.OfpMeterConfig
+	if sq.flowMetadata != nil {
+		for _, meter := range sq.flowMetadata.Meters {
+			if sq.meterID == meter.MeterId {
+				meterConfig = meter
+				logger.Debugw(ctx, "found-meter-config-from-flowmetadata",
+					log.Fields{"meterConfig": meterConfig,
+						"device-id": f.deviceHandler.device.Id})
+				break
+			}
+		}
+	} else {
+		logger.Errorw(ctx, "flow-metadata-not-present-in-flow", log.Fields{"device-id": f.deviceHandler.device.Id})
+	}
+	if meterConfig == nil {
+		return olterrors.NewErrNotFound("meterbands", log.Fields{
+			"reason":        "Could-not-get-meterbands-from-flowMetadata",
+			"flow-metadata": sq.flowMetadata,
+			"meter-id":      sq.meterID,
+			"device-id":     f.deviceHandler.device.Id}, nil)
+	} else if len(meterConfig.Bands) < MaxMeterBand {
+		logger.Errorw(ctx, "invalid-number-of-bands-in-meter",
+			log.Fields{"Bands": meterConfig.Bands,
+				"meter-id":  sq.meterID,
+				"device-id": f.deviceHandler.device.Id})
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"reason":          "Invalid-number-of-bands-in-meter",
+			"meterband-count": len(meterConfig.Bands),
+			"metabands":       meterConfig.Bands,
+			"meter-id":        sq.meterID,
+			"device-id":       f.deviceHandler.device.Id}, nil)
+	}
+	cir := meterConfig.Bands[0].Rate
+	cbs := meterConfig.Bands[0].BurstSize
+	eir := meterConfig.Bands[1].Rate
+	ebs := meterConfig.Bands[1].BurstSize
+	pir := cir + eir
+	pbs := cbs + ebs
+	TrafficShaping := &tp_pb.TrafficShapingInfo{Cir: cir, Cbs: cbs, Pir: pir, Pbs: pbs}
+
+	TrafficSched := []*tp_pb.TrafficScheduler{f.techprofile[sq.intfID].GetTrafficScheduler(sq.tpInst.(*tp.TechProfile), SchedCfg, TrafficShaping)}
+	TrafficSched[0].TechProfileId = sq.tpID
+
+	if err := f.pushSchedulerQueuesToDevice(ctx, sq, TrafficShaping, TrafficSched); err != nil {
+		return olterrors.NewErrAdapter("failure-pushing-traffic-scheduler-and-queues-to-device",
+			log.Fields{"intf-id": sq.intfID,
+				"direction": sq.direction,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	/* After we successfully applied the scheduler configuration on the OLT device,
+	 * store the meter id on the KV store, for further reference.
+	 */
+	if err := f.resourceMgr.UpdateMeterIDForOnu(ctx, Direction, sq.intfID, sq.onuID, sq.uniID, sq.tpID, meterConfig); err != nil {
+		return olterrors.NewErrAdapter("failed-updating-meter-id",
+			log.Fields{"onu-id": sq.onuID,
+				"meter-id":  sq.meterID,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	logger.Infow(ctx, "updated-meter-info-into-kv-store-successfully",
+		log.Fields{"direction": Direction,
+			"Meter":     meterConfig,
+			"device-id": f.deviceHandler.device.Id})
+
+	return nil
+}
+
+func (f *OpenOltFlowMgr) pushSchedulerQueuesToDevice(ctx context.Context, sq schedQueue, TrafficShaping *tp_pb.TrafficShapingInfo, TrafficSched []*tp_pb.TrafficScheduler) error {
+	trafficQueues, err := f.techprofile[sq.intfID].GetTrafficQueues(ctx, sq.tpInst.(*tp.TechProfile), sq.direction)
+
+	if err != nil {
+		return olterrors.NewErrAdapter("unable-to-construct-traffic-queue-configuration",
+			log.Fields{"intf-id": sq.intfID,
+				"direction": sq.direction,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	logger.Debugw(ctx, "sending-traffic-scheduler-create-to-device",
+		log.Fields{
+			"direction":     sq.direction,
+			"TrafficScheds": TrafficSched,
+			"device-id":     f.deviceHandler.device.Id})
+	if _, err := f.deviceHandler.Client.CreateTrafficSchedulers(ctx, &tp_pb.TrafficSchedulers{
+		IntfId: sq.intfID, OnuId: sq.onuID,
+		UniId: sq.uniID, PortNo: sq.uniPort,
+		TrafficScheds: TrafficSched}); err != nil {
+		return olterrors.NewErrAdapter("failed-to-create-traffic-schedulers-in-device", log.Fields{"TrafficScheds": TrafficSched}, err)
+	}
+	logger.Infow(ctx, "successfully-created-traffic-schedulers", log.Fields{
+		"direction":      sq.direction,
+		"traffic-queues": trafficQueues,
+		"device-id":      f.deviceHandler.device.Id})
+
+	logger.Debugw(ctx, "sending-traffic-queues-create-to-device",
+		log.Fields{"direction": sq.direction,
+			"traffic-queues": trafficQueues,
+			"device-id":      f.deviceHandler.device.Id})
+	if _, err := f.deviceHandler.Client.CreateTrafficQueues(ctx,
+		&tp_pb.TrafficQueues{IntfId: sq.intfID, OnuId: sq.onuID,
+			UniId: sq.uniID, PortNo: sq.uniPort,
+			TrafficQueues: trafficQueues,
+			TechProfileId: TrafficSched[0].TechProfileId}); err != nil {
+		return olterrors.NewErrAdapter("failed-to-create-traffic-queues-in-device", log.Fields{"traffic-queues": trafficQueues}, err)
+	}
+	logger.Infow(ctx, "successfully-created-traffic-schedulers", log.Fields{
+		"direction":      sq.direction,
+		"traffic-queues": trafficQueues,
+		"device-id":      f.deviceHandler.device.Id})
+
+	if sq.direction == tp_pb.Direction_DOWNSTREAM {
+		multicastTrafficQueues := f.techprofile[sq.intfID].GetMulticastTrafficQueues(ctx, sq.tpInst.(*tp.TechProfile))
+		if len(multicastTrafficQueues) > 0 {
+			if _, present := f.interfaceToMcastQueueMap[sq.intfID]; !present {
+				//assumed that there is only one queue per PON for the multicast service
+				//the default queue with multicastQueuePerPonPort.Priority per a pon interface is used for multicast service
+				//just put it in interfaceToMcastQueueMap to use for building group members
+				logger.Debugw(ctx, "multicast-traffic-queues", log.Fields{"device-id": f.deviceHandler.device.Id})
+				multicastQueuePerPonPort := multicastTrafficQueues[0]
+				f.interfaceToMcastQueueMap[sq.intfID] = &queueInfoBrief{
+					gemPortID:       multicastQueuePerPonPort.GemportId,
+					servicePriority: multicastQueuePerPonPort.Priority,
+				}
+				//also store the queue info in kv store
+				if err := f.resourceMgr.AddMcastQueueForIntf(ctx, sq.intfID, multicastQueuePerPonPort.GemportId, multicastQueuePerPonPort.Priority); err != nil {
+					logger.Errorw(ctx, "failed-to-add-mcast-queue", log.Fields{"error": err})
+					return err
+				}
+
+				logger.Infow(ctx, "multicast-queues-successfully-updated", log.Fields{"device-id": f.deviceHandler.device.Id})
+			}
+		}
+	}
+	return nil
+}
+
+// RemoveSchedulerQueues removes the traffic schedulers from the device based on the given scheduler configuration and traffic shaping info
+func (f *OpenOltFlowMgr) RemoveSchedulerQueues(ctx context.Context, sq schedQueue) error {
+
+	var Direction string
+	var SchedCfg *tp_pb.SchedulerConfig
+	var err error
+	logger.Infow(ctx, "removing-schedulers-and-queues-in-olt",
+		log.Fields{
+			"direction": sq.direction,
+			"intf-id":   sq.intfID,
+			"onu-id":    sq.onuID,
+			"uni-id":    sq.uniID,
+			"uni-port":  sq.uniPort,
+			"device-id": f.deviceHandler.device.Id})
+	if sq.direction == tp_pb.Direction_UPSTREAM {
+		SchedCfg, err = f.techprofile[sq.intfID].GetUsScheduler(ctx, sq.tpInst.(*tp.TechProfile))
+		Direction = "upstream"
+	} else if sq.direction == tp_pb.Direction_DOWNSTREAM {
+		SchedCfg, err = f.techprofile[sq.intfID].GetDsScheduler(ctx, sq.tpInst.(*tp.TechProfile))
+		Direction = "downstream"
+	}
+
+	if err != nil {
+		return olterrors.NewErrNotFound("scheduler-config",
+			log.Fields{
+				"int-id":    sq.intfID,
+				"direction": sq.direction,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	KVStoreMeter, err := f.resourceMgr.GetMeterIDForOnu(ctx, Direction, sq.intfID, sq.onuID, sq.uniID, sq.tpID)
+	if err != nil {
+		return olterrors.NewErrNotFound("meter",
+			log.Fields{
+				"onu-id":    sq.onuID,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	if KVStoreMeter == nil {
+		logger.Warnw(ctx, "no-meter-installed-yet",
+			log.Fields{
+				"direction": Direction,
+				"intf-id":   sq.intfID,
+				"onu-id":    sq.onuID,
+				"uni-id":    sq.uniID,
+				"device-id": f.deviceHandler.device.Id})
+		return nil
+	}
+	cir := KVStoreMeter.Bands[0].Rate
+	cbs := KVStoreMeter.Bands[0].BurstSize
+	eir := KVStoreMeter.Bands[1].Rate
+	ebs := KVStoreMeter.Bands[1].BurstSize
+	pir := cir + eir
+	pbs := cbs + ebs
+
+	TrafficShaping := &tp_pb.TrafficShapingInfo{Cir: cir, Cbs: cbs, Pir: pir, Pbs: pbs}
+
+	TrafficSched := []*tp_pb.TrafficScheduler{f.techprofile[sq.intfID].GetTrafficScheduler(sq.tpInst.(*tp.TechProfile), SchedCfg, TrafficShaping)}
+	TrafficSched[0].TechProfileId = sq.tpID
+
+	TrafficQueues, err := f.techprofile[sq.intfID].GetTrafficQueues(ctx, sq.tpInst.(*tp.TechProfile), sq.direction)
+	if err != nil {
+		return olterrors.NewErrAdapter("unable-to-construct-traffic-queue-configuration",
+			log.Fields{
+				"intf-id":   sq.intfID,
+				"direction": sq.direction,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	if _, err = f.deviceHandler.Client.RemoveTrafficQueues(ctx,
+		&tp_pb.TrafficQueues{IntfId: sq.intfID, OnuId: sq.onuID,
+			UniId: sq.uniID, PortNo: sq.uniPort,
+			TrafficQueues: TrafficQueues,
+			TechProfileId: TrafficSched[0].TechProfileId}); err != nil {
+		return olterrors.NewErrAdapter("unable-to-remove-traffic-queues-from-device",
+			log.Fields{
+				"intf-id":        sq.intfID,
+				"traffic-queues": TrafficQueues,
+				"device-id":      f.deviceHandler.device.Id}, err)
+	}
+	logger.Infow(ctx, "removed-traffic-queues-successfully", log.Fields{"device-id": f.deviceHandler.device.Id})
+	if _, err = f.deviceHandler.Client.RemoveTrafficSchedulers(ctx, &tp_pb.TrafficSchedulers{
+		IntfId: sq.intfID, OnuId: sq.onuID,
+		UniId: sq.uniID, PortNo: sq.uniPort,
+		TrafficScheds: TrafficSched}); err != nil {
+		return olterrors.NewErrAdapter("unable-to-remove-traffic-schedulers-from-device",
+			log.Fields{
+				"intf-id":            sq.intfID,
+				"traffic-schedulers": TrafficSched}, err)
+	}
+
+	logger.Infow(ctx, "removed-traffic-schedulers-successfully", log.Fields{"device-id": f.deviceHandler.device.Id})
+
+	/* After we successfully remove the scheduler configuration on the OLT device,
+	 * delete the meter id on the KV store.
+	 */
+	err = f.resourceMgr.RemoveMeterIDForOnu(ctx, Direction, sq.intfID, sq.onuID, sq.uniID, sq.tpID)
+	if err != nil {
+		return olterrors.NewErrAdapter("unable-to-remove-meter",
+			log.Fields{
+				"onu":       sq.onuID,
+				"meter":     KVStoreMeter.MeterId,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	logger.Infow(ctx, "removed-meter-from-KV-store-successfully",
+		log.Fields{
+			"meter-id":  KVStoreMeter.MeterId,
+			"dir":       Direction,
+			"device-id": f.deviceHandler.device.Id})
+	return err
+}
+
+// This function allocates tconts and GEM ports for an ONU
+func (f *OpenOltFlowMgr) createTcontGemports(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, uni string, uniPort uint32, TpID uint32, UsMeterID uint32, DsMeterID uint32, flowMetadata *voltha.FlowMetadata) (uint32, []uint32, interface{}) {
+	var allocIDs []uint32
+	var allgemPortIDs []uint32
+	var gemPortIDs []uint32
+	tpInstanceExists := false
+	var err error
+
+	allocIDs = f.resourceMgr.GetCurrentAllocIDsForOnu(ctx, intfID, onuID, uniID)
+	allgemPortIDs = f.resourceMgr.GetCurrentGEMPortIDsForOnu(ctx, intfID, onuID, uniID)
+
+	tpPath := f.getTPpath(ctx, intfID, uni, TpID)
+
+	logger.Debugw(ctx, "creating-new-tcont-and-gem", log.Fields{
+		"intf-id":   intfID,
+		"onu-id":    onuID,
+		"uni-id":    uniID,
+		"device-id": f.deviceHandler.device.Id,
+		"tp-id":     TpID})
+
+	techProfileInstance, _ := f.techprofile[intfID].GetTPInstanceFromKVStore(ctx, TpID, tpPath)
+	if techProfileInstance == nil {
+		logger.Infow(ctx, "tp-instance-not-found--creating-new",
+			log.Fields{
+				"path":      tpPath,
+				"device-id": f.deviceHandler.device.Id})
+		techProfileInstance, err = f.techprofile[intfID].CreateTechProfInstance(ctx, TpID, uni, intfID)
+		if err != nil {
+			// This should not happen, something wrong in KV backend transaction
+			logger.Errorw(ctx, "tp-instance-create-failed",
+				log.Fields{
+					"error":     err,
+					"tp-id":     TpID,
+					"device-id": f.deviceHandler.device.Id})
+			return 0, nil, nil
+		}
+		if err := f.resourceMgr.UpdateTechProfileIDForOnu(ctx, intfID, onuID, uniID, TpID); err != nil {
+			logger.Warnw(ctx, "failed-to-update-tech-profile-id", log.Fields{"error": err})
+		}
+	} else {
+		logger.Debugw(ctx, "tech-profile-instance-already-exist-for-given port-name",
+			log.Fields{
+				"uni":       uni,
+				"device-id": f.deviceHandler.device.Id})
+		tpInstanceExists = true
+	}
+
+	switch tpInst := techProfileInstance.(type) {
+	case *tp.TechProfile:
+		if UsMeterID != 0 {
+			sq := schedQueue{direction: tp_pb.Direction_UPSTREAM, intfID: intfID, onuID: onuID, uniID: uniID, tpID: TpID,
+				uniPort: uniPort, tpInst: techProfileInstance, meterID: UsMeterID, flowMetadata: flowMetadata}
+			if err := f.CreateSchedulerQueues(ctx, sq); err != nil {
+				logger.Errorw(ctx, "CreateSchedulerQueues-failed-upstream",
+					log.Fields{
+						"error":     err,
+						"meter-id":  UsMeterID,
+						"device-id": f.deviceHandler.device.Id})
+				return 0, nil, nil
+			}
+		}
+		if DsMeterID != 0 {
+			sq := schedQueue{direction: tp_pb.Direction_DOWNSTREAM, intfID: intfID, onuID: onuID, uniID: uniID, tpID: TpID,
+				uniPort: uniPort, tpInst: techProfileInstance, meterID: DsMeterID, flowMetadata: flowMetadata}
+			if err := f.CreateSchedulerQueues(ctx, sq); err != nil {
+				logger.Errorw(ctx, "CreateSchedulerQueues-failed-downstream",
+					log.Fields{
+						"error":     err,
+						"meter-id":  DsMeterID,
+						"device-id": f.deviceHandler.device.Id})
+				return 0, nil, nil
+			}
+		}
+		allocID := tpInst.UsScheduler.AllocID
+		for _, gem := range tpInst.UpstreamGemPortAttributeList {
+			gemPortIDs = append(gemPortIDs, gem.GemportID)
+		}
+		allocIDs = appendUnique(allocIDs, allocID)
+
+		if tpInstanceExists {
+			return allocID, gemPortIDs, techProfileInstance
+		}
+
+		for _, gemPortID := range gemPortIDs {
+			allgemPortIDs = appendUnique(allgemPortIDs, gemPortID)
+		}
+		logger.Infow(ctx, "allocated-tcont-and-gem-ports",
+			log.Fields{
+				"alloc-ids": allocIDs,
+				"gemports":  allgemPortIDs,
+				"device-id": f.deviceHandler.device.Id})
+		// Send Tconts and GEM ports to KV store
+		f.storeTcontsGEMPortsIntoKVStore(ctx, intfID, onuID, uniID, allocIDs, allgemPortIDs)
+		return allocID, gemPortIDs, techProfileInstance
+	case *tp.EponProfile:
+		// CreateSchedulerQueues for EPON needs to be implemented here
+		// when voltha-protos for EPON is completed.
+
+		// TODO
+		if UsMeterID != 0 {
+			go func() {
+				sq := schedQueue{direction: tp_pb.Direction_UPSTREAM, intfID: intfID, onuID: onuID, uniID: uniID, tpID: TpID,
+					uniPort: uniPort, tpInst: techProfileInstance, meterID: UsMeterID, flowMetadata: flowMetadata}
+				if err := f.L2oamCreateSchedulerQueues(ctx, sq); err != nil {
+					logger.Errorw(ctx, "CreateSchedulerQueues-failed-upstream",
+						log.Fields{
+							"error":     err,
+							"meter-id":  UsMeterID,
+							"device-id": f.deviceHandler.device.Id})
+					//return 0, nil, nil
+				}
+			}()
+		}
+		/*
+			if DsMeterID != 0 {
+					sq := schedQueue{direction: tp_pb.Direction_DOWNSTREAM, intfID: intfID, onuID: onuID, uniID: uniID, tpID: TpID,
+						uniPort: uniPort, tpInst: techProfileInstance, meterID: DsMeterID, flowMetadata: flowMetadata}
+					if err := f.L2oamCreateSchedulerQueues(ctx, sq); err != nil {
+						logger.Errorw(ctx, "CreateSchedulerQueues-failed-downstream",
+							log.Fields{
+								"error":     err,
+								"meter-id":  DsMeterID,
+								"device-id": f.deviceHandler.device.Id})
+						return 0, nil, nil
+					}
+			}
+		*/
+
+		allocID := tpInst.AllocID
+		for _, gem := range tpInst.UpstreamQueueAttributeList {
+			gemPortIDs = append(gemPortIDs, gem.GemportID)
+		}
+		allocIDs = appendUnique(allocIDs, allocID)
+
+		if tpInstanceExists {
+			return allocID, gemPortIDs, techProfileInstance
+		}
+
+		for _, gemPortID := range gemPortIDs {
+			allgemPortIDs = appendUnique(allgemPortIDs, gemPortID)
+		}
+		logger.Infow(ctx, "allocated-tcont-and-gem-ports",
+			log.Fields{
+				"alloc-ids": allocIDs,
+				"gemports":  allgemPortIDs,
+				"device-id": f.deviceHandler.device.Id})
+		// Send Tconts and GEM ports to KV store
+		f.storeTcontsGEMPortsIntoKVStore(ctx, intfID, onuID, uniID, allocIDs, allgemPortIDs)
+		return allocID, gemPortIDs, techProfileInstance
+	default:
+		logger.Errorw(ctx, "unknown-tech",
+			log.Fields{
+				"tpInst": tpInst})
+		return 0, nil, nil
+	}
+}
+
+func (f *OpenOltFlowMgr) storeTcontsGEMPortsIntoKVStore(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, allocID []uint32, gemPortIDs []uint32) {
+
+	logger.Debugw(ctx, "storing-allocated-tconts-and-gem-ports-into-KV-store",
+		log.Fields{
+			"intf-id":     intfID,
+			"onu-id":      onuID,
+			"uni-id":      uniID,
+			"alloc-id":    allocID,
+			"gemport-ids": gemPortIDs,
+			"device-id":   f.deviceHandler.device.Id})
+	/* Update the allocated alloc_id and gem_port_id for the ONU/UNI to KV store  */
+	if err := f.resourceMgr.UpdateAllocIdsForOnu(ctx, intfID, onuID, uniID, allocID); err != nil {
+		logger.Errorw(ctx, "error-while-uploading-allocid-to-kv-store", log.Fields{"device-id": f.deviceHandler.device.Id})
+	}
+	if err := f.resourceMgr.UpdateGEMPortIDsForOnu(ctx, intfID, onuID, uniID, gemPortIDs); err != nil {
+		logger.Errorw(ctx, "error-while-uploading-gemports-to-kv-store", log.Fields{"device-id": f.deviceHandler.device.Id})
+	}
+	if err := f.resourceMgr.UpdateGEMportsPonportToOnuMapOnKVStore(ctx, gemPortIDs, intfID, onuID, uniID); err != nil {
+		logger.Error(ctx, "error-while-uploading-gemtopon-map-to-kv-store", log.Fields{"device-id": f.deviceHandler.device.Id})
+	}
+	logger.Infow(ctx, "stored-tconts-and-gem-into-kv-store-successfully", log.Fields{"device-id": f.deviceHandler.device.Id})
+	for _, gemPort := range gemPortIDs {
+		f.addGemPortToOnuInfoMap(ctx, intfID, onuID, gemPort)
+	}
+}
+
+func (f *OpenOltFlowMgr) populateTechProfilePerPonPort(ctx context.Context) error {
+	var tpCount int
+	for _, techRange := range f.resourceMgr.DevInfo.Ranges {
+		for _, intfID := range techRange.IntfIds {
+			f.techprofile[intfID] = f.resourceMgr.ResourceMgrs[uint32(intfID)].TechProfileMgr
+			tpCount++
+			logger.Debugw(ctx, "init-tech-profile-done",
+				log.Fields{
+					"intf-id":   intfID,
+					"device-id": f.deviceHandler.device.Id})
+		}
+	}
+	if tpCount != int(f.resourceMgr.DevInfo.GetPonPorts()) {
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"reason":             "tP-count-does-not-match-number-of-pon-ports",
+			"tech-profile-count": tpCount,
+			"pon-port-count":     f.resourceMgr.DevInfo.GetPonPorts(),
+			"device-id":          f.deviceHandler.device.Id}, nil)
+	}
+	logger.Infow(ctx, "populated-techprofile-for-ponports-successfully",
+		log.Fields{
+			"numofTech":   tpCount,
+			"numPonPorts": f.resourceMgr.DevInfo.GetPonPorts(),
+			"device-id":   f.deviceHandler.device.Id})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) addUpstreamDataFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32,
+	portNo uint32, uplinkClassifier map[string]interface{},
+	uplinkAction map[string]interface{}, logicalFlow *ofp.OfpFlowStats,
+	allocID uint32, gemportID uint32, tpID uint32) error {
+	uplinkClassifier[PacketTagType] = SingleTag
+	logger.Debugw(ctx, "adding-upstream-data-flow",
+		log.Fields{
+			"uplinkClassifier": uplinkClassifier,
+			"uplinkAction":     uplinkAction})
+	return f.addHSIAFlow(ctx, intfID, onuID, uniID, portNo, uplinkClassifier, uplinkAction,
+		Upstream, logicalFlow, allocID, gemportID, tpID)
+	/* TODO: Install Secondary EAP on the subscriber vlan */
+}
+
+func (f *OpenOltFlowMgr) addDownstreamDataFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32,
+	portNo uint32, downlinkClassifier map[string]interface{},
+	downlinkAction map[string]interface{}, logicalFlow *ofp.OfpFlowStats,
+	allocID uint32, gemportID uint32, tpID uint32) error {
+	downlinkClassifier[PacketTagType] = DoubleTag
+	logger.Debugw(ctx, "adding-downstream-data-flow",
+		log.Fields{
+			"downlinkClassifier": downlinkClassifier,
+			"downlinkAction":     downlinkAction})
+	if vlan, exists := downlinkClassifier[VlanVid]; exists {
+		if vlan.(uint32) == (uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 4000) { //private VLAN given by core
+			if metadata, exists := downlinkClassifier[Metadata]; exists { // inport is filled in metadata by core
+				if uint32(metadata.(uint64)) == MkUniPortNum(ctx, intfID, onuID, uniID) {
+					logger.Infow(ctx, "ignoring-dl-trap-device-flow-from-core",
+						log.Fields{
+							"flow":      logicalFlow,
+							"device-id": f.deviceHandler.device.Id,
+							"onu-id":    onuID,
+							"intf-id":   intfID})
+					return nil
+				}
+			}
+		}
+	}
+
+	/* Already this info available classifier? */
+	downlinkAction[PopVlan] = true
+	dlClVid, ok := downlinkClassifier[VlanVid].(uint32)
+	if ok {
+		downlinkAction[VlanVid] = dlClVid & 0xfff
+	} else {
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"reason":    "failed-to-convert-vlanid-classifier",
+			"vlan-id":   VlanVid,
+			"device-id": f.deviceHandler.device.Id}, nil).Log()
+	}
+
+	return f.addHSIAFlow(ctx, intfID, onuID, uniID, portNo, downlinkClassifier, downlinkAction,
+		Downstream, logicalFlow, allocID, gemportID, tpID)
+}
+
+func (f *OpenOltFlowMgr) addHSIAFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32, classifier map[string]interface{},
+	action map[string]interface{}, direction string, logicalFlow *ofp.OfpFlowStats,
+	allocID uint32, gemPortID uint32, tpID uint32) error {
+	/* One of the OLT platform (Broadcom BAL) requires that symmetric
+	   flows require the same flow_id to be used across UL and DL.
+	   Since HSIA flow is the only symmetric flow currently, we need to
+	   re-use the flow_id across both direction. The 'flow_category'
+	   takes priority over flow_cookie to find any available HSIA_FLOW
+	   id for the ONU.
+	*/
+	logger.Infow(ctx, "adding-hsia-flow",
+		log.Fields{
+			"intf-id":     intfID,
+			"onu-id":      onuID,
+			"uni-id":      uniID,
+			"device-id":   f.deviceHandler.device.Id,
+			"classifier":  classifier,
+			"action":      action,
+			"direction":   direction,
+			"alloc-id":    allocID,
+			"gemport-id":  gemPortID,
+			"logicalflow": *logicalFlow})
+	var vlanPbit uint32 = 0xff // means no pbit
+	var vlanVid uint32
+	if _, ok := classifier[VlanPcp]; ok {
+		vlanPbit = classifier[VlanPcp].(uint32)
+		logger.Debugw(ctx, "found-pbit-in-flow",
+			log.Fields{
+				"vlan-pbit": vlanPbit,
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"device-id": f.deviceHandler.device.Id})
+	} else {
+		logger.Debugw(ctx, "pbit-not-found-in-flow",
+			log.Fields{
+				"vlan-pcp":  VlanPcp,
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"device-id": f.deviceHandler.device.Id})
+	}
+	if _, ok := classifier[VlanVid]; ok {
+		vlanVid = classifier[VlanVid].(uint32)
+		logger.Debugw(ctx, "found-vlan-in-the-flow",
+			log.Fields{
+				"vlan-vid":  vlanVid,
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"device-id": f.deviceHandler.device.Id})
+	}
+	flowStoreCookie := getFlowStoreCookie(ctx, classifier, gemPortID)
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(intfID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "flow-already-exists",
+			log.Fields{
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID,
+				"onu-id":    onuID})
+		return nil
+	}
+	flowID, err := f.resourceMgr.GetFlowID(ctx, intfID, int32(onuID), int32(uniID), gemPortID, flowStoreCookie, HsiaFlow, vlanVid, vlanPbit)
+	if err != nil {
+		return olterrors.NewErrNotFound("hsia-flow-id",
+			log.Fields{
+				"direction": direction,
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+			}, err).Log()
+	}
+	classifierProto, err := makeOpenOltClassifierField(classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Debugw(ctx, "created-classifier-proto",
+		log.Fields{
+			"classifier": *classifierProto,
+			"device-id":  f.deviceHandler.device.Id})
+	actionProto, err := makeOpenOltActionField(action, classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": action, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Debugw(ctx, "created-action-proto",
+		log.Fields{
+			"action":    *actionProto,
+			"device-id": f.deviceHandler.device.Id})
+	networkIntfID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-interface-id",
+			log.Fields{
+				"classifier": classifier,
+				"action":     action,
+				"device-id":  f.deviceHandler.device.Id,
+			}, err).Log()
+	}
+	flow := openoltpb2.Flow{AccessIntfId: int32(intfID),
+		OnuId:         int32(onuID),
+		UniId:         int32(uniID),
+		FlowId:        flowID,
+		FlowType:      direction,
+		AllocId:       int32(allocID),
+		NetworkIntfId: int32(networkIntfID),
+		GemportId:     int32(gemPortID),
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo,
+		TechProfileId: tpID,
+	}
+	if err := f.addFlowToDevice(ctx, logicalFlow, &flow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, nil, err).Log()
+	}
+	logger.Infow(ctx, "hsia-flow-added-to-device-successfully",
+		log.Fields{"direction": direction,
+			"device-id": f.deviceHandler.device.Id,
+			"flow":      flow,
+			"intf-id":   intfID,
+			"onu-id":    onuID})
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &flow, flowStoreCookie, HsiaFlow, flowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, flow.AccessIntfId,
+		flow.OnuId,
+		flow.UniId,
+		flow.FlowId /*flowCategory,*/, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flowID,
+			log.Fields{
+				"flow":      flow,
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID,
+				"onu-id":    onuID}, err).Log()
+	}
+
+	go f.l2oamAddFlowDevice(ctx, intfID, onuID, classifierProto.OVid, classifierProto.IVid)
+
+	return nil
+}
+
+func (f *OpenOltFlowMgr) addDHCPTrapFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32,
+	classifier map[string]interface{}, action map[string]interface{}, logicalFlow *ofp.OfpFlowStats, allocID uint32,
+	gemPortID uint32, tpID uint32) error {
+
+	networkIntfID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-interface-id", log.Fields{
+			"classifier": classifier,
+			"action":     action,
+			"device-id":  f.deviceHandler.device.Id},
+			err).Log()
+	}
+
+	for k := range action {
+		delete(action, k)
+	}
+
+	action[TrapToHost] = true
+	classifier[UDPSrc] = uint32(68)
+	classifier[UDPDst] = uint32(67)
+	classifier[PacketTagType] = SingleTag
+
+	flowStoreCookie := getFlowStoreCookie(ctx, classifier, gemPortID)
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(intfID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "flow-exists--not-re-adding",
+			log.Fields{
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID,
+				"onu-id":    onuID})
+		return nil
+	}
+
+	flowID, err := f.resourceMgr.GetFlowID(ctx, intfID, int32(onuID), int32(uniID), gemPortID, flowStoreCookie, DhcpFlow, 0 /*classifier[VLAN_PCP].(uint32)*/)
+
+	if err != nil {
+		return olterrors.NewErrNotFound("flow",
+			log.Fields{
+				"interface-id": intfID,
+				"gem-port":     gemPortID,
+				"cookie":       flowStoreCookie,
+				"device-id":    f.deviceHandler.device.Id},
+			err).Log()
+	}
+
+	logger.Debugw(ctx, "creating-ul-dhcp-flow",
+		log.Fields{
+			"ul_classifier": classifier,
+			"ul_action":     action,
+			"uplinkFlowId":  flowID,
+			"intf-id":       intfID,
+			"onu-id":        onuID,
+			"device-id":     f.deviceHandler.device.Id})
+
+	classifierProto, err := makeOpenOltClassifierField(classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err).Log()
+	}
+	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": *classifierProto})
+	actionProto, err := makeOpenOltActionField(action, classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err).Log()
+	}
+
+	dhcpFlow := openoltpb2.Flow{AccessIntfId: int32(intfID),
+		OnuId:         int32(onuID),
+		UniId:         int32(uniID),
+		FlowId:        flowID,
+		FlowType:      Upstream,
+		AllocId:       int32(allocID),
+		NetworkIntfId: int32(networkIntfID),
+		GemportId:     int32(gemPortID),
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo,
+		TechProfileId: tpID,
+	}
+	if err := f.addFlowToDevice(ctx, logicalFlow, &dhcpFlow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, log.Fields{"dhcp-flow": dhcpFlow}, err).Log()
+	}
+	logger.Infow(ctx, "dhcp-ul-flow-added-to-device-successfully",
+		log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"flow-id":   flowID,
+			"intf-id":   intfID,
+			"onu-id":    onuID})
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &dhcpFlow, flowStoreCookie, "DHCP", flowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, dhcpFlow.AccessIntfId,
+		dhcpFlow.OnuId,
+		dhcpFlow.UniId,
+		dhcpFlow.FlowId, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", dhcpFlow.FlowId,
+			log.Fields{
+				"flow":      dhcpFlow,
+				"device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+
+	return nil
+}
+
+//addIGMPTrapFlow creates IGMP trap-to-host flow
+func (f *OpenOltFlowMgr) addIGMPTrapFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32, classifier map[string]interface{},
+	action map[string]interface{}, logicalFlow *ofp.OfpFlowStats, allocID uint32, gemPortID uint32, tpID uint32) error {
+	return f.addUpstreamTrapFlow(ctx, intfID, onuID, uniID, portNo, classifier, action, logicalFlow, allocID, gemPortID, IgmpFlow, tpID)
+}
+
+//addUpstreamTrapFlow creates a trap-to-host flow
+func (f *OpenOltFlowMgr) addUpstreamTrapFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32, classifier map[string]interface{},
+	action map[string]interface{}, logicalFlow *ofp.OfpFlowStats, allocID uint32, gemPortID uint32, flowType string, tpID uint32) error {
+
+	networkIntfID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-interface-id",
+			log.Fields{
+				"classifier": classifier,
+				"action":     action,
+				"device-id":  f.deviceHandler.device.Id},
+			err).Log()
+	}
+
+	for k := range action {
+		delete(action, k)
+	}
+
+	action[TrapToHost] = true
+	classifier[PacketTagType] = SingleTag
+	delete(classifier, VlanVid)
+
+	flowStoreCookie := getFlowStoreCookie(ctx, classifier, gemPortID)
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(networkIntfID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "flow-exists-not-re-adding", log.Fields{"device-id": f.deviceHandler.device.Id})
+		return nil
+	}
+
+	flowID, err := f.resourceMgr.GetFlowID(ctx, intfID, int32(onuID), int32(uniID), gemPortID, flowStoreCookie, flowType, 0, 0 /*classifier[VLAN_PCP].(uint32)*/)
+
+	if err != nil {
+		return olterrors.NewErrNotFound("flow-id",
+			log.Fields{
+				"intf-id":   intfID,
+				"oni-id":    onuID,
+				"cookie":    flowStoreCookie,
+				"flow-type": flowType,
+				"device-id": f.deviceHandler.device.Id,
+				"onu-id":    onuID},
+			err).Log()
+	}
+
+	logger.Debugw(ctx, "creating-upstream-trap-flow",
+		log.Fields{
+			"ul_classifier": classifier,
+			"ul_action":     action,
+			"uplinkFlowId":  flowID,
+			"flowType":      flowType,
+			"device-id":     f.deviceHandler.device.Id,
+			"intf-id":       intfID,
+			"onu-id":        onuID})
+
+	classifierProto, err := makeOpenOltClassifierField(classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Debugw(ctx, "created-classifier-proto",
+		log.Fields{
+			"classifier": *classifierProto,
+			"device-id":  f.deviceHandler.device.Id})
+	actionProto, err := makeOpenOltActionField(action, classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": action, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+
+	flow := openoltpb2.Flow{AccessIntfId: int32(intfID),
+		OnuId:         int32(onuID),
+		UniId:         int32(uniID),
+		FlowId:        flowID,
+		FlowType:      Upstream,
+		AllocId:       int32(allocID),
+		NetworkIntfId: int32(networkIntfID),
+		GemportId:     int32(gemPortID),
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo,
+		TechProfileId: tpID,
+	}
+
+	if err := f.addFlowToDevice(ctx, logicalFlow, &flow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, log.Fields{"flow": flow, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Infof(ctx, "%s ul-flow-added-to-device-successfully", flowType)
+
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &flow, flowStoreCookie, flowType, flowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, flow.AccessIntfId,
+		flow.OnuId,
+		flow.UniId,
+		flow.FlowId, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flow.FlowId, log.Fields{"flow": flow, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+
+	return nil
+}
+
+// Add EAPOL flow to  device with mac, vlanId as classifier for upstream and downstream
+func (f *OpenOltFlowMgr) addEAPOLFlow(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, portNo uint32,
+	classifier map[string]interface{}, action map[string]interface{}, logicalFlow *ofp.OfpFlowStats, allocID uint32,
+	gemPortID uint32, vlanID uint32, tpID uint32) error {
+	logger.Infow(ctx, "adding-eapol-to-device",
+		log.Fields{
+			"intf-id":    intfID,
+			"onu-id":     onuID,
+			"port-no":    portNo,
+			"alloc-id":   allocID,
+			"gemport-id": gemPortID,
+			"vlan-id":    vlanID,
+			"flow":       logicalFlow})
+
+	uplinkClassifier := make(map[string]interface{})
+	uplinkAction := make(map[string]interface{})
+
+	uplinkClassifier[EthType] = uint32(EapEthType)
+	uplinkClassifier[PacketTagType] = SingleTag
+	uplinkClassifier[VlanVid] = vlanID
+	uplinkClassifier[VlanPcp] = classifier[VlanPcp]
+	uplinkAction[TrapToHost] = true
+	flowStoreCookie := getFlowStoreCookie(ctx, uplinkClassifier, gemPortID)
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(intfID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "flow-exists-not-re-adding", log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"onu-id":    onuID,
+			"intf-id":   intfID})
+		return nil
+	}
+	uplinkFlowID, err := f.resourceMgr.GetFlowID(ctx, intfID, int32(onuID), int32(uniID), gemPortID, flowStoreCookie, "", 0, 0)
+	if err != nil {
+		return olterrors.NewErrNotFound("flow-id",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"coookie":   flowStoreCookie,
+				"device-id": f.deviceHandler.device.Id},
+			err).Log()
+	}
+	logger.Debugw(ctx, "creating-ul-eapol-flow",
+		log.Fields{
+			"ul_classifier": uplinkClassifier,
+			"ul_action":     uplinkAction,
+			"uplinkFlowId":  uplinkFlowID,
+			"device-id":     f.deviceHandler.device.Id,
+			"intf-id":       intfID,
+			"onu-id":        onuID})
+
+	classifierProto, err := makeOpenOltClassifierField(uplinkClassifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"classifier": uplinkClassifier,
+			"device-id":  f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Debugw(ctx, "created-classifier-proto",
+		log.Fields{
+			"classifier": *classifierProto,
+			"device-id":  f.deviceHandler.device.Id})
+	actionProto, err := makeOpenOltActionField(uplinkAction, uplinkClassifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": uplinkAction, "device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	logger.Debugw(ctx, "created-action-proto",
+		log.Fields{
+			"action":    *actionProto,
+			"device-id": f.deviceHandler.device.Id})
+	networkIntfID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-interface-id", log.Fields{
+			"classifier": classifier,
+			"action":     action,
+			"device-id":  f.deviceHandler.device.Id},
+			err).Log()
+	}
+
+	upstreamFlow := openoltpb2.Flow{AccessIntfId: int32(intfID),
+		OnuId:         int32(onuID),
+		UniId:         int32(uniID),
+		FlowId:        uplinkFlowID,
+		FlowType:      Upstream,
+		AllocId:       int32(allocID),
+		NetworkIntfId: int32(networkIntfID),
+		GemportId:     int32(gemPortID),
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo,
+		TechProfileId: tpID,
+	}
+	if err := f.addFlowToDevice(ctx, logicalFlow, &upstreamFlow); err != nil {
+		return olterrors.NewErrFlowOp("add", uplinkFlowID, log.Fields{"flow": upstreamFlow}, err).Log()
+	}
+	logger.Infow(ctx, "eapol-ul-flow-added-to-device-successfully",
+		log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"onu-id":    onuID,
+			"intf-id":   intfID,
+		})
+	flowCategory := "EAPOL"
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &upstreamFlow, flowStoreCookie, flowCategory, uplinkFlowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, upstreamFlow.AccessIntfId,
+		upstreamFlow.OnuId,
+		upstreamFlow.UniId,
+		upstreamFlow.FlowId,
+		/* lowCategory, */
+		flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", upstreamFlow.FlowId,
+			log.Fields{
+				"flow":      upstreamFlow,
+				"device-id": f.deviceHandler.device.Id}, err).Log()
+	}
+	return nil
+}
+
+func makeOpenOltClassifierField(classifierInfo map[string]interface{}) (*openoltpb2.Classifier, error) {
+	var classifier openoltpb2.Classifier
+
+	classifier.EthType, _ = classifierInfo[EthType].(uint32)
+	classifier.IpProto, _ = classifierInfo[IPProto].(uint32)
+	if vlanID, ok := classifierInfo[VlanVid].(uint32); ok {
+		if vlanID != ReservedVlan {
+			vid := vlanID & VlanvIDMask
+			classifier.OVid = vid
+		}
+	}
+	if metadata, ok := classifierInfo[Metadata].(uint64); ok {
+		vid := uint32(metadata)
+		if vid != ReservedVlan {
+			classifier.IVid = vid
+		}
+	}
+	if vlanPcp, ok := classifierInfo[VlanPcp].(uint32); ok {
+		classifier.OPbits = vlanPcp
+	} else {
+		classifier.OPbits = VlanPCPMask
+	}
+	classifier.SrcPort, _ = classifierInfo[UDPSrc].(uint32)
+	classifier.DstPort, _ = classifierInfo[UDPDst].(uint32)
+	classifier.DstIp, _ = classifierInfo[Ipv4Dst].(uint32)
+	classifier.SrcIp, _ = classifierInfo[Ipv4Src].(uint32)
+	classifier.DstMac, _ = classifierInfo[EthDst].([]uint8)
+	if pktTagType, ok := classifierInfo[PacketTagType].(string); ok {
+		classifier.PktTagType = pktTagType
+
+		switch pktTagType {
+		case SingleTag:
+		case DoubleTag:
+		case Untagged:
+		default:
+			return nil, olterrors.NewErrInvalidValue(log.Fields{"packet-tag-type": pktTagType}, nil)
+		}
+	}
+	return &classifier, nil
+}
+
+func makeOpenOltActionField(actionInfo map[string]interface{}, classifierInfo map[string]interface{}) (*openoltpb2.Action, error) {
+	var actionCmd openoltpb2.ActionCmd
+	var action openoltpb2.Action
+	action.Cmd = &actionCmd
+	if _, ok := actionInfo[PopVlan]; ok {
+		action.Cmd.RemoveOuterTag = true
+		if _, ok := actionInfo[VlanPcp]; ok {
+			action.Cmd.RemarkInnerPbits = true
+			action.IPbits = actionInfo[VlanPcp].(uint32)
+			if _, ok := actionInfo[VlanVid]; ok {
+				action.Cmd.TranslateInnerTag = true
+				action.IVid = actionInfo[VlanVid].(uint32)
+			}
+		}
+	} else if _, ok := actionInfo[PushVlan]; ok {
+		action.OVid = actionInfo[VlanVid].(uint32)
+		action.Cmd.AddOuterTag = true
+		if _, ok := actionInfo[VlanPcp]; ok {
+			action.OPbits = actionInfo[VlanPcp].(uint32)
+			action.Cmd.RemarkOuterPbits = true
+			if _, ok := classifierInfo[VlanVid]; ok {
+				action.IVid = classifierInfo[VlanVid].(uint32)
+				action.Cmd.TranslateInnerTag = true
+			}
+		}
+	} else if _, ok := actionInfo[TrapToHost]; ok {
+		action.Cmd.TrapToHost = actionInfo[TrapToHost].(bool)
+	} else {
+		return nil, olterrors.NewErrInvalidValue(log.Fields{"action-command": actionInfo}, nil)
+	}
+	return &action, nil
+}
+
+// getTPpath return the ETCD path for a given UNI port
+func (f *OpenOltFlowMgr) getTPpath(ctx context.Context, intfID uint32, uniPath string, TpID uint32) string {
+	return f.techprofile[intfID].GetTechProfileInstanceKVPath(ctx, TpID, uniPath)
+}
+
+// DeleteTechProfileInstances removes the tech profile instances from persistent storage
+func (f *OpenOltFlowMgr) DeleteTechProfileInstances(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, sn string) error {
+	tpIDList := f.resourceMgr.GetTechProfileIDForOnu(ctx, intfID, onuID, uniID)
+	uniPortName := getUniPortPath(f.deviceHandler.device.Id, intfID, int32(onuID), int32(uniID))
+
+	for _, tpID := range tpIDList {
+		if err := f.DeleteTechProfileInstance(ctx, intfID, onuID, uniID, uniPortName, tpID); err != nil {
+			_ = olterrors.NewErrAdapter("delete-tech-profile-failed", log.Fields{"device-id": f.deviceHandler.device.Id}, err).Log()
+			// return err
+			// We should continue to delete tech-profile instances for other TP IDs
+		}
+		logger.Debugw(ctx, "tech-profile-deleted", log.Fields{"device-id": f.deviceHandler.device.Id, "tp-id": tpID})
+	}
+	return nil
+}
+
+// DeleteTechProfileInstance removes the tech profile instance from persistent storage
+func (f *OpenOltFlowMgr) DeleteTechProfileInstance(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, uniPortName string, tpID uint32) error {
+	if uniPortName == "" {
+		uniPortName = getUniPortPath(f.deviceHandler.device.Id, intfID, int32(onuID), int32(uniID))
+	}
+	if err := f.techprofile[intfID].DeleteTechProfileInstance(ctx, tpID, uniPortName); err != nil {
+		return olterrors.NewErrAdapter("failed-to-delete-tp-instance-from-kv-store",
+			log.Fields{
+				"tp-id":         tpID,
+				"uni-port-name": uniPortName,
+				"device-id":     f.deviceHandler.device.Id}, err)
+	}
+	return nil
+}
+
+func getFlowStoreCookie(ctx context.Context, classifier map[string]interface{}, gemPortID uint32) uint64 {
+	if len(classifier) == 0 { // should never happen
+		logger.Error(ctx, "invalid-classfier-object")
+		return 0
+	}
+	logger.Debugw(ctx, "generating-flow-store-cookie",
+		log.Fields{
+			"classifier": classifier,
+			"gemport-id": gemPortID})
+	var jsonData []byte
+	var flowString string
+	var err error
+	if jsonData, err = json.Marshal(classifier); err != nil {
+		logger.Error(ctx, "failed-to-encode-classifier")
+		return 0
+	}
+	flowString = string(jsonData)
+	if gemPortID != 0 {
+		flowString = fmt.Sprintf("%s%s", string(jsonData), string(gemPortID))
+	}
+	h := md5.New()
+	_, _ = h.Write([]byte(flowString))
+	hash := big.NewInt(0)
+	hash.SetBytes(h.Sum(nil))
+	generatedHash := hash.Uint64()
+	logger.Debugw(ctx, "hash-generated", log.Fields{"hash": generatedHash})
+	return generatedHash
+}
+
+func (f *OpenOltFlowMgr) getUpdatedFlowInfo(ctx context.Context, flow *openoltpb2.Flow, flowStoreCookie uint64, flowCategory string, deviceFlowID uint32, logicalFlowID uint64) *[]rsrcMgr.FlowInfo {
+	var flows = []rsrcMgr.FlowInfo{{Flow: flow, FlowCategory: flowCategory, FlowStoreCookie: flowStoreCookie, LogicalFlowID: logicalFlowID}}
+	var intfID uint32
+	/* For flows which trap out of the NNI, the AccessIntfId is invalid
+	   (set to -1). In such cases, we need to refer to the NetworkIntfId .
+	*/
+	if flow.AccessIntfId != -1 {
+		intfID = uint32(flow.AccessIntfId)
+	} else {
+		intfID = uint32(flow.NetworkIntfId)
+	}
+	existingFlows := f.resourceMgr.GetFlowIDInfo(ctx, intfID, flow.OnuId, flow.UniId, flow.FlowId)
+	if existingFlows != nil {
+		logger.Debugw(ctx, "flow-exists-for-given-flowID--appending-it-to-current-flow",
+			log.Fields{
+				"flow-id":   flow.FlowId,
+				"device-id": f.deviceHandler.device.Id,
+				"intf-id":   intfID,
+				"onu-id":    flow.OnuId})
+		//for _, f := range *existingFlows {
+		//	flows = append(flows, f)
+		//}
+		flows = append(flows, *existingFlows...)
+	}
+	logger.Debugw(ctx, "updated-flows-for-given-flowID-and-onuid",
+		log.Fields{
+			"updatedflow": flows,
+			"flow-id":     flow.FlowId,
+			"onu-id":      flow.OnuId,
+			"device-id":   f.deviceHandler.device.Id})
+	return &flows
+}
+
+func (f *OpenOltFlowMgr) updateFlowInfoToKVStore(ctx context.Context, intfID int32, onuID int32, uniID int32, flowID uint32, flows *[]rsrcMgr.FlowInfo) error {
+	logger.Debugw(ctx, "storing-flow(s)-into-kv-store", log.Fields{
+		"flow-id":   flowID,
+		"device-id": f.deviceHandler.device.Id,
+		"intf-id":   intfID,
+		"onu-id":    onuID})
+	if err := f.resourceMgr.UpdateFlowIDInfo(ctx, intfID, onuID, uniID, flowID, flows); err != nil {
+		logger.Warnw(ctx, "error-while-storing-flow-into-kv-store", log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"onu-id":    onuID,
+			"intf-id":   intfID,
+			"flow-id":   flowID})
+		return err
+	}
+	logger.Infow(ctx, "stored-flow(s)-into-kv-store-successfully!", log.Fields{
+		"device-id": f.deviceHandler.device.Id,
+		"onu-id":    onuID,
+		"intf-id":   intfID,
+		"flow-id":   flowID})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) addFlowToDevice(ctx context.Context, logicalFlow *ofp.OfpFlowStats, deviceFlow *openoltpb2.Flow) error {
+
+	var intfID uint32
+	/* For flows which trap out of the NNI, the AccessIntfId is invalid
+	   (set to -1). In such cases, we need to refer to the NetworkIntfId .
+	*/
+	if deviceFlow.AccessIntfId != -1 {
+		intfID = uint32(deviceFlow.AccessIntfId)
+	} else {
+		// REVIST : Why ponport is given as network port?
+		intfID = uint32(deviceFlow.NetworkIntfId)
+	}
+
+	logger.Debugw(ctx, "sending-flow-to-device-via-grpc", log.Fields{
+		"flow":      *deviceFlow,
+		"device-id": f.deviceHandler.device.Id,
+		"intf-id":   intfID})
+	_, err := f.deviceHandler.Client.FlowAdd(log.WithSpanFromContext(context.Background(), ctx), deviceFlow)
+
+	st, _ := status.FromError(err)
+	if st.Code() == codes.AlreadyExists {
+		logger.Debug(ctx, "flow-already-exists", log.Fields{
+			"err":        err,
+			"deviceFlow": deviceFlow,
+			"device-id":  f.deviceHandler.device.Id,
+			"intf-id":    intfID})
+		return nil
+	}
+
+	if err != nil {
+		logger.Errorw(ctx, "failed-to-add-flow-to-device",
+			log.Fields{"err": err,
+				"device-flow": deviceFlow,
+				"device-id":   f.deviceHandler.device.Id,
+				"intf-id":     intfID})
+		f.resourceMgr.FreeFlowID(ctx, intfID, deviceFlow.OnuId, deviceFlow.UniId, deviceFlow.FlowId)
+		return err
+	}
+	if deviceFlow.GemportId != -1 {
+		// No need to register the flow if it is a trap on nni flow.
+		if err := f.registerFlow(ctx, logicalFlow, deviceFlow); err != nil {
+			logger.Errorw(ctx, "failed-to-register-flow", log.Fields{"err": err})
+			return err
+		}
+	}
+	logger.Infow(ctx, "flow-added-to-device-successfully ",
+		log.Fields{
+			"flow":      *deviceFlow,
+			"device-id": f.deviceHandler.device.Id,
+			"intf-id":   intfID})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) removeFlowFromDevice(ctx context.Context, deviceFlow *openoltpb2.Flow, ofFlowID uint64) error {
+	logger.Debugw(ctx, "sending-flow-to-device-via-grpc",
+		log.Fields{
+			"flow":      *deviceFlow,
+			"device-id": f.deviceHandler.device.Id})
+	_, err := f.deviceHandler.Client.FlowRemove(log.WithSpanFromContext(context.Background(), ctx), deviceFlow)
+	if err != nil {
+		if f.deviceHandler.device.ConnectStatus == common.ConnectStatus_UNREACHABLE {
+			logger.Warnw(ctx, "can-not-remove-flow-from-device--unreachable",
+				log.Fields{
+					"err":        err,
+					"deviceFlow": deviceFlow,
+					"device-id":  f.deviceHandler.device.Id})
+			//Assume the flow is removed
+			return nil
+		}
+		return olterrors.NewErrFlowOp("remove", deviceFlow.FlowId, log.Fields{"deviceFlow": deviceFlow}, err)
+
+	}
+	logger.Infow(ctx, "flow-removed-from-device-successfully", log.Fields{
+		"of-flow-id": ofFlowID,
+		"flow":       *deviceFlow,
+		"device-id":  f.deviceHandler.device.Id,
+	})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) addLLDPFlow(ctx context.Context, flow *ofp.OfpFlowStats, portNo uint32) error {
+
+	classifierInfo := make(map[string]interface{})
+	actionInfo := make(map[string]interface{})
+
+	classifierInfo[EthType] = uint32(LldpEthType)
+	classifierInfo[PacketTagType] = Untagged
+	actionInfo[TrapToHost] = true
+
+
+	var onuID = -1
+	var uniID = -1
+	var gemPortID = -1
+
+	networkInterfaceID, err := IntfIDFromNniPortNum(ctx, portNo)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"nni-port-number": portNo}, err).Log()
+	}
+	var flowStoreCookie = getFlowStoreCookie(ctx, classifierInfo, uint32(0))
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "flow-exists--not-re-adding", log.Fields{"device-id": f.deviceHandler.device.Id})
+		return nil
+	}
+	flowID, err := f.resourceMgr.GetFlowID(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), uint32(gemPortID), flowStoreCookie, "", 0)
+
+	if err != nil {
+		return olterrors.NewErrNotFound("flow-id",
+			log.Fields{
+				"interface-id": networkInterfaceID,
+				"onu-id":       onuID,
+				"uni-id":       uniID,
+				"gem-port-id":  gemPortID,
+				"cookie":       flowStoreCookie,
+				"device-id":    f.deviceHandler.device.Id},
+			err)
+	}
+	classifierProto, err := makeOpenOltClassifierField(classifierInfo)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(
+			log.Fields{
+				"classifier": classifierInfo,
+				"device-id":  f.deviceHandler.device.Id}, err)
+	}
+	logger.Debugw(ctx, "created-classifier-proto",
+		log.Fields{
+			"classifier": *classifierProto,
+			"device-id":  f.deviceHandler.device.Id})
+	actionProto, err := makeOpenOltActionField(actionInfo, classifierInfo)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(
+			log.Fields{
+				"action":    actionInfo,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	logger.Debugw(ctx, "created-action-proto",
+		log.Fields{
+			"action":    *actionProto,
+			"device-id": f.deviceHandler.device.Id})
+
+	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
+		OnuId:         int32(onuID), // OnuId not required
+		UniId:         int32(uniID), // UniId not used
+		FlowId:        flowID,
+		FlowType:      Downstream,
+		NetworkIntfId: int32(networkInterfaceID),
+		GemportId:     int32(gemPortID),
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(flow.Priority),
+		Cookie:        flow.Cookie,
+		PortNo:        portNo}
+	if err := f.addFlowToDevice(ctx, flow, &downstreamflow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID,
+			log.Fields{
+				"flow":      downstreamflow,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	logger.Infow(ctx, "lldp-trap-on-nni-flow-added-to-device-successfully",
+		log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"onu-id":    onuID,
+			"flow-id":   flowID})
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &downstreamflow, flowStoreCookie, "", flowID, flow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, int32(networkInterfaceID),
+		int32(onuID),
+		int32(uniID),
+		flowID, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flowID,
+			log.Fields{
+				"flow":      downstreamflow,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+	return nil
+}
+
+func getUniPortPath(oltID string, intfID uint32, onuID int32, uniID int32) string {
+	return fmt.Sprintf("olt-{%s}/pon-{%d}/onu-{%d}/uni-{%d}", oltID, intfID, onuID, uniID)
+}
+
+//getOnuDevice to fetch onu from cache or core.
+func (f *OpenOltFlowMgr) getOnuDevice(ctx context.Context, intfID uint32, onuID uint32) (*OnuDevice, error) {
+	onuKey := f.deviceHandler.formOnuKey(intfID, onuID)
+	onuDev, ok := f.deviceHandler.onus.Load(onuKey)
+	if !ok {
+		logger.Debugw(ctx, "couldnt-find-onu-in-cache",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"device-id": f.deviceHandler.device.Id})
+		onuDevice, err := f.getChildDevice(ctx, intfID, onuID)
+		if err != nil {
+			return nil, olterrors.NewErrNotFound("onu-child-device",
+				log.Fields{
+					"onu-id":    onuID,
+					"intf-id":   intfID,
+					"device-id": f.deviceHandler.device.Id}, err)
+		}
+		onuDev = NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuDevice.ProxyAddress.OnuId, onuDevice.ProxyAddress.ChannelId, onuDevice.ProxyAddress.DeviceId, false)
+		//better to ad the device to cache here.
+		f.deviceHandler.StoreOnuDevice(onuDev.(*OnuDevice))
+	} else {
+		logger.Debugw(ctx, "found-onu-in-cache",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"device-id": f.deviceHandler.device.Id})
+	}
+
+	return onuDev.(*OnuDevice), nil
+}
+
+//getChildDevice to fetch onu
+func (f *OpenOltFlowMgr) getChildDevice(ctx context.Context, intfID uint32, onuID uint32) (*voltha.Device, error) {
+	logger.Infow(ctx, "GetChildDevice",
+		log.Fields{
+			"pon-port":  intfID,
+			"onu-id":    onuID,
+			"device-id": f.deviceHandler.device.Id})
+	parentPortNo := IntfIDToPortNo(intfID, voltha.Port_PON_OLT)
+	onuDevice, err := f.deviceHandler.GetChildDevice(ctx, parentPortNo, onuID)
+	if err != nil {
+		return nil, olterrors.NewErrNotFound("onu",
+			log.Fields{
+				"interface-id": parentPortNo,
+				"onu-id":       onuID,
+				"device-id":    f.deviceHandler.device.Id},
+			err)
+	}
+	logger.Infow(ctx, "successfully-received-child-device-from-core",
+		log.Fields{
+			"device-id":       f.deviceHandler.device.Id,
+			"child_device_id": onuDevice.Id,
+			"child_device_sn": onuDevice.SerialNumber})
+	return onuDevice, nil
+}
+
+func (f *OpenOltFlowMgr) sendDeleteGemPortToChild(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, gemPortID uint32, tpPath string) error {
+	onuDev, err := f.getOnuDevice(ctx, intfID, onuID)
+	if err != nil {
+		logger.Debugw(ctx, "couldnt-find-onu-child-device",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"uni-id":    uniID,
+				"device-id": f.deviceHandler.device.Id})
+		return err
+	}
+
+	delGemPortMsg := &ic.InterAdapterDeleteGemPortMessage{UniId: uniID, TpPath: tpPath, GemPortId: gemPortID}
+	logger.Debugw(ctx, "sending-gem-port-delete-to-openonu-adapter",
+		log.Fields{
+			"msg":       *delGemPortMsg,
+			"device-id": f.deviceHandler.device.Id})
+	if sendErr := f.deviceHandler.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx),
+		delGemPortMsg,
+		ic.InterAdapterMessageType_DELETE_GEM_PORT_REQUEST,
+		f.deviceHandler.device.Type,
+		onuDev.deviceType,
+		onuDev.deviceID,
+		onuDev.proxyDeviceID, ""); sendErr != nil {
+		return olterrors.NewErrCommunication("send-delete-gem-port-to-onu-adapter",
+			log.Fields{
+				"from-adapter":  f.deviceHandler.device.Type,
+				"to-adapter":    onuDev.deviceType,
+				"onu-id":        onuDev.deviceID,
+				"proxyDeviceID": onuDev.proxyDeviceID,
+				"device-id":     f.deviceHandler.device.Id}, sendErr)
+	}
+	logger.Infow(ctx, "success-sending-del-gem-port-to-onu-adapter",
+		log.Fields{
+			"msg":          delGemPortMsg,
+			"from-adapter": f.deviceHandler.device.Type,
+			"to-adapter":   onuDev.deviceType,
+			"device-id":    f.deviceHandler.device.Id})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) sendDeleteTcontToChild(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, allocID uint32, tpPath string) error {
+	onuDev, err := f.getOnuDevice(ctx, intfID, onuID)
+	if err != nil {
+		logger.Warnw(ctx, "couldnt-find-onu-child-device",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"uni-id":    uniID,
+				"device-id": f.deviceHandler.device.Id})
+		return err
+	}
+
+	delTcontMsg := &ic.InterAdapterDeleteTcontMessage{UniId: uniID, TpPath: tpPath, AllocId: allocID}
+	logger.Debugw(ctx, "sending-tcont-delete-to-openonu-adapter",
+		log.Fields{
+			"msg":       *delTcontMsg,
+			"device-id": f.deviceHandler.device.Id})
+	if sendErr := f.deviceHandler.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx),
+		delTcontMsg,
+		ic.InterAdapterMessageType_DELETE_TCONT_REQUEST,
+		f.deviceHandler.device.Type,
+		onuDev.deviceType,
+		onuDev.deviceID,
+		onuDev.proxyDeviceID, ""); sendErr != nil {
+		return olterrors.NewErrCommunication("send-delete-tcont-to-onu-adapter",
+			log.Fields{
+				"from-adapter": f.deviceHandler.device.Type,
+				"to-adapter":   onuDev.deviceType, "onu-id": onuDev.deviceID,
+				"proxyDeviceID": onuDev.proxyDeviceID,
+				"device-id":     f.deviceHandler.device.Id}, sendErr)
+	}
+	logger.Infow(ctx, "success-sending-del-tcont-to-onu-adapter",
+		log.Fields{
+			"msg":       delTcontMsg,
+			"device-id": f.deviceHandler.device.Id})
+	return nil
+}
+
+func (f *OpenOltFlowMgr) deletePendingFlows(ctx context.Context, Intf uint32, onuID int32, uniID int32) {
+	pnFlDelKey := pendingFlowDeleteKey{Intf, uint32(onuID), uint32(uniID)}
+	if val, ok := f.pendingFlowDelete.Load(pnFlDelKey); ok {
+		if val.(int) > 0 {
+			pnFlDels := val.(int) - 1
+			if pnFlDels > 0 {
+				logger.Debugw(ctx, "flow-delete-succeeded--more-pending",
+					log.Fields{
+						"intf":               Intf,
+						"onu-id":             onuID,
+						"uni-id":             uniID,
+						"currpendingflowcnt": pnFlDels,
+						"device-id":          f.deviceHandler.device.Id})
+				f.pendingFlowDelete.Store(pnFlDelKey, pnFlDels)
+			} else {
+				logger.Debugw(ctx, "all-pending-flow-deletes-handled--removing-entry-from-map",
+					log.Fields{
+						"intf":      Intf,
+						"onu-id":    onuID,
+						"uni-id":    uniID,
+						"device-id": f.deviceHandler.device.Id})
+				f.pendingFlowDelete.Delete(pnFlDelKey)
+			}
+		}
+	} else {
+		logger.Debugw(ctx, "no-pending-delete-flows-found",
+			log.Fields{
+				"intf":      Intf,
+				"onu-id":    onuID,
+				"uni-id":    uniID,
+				"device-id": f.deviceHandler.device.Id})
+
+	}
+
+}
+
+// Once the gemport is released for a given onu, it also has to be cleared from local cache
+// which was used for deriving the gemport->logicalPortNo during packet-in.
+// Otherwise stale info continues to exist after gemport is freed and wrong logicalPortNo
+// is conveyed to ONOS during packet-in OF message.
+func (f *OpenOltFlowMgr) deleteGemPortFromLocalCache(ctx context.Context, intfID uint32, onuID uint32, gemPortID uint32) {
+
+	f.onuGemInfoLock.Lock()
+	defer f.onuGemInfoLock.Unlock()
+
+	logger.Infow(ctx, "deleting-gem-from-local-cache",
+		log.Fields{
+			"gem-port-id": gemPortID,
+			"intf-id":     intfID,
+			"onu-id":      onuID,
+			"device-id":   f.deviceHandler.device.Id,
+			"onu-gem":     f.onuGemInfo[intfID]})
+	onugem := f.onuGemInfo[intfID]
+deleteLoop:
+	for i, onu := range onugem {
+		if onu.OnuID == onuID {
+			for j, gem := range onu.GemPorts {
+				// If the gemport is found, delete it from local cache.
+				if gem == gemPortID {
+					onu.GemPorts = append(onu.GemPorts[:j], onu.GemPorts[j+1:]...)
+					onugem[i] = onu
+					logger.Infow(ctx, "removed-gemport-from-local-cache",
+						log.Fields{
+							"intf-id":           intfID,
+							"onu-id":            onuID,
+							"deletedgemport-id": gemPortID,
+							"gemports":          onu.GemPorts,
+							"device-id":         f.deviceHandler.device.Id})
+					break deleteLoop
+				}
+			}
+			break deleteLoop
+		}
+	}
+}
+
+//clearResources clears pon resources in kv store and the device
+// nolint: gocyclo
+func (f *OpenOltFlowMgr) clearResources(ctx context.Context, flow *ofp.OfpFlowStats, Intf uint32, onuID int32, uniID int32,
+	gemPortID int32, flowID uint32, flowDirection string,
+	portNum uint32, updatedFlows []rsrcMgr.FlowInfo) error {
+
+	tpID, err := getTpIDFromFlow(ctx, flow)
+	if err != nil {
+		return olterrors.NewErrNotFound("tp-id",
+			log.Fields{
+				"flow":      flow,
+				"intf":      Intf,
+				"onu-id":    onuID,
+				"uni-id":    uniID,
+				"device-id": f.deviceHandler.device.Id}, err)
+	}
+
+	if len(updatedFlows) >= 0 {
+		// There are still flows referencing the same flow_id.
+		// So the flow should not be freed yet.
+		// For ex: Case of HSIA where same flow is shared
+		// between DS and US.
+		if err := f.updateFlowInfoToKVStore(ctx, int32(Intf), int32(onuID), int32(uniID), flowID, &updatedFlows); err != nil {
+			_ = olterrors.NewErrPersistence("update", "flow", flowID,
+				log.Fields{
+					"flow":      updatedFlows,
+					"device-id": f.deviceHandler.device.Id}, err).Log()
+		}
+		if len(updatedFlows) == 0 {
+			// Do this for subscriber flows only (not trap from NNI flows)
+			if onuID != -1 && uniID != -1 {
+				pnFlDelKey := pendingFlowDeleteKey{Intf, uint32(onuID), uint32(uniID)}
+				if val, ok := f.pendingFlowDelete.Load(pnFlDelKey); !ok {
+					logger.Debugw(ctx, "creating-entry-for-pending-flow-delete",
+						log.Fields{
+							"flow-id":   flowID,
+							"intf":      Intf,
+							"onu-id":    onuID,
+							"uni-id":    uniID,
+							"device-id": f.deviceHandler.device.Id})
+					f.pendingFlowDelete.Store(pnFlDelKey, 1)
+				} else {
+					pnFlDels := val.(int) + 1
+					logger.Debugw(ctx, "updating-flow-delete-entry",
+						log.Fields{
+							"flow-id":            flowID,
+							"intf":               Intf,
+							"onu-id":             onuID,
+							"uni-id":             uniID,
+							"currPendingFlowCnt": pnFlDels,
+							"device-id":          f.deviceHandler.device.Id})
+					f.pendingFlowDelete.Store(pnFlDelKey, pnFlDels)
+				}
+
+				defer f.deletePendingFlows(ctx, Intf, onuID, uniID)
+			}
+
+			logger.Debugw(ctx, "releasing-flow-id-to-resource-manager",
+				log.Fields{
+					"Intf":      Intf,
+					"onu-id":    onuID,
+					"uni-id":    uniID,
+					"flow-id":   flowID,
+					"device-id": f.deviceHandler.device.Id})
+			f.resourceMgr.FreeFlowID(ctx, Intf, int32(onuID), int32(uniID), flowID)
+
+			uni := getUniPortPath(f.deviceHandler.device.Id, Intf, onuID, uniID)
+			tpPath := f.getTPpath(ctx, Intf, uni, tpID)
+			logger.Debugw(ctx, "getting-techprofile-instance-for-subscriber",
+				log.Fields{
+					"TP-PATH":   tpPath,
+					"device-id": f.deviceHandler.device.Id})
+			techprofileInst, err := f.techprofile[Intf].GetTPInstanceFromKVStore(ctx, tpID, tpPath)
+			if err != nil || techprofileInst == nil { // This should not happen, something wrong in KV backend transaction
+				return olterrors.NewErrNotFound("tech-profile-in-kv-store",
+					log.Fields{
+						"tp-id": tpID,
+						"path":  tpPath}, err)
+			}
+
+			gemPK := gemPortKey{Intf, uint32(gemPortID)}
+			used, err := f.isGemPortUsedByAnotherFlow(ctx, gemPK)
+			if err != nil {
+				return err
+			}
+			if used {
+				if f.perGemPortLock.TryLock(gemPK) {
+					flowIDs := f.flowsUsedByGemPort[gemPK]
+					for i, flowIDinMap := range flowIDs {
+						if flowIDinMap == flowID {
+							flowIDs = append(flowIDs[:i], flowIDs[i+1:]...)
+							// everytime flowsUsedByGemPort cache is updated the same should be updated
+							// in kv store by calling UpdateFlowIDsForGem
+							f.flowsUsedByGemPort[gemPK] = flowIDs
+							if err := f.resourceMgr.UpdateFlowIDsForGem(ctx, Intf, uint32(gemPortID), flowIDs); err != nil {
+								return err
+							}
+							break
+						}
+					}
+					logger.Debugw(ctx, "gem-port-id-is-still-used-by-other-flows",
+						log.Fields{
+							"gemport-id":  gemPortID,
+							"usedByFlows": flowIDs,
+							"device-id":   f.deviceHandler.device.Id})
+					f.perGemPortLock.Unlock(gemPK)
+					return nil
+				}
+
+				logger.Error(ctx, "failed-to-acquire-per-gem-port-lock",
+					log.Fields{
+						"gemport-id": gemPortID,
+						"device-id":  f.deviceHandler.device.Id,
+						"key":        gemPK,
+					})
+				return olterrors.NewErrAdapter("failed-to-acquire-per-gem-port-lock", log.Fields{
+					"gemport-id": gemPortID,
+					"device-id":  f.deviceHandler.device.Id,
+					"key":        gemPK,
+				}, nil)
+			}
+			logger.Debugf(ctx, "gem-port-id %d is-not-used-by-another-flow--releasing-the-gem-port", gemPortID)
+			f.resourceMgr.RemoveGemPortIDForOnu(ctx, Intf, uint32(onuID), uint32(uniID), uint32(gemPortID))
+			// TODO: The TrafficQueue corresponding to this gem-port also should be removed immediately.
+			// But it is anyway eventually  removed later when the TechProfile is freed, so not a big issue for now.
+			f.resourceMgr.RemoveGEMportPonportToOnuMapOnKVStore(ctx, uint32(gemPortID), Intf)
+			f.deleteGemPortFromLocalCache(ctx, Intf, uint32(onuID), uint32(gemPortID))
+			f.onuIdsLock.Lock()
+			//everytime an entry is deleted from flowsUsedByGemPort cache, the same should be updated in kv as well
+			// by calling DeleteFlowIDsForGem
+			if f.perGemPortLock.TryLock(gemPK) {
+				delete(f.flowsUsedByGemPort, gemPK)
+				f.perGemPortLock.Unlock(gemPK)
+			} else {
+				logger.Error(ctx, "failed-to-acquire-per-gem-port-lock",
+					log.Fields{
+						"device-id": f.deviceHandler.device.Id,
+						"key":       gemPK,
+					})
+			}
+			f.resourceMgr.DeleteFlowIDsForGem(ctx, Intf, uint32(gemPortID))
+			f.resourceMgr.FreeGemPortID(ctx, Intf, uint32(onuID), uint32(uniID), uint32(gemPortID))
+			f.onuIdsLock.Unlock()
+			// Delete the gem port on the ONU.
+			if err := f.sendDeleteGemPortToChild(ctx, Intf, uint32(onuID), uint32(uniID), uint32(gemPortID), tpPath); err != nil {
+				logger.Errorw(ctx, "error-processing-delete-gem-port-towards-onu",
+					log.Fields{
+						"err":        err,
+						"intf":       Intf,
+						"onu-id":     onuID,
+						"uni-id":     uniID,
+						"device-id":  f.deviceHandler.device.Id,
+						"gemport-id": gemPortID})
+			}
+			switch techprofileInst := techprofileInst.(type) {
+			case *tp.TechProfile:
+				ok, _ := f.isTechProfileUsedByAnotherGem(ctx, Intf, uint32(onuID), uint32(uniID), tpID, techprofileInst, uint32(gemPortID))
+				if !ok {
+					if err := f.resourceMgr.RemoveTechProfileIDForOnu(ctx, Intf, uint32(onuID), uint32(uniID), tpID); err != nil {
+						logger.Warn(ctx, err)
+					}
+					if err := f.DeleteTechProfileInstance(ctx, Intf, uint32(onuID), uint32(uniID), "", tpID); err != nil {
+						logger.Warn(ctx, err)
+					}
+					if err := f.RemoveSchedulerQueues(ctx, schedQueue{direction: tp_pb.Direction_UPSTREAM, intfID: Intf, onuID: uint32(onuID), uniID: uint32(uniID), tpID: tpID, uniPort: portNum, tpInst: techprofileInst}); err != nil {
+						logger.Warn(ctx, err)
+					}
+					if err := f.RemoveSchedulerQueues(ctx, schedQueue{direction: tp_pb.Direction_DOWNSTREAM, intfID: Intf, onuID: uint32(onuID), uniID: uint32(uniID), tpID: tpID, uniPort: portNum, tpInst: techprofileInst}); err != nil {
+						logger.Warn(ctx, err)
+					}
+					f.resourceMgr.FreeAllocID(ctx, Intf, uint32(onuID), uint32(uniID), techprofileInst.UsScheduler.AllocID)
+					// Delete the TCONT on the ONU.
+					if err := f.sendDeleteTcontToChild(ctx, Intf, uint32(onuID), uint32(uniID), uint32(techprofileInst.UsScheduler.AllocID), tpPath); err != nil {
+						logger.Errorw(ctx, "error-processing-delete-tcont-towards-onu",
+							log.Fields{
+								"intf":      Intf,
+								"onu-id":    onuID,
+								"uni-id":    uniID,
+								"device-id": f.deviceHandler.device.Id,
+								"alloc-id":  techprofileInst.UsScheduler.AllocID})
+					}
+				}
+			case *tp.EponProfile:
+				if err := f.resourceMgr.RemoveTechProfileIDForOnu(ctx, Intf, uint32(onuID), uint32(uniID), tpID); err != nil {
+					logger.Warn(ctx, err)
+				}
+				if err := f.DeleteTechProfileInstance(ctx, Intf, uint32(onuID), uint32(uniID), "", tpID); err != nil {
+					logger.Warn(ctx, err)
+				}
+				f.resourceMgr.FreeAllocID(ctx, Intf, uint32(onuID), uint32(uniID), techprofileInst.AllocID)
+				// Delete the TCONT on the ONU.
+				if err := f.sendDeleteTcontToChild(ctx, Intf, uint32(onuID), uint32(uniID), uint32(techprofileInst.AllocID), tpPath); err != nil {
+					logger.Errorw(ctx, "error-processing-delete-tcont-towards-onu",
+						log.Fields{
+							"intf":      Intf,
+							"onu-id":    onuID,
+							"uni-id":    uniID,
+							"device-id": f.deviceHandler.device.Id,
+							"alloc-id":  techprofileInst.AllocID})
+				}
+			default:
+				logger.Errorw(ctx, "error-unknown-tech",
+					log.Fields{
+						"techprofileInst": techprofileInst})
+			}
+		}
+	}
+	return nil
+}
+
+// nolint: gocyclo
+func (f *OpenOltFlowMgr) clearFlowFromResourceManager(ctx context.Context, flow *ofp.OfpFlowStats, flowDirection string) {
+
+	logger.Infow(ctx, "clear-flow-from-resource-manager",
+		log.Fields{
+			"flowDirection": flowDirection,
+			"flow":          *flow,
+			"device-id":     f.deviceHandler.device.Id})
+
+	if flowDirection == Multicast {
+		f.clearMulticastFlowFromResourceManager(ctx, flow)
+		return
+	}
+
+	classifierInfo := make(map[string]interface{})
+
+	portNum, Intf, onu, uni, inPort, ethType, err := FlowExtractInfo(ctx, flow, flowDirection)
+	if err != nil {
+		logger.Error(ctx, err)
+		return
+	}
+
+	onuID := int32(onu)
+	uniID := int32(uni)
+
+	for _, field := range flows.GetOfbFields(flow) {
+		if field.Type == flows.IP_PROTO {
+			classifierInfo[IPProto] = field.GetIpProto()
+			logger.Debugw(ctx, "field-type-ip-proto", log.Fields{"classifierInfo[IP_PROTO]": classifierInfo[IPProto].(uint32)})
+		}
+	}
+	logger.Infow(ctx, "extracted-access-info-from-flow-to-be-deleted",
+		log.Fields{
+			"flow-id": flow.Id,
+			"intf-id": Intf,
+			"onu-id":  onuID,
+			"uni-id":  uniID})
+
+	if ethType == LldpEthType || ((classifierInfo[IPProto] == IPProtoDhcp) && (flowDirection == "downstream")) {
+		onuID = -1
+		uniID = -1
+		logger.Debug(ctx, "trap-on-nni-flow-set-oni--uni-to- -1")
+		Intf, err = IntfIDFromNniPortNum(ctx, inPort)
+		if err != nil {
+			logger.Errorw(ctx, "invalid-in-port-number",
+				log.Fields{
+					"port-number": inPort,
+					"error":       err})
+			return
+		}
+	}
+	flowIds := f.resourceMgr.GetCurrentFlowIDsForOnu(ctx, Intf, onuID, uniID)
+	for _, flowID := range flowIds {
+		flowInfo := f.resourceMgr.GetFlowIDInfo(ctx, Intf, onuID, uniID, flowID)
+		if flowInfo == nil {
+			logger.Debugw(ctx, "no-flowinfo-found-in-kv-store",
+				log.Fields{
+					"intf":    Intf,
+					"onu-id":  onuID,
+					"uni-id":  uniID,
+					"flow-id": flowID})
+			return
+		}
+
+		updatedFlows := *flowInfo
+		for i, storedFlow := range updatedFlows {
+			if flow.Id == storedFlow.LogicalFlowID {
+				removeFlowMessage := openoltpb2.Flow{FlowId: storedFlow.Flow.FlowId, FlowType: storedFlow.Flow.FlowType}
+				logger.Debugw(ctx, "flow-to-be-deleted", log.Fields{"flow": storedFlow})
+				// DKB
+				if err = f.removeFlowFromDevice(ctx, &removeFlowMessage, flow.Id); err != nil {
+					logger.Errorw(ctx, "failed-to-remove-flow", log.Fields{"error": err})
+					return
+				}
+				logger.Info(ctx, "flow-removed-from-device-successfully", log.Fields{
+					"flow-id":        flow.Id,
+					"stored-flow":    storedFlow,
+					"device-id":      f.deviceHandler.device.Id,
+					"stored-flow-id": flowID,
+					"onu-id":         onuID,
+					"intf":           Intf,
+				})
+				//Remove the Flow from FlowInfo
+				updatedFlows = append(updatedFlows[:i], updatedFlows[i+1:]...)
+				if err = f.clearResources(ctx, flow, Intf, onuID, uniID, storedFlow.Flow.GemportId,
+					flowID, flowDirection, portNum, updatedFlows); err != nil {
+					logger.Error(ctx, "failed-to-clear-resources-for-flow", log.Fields{
+						"flow-id":        flow.Id,
+						"stored-flow":    storedFlow,
+						"device-id":      f.deviceHandler.device.Id,
+						"stored-flow-id": flowID,
+						"onu-id":         onuID,
+						"intf":           Intf,
+					})
+					return
+				}
+			}
+		}
+	}
+}
+
+//clearMulticastFlowFromResourceManager  removes a multicast flow from the KV store and
+// clears resources reserved for this multicast flow
+func (f *OpenOltFlowMgr) clearMulticastFlowFromResourceManager(ctx context.Context, flow *ofp.OfpFlowStats) {
+	classifierInfo := make(map[string]interface{})
+	formulateClassifierInfoFromFlow(ctx, classifierInfo, flow)
+	networkInterfaceID, err := f.getNNIInterfaceIDOfMulticastFlow(ctx, classifierInfo)
+
+	if err != nil {
+		logger.Warnw(ctx, "no-inport-found--cannot-release-resources-of-the-multicast-flow", log.Fields{"flowId:": flow.Id})
+		return
+	}
+
+	var onuID = int32(NoneOnuID)
+	var uniID = int32(NoneUniID)
+	var flowID uint32
+
+	flowIds := f.resourceMgr.GetCurrentFlowIDsForOnu(ctx, networkInterfaceID, onuID, uniID)
+
+	for _, flowID = range flowIds {
+		flowInfo := f.resourceMgr.GetFlowIDInfo(ctx, networkInterfaceID, onuID, uniID, flowID)
+		if flowInfo == nil {
+			logger.Debugw(ctx, "no-multicast-flowinfo-found-in-the-kv-store",
+				log.Fields{
+					"intf":    networkInterfaceID,
+					"onu-id":  onuID,
+					"uni-id":  uniID,
+					"flow-id": flowID})
+			continue
+		}
+		updatedFlows := *flowInfo
+		for i, storedFlow := range updatedFlows {
+			if flow.Id == storedFlow.LogicalFlowID {
+				removeFlowMessage := openoltpb2.Flow{FlowId: storedFlow.Flow.FlowId, FlowType: storedFlow.Flow.FlowType}
+				logger.Debugw(ctx, "multicast-flow-to-be-deleted",
+					log.Fields{
+						"flow":      storedFlow,
+						"flow-id":   flow.Id,
+						"device-id": f.deviceHandler.device.Id})
+				//remove from device
+				if err := f.removeFlowFromDevice(ctx, &removeFlowMessage, flow.Id); err != nil {
+					// DKB
+					logger.Errorw(ctx, "failed-to-remove-multicast-flow",
+						log.Fields{
+							"flow-id": flow.Id,
+							"error":   err})
+					return
+				}
+				logger.Infow(ctx, "multicast-flow-removed-from-device-successfully", log.Fields{"flow-id": flow.Id})
+				//Remove the Flow from FlowInfo
+				updatedFlows = append(updatedFlows[:i], updatedFlows[i+1:]...)
+				if err := f.updateFlowInfoToKVStore(ctx, int32(networkInterfaceID), NoneOnuID, NoneUniID, flowID, &updatedFlows); err != nil {
+					logger.Errorw(ctx, "failed-to-delete-multicast-flow-from-the-kv-store",
+						log.Fields{"flow": storedFlow,
+							"err": err})
+					return
+				}
+				//release flow id
+				logger.Debugw(ctx, "releasing-multicast-flow-id",
+					log.Fields{"flow-id": flowID,
+						"interfaceID": networkInterfaceID})
+				f.resourceMgr.FreeFlowID(ctx, uint32(networkInterfaceID), NoneOnuID, NoneUniID, flowID)
+			}
+		}
+	}
+}
+
+//RemoveFlow removes the flow from the device
+func (f *OpenOltFlowMgr) RemoveFlow(ctx context.Context, flow *ofp.OfpFlowStats) error {
+	logger.Infow(ctx, "removing-flow", log.Fields{"flow": *flow})
+	var direction string
+	actionInfo := make(map[string]interface{})
+
+	for _, action := range flows.GetActions(flow) {
+		if action.Type == flows.OUTPUT {
+			if out := action.GetOutput(); out != nil {
+				actionInfo[Output] = out.GetPort()
+				logger.Debugw(ctx, "action-type-output", log.Fields{"out_port": actionInfo[Output].(uint32)})
+			} else {
+				logger.Error(ctx, "invalid-output-port-in-action")
+				return olterrors.NewErrInvalidValue(log.Fields{"invalid-out-port-action": 0}, nil)
+			}
+		}
+	}
+
+	if flows.HasGroup(flow) {
+		direction = Multicast
+		f.clearFlowFromResourceManager(ctx, flow, direction)
+		return nil
+	} else if IsUpstream(actionInfo[Output].(uint32)) {
+		direction = Upstream
+	} else {
+		direction = Downstream
+	}
+
+	_, intfID, onuID, uniID, _, _, err := FlowExtractInfo(ctx, flow, direction)
+	if err != nil {
+		return err
+	}
+
+	userKey := tpLockKey{intfID, onuID, uniID}
+
+	if f.perUserFlowHandleLock.TryLock(userKey) {
+		f.clearFlowFromResourceManager(ctx, flow, direction) //TODO: Take care of the limitations
+		f.perUserFlowHandleLock.Unlock(userKey)
+	} else {
+		// Ideally this should never happen
+		logger.Errorw(ctx, "failed-to-acquire-lock-to-remove-flow--remove-aborted", log.Fields{"flow": flow})
+		return errors.New("failed-to-acquire-per-user-lock")
+	}
+
+	return nil
+}
+
+func (f *OpenOltFlowMgr) waitForFlowDeletesToCompleteForOnu(ctx context.Context, intfID uint32, onuID uint32,
+	uniID uint32, ch chan bool) {
+	pnFlDelKey := pendingFlowDeleteKey{intfID, onuID, uniID}
+	for {
+		select {
+		case <-time.After(20 * time.Millisecond):
+			if flowDelRefCnt, ok := f.pendingFlowDelete.Load(pnFlDelKey); !ok || flowDelRefCnt == 0 {
+				logger.Debug(ctx, "pending-flow-deletes-completed")
+				ch <- true
+				return
+			}
+		case <-ctx.Done():
+			logger.Error(ctx, "flow-delete-wait-handler-routine-canceled")
+			return
+		}
+	}
+}
+
+//isIgmpTrapDownstreamFlow return true if the flow is a downsteam IGMP trap-to-host flow; false otherwise
+func isIgmpTrapDownstreamFlow(classifierInfo map[string]interface{}) bool {
+	if portType := IntfIDToPortTypeName(classifierInfo[InPort].(uint32)); portType == voltha.Port_ETHERNET_NNI {
+		if ethType, ok := classifierInfo[EthType]; ok {
+			if ethType.(uint32) == IPv4EthType {
+				if ipProto, ok := classifierInfo[IPProto]; ok {
+					if ipProto.(uint32) == IgmpProto {
+						return true
+					}
+				}
+			}
+		}
+	}
+	return false
+}
+
+// AddFlow add flow to device
+// nolint: gocyclo
+func (f *OpenOltFlowMgr) AddFlow(ctx context.Context, flow *ofp.OfpFlowStats, flowMetadata *voltha.FlowMetadata) error {
+	classifierInfo := make(map[string]interface{})
+	actionInfo := make(map[string]interface{})
+	var UsMeterID uint32
+	var DsMeterID uint32
+
+	logger.Infow(ctx, "adding-flow",
+		log.Fields{
+			"flow":         flow,
+			"flowmetadata": flowMetadata})
+	formulateClassifierInfoFromFlow(ctx, classifierInfo, flow)
+
+	err := formulateActionInfoFromFlow(ctx, actionInfo, classifierInfo, flow)
+	if err != nil {
+		// Error logging is already done in the called function
+		// So just return in case of error
+		return err
+	}
+
+	if flows.HasGroup(flow) {
+		// handle multicast flow
+		return f.handleFlowWithGroup(ctx, actionInfo, classifierInfo, flow)
+	}
+
+	/* Controller bound trap flows */
+	err = formulateControllerBoundTrapFlowInfo(ctx, actionInfo, classifierInfo, flow)
+	if err != nil {
+		// error if any, already logged in the called function
+		return err
+	}
+
+	logger.Debugw(ctx, "flow-ports",
+		log.Fields{
+			"classifierinfo_inport": classifierInfo[InPort],
+			"action_output":         actionInfo[Output]})
+	portNo, intfID, onuID, uniID := ExtractAccessFromFlow(classifierInfo[InPort].(uint32), actionInfo[Output].(uint32))
+
+	if ethType, ok := classifierInfo[EthType]; ok {
+		if ethType.(uint32) == LldpEthType {
+			logger.Info(ctx, "adding-lldp-flow")
+			return f.addLLDPFlow(ctx, flow, portNo)
+		}
+	}
+	if ipProto, ok := classifierInfo[IPProto]; ok {
+		if ipProto.(uint32) == IPProtoDhcp {
+			if udpSrc, ok := classifierInfo[UDPSrc]; ok {
+				if udpSrc.(uint32) == uint32(67) || udpSrc.(uint32) == uint32(546) {
+					logger.Debug(ctx, "trap-dhcp-from-nni-flow")
+					return f.addDHCPTrapFlowOnNNI(ctx, flow, classifierInfo, portNo)
+				}
+			}
+		}
+	}
+	if isIgmpTrapDownstreamFlow(classifierInfo) {
+		logger.Debug(ctx, "trap-igmp-from-nni-flow")
+		return f.addIgmpTrapFlowOnNNI(ctx, flow, classifierInfo, portNo)
+	}
+
+	f.resourceMgr.AddUniPortToOnuInfo(ctx, intfID, onuID, portNo)
+
+	TpID, err := getTpIDFromFlow(ctx, flow)
+	if err != nil {
+		return olterrors.NewErrNotFound("tpid-for-flow",
+			log.Fields{
+				"flow":    flow,
+				"intf-id": IntfID,
+				"onu-id":  onuID,
+				"uni-id":  uniID}, err)
+	}
+	logger.Debugw(ctx, "tpid-for-this-subcriber",
+		log.Fields{
+			"tp-id":   TpID,
+			"intf-id": intfID,
+			"onu-id":  onuID,
+			"uni-id":  uniID})
+	if IsUpstream(actionInfo[Output].(uint32)) {
+		UsMeterID = flows.GetMeterIdFromFlow(flow)
+		logger.Debugw(ctx, "upstream-flow-meter-id", log.Fields{"us-meter-id": UsMeterID})
+	} else {
+		DsMeterID = flows.GetMeterIdFromFlow(flow)
+		logger.Debugw(ctx, "downstream-flow-meter-id", log.Fields{"ds-meter-id": DsMeterID})
+
+	}
+
+	pnFlDelKey := pendingFlowDeleteKey{intfID, onuID, uniID}
+	if _, ok := f.pendingFlowDelete.Load(pnFlDelKey); !ok {
+		logger.Debugw(ctx, "no-pending-flows-found--going-ahead-with-flow-install",
+			log.Fields{
+				"intf-id": intfID,
+				"onu-id":  onuID,
+				"uni-id":  uniID})
+		f.divideAndAddFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, uint32(TpID), UsMeterID, DsMeterID, flowMetadata)
+	} else {
+		pendingFlowDelComplete := make(chan bool)
+		go f.waitForFlowDeletesToCompleteForOnu(ctx, intfID, onuID, uniID, pendingFlowDelComplete)
+		select {
+		case <-pendingFlowDelComplete:
+			logger.Debugw(ctx, "all-pending-flow-deletes-completed",
+				log.Fields{
+					"intf-id": intfID,
+					"onu-id":  onuID,
+					"uni-id":  uniID})
+			f.divideAndAddFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, uint32(TpID), UsMeterID, DsMeterID, flowMetadata)
+
+		case <-time.After(10 * time.Second):
+			return olterrors.NewErrTimeout("pending-flow-deletes",
+				log.Fields{
+					"intf-id": intfID,
+					"onu-id":  onuID,
+					"uni-id":  uniID}, nil)
+		}
+	}
+
+	logger.Debugw(ctx, "end-adding-flow",
+		log.Fields{
+			"flow":         flow,
+			"flowmetadata": flowMetadata})
+
+	return nil
+}
+
+// handleFlowWithGroup adds multicast flow to the device.
+func (f *OpenOltFlowMgr) handleFlowWithGroup(ctx context.Context, actionInfo, classifierInfo map[string]interface{}, flow *ofp.OfpFlowStats) error {
+	classifierInfo[PacketTagType] = DoubleTag
+	logger.Debugw(ctx, "add-multicast-flow", log.Fields{
+		"classifier-info": classifierInfo,
+		"actionInfo":      actionInfo})
+
+	networkInterfaceID, err := f.getNNIInterfaceIDOfMulticastFlow(ctx, classifierInfo)
+	if err != nil {
+		return olterrors.NewErrNotFound("multicast-in-port", log.Fields{"classifier": classifierInfo}, err)
+	}
+	mcastFlowClassificationByEthDst := false
+
+	if mcastFlowClassificationByEthDst {
+		//replace ipDst with ethDst
+		if ipv4Dst, ok := classifierInfo[Ipv4Dst]; ok &&
+			flows.IsMulticastIp(ipv4Dst.(uint32)) {
+			// replace ipv4_dst classifier with eth_dst
+			multicastMac := flows.ConvertToMulticastMacBytes(ipv4Dst.(uint32))
+			delete(classifierInfo, Ipv4Dst)
+			classifierInfo[EthDst] = multicastMac
+			logger.Debugw(ctx, "multicast-ip-to-mac-conversion-success",
+				log.Fields{
+					"ip:":  ipv4Dst.(uint32),
+					"mac:": multicastMac})
+		}
+	}
+	delete(classifierInfo, EthType)
+
+	onuID := NoneOnuID
+	uniID := NoneUniID
+	gemPortID := NoneGemPortID
+
+	flowStoreCookie := getFlowStoreCookie(ctx, classifierInfo, uint32(0))
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Infow(ctx, "multicast-flow-exists-not-re-adding", log.Fields{"classifier-info": classifierInfo})
+		return nil
+	}
+	flowID, err := f.resourceMgr.GetFlowID(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), uint32(gemPortID), flowStoreCookie, "", 0, 0)
+	if err != nil {
+		return olterrors.NewErrNotFound("multicast-flow-id",
+			log.Fields{
+				"interface-id": networkInterfaceID,
+				"onu-id":       onuID,
+				"uni-id":       uniID,
+				"gem-port-id":  gemPortID,
+				"cookie":       flowStoreCookie},
+			err)
+	}
+	classifierProto, err := makeOpenOltClassifierField(classifierInfo)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifierInfo}, err)
+	}
+	groupID := actionInfo[GroupID].(uint32)
+	multicastFlow := openoltpb2.Flow{
+		FlowId:        flowID,
+		FlowType:      Multicast,
+		NetworkIntfId: int32(networkInterfaceID),
+		GroupId:       groupID,
+		Classifier:    classifierProto,
+		Priority:      int32(flow.Priority),
+		Cookie:        flow.Cookie}
+
+	if err := f.addFlowToDevice(ctx, flow, &multicastFlow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, log.Fields{"flow": multicastFlow}, err)
+	}
+	logger.Info(ctx, "multicast-flow-added-to-device-successfully")
+	if group, _, err := f.GetFlowGroupFromKVStore(ctx, groupID, true); err == nil {
+		//calling groupAdd to set group members after multicast flow creation
+		if err := f.ModifyGroup(ctx, group); err != nil {
+			return olterrors.NewErrGroupOp("modify", groupID, log.Fields{"group": group}, err)
+		}
+		//cached group can be removed now
+		if err := f.resourceMgr.RemoveFlowGroupFromKVStore(ctx, groupID, true); err != nil {
+			logger.Warnw(ctx, "failed-to-remove-flow-group", log.Fields{"group-id": groupID, "error": err})
+		}
+	}
+
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &multicastFlow, flowStoreCookie, MulticastFlow, flowID, flow.Id)
+	if err = f.updateFlowInfoToKVStore(ctx, int32(networkInterfaceID),
+		int32(onuID),
+		int32(uniID),
+		flowID, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flowID, log.Fields{"flow": multicastFlow}, err)
+	}
+	return nil
+}
+
+//getNNIInterfaceIDOfMulticastFlow returns associated NNI interface id of the inPort criterion if exists; returns the first NNI interface of the device otherwise
+func (f *OpenOltFlowMgr) getNNIInterfaceIDOfMulticastFlow(ctx context.Context, classifierInfo map[string]interface{}) (uint32, error) {
+	if inPort, ok := classifierInfo[InPort]; ok {
+		nniInterfaceID, err := IntfIDFromNniPortNum(ctx, inPort.(uint32))
+		if err != nil {
+			return 0, olterrors.NewErrInvalidValue(log.Fields{"nni-in-port-number": inPort}, err)
+		}
+		return nniInterfaceID, nil
+	}
+	nniPorts, e := f.resourceMgr.GetNNIFromKVStore(ctx)
+	if e == nil && len(nniPorts) > 0 {
+		return nniPorts[0], nil
+	}
+	return 0, olterrors.NewErrNotFound("nni-port", nil, e).Log()
+}
+
+// AddGroup add or update the group
+func (f *OpenOltFlowMgr) AddGroup(ctx context.Context, group *ofp.OfpGroupEntry) error {
+	logger.Infow(ctx, "add-group", log.Fields{"group": group})
+	if group == nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"group": group}, nil)
+	}
+
+	groupToOlt := openoltpb2.Group{
+		GroupId: group.Desc.GroupId,
+		Command: openoltpb2.Group_SET_MEMBERS,
+		Action:  f.buildGroupAction(),
+	}
+
+	logger.Debugw(ctx, "sending-group-to-device", log.Fields{"groupToOlt": groupToOlt})
+	_, err := f.deviceHandler.Client.PerformGroupOperation(ctx, &groupToOlt)
+	if err != nil {
+		return olterrors.NewErrAdapter("add-group-operation-failed", log.Fields{"groupToOlt": groupToOlt}, err)
+	}
+	if err := f.resourceMgr.AddFlowGroupToKVStore(ctx, group, true); err != nil {
+		return olterrors.NewErrPersistence("add", "flow-group", group.Desc.GroupId, log.Fields{"group": group}, err)
+	}
+	logger.Infow(ctx, "add-group-operation-performed-on-the-device-successfully ", log.Fields{"groupToOlt": groupToOlt})
+	return nil
+}
+
+// DeleteGroup deletes a group from the device
+func (f *OpenOltFlowMgr) DeleteGroup(ctx context.Context, group *ofp.OfpGroupEntry) error {
+	logger.Debugw(ctx, "delete-group", log.Fields{"group": group})
+	if group == nil {
+		logger.Error(ctx, "unable-to-delete-group--invalid-argument--group-is-nil")
+		return olterrors.NewErrInvalidValue(log.Fields{"group": group}, nil)
+	}
+
+	groupToOlt := openoltpb2.Group{
+		GroupId: group.Desc.GroupId,
+	}
+
+	logger.Debugw(ctx, "deleting-group-from-device", log.Fields{"groupToOlt": groupToOlt})
+	_, err := f.deviceHandler.Client.DeleteGroup(ctx, &groupToOlt)
+	if err != nil {
+		logger.Errorw(ctx, "delete-group-failed-on-dev", log.Fields{"groupToOlt": groupToOlt, "err": err})
+		return olterrors.NewErrAdapter("delete-group-operation-failed", log.Fields{"groupToOlt": groupToOlt}, err)
+	}
+	if err := f.resourceMgr.RemoveFlowGroupFromKVStore(ctx, group.Desc.GroupId, false); err != nil {
+		return olterrors.NewErrPersistence("delete", "flow-group", group.Desc.GroupId, log.Fields{"group": group}, err)
+	}
+	logger.Debugw(ctx, "delete-group-operation-performed-on-the-device-successfully ", log.Fields{"groupToOlt": groupToOlt})
+	return nil
+}
+
+//buildGroupAction creates and returns a group action
+func (f *OpenOltFlowMgr) buildGroupAction() *openoltpb2.Action {
+	var actionCmd openoltpb2.ActionCmd
+	var action openoltpb2.Action
+	action.Cmd = &actionCmd
+	action.Cmd.RemoveOuterTag = true
+	return &action
+}
+
+// ModifyGroup updates the group
+func (f *OpenOltFlowMgr) ModifyGroup(ctx context.Context, group *ofp.OfpGroupEntry) error {
+	logger.Infow(ctx, "modify-group", log.Fields{"group": group})
+	if group == nil || group.Desc == nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"group": group}, nil)
+	}
+
+	newGroup := f.buildGroup(ctx, group.Desc.GroupId, group.Desc.Buckets)
+	val, groupExists, err := f.GetFlowGroupFromKVStore(ctx, group.Desc.GroupId, false)
+
+	if err != nil {
+		return olterrors.NewErrNotFound("flow-group-in-kv-store", log.Fields{"groupId": group.Desc.GroupId}, err)
+	}
+
+	var current *openoltpb2.Group // represents the group on the device
+	if groupExists {
+		// group already exists
+		current = f.buildGroup(ctx, group.Desc.GroupId, val.Desc.GetBuckets())
+		logger.Debugw(ctx, "modify-group--group exists",
+			log.Fields{
+				"group on the device": val,
+				"new":                 group})
+	} else {
+		current = f.buildGroup(ctx, group.Desc.GroupId, nil)
+	}
+
+	logger.Debugw(ctx, "modify-group--comparing-current-and-new",
+		log.Fields{
+			"group on the device": current,
+			"new":                 newGroup})
+	membersToBeAdded := f.findDiff(current, newGroup)
+	membersToBeRemoved := f.findDiff(newGroup, current)
+
+	logger.Infow(ctx, "modify-group--differences found", log.Fields{
+		"membersToBeAdded":   membersToBeAdded,
+		"membersToBeRemoved": membersToBeRemoved,
+		"groupId":            group.Desc.GroupId})
+
+	groupToOlt := openoltpb2.Group{
+		GroupId: group.Desc.GroupId,
+	}
+	var errAdd, errRemoved error
+	if len(membersToBeAdded) > 0 {
+		groupToOlt.Command = openoltpb2.Group_ADD_MEMBERS
+		groupToOlt.Members = membersToBeAdded
+		//execute addMembers
+		errAdd = f.callGroupAddRemove(ctx, &groupToOlt)
+	}
+	if len(membersToBeRemoved) > 0 {
+		groupToOlt.Command = openoltpb2.Group_REMOVE_MEMBERS
+		groupToOlt.Members = membersToBeRemoved
+		//execute removeMembers
+		errRemoved = f.callGroupAddRemove(ctx, &groupToOlt)
+	}
+
+	if errAdd == nil && errRemoved == nil {
+		if err := f.resourceMgr.AddFlowGroupToKVStore(ctx, group, false); err != nil {
+			return olterrors.NewErrPersistence("add", "flow-group", group.Desc.GroupId, log.Fields{"group": group}, err)
+		}
+		logger.Infow(ctx, "modify-group-was-success--storing-group",
+			log.Fields{
+				"group":         group,
+				"existingGroup": current})
+	} else {
+		logger.Warnw(ctx, "one-of-the-group-add/remove-operations-failed--cannot-save-group-modifications",
+			log.Fields{"group": group})
+		if errAdd != nil {
+			return errAdd
+		}
+		return errRemoved
+	}
+	return nil
+}
+
+//callGroupAddRemove performs add/remove buckets operation for the indicated group
+func (f *OpenOltFlowMgr) callGroupAddRemove(ctx context.Context, group *openoltpb2.Group) error {
+	if err := f.performGroupOperation(ctx, group); err != nil {
+		st, _ := status.FromError(err)
+		//ignore already exists error code
+		if st.Code() != codes.AlreadyExists {
+			return olterrors.NewErrGroupOp("groupAddRemove", group.GroupId, log.Fields{"status": st}, err)
+		}
+	}
+	return nil
+}
+
+//findDiff compares group members and finds members which only exists in groups2
+func (f *OpenOltFlowMgr) findDiff(group1 *openoltpb2.Group, group2 *openoltpb2.Group) []*openoltpb2.GroupMember {
+	var members []*openoltpb2.GroupMember
+	for _, bucket := range group2.Members {
+		if !f.contains(group1.Members, bucket) {
+			// bucket does not exist and must be added
+			members = append(members, bucket)
+		}
+	}
+	return members
+}
+
+//contains returns true if the members list contains the given member; false otherwise
+func (f *OpenOltFlowMgr) contains(members []*openoltpb2.GroupMember, member *openoltpb2.GroupMember) bool {
+	for _, groupMember := range members {
+		if groupMember.InterfaceId == member.InterfaceId {
+			return true
+		}
+	}
+	return false
+}
+
+//performGroupOperation call performGroupOperation operation of openolt proto
+func (f *OpenOltFlowMgr) performGroupOperation(ctx context.Context, group *openoltpb2.Group) error {
+	logger.Debugw(ctx, "sending-group-to-device",
+		log.Fields{
+			"groupToOlt": group,
+			"command":    group.Command})
+	_, err := f.deviceHandler.Client.PerformGroupOperation(log.WithSpanFromContext(context.Background(), ctx), group)
+	if err != nil {
+		return olterrors.NewErrAdapter("group-operation-failed", log.Fields{"groupToOlt": group}, err)
+	}
+	return nil
+}
+
+//buildGroup build openoltpb2.Group from given group id and bucket list
+func (f *OpenOltFlowMgr) buildGroup(ctx context.Context, groupID uint32, buckets []*ofp.OfpBucket) *openoltpb2.Group {
+	group := openoltpb2.Group{
+		GroupId: groupID}
+	for _, ofBucket := range buckets {
+		member := f.buildMember(ctx, ofBucket)
+		if member != nil && !f.contains(group.Members, member) {
+			group.Members = append(group.Members, member)
+		}
+	}
+	return &group
+}
+
+//buildMember builds openoltpb2.GroupMember from an OpenFlow bucket
+func (f *OpenOltFlowMgr) buildMember(ctx context.Context, ofBucket *ofp.OfpBucket) *openoltpb2.GroupMember {
+	var outPort uint32
+	outPortFound := false
+	for _, ofAction := range ofBucket.Actions {
+		if ofAction.Type == ofp.OfpActionType_OFPAT_OUTPUT {
+			outPort = ofAction.GetOutput().Port
+			outPortFound = true
+		}
+	}
+
+	if !outPortFound {
+		logger.Debugw(ctx, "bucket-skipped-since-no-out-port-found-in-it", log.Fields{"ofBucket": ofBucket})
+		return nil
+	}
+	interfaceID := IntfIDFromUniPortNum(outPort)
+	logger.Debugw(ctx, "got-associated-interface-id-of-the-port",
+		log.Fields{
+			"portNumber:":  outPort,
+			"interfaceId:": interfaceID})
+	if groupInfo, ok := f.interfaceToMcastQueueMap[interfaceID]; ok {
+		member := openoltpb2.GroupMember{
+			InterfaceId:   interfaceID,
+			InterfaceType: openoltpb2.GroupMember_PON,
+			GemPortId:     groupInfo.gemPortID,
+			Priority:      groupInfo.servicePriority,
+		}
+		//add member to the group
+		return &member
+	}
+	logger.Warnf(ctx, "bucket-skipped-since-interface-2-gem-mapping-cannot-be-found", log.Fields{"ofBucket": ofBucket})
+	return nil
+}
+
+//sendTPDownloadMsgToChild send payload
+func (f *OpenOltFlowMgr) sendTPDownloadMsgToChild(ctx context.Context, intfID uint32, onuID uint32, uniID uint32, uni string, TpID uint32) error {
+
+	onuDev, err := f.getOnuDevice(ctx, intfID, onuID)
+	if err != nil {
+		logger.Errorw(ctx, "couldnt-find-onu-child-device",
+			log.Fields{
+				"intf-id": intfID,
+				"onu-id":  onuID,
+				"uni-id":  uniID})
+		return err
+	}
+	logger.Debugw(ctx, "got-child-device-from-olt-device-handler", log.Fields{"onu-id": onuDev.deviceID})
+
+	tpPath := f.getTPpath(ctx, intfID, uni, TpID)
+	tpDownloadMsg := &ic.InterAdapterTechProfileDownloadMessage{UniId: uniID, Path: tpPath}
+	logger.Debugw(ctx, "sending-load-tech-profile-request-to-brcm-onu-adapter", log.Fields{"tpDownloadMsg": *tpDownloadMsg})
+	sendErr := f.deviceHandler.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx),
+		tpDownloadMsg,
+		ic.InterAdapterMessageType_TECH_PROFILE_DOWNLOAD_REQUEST,
+		f.deviceHandler.device.Type,
+		onuDev.deviceType,
+		onuDev.deviceID,
+		onuDev.proxyDeviceID, "")
+	if sendErr != nil {
+		return olterrors.NewErrCommunication("send-techprofile-download-request",
+			log.Fields{
+				"from-adapter":  f.deviceHandler.device.Type,
+				"to-adapter":    onuDev.deviceType,
+				"onu-id":        onuDev.deviceID,
+				"proxyDeviceID": onuDev.proxyDeviceID}, sendErr)
+	}
+	logger.Infow(ctx, "success-sending-load-tech-profile-request-to-brcm-onu-adapter", log.Fields{"tpDownloadMsg": *tpDownloadMsg})
+	return nil
+}
+
+//UpdateOnuInfo function adds onu info to cache and kvstore
+func (f *OpenOltFlowMgr) UpdateOnuInfo(ctx context.Context, intfID uint32, onuID uint32, serialNum string) error {
+
+	f.onuGemInfoLock.Lock()
+	defer f.onuGemInfoLock.Unlock()
+
+	onu := rsrcMgr.OnuGemInfo{OnuID: onuID, SerialNumber: serialNum, IntfID: intfID}
+	f.onuGemInfo[intfID] = append(f.onuGemInfo[intfID], onu)
+	if err := f.resourceMgr.AddOnuGemInfo(ctx, intfID, onu); err != nil {
+		return err
+	}
+	logger.Infow(ctx, "updated-onuinfo",
+		log.Fields{
+			"intf-id":    intfID,
+			"onu-id":     onuID,
+			"serial-num": serialNum,
+			"onu":        onu,
+			"device-id":  f.deviceHandler.device.Id})
+	return nil
+}
+
+//addGemPortToOnuInfoMap function adds GEMport to ONU map
+func (f *OpenOltFlowMgr) addGemPortToOnuInfoMap(ctx context.Context, intfID uint32, onuID uint32, gemPort uint32) {
+
+	f.onuGemInfoLock.Lock()
+	defer f.onuGemInfoLock.Unlock()
+
+	logger.Infow(ctx, "adding-gem-to-onu-info-map",
+		log.Fields{
+			"gem-port-id": gemPort,
+			"intf-id":     intfID,
+			"onu-id":      onuID,
+			"device-id":   f.deviceHandler.device.Id,
+			"onu-gem":     f.onuGemInfo[intfID]})
+	onugem := f.onuGemInfo[intfID]
+	for idx, onu := range onugem {
+		if onu.OnuID == onuID {
+			// check if gem already exists , else update the cache and kvstore
+			for _, gem := range onu.GemPorts {
+				if gem == gemPort {
+					logger.Debugw(ctx, "gem-already-in-cache-no-need-to-update-cache-and-kv-store",
+						log.Fields{
+							"gem":       gemPort,
+							"device-id": f.deviceHandler.device.Id})
+					return
+				}
+			}
+			onugem[idx].GemPorts = append(onugem[idx].GemPorts, gemPort)
+			f.onuGemInfo[intfID] = onugem
+		}
+	}
+	err := f.resourceMgr.AddGemToOnuGemInfo(ctx, intfID, onuID, gemPort)
+	if err != nil {
+		logger.Errorw(ctx, "failed-to-add-gem-to-onu",
+			log.Fields{
+				"intf-id":   intfID,
+				"onu-id":    onuID,
+				"gemPort":   gemPort,
+				"device-id": f.deviceHandler.device.Id})
+		return
+	}
+	logger.Infow(ctx, "gem-added-to-onu-info-map",
+		log.Fields{
+			"gem-port-id": gemPort,
+			"intf-id":     intfID,
+			"onu-id":      onuID,
+			"device-id":   f.deviceHandler.device.Id,
+			"onu-gem":     f.onuGemInfo[intfID]})
+}
+
+// This function Lookup maps  by serialNumber or (intfId, gemPort)
+
+//getOnuIDfromGemPortMap Returns OnuID,nil if found or set 0,error if no onuId is found for serialNumber or (intfId, gemPort)
+func (f *OpenOltFlowMgr) getOnuIDfromGemPortMap(ctx context.Context, intfID uint32, gemPortID uint32) (uint32, error) {
+
+	f.onuGemInfoLock.RLock()
+	defer f.onuGemInfoLock.RUnlock()
+
+	logger.Infow(ctx, "getting-onu-id-from-gem-port-and-pon-port",
+		log.Fields{
+			"device-id":   f.deviceHandler.device.Id,
+			"onu-geminfo": f.onuGemInfo[intfID],
+			"intf-id":     intfID,
+			"gemport-id":  gemPortID})
+
+	onugem := f.onuGemInfo[intfID]
+
+	for _, onu := range onugem {
+		for _, gem := range onu.GemPorts {
+			if gem == gemPortID {
+				return onu.OnuID, nil
+			}
+		}
+	}
+	logger.Errorw(ctx, "onu-id-from-gem-port-not-found", log.Fields{
+		"gem-port-id":      gemPortID,
+		"interface-id":     intfID,
+		"all-gems-on-port": onugem,
+	})
+	return uint32(0), olterrors.NewErrNotFound("onu-id", log.Fields{
+		"interface-id": intfID,
+		"gem-port-id":  gemPortID},
+		nil)
+}
+
+//GetLogicalPortFromPacketIn function computes logical port UNI/NNI port from packet-in indication and returns the same
+func (f *OpenOltFlowMgr) GetLogicalPortFromPacketIn(ctx context.Context, packetIn *openoltpb2.PacketIndication) (uint32, error) {
+	var logicalPortNum uint32
+	var onuID uint32
+	var err error
+
+	if packetIn.IntfType == "pon" {
+		// packet indication does not have serial number , so sending as nil
+		if onuID, err = f.getOnuIDfromGemPortMap(ctx, packetIn.IntfId, packetIn.GemportId); err != nil {
+			// Called method is returning error with all data populated; just return the same
+			return logicalPortNum, err
+		}
+		if packetIn.PortNo != 0 {
+			logicalPortNum = packetIn.PortNo
+		} else {
+			uniID := uint32(0) //  FIXME - multi-uni support
+			logicalPortNum = MkUniPortNum(ctx, packetIn.IntfId, onuID, uniID)
+		}
+		// Store the gem port through which the packet_in came. Use the same gem port for packet_out
+		f.UpdateGemPortForPktIn(ctx, packetIn.IntfId, onuID, logicalPortNum, packetIn.GemportId, packetIn.Pkt)
+	} else if packetIn.IntfType == "nni" {
+		logicalPortNum = IntfIDToPortNo(packetIn.IntfId, voltha.Port_ETHERNET_NNI)
+	}
+	logger.Infow(ctx, "retrieved-logicalport-from-packet-in",
+		log.Fields{
+			"logical-port-num": logicalPortNum,
+			"intf-type":        packetIn.IntfType,
+			"packet":           hex.EncodeToString(packetIn.Pkt),
+		})
+	return logicalPortNum, nil
+}
+
+//GetPacketOutGemPortID returns gemPortId
+func (f *OpenOltFlowMgr) GetPacketOutGemPortID(ctx context.Context, intfID uint32, onuID uint32, portNum uint32, packet []byte) (uint32, error) {
+	var gemPortID uint32
+
+	ctag, priority, err := getCTagFromPacket(ctx, packet)
+	if err != nil {
+		return 0, err
+	}
+
+	f.onuGemInfoLock.RLock()
+	defer f.onuGemInfoLock.RUnlock()
+	pktInkey := rsrcMgr.PacketInInfoKey{IntfID: intfID, OnuID: onuID, LogicalPort: portNum, VlanID: ctag, Priority: priority}
+	var ok bool
+	gemPortID, ok = f.packetInGemPort[pktInkey]
+	if ok {
+		logger.Debugw(ctx, "found-gemport-for-pktin-key",
+			log.Fields{
+				"pktinkey": pktInkey,
+				"gem":      gemPortID})
+
+		return gemPortID, nil
+	}
+	gemPortID, err = f.resourceMgr.GetGemPortFromOnuPktIn(ctx, pktInkey)
+	if err == nil {
+		if gemPortID != 0 {
+			f.packetInGemPort[pktInkey] = gemPortID
+			logger.Infow(ctx, "found-gem-port-from-kv-store-and-updating-cache-with-gemport",
+				log.Fields{
+					"pktinkey": pktInkey,
+					"gem":      gemPortID})
+			return gemPortID, nil
+		}
+	}
+	return uint32(0), olterrors.NewErrNotFound("gem-port",
+		log.Fields{
+			"pktinkey": pktInkey,
+			"gem":      gemPortID}, err)
+
+}
+
+// nolint: gocyclo
+func installFlowOnAllGemports(ctx context.Context,
+	f1 func(ctx context.Context, intfId uint32, onuId uint32, uniId uint32,
+		portNo uint32, classifier map[string]interface{}, action map[string]interface{},
+		logicalFlow *ofp.OfpFlowStats, allocId uint32, gemPortId uint32, tpID uint32) error,
+	f2 func(ctx context.Context, intfId uint32, onuId uint32, uniId uint32, portNo uint32,
+		classifier map[string]interface{}, action map[string]interface{},
+		logicalFlow *ofp.OfpFlowStats, allocId uint32, gemPortId uint32, vlanId uint32,
+		tpID uint32) error,
+	args map[string]uint32,
+	classifier map[string]interface{}, action map[string]interface{},
+	logicalFlow *ofp.OfpFlowStats,
+	gemPorts []uint32,
+	TpInst interface{},
+	FlowType string,
+	direction string,
+	tpID uint32,
+	vlanID ...uint32) {
+	logger.Debugw(ctx, "installing-flow-on-all-gem-ports",
+		log.Fields{
+			"FlowType": FlowType,
+			"gemPorts": gemPorts,
+			"vlan":     vlanID})
+
+
+
+	switch TpInst := TpInst.(type) {
+	case *tp.TechProfile:
+		attributes := TpInst.DownstreamGemPortAttributeList
+		if direction == Upstream {
+			attributes = TpInst.UpstreamGemPortAttributeList
+		}
+
+		for _, gemPortAttribute := range attributes {
+			if direction == Downstream && strings.ToUpper(gemPortAttribute.IsMulticast) == "TRUE" {
+				continue
+			}
+			gemPortID := gemPortAttribute.GemportID
+			if allPbitsMarked(gemPortAttribute.PbitMap) {
+				classifier[VlanPcp] = uint32(VlanPCPMask)
+				if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+					if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+						logger.Warn(ctx, err)
+					}
+				} else if FlowType == EapolFlow {
+					if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+						logger.Warn(ctx, err)
+					}
+				}
+			} else {
+				for pos, pbitSet := range strings.TrimPrefix(gemPortAttribute.PbitMap, BinaryStringPrefix) {
+					if pbitSet == BinaryBit1 {
+						classifier[VlanPcp] = uint32(len(strings.TrimPrefix(gemPortAttribute.PbitMap, BinaryStringPrefix))) - 1 - uint32(pos)
+						if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+							if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+								logger.Warn(ctx, err)
+							}
+						} else if FlowType == EapolFlow {
+							if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+								logger.Warn(ctx, err)
+							}
+						}
+					}
+				}
+			}
+		}
+	case *tp.EponProfile:
+		if direction == Upstream {
+			attributes := TpInst.UpstreamQueueAttributeList
+			for _, queueAttribute := range attributes {
+				gemPortID := queueAttribute.GemportID
+				if allPbitsMarked(queueAttribute.PbitMap) {
+					classifier[VlanPcp] = uint32(VlanPCPMask)
+					if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+						if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+							logger.Warn(ctx, err)
+						}
+					} else if FlowType == EapolFlow {
+						if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+							logger.Warn(ctx, err)
+						}
+					}
+				} else {
+					for pos, pbitSet := range strings.TrimPrefix(queueAttribute.PbitMap, BinaryStringPrefix) {
+						if pbitSet == BinaryBit1 {
+							classifier[VlanPcp] = uint32(len(strings.TrimPrefix(queueAttribute.PbitMap, BinaryStringPrefix))) - 1 - uint32(pos)
+							if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+								if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+									logger.Warn(ctx, err)
+								}
+							} else if FlowType == EapolFlow {
+								if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+									logger.Warn(ctx, err)
+								}
+							}
+						}
+					}
+				}
+			}
+		} else {
+			attributes := TpInst.DownstreamQueueAttributeList
+			for _, queueAttribute := range attributes {
+				gemPortID := queueAttribute.GemportID
+				if allPbitsMarked(queueAttribute.PbitMap) {
+					classifier[VlanPcp] = uint32(VlanPCPMask)
+					if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+						if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+							logger.Warn(ctx, err)
+						}
+					} else if FlowType == EapolFlow {
+						if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+							logger.Warn(ctx, err)
+						}
+					}
+				} else {
+					for pos, pbitSet := range strings.TrimPrefix(queueAttribute.PbitMap, BinaryStringPrefix) {
+						if pbitSet == BinaryBit1 {
+							classifier[VlanPcp] = uint32(len(strings.TrimPrefix(queueAttribute.PbitMap, BinaryStringPrefix))) - 1 - uint32(pos)
+							if FlowType == DhcpFlow || FlowType == IgmpFlow || FlowType == HsiaFlow {
+								if err := f1(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, tpID); err != nil {
+									logger.Warn(ctx, err)
+								}
+							} else if FlowType == EapolFlow {
+								if err := f2(ctx, args["intfId"], args["onuId"], args["uniId"], args["portNo"], classifier, action, logicalFlow, args["allocId"], gemPortID, vlanID[0], tpID); err != nil {
+									logger.Warn(ctx, err)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	default:
+		logger.Errorw(ctx, "unknown-tech", log.Fields{"tpInst": TpInst})
+	}
+}
+
+func allPbitsMarked(pbitMap string) bool {
+	for pos, pBit := range pbitMap {
+		if pos >= 2 && pBit != BinaryBit1 {
+			return false
+		}
+	}
+	return true
+}
+
+func (f *OpenOltFlowMgr) addDHCPTrapFlowOnNNI(ctx context.Context, logicalFlow *ofp.OfpFlowStats, classifier map[string]interface{}, portNo uint32) error {
+	logger.Debug(ctx, "adding-trap-dhcp-of-nni-flow")
+	action := make(map[string]interface{})
+	classifier[PacketTagType] = DoubleTag
+	action[TrapToHost] = true
+	/* We manage flowId resource pool on per PON port basis.
+	   Since this situation is tricky, as a hack, we pass the NNI port
+	   index (network_intf_id) as PON port Index for the flowId resource
+	   pool. Also, there is no ONU Id available for trapping DHCP packets
+	   on NNI port, use onu_id as -1 (invalid)
+	   ****************** CAVEAT *******************
+	   This logic works if the NNI Port Id falls within the same valid
+	   range of PON Port Ids. If this doesn't work for some OLT Vendor
+	   we need to have a re-look at this.
+	   *********************************************
+	*/
+	onuID := -1
+	uniID := -1
+	gemPortID := -1
+	allocID := -1
+	networkInterfaceID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-intreface-id",
+			log.Fields{
+				"classifier": classifier,
+				"action":     action},
+			err)
+	}
+
+	flowStoreCookie := getFlowStoreCookie(ctx, classifier, uint32(0))
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Info(ctx, "flow-exists-not-re-adding")
+		return nil
+	}
+	flowID, err := f.resourceMgr.GetFlowID(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), uint32(gemPortID), flowStoreCookie, "", 0, 0)
+	if err != nil {
+		return olterrors.NewErrNotFound("dhcp-trap-nni-flow-id",
+			log.Fields{
+				"interface-id": networkInterfaceID,
+				"onu-id":       onuID,
+				"uni-id":       uniID,
+				"gem-port-id":  gemPortID,
+				"cookie":       flowStoreCookie},
+			err)
+	}
+	classifierProto, err := makeOpenOltClassifierField(classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err)
+	}
+	logger.Debugw(ctx, "created-classifier-proto", log.Fields{"classifier": *classifierProto})
+	actionProto, err := makeOpenOltActionField(action, classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err)
+	}
+	logger.Debugw(ctx, "created-action-proto", log.Fields{"action": *actionProto})
+	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
+		OnuId:         int32(onuID), // OnuId not required
+		UniId:         int32(uniID), // UniId not used
+		FlowId:        flowID,
+		FlowType:      Downstream,
+		AllocId:       int32(allocID), // AllocId not used
+		NetworkIntfId: int32(networkInterfaceID),
+		GemportId:     int32(gemPortID), // GemportId not used
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo}
+	if err := f.addFlowToDevice(ctx, logicalFlow, &downstreamflow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, log.Fields{"flow": downstreamflow}, err)
+	}
+	logger.Info(ctx, "dhcp-trap-on-nni-flow-added–to-device-successfully")
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &downstreamflow, flowStoreCookie, "", flowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, int32(networkInterfaceID),
+		int32(onuID),
+		int32(uniID),
+		flowID, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flowID, log.Fields{"flow": downstreamflow}, err)
+	}
+	return nil
+}
+
+//getPacketTypeFromClassifiers finds and returns packet type of a flow by checking flow classifiers
+func getPacketTypeFromClassifiers(classifierInfo map[string]interface{}) string {
+	var packetType string
+	ovid, ivid := false, false
+	if vlanID, ok := classifierInfo[VlanVid].(uint32); ok {
+		vid := vlanID & VlanvIDMask
+		if vid != ReservedVlan {
+			ovid = true
+		}
+	}
+	if metadata, ok := classifierInfo[Metadata].(uint64); ok {
+		vid := uint32(metadata)
+		if vid != ReservedVlan {
+			ivid = true
+		}
+	}
+	if ovid && ivid {
+		packetType = DoubleTag
+	} else if !ovid && !ivid {
+		packetType = Untagged
+	} else {
+		packetType = SingleTag
+	}
+	return packetType
+}
+
+//addIgmpTrapFlowOnNNI adds a trap-to-host flow on NNI
+func (f *OpenOltFlowMgr) addIgmpTrapFlowOnNNI(ctx context.Context, logicalFlow *ofp.OfpFlowStats, classifier map[string]interface{}, portNo uint32) error {
+	logger.Infow(ctx, "adding-igmp-trap-of-nni-flow", log.Fields{"classifier-info": classifier})
+	action := make(map[string]interface{})
+	classifier[PacketTagType] = getPacketTypeFromClassifiers(classifier)
+	action[TrapToHost] = true
+	/* We manage flowId resource pool on per PON port basis.
+	   Since this situation is tricky, as a hack, we pass the NNI port
+	   index (network_intf_id) as PON port Index for the flowId resource
+	   pool. Also, there is no ONU Id available for trapping packets
+	   on NNI port, use onu_id as -1 (invalid)
+	   ****************** CAVEAT *******************
+	   This logic works if the NNI Port Id falls within the same valid
+	   range of PON Port Ids. If this doesn't work for some OLT Vendor
+	   we need to have a re-look at this.
+	   *********************************************
+	*/
+	onuID := -1
+	uniID := -1
+	gemPortID := -1
+	allocID := -1
+	networkInterfaceID, err := getNniIntfID(ctx, classifier, action)
+	if err != nil {
+		return olterrors.NewErrNotFound("nni-interface-id", log.Fields{
+			"classifier": classifier,
+			"action":     action},
+			err)
+	}
+	flowStoreCookie := getFlowStoreCookie(ctx, classifier, uint32(0))
+	if present := f.resourceMgr.IsFlowCookieOnKVStore(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), flowStoreCookie); present {
+		logger.Info(ctx, "igmp-flow-exists-not-re-adding")
+		return nil
+	}
+	flowID, err := f.resourceMgr.GetFlowID(ctx, uint32(networkInterfaceID), int32(onuID), int32(uniID), uint32(gemPortID), flowStoreCookie, "", 0, 0)
+	if err != nil {
+		return olterrors.NewErrNotFound("igmp-flow-id",
+			log.Fields{
+				"interface-id": networkInterfaceID,
+				"onu-id":       onuID,
+				"uni-id":       uniID,
+				"gem-port-id":  gemPortID,
+				"cookie":       flowStoreCookie},
+			err)
+	}
+	classifierProto, err := makeOpenOltClassifierField(classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"classifier": classifier}, err)
+	}
+	logger.Debugw(ctx, "created-classifier-proto-for-the-igmp-flow", log.Fields{"classifier": *classifierProto})
+	actionProto, err := makeOpenOltActionField(action, classifier)
+	if err != nil {
+		return olterrors.NewErrInvalidValue(log.Fields{"action": action}, err)
+	}
+	logger.Debugw(ctx, "created-action-proto-for-the-igmp-flow", log.Fields{"action": *actionProto})
+	downstreamflow := openoltpb2.Flow{AccessIntfId: int32(-1), // AccessIntfId not required
+		OnuId:         int32(onuID), // OnuId not required
+		UniId:         int32(uniID), // UniId not used
+		FlowId:        flowID,
+		FlowType:      Downstream,
+		AllocId:       int32(allocID), // AllocId not used
+		NetworkIntfId: int32(networkInterfaceID),
+		GemportId:     int32(gemPortID), // GemportId not used
+		Classifier:    classifierProto,
+		Action:        actionProto,
+		Priority:      int32(logicalFlow.Priority),
+		Cookie:        logicalFlow.Cookie,
+		PortNo:        portNo}
+	if err := f.addFlowToDevice(ctx, logicalFlow, &downstreamflow); err != nil {
+		return olterrors.NewErrFlowOp("add", flowID, log.Fields{"flow": downstreamflow}, err)
+	}
+	logger.Info(ctx, "igmp-trap-on-nni-flow-added-to-device-successfully")
+	flowsToKVStore := f.getUpdatedFlowInfo(ctx, &downstreamflow, flowStoreCookie, "", flowID, logicalFlow.Id)
+	if err := f.updateFlowInfoToKVStore(ctx, int32(networkInterfaceID),
+		int32(onuID),
+		int32(uniID),
+		flowID, flowsToKVStore); err != nil {
+		return olterrors.NewErrPersistence("update", "flow", flowID, log.Fields{"flow": downstreamflow}, err)
+	}
+	return nil
+}
+
+func verifyMeterIDAndGetDirection(MeterID uint32, Dir tp_pb.Direction) (string, error) {
+	if MeterID == 0 { // This should never happen
+		return "", olterrors.NewErrInvalidValue(log.Fields{"meter-id": MeterID}, nil).Log()
+	}
+	if Dir == tp_pb.Direction_UPSTREAM {
+		return "upstream", nil
+	} else if Dir == tp_pb.Direction_DOWNSTREAM {
+		return "downstream", nil
+	}
+	return "", nil
+}
+
+// nolint: gocyclo
+func (f *OpenOltFlowMgr) checkAndAddFlow(ctx context.Context, args map[string]uint32, classifierInfo map[string]interface{},
+	actionInfo map[string]interface{}, flow *ofp.OfpFlowStats, TpInst interface{}, gemPorts []uint32,
+	tpID uint32, uni string) {
+	var gemPort uint32
+	intfID := args[IntfID]
+	onuID := args[OnuID]
+	uniID := args[UniID]
+	portNo := args[PortNo]
+	allocID := args[AllocID]
+	if ipProto, ok := classifierInfo[IPProto]; ok {
+		if ipProto.(uint32) == IPProtoDhcp {
+			logger.Infow(ctx, "adding-dhcp-flow", log.Fields{
+				"tp-id":    tpID,
+				"alloc-id": allocID,
+				"intf-id":  intfID,
+				"onu-id":   onuID,
+				"uni-id":   uniID,
+			})
+			if pcp, ok := classifierInfo[VlanPcp]; ok {
+				gemPort = f.techprofile[intfID].GetGemportIDForPbit(ctx, TpInst,
+					tp_pb.Direction_UPSTREAM,
+					pcp.(uint32))
+				//Adding DHCP upstream flow
+
+				if err := f.addDHCPTrapFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, allocID, gemPort, tpID); err != nil {
+					logger.Warn(ctx, err)
+				}
+			} else {
+				//Adding DHCP upstream flow to all gemports
+				installFlowOnAllGemports(ctx, f.addDHCPTrapFlow, nil, args, classifierInfo, actionInfo, flow, gemPorts, TpInst, DhcpFlow, Upstream, tpID)
+			}
+
+		} else if ipProto.(uint32) == IgmpProto {
+			logger.Infow(ctx, "adding-us-igmp-flow",
+				log.Fields{
+					"intf-id":          intfID,
+					"onu-id":           onuID,
+					"uni-id":           uniID,
+					"classifier-info:": classifierInfo})
+			if pcp, ok := classifierInfo[VlanPcp]; ok {
+				gemPort = f.techprofile[intfID].GetGemportIDForPbit(ctx, TpInst,
+					tp_pb.Direction_UPSTREAM,
+					pcp.(uint32))
+				if err := f.addIGMPTrapFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, allocID, gemPort, tpID); err != nil {
+					logger.Warn(ctx, err)
+				}
+			} else {
+				//Adding IGMP upstream flow to all gem ports
+				installFlowOnAllGemports(ctx, f.addIGMPTrapFlow, nil, args, classifierInfo, actionInfo, flow, gemPorts, TpInst, IgmpFlow, Upstream, tpID)
+			}
+		} else {
+			logger.Errorw(ctx, "invalid-classifier-to-handle", log.Fields{"classifier": classifierInfo, "action": actionInfo})
+			return
+		}
+	} else if ethType, ok := classifierInfo[EthType]; ok {
+		if ethType.(uint32) == EapEthType {
+			logger.Infow(ctx, "adding-eapol-flow", log.Fields{
+				"intf-id": intfID,
+				"onu-id":  onuID,
+				"uni-id":  uniID,
+			})
+			var vlanID uint32
+			if val, ok := classifierInfo[VlanVid]; ok {
+				vlanID = (val.(uint32)) & VlanvIDMask
+			} else {
+				vlanID = DefaultMgmtVlan
+			}
+			if pcp, ok := classifierInfo[VlanPcp]; ok {
+				gemPort = f.techprofile[intfID].GetGemportIDForPbit(ctx, TpInst,
+					tp_pb.Direction_UPSTREAM,
+					pcp.(uint32))
+
+				if err := f.addEAPOLFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, allocID, gemPort, vlanID, tpID); err != nil {
+					logger.Warn(ctx, err)
+				}
+			} else {
+				installFlowOnAllGemports(ctx, nil, f.addEAPOLFlow, args, classifierInfo, actionInfo, flow, gemPorts, TpInst, EapolFlow, Upstream, tpID, vlanID)
+			}
+		}
+	} else if _, ok := actionInfo[PushVlan]; ok {
+		logger.Infow(ctx, "adding-upstream-data-rule", log.Fields{
+			"intf-id": intfID,
+			"onu-id":  onuID,
+			"uni-id":  uniID,
+		})
+		if pcp, ok := classifierInfo[VlanPcp]; ok {
+			gemPort = f.techprofile[intfID].GetGemportIDForPbit(ctx, TpInst,
+				tp_pb.Direction_UPSTREAM,
+				pcp.(uint32))
+			//Adding HSIA upstream flow
+			if err := f.addUpstreamDataFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, allocID, gemPort, tpID); err != nil {
+				logger.Warn(ctx, err)
+			}
+		} else {
+			//Adding HSIA upstream flow to all gemports
+			installFlowOnAllGemports(ctx, f.addUpstreamDataFlow, nil, args, classifierInfo, actionInfo, flow, gemPorts, TpInst, HsiaFlow, Upstream, tpID)
+		}
+	} else if _, ok := actionInfo[PopVlan]; ok {
+		logger.Infow(ctx, "adding-downstream-data-rule", log.Fields{
+			"intf-id": intfID,
+			"onu-id":  onuID,
+			"uni-id":  uniID,
+		})
+		if pcp, ok := classifierInfo[VlanPcp]; ok {
+			gemPort = f.techprofile[intfID].GetGemportIDForPbit(ctx, TpInst,
+				tp_pb.Direction_DOWNSTREAM,
+				pcp.(uint32))
+			//Adding HSIA downstream flow
+			if err := f.addDownstreamDataFlow(ctx, intfID, onuID, uniID, portNo, classifierInfo, actionInfo, flow, allocID, gemPort, tpID); err != nil {
+				logger.Warn(ctx, err)
+			}
+		} else {
+			//Adding HSIA downstream flow to all gemports
+			installFlowOnAllGemports(ctx, f.addDownstreamDataFlow, nil, args, classifierInfo, actionInfo, flow, gemPorts, TpInst, HsiaFlow, Downstream, tpID)
+		}
+	} else {
+		logger.Errorw(ctx, "invalid-flow-type-to-handle",
+			log.Fields{
+				"intf-id":    intfID,
+				"onu-id":     onuID,
+				"uni-id":     uniID,
+				"classifier": classifierInfo,
+				"action":     actionInfo,
+				"flow":       flow})
+		return
+	}
+	if noticeDownloadRequest {
+		go func() {
+			if err := f.sendTPDownloadMsgToChild(ctx, intfID, onuID, uniID, uni, tpID); err != nil {
+				logger.Warn(ctx, err)
+			}
+		}()
+	}
+}
+
+func (f *OpenOltFlowMgr) isGemPortUsedByAnotherFlow(ctx context.Context, gemPK gemPortKey) (bool, error) {
+	if f.perGemPortLock.TryLock(gemPK) {
+		flowIDList := f.flowsUsedByGemPort[gemPK]
+		f.perGemPortLock.Unlock(gemPK)
+		return len(flowIDList) > 1, nil
+	}
+	logger.Error(ctx, "failed-to-acquire-per-gem-port-lock",
+		log.Fields{
+			"device-id": f.deviceHandler.device.Id,
+			"key":       gemPK,
+		})
+	return false, olterrors.NewErrAdapter("failed-to-acquire-per-gem-port-lock", log.Fields{
+		"device-id": f.deviceHandler.device.Id,
+		"key":       gemPK,
+	}, nil)
+}
+
+func (f *OpenOltFlowMgr) isTechProfileUsedByAnotherGem(ctx context.Context, ponIntf uint32, onuID uint32, uniID uint32, tpID uint32, tpInst *tp.TechProfile, gemPortID uint32) (bool, uint32) {
+	currentGemPorts := f.resourceMgr.GetCurrentGEMPortIDsForOnu(ctx, ponIntf, onuID, uniID)
+	tpGemPorts := tpInst.UpstreamGemPortAttributeList
+	for _, currentGemPort := range currentGemPorts {
+		for _, tpGemPort := range tpGemPorts {
+			if (currentGemPort == tpGemPort.GemportID) && (currentGemPort != gemPortID) {
+				return true, currentGemPort
+			}
+		}
+	}
+	if tpInst.InstanceCtrl.Onu == "single-instance" {
+		// The TP information for the given TP ID, PON ID, ONU ID, UNI ID should be removed.
+		if err := f.resourceMgr.RemoveTechProfileIDForOnu(ctx, ponIntf, uint32(onuID), uint32(uniID), tpID); err != nil {
+			logger.Warn(ctx, err)
+		}
+		if err := f.DeleteTechProfileInstance(ctx, ponIntf, uint32(onuID), uint32(uniID), "", tpID); err != nil {
+			logger.Warn(ctx, err)
+		}
+
+		// Although we cleaned up TP Instance for the given (PON ID, ONU ID, UNI ID), the TP might
+		// still be used on other uni ports.
+		// So, we need to check and make sure that no other gem port is referring to the given TP ID
+		// on any other uni port.
+		tpInstances := f.techprofile[ponIntf].FindAllTpInstances(ctx, tpID, ponIntf, onuID).([]tp.TechProfile)
+		logger.Debugw(ctx, "got-single-instance-tp-instances", log.Fields{"tp-instances": tpInstances})
+		for i := 0; i < len(tpInstances); i++ {
+			tpI := tpInstances[i]
+			tpGemPorts := tpI.UpstreamGemPortAttributeList
+			for _, tpGemPort := range tpGemPorts {
+				if tpGemPort.GemportID != gemPortID {
+					logger.Debugw(ctx, "single-instance-tp-is-in-use-by-gem", log.Fields{"gemPort": tpGemPort.GemportID})
+					return true, tpGemPort.GemportID
+				}
+			}
+		}
+	}
+	logger.Debug(ctx, "tech-profile-is-not-in-use-by-any-gem")
+	return false, 0
+}
+
+func formulateClassifierInfoFromFlow(ctx context.Context, classifierInfo map[string]interface{}, flow *ofp.OfpFlowStats) {
+	for _, field := range flows.GetOfbFields(flow) {
+		if field.Type == flows.ETH_TYPE {
+			classifierInfo[EthType] = field.GetEthType()
+			logger.Debug(ctx, "field-type-eth-type", log.Fields{"classifierInfo[ETH_TYPE]": classifierInfo[EthType].(uint32)})
+		} else if field.Type == flows.ETH_DST {
+			classifierInfo[EthDst] = field.GetEthDst()
+			logger.Debug(ctx, "field-type-eth-type", log.Fields{"classifierInfo[ETH_DST]": classifierInfo[EthDst].([]uint8)})
+		} else if field.Type == flows.IP_PROTO {
+			classifierInfo[IPProto] = field.GetIpProto()
+			logger.Debug(ctx, "field-type-ip-proto", log.Fields{"classifierInfo[IP_PROTO]": classifierInfo[IPProto].(uint32)})
+		} else if field.Type == flows.IN_PORT {
+			classifierInfo[InPort] = field.GetPort()
+			logger.Debug(ctx, "field-type-in-port", log.Fields{"classifierInfo[IN_PORT]": classifierInfo[InPort].(uint32)})
+		} else if field.Type == flows.VLAN_VID {
+			classifierInfo[VlanVid] = field.GetVlanVid() & 0xfff
+			logger.Debug(ctx, "field-type-vlan-vid", log.Fields{"classifierInfo[VLAN_VID]": classifierInfo[VlanVid].(uint32)})
+		} else if field.Type == flows.VLAN_PCP {
+			classifierInfo[VlanPcp] = field.GetVlanPcp()
+			logger.Debug(ctx, "field-type-vlan-pcp", log.Fields{"classifierInfo[VLAN_PCP]": classifierInfo[VlanPcp].(uint32)})
+		} else if field.Type == flows.UDP_DST {
+			classifierInfo[UDPDst] = field.GetUdpDst()
+			logger.Debug(ctx, "field-type-udp-dst", log.Fields{"classifierInfo[UDP_DST]": classifierInfo[UDPDst].(uint32)})
+		} else if field.Type == flows.UDP_SRC {
+			classifierInfo[UDPSrc] = field.GetUdpSrc()
+			logger.Debug(ctx, "field-type-udp-src", log.Fields{"classifierInfo[UDP_SRC]": classifierInfo[UDPSrc].(uint32)})
+		} else if field.Type == flows.IPV4_DST {
+			classifierInfo[Ipv4Dst] = field.GetIpv4Dst()
+			logger.Debug(ctx, "field-type-ipv4-dst", log.Fields{"classifierInfo[IPV4_DST]": classifierInfo[Ipv4Dst].(uint32)})
+		} else if field.Type == flows.IPV4_SRC {
+			classifierInfo[Ipv4Src] = field.GetIpv4Src()
+			logger.Debug(ctx, "field-type-ipv4-src", log.Fields{"classifierInfo[IPV4_SRC]": classifierInfo[Ipv4Src].(uint32)})
+		} else if field.Type == flows.METADATA {
+			classifierInfo[Metadata] = field.GetTableMetadata()
+			logger.Debug(ctx, "field-type-metadata", log.Fields{"classifierInfo[Metadata]": classifierInfo[Metadata].(uint64)})
+		} else if field.Type == flows.TUNNEL_ID {
+			classifierInfo[TunnelID] = field.GetTunnelId()
+			logger.Debug(ctx, "field-type-tunnelId", log.Fields{"classifierInfo[TUNNEL_ID]": classifierInfo[TunnelID].(uint64)})
+		} else {
+			logger.Errorw(ctx, "un-supported-field-type", log.Fields{"type": field.Type})
+			return
+		}
+	}
+}
+
+func formulateActionInfoFromFlow(ctx context.Context, actionInfo, classifierInfo map[string]interface{}, flow *ofp.OfpFlowStats) error {
+	for _, action := range flows.GetActions(flow) {
+		if action.Type == flows.OUTPUT {
+			if out := action.GetOutput(); out != nil {
+				actionInfo[Output] = out.GetPort()
+				logger.Debugw(ctx, "action-type-output", log.Fields{"out-port": actionInfo[Output].(uint32)})
+			} else {
+				return olterrors.NewErrInvalidValue(log.Fields{"output-port": nil}, nil)
+			}
+		} else if action.Type == flows.POP_VLAN {
+			actionInfo[PopVlan] = true
+			logger.Debugw(ctx, "action-type-pop-vlan", log.Fields{"in_port": classifierInfo[InPort].(uint32)})
+		} else if action.Type == flows.PUSH_VLAN {
+			if out := action.GetPush(); out != nil {
+				if tpid := out.GetEthertype(); tpid != 0x8100 {
+					logger.Errorw(ctx, "invalid ethertype in push action", log.Fields{"ethertype": actionInfo[PushVlan].(int32)})
+				} else {
+					actionInfo[PushVlan] = true
+					actionInfo[TPID] = tpid
+					logger.Debugw(ctx, "action-type-push-vlan",
+						log.Fields{
+							"push-tpid": actionInfo[TPID].(uint32),
+							"in-port":   classifierInfo[InPort].(uint32)})
+				}
+			}
+		} else if action.Type == flows.SET_FIELD {
+			if out := action.GetSetField(); out != nil {
+				if field := out.GetField(); field != nil {
+					if ofClass := field.GetOxmClass(); ofClass != ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC {
+						return olterrors.NewErrInvalidValue(log.Fields{"openflow-class": ofClass}, nil)
+					}
+					/*logger.Debugw(ctx, "action-type-set-field",log.Fields{"field": field, "in_port": classifierInfo[IN_PORT].(uint32)})*/
+					formulateSetFieldActionInfoFromFlow(ctx, field, actionInfo)
+				}
+			}
+		} else if action.Type == flows.GROUP {
+			formulateGroupActionInfoFromFlow(ctx, action, actionInfo)
+		} else {
+			return olterrors.NewErrInvalidValue(log.Fields{"action-type": action.Type}, nil)
+		}
+	}
+	return nil
+}
+
+func formulateSetFieldActionInfoFromFlow(ctx context.Context, field *ofp.OfpOxmField, actionInfo map[string]interface{}) {
+	if ofbField := field.GetOfbField(); ofbField != nil {
+		fieldtype := ofbField.GetType()
+		if fieldtype == ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID {
+			if vlan := ofbField.GetVlanVid(); vlan != 0 {
+				actionInfo[VlanVid] = vlan & 0xfff
+				logger.Debugw(ctx, "action-set-vlan-vid", log.Fields{"actionInfo[VLAN_VID]": actionInfo[VlanVid].(uint32)})
+			} else {
+				logger.Error(ctx, "no-invalid-vlan-id-in-set-vlan-vid-action")
+			}
+		} else if fieldtype == ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP {
+			pcp := ofbField.GetVlanPcp()
+			actionInfo[VlanPcp] = pcp
+			logger.Debugw(ctx, "action-set-vlan-pcp", log.Fields{"actionInfo[VLAN_PCP]": actionInfo[VlanPcp].(uint32)})
+		} else {
+			logger.Errorw(ctx, "unsupported-action-set-field-type", log.Fields{"type": fieldtype})
+		}
+	}
+}
+
+func formulateGroupActionInfoFromFlow(ctx context.Context, action *ofp.OfpAction, actionInfo map[string]interface{}) {
+	if action.GetGroup() == nil {
+		logger.Warn(ctx, "no-group-entry-found-in-the-group-action")
+	} else {
+		actionInfo[GroupID] = action.GetGroup().GroupId
+		logger.Debugw(ctx, "action-group-id", log.Fields{"actionInfo[GroupID]": actionInfo[GroupID].(uint32)})
+	}
+}
+
+func formulateControllerBoundTrapFlowInfo(ctx context.Context, actionInfo, classifierInfo map[string]interface{}, flow *ofp.OfpFlowStats) error {
+	if isControllerFlow := IsControllerBoundFlow(actionInfo[Output].(uint32)); isControllerFlow {
+		logger.Debug(ctx, "controller-bound-trap-flows--getting-inport-from-tunnelid")
+		/* Get UNI port/ IN Port from tunnel ID field for upstream controller bound flows  */
+		if portType := IntfIDToPortTypeName(classifierInfo[InPort].(uint32)); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				classifierInfo[InPort] = uniPort
+				logger.Debugw(ctx, "upstream-pon-to-controller-flow--inport-in-tunnelid",
+					log.Fields{
+						"newinport": classifierInfo[InPort].(uint32),
+						"outport":   actionInfo[Output].(uint32)})
+			} else {
+				return olterrors.NewErrNotFound("child-in-port",
+					log.Fields{
+						"reason": "upstream-pon-to-controller-flow--no-inport-in-tunnelid",
+						"flow":   flow}, nil)
+			}
+		}
+	} else {
+		logger.Debug(ctx, "non-controller-flows--getting-uniport-from-tunnelid")
+		// Downstream flow from NNI to PON port , Use tunnel ID as new OUT port / UNI port
+		if portType := IntfIDToPortTypeName(actionInfo[Output].(uint32)); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				actionInfo[Output] = uniPort
+				logger.Debugw(ctx, "downstream-nni-to-pon-port-flow, outport-in-tunnelid",
+					log.Fields{
+						"newoutport": actionInfo[Output].(uint32),
+						"outport":    actionInfo[Output].(uint32)})
+			} else {
+				return olterrors.NewErrNotFound("out-port",
+					log.Fields{
+						"reason": "downstream-nni-to-pon-port-flow--no-outport-in-tunnelid",
+						"flow":   flow}, nil)
+			}
+			// Upstream flow from PON to NNI port , Use tunnel ID as new IN port / UNI port
+		} else if portType := IntfIDToPortTypeName(classifierInfo[InPort].(uint32)); portType == voltha.Port_PON_OLT {
+			if uniPort := flows.GetChildPortFromTunnelId(flow); uniPort != 0 {
+				classifierInfo[InPort] = uniPort
+				logger.Debugw(ctx, "upstream-pon-to-nni-port-flow, inport-in-tunnelid",
+					log.Fields{
+						"newinport": actionInfo[Output].(uint32),
+						"outport":   actionInfo[Output].(uint32)})
+			} else {
+				return olterrors.NewErrNotFound("nni-port",
+					log.Fields{
+						"reason":   "upstream-pon-to-nni-port-flow--no-inport-in-tunnelid",
+						"in-port":  classifierInfo[InPort].(uint32),
+						"out-port": actionInfo[Output].(uint32),
+						"flow":     flow}, nil)
+			}
+		}
+	}
+	return nil
+}
+
+func getTpIDFromFlow(ctx context.Context, flow *ofp.OfpFlowStats) (uint32, error) {
+	/*     Metadata 8 bytes:
+		   Most Significant 2 Bytes = Inner VLAN
+		   Next 2 Bytes = Tech Profile ID(TPID)
+		   Least Significant 4 Bytes = Port ID
+	       Flow Metadata carries Tech-Profile (TP) ID and is mandatory in all
+	       subscriber related flows.
+	*/
+	metadata := flows.GetMetadataFromWriteMetadataAction(ctx, flow)
+	if metadata == 0 {
+		return 0, olterrors.NewErrNotFound("metadata", log.Fields{"flow": flow}, nil)
+	}
+	TpID := flows.GetTechProfileIDFromWriteMetaData(ctx, metadata)
+	return uint32(TpID), nil
+}
+
+func appendUnique(slice []uint32, item uint32) []uint32 {
+	for _, sliceElement := range slice {
+		if sliceElement == item {
+			return slice
+		}
+	}
+	return append(slice, item)
+}
+
+// getNniIntfID gets nni intf id from the flow classifier/action
+func getNniIntfID(ctx context.Context, classifier map[string]interface{}, action map[string]interface{}) (uint32, error) {
+
+	portType := IntfIDToPortTypeName(classifier[InPort].(uint32))
+	if portType == voltha.Port_PON_OLT {
+		intfID, err := IntfIDFromNniPortNum(ctx, action[Output].(uint32))
+		if err != nil {
+			logger.Debugw(ctx, "invalid-action-port-number",
+				log.Fields{
+					"port-number": action[Output].(uint32),
+					"error":       err})
+			return uint32(0), err
+		}
+		logger.Infow(ctx, "output-nni-intfId-is", log.Fields{"intf-id": intfID})
+		return intfID, nil
+	} else if portType == voltha.Port_ETHERNET_NNI {
+		intfID, err := IntfIDFromNniPortNum(ctx, classifier[InPort].(uint32))
+		if err != nil {
+			logger.Debugw(ctx, "invalid-classifier-port-number",
+				log.Fields{
+					"port-number": action[Output].(uint32),
+					"error":       err})
+			return uint32(0), err
+		}
+		logger.Infow(ctx, "input-nni-intfId-is", log.Fields{"intf-id": intfID})
+		return intfID, nil
+	}
+	return uint32(0), nil
+}
+
+// UpdateGemPortForPktIn updates gemport for packet-in in to the cache and to the kv store as well.
+func (f *OpenOltFlowMgr) UpdateGemPortForPktIn(ctx context.Context, intfID uint32, onuID uint32, logicalPort uint32, gemPort uint32, pkt []byte) {
+	cTag, priority, err := getCTagFromPacket(ctx, pkt)
+	if err != nil {
+		logger.Errorw(ctx, "unable-to-update-gem-port-for-packet-in",
+			log.Fields{"intfID": intfID, "onuID": onuID, "logicalPort": logicalPort, "gemPort": gemPort, "err": err})
+		return
+	}
+	pktInkey := rsrcMgr.PacketInInfoKey{IntfID: intfID, OnuID: onuID, LogicalPort: logicalPort, VlanID: cTag, Priority: priority}
+
+	f.onuGemInfoLock.Lock()
+	defer f.onuGemInfoLock.Unlock()
+
+	lookupGemPort, ok := f.packetInGemPort[pktInkey]
+	if ok {
+		if lookupGemPort == gemPort {
+			logger.Infow(ctx, "pktin-key/value-found-in-cache--no-need-to-update-kv--assume-both-in-sync",
+				log.Fields{
+					"pktinkey": pktInkey,
+					"gem":      gemPort})
+			return
+		}
+	}
+	f.packetInGemPort[pktInkey] = gemPort
+
+	f.resourceMgr.UpdateGemPortForPktIn(ctx, pktInkey, gemPort)
+	logger.Infow(ctx, "pktin-key-not-found-in-local-cache-value-is-different--updating-cache-and-kv-store",
+		log.Fields{
+			"pktinkey": pktInkey,
+			"gem":      gemPort})
+}
+
+//getCTagFromPacket retrieves and returns c-tag and priority value from a packet.
+func getCTagFromPacket(ctx context.Context, packet []byte) (uint16, uint8, error) {
+	if packet == nil || len(packet) < 18 {
+		logger.Error(ctx, "unable-get-c-tag-from-the-packet--invalid-packet-length ")
+		return 0, 0, errors.New("invalid packet length")
+	}
+	outerEthType := (uint16(packet[12]) << 8) | uint16(packet[13])
+	innerEthType := (uint16(packet[16]) << 8) | uint16(packet[17])
+
+	var index int8
+	if outerEthType == 0x8100 {
+		if innerEthType == 0x8100 {
+			// q-in-q 802.1ad or 802.1q double tagged packet.
+			// get the inner vlanId
+			index = 18
+		} else {
+			index = 14
+		}
+		priority := (packet[index] >> 5) & 0x7
+		//13 bits composes vlanId value
+		vlan := ((uint16(packet[index]) << 8) & 0x0fff) | uint16(packet[index+1])
+		return vlan, priority, nil
+	}
+	logger.Debugf(ctx, "No vlanId found in the packet. Returning zero as c-tag")
+	return 0, 0, nil
+}
+
+// AddUniPortToOnuInfo adds uni port to the onugem info both in cache and kvstore.
+func (f *OpenOltFlowMgr) AddUniPortToOnuInfo(ctx context.Context, intfID uint32, onuID uint32, portNum uint32) {
+
+	f.onuGemInfoLock.Lock()
+	defer f.onuGemInfoLock.Unlock()
+
+	onugem := f.onuGemInfo[intfID]
+	for idx, onu := range onugem {
+		if onu.OnuID == onuID {
+			for _, uni := range onu.UniPorts {
+				if uni == portNum {
+					logger.Infow(ctx, "uni-already-in-cache--no-need-to-update-cache-and-kv-store", log.Fields{"uni": portNum})
+					return
+				}
+			}
+			onugem[idx].UniPorts = append(onugem[idx].UniPorts, portNum)
+			f.onuGemInfo[intfID] = onugem
+		}
+	}
+	f.resourceMgr.AddUniPortToOnuInfo(ctx, intfID, onuID, portNum)
+
+}
+
+func (f *OpenOltFlowMgr) loadFlowIDlistForGem(ctx context.Context, intf uint32) {
+	flowIDsList, err := f.resourceMgr.GetFlowIDsGemMapForInterface(ctx, intf)
+	if err != nil {
+		logger.Error(ctx, "failed-to-get-flowid-list-per-gem", log.Fields{"intf": intf})
+		return
+	}
+	for gem, FlowIDs := range flowIDsList {
+		gemPK := gemPortKey{intf, uint32(gem)}
+		if f.perGemPortLock.TryLock(gemPK) {
+			f.flowsUsedByGemPort[gemPK] = FlowIDs
+			f.perGemPortLock.Unlock(gemPK)
+		} else {
+			logger.Error(ctx, "failed-to-acquire-per-gem-port-lock",
+				log.Fields{
+					"intf-id":   intf,
+					"device-id": f.deviceHandler.device.Id,
+					"key":       gemPK,
+				})
+		}
+	}
+}
+
+//loadInterfaceToMulticastQueueMap reads multicast queues per interface from the KV store
+//and put them into interfaceToMcastQueueMap.
+func (f *OpenOltFlowMgr) loadInterfaceToMulticastQueueMap(ctx context.Context) {
+	storedMulticastQueueMap, err := f.resourceMgr.GetMcastQueuePerInterfaceMap(ctx)
+	if err != nil {
+		logger.Error(ctx, "failed-to-get-pon-interface-to-multicast-queue-map")
+		return
+	}
+	for intf, queueInfo := range storedMulticastQueueMap {
+		q := queueInfoBrief{
+			gemPortID:       queueInfo[0],
+			servicePriority: queueInfo[1],
+		}
+		f.interfaceToMcastQueueMap[intf] = &q
+	}
+}
+
+//GetFlowGroupFromKVStore fetches and returns flow group from the KV store. Returns (nil, false, error) if any problem occurs during
+//fetching the data. Returns (group, true, nil) if the group is fetched and returned successfully.
+//Returns (nil, false, nil) if the group does not exists in the KV store.
+func (f *OpenOltFlowMgr) GetFlowGroupFromKVStore(ctx context.Context, groupID uint32, cached bool) (*ofp.OfpGroupEntry, bool, error) {
+	exists, groupInfo, err := f.resourceMgr.GetFlowGroupFromKVStore(ctx, groupID, cached)
+	if err != nil {
+		return nil, false, olterrors.NewErrNotFound("flow-group", log.Fields{"group-id": groupID}, err)
+	}
+	if exists {
+		return newGroup(groupInfo.GroupID, groupInfo.OutPorts), exists, nil
+	}
+	return nil, exists, nil
+}
+
+func newGroup(groupID uint32, outPorts []uint32) *ofp.OfpGroupEntry {
+	groupDesc := ofp.OfpGroupDesc{
+		Type:    ofp.OfpGroupType_OFPGT_ALL,
+		GroupId: groupID,
+	}
+	groupEntry := ofp.OfpGroupEntry{
+		Desc: &groupDesc,
+	}
+	for i := 0; i < len(outPorts); i++ {
+		var acts []*ofp.OfpAction
+		acts = append(acts, flows.Output(outPorts[i]))
+		bucket := ofp.OfpBucket{
+			Actions: acts,
+		}
+		groupDesc.Buckets = append(groupDesc.Buckets, &bucket)
+	}
+	return &groupEntry
+}
+
+// L2oamCreateSchedulerQueues creates scheduler queues
+func (f *OpenOltFlowMgr) L2oamCreateSchedulerQueues(ctx context.Context, sq schedQueue) error {
+	if !autoAddFlow {
+		return nil
+	}
+
+	var meterConfig *ofp.OfpMeterConfig
+	if sq.flowMetadata != nil {
+		for _, meter := range sq.flowMetadata.Meters {
+			if sq.meterID == meter.MeterId {
+				meterConfig = meter
+				logger.Debugw(ctx, "found-meter-config-from-flowmetadata",
+					log.Fields{"meterConfig": meterConfig,
+						"device-id": f.deviceHandler.device.Id})
+				break
+			}
+		}
+	} else {
+		logger.Errorw(ctx, "flow-metadata-not-present-in-flow", log.Fields{"device-id": f.deviceHandler.device.Id})
+	}
+	if meterConfig == nil {
+		return olterrors.NewErrNotFound("meterbands", log.Fields{
+			"reason":        "Could-not-get-meterbands-from-flowMetadata",
+			"flow-metadata": sq.flowMetadata,
+			"meter-id":      sq.meterID,
+			"device-id":     f.deviceHandler.device.Id}, nil)
+	} else if len(meterConfig.Bands) < MaxMeterBand {
+		logger.Errorw(ctx, "invalid-number-of-bands-in-meter",
+			log.Fields{"Bands": meterConfig.Bands,
+				"meter-id":  sq.meterID,
+				"device-id": f.deviceHandler.device.Id})
+		return olterrors.NewErrInvalidValue(log.Fields{
+			"reason":          "Invalid-number-of-bands-in-meter",
+			"meterband-count": len(meterConfig.Bands),
+			"metabands":       meterConfig.Bands,
+			"meter-id":        sq.meterID,
+			"device-id":       f.deviceHandler.device.Id}, nil)
+	}
+	cir := meterConfig.Bands[0].Rate
+	eir := meterConfig.Bands[1].Rate
+	pir := cir + eir
+	onuKey := f.deviceHandler.formOnuKey(sq.intfID, sq.onuID)
+	onuDev, ok := f.deviceHandler.onus.Load(onuKey)
+	if !ok {
+		logger.Errorw(ctx, "not-found-onu-device",
+			log.Fields{"intf-id": sq.intfID,
+				"onu-id": sq.onuID})
+	} else {
+		onuDeviceID := (onuDev.(*OnuDevice)).deviceID
+		if _, exists := mapCreateScheduler[onuDeviceID]; exists {
+			logger.Debugw(ctx, "scheduler-exists",
+				log.Fields{"onu-device-id": onuDeviceID})
+			return nil
+		}
+		mapCreateScheduler[onuDeviceID] = true
+		l2oamCmd := &L2oamCmd{
+			Type:        "add-flow",
+			Cir:         []byte{0x00, 0x00, 0x00, 0x00},
+			Pir:         []byte{0x00, 0x00, 0x00, 0x00},
+			OnuDeviceID: onuDeviceID,
+		}
+		binary.BigEndian.PutUint32(l2oamCmd.Cir[0:4], cir)
+		binary.BigEndian.PutUint32(l2oamCmd.Pir[0:4], pir)
+		L2oamAddFlow(ctx, f.deviceHandler, l2oamCmd)
+
+		f.deviceHandler.L2oamAddFlowAndMount(ctx, onuDeviceID, []byte{0x0f, 0xfb}, []byte{0x00, 0x64})
+	}
+
+	return nil
+}
+
+// l2oamAddEapolToDevice adds EAPOL flow to device
+/*
+func (f *OpenOltFlowMgr) l2oamAddEapolToDevice(ctx context.Context, intfID uint32, onuID uint32) error {
+	if !autoAddFlow {
+		return nil
+	}
+
+	onuKey := f.deviceHandler.formOnuKey(intfID, onuID)
+	onuDev, ok := f.deviceHandler.onus.Load(onuKey)
+	if !ok {
+		logger.Errorw(ctx, "not-found-onu-device",
+			log.Fields{"intf-id": intfID,
+				"onu-id": onuID})
+	} else {
+		f.deviceHandler.L2oamAddFlowAndMount(ctx, (onuDev.(*OnuDevice)).deviceID, []byte{0x0f, 0xfb}, []byte{0x00, 0x64})
+	}
+
+	return nil
+}
+*/
+
+func (f *OpenOltFlowMgr) l2oamAddFlowDevice(ctx context.Context, intfID uint32, onuID uint32, ovid uint32, ivid uint32) {
+	logger.Debugw(ctx, "add-flow-to-device",
+		log.Fields{"onu-id": onuID, "o-vid": ovid, "i-vid": ivid})
+
+	if !autoAddFlow {
+		return
+	}
+
+	onuKey := f.deviceHandler.formOnuKey(intfID, onuID)
+	onuDev, ok := f.deviceHandler.onus.Load(onuKey)
+	if !ok {
+		logger.Errorw(ctx, "not-found-onu-device",
+			log.Fields{"intf-id": intfID,
+				"onu-id": onuID})
+	} else {
+		onuDeviceID := (onuDev.(*OnuDevice)).deviceID
+		if _, exists := mapAddFlow[onuDeviceID]; exists {
+			logger.Debugw(ctx, "flow is added already",
+				log.Fields{"onu-device-id": onuDeviceID})
+			return
+		}
+		mapAddFlow[onuDeviceID] = true
+		ovidBytes := []byte{0x00, 0x00}
+		binary.BigEndian.PutUint16(ovidBytes[:], uint16(ovid))
+		ividBytes := []byte{0x00, 0x00}
+		binary.BigEndian.PutUint16(ividBytes[:], uint16(ivid))
+		f.deviceHandler.L2oamAddFlowAndMount(ctx, onuDeviceID, ovidBytes, ividBytes)
+	}
+}
diff --git a/internal/pkg/core/openolt_flowmgr_test.go b/internal/pkg/core/openolt_flowmgr_test.go
new file mode 100644
index 0000000..4b70e41
--- /dev/null
+++ b/internal/pkg/core/openolt_flowmgr_test.go
@@ -0,0 +1,1116 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/db"
+	fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	tp "github.com/opencord/voltha-lib-go/v3/pkg/techprofile"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
+	rsrcMgr "github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
+	"github.com/opencord/voltha-openolt-adapter/pkg/mocks"
+	ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	"github.com/opencord/voltha-protos/v3/go/openolt"
+	openoltpb2 "github.com/opencord/voltha-protos/v3/go/openolt"
+	tp_pb "github.com/opencord/voltha-protos/v3/go/tech_profile"
+)
+
+var flowMgr *OpenOltFlowMgr
+
+func init() {
+	_, _ = log.SetDefaultLogger(log.JSON, log.DebugLevel, nil)
+	flowMgr = newMockFlowmgr()
+}
+func newMockResourceMgr() *resourcemanager.OpenOltResourceMgr {
+	ranges := []*openolt.DeviceInfo_DeviceResourceRanges{
+		{
+			IntfIds:    []uint32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+			Technology: "Default",
+		},
+	}
+
+	deviceinfo := &openolt.DeviceInfo{Vendor: "openolt", Model: "openolt", HardwareVersion: "1.0", FirmwareVersion: "1.0",
+		DeviceId: "olt", DeviceSerialNumber: "openolt", PonPorts: 16, Technology: "Default",
+		OnuIdStart: 1, OnuIdEnd: 1, AllocIdStart: 1, AllocIdEnd: 1,
+		GemportIdStart: 1, GemportIdEnd: 1, FlowIdStart: 1, FlowIdEnd: 1,
+		Ranges: ranges,
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	rsrMgr := resourcemanager.NewResourceMgr(ctx, "olt", "127.0.0.1:2379", "etcd", "olt", deviceinfo)
+	for key := range rsrMgr.ResourceMgrs {
+		rsrMgr.ResourceMgrs[key].KVStore = &db.Backend{}
+		rsrMgr.ResourceMgrs[key].KVStore.Client = &mocks.MockKVClient{}
+		rsrMgr.ResourceMgrs[key].TechProfileMgr = mocks.MockTechProfile{TpID: key}
+	}
+	return rsrMgr
+}
+
+func newMockFlowmgr() *OpenOltFlowMgr {
+	rMgr := newMockResourceMgr()
+	dh := newMockDeviceHandler()
+
+	rMgr.KVStore = &db.Backend{}
+	rMgr.KVStore.Client = &mocks.MockKVClient{}
+
+	dh.resourceMgr = rMgr
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	flwMgr := NewFlowManager(ctx, dh, rMgr)
+
+	onuGemInfo1 := make([]rsrcMgr.OnuGemInfo, 2)
+	onuGemInfo2 := make([]rsrcMgr.OnuGemInfo, 2)
+	onuGemInfo1[0] = rsrcMgr.OnuGemInfo{OnuID: 1, SerialNumber: "1", IntfID: 1, GemPorts: []uint32{1}}
+	onuGemInfo2[1] = rsrcMgr.OnuGemInfo{OnuID: 2, SerialNumber: "2", IntfID: 2, GemPorts: []uint32{2}}
+	flwMgr.onuGemInfo[1] = onuGemInfo1
+	flwMgr.onuGemInfo[2] = onuGemInfo2
+
+	packetInGemPort := make(map[rsrcMgr.PacketInInfoKey]uint32)
+	packetInGemPort[rsrcMgr.PacketInInfoKey{IntfID: 1, OnuID: 1, LogicalPort: 1}] = 1
+	packetInGemPort[rsrcMgr.PacketInInfoKey{IntfID: 2, OnuID: 2, LogicalPort: 2}] = 2
+
+	flwMgr.packetInGemPort = packetInGemPort
+	tps := make(map[uint32]tp.TechProfileIf)
+	for key := range rMgr.ResourceMgrs {
+		tps[key] = mocks.MockTechProfile{TpID: key}
+	}
+	flwMgr.techprofile = tps
+
+	interface2mcastQeueuMap := make(map[uint32]*queueInfoBrief)
+	interface2mcastQeueuMap[0] = &queueInfoBrief{
+		gemPortID:       4000,
+		servicePriority: 3,
+	}
+	flwMgr.interfaceToMcastQueueMap = interface2mcastQeueuMap
+	return flwMgr
+}
+
+func TestOpenOltFlowMgr_CreateSchedulerQueues(t *testing.T) {
+
+	tprofile := &tp.TechProfile{Name: "tp1", SubscriberIdentifier: "subscriber1",
+		ProfileType: "pt1", NumGemPorts: 1, Version: 1,
+		InstanceCtrl: tp.InstanceControl{Onu: "1", Uni: "1", MaxGemPayloadSize: "1"},
+	}
+	tprofile.UsScheduler.Direction = "UPSTREAM"
+	tprofile.UsScheduler.AdditionalBw = "AdditionalBW_None"
+	tprofile.UsScheduler.QSchedPolicy = "WRR"
+
+	tprofile2 := tprofile
+	tprofile2.DsScheduler.Direction = "DOWNSTREAM"
+	tprofile2.DsScheduler.AdditionalBw = "AdditionalBW_None"
+	tprofile2.DsScheduler.QSchedPolicy = "WRR"
+	bands := make([]*ofp.OfpMeterBandHeader, 2)
+	bands[0] = &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 1000, BurstSize: 5000, Data: &ofp.OfpMeterBandHeader_Drop{}}
+	bands[1] = &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 2000, BurstSize: 5000, Data: &ofp.OfpMeterBandHeader_Drop{}}
+	ofpMeterConfig := &ofp.OfpMeterConfig{Flags: 1, MeterId: 1, Bands: bands}
+	flowmetadata := &voltha.FlowMetadata{
+		Meters: []*ofp.OfpMeterConfig{ofpMeterConfig},
+	}
+	tests := []struct {
+		name       string
+		schedQueue schedQueue
+		wantErr    bool
+	}{
+		// TODO: Add test cases.
+		{"CreateSchedulerQueues-1", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 1, flowmetadata}, false},
+		{"CreateSchedulerQueues-2", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 1, flowmetadata}, false},
+		{"CreateSchedulerQueues-3", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 2, flowmetadata}, true},
+		{"CreateSchedulerQueues-4", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 2, flowmetadata}, true},
+		{"CreateSchedulerQueues-5", schedQueue{tp_pb.Direction_UPSTREAM, 2, 2, 2, 64, 2, tprofile, 2, flowmetadata}, true},
+		{"CreateSchedulerQueues-6", schedQueue{tp_pb.Direction_DOWNSTREAM, 2, 2, 2, 65, 2, tprofile2, 2, flowmetadata}, true},
+		{"CreateSchedulerQueues-13", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 1, flowmetadata}, false},
+		//Negative testcases
+		{"CreateSchedulerQueues-7", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 1, &voltha.FlowMetadata{}}, true},
+		{"CreateSchedulerQueues-8", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 0, &voltha.FlowMetadata{}}, true},
+		{"CreateSchedulerQueues-9", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 1, &voltha.FlowMetadata{}}, true},
+		{"CreateSchedulerQueues-10", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 2, &voltha.FlowMetadata{}}, true},
+		{"CreateSchedulerQueues-11", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 2, &voltha.FlowMetadata{}}, true},
+		{"CreateSchedulerQueues-12", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 2, nil}, true},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := flowMgr.CreateSchedulerQueues(ctx, tt.schedQueue); (err != nil) != tt.wantErr {
+				t.Errorf("OpenOltFlowMgr.CreateSchedulerQueues() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_RemoveSchedulerQueues(t *testing.T) {
+
+	tprofile := &tp.TechProfile{Name: "tp1", SubscriberIdentifier: "subscriber1",
+		ProfileType: "pt1", NumGemPorts: 1, Version: 1,
+		InstanceCtrl: tp.InstanceControl{Onu: "1", Uni: "1", MaxGemPayloadSize: "1"},
+	}
+	tprofile.UsScheduler.Direction = "UPSTREAM"
+	tprofile.UsScheduler.AdditionalBw = "AdditionalBW_None"
+	tprofile.UsScheduler.QSchedPolicy = "WRR"
+
+	tprofile2 := tprofile
+	tprofile2.DsScheduler.Direction = "DOWNSTREAM"
+	tprofile2.DsScheduler.AdditionalBw = "AdditionalBW_None"
+	tprofile2.DsScheduler.QSchedPolicy = "WRR"
+	tests := []struct {
+		name       string
+		schedQueue schedQueue
+		wantErr    bool
+	}{
+		// TODO: Add test cases.
+		{"RemoveSchedulerQueues", schedQueue{tp_pb.Direction_UPSTREAM, 1, 1, 1, 64, 1, tprofile, 0, nil}, false},
+		{"RemoveSchedulerQueues", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 0, nil}, false},
+		// negative test cases
+		{"RemoveSchedulerQueues", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 0, nil}, false},
+		{"RemoveSchedulerQueues", schedQueue{tp_pb.Direction_DOWNSTREAM, 1, 1, 1, 65, 1, tprofile2, 0, nil}, false},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := flowMgr.RemoveSchedulerQueues(ctx, tt.schedQueue); (err != nil) != tt.wantErr {
+				t.Errorf("OpenOltFlowMgr.RemoveSchedulerQueues() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+
+}
+
+func TestOpenOltFlowMgr_createTcontGemports(t *testing.T) {
+	bands := make([]*ofp.OfpMeterBandHeader, 2)
+	bands[0] = &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 1000, BurstSize: 5000, Data: &ofp.OfpMeterBandHeader_Drop{}}
+	bands[1] = &ofp.OfpMeterBandHeader{Type: ofp.OfpMeterBandType_OFPMBT_DROP, Rate: 2000, BurstSize: 5000, Data: &ofp.OfpMeterBandHeader_Drop{}}
+	ofpMeterConfig := &ofp.OfpMeterConfig{Flags: 1, MeterId: 1, Bands: bands}
+	flowmetadata := &voltha.FlowMetadata{
+		Meters: []*ofp.OfpMeterConfig{ofpMeterConfig},
+	}
+	type args struct {
+		intfID       uint32
+		onuID        uint32
+		uniID        uint32
+		uni          string
+		uniPort      uint32
+		TpID         uint32
+		UsMeterID    uint32
+		DsMeterID    uint32
+		flowMetadata *voltha.FlowMetadata
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{"createTcontGemports-1", args{intfID: 0, onuID: 1, uniID: 1, uni: "16", uniPort: 1, TpID: 64, UsMeterID: 1, DsMeterID: 1, flowMetadata: flowmetadata}},
+		{"createTcontGemports-1", args{intfID: 0, onuID: 1, uniID: 1, uni: "16", uniPort: 1, TpID: 65, UsMeterID: 1, DsMeterID: 1, flowMetadata: flowmetadata}},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, _, tpInst := flowMgr.createTcontGemports(ctx, tt.args.intfID, tt.args.onuID, tt.args.uniID, tt.args.uni, tt.args.uniPort, tt.args.TpID, tt.args.UsMeterID, tt.args.DsMeterID, tt.args.flowMetadata)
+			switch tpInst := tpInst.(type) {
+			case *tp.TechProfile:
+				if tt.args.TpID != 64 {
+					t.Errorf("OpenOltFlowMgr.createTcontGemports() error = different tech, tech %v", tpInst)
+				}
+			case *tp.EponProfile:
+				if tt.args.TpID != 65 {
+					t.Errorf("OpenOltFlowMgr.createTcontGemports() error = different tech, tech %v", tpInst)
+				}
+			default:
+				t.Errorf("OpenOltFlowMgr.createTcontGemports() error = different tech, tech %v", tpInst)
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_RemoveFlow(t *testing.T) {
+	ctx := context.Background()
+	logger.Debug(ctx, "Info Warning Error: Starting RemoveFlow() test")
+	fa := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(2),
+			fu.Metadata_ofp(2),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+			fu.Output(1),
+		},
+	}
+	ofpstats, _ := fu.MkFlowStat(fa)
+	ofpstats.Cookie = ofpstats.Id
+	lldpFa := &fu.FlowArgs{
+		KV: fu.OfpFlowModArgs{"priority": 1000, "cookie": 48132224281636694},
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1),
+			fu.EthType(0x88CC),
+			fu.TunnelId(536870912),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+		},
+	}
+	lldpofpstats, _ := fu.MkFlowStat(lldpFa)
+
+	dhcpFa := &fu.FlowArgs{
+		KV: fu.OfpFlowModArgs{"priority": 1000, "cookie": 48132224281636694},
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1),
+			fu.UdpSrc(67),
+			//fu.TunnelId(536870912),
+			fu.IpProto(17),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+		},
+	}
+	dhcpofpstats, _ := fu.MkFlowStat(dhcpFa)
+
+	multicastFa := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(65536),
+			fu.VlanVid(660),             //vlan
+			fu.Metadata_ofp(uint64(66)), //inner vlan
+			fu.EthType(0x800),           //ipv4
+			fu.Ipv4Dst(3809869825),      //227.22.0.1
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Group(1),
+		},
+	}
+	multicastOfpStats, _ := fu.MkFlowStat(multicastFa)
+	multicastOfpStats.Id = 1
+
+	type args struct {
+		flow *ofp.OfpFlowStats
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"RemoveFlow", args{flow: ofpstats}},
+		{"RemoveFlow", args{flow: lldpofpstats}},
+		{"RemoveFlow", args{flow: dhcpofpstats}},
+		{"RemoveFlow", args{flow: multicastOfpStats}},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := flowMgr.RemoveFlow(ctx, tt.args.flow); err != nil {
+				logger.Warn(ctx, err)
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_AddFlow(t *testing.T) {
+	kw := make(map[string]uint64)
+	kw["table_id"] = 1
+	kw["meter_id"] = 1
+	kw["write_metadata"] = 0x4000000000 // Tech-Profile-ID 64
+
+	fa := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65536),
+			fu.PushVlan(0x8100),
+		},
+		KV: kw,
+	}
+
+	fa3 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(65536),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			//fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+			fu.PopVlan(),
+			fu.Output(536870912),
+		},
+		KV: kw,
+	}
+
+	fa2 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1000),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+			fu.Output(65533),
+		},
+		KV: kw,
+	}
+
+
+	fa4 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1000),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Experimenter(257, []byte{1, 2, 3, 4}),
+		},
+		KV: kw,
+	}
+
+	fa5 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1000),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(0),
+		},
+		KV: kw,
+	}
+
+	kw6 := make(map[string]uint64)
+	kw6["table_id"] = 1
+	kw6["meter_id"] = 1
+	kw6["write_metadata"] = 0x4100000000 // TpID Other than the stored one
+	fa6 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.TunnelId(16),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65535),
+		},
+		KV: kw6,
+	}
+
+	lldpFa := &fu.FlowArgs{
+		KV: fu.OfpFlowModArgs{"priority": 1000, "cookie": 48132224281636694},
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1),
+			fu.EthType(0x88CC),
+			fu.TunnelId(536870912),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+		},
+	}
+
+	dhcpFa := &fu.FlowArgs{
+		KV: fu.OfpFlowModArgs{"priority": 1000, "cookie": 48132224281636694},
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1),
+			fu.UdpSrc(67),
+			//fu.TunnelId(536870912),
+			fu.IpProto(17),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+		},
+	}
+	igmpFa := &fu.FlowArgs{
+		KV: fu.OfpFlowModArgs{"priority": 1000, "cookie": 48132224281636694},
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1),
+			fu.UdpSrc(67),
+			//fu.TunnelId(536870912),
+			fu.IpProto(2),
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+		},
+	}
+
+	fa9 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.TunnelId(16),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+			fu.VlanPcp(1000),
+			fu.UdpDst(65535),
+			fu.UdpSrc(536870912),
+			fu.Ipv4Dst(65535),
+			fu.Ipv4Src(536870912),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65535),
+		},
+		KV: kw6,
+	}
+
+	fa10 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(65533),
+			//	fu.TunnelId(16),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+			fu.VlanPcp(1000),
+			fu.UdpDst(65535),
+			fu.UdpSrc(536870912),
+			fu.Ipv4Dst(65535),
+			fu.Ipv4Src(536870912),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65535),
+		},
+		KV: kw6,
+	}
+	fa11 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(65536),
+			fu.VlanVid(660),             //vlan
+			fu.Metadata_ofp(uint64(66)), //inner vlan
+			fu.EthType(0x800),           //ipv4
+			fu.Ipv4Dst(3809869825),      //227.22.0.1
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Group(1),
+		},
+		KV: kw6,
+	}
+	ofpstats, _ := fu.MkFlowStat(fa)
+	ofpstats2, _ := fu.MkFlowStat(fa2)
+	ofpstats3, _ := fu.MkFlowStat(fa3)
+	ofpstats4, _ := fu.MkFlowStat(fa4)
+	ofpstats5, _ := fu.MkFlowStat(fa5)
+	ofpstats6, _ := fu.MkFlowStat(fa6)
+	ofpstats7, _ := fu.MkFlowStat(lldpFa)
+	ofpstats8, _ := fu.MkFlowStat(dhcpFa)
+	ofpstats9, _ := fu.MkFlowStat(fa9)
+	ofpstats10, _ := fu.MkFlowStat(fa10)
+	igmpstats, _ := fu.MkFlowStat(igmpFa)
+	ofpstats11, _ := fu.MkFlowStat(fa11)
+
+	fmt.Println(ofpstats6, ofpstats9, ofpstats10)
+
+	ofpMeterConfig := &ofp.OfpMeterConfig{Flags: 1, MeterId: 1}
+	flowMetadata := &voltha.FlowMetadata{
+		Meters: []*ofp.OfpMeterConfig{ofpMeterConfig},
+	}
+	type args struct {
+		flow         *ofp.OfpFlowStats
+		flowMetadata *voltha.FlowMetadata
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"AddFlow", args{flow: ofpstats, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats2, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats3, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats4, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats5, flowMetadata: flowMetadata}},
+		//{"AddFlow", args{flow: ofpstats6, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats7, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: ofpstats8, flowMetadata: flowMetadata}},
+		//{"AddFlow", args{flow: ofpstats9, flowMetadata: flowMetadata}},
+		{"AddFlow", args{flow: igmpstats, flowMetadata: flowMetadata}},
+		//{"AddFlow", args{flow: ofpstats10, flowMetadata: flowMetadata}},
+		//ofpstats10
+		{"AddFlow", args{flow: ofpstats11, flowMetadata: flowMetadata}},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_ = flowMgr.AddFlow(ctx, tt.args.flow, tt.args.flowMetadata)
+			// TODO: actually verify test cases
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_UpdateOnuInfo(t *testing.T) {
+	flwMgr := newMockFlowmgr()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	wg := sync.WaitGroup{}
+
+	intfCount := 16
+	onuCount := 32
+
+	for i := 0; i < intfCount; i++ {
+		for j := 0; j < onuCount; j++ {
+			wg.Add(1)
+			go func(i uint32, j uint32) {
+				// TODO: actually verify success
+				_ = flwMgr.UpdateOnuInfo(ctx, i, i, fmt.Sprintf("onu-%d", i))
+				wg.Done()
+			}(uint32(i), uint32(j))
+		}
+
+	}
+
+	wg.Wait()
+}
+
+func TestOpenOltFlowMgr_addGemPortToOnuInfoMap(t *testing.T) {
+	flowMgr = newMockFlowmgr()
+	intfNum := 16
+	onuNum := 32
+
+	flowMgr.onuGemInfo = make(map[uint32][]rsrcMgr.OnuGemInfo, intfNum)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	for i := 0; i < intfNum; i++ {
+		for o := 0; o < onuNum; o++ {
+			// TODO: actually verify success
+			_ = flowMgr.UpdateOnuInfo(ctx, uint32(i), uint32(o), fmt.Sprintf("i%do%d", i, o))
+		}
+	}
+
+	wg := sync.WaitGroup{}
+
+	for o := 0; o < onuNum; o++ {
+		for i := 0; i < intfNum; i++ {
+			wg.Add(1)
+			go func(intfId uint32, onuId uint32) {
+				gemID, _ := strconv.Atoi(fmt.Sprintf("90%d%d", intfId, onuId))
+
+				flowMgr.addGemPortToOnuInfoMap(ctx, intfId, onuId, uint32(gemID))
+				wg.Done()
+			}(uint32(i), uint32(o))
+		}
+	}
+
+	wg.Wait()
+
+	for i := 0; i < intfNum; i++ {
+		lenofOnu := len(flowMgr.onuGemInfo[uint32(i)])
+		if onuNum != lenofOnu {
+			t.Errorf("OnuGemInfo length is not as expected len = %d, want %d", lenofOnu, onuNum)
+		}
+
+		for o := 0; o < onuNum; o++ {
+			lenOfGemPorts := len(flowMgr.onuGemInfo[uint32(i)][o].GemPorts)
+			// check that each onuEntry has 1 gemPort
+			if lenOfGemPorts != 1 {
+				t.Errorf("Expected 1 GemPort per ONU, found %d", lenOfGemPorts)
+			}
+
+			// check that the value of the gemport is correct
+			gemID, _ := strconv.Atoi(fmt.Sprintf("90%d%d", i, o))
+			currentValue := flowMgr.onuGemInfo[uint32(i)][o].GemPorts[0]
+			if uint32(gemID) != currentValue {
+				t.Errorf("Expected GemPort value to be %d, found %d", gemID, currentValue)
+			}
+		}
+	}
+}
+
+func TestOpenOltFlowMgr_deleteGemPortFromLocalCache(t *testing.T) {
+	flwMgr := newMockFlowmgr()
+	type args struct {
+		intfID                uint32
+		onuID                 uint32
+		gemPortIDs            []uint32
+		gemPortIDsToBeDeleted []uint32
+		gemPortIDsRemaining   []uint32
+		serialNum             string
+		finalLength           int
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// Add/Delete single gem port
+		{"DeleteGemPortFromLocalCache1", args{0, 1, []uint32{1}, []uint32{1}, []uint32{}, "onu1", 0}},
+		// Delete all gemports
+		{"DeleteGemPortFromLocalCache2", args{0, 1, []uint32{1, 2, 3, 4}, []uint32{1, 2, 3, 4}, []uint32{}, "onu1", 0}},
+		// Try to delete when there is no gem port
+		{"DeleteGemPortFromLocalCache3", args{0, 1, []uint32{}, []uint32{1, 2}, []uint32{}, "onu1", 0}},
+		// Try to delete non-existent gem port
+		{"DeleteGemPortFromLocalCache4", args{0, 1, []uint32{1}, []uint32{2}, []uint32{1}, "onu1", 1}},
+		// Try to delete two of the gem ports
+		{"DeleteGemPortFromLocalCache5", args{0, 1, []uint32{1, 2, 3, 4}, []uint32{2, 4}, []uint32{1, 3}, "onu1", 2}},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// TODO: should check returned errors are as expected?
+			_ = flwMgr.UpdateOnuInfo(ctx, tt.args.intfID, tt.args.onuID, tt.args.serialNum)
+			for _, gemPort := range tt.args.gemPortIDs {
+				flwMgr.addGemPortToOnuInfoMap(ctx, tt.args.intfID, tt.args.onuID, gemPort)
+			}
+			for _, gemPortDeleted := range tt.args.gemPortIDsToBeDeleted {
+				flwMgr.deleteGemPortFromLocalCache(ctx, tt.args.intfID, tt.args.onuID, gemPortDeleted)
+			}
+			lenofGemPorts := len(flwMgr.onuGemInfo[tt.args.intfID][0].GemPorts)
+			if lenofGemPorts != tt.args.finalLength {
+				t.Errorf("GemPorts length is not as expected len = %d, want %d", lenofGemPorts, tt.args.finalLength)
+			}
+			gemPorts := flwMgr.onuGemInfo[tt.args.intfID][0].GemPorts
+			if !reflect.DeepEqual(tt.args.gemPortIDsRemaining, gemPorts) {
+				t.Errorf("GemPorts are not as expected = %v, want %v", gemPorts, tt.args.gemPortIDsRemaining)
+			}
+
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_GetLogicalPortFromPacketIn(t *testing.T) {
+	flwMgr := newMockFlowmgr()
+	type args struct {
+		packetIn *openoltpb2.PacketIndication
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint32
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"GetLogicalPortFromPacketIn", args{packetIn: &openoltpb2.PacketIndication{IntfType: "pon", IntfId: 1, GemportId: 1, FlowId: 100, PortNo: 1, Cookie: 100, Pkt: []byte("GetLogicalPortFromPacketIn")}}, 1, false},
+		{"GetLogicalPortFromPacketIn", args{packetIn: &openoltpb2.PacketIndication{IntfType: "nni", IntfId: 1, GemportId: 1, FlowId: 100, PortNo: 1, Cookie: 100, Pkt: []byte("GetLogicalPortFromPacketIn")}}, 1048577, false},
+		// Negative Test cases.
+		{"GetLogicalPortFromPacketIn", args{packetIn: &openoltpb2.PacketIndication{IntfType: "pon", IntfId: 2, GemportId: 1, FlowId: 100, PortNo: 1, Cookie: 100, Pkt: []byte("GetLogicalPortFromPacketIn")}}, 0, true},
+		{"GetLogicalPortFromPacketIn", args{packetIn: &openoltpb2.PacketIndication{IntfType: "pon", IntfId: 1, GemportId: 1, FlowId: 100, PortNo: 0, Cookie: 100, Pkt: []byte("GetLogicalPortFromPacketIn")}}, 4112, false},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			got, err := flwMgr.GetLogicalPortFromPacketIn(ctx, tt.args.packetIn)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("OpenOltFlowMgr.GetLogicalPortFromPacketIn() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("OpenOltFlowMgr.GetLogicalPortFromPacketIn() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_GetPacketOutGemPortID(t *testing.T) {
+
+	untaggedStr := "01005e000002000000000001080046c00020000040000102fa140a000001e00000029404000017000705e10000fa"
+	untagged, err := hex.DecodeString(untaggedStr)
+	if err != nil {
+		t.Error("Unable to parse hex string", err)
+		panic(err)
+	}
+	singleTaggedStr := "01005e0000010025ba48172481000225080046c0002000004000010257deab140023e0000001940400001164ee9b0000000000000000000000000000"
+	singleTagged, err := hex.DecodeString(singleTaggedStr)
+	if err != nil {
+		t.Error("Unable to parse hex string", err)
+		panic(err)
+	}
+	doubleTaggedStr := "01005e000016deadbeefba11810002108100e030080046000028000000000102c5b87f000001e0000016940400002200f8030000000104000000e10000fa"
+	doubleTagged, err := hex.DecodeString(doubleTaggedStr)
+	if err != nil {
+		t.Error("Unable to parse hex string", err)
+		panic(err)
+	}
+
+	type args struct {
+		intfID  uint32
+		onuID   uint32
+		portNum uint32
+		packet  []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint32
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"GetPacketOutGemPortID", args{intfID: 1, onuID: 1, portNum: 3, packet: untagged}, 3, false},
+		{"GetPacketOutGemPortID", args{intfID: 2, onuID: 2, portNum: 4, packet: singleTagged}, 4, false},
+		{"GetPacketOutGemPortID", args{intfID: 1, onuID: 2, portNum: 2, packet: doubleTagged}, 2, false},
+		{"GetPacketOutGemPortID", args{intfID: 1, onuID: 10, portNum: 10, packet: untagged}, 2, true},
+		{"GetPacketOutGemPortID", args{intfID: 1, onuID: 1, portNum: 3, packet: []byte{}}, 3, true},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			got, err := flowMgr.GetPacketOutGemPortID(ctx, tt.args.intfID, tt.args.onuID, tt.args.portNum, tt.args.packet)
+			if tt.wantErr {
+				if err == nil {
+					//error expected but got value
+					t.Errorf("OpenOltFlowMgr.GetPacketOutGemPortID() = %v, wantErr %v", got, tt.wantErr)
+				}
+			} else {
+				if err != nil {
+					//error is not expected but got error
+					t.Errorf("OpenOltFlowMgr.GetPacketOutGemPortID() error = %v, wantErr %v", err, tt.wantErr)
+					return
+				}
+				if got != tt.want {
+					t.Errorf("OpenOltFlowMgr.GetPacketOutGemPortID() = %v, want %v", got, tt.want)
+				}
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_DeleteTechProfileInstance(t *testing.T) {
+	type args struct {
+		intfID uint32
+		onuID  uint32
+		uniID  uint32
+		sn     string
+		tpID   uint32
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"DeleteTechProfileInstance", args{intfID: 0, onuID: 1, uniID: 1, sn: "", tpID: 64}, false},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := flowMgr.DeleteTechProfileInstance(ctx, tt.args.intfID, tt.args.onuID, tt.args.uniID, tt.args.sn, tt.args.tpID); (err != nil) != tt.wantErr {
+				t.Errorf("OpenOltFlowMgr.DeleteTechProfileInstance() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_checkAndAddFlow(t *testing.T) {
+	ctx := context.Background()
+	kw := make(map[string]uint64)
+	kw["table_id"] = 1
+	kw["meter_id"] = 1
+	kw["write_metadata"] = 0x4000000000 // Tech-Profile-ID 64
+
+	fa := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.Metadata_ofp(1),
+			fu.IpProto(17), // dhcp
+			fu.VlanPcp(0),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65536),
+			fu.PushVlan(0x8100),
+		},
+		KV: kw,
+	}
+
+	fa2 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.Metadata_ofp(1),
+			fu.EthType(0x888E),
+			fu.VlanPcp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 257)),
+			fu.Output(65536),
+			fu.PushVlan(0x8100),
+		},
+		KV: kw,
+	}
+
+	fa3 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(536870912),
+			fu.Metadata_ofp(1),
+			//fu.EthType(0x8100),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT))),
+			fu.Output(65536),
+			fu.PushVlan(0x8100),
+		},
+		KV: kw,
+	}
+
+	fa4 := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(65535),
+			fu.Metadata_ofp(1),
+			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT)),
+			fu.VlanPcp(1),
+		},
+		Actions: []*ofp.OfpAction{
+			//fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA | 2))),
+			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT))),
+			fu.Output(536870912),
+			fu.PopVlan(),
+		},
+		KV: kw,
+	}
+
+	classifierInfo := make(map[string]interface{})
+	actionInfo := make(map[string]interface{})
+	classifierInfo2 := make(map[string]interface{})
+	actionInfo2 := make(map[string]interface{})
+	classifierInfo3 := make(map[string]interface{})
+	actionInfo3 := make(map[string]interface{})
+	classifierInfo4 := make(map[string]interface{})
+	actionInfo4 := make(map[string]interface{})
+	flowState, _ := fu.MkFlowStat(fa)
+	flowState2, _ := fu.MkFlowStat(fa2)
+	flowState3, _ := fu.MkFlowStat(fa3)
+	flowState4, _ := fu.MkFlowStat(fa4)
+	formulateClassifierInfoFromFlow(ctx, classifierInfo, flowState)
+	formulateClassifierInfoFromFlow(ctx, classifierInfo2, flowState2)
+	formulateClassifierInfoFromFlow(ctx, classifierInfo3, flowState3)
+	formulateClassifierInfoFromFlow(ctx, classifierInfo4, flowState4)
+
+	err := formulateActionInfoFromFlow(ctx, actionInfo, classifierInfo, flowState)
+	if err != nil {
+		// Error logging is already done in the called function
+		// So just return in case of error
+		return
+	}
+
+	err = formulateActionInfoFromFlow(ctx, actionInfo2, classifierInfo2, flowState2)
+	if err != nil {
+		// Error logging is already done in the called function
+		// So just return in case of error
+		return
+	}
+
+	err = formulateActionInfoFromFlow(ctx, actionInfo3, classifierInfo3, flowState3)
+	if err != nil {
+		// Error logging is already done in the called function
+		// So just return in case of error
+		return
+	}
+
+	err = formulateActionInfoFromFlow(ctx, actionInfo4, classifierInfo4, flowState4)
+	if err != nil {
+		// Error logging is already done in the called function
+		// So just return in case of error
+		return
+	}
+
+
+	TpInst := &tp.TechProfile{
+		Name:                 "Test-Tech-Profile",
+		SubscriberIdentifier: "257",
+		ProfileType:          "Mock",
+		Version:              1,
+		NumGemPorts:          4,
+		InstanceCtrl: tp.InstanceControl{
+			Onu: "1",
+			Uni: "16",
+		},
+	}
+
+	type args struct {
+		args           map[string]uint32
+		classifierInfo map[string]interface{}
+		actionInfo     map[string]interface{}
+		flow           *ofp.OfpFlowStats
+		gemPort        uint32
+		intfID         uint32
+		onuID          uint32
+		uniID          uint32
+		portNo         uint32
+		TpInst         *tp.TechProfile
+		allocID        []uint32
+		gemPorts       []uint32
+		TpID           uint32
+		uni            string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "checkAndAddFlow-1",
+			args: args{
+				args:           nil,
+				classifierInfo: classifierInfo,
+				actionInfo:     actionInfo,
+				flow:           flowState,
+				gemPort:        1,
+				intfID:         1,
+				onuID:          1,
+				uniID:          16,
+				portNo:         1,
+				TpInst:         TpInst,
+				allocID:        []uint32{0x8001, 0x8002, 0x8003, 0x8004},
+				gemPorts:       []uint32{1, 2, 3, 4},
+				TpID:           64,
+				uni:            "16",
+			},
+		},
+		{
+			name: "checkAndAddFlow-2",
+			args: args{
+				args:           nil,
+				classifierInfo: classifierInfo2,
+				actionInfo:     actionInfo2,
+				flow:           flowState2,
+				gemPort:        1,
+				intfID:         1,
+				onuID:          1,
+				uniID:          16,
+				portNo:         1,
+				TpInst:         TpInst,
+				allocID:        []uint32{0x8001, 0x8002, 0x8003, 0x8004},
+				gemPorts:       []uint32{1, 2, 3, 4},
+				TpID:           64,
+				uni:            "16",
+			},
+		},
+		{
+			name: "checkAndAddFlow-3",
+			args: args{
+				args:           nil,
+				classifierInfo: classifierInfo3,
+				actionInfo:     actionInfo3,
+				flow:           flowState3,
+				gemPort:        1,
+				intfID:         1,
+				onuID:          1,
+				uniID:          16,
+				portNo:         1,
+				TpInst:         TpInst,
+				allocID:        []uint32{0x8001, 0x8002, 0x8003, 0x8004},
+				gemPorts:       []uint32{1, 2, 3, 4},
+				TpID:           64,
+				uni:            "16",
+			},
+		},
+		{
+			name: "checkAndAddFlow-4",
+			args: args{
+				args:           nil,
+				classifierInfo: classifierInfo4,
+				actionInfo:     actionInfo4,
+				flow:           flowState4,
+				gemPort:        1,
+				intfID:         1,
+				onuID:          1,
+				uniID:          16,
+				portNo:         1,
+				TpInst:         TpInst,
+				allocID:        []uint32{0x8001, 0x8002, 0x8003, 0x8004},
+				gemPorts:       []uint32{1, 2, 3, 4},
+				TpID:           64,
+				uni:            "16",
+			},
+		},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			flowMgr.checkAndAddFlow(ctx, tt.args.args, tt.args.classifierInfo, tt.args.actionInfo, tt.args.flow,
+				tt.args.TpInst, tt.args.gemPorts, tt.args.TpID, tt.args.uni)
+		})
+	}
+}
+
+func TestOpenOltFlowMgr_TestMulticastFlowAndGroup(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	group := newGroup(2, []uint32{1})
+	err := flowMgr.AddGroup(ctx, group)
+	if err != nil {
+		t.Error("group-add failed", err)
+		return
+	}
+	multicastFlowArgs := &fu.FlowArgs{
+		MatchFields: []*ofp.OfpOxmOfbField{
+			fu.InPort(1048576),
+			fu.VlanVid(660),             //vlan
+			fu.Metadata_ofp(uint64(66)), //inner vlan
+			fu.EthType(0x800),           //ipv4
+			fu.Ipv4Dst(3809869825),      //227.22.0.1
+		},
+		Actions: []*ofp.OfpAction{
+			fu.Group(1),
+		},
+	}
+	ofpStats, _ := fu.MkFlowStat(multicastFlowArgs)
+	fmt.Println(ofpStats.Id)
+	err = flowMgr.AddFlow(ctx, ofpStats, &voltha.FlowMetadata{})
+	if err != nil {
+		t.Error("Multicast flow-add failed", err)
+		return
+	}
+
+	group = newGroup(2, []uint32{1, 2})
+	err = flowMgr.ModifyGroup(ctx, group)
+	if err != nil {
+		t.Error("modify-group failed", err)
+		return
+	}
+	err = flowMgr.RemoveFlow(ctx, ofpStats)
+	if err != nil {
+		t.Error("Multicast flow-remove failed", err)
+		return
+	}
+
+	err = flowMgr.DeleteGroup(ctx, group)
+	if err != nil {
+		t.Error("delete-group failed", err)
+		return
+	}
+}
diff --git a/internal/pkg/core/openolt_test.go b/internal/pkg/core/openolt_test.go
new file mode 100644
index 0000000..08c2f52
--- /dev/null
+++ b/internal/pkg/core/openolt_test.go
@@ -0,0 +1,938 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+This file contains unit test cases for functions in the file openolt.go.
+This file also implements the fields struct to mock the Openolt and few utility functions.
+*/
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	com "github.com/opencord/voltha-lib-go/v3/pkg/adapters/common"
+	fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v3/pkg/kafka"
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/config"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	ic "github.com/opencord/voltha-protos/v3/go/inter_container"
+	"github.com/opencord/voltha-protos/v3/go/openflow_13"
+	ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+// mocks the OpenOLT struct.
+type fields struct {
+	deviceHandlers map[string]*DeviceHandler
+	coreProxy      *com.CoreProxy
+	adapterProxy   *com.AdapterProxy
+	eventProxy     *com.EventProxy
+	kafkaICProxy   kafka.InterContainerProxy
+	numOnus        int
+	KVStoreAddress string
+	KVStoreType    string
+	exitChannel    chan int
+	ctx            context.Context
+}
+
+// mockOlt mocks OpenOLT struct.
+func mockOlt() *fields {
+	dh := newMockDeviceHandler()
+	newOlt := &fields{}
+	newOlt.deviceHandlers = map[string]*DeviceHandler{}
+	newOlt.deviceHandlers[dh.device.Id] = dh
+	return newOlt
+}
+
+// testOltObject maps fields type to OpenOLt type.
+func testOltObject(testOlt *fields) *OpenOLT {
+	return &OpenOLT{
+		deviceHandlers: testOlt.deviceHandlers,
+		coreProxy:      testOlt.coreProxy,
+		adapterProxy:   testOlt.adapterProxy,
+		eventProxy:     testOlt.eventProxy,
+		kafkaICProxy:   testOlt.kafkaICProxy,
+		numOnus:        testOlt.numOnus,
+		KVStoreAddress: testOlt.KVStoreAddress,
+		KVStoreType:    testOlt.KVStoreType,
+		exitChannel:    testOlt.exitChannel,
+	}
+}
+
+// mockDevice mocks Device.
+func mockDevice() *voltha.Device {
+	return &voltha.Device{
+		Id:       "olt",
+		Root:     true,
+		ParentId: "logical_device",
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "olt",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+	}
+}
+
+func TestNewOpenOLT(t *testing.T) {
+	tests := []struct {
+		name        string
+		fields      *fields
+		configFlags *config.AdapterFlags
+		want        *OpenOLT
+	}{
+		{"newopenolt-1", &fields{}, &config.AdapterFlags{OnuNumber: 1, KVStoreAddress: "1.1.1.1:1", KVStoreType: "consul"},
+			&OpenOLT{numOnus: 1, KVStoreAddress: "1.1.1.1:1", KVStoreType: "consul"}},
+		{"newopenolt-2", &fields{}, &config.AdapterFlags{OnuNumber: 2, KVStoreAddress: "2.2.2.2:2", KVStoreType: "etcd"},
+			&OpenOLT{numOnus: 2, KVStoreAddress: "2.2.2.2:2", KVStoreType: "etcd"}},
+		{"newopenolt-3", &fields{}, &config.AdapterFlags{OnuNumber: 3, KVStoreAddress: "3.3.3.3:3", KVStoreType: "consul"},
+			&OpenOLT{numOnus: 3, KVStoreAddress: "3.3.3.3:3", KVStoreType: "consul"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewOpenOLT(tt.fields.ctx, tt.fields.kafkaICProxy, tt.fields.coreProxy, tt.fields.adapterProxy,
+				tt.fields.eventProxy, tt.configFlags); reflect.TypeOf(got) != reflect.TypeOf(tt.want) && got != nil {
+				t.Errorf("NewOpenOLT() error = %v, wantErr %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Abandon_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"abandon_device-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"abandon_device-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"abandon_device-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Abandon_device(context.Background(), tt.args.device); err != tt.wantErr {
+				t.Errorf("Abandon_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Activate_image_update(t *testing.T) {
+	type args struct {
+		device  *voltha.Device
+		request *voltha.ImageDownload
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *voltha.ImageDownload
+		wantErr error
+	}{
+		{"activate_image_upate-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
+			olterrors.ErrNotImplemented},
+		{"activate_image_upate-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123CDE"},
+			olterrors.ErrNotImplemented},
+		{"activate_image_upate-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123EFG"},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Activate_image_update(context.Background(), tt.args.device, tt.args.request)
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Activate_image_update() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Adapter_descriptor(t *testing.T) {
+	tests := []struct {
+		name    string
+		fields  *fields
+		wantErr error
+	}{
+		{"adapter_descriptor-1", &fields{}, olterrors.ErrNotImplemented},
+		{"adapter_descriptor-2", &fields{}, olterrors.ErrNotImplemented},
+		{"adapter_descriptor-3", &fields{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Adapter_descriptor(context.Background()); err != tt.wantErr {
+				t.Errorf("Adapter_descriptor() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Adopt_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	var device = mockDevice()
+	device.Id = "olt"
+	nilDevice := olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"adopt_device-1", mockOlt(), args{}, nilDevice},
+		{"adopt_device-2", mockOlt(), args{device}, nilDevice},
+		{"adopt_device-3", mockOlt(), args{mockDevice()}, nil},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			err := oo.Adopt_device(context.Background(), tt.args.device)
+			if (err != nil) && (reflect.TypeOf(err) !=
+				reflect.TypeOf(tt.wantErr)) && (tt.args.device == nil) {
+				t.Errorf("Adopt_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err == nil {
+				t.Log("return'd nil")
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Cancel_image_download(t *testing.T) {
+	type args struct {
+		device  *voltha.Device
+		request *voltha.ImageDownload
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *voltha.ImageDownload
+		wantErr error
+	}{
+		{"cancel_image_download-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
+			olterrors.ErrNotImplemented},
+		{"cancel_image_download-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123IJK"},
+			olterrors.ErrNotImplemented},
+		{"cancel_image_download-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123KLM"},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Cancel_image_download(context.Background(), tt.args.device, tt.args.request)
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Cancel_image_download() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Delete_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"delete_device-1", &fields{}, args{mockDevice()},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Delete_device(context.Background(), tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Delete_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Device_types(t *testing.T) {
+	tests := []struct {
+		name    string
+		fields  *fields
+		want    *voltha.DeviceTypes
+		wantErr error
+	}{
+		{"device_types-1", &fields{}, &voltha.DeviceTypes{},
+			olterrors.ErrNotImplemented},
+		{"device_types-2", &fields{}, &voltha.DeviceTypes{},
+			olterrors.ErrNotImplemented},
+		{"device_types-3", &fields{}, &voltha.DeviceTypes{},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Device_types(context.Background())
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Device_types() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Disable_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"disable_device-1", mockOlt(), args{mockDevice()}, nil},
+		{"disable_device-2", &fields{}, args{mockDevice()},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Disable_device(context.Background(), tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Disable_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Download_image(t *testing.T) {
+	type args struct {
+		device  *voltha.Device
+		request *voltha.ImageDownload
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *voltha.ImageDownload
+		wantErr error
+	}{
+		{"download_image-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
+			olterrors.ErrNotImplemented},
+		{"download_image-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123LKJ"},
+			olterrors.ErrNotImplemented},
+		{"download_image-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123RTY"},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Download_image(context.Background(), tt.args.device, tt.args.request)
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Download_image() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Get_device_details(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"get_device_details-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"get_device_details-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"get_device_details-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Get_device_details(context.Background(), tt.args.device); err != tt.wantErr {
+				t.Errorf("Get_device_details() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Get_image_download_status(t *testing.T) {
+	type args struct {
+		device  *voltha.Device
+		request *voltha.ImageDownload
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *voltha.ImageDownload
+		wantErr error
+	}{
+		{"get_image_download_status-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
+			olterrors.ErrNotImplemented},
+		{"get_image_download_status-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123LKJ"},
+			olterrors.ErrNotImplemented},
+		{"get_image_download_status-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123DFG"},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Get_image_download_status(context.Background(), tt.args.device, tt.args.request)
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Get_image_download_status() got = %v want = %v error = %v, wantErr %v",
+					got, tt.want, err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Get_ofp_device_info(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *ic.SwitchCapability
+		wantErr error
+	}{
+		{"get_ofp_device_info-1", mockOlt(), args{mockDevice()}, &ic.SwitchCapability{
+			Desc: &openflow_13.OfpDesc{
+				MfrDesc: "VOLTHA Project",
+				HwDesc:  "open_pon",
+				SwDesc:  "open_pon",
+			},
+			SwitchFeatures: &openflow_13.OfpSwitchFeatures{
+				NBuffers:     uint32(256),
+				NTables:      uint32(2),
+				Capabilities: uint32(15),
+			},
+		}, nil},
+		{"get_ofp_device_info-2", &fields{}, args{mockDevice()}, nil,
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Get_ofp_device_info(context.Background(), tt.args.device)
+			if !reflect.DeepEqual(err, tt.wantErr) || !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Get_ofp_device_info() got = %v want = %v error = %v, wantErr = %v",
+					got, tt.want, err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Health(t *testing.T) {
+	tests := []struct {
+		name    string
+		fields  *fields
+		want    *voltha.HealthStatus
+		wantErr error
+	}{
+		{"health-1", &fields{}, &voltha.HealthStatus{}, olterrors.ErrNotImplemented},
+		{"health-2", &fields{}, &voltha.HealthStatus{}, olterrors.ErrNotImplemented},
+		{"health-3", &fields{}, &voltha.HealthStatus{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Health(context.Background())
+			if err != tt.wantErr && got == nil {
+				t.Errorf("Get_ofp_port_info() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Process_inter_adapter_message(t *testing.T) {
+	type args struct {
+		msg *ic.InterAdapterMessage
+	}
+	var message1 = args{
+		msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:            "olt",
+				ProxyDeviceId: "",
+				ToDeviceId:    "onu1",
+			},
+		},
+	}
+	var message2 = args{
+		msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:            "olt",
+				ProxyDeviceId: "olt",
+				ToDeviceId:    "olt",
+				Type:          ic.InterAdapterMessageType_OMCI_REQUEST,
+			},
+		},
+	}
+	var message3 = args{
+		msg: &ic.InterAdapterMessage{
+			Header: &ic.InterAdapterHeader{
+				Id:            "olt",
+				ProxyDeviceId: "olt",
+				ToDeviceId:    "olt",
+				Type:          ic.InterAdapterMessageType_FLOW_REQUEST,
+			},
+		},
+	}
+	tests := []struct {
+		name        string
+		fields      *fields
+		args        args
+		wantErrType reflect.Type
+	}{
+		{"process_inter_adaptor_messgae-1", mockOlt(), message1,
+			reflect.TypeOf(&olterrors.ErrNotFound{})},
+		{"process_inter_adaptor_messgae-2", mockOlt(), message2,
+			reflect.TypeOf(&olterrors.ErrAdapter{})},
+		{"process_inter_adaptor_messgae-3", mockOlt(), message3,
+			reflect.TypeOf(&olterrors.ErrInvalidValue{})},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Process_inter_adapter_message(context.Background(), tt.args.msg); reflect.TypeOf(err) != tt.wantErrType {
+				t.Errorf("Process_inter_adapter_message() error = %v, wantErr %v",
+					reflect.TypeOf(err), tt.wantErrType)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Reboot_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"reboot_device-1", mockOlt(), args{mockDevice()}, nil},
+		{"reboot_device-2", &fields{}, args{mockDevice()},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Reboot_device(context.Background(), tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Reboot_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Receive_packet_out(t *testing.T) {
+	acts := []*ofp.OfpAction{
+		fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA))),
+		fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+		fu.Output(1),
+	}
+	type args struct {
+		deviceID     string
+		egressPortNo int
+		packet       *openflow_13.OfpPacketOut
+	}
+	pktout := &ofp.OfpPacketOut{BufferId: 0, InPort: 1, Actions: acts, Data: []byte("AYDCAAAOAODsSE5TiMwCBwQA4OxITlIEBQUwLzUx" +
+		"BgIAFAgEMC81MQoJbG9jYWxob3N0EBwFAawbqqACAAAAoRAxLjMuNi4xLjQuMS40NDEz/gYAgMILAgD+GQCAwgkDAAAAAGQAAAAAAAAAAgICAgICAgL+" +
+		"GQCAwgoDAAAAAGQAAAAAAAAAAgICAgICAgIAAA==")}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"receive_packet_out-1", mockOlt(), args{mockDevice().Id, 1, pktout}, nil},
+		{"receive_packet_out-2", mockOlt(), args{"1234", 1, pktout},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "1234"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Receive_packet_out(context.Background(), tt.args.deviceID, tt.args.egressPortNo, tt.args.packet); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Receive_packet_out() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Reconcile_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	expectedError := olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"reconcile_device-1", &fields{}, args{}, expectedError},
+		{"reconcile_device-2", &fields{}, args{}, expectedError},
+		{"reconcile_device-3", &fields{}, args{}, expectedError},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Reconcile_device(context.Background(), tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Reconcile_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Reenable_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"reenable_device-1", mockOlt(), args{mockDevice()}, nil},
+		{"reenable_device-2", &fields{}, args{mockDevice()},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Reenable_device(context.Background(), tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Reenable_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Revert_image_update(t *testing.T) {
+	type args struct {
+		device  *voltha.Device
+		request *voltha.ImageDownload
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		want    *voltha.ImageDownload
+		wantErr error
+	}{
+		{"revert_image_update-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
+			olterrors.ErrNotImplemented},
+		{"revert_image_update-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123TYU"},
+			olterrors.ErrNotImplemented},
+		{"revert_image_update-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123GTH"},
+			olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			got, err := oo.Revert_image_update(context.Background(), tt.args.device, tt.args.request)
+			if err != tt.wantErr && got == nil {
+				t.Log("error :", err)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Self_test_device(t *testing.T) {
+	type args struct {
+		device *voltha.Device
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"self_test_device-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"self_test_device-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"self_test_device-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Self_test_device(context.Background(), tt.args.device); err != tt.wantErr {
+				t.Errorf("Self_test_device() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Start(t *testing.T) {
+	type args struct {
+		ctx context.Context
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"start-1", &fields{}, args{}, errors.New("start error")},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Start(tt.args.ctx); err != nil {
+				t.Errorf("Start() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Stop(t *testing.T) {
+	type args struct {
+		ctx context.Context
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"stop-1", &fields{exitChannel: make(chan int, 1)}, args{}, errors.New("stop error")},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Start(tt.args.ctx); err != nil {
+				t.Error(err)
+			}
+			if err := oo.Stop(tt.args.ctx); err != nil {
+				t.Errorf("Stop() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Suppress_event(t *testing.T) {
+	type args struct {
+		filter *voltha.EventFilter
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"suppress_event-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"suppress_event-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"suppress_event-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Suppress_event(context.Background(), tt.args.filter); err != tt.wantErr {
+				t.Errorf("Suppress_event() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Unsuppress_event(t *testing.T) {
+	type args struct {
+		filter *voltha.EventFilter
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"unsupress_event-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"unsupress_event-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"unsupress_event-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Unsuppress_event(context.Background(), tt.args.filter); err != tt.wantErr {
+				t.Errorf("Unsuppress_event() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Update_flows_bulk(t *testing.T) {
+	type args struct {
+		device       *voltha.Device
+		flows        *voltha.Flows
+		groups       *voltha.FlowGroups
+		flowMetadata *voltha.FlowMetadata
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"update_flows_bulk-1", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"update_flows_bulk-2", &fields{}, args{}, olterrors.ErrNotImplemented},
+		{"update_flows_bulk-3", &fields{}, args{}, olterrors.ErrNotImplemented},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Update_flows_bulk(context.Background(), tt.args.device, tt.args.flows, tt.args.groups, tt.args.flowMetadata); err != tt.wantErr {
+				t.Errorf("Update_flows_bulk() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Update_flows_incrementally(t *testing.T) {
+	type args struct {
+		device       *voltha.Device
+		flows        *openflow_13.FlowChanges
+		groups       *openflow_13.FlowGroupChanges
+		flowMetadata *voltha.FlowMetadata
+	}
+
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"update_flows_incrementally-1", &fields{}, args{device: mockDevice()},
+			olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+		{"update_flows_incrementally-2", mockOlt(), args{device: mockDevice()}, nil},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Update_flows_incrementally(context.Background(), tt.args.device, tt.args.flows, tt.args.groups, tt.args.flowMetadata); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Update_flows_incrementally() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Update_pm_config(t *testing.T) {
+	type args struct {
+		device    *voltha.Device
+		pmConfigs *voltha.PmConfigs
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr error
+	}{
+		{"update_pm_config-1", mockOlt(), args{device: mockDevice(), pmConfigs: &voltha.PmConfigs{DefaultFreq: 150, Grouped: false, FreqOverride: false}}, nil},
+		{"update_pm_config-2", &fields{}, args{device: mockDevice(), pmConfigs: &voltha.PmConfigs{DefaultFreq: 150, Grouped: false, FreqOverride: false}}, olterrors.NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+
+			if err := oo.Update_pm_config(context.Background(), tt.args.device, tt.args.pmConfigs); !reflect.DeepEqual(err, tt.wantErr) {
+				t.Errorf("Update_pm_config() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+		})
+	}
+}
+
+func TestOpenOLT_deleteDeviceHandlerToMap(t *testing.T) {
+	type args struct {
+		agent *DeviceHandler
+	}
+	tests := []struct {
+		name   string
+		fields *fields
+		args   args
+	}{
+		{"delete_device_handler_map-1", mockOlt(), args{newMockDeviceHandler()}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			oo.deleteDeviceHandlerToMap(tt.args.agent)
+			if len(oo.deviceHandlers) > 0 {
+				t.Errorf("delete device manager failed")
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Enable_port(t *testing.T) {
+	type args struct {
+		deviceID string
+		port     *voltha.Port
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"Enable_port-1", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_PON_OLT, PortNo: 1}}, false},
+		{"Enable_port-2", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_ETHERNET_NNI, PortNo: 1}}, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Enable_port(context.Background(), tt.args.deviceID, tt.args.port); (err != nil) != tt.wantErr {
+				t.Errorf("OpenOLT.Enable_port() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOpenOLT_Disable_port(t *testing.T) {
+	type args struct {
+		deviceID string
+		port     *voltha.Port
+	}
+	tests := []struct {
+		name    string
+		fields  *fields
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+		{"Disable_port-1", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_PON_OLT, PortNo: 1}}, false},
+		{"Disable_port-2", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_ETHERNET_NNI, PortNo: 1}}, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			oo := testOltObject(tt.fields)
+			if err := oo.Disable_port(context.Background(), tt.args.deviceID, tt.args.port); (err != nil) != tt.wantErr {
+				t.Errorf("OpenOLT.Disable_port() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/statsmanager.go b/internal/pkg/core/statsmanager.go
new file mode 100644
index 0000000..d8fa663
--- /dev/null
+++ b/internal/pkg/core/statsmanager.go
@@ -0,0 +1,497 @@
+/*
+ * Copyright 2019-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/log"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
+	"github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+var mutex = &sync.Mutex{}
+
+// PonPort representation
+type PonPort struct {
+	/*
+	   This is a highly reduced version taken from the adtran pon_port.
+	   TODO: Extend for use in the openolt adapter set.
+	*/
+	/*    MAX_ONUS_SUPPORTED = 256
+	      DEFAULT_ENABLED = False
+	      MAX_DEPLOYMENT_RANGE = 25000  # Meters (OLT-PB maximum)
+
+	      _MCAST_ONU_ID = 253
+	      _MCAST_ALLOC_BASE = 0x500
+
+	      _SUPPORTED_ACTIVATION_METHODS = ['autodiscovery']  # , 'autoactivate']
+	      _SUPPORTED_AUTHENTICATION_METHODS = ['serial-number']
+	*/
+	PONID    uint32
+	DeviceID string
+	IntfID   uint32
+	PortNum  uint32
+	PortID   uint32
+	Label    string
+	ONUs     map[uint32]interface{}
+	ONUsByID map[uint32]interface{}
+
+	RxBytes        uint64
+	RxPackets      uint64
+	RxUcastPackets uint64
+	RxMcastPackets uint64
+	RxBcastPackets uint64
+	RxErrorPackets uint64
+	TxBytes        uint64
+	TxPackets      uint64
+	TxUcastPackets uint64
+	TxMcastPackets uint64
+	TxBcastPackets uint64
+	TxErrorPackets uint64
+	RxCrcErrors    uint64
+	BipErrors      uint64
+}
+
+// NewPONPort returns a new instance of PonPort initialized with given PONID, DeviceID, IntfID and PortNum
+func NewPONPort(PONID uint32, DeviceID string, IntfID uint32, PortNum uint32) *PonPort {
+
+	var PON PonPort
+
+	PON.PONID = PONID
+	PON.DeviceID = DeviceID
+	PON.IntfID = IntfID
+	PON.PortNum = PortNum
+	PON.PortID = 0
+	PON.Label = fmt.Sprintf("%s%d", "pon-", PONID)
+
+	PON.ONUs = make(map[uint32]interface{})
+	PON.ONUsByID = make(map[uint32]interface{})
+
+	/*
+	   Statistics  taken from nni_port
+	   self.intf_id = 0  #handled by getter
+	   self.port_no = 0  #handled by getter
+	   self.port_id = 0  #handled by getter
+
+	   Note:  In the current implementation of the kpis coming from the BAL the stats are the
+	   samne model for NNI and PON.
+
+	   TODO:   Integrate additional kpis for the PON and other southbound port objecgts.
+
+	*/
+
+	PON.RxBytes = 0
+	PON.RxPackets = 0
+	PON.RxUcastPackets = 0
+	PON.RxMcastPackets = 0
+	PON.RxBcastPackets = 0
+	PON.RxErrorPackets = 0
+	PON.TxBytes = 0
+	PON.TxPackets = 0
+	PON.TxUcastPackets = 0
+	PON.TxMcastPackets = 0
+	PON.TxBcastPackets = 0
+	PON.TxErrorPackets = 0
+	PON.RxCrcErrors = 0
+	PON.BipErrors = 0
+
+	/*    def __str__(self):
+	      return "PonPort-{}: Admin: {}, Oper: {}, OLT: {}".format(self._label,
+	                                                               self._admin_state,
+	                                                               self._oper_status,
+	                                                               self.olt)
+	*/
+	return &PON
+}
+
+// NniPort representation
+type NniPort struct {
+	/*
+	   Northbound network port, often Ethernet-based
+
+	   This is a highly reduced version taken from the adtran nni_port code set
+	   TODO:   add functions to allow for port specific values and operations
+	*/
+	PortNum     uint32
+	Name        string
+	LogicalPort uint32
+	IntfID      uint32
+
+	RxBytes        uint64
+	RxPackets      uint64
+	RxUcastPackets uint64
+	RxMcastPackets uint64
+	RxBcastPackets uint64
+	RxErrorPackets uint64
+	TxBytes        uint64
+	TxPackets      uint64
+	TxUcastPackets uint64
+	TxMcastPackets uint64
+	TxBcastPackets uint64
+	TxErrorPackets uint64
+	RxCrcErrors    uint64
+	BipErrors      uint64
+}
+
+// NewNniPort returns a new instance of NniPort initialized with the given PortNum and IntfID
+func NewNniPort(PortNum uint32, IntfID uint32) *NniPort {
+
+	var NNI NniPort
+
+	NNI.PortNum = PortNum
+	NNI.Name = fmt.Sprintf("%s%d", "nni-", PortNum)
+	NNI.IntfID = IntfID
+
+	NNI.RxBytes = 0
+	NNI.RxPackets = 0
+	NNI.RxUcastPackets = 0
+	NNI.RxMcastPackets = 0
+	NNI.RxBcastPackets = 0
+	NNI.RxErrorPackets = 0
+	NNI.TxBytes = 0
+	NNI.TxPackets = 0
+	NNI.TxUcastPackets = 0
+	NNI.TxMcastPackets = 0
+	NNI.TxBcastPackets = 0
+	NNI.TxErrorPackets = 0
+	NNI.RxCrcErrors = 0
+	NNI.BipErrors = 0
+
+	return &NNI
+}
+
+// OpenOltStatisticsMgr structure
+type OpenOltStatisticsMgr struct {
+	Device         *DeviceHandler
+	NorthBoundPort map[uint32]*NniPort
+	SouthBoundPort map[uint32]*PonPort
+}
+
+// NewOpenOltStatsMgr returns a new instance of the OpenOltStatisticsMgr
+func NewOpenOltStatsMgr(ctx context.Context, Dev *DeviceHandler) *OpenOltStatisticsMgr {
+
+	var StatMgr OpenOltStatisticsMgr
+
+	StatMgr.Device = Dev
+	var Ports interface{}
+	Ports, _ = InitPorts(ctx, "nni", Dev.device.Id, 1)
+	StatMgr.NorthBoundPort, _ = Ports.(map[uint32]*NniPort)
+	NumPonPorts := Dev.resourceMgr.DevInfo.GetPonPorts()
+	Ports, _ = InitPorts(ctx, "pon", Dev.device.Id, NumPonPorts)
+	StatMgr.SouthBoundPort, _ = Ports.(map[uint32]*PonPort)
+	return &StatMgr
+}
+
+// InitPorts collects the port objects:  nni and pon that are updated with the current data from the OLT
+func InitPorts(ctx context.Context, Intftype string, DeviceID string, numOfPorts uint32) (interface{}, error) {
+	/*
+	     This method collects the port objects:  nni and pon that are updated with the
+	     current data from the OLT
+
+	     Both the northbound (nni) and southbound ports are indexed by the interface id (intf_id)
+	     and NOT the port number. When the port object is instantiated it will contain the intf_id and
+	     port_no values
+
+	   :param type:
+	   :return:
+	*/
+	var i uint32
+	if Intftype == "nni" {
+		NniPorts := make(map[uint32]*NniPort)
+		for i = 0; i < numOfPorts; i++ {
+			Port := BuildPortObject(ctx, i, "nni", DeviceID).(*NniPort)
+			NniPorts[Port.IntfID] = Port
+		}
+		return NniPorts, nil
+	} else if Intftype == "pon" {
+		PONPorts := make(map[uint32]*PonPort)
+		for i = 0; i < numOfPorts; i++ {
+			PONPort := BuildPortObject(ctx, i, "pon", DeviceID).(*PonPort)
+			PONPorts[PortNoToIntfID(PONPort.IntfID, voltha.Port_PON_OLT)] = PONPort
+		}
+		return PONPorts, nil
+	} else {
+		logger.Errorw(ctx, "invalid-type-of-interface", log.Fields{"interface-type": Intftype})
+		return nil, olterrors.NewErrInvalidValue(log.Fields{"interface-type": Intftype}, nil)
+	}
+}
+
+// BuildPortObject allows for updating north and southbound ports, newly discovered ports, and devices
+func BuildPortObject(ctx context.Context, PortNum uint32, IntfType string, DeviceID string) interface{} {
+	/*
+	   Separate method to allow for updating north and southbound ports
+	   newly discovered ports and devices
+
+	   :param port_num:
+	   :param type:
+	   :return:
+	*/
+
+	if IntfType == "nni" {
+		IntfID := IntfIDToPortNo(PortNum, voltha.Port_ETHERNET_NNI)
+		nniID := PortNoToIntfID(IntfID, voltha.Port_ETHERNET_NNI)
+		logger.Debugw(ctx, "interface-type-nni",
+			log.Fields{
+				"nni-id":    nniID,
+				"intf-type": IntfType})
+		return NewNniPort(PortNum, nniID)
+	} else if IntfType == "pon" {
+		// PON ports require a different configuration
+		//  intf_id and pon_id are currently equal.
+		IntfID := IntfIDToPortNo(PortNum, voltha.Port_PON_OLT)
+		PONID := PortNoToIntfID(IntfID, voltha.Port_PON_OLT)
+		logger.Debugw(ctx, "interface-type-pon",
+			log.Fields{
+				"pon-id":    PONID,
+				"intf-type": IntfType})
+		return NewPONPort(PONID, DeviceID, IntfID, PortNum)
+	} else {
+		logger.Errorw(ctx, "invalid-type-of-interface", log.Fields{"intf-type": IntfType})
+		return nil
+	}
+}
+
+// collectNNIMetrics will collect the nni port metrics
+func (StatMgr *OpenOltStatisticsMgr) collectNNIMetrics(nniID uint32) map[string]float32 {
+
+	nnival := make(map[string]float32)
+	mutex.Lock()
+	cm := StatMgr.Device.portStats.NorthBoundPort[nniID]
+	mutex.Unlock()
+	metricNames := StatMgr.Device.metrics.GetSubscriberMetrics()
+
+	var metrics []string
+	for metric := range metricNames {
+		if metricNames[metric].Enabled {
+			metrics = append(metrics, metric)
+		}
+	}
+
+	for _, mName := range metrics {
+		switch mName {
+		case "rx_bytes":
+			nnival["RxBytes"] = float32(cm.RxBytes)
+		case "rx_packets":
+			nnival["RxPackets"] = float32(cm.RxPackets)
+		case "rx_ucast_packets":
+			nnival["RxUcastPackets"] = float32(cm.RxUcastPackets)
+		case "rx_mcast_packets":
+			nnival["RxMcastPackets"] = float32(cm.RxMcastPackets)
+		case "rx_bcast_packets":
+			nnival["RxBcastPackets"] = float32(cm.RxBcastPackets)
+		case "tx_bytes":
+			nnival["TxBytes"] = float32(cm.TxBytes)
+		case "tx_packets":
+			nnival["TxPackets"] = float32(cm.TxPackets)
+		case "tx_mcast_packets":
+			nnival["TxMcastPackets"] = float32(cm.TxMcastPackets)
+		case "tx_bcast_packets":
+			nnival["TxBcastPackets"] = float32(cm.TxBcastPackets)
+		}
+	}
+	return nnival
+}
+
+// collectPONMetrics will collect the pon port metrics
+func (StatMgr *OpenOltStatisticsMgr) collectPONMetrics(pID uint32) map[string]float32 {
+
+	ponval := make(map[string]float32)
+	mutex.Lock()
+	cm := StatMgr.Device.portStats.SouthBoundPort[pID]
+	mutex.Unlock()
+	metricNames := StatMgr.Device.metrics.GetSubscriberMetrics()
+
+	var metrics []string
+	for metric := range metricNames {
+		if metricNames[metric].Enabled {
+			metrics = append(metrics, metric)
+		}
+	}
+
+	for _, mName := range metrics {
+		switch mName {
+		case "rx_bytes":
+			ponval["RxBytes"] = float32(cm.RxBytes)
+		case "rx_packets":
+			ponval["RxPackets"] = float32(cm.RxPackets)
+		case "rx_ucast_packets":
+			ponval["RxUcastPackets"] = float32(cm.RxUcastPackets)
+		case "rx_mcast_packets":
+			ponval["RxMcastPackets"] = float32(cm.RxMcastPackets)
+		case "rx_bcast_packets":
+			ponval["RxBcastPackets"] = float32(cm.RxBcastPackets)
+		case "tx_bytes":
+			ponval["TxBytes"] = float32(cm.TxBytes)
+		case "tx_packets":
+			ponval["TxPackets"] = float32(cm.TxPackets)
+		case "tx_mcast_packets":
+			ponval["TxMcastPackets"] = float32(cm.TxMcastPackets)
+		case "tx_bcast_packets":
+			ponval["TxBcastPackets"] = float32(cm.TxBcastPackets)
+		}
+	}
+
+	return ponval
+}
+
+// publishMatrics will publish the pon port metrics
+func (StatMgr OpenOltStatisticsMgr) publishMetrics(ctx context.Context, val map[string]float32,
+	port *voltha.Port, devID string, devType string) {
+	logger.Debugw(ctx, "publish-metrics",
+		log.Fields{
+			"port":    port.Label,
+			"metrics": val})
+
+	var metricInfo voltha.MetricInformation
+	var ke voltha.KpiEvent2
+	var volthaEventSubCatgry voltha.EventSubCategory_Types
+	metricsContext := make(map[string]string)
+	metricsContext["oltid"] = devID
+	metricsContext["devicetype"] = devType
+	metricsContext["portlabel"] = port.Label
+	metricsContext["portno"] = strconv.Itoa(int(port.PortNo))
+
+	if port.Type == voltha.Port_ETHERNET_NNI {
+		volthaEventSubCatgry = voltha.EventSubCategory_NNI
+	} else {
+		volthaEventSubCatgry = voltha.EventSubCategory_PON
+	}
+
+	raisedTs := time.Now().UnixNano()
+	mmd := voltha.MetricMetaData{
+		Title:    port.Type.String(),
+		Ts:       float64(raisedTs),
+		Context:  metricsContext,
+		DeviceId: devID,
+	}
+
+	metricInfo.Metadata = &mmd
+	metricInfo.Metrics = val
+
+	ke.SliceData = []*voltha.MetricInformation{&metricInfo}
+	ke.Type = voltha.KpiEventType_slice
+	ke.Ts = float64(time.Now().UnixNano())
+
+	if err := StatMgr.Device.EventProxy.SendKpiEvent(ctx, "STATS_EVENT", &ke, voltha.EventCategory_EQUIPMENT, volthaEventSubCatgry, raisedTs); err != nil {
+		logger.Errorw(ctx, "failed-to-send-pon-stats", log.Fields{"err": err})
+	}
+}
+
+// PortStatisticsIndication handles the port statistics indication
+func (StatMgr *OpenOltStatisticsMgr) PortStatisticsIndication(ctx context.Context, PortStats *openolt.PortStatistics, NumPonPorts uint32) {
+	StatMgr.PortsStatisticsKpis(ctx, PortStats, NumPonPorts)
+	logger.Debugw(ctx, "received-port-stats-indication", log.Fields{"port-stats": PortStats})
+}
+
+// FlowStatisticsIndication to be implemented
+func FlowStatisticsIndication(ctx context.Context, self, FlowStats *openolt.FlowStatistics) {
+	logger.Debugw(ctx, "flow-stats-collected", log.Fields{"flow-stats": FlowStats})
+}
+
+// PortsStatisticsKpis map the port stats values into a dictionary, creates the kpiEvent and then publish to Kafka
+func (StatMgr *OpenOltStatisticsMgr) PortsStatisticsKpis(ctx context.Context, PortStats *openolt.PortStatistics, NumPonPorts uint32) {
+
+	/*map the port stats values into a dictionary
+	  Create a kpoEvent and publish to Kafka
+
+	  :param port_stats:
+	  :return:
+	*/
+	IntfID := PortStats.IntfId
+
+	if (IntfIDToPortNo(1, voltha.Port_ETHERNET_NNI) < IntfID) &&
+		(IntfID < IntfIDToPortNo(4, voltha.Port_ETHERNET_NNI)) {
+		/*
+		   for this release we are only interested in the first NNI for
+		   Northbound.
+		   we are not using the other 3
+		*/
+		return
+	} else if IntfIDToPortNo(0, voltha.Port_ETHERNET_NNI) == IntfID {
+
+		var portNNIStat NniPort
+		portNNIStat.IntfID = IntfID
+		portNNIStat.PortNum = uint32(0)
+		portNNIStat.RxBytes = PortStats.RxBytes
+		portNNIStat.RxPackets = PortStats.RxPackets
+		portNNIStat.RxUcastPackets = PortStats.RxUcastPackets
+		portNNIStat.RxMcastPackets = PortStats.RxMcastPackets
+		portNNIStat.RxBcastPackets = PortStats.RxBcastPackets
+		portNNIStat.TxBytes = PortStats.TxBytes
+		portNNIStat.TxPackets = PortStats.TxPackets
+		portNNIStat.TxUcastPackets = PortStats.TxUcastPackets
+		portNNIStat.TxMcastPackets = PortStats.TxMcastPackets
+		portNNIStat.TxBcastPackets = PortStats.TxBcastPackets
+		mutex.Lock()
+		StatMgr.NorthBoundPort[0] = &portNNIStat
+		mutex.Unlock()
+		logger.Debugw(ctx, "received-nni-stats", log.Fields{"nni-stats": StatMgr.NorthBoundPort})
+	}
+	for i := uint32(0); i < NumPonPorts; i++ {
+
+		if IntfIDToPortNo(i, voltha.Port_PON_OLT) == IntfID {
+			var portPonStat PonPort
+			portPonStat.IntfID = IntfID
+			portPonStat.PortNum = i
+			portPonStat.PONID = i
+			portPonStat.RxBytes = PortStats.RxBytes
+			portPonStat.RxPackets = PortStats.RxPackets
+			portPonStat.RxUcastPackets = PortStats.RxUcastPackets
+			portPonStat.RxMcastPackets = PortStats.RxMcastPackets
+			portPonStat.RxBcastPackets = PortStats.RxBcastPackets
+			portPonStat.TxBytes = PortStats.TxBytes
+			portPonStat.TxPackets = PortStats.TxPackets
+			portPonStat.TxUcastPackets = PortStats.TxUcastPackets
+			portPonStat.TxMcastPackets = PortStats.TxMcastPackets
+			portPonStat.TxBcastPackets = PortStats.TxBcastPackets
+			mutex.Lock()
+			StatMgr.SouthBoundPort[i] = &portPonStat
+			mutex.Unlock()
+			logger.Debugw(ctx, "received-pon-stats-for-port", log.Fields{"port-pon-stats": portPonStat})
+		}
+	}
+
+	/*
+	   Based upon the intf_id map to an nni port or a pon port
+	   the intf_id is the key to the north or south bound collections
+
+	   Based upon the intf_id the port object (nni_port or pon_port) will
+	   have its data attr. updated by the current dataset collected.
+
+	   For prefixing the rule is currently to use the port number and not the intf_id
+	*/
+	/* TODO should the data be marshaled before sending it ?
+	   if IntfID == IntfIdToPortNo(0, voltha.Port_ETHERNET_NNI) {
+	       //NNI port (just the first one)
+	       err = UpdatePortObjectKpiData(StatMgr.NorthBoundPorts[PortStats.IntfID], PMData)
+	   } else {
+	       //PON ports
+	       err = UpdatePortObjectKpiData(SouthboundPorts[PortStats.IntfID], PMData)
+	   }
+	   if (err != nil) {
+	       logger.Error(ctx, "Error publishing statistics data")
+	   }
+	*/
+
+}
diff --git a/internal/pkg/core/statsmanager_test.go b/internal/pkg/core/statsmanager_test.go
new file mode 100644
index 0000000..0155330
--- /dev/null
+++ b/internal/pkg/core/statsmanager_test.go
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2019-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//Package core provides the utility for olt devices, flows and statistics
+package core
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/opencord/voltha-protos/v3/go/openolt"
+	"github.com/opencord/voltha-protos/v3/go/voltha"
+)
+
+func TestOpenOltStatisticsMgr_PortStatisticsIndication(t *testing.T) {
+	device := &voltha.Device{
+		Id:       "olt",
+		Root:     true,
+		ParentId: "logical_device",
+		ProxyAddress: &voltha.Device_ProxyAddress{
+			DeviceId:       "olt",
+			DeviceType:     "onu",
+			ChannelId:      1,
+			ChannelGroupId: 1,
+		},
+		ConnectStatus: 1,
+	}
+	dh := newMockDeviceHandler()
+	dh.device = device
+	StatMgr := NewOpenOltStatsMgr(context.Background(), dh)
+
+	type args struct {
+		PortStats *openolt.PortStatistics
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+		{"PortStatisticsIndication", args{PortStats: &openolt.PortStatistics{}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			StatMgr.PortStatisticsIndication(context.Background(), tt.args.PortStats, 16)
+		})
+	}
+}
+
+func TestOpenOltStatisticsMgr_publishMetrics(t *testing.T) {
+	type fields struct {
+		Device         *DeviceHandler
+		NorthBoundPort map[uint32]*NniPort
+		SouthBoundPort map[uint32]*PonPort
+	}
+	type args struct {
+		val  map[string]float32
+		port *voltha.Port
+	}
+	ponmap := map[uint32]*PonPort{}
+	ponmap[0] = &PonPort{
+		PONID:          0,
+		DeviceID:       "onu1",
+		IntfID:         0,
+		PortNum:        0,
+		PortID:         0,
+		Label:          "",
+		ONUs:           nil,
+		ONUsByID:       nil,
+		RxBytes:        0,
+		RxPackets:      0,
+		RxUcastPackets: 0,
+		RxMcastPackets: 0,
+		RxBcastPackets: 0,
+		RxErrorPackets: 0,
+		TxBytes:        0,
+		TxPackets:      0,
+		TxUcastPackets: 0,
+		TxMcastPackets: 0,
+		TxBcastPackets: 0,
+		TxErrorPackets: 0,
+		RxCrcErrors:    0,
+		BipErrors:      0,
+	}
+	nnimap := map[uint32]*NniPort{}
+	nnimap[0] = &NniPort{
+		PortNum:        0,
+		Name:           "olt1",
+		LogicalPort:    0,
+		IntfID:         0,
+		RxBytes:        0,
+		RxPackets:      0,
+		RxUcastPackets: 0,
+		RxMcastPackets: uint64(1111),
+		RxBcastPackets: 0,
+		RxErrorPackets: 0,
+		TxBytes:        0,
+		TxPackets:      0,
+		TxUcastPackets: 0,
+		TxMcastPackets: 0,
+		TxBcastPackets: 0,
+		TxErrorPackets: 0,
+		RxCrcErrors:    0,
+		BipErrors:      0,
+	}
+	pval := make(map[string]float32)
+	pval["rx_bytes"] = float32(111)
+	nval := make(map[string]float32)
+	nval["rx_bytes"] = float32(111)
+	dhandlerNNI := newMockDeviceHandler()
+	dhandlerNNI.portStats = &OpenOltStatisticsMgr{Device: nil, SouthBoundPort: nil, NorthBoundPort: nnimap}
+	dhandlerPON := newMockDeviceHandler()
+	dhandlerPON.portStats = &OpenOltStatisticsMgr{Device: nil, SouthBoundPort: ponmap, NorthBoundPort: nil}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+	}{
+		{
+			name: "PublishNNIMetrics-1",
+			fields: fields{
+				Device:         dhandlerNNI,
+				NorthBoundPort: nnimap,
+				SouthBoundPort: nil,
+			},
+			args: args{
+				val:  nval,
+				port: &voltha.Port{PortNo: 0, Label: fmt.Sprintf("%s%d", "nni-", 0), Type: voltha.Port_ETHERNET_NNI},
+			},
+		},
+		{
+			name: "PublishPONMetrics-1",
+			fields: fields{
+				Device:         dhandlerPON,
+				NorthBoundPort: nil,
+				SouthBoundPort: ponmap,
+			},
+			args: args{
+				val:  pval,
+				port: &voltha.Port{PortNo: 1, Label: fmt.Sprintf("%s%d", "pon-", 1), Type: voltha.Port_PON_OLT},
+			},
+		},
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			StatMgr := &OpenOltStatisticsMgr{
+				Device:         tt.fields.Device,
+				NorthBoundPort: tt.fields.NorthBoundPort,
+				SouthBoundPort: tt.fields.SouthBoundPort,
+			}
+			StatMgr.publishMetrics(context.Background(), tt.args.val, tt.args.port, "onu1", "openolt")
+		})
+	}
+}
+
+func TestOpenOltStatisticsMgr_collectNNIMetrics(t *testing.T) {
+	type fields struct {
+		Device         *DeviceHandler
+		NorthBoundPort map[uint32]*NniPort
+		SouthBoundPort map[uint32]*PonPort
+	}
+	type args struct {
+		nniID uint32
+	}
+	dhandler := newMockDeviceHandler()
+	pmconfig := make(map[string]*voltha.PmConfig)
+	pmconfig["rx_bytes"] = &voltha.PmConfig{Name: "olt"}
+
+	var res map[string]float32
+	nnimap := map[uint32]*NniPort{}
+	nnimap[0] = &NniPort{Name: "olt"}
+	nnimap[1] = &NniPort{Name: "olt"}
+	dh := &DeviceHandler{portStats: &OpenOltStatisticsMgr{Device: dhandler, SouthBoundPort: nil, NorthBoundPort: nnimap}}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   map[string]float32
+	}{
+		{"CollectNNIMetrics-1", fields{
+			Device:         dh,
+			NorthBoundPort: nnimap,
+			SouthBoundPort: nil,
+		}, args{0}, res},
+		{"CollectNNIMetrics-2", fields{
+			Device:         dh,
+			NorthBoundPort: nnimap,
+			SouthBoundPort: nil,
+		}, args{1}, res},
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			StatMgr := &OpenOltStatisticsMgr{
+				Device:         tt.fields.Device,
+				NorthBoundPort: tt.fields.NorthBoundPort,
+				SouthBoundPort: tt.fields.SouthBoundPort,
+			}
+			got := StatMgr.collectNNIMetrics(tt.args.nniID)
+			if reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
+				t.Errorf("collectNNIMetrics() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestOpenOltStatisticsMgr_collectPONMetrics(t *testing.T) {
+	type fields struct {
+		Device         *DeviceHandler
+		NorthBoundPort map[uint32]*NniPort
+		SouthBoundPort map[uint32]*PonPort
+	}
+	type args struct {
+		pID uint32
+	}
+	dhandler := newMockDeviceHandler()
+	pmconfig := make(map[string]*voltha.PmConfig)
+	pmconfig["rx_bytes"] = &voltha.PmConfig{Name: "olt"}
+
+	var res map[string]float32
+	ponmap := map[uint32]*PonPort{}
+	ponmap[0] = &PonPort{DeviceID: "olt"}
+	ponmap[1] = &PonPort{DeviceID: "olt"}
+	dh := &DeviceHandler{portStats: &OpenOltStatisticsMgr{Device: dhandler, SouthBoundPort: ponmap, NorthBoundPort: nil}}
+
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   map[string]float32
+	}{
+		{"CollectPONMetrics-1", fields{
+			Device:         dh,
+			NorthBoundPort: nil,
+			SouthBoundPort: ponmap,
+		}, args{0}, res},
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			StatMgr := &OpenOltStatisticsMgr{
+				Device:         tt.fields.Device,
+				NorthBoundPort: tt.fields.NorthBoundPort,
+				SouthBoundPort: tt.fields.SouthBoundPort,
+			}
+			got := StatMgr.collectPONMetrics(tt.args.pID)
+			if reflect.TypeOf(got) != reflect.TypeOf(tt.want) {
+				t.Errorf("collectPONMetrics() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/internal/pkg/core/status.go b/internal/pkg/core/status.go
new file mode 100644
index 0000000..6a3181e
--- /dev/null
+++ b/internal/pkg/core/status.go
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2020-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package core
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v3/pkg/adapters/adapterif"
+	"github.com/opencord/voltha-openolt-adapter/internal/pkg/core/l2oam"
+)
+
+var startWatchStatus bool = false
+
+// WatchStatus ovserves the setting file is updated or not
+func WatchStatus(ctx context.Context, cp adapterif.CoreProxy) {
+	if startWatchStatus {
+		return
+	}
+	startWatchStatus = true
+	logger.Debug(ctx, "Start WatchStatus()")
+	ticker := time.NewTicker(1000 * time.Millisecond)
+	for range ticker.C {
+		onuList, err := l2oam.ReadOnuStatusList()
+		if err == nil {
+			for i, onu := range onuList {
+				if onu.RebootState == "reboot" {
+					logger.Debug(ctx, fmt.Sprintf("WatchStatus() reboot: %s", onu.ID))
+					// reboot flag is set to off immediately
+					onuList[i].RebootState = ""
+
+					// find onu using MAC address
+					onuDevice := FindL2oamDevice(onu.MacAddress)
+					if onuDevice == nil {
+						logger.Debug(ctx, fmt.Sprintf("WatchStatus() device not found: %s", onu.ID))
+						continue
+					}
+
+					// send Reset ONU message
+					if err := onuDevice.send(l2oam.GenerateSetResetOnu(l2oam.OnuPkgType)); err != nil {
+						continue
+					}
+					_, err := onuDevice.waitResponse(ResponseTimer)
+					if err != nil {
+						logger.Error(ctx, fmt.Sprintf("[%s] reset ONU Send Error: %v", onuDevice.getDeviceName(), err))
+						continue
+					}
+				}
+			}
+			if err := l2oam.WriteOnuStatusList(onuList); err != nil {
+				continue
+			}
+		}
+	}
+}