diff --git a/rw_core/core/device/agent.go b/rw_core/core/device/agent.go
index 38197e6..3bbebbc 100755
--- a/rw_core/core/device/agent.go
+++ b/rw_core/core/device/agent.go
@@ -22,6 +22,7 @@
 	"errors"
 	"fmt"
 	"reflect"
+	"strings"
 	"sync"
 	"time"
 
@@ -1796,3 +1797,383 @@
 	}
 	return fmt.Errorf("device-cannot-process-request-%s", agent.deviceID)
 }
+
+func (agent *Agent) disableOnuDevice(ctx context.Context, adapterEndpoint string) error {
+	var err error
+	var desc string
+	var prevAdminState, currAdminState common.AdminState_Types
+	requestStatus := &common.OperationResp{Code: common.OperationResp_OPERATION_FAILURE}
+
+	defer func() {
+		agent.logDeviceUpdate(ctx, &prevAdminState, &currAdminState, requestStatus, err, desc)
+	}()
+
+	if err = agent.requestQueue.WaitForGreenLight(ctx); err != nil {
+		desc = "Failed while waiting for green light"
+		return err
+	}
+	logger.Debugw(ctx, "disable-child-device", log.Fields{"device-id": agent.deviceID, "serial-number": agent.device.SerialNumber})
+
+	prevAdminState = agent.device.AdminState
+
+	cloned, desc, err := agent.checkDisableEligibility()
+	if err != nil {
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	cloned.AdminState = voltha.AdminState_DISABLED
+
+	client, err := agent.adapterMgr.GetAdapterClient(ctx, adapterEndpoint)
+	if err != nil {
+		logger.Errorw(ctx, "grpc-client-nil",
+			log.Fields{
+				"error":            err,
+				"device-id":        agent.deviceID,
+				"device-type":      agent.deviceType,
+				"adapter-endpoint": adapterEndpoint,
+			})
+		desc = fmt.Sprintf("failed to get adapter client for endpoint %s", adapterEndpoint)
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	subCtx, cancel := context.WithTimeout(coreutils.WithAllMetadataFromContext(ctx), agent.rpcTimeout)
+	defer cancel()
+	requestStatus.Code = common.OperationResp_OPERATION_IN_PROGRESS
+
+	resultCh := make(chan error, 1)
+
+	go func() {
+		if _, callErr := client.DisableOnuDevice(subCtx, cloned); callErr == nil {
+			logger.Infow(subCtx, "disable-child-device-success", log.Fields{"device-id": cloned.Id, "serial-number": cloned.SerialNumber})
+			agent.onSuccess(subCtx, nil, nil, true)
+			resultCh <- nil
+		} else {
+			logger.Errorw(subCtx, "disable-child-device-failed", log.Fields{"device-id": cloned.Id, "serial-number": cloned.SerialNumber, "error": callErr})
+			agent.onFailure(subCtx, callErr, nil, nil, true)
+			trimmedErr := extractLastRpcError(callErr)
+			desc = fmt.Sprintf("disableOnuDevice call failed: %s", trimmedErr)
+			resultCh <- fmt.Errorf("disable-child-device-failed: %s", trimmedErr)
+		}
+	}()
+
+	select {
+	case resultErr := <-resultCh:
+		if resultErr != nil {
+			agent.requestQueue.RequestComplete()
+			return resultErr
+		}
+	case <-ctx.Done():
+		err = fmt.Errorf("operation cancelled or timed out: %w", ctx.Err())
+		desc = "disable ONU device operation cancelled or timed out"
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	if updateErr := agent.updateDeviceAndReleaseLock(subCtx, cloned); updateErr != nil {
+		desc = "failed to update device after disabling ONU"
+		return fmt.Errorf("update-device-failed: %w", updateErr)
+	}
+
+	currAdminState = cloned.AdminState
+	return nil
+}
+
+func (agent *Agent) enableOnuDevice(ctx context.Context, adapterEndpoint string) error {
+	var err error
+	var desc string
+	var prevAdminState, currAdminState common.AdminState_Types
+	requestStatus := &common.OperationResp{Code: common.OperationResp_OPERATION_FAILURE}
+
+	defer func() { agent.logDeviceUpdate(ctx, &prevAdminState, &currAdminState, requestStatus, err, desc) }()
+
+	if err = agent.requestQueue.WaitForGreenLight(ctx); err != nil {
+		desc = "Failed while waiting for green light"
+		return err
+	}
+	logger.Debugw(ctx, "enable-child-device", log.Fields{"device-id": agent.deviceID, "serial-number": agent.device.SerialNumber})
+
+	prevAdminState = agent.device.AdminState
+
+	newDevice, desc, err := agent.checkEnableEligibility()
+	if err != nil {
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	// Update the Admin State and set the operational state to activating before sending the request to the Adapters
+	newDevice.AdminState = voltha.AdminState_ENABLED
+
+	client, err := agent.adapterMgr.GetAdapterClient(ctx, adapterEndpoint)
+	if err != nil {
+		logger.Errorw(ctx, "grpc-client-nil",
+			log.Fields{
+				"error":            err,
+				"device-id":        agent.deviceID,
+				"device-type":      agent.deviceType,
+				"adapter-endpoint": adapterEndpoint,
+			})
+
+		desc = fmt.Sprintf("failed to get adapter client for endpoint %s", adapterEndpoint)
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+	subCtx, cancel := context.WithTimeout(coreutils.WithAllMetadataFromContext(ctx), agent.rpcTimeout)
+	defer cancel()
+	requestStatus.Code = common.OperationResp_OPERATION_IN_PROGRESS
+
+	resultCh := make(chan error, 1)
+
+	go func() {
+		_, callErr := client.EnableOnuDevice(subCtx, newDevice)
+
+		if callErr == nil {
+			logger.Infow(subCtx, "enable-child-device-success", log.Fields{"device-id": newDevice.Id, "serial-number": newDevice.SerialNumber})
+			agent.onSuccess(subCtx, nil, nil, true)
+			resultCh <- nil
+		} else {
+			logger.Errorw(subCtx, "enable-child-device-failed", log.Fields{"device-id": newDevice.Id, "serial-number": newDevice.SerialNumber, "error": callErr})
+			agent.onFailure(subCtx, callErr, nil, nil, true)
+			trimmedErr := extractLastRpcError(callErr)
+			desc = fmt.Sprintf(" enableOnuDevice call failed: %s", trimmedErr)
+			resultCh <- fmt.Errorf("enable-child-device-failed: %s", trimmedErr)
+		}
+	}()
+
+	select {
+	case resultErr := <-resultCh:
+		if resultErr != nil {
+			agent.requestQueue.RequestComplete()
+			return resultErr
+		}
+	case <-ctx.Done():
+		err = fmt.Errorf("operation cancelled or timed out: %w", ctx.Err())
+		agent.requestQueue.RequestComplete()
+		desc = "enable ONU device operation cancelled or timed out"
+		return err
+	}
+
+	if updateErr := agent.updateDeviceAndReleaseLock(subCtx, newDevice); updateErr != nil {
+		desc = "failed to update device after enabling ONU"
+		return fmt.Errorf("update-device-failed: %w", updateErr)
+	}
+
+	currAdminState = newDevice.AdminState
+	return nil
+
+}
+
+func (agent *Agent) disableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon, adapterEndpoint string) error {
+	var err error
+	var desc string
+	var prevAdminState, currAdminState common.AdminState_Types
+	requestStatus := &common.OperationResp{Code: common.OperationResp_OPERATION_FAILURE}
+
+	defer func() {
+		agent.logDeviceUpdate(ctx, &prevAdminState, &currAdminState, requestStatus, err, desc)
+	}()
+
+	if err = agent.requestQueue.WaitForGreenLight(ctx); err != nil {
+		desc = "Failed while waiting for green light"
+		return err
+	}
+	logger.Debugw(ctx, "disable-child-serial-number", log.Fields{"device-id": agent.deviceID, "serial-number": agent.device.SerialNumber})
+
+	prevAdminState = agent.device.AdminState
+	cloned, desc, err := agent.checkDisableEligibility()
+	if err != nil {
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	cloned.AdminState = voltha.AdminState_DISABLED
+
+	client, err := agent.adapterMgr.GetAdapterClient(ctx, adapterEndpoint)
+	if err != nil {
+		logger.Errorw(ctx, "grpc-client-nil",
+			log.Fields{
+				"error":            err,
+				"device-id":        agent.deviceID,
+				"device-type":      agent.deviceType,
+				"adapter-endpoint": adapterEndpoint,
+			})
+
+		desc = fmt.Sprintf("failed to get adapter client for endpoint %s", adapterEndpoint)
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	subCtx, cancel := context.WithTimeout(coreutils.WithAllMetadataFromContext(ctx), agent.rpcTimeout)
+	defer cancel()
+	requestStatus.Code = common.OperationResp_OPERATION_IN_PROGRESS
+
+	resultCh := make(chan error, 1)
+
+	go func() {
+		_, callErr := client.DisableOnuSerialNumber(subCtx, device)
+		if callErr == nil {
+			logger.Infow(subCtx, "disable-child-serial-number-success", log.Fields{"device-id": cloned.Id, "serial-number": device.SerialNumber})
+			agent.onSuccess(subCtx, nil, nil, true)
+			resultCh <- nil
+		} else {
+			logger.Errorw(subCtx, "disable-child-serial-number-failed", log.Fields{"device-id": cloned.Id, "serial-number": device.SerialNumber, "error": callErr})
+			agent.onFailure(subCtx, callErr, nil, nil, true)
+			trimmedErr := extractLastRpcError(callErr)
+			desc = fmt.Sprintf("disableOnuSerialNumber call failed: %s", trimmedErr)
+			resultCh <- fmt.Errorf("disable-child-serial-number-failed: %s", trimmedErr)
+		}
+	}()
+
+	select {
+	case resultErr := <-resultCh:
+		if resultErr != nil {
+			agent.requestQueue.RequestComplete()
+			return resultErr
+		}
+
+	case <-ctx.Done():
+		err = fmt.Errorf("operation cancelled or timed out: %w", ctx.Err())
+		agent.requestQueue.RequestComplete()
+		desc = "disable ONU serial number operation cancelled or timed out"
+		return err
+	}
+
+	if updateErr := agent.updateDeviceAndReleaseLock(subCtx, cloned); updateErr != nil {
+		desc = "failed to update device after disabling ONU serial number"
+		return fmt.Errorf("update-device-failed: %w", updateErr)
+	}
+	currAdminState = cloned.AdminState
+	return nil
+
+}
+
+func (agent *Agent) enableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon, adapterEndpoint string) error {
+	var err error
+	var desc string
+	var cloned *voltha.Device
+	var prevAdminState, currAdminState common.AdminState_Types
+	requestStatus := &common.OperationResp{Code: common.OperationResp_OPERATION_FAILURE}
+
+	defer func() {
+		agent.logDeviceUpdate(ctx, &prevAdminState, &currAdminState, requestStatus, err, desc)
+	}()
+
+	if err = agent.requestQueue.WaitForGreenLight(ctx); err != nil {
+		desc = "Failed while waiting for green light"
+		return err
+	}
+	logger.Debugw(ctx, "enable-child-serial-number", log.Fields{"serial-number": device.SerialNumber})
+
+	prevAdminState = agent.device.AdminState
+	cloned, desc, err = agent.checkEnableEligibility()
+	if err != nil {
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	cloned.AdminState = voltha.AdminState_ENABLED
+
+	client, err := agent.adapterMgr.GetAdapterClient(ctx, adapterEndpoint)
+	if err != nil {
+		logger.Errorw(ctx, "grpc-client-nil",
+			log.Fields{
+				"error":            err,
+				"device-id":        agent.deviceID,
+				"device-type":      agent.deviceType,
+				"adapter-endpoint": agent.adapterEndpoint,
+			})
+
+		desc = fmt.Sprintf("failed to get adapter client for endpoint %s", adapterEndpoint)
+		agent.requestQueue.RequestComplete()
+		return err
+	}
+
+	subCtx, cancel := context.WithTimeout(coreutils.WithAllMetadataFromContext(ctx), agent.rpcTimeout)
+	defer cancel()
+	requestStatus.Code = common.OperationResp_OPERATION_IN_PROGRESS
+
+	resultCh := make(chan error, 1)
+
+	go func() {
+		_, callErr := client.EnableOnuSerialNumber(subCtx, device)
+		if callErr == nil {
+			logger.Infow(subCtx, "enable-child-serial-number-success", log.Fields{"serial number": device.SerialNumber})
+			agent.onSuccess(subCtx, nil, nil, true)
+			resultCh <- nil
+		} else {
+			logger.Errorw(subCtx, "enable-child-serial-number-failed", log.Fields{"serial number": device.SerialNumber, "error": callErr})
+			agent.onFailure(subCtx, callErr, nil, nil, true)
+			trimmedErr := extractLastRpcError(callErr)
+			desc = fmt.Sprintf("enableOnuSerialNumber call failed: %s", trimmedErr)
+			resultCh <- fmt.Errorf("enable-child-serial-number-failed: %s", trimmedErr)
+		}
+	}()
+
+	select {
+	case resultErr := <-resultCh:
+		if resultErr != nil {
+			agent.requestQueue.RequestComplete()
+			return resultErr
+		}
+
+	case <-ctx.Done():
+		err = fmt.Errorf("operation cancelled or timed out: %w", ctx.Err())
+		agent.requestQueue.RequestComplete()
+		desc = "enable ONU serial number operation cancelled or timed out"
+		return err
+	}
+
+	if updateErr := agent.updateDeviceAndReleaseLock(subCtx, cloned); updateErr != nil {
+		desc = "failed to update device after enabling ONU serial number"
+		return fmt.Errorf("update-device-failed: %w", updateErr)
+	}
+	currAdminState = cloned.AdminState
+	return nil
+}
+
+func (agent *Agent) checkDisableEligibility() (*voltha.Device, string, error) {
+	cloned := agent.cloneDeviceWithoutLock()
+
+	if !agent.proceedWithRequest(cloned) {
+		err := status.Errorf(codes.FailedPrecondition, "cannot complete operation as device deletion is in progress/failed: %s", agent.deviceID)
+		return nil, "device-deletion-in-progress", err
+	}
+
+	if cloned.AdminState == voltha.AdminState_DISABLED {
+		err := status.Errorf(codes.FailedPrecondition, "device-already-disabled: %s", agent.deviceID)
+		return nil, "device-already-disabled", err
+	}
+	if cloned.AdminState == voltha.AdminState_PREPROVISIONED {
+		err := status.Errorf(codes.FailedPrecondition, "deviceId:%s, invalid-admin-state:%s", agent.deviceID, cloned.AdminState)
+		return nil, "invalid-admin-state", err
+	}
+
+	return cloned, "", nil
+}
+
+func (agent *Agent) checkEnableEligibility() (*voltha.Device, string, error) {
+	device := agent.getDeviceReadOnlyWithoutLock()
+
+	if !agent.proceedWithRequest(device) {
+		err := status.Errorf(codes.FailedPrecondition, "cannot complete operation as device deletion is in progress or reconciling is in progress/failed: %s", agent.deviceID)
+		return nil, "device-deletion-in-progress", err
+	}
+
+	if device.AdminState == voltha.AdminState_ENABLED && device.OperStatus != voltha.OperStatus_FAILED {
+		err := status.Errorf(codes.FailedPrecondition, "device-already-enabled: %s", device.Id)
+		return nil, "device-already-enabled", err
+	}
+
+	cloned := agent.cloneDeviceWithoutLock()
+	return cloned, "", nil
+}
+
+// extracting only the error message from the rpc error
+func extractLastRpcError(err error) string {
+	s := err.Error()
+	if i := strings.LastIndex(s, "rpc error:"); i >= 0 {
+		return strings.TrimSpace(s[i:])
+	}
+	return s
+}
diff --git a/rw_core/core/device/manager.go b/rw_core/core/device/manager.go
index 0b5df56..e39d822 100755
--- a/rw_core/core/device/manager.go
+++ b/rw_core/core/device/manager.go
@@ -881,3 +881,20 @@
 	logger.Errorw(ctx, "restarted-adapter-not-found", log.Fields{"endpoint": endpoint})
 	return fmt.Errorf("restarted adapter at endpoint %s not found", endpoint)
 }
+
+func (dMgr *Manager) GetOnuDeviceIdBySerial(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (string, error) {
+	var onuDeviceId string
+	dMgr.deviceAgents.Range(func(key, value interface{}) bool {
+		devAgent := value.(*Agent)
+		dev := devAgent.device
+		if dev.SerialNumber == device.GetSerialNumber() && dev.ParentId == device.GetOltDeviceId().Id {
+			onuDeviceId = dev.Id
+			return false
+		}
+		return true
+	})
+	if onuDeviceId != "" {
+		return onuDeviceId, nil
+	}
+	return "", fmt.Errorf("ONU with serial %s not found under OLT %s", device.GetSerialNumber(), device.GetOltDeviceId().Id)
+}
diff --git a/rw_core/core/device/manager_nbi.go b/rw_core/core/device/manager_nbi.go
index 1e0da90..2a8aeb8 100644
--- a/rw_core/core/device/manager_nbi.go
+++ b/rw_core/core/device/manager_nbi.go
@@ -951,3 +951,84 @@
 func (dMgr *Manager) DeleteVoipSystemProfile(ctx context.Context, key *common.Key) (*empty.Empty, error) {
 	return nil, status.Error(codes.Unimplemented, "delete-voip-system-profile-not-implemented")
 }
+
+func (dMgr *Manager) DisableOnuDevice(ctx context.Context, id *voltha.ID) (*empty.Empty, error) {
+	ctx = utils.WithRPCMetadataContext(ctx, "DisableOnuDevice")
+	log.EnrichSpan(ctx, log.Fields{"device-id": id.Id})
+
+	logger.Info(ctx, "disable-child-device", log.Fields{"device-id": id.Id})
+	agent := dMgr.getDeviceAgent(ctx, id.Id)
+	if agent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", id.Id)
+	}
+
+	oltAgent := dMgr.getDeviceAgent(ctx, agent.device.ParentId)
+	if oltAgent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", agent.device.ParentId)
+	}
+	logger.Debugw(ctx, "serial-no to be diabled", log.Fields{"serial-number": agent.device.SerialNumber})
+	return &empty.Empty{}, agent.disableOnuDevice(ctx, oltAgent.adapterEndpoint)
+}
+
+func (dMgr *Manager) EnableOnuDevice(ctx context.Context, id *voltha.ID) (*empty.Empty, error) {
+	ctx = utils.WithRPCMetadataContext(ctx, "EnableOnuDevice")
+	log.EnrichSpan(ctx, log.Fields{"device-id": id.Id})
+
+	logger.Info(ctx, "enable-child-device", log.Fields{"device-id": id.Id})
+	agent := dMgr.getDeviceAgent(ctx, id.Id)
+	if agent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", id.Id)
+	}
+
+	oltAgent := dMgr.getDeviceAgent(ctx, agent.device.ParentId)
+	if oltAgent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", agent.device.ParentId)
+	}
+	logger.Debugw(ctx, "serial-no to be enabled", log.Fields{"serial-number": agent.device.SerialNumber})
+	return &empty.Empty{}, agent.enableOnuDevice(ctx, oltAgent.adapterEndpoint)
+}
+
+func (dMgr *Manager) DisableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	ctx = utils.WithRPCMetadataContext(ctx, "DisableOnuSerialNumber")
+	log.EnrichSpan(ctx, log.Fields{"device-id": device.OltDeviceId})
+
+	logger.Infow(ctx, "disable-child serial number", log.Fields{"device-id": device.OltDeviceId, "serial-number": device.SerialNumber, "pon-port": device.Port})
+	oltAgent := dMgr.getDeviceAgent(ctx, device.OltDeviceId.GetId())
+	if oltAgent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", device.OltDeviceId)
+	}
+
+	onuDeviceID, err := dMgr.GetOnuDeviceIdBySerial(ctx, device)
+	if err != nil {
+		return nil, status.Errorf(codes.NotFound, "onu-device-id-not-found-for-serial-number-%s", device.SerialNumber)
+	}
+
+	agent := dMgr.getDeviceAgent(ctx, onuDeviceID)
+	if agent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", onuDeviceID)
+	}
+	return &empty.Empty{}, agent.disableOnuSerialNumber(ctx, device, oltAgent.adapterEndpoint)
+}
+
+func (dMgr *Manager) EnableOnuSerialNumber(ctx context.Context, device *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	ctx = utils.WithRPCMetadataContext(ctx, "EnableOnuSerialNumber")
+	log.EnrichSpan(ctx, log.Fields{"device-id": device.OltDeviceId})
+
+	logger.Info(ctx, "enable-child serial number", log.Fields{"device-id": device.OltDeviceId, "serial-number": device.SerialNumber, "pon-port": device.Port})
+	oltAgent := dMgr.getDeviceAgent(ctx, device.OltDeviceId.GetId())
+	if oltAgent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", device.OltDeviceId)
+	}
+
+	onuDeviceID, err := dMgr.GetOnuDeviceIdBySerial(ctx, device)
+	if err != nil {
+		return nil, status.Errorf(codes.NotFound, "onu-device-id-not-found-for-serial-number-%s", device.SerialNumber)
+	}
+
+	agent := dMgr.getDeviceAgent(ctx, onuDeviceID)
+	if agent == nil {
+		return nil, status.Errorf(codes.NotFound, "%s", onuDeviceID)
+	}
+
+	return &empty.Empty{}, agent.enableOnuSerialNumber(ctx, device, oltAgent.adapterEndpoint)
+}
diff --git a/rw_core/mocks/adapter_olt.go b/rw_core/mocks/adapter_olt.go
index 65c5503..9d4a4a6 100644
--- a/rw_core/mocks/adapter_olt.go
+++ b/rw_core/mocks/adapter_olt.go
@@ -489,3 +489,19 @@
 	}
 
 }
+
+func (onuA *OLTAdapter) DisableOnuSerialNumber(ctx context.Context, in *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *OLTAdapter) EnableOnuSerialNumber(ctx context.Context, in *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *OLTAdapter) DisableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *OLTAdapter) EnableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
diff --git a/rw_core/mocks/adapter_onu.go b/rw_core/mocks/adapter_onu.go
index b7309f6..c2e5a8f 100644
--- a/rw_core/mocks/adapter_onu.go
+++ b/rw_core/mocks/adapter_onu.go
@@ -338,3 +338,19 @@
 	logger.Errorw(ctx, "connection-down", log.Fields{"remote-client": remoteClient, "error": err, "initial-conn-time": initialRequestTime})
 	return err
 }
+
+func (onuA *ONUAdapter) DisableOnuSerialNumber(ctx context.Context, in *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *ONUAdapter) EnableOnuSerialNumber(ctx context.Context, in *voltha.OnuSerialNumberOnOLTPon) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *ONUAdapter) DisableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}
+
+func (onuA *ONUAdapter) EnableOnuDevice(ctx context.Context, device *voltha.Device) (*empty.Empty, error) {
+	return &empty.Empty{}, nil
+}