diff --git a/internal/pkg/config/config.go b/internal/pkg/config/config.go
index fad08fa..c4ab249 100644
--- a/internal/pkg/config/config.go
+++ b/internal/pkg/config/config.go
@@ -66,7 +66,9 @@
 	defaultMibAuditInterval   = 0
 	defaultAlarmAuditInterval = 300 * time.Second
 
-	defaultOmciTimeout = 3 * time.Second
+	defaultOmciTimeout          = 3 * time.Second
+	defaultDlToAdapterTimeout   = 10 * time.Second
+	defaultDlToOnuTimeoutPer4MB = 60 * time.Minute //assumed for 4 MB of the image
 )
 
 // AdapterFlags represents the set of configurations used by the read-write adaptercore service
@@ -105,6 +107,8 @@
 	MibAuditInterval            time.Duration
 	OmciTimeout                 time.Duration
 	AlarmAuditInterval          time.Duration
+	DownloadToAdapterTimeout    time.Duration
+	DownloadToOnuTimeout4MB     time.Duration
 }
 
 // NewAdapterFlags returns a new RWCore config
@@ -143,6 +147,8 @@
 		MibAuditInterval:            defaultMibAuditInterval,
 		AlarmAuditInterval:          defaultAlarmAuditInterval,
 		OmciTimeout:                 defaultOmciTimeout,
+		DownloadToAdapterTimeout:    defaultDlToAdapterTimeout,
+		DownloadToOnuTimeout4MB:     defaultDlToOnuTimeoutPer4MB,
 	}
 	return &adapterFlags
 }
@@ -150,104 +156,110 @@
 // ParseCommandArguments parses the arguments when running read-write adaptercore service
 func (so *AdapterFlags) ParseCommandArguments() {
 
-	help := fmt.Sprintf("Kafka - Adapter messaging address")
+	help := "Kafka - Adapter messaging address"
 	flag.StringVar(&(so.KafkaAdapterAddress), "kafka_adapter_address", defaultKafkaadapteraddress, help)
 
-	help = fmt.Sprintf("Kafka - Cluster messaging address")
+	help = "Kafka - Cluster messaging address"
 	flag.StringVar(&(so.KafkaClusterAddress), "kafka_cluster_address", defaultKafkaclusteraddress, help)
 
-	help = fmt.Sprintf("Open ONU topic")
+	help = "Open ONU topic"
 	baseAdapterTopic := flag.String("adapter_topic", defaultTopic, help)
 
-	help = fmt.Sprintf("Core topic")
+	help = "Core topic"
 	flag.StringVar(&(so.CoreTopic), "core_topic", defaultCoreTopic, help)
 
-	help = fmt.Sprintf("Event topic")
+	help = "Event topic"
 	flag.StringVar(&(so.EventTopic), "event_topic", defaultEventTopic, help)
 
-	help = fmt.Sprintf("KV store type")
+	help = "KV store type"
 	flag.StringVar(&(so.KVStoreType), "kv_store_type", defaultKvstoretype, help)
 
-	help = fmt.Sprintf("The default timeout when making a kv store request")
+	help = "The default timeout when making a kv store request"
 	flag.DurationVar(&(so.KVStoreTimeout), "kv_store_request_timeout", defaultKvstoretimeout, help)
 
-	help = fmt.Sprintf("KV store address")
+	help = "KV store address"
 	flag.StringVar(&(so.KVStoreAddress), "kv_store_address", defaultKvstoreaddress, help)
 
-	help = fmt.Sprintf("Log level")
+	help = "Log level"
 	flag.StringVar(&(so.LogLevel), "log_level", defaultLoglevel, help)
 
-	help = fmt.Sprintf("Number of ONUs")
+	help = "Number of ONUs"
 	flag.IntVar(&(so.OnuNumber), "onu_number", defaultOnunumber, help)
 
-	help = fmt.Sprintf("Show startup banner log lines")
+	help = "Show startup banner log lines"
 	flag.BoolVar(&(so.Banner), "banner", defaultBanner, help)
 
-	help = fmt.Sprintf("Show version information and exit")
+	help = "Show version information and exit"
 	flag.BoolVar(&(so.DisplayVersionOnly), "version", defaultDisplayVersionOnly, help)
 
-	help = fmt.Sprintf("Acceptance of incremental EVTOCD configuration")
+	help = "Acceptance of incremental EVTOCD configuration"
 	flag.BoolVar(&(so.AccIncrEvto), "accept_incr_evto", defaultAccIncrEvto, help)
 
-	help = fmt.Sprintf("The address on which to listen to answer liveness and readiness probe queries over HTTP.")
+	help = "The address on which to listen to answer liveness and readiness probe queries over HTTP"
 	flag.StringVar(&(so.ProbeHost), "probe_host", defaultProbeHost, help)
 
-	help = fmt.Sprintf("The port on which to listen to answer liveness and readiness probe queries over HTTP.")
+	help = "The port on which to listen to answer liveness and readiness probe queries over HTTP"
 	flag.IntVar(&(so.ProbePort), "probe_port", defaultProbePort, help)
 
-	help = fmt.Sprintf("Number of seconds for the default liveliness check")
+	help = "Number of seconds for the default liveliness check"
 	flag.DurationVar(&(so.LiveProbeInterval), "live_probe_interval", defaultLiveProbeInterval, help)
 
-	help = fmt.Sprintf("Number of seconds for liveliness check if probe is not running")
+	help = "Number of seconds for liveliness check if probe is not running"
 	flag.DurationVar(&(so.NotLiveProbeInterval), "not_live_probe_interval", defaultNotLiveProbeInterval, help)
 
-	help = fmt.Sprintf("Number of seconds for heartbeat check interval.")
+	help = "Number of seconds for heartbeat check interval"
 	flag.DurationVar(&(so.HeartbeatCheckInterval), "hearbeat_check_interval", defaultHearbeatCheckInterval, help)
 
-	help = fmt.Sprintf("Number of seconds adapter has to wait before reporting core on the hearbeat check failure.")
+	help = "Number of seconds adapter has to wait before reporting core on the hearbeat check failure"
 	flag.DurationVar(&(so.HeartbeatFailReportInterval), "hearbeat_fail_interval", defaultHearbeatFailReportInterval, help)
 
-	help = fmt.Sprintf("Number of retries to connect to Kafka.")
+	help = "Number of retries to connect to Kafka"
 	flag.IntVar(&(so.KafkaReconnectRetries), "kafka_reconnect_retries", defaultKafkaReconnectRetries, help)
 
-	help = "Replica number of this particular instance (default: %s)"
+	help = "Replica number of this particular instance"
 	flag.IntVar(&(so.CurrentReplica), "current_replica", defaultCurrentReplica, help)
 
 	help = "Total number of instances for this adapter"
 	flag.IntVar(&(so.TotalReplicas), "total_replica", defaultTotalReplicas, help)
 
-	help = fmt.Sprintf("Maximum Number of seconds for the default interadapter communication timeout")
+	help = "Maximum Number of seconds for the default interadapter communication timeout"
 	flag.DurationVar(&(so.MaxTimeoutInterAdapterComm), "max_timeout_interadapter_comm",
 		defaultMaxTimeoutInterAdapterComm, help)
 
-	help = fmt.Sprintf("Maximum Number of seconds for the default ONU reconciling timeout")
+	help = "Maximum Number of seconds for the default ONU reconciling timeout"
 	flag.DurationVar(&(so.MaxTimeoutReconciling), "max_timeout_reconciling",
 		defaultMaxTimeoutReconciling, help)
 
-	help = fmt.Sprintf("Whether to send logs to tracing agent?")
+	help = "Whether to send logs to tracing agent"
 	flag.BoolVar(&(so.TraceEnabled), "trace_enabled", defaultTraceEnabled, help)
 
-	help = fmt.Sprintf("The address of tracing agent to which span info should be sent.")
+	help = "The address of tracing agent to which span info should be sent"
 	flag.StringVar(&(so.TraceAgentAddress), "trace_agent_address", defaultTraceAgentAddress, help)
 
-	help = fmt.Sprintf("Whether to enrich log statements with fields denoting operation being executed for achieving correlation?")
+	help = "Whether to enrich log statements with fields denoting operation being executed for achieving correlation"
 	flag.BoolVar(&(so.LogCorrelationEnabled), "log_correlation_enabled", defaultLogCorrelationEnabled, help)
 
-	help = fmt.Sprintf("List of Allowed ONU Vendor Ids")
+	help = "List of Allowed ONU Vendor Ids"
 	flag.StringVar(&(so.OnuVendorIds), "allowed_onu_vendors", defaultOnuVendorIds, help)
 
-	help = fmt.Sprintf("Whether to enable metrics collection")
+	help = "Whether to enable metrics collection"
 	flag.BoolVar(&(so.MetricsEnabled), "metrics_enabled", defaultMetricsEnabled, help)
 
-	help = fmt.Sprintf("Mib Audit Interval in seconds - the value zero will disable Mib Audit")
+	help = "Mib Audit Interval in seconds - the value zero will disable Mib Audit"
 	flag.DurationVar(&(so.MibAuditInterval), "mib_audit_interval", defaultMibAuditInterval, help)
 
-	help = fmt.Sprintf("OMCI timeout duration - this timeout value is used on the OMCI channel for waiting on response from ONU")
+	help = "OMCI timeout duration - this timeout value is used on the OMCI channel for waiting on response from ONU"
 	flag.DurationVar(&(so.OmciTimeout), "omci_timeout", defaultOmciTimeout, help)
 
-	help = fmt.Sprintf("Alarm Audit Interval in seconds - the value zero will disable alarm audit")
+	help = "Alarm Audit Interval in seconds - the value zero will disable alarm audit"
 	flag.DurationVar(&(so.AlarmAuditInterval), "alarm_audit_interval", defaultAlarmAuditInterval, help)
 
+	help = "File download to adapter timeout in seconds"
+	flag.DurationVar(&(so.DownloadToAdapterTimeout), "download_to_adapter_timeout", defaultDlToAdapterTimeout, help)
+
+	help = "File download to ONU timeout in minutes for a block of 4MB"
+	flag.DurationVar(&(so.DownloadToOnuTimeout4MB), "download_to_onu_timeout_4MB", defaultDlToOnuTimeoutPer4MB, help)
+
 	flag.Parse()
 	containerName := getContainerInfo()
 	if len(containerName) > 0 {
diff --git a/internal/pkg/onuadaptercore/device_handler.go b/internal/pkg/onuadaptercore/device_handler.go
index 07fa67b..fc29ac2 100644
--- a/internal/pkg/onuadaptercore/device_handler.go
+++ b/internal/pkg/onuadaptercore/device_handler.go
@@ -1100,6 +1100,182 @@
 	return err
 }
 
+//onuSwUpgradeAfterDownload initiates the SW download transfer to the ONU with activate and commit options
+// after the OnuImage has been downloaded to the adapter, called in background
+func (dh *deviceHandler) onuSwUpgradeAfterDownload(ctx context.Context, apImageRequest *voltha.DeviceImageDownloadRequest,
+	apDownloadManager *fileDownloadManager, aImageIdentifier string) {
+
+	var err error
+	pDevEntry := dh.getOnuDeviceEntry(ctx, true)
+	if pDevEntry == nil {
+		logger.Errorw(ctx, "start Onu SW upgrade rejected: no valid OnuDevice", log.Fields{"device-id": dh.deviceID})
+		return
+	}
+
+	var inactiveImageID uint16
+	if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err == nil {
+		logger.Debugw(ctx, "onuSwUpgrade requested", log.Fields{
+			"device-id": dh.deviceID, "image-version": apImageRequest.Image.Version, "to onu-image": inactiveImageID})
+		dh.lockUpgradeFsm.Lock()
+		defer dh.lockUpgradeFsm.Unlock()
+		if dh.pOnuUpradeFsm == nil {
+			//OmciOnuSwUpgradeDone could be used to create some Kafka event with information on upgrade completion,
+			//  but none yet defined
+			err = dh.createOnuUpgradeFsm(ctx, pDevEntry, OmciOnuSwUpgradeDone)
+			if err == nil {
+				if err = dh.pOnuUpradeFsm.SetDownloadParamsAfterDownload(ctx, inactiveImageID,
+					apImageRequest, apDownloadManager, aImageIdentifier, dh.pOpenOnuAc.dlToOnuTimeout4M); err != nil {
+					logger.Errorw(ctx, "onu upgrade fsm could not set parameters", log.Fields{
+						"device-id": dh.deviceID, "error": err})
+					return
+				}
+			} else {
+				logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
+					"device-id": dh.deviceID, "error": err})
+			}
+			return
+		}
+		//OnuSw upgrade already running - restart (with possible abort of running)
+		logger.Debugw(ctx, "Onu SW upgrade already running - abort", log.Fields{"device-id": dh.deviceID})
+		pUpgradeStatemachine := dh.pOnuUpradeFsm.pAdaptFsm.pFsm
+		if pUpgradeStatemachine != nil {
+			if err = pUpgradeStatemachine.Event(upgradeEvAbort); err != nil {
+				logger.Errorw(ctx, "onu upgrade fsm could not abort a running processing", log.Fields{
+					"device-id": dh.deviceID, "error": err})
+				return
+			}
+			//TODO!!!: wait for 'ready' to start and configure - see above SetDownloadParams()
+			// for now a second start of download should work again - must still be initiated by user
+		} else { //should never occur
+			logger.Errorw(ctx, "onu upgrade fsm inconsistent setup", log.Fields{
+				"device-id": dh.deviceID})
+		}
+		return
+	}
+	logger.Errorw(ctx, "start Onu SW upgrade rejected: no inactive image", log.Fields{
+		"device-id": dh.deviceID, "error": err})
+}
+
+//onuSwActivateRequest ensures activation of the requested image with commit options
+func (dh *deviceHandler) onuSwActivateRequest(ctx context.Context, aVersion string, aCommitRequest bool) {
+	var err error
+	//SW activation for the ONU image may have two use cases, one of them is selected here according to following prioritization:
+	//  1.) activation of the image for a started upgrade process (in case the running upgrade runs on the requested image)
+	//  2.) activation of the inactive image
+
+	pDevEntry := dh.getOnuDeviceEntry(ctx, true)
+	if pDevEntry == nil {
+		logger.Errorw(ctx, "Onu image activation rejected: no valid OnuDevice", log.Fields{"device-id": dh.deviceID})
+		return
+	}
+	dh.lockUpgradeFsm.RLock()
+	if dh.pOnuUpradeFsm != nil {
+		dh.lockUpgradeFsm.RUnlock()
+		onuVolthaDevice, getErr := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx),
+			dh.deviceID, dh.deviceID)
+		if getErr != nil || onuVolthaDevice == nil {
+			logger.Errorw(ctx, "Failed to fetch Onu device for image activation", log.Fields{"device-id": dh.deviceID, "err": getErr})
+			return
+		}
+		//  use the OnuVendor identification from this device for the internal unique name
+		imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU
+		// 1.) check a started upgrade process and rely the activation request to it
+		if err = dh.pOnuUpradeFsm.SetActivationParamsRunning(ctx, imageIdentifier, aCommitRequest); err != nil {
+			logger.Errorw(ctx, "onu upgrade fsm did not accept activation while running", log.Fields{
+				"device-id": dh.deviceID, "error": err})
+		} else {
+			logger.Debugw(ctx, "image activation acknowledged by onu upgrade processing", log.Fields{
+				"device-id": dh.deviceID, "image-id": imageIdentifier})
+		}
+		//if some ONU upgrade is ongoing we do not accept some explicit ONU image-version related activation
+		//   (even though parameter setting is not accepted)
+		return
+	} //else
+	dh.lockUpgradeFsm.RUnlock()
+
+	// 2.) check if requested image-version equals the inactive one and start its activation
+	//   (image version is not [yet] checked - would be possible, but with increased effort ...)
+	var inactiveImageID uint16
+	if inactiveImageID, err = pDevEntry.GetInactiveImageMeID(ctx); err != nil || inactiveImageID > 1 {
+		logger.Errorw(ctx, "get inactive image failed", log.Fields{
+			"device-id": dh.deviceID, "err": err, "image-id": inactiveImageID})
+		return
+	}
+	err = dh.createOnuUpgradeFsm(ctx, pDevEntry, OmciOnuSwUpgradeDone)
+	if err == nil {
+		if err = dh.pOnuUpradeFsm.SetActivationParamsStart(ctx, aVersion,
+			inactiveImageID, aCommitRequest); err != nil {
+			logger.Errorw(ctx, "onu upgrade fsm did not accept activation to start", log.Fields{
+				"device-id": dh.deviceID, "error": err})
+			return
+		}
+		logger.Debugw(ctx, "inactive image activation acknowledged by onu upgrade", log.Fields{
+			"device-id": dh.deviceID, "image-version": aVersion})
+		return
+	} //else
+	logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
+		"device-id": dh.deviceID, "error": err})
+}
+
+//onuSwCommitRequest ensures commitment of the requested image
+func (dh *deviceHandler) onuSwCommitRequest(ctx context.Context, aVersion string) {
+	var err error
+	//SW commitment for the ONU image may have two use cases, one of them is selected here according to following prioritization:
+	//  1.) commitment of the image for a started upgrade process (in case the running upgrade runs on the requested image)
+	//  2.) commitment of the active image
+
+	pDevEntry := dh.getOnuDeviceEntry(ctx, true)
+	if pDevEntry == nil {
+		logger.Errorw(ctx, "Onu image commitment rejected: no valid OnuDevice", log.Fields{"device-id": dh.deviceID})
+		return
+	}
+	dh.lockUpgradeFsm.RLock()
+	if dh.pOnuUpradeFsm != nil {
+		dh.lockUpgradeFsm.RUnlock()
+		onuVolthaDevice, getErr := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx),
+			dh.deviceID, dh.deviceID)
+		if getErr != nil || onuVolthaDevice == nil {
+			logger.Errorw(ctx, "Failed to fetch Onu device for image commitment", log.Fields{"device-id": dh.deviceID, "err": getErr})
+			return
+		}
+		//  use the OnuVendor identification from this device for the internal unique name
+		imageIdentifier := onuVolthaDevice.VendorId + aVersion //head on vendor ID of the ONU
+		// 1.) check a started upgrade process and rely the commitment request to it
+		if err = dh.pOnuUpradeFsm.SetCommitmentParamsRunning(ctx, imageIdentifier); err != nil {
+			logger.Errorw(ctx, "onu upgrade fsm did not accept commitment while running", log.Fields{
+				"device-id": dh.deviceID, "error": err})
+		} else {
+			logger.Debugw(ctx, "image commitment acknowledged by onu upgrade processing", log.Fields{
+				"device-id": dh.deviceID, "image-id": imageIdentifier})
+		}
+		//if some ONU upgrade is ongoing we do not accept some explicit ONU image-version related commitment
+		//   (even though parameter setting is not accepted)
+		return
+	} //else
+	dh.lockUpgradeFsm.RUnlock()
+
+	// 2.) check if requested image-version equals the inactive one and start its commitment
+	var activeImageID uint16
+	if activeImageID, err = pDevEntry.GetActiveImageMeID(ctx); err != nil || activeImageID > 1 {
+		logger.Errorw(ctx, "get active image failed", log.Fields{
+			"device-id": dh.deviceID, "err": err, "image-id": activeImageID})
+		return
+	}
+	err = dh.createOnuUpgradeFsm(ctx, pDevEntry, OmciOnuSwUpgradeDone)
+	if err == nil {
+		if err = dh.pOnuUpradeFsm.SetCommitmentParamsStart(ctx, aVersion, activeImageID); err != nil {
+			logger.Errorw(ctx, "onu upgrade fsm did not accept commitment to start", log.Fields{
+				"device-id": dh.deviceID, "error": err})
+			return
+		}
+		logger.Debugw(ctx, "active image commitment acknowledged by onu upgrade", log.Fields{
+			"device-id": dh.deviceID, "image-version": aVersion})
+		return
+	} //else
+	logger.Errorw(ctx, "onu upgrade fsm could not be created", log.Fields{
+		"device-id": dh.deviceID, "error": err})
+}
+
 //  deviceHandler methods that implement the adapters interface requests## end #########
 // #####################################################################################
 
@@ -1731,18 +1907,10 @@
 	}
 
 	//reset a possibly running upgrade FSM
-	// specific here: If the FSM is in upgradeStWaitForCommit, it is left there for possibly later commit
-	// this possibly also refers later to (not yet existing) upgradeStWaitForActivate (with ctl API changes)
+	//  (note the Upgrade FSM may stay alive e.g. in state upgradeStWaitForCommit to endure the ONU reboot)
 	dh.lockUpgradeFsm.RLock()
 	if dh.pOnuUpradeFsm != nil {
-		pUpgradeStatemachine := dh.pOnuUpradeFsm.pAdaptFsm.pFsm
-		if pUpgradeStatemachine != nil {
-			if pUpgradeStatemachine.Is(upgradeStWaitEndDL) {
-				dh.pOnuUpradeFsm.chReceiveExpectedResponse <- false //which aborts the FSM (activate was not yet sent)
-			}
-			_ = pUpgradeStatemachine.Event(upgradeEvReset) //anyway and for all other states
-		}
-		//else the FSM seems already to be in some released state
+		dh.pOnuUpradeFsm.CancelProcessing(ctx)
 	}
 	dh.lockUpgradeFsm.RUnlock()
 
diff --git a/internal/pkg/onuadaptercore/file_download_manager.go b/internal/pkg/onuadaptercore/file_download_manager.go
new file mode 100644
index 0000000..0658c6f
--- /dev/null
+++ b/internal/pkg/onuadaptercore/file_download_manager.go
@@ -0,0 +1,350 @@
+/*
+ * 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 adaptercoreonu provides the utility for onu devices, flows and statistics
+package adaptercoreonu
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/opencord/voltha-lib-go/v4/pkg/log"
+)
+
+const cDefaultLocalDir = "/tmp" //this is the default local dir to download to
+
+type fileState uint32
+
+//nolint:varcheck, deadcode
+const (
+	cFileStateUnknown fileState = iota
+	cFileStateDlStarted
+	cFileStateDlSucceeded
+	cFileStateDlFailed
+	cFileStateDlAborted
+	cFileStateDlInvalid
+)
+
+type downloadImageParams struct {
+	downloadImageName  string
+	downloadImageState fileState
+	downloadImageLen   int64
+	downloadImageCrc   uint32
+}
+
+type requesterChannelMap map[chan<- bool]struct{} //using an empty structure map for easier (unique) element appending
+
+//fileDownloadManager structure holds information needed for downloading to and storing images within the adapter
+type fileDownloadManager struct {
+	mutexDownloadImageDsc sync.RWMutex
+	downloadImageDscSlice []downloadImageParams
+	dnldImgReadyWaiting   map[string]requesterChannelMap
+	dlToAdapterTimeout    time.Duration
+}
+
+//newFileDownloadManager constructor returns a new instance of a fileDownloadManager
+//mib_db (as well as not inluded alarm_db not really used in this code? VERIFY!!)
+func newFileDownloadManager(ctx context.Context) *fileDownloadManager {
+	logger.Debug(ctx, "init-fileDownloadManager")
+	var localDnldMgr fileDownloadManager
+	localDnldMgr.downloadImageDscSlice = make([]downloadImageParams, 0)
+	localDnldMgr.dnldImgReadyWaiting = make(map[string]requesterChannelMap)
+	localDnldMgr.dlToAdapterTimeout = 10 * time.Second //default timeout, should be overwritten immediately after start
+	return &localDnldMgr
+}
+
+//SetDownloadTimeout configures the timeout used to supervice the download of the image to the adapter (assumed in seconds)
+func (dm *fileDownloadManager) SetDownloadTimeout(ctx context.Context, aDlTimeout time.Duration) {
+	dm.mutexDownloadImageDsc.Lock()
+	defer dm.mutexDownloadImageDsc.Unlock()
+	logger.Debugw(ctx, "setting download timeout", log.Fields{"timeout": aDlTimeout})
+	dm.dlToAdapterTimeout = aDlTimeout
+}
+
+//GetDownloadTimeout delivers the timeout used to supervice the download of the image to the adapter (assumed in seconds)
+func (dm *fileDownloadManager) GetDownloadTimeout(ctx context.Context) time.Duration {
+	dm.mutexDownloadImageDsc.RLock()
+	defer dm.mutexDownloadImageDsc.RUnlock()
+	return dm.dlToAdapterTimeout
+}
+
+//ImageExists returns true if the requested image already exists within the adapter
+func (dm *fileDownloadManager) ImageExists(ctx context.Context, aImageName string) bool {
+	logger.Debugw(ctx, "checking on existence of the image", log.Fields{"image-name": aImageName})
+	dm.mutexDownloadImageDsc.RLock()
+	defer dm.mutexDownloadImageDsc.RUnlock()
+
+	for _, dnldImgDsc := range dm.downloadImageDscSlice {
+		if dnldImgDsc.downloadImageName == aImageName {
+			//image found (by name)
+			return true
+		}
+	}
+	//image not found (by name)
+	return false
+}
+
+//StartDownload returns true if the download of the requested image could be started for the given file name and URL
+func (dm *fileDownloadManager) StartDownload(ctx context.Context, aImageName string, aURLCommand string) error {
+	logger.Infow(ctx, "image download-to-adapter requested", log.Fields{
+		"image-name": aImageName, "url-command": aURLCommand})
+	loDownloadImageParams := downloadImageParams{
+		downloadImageName: aImageName, downloadImageState: cFileStateDlStarted,
+		downloadImageLen: 0, downloadImageCrc: 0}
+	dm.mutexDownloadImageDsc.Lock()
+	dm.downloadImageDscSlice = append(dm.downloadImageDscSlice, loDownloadImageParams)
+	dm.mutexDownloadImageDsc.Unlock()
+	//try to download from http
+	err := dm.downloadFile(ctx, aURLCommand, cDefaultLocalDir, aImageName)
+	//return the result of the start-request to comfort the core processing even though the complete download may go on in background
+	return err
+}
+
+//GetImageBufferLen returns the length of the specified file in bytes (file size) - as detected after download
+func (dm *fileDownloadManager) GetImageBufferLen(ctx context.Context, aFileName string) (int64, error) {
+	dm.mutexDownloadImageDsc.RLock()
+	defer dm.mutexDownloadImageDsc.RUnlock()
+	for _, dnldImgDsc := range dm.downloadImageDscSlice {
+		if dnldImgDsc.downloadImageName == aFileName && dnldImgDsc.downloadImageState == cFileStateDlSucceeded {
+			//image found (by name) and fully downloaded
+			return dnldImgDsc.downloadImageLen, nil
+		}
+	}
+	return 0, fmt.Errorf("no downloaded image found: %s", aFileName)
+}
+
+//GetDownloadImageBuffer returns the content of the requested file as byte slice
+func (dm *fileDownloadManager) GetDownloadImageBuffer(ctx context.Context, aFileName string) ([]byte, error) {
+	//nolint:gosec
+	file, err := os.Open(cDefaultLocalDir + "/" + aFileName)
+	if err != nil {
+		return nil, err
+	}
+	//nolint:errcheck
+	defer file.Close()
+
+	stats, statsErr := file.Stat()
+	if statsErr != nil {
+		return nil, statsErr
+	}
+
+	var size int64 = stats.Size()
+	bytes := make([]byte, size)
+
+	buffer := bufio.NewReader(file)
+	_, err = buffer.Read(bytes)
+
+	return bytes, err
+}
+
+//RequestDownloadReady receives a channel that has to be used to inform the requester in case the concerned file is downloaded
+func (dm *fileDownloadManager) RequestDownloadReady(ctx context.Context, aFileName string, aWaitChannel chan<- bool) {
+	if dm.imageLocallyDownloaded(ctx, aFileName) {
+		//image found (by name) and fully downloaded
+		logger.Debugw(ctx, "file ready - immediate response", log.Fields{"image-name": aFileName})
+		aWaitChannel <- true
+		return
+	}
+	//when we are here the image was not yet found or not fully downloaded -
+	//  add the device specific channel to the list of waiting requesters
+	dm.mutexDownloadImageDsc.Lock()
+	defer dm.mutexDownloadImageDsc.Unlock()
+	if loRequesterChannelMap, ok := dm.dnldImgReadyWaiting[aFileName]; ok {
+		//entry for the file name already exists
+		if _, exists := loRequesterChannelMap[aWaitChannel]; !exists {
+			// requester channel does not yet exist for the image
+			loRequesterChannelMap[aWaitChannel] = struct{}{}
+			dm.dnldImgReadyWaiting[aFileName] = loRequesterChannelMap
+			logger.Debugw(ctx, "file not ready - adding new requester", log.Fields{
+				"image-name": aFileName, "number-of-requesters": len(dm.dnldImgReadyWaiting[aFileName])})
+		}
+	} else {
+		//entry for the file name does not even exist
+		addRequesterChannelMap := make(map[chan<- bool]struct{})
+		addRequesterChannelMap[aWaitChannel] = struct{}{}
+		dm.dnldImgReadyWaiting[aFileName] = addRequesterChannelMap
+		logger.Debugw(ctx, "file not ready - setting first requester", log.Fields{
+			"image-name": aFileName})
+	}
+}
+
+//RemoveReadyRequest removes the specified channel from the requester(channel) map for the given file name
+func (dm *fileDownloadManager) RemoveReadyRequest(ctx context.Context, aFileName string, aWaitChannel chan bool) {
+	dm.mutexDownloadImageDsc.Lock()
+	defer dm.mutexDownloadImageDsc.Unlock()
+	for imageName, channelMap := range dm.dnldImgReadyWaiting {
+		if imageName == aFileName {
+			for channel := range channelMap {
+				if channel == aWaitChannel {
+					delete(dm.dnldImgReadyWaiting[imageName], channel)
+					logger.Debugw(ctx, "channel removed from the requester map", log.Fields{
+						"image-name": aFileName, "new number-of-requesters": len(dm.dnldImgReadyWaiting[aFileName])})
+					return //can leave directly
+				}
+			}
+			return //can leave directly
+		}
+	}
+}
+
+// FileDownloadManager private (unexported) methods -- start
+
+//imageLocallyDownloaded returns true if the requested image already exists within the adapter
+func (dm *fileDownloadManager) imageLocallyDownloaded(ctx context.Context, aImageName string) bool {
+	logger.Debugw(ctx, "checking if image is fully downloaded to adapter", log.Fields{"image-name": aImageName})
+	dm.mutexDownloadImageDsc.RLock()
+	defer dm.mutexDownloadImageDsc.RUnlock()
+
+	for _, dnldImgDsc := range dm.downloadImageDscSlice {
+		if dnldImgDsc.downloadImageName == aImageName {
+			//image found (by name)
+			if dnldImgDsc.downloadImageState == cFileStateDlSucceeded {
+				logger.Debugw(ctx, "image has been fully downloaded", log.Fields{"image-name": aImageName})
+				return true
+			}
+			logger.Debugw(ctx, "image not yet fully downloaded", log.Fields{"image-name": aImageName})
+			return false
+		}
+	}
+	//image not found (by name)
+	logger.Errorw(ctx, "image does not exist", log.Fields{"image-name": aImageName})
+	return false
+}
+
+//downloadFile downloads the specified file from the given http location
+func (dm *fileDownloadManager) downloadFile(ctx context.Context, aURLCommand string, aFilePath string, aFileName string) error {
+	// Get the data
+	logger.Infow(ctx, "downloading with URL", log.Fields{"url": aURLCommand, "localPath": aFilePath})
+	// verifying the complete URL by parsing it to its URL elements
+	urlBase, err1 := url.Parse(aURLCommand)
+	if err1 != nil {
+		logger.Errorw(ctx, "could not set base url command", log.Fields{"url": aURLCommand, "error": err1})
+		return fmt.Errorf("could not set base url command: %s, error: %s", aURLCommand, err1)
+	}
+	urlParams := url.Values{}
+	urlBase.RawQuery = urlParams.Encode()
+
+	//pre-check on file existence - assuming http location here
+	reqExist, errExist2 := http.NewRequest("HEAD", urlBase.String(), nil)
+	if errExist2 != nil {
+		logger.Errorw(ctx, "could not generate http head request", log.Fields{"url": urlBase.String(), "error": errExist2})
+		return fmt.Errorf("could not  generate http head request: %s, error: %s", aURLCommand, errExist2)
+	}
+	ctxExist, cancelExist := context.WithDeadline(ctx, time.Now().Add(3*time.Second)) //waiting for some fast answer
+	defer cancelExist()
+	_ = reqExist.WithContext(ctxExist)
+	respExist, errExist3 := http.DefaultClient.Do(reqExist)
+	if errExist3 != nil || respExist.StatusCode != http.StatusOK {
+		logger.Infow(ctx, "could not http head from url", log.Fields{"url": urlBase.String(),
+			"error": errExist3, "status": respExist.StatusCode})
+		//if head is not supported by server we cannot use this test and just try to continue
+		if respExist.StatusCode != http.StatusMethodNotAllowed {
+			logger.Errorw(ctx, "http head from url: file does not exist here, aborting", log.Fields{"url": urlBase.String(),
+				"error": errExist3, "status": respExist.StatusCode})
+			return fmt.Errorf("http head from url: file does not exist here, aborting: %s, error: %s, status: %d",
+				aURLCommand, errExist2, respExist.StatusCode)
+		}
+	}
+	defer func() {
+		deferredErr := respExist.Body.Close()
+		if deferredErr != nil {
+			logger.Errorw(ctx, "error at closing http head response body", log.Fields{"url": urlBase.String(), "error": deferredErr})
+		}
+	}()
+
+	//trying to download - do it in background as it may take some time ...
+	go func() {
+		req, err2 := http.NewRequest("GET", urlBase.String(), nil)
+		if err2 != nil {
+			logger.Errorw(ctx, "could not generate http request", log.Fields{"url": urlBase.String(), "error": err2})
+			return
+		}
+		ctx, cancel := context.WithDeadline(ctx, time.Now().Add(dm.dlToAdapterTimeout)) //timeout as given from SetDownloadTimeout()
+		defer cancel()
+		_ = req.WithContext(ctx)
+		resp, err3 := http.DefaultClient.Do(req)
+		if err3 != nil || respExist.StatusCode != http.StatusOK {
+			logger.Errorw(ctx, "could not http get from url", log.Fields{"url": urlBase.String(),
+				"error": err3, "status": respExist.StatusCode})
+			return
+		}
+		defer func() {
+			deferredErr := resp.Body.Close()
+			if deferredErr != nil {
+				logger.Errorw(ctx, "error at closing http get response body", log.Fields{"url": urlBase.String(), "error": deferredErr})
+			}
+		}()
+
+		// Create the file
+		aLocalPathName := aFilePath + "/" + aFileName
+		file, err := os.Create(aLocalPathName)
+		if err != nil {
+			logger.Errorw(ctx, "could not create local file", log.Fields{"path_file": aLocalPathName, "error": err})
+			return
+		}
+		defer func() {
+			deferredErr := file.Close()
+			if deferredErr != nil {
+				logger.Errorw(ctx, "error at closing new file", log.Fields{"path_file": aLocalPathName, "error": deferredErr})
+			}
+		}()
+
+		// Write the body to file
+		_, err = io.Copy(file, resp.Body)
+		if err != nil {
+			logger.Errorw(ctx, "could not copy file content", log.Fields{"url": urlBase.String(), "file": aLocalPathName, "error": err})
+			return
+		}
+
+		fileStats, statsErr := file.Stat()
+		if err != nil {
+			logger.Errorw(ctx, "created file can't be accessed", log.Fields{"file": aLocalPathName, "stat-error": statsErr})
+		}
+		fileSize := fileStats.Size()
+		logger.Infow(ctx, "written file size is", log.Fields{"file": aLocalPathName, "length": fileSize})
+
+		dm.mutexDownloadImageDsc.Lock()
+		defer dm.mutexDownloadImageDsc.Unlock()
+		for imgKey, dnldImgDsc := range dm.downloadImageDscSlice {
+			if dnldImgDsc.downloadImageName == aFileName {
+				//image found (by name) - need to write changes on the original map
+				dm.downloadImageDscSlice[imgKey].downloadImageState = cFileStateDlSucceeded
+				dm.downloadImageDscSlice[imgKey].downloadImageLen = fileSize
+				//in case upgrade process(es) was/were waiting for the file, inform them
+				for imageName, channelMap := range dm.dnldImgReadyWaiting {
+					if imageName == aFileName {
+						for channel := range channelMap {
+							// use all found channels to inform possible requesters about the existence of the file
+							channel <- true
+							delete(dm.dnldImgReadyWaiting[imageName], channel) //requester served
+						}
+						return //can leave directly
+					}
+				}
+				return //can leave directly
+			}
+		}
+		//TODO:!!! further extension could be provided here, e.g. already computing and possibly comparing the CRC, vendor check
+	}()
+	return nil
+}
diff --git a/internal/pkg/onuadaptercore/omci_cc.go b/internal/pkg/onuadaptercore/omci_cc.go
index f371379..0e3b8a5 100644
--- a/internal/pkg/onuadaptercore/omci_cc.go
+++ b/internal/pkg/onuadaptercore/omci_cc.go
@@ -492,13 +492,15 @@
 func (oo *omciCC) send(ctx context.Context, txFrame []byte, timeout int, retry int, highPrio bool,
 	receiveCallbackPair callbackPair) error {
 
-	logger.Debugw(ctx, "register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
-	// it could be checked, if the callback keay is already registered - but simply overwrite may be acceptable ...
-	oo.mutexRxSchedMap.Lock()
-	oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
-	printFrame := receiveCallbackPair.cbEntry.framePrint //printFrame true means debug print of frame is requested
-	oo.mutexRxSchedMap.Unlock()
+	if timeout != 0 {
+		logger.Debugw(ctx, "register-response-callback:", log.Fields{"for TansCorrId": receiveCallbackPair.cbKey})
+		oo.mutexRxSchedMap.Lock()
+		// it could be checked, if the callback key is already registered - but simply overwrite may be acceptable ...
+		oo.rxSchedulerMap[receiveCallbackPair.cbKey] = receiveCallbackPair.cbEntry
+		oo.mutexRxSchedMap.Unlock()
+	} //else timeout 0 indicates that no response is expected - fire and forget
 
+	printFrame := receiveCallbackPair.cbEntry.framePrint //printFrame true means debug print of frame is requested
 	//just use a simple list for starting - might need some more effort, especially for multi source write access
 	omciTxRequest := omciTransferStructure{
 		txFrame,
@@ -585,15 +587,6 @@
 			proxy_device_id=self._proxy_address.device_id
 		)
 		*/
-		device, err := oo.coreProxy.GetDevice(ctx,
-			oo.pBaseDeviceHandler.deviceID, oo.deviceID) //parent, child
-		if err != nil || device == nil {
-			/*TODO: needs to handle error scenarios */
-			logger.Errorw(ctx, "Failed to fetch device", log.Fields{"err": err, "ParentId": oo.pBaseDeviceHandler.deviceID,
-				"ChildId": oo.deviceID})
-			return fmt.Errorf("failed to fetch device %s", oo.deviceID)
-		}
-
 		if omciTxRequest.withFramePrint {
 			logger.Debugw(ctx, "omci-message-to-send:", log.Fields{
 				"TxOmciMessage": hex.EncodeToString(omciTxRequest.txFrame),
@@ -2706,7 +2699,7 @@
 	return nil
 }
 
-func (oo *omciCC) sendDownloadSection(ctx context.Context, timeout int, highPrio bool,
+func (oo *omciCC) sendDownloadSection(ctx context.Context, aTimeout int, highPrio bool,
 	rxChan chan Message, aImageMeID uint16, aAckRequest uint8, aDownloadSectionNo uint8, aSection []byte, aPrint bool) error {
 	tid := oo.getNextTid(highPrio)
 	logger.Debugw(ctx, "send DlSectionRequest:", log.Fields{"device-id": oo.deviceID,
@@ -2716,8 +2709,10 @@
 	//TODO!!!: don't know by now on how to generate the possibly needed AR (or enforce it to 0) with current omci-lib
 	//    by now just try to send it as defined by omci-lib
 	msgType := omci.DownloadSectionRequestType
+	var timeout int = 0 //default value for no response expected
 	if aAckRequest > 0 {
 		msgType = omci.DownloadSectionRequestWithResponseType
+		timeout = aTimeout
 	}
 	omciLayer := &omci.OMCI{
 		TransactionID: tid,
@@ -2754,6 +2749,8 @@
 	}
 
 	omciRxCallbackPair := callbackPair{cbKey: tid,
+		// the callback is set even though no response might be required here, the tid (key) setting is needed here anyway
+		//   (used to avoid retransmission of frames with the same TID)
 		cbEntry: callbackPairEntry{rxChan, oo.receiveOmciResponse, printFrame /*aPrint*/},
 	}
 	err = oo.send(ctx, outgoingPacket, timeout, cDefaultRetries, highPrio, omciRxCallbackPair)
@@ -3014,52 +3011,58 @@
 
 func (oo *omciCC) processRequestMonitoring(ctx context.Context, aOmciTxRequest omciTransferStructure) {
 
-	chSuccess := make(chan bool)
-	aOmciTxRequest.chSuccess = chSuccess
-
-	tid := aOmciTxRequest.cbPair.cbKey
 	timeout := aOmciTxRequest.timeout
-	retries := aOmciTxRequest.retries
-
-	oo.mutexMonReq.Lock()
-	oo.monitoredRequests[tid] = aOmciTxRequest
-	oo.mutexMonReq.Unlock()
-
-	retryCounter := 0
-loop:
-	for retryCounter <= retries {
-
+	if timeout == 0 {
+		//timeout 0 indicates that no response is expected - fire and forget
 		oo.mutexTxQueue.Lock()
 		oo.txQueue.PushBack(aOmciTxRequest) // enqueue
 		oo.mutexTxQueue.Unlock()
-
 		go oo.sendNextRequest(ctx)
+	} else {
+		chSuccess := make(chan bool)
+		aOmciTxRequest.chSuccess = chSuccess
+		tid := aOmciTxRequest.cbPair.cbKey
+		retries := aOmciTxRequest.retries
 
-		select {
-		case success := <-chSuccess:
-			if success {
-				logger.Debugw(ctx, "reqMon: response received in time",
-					log.Fields{"tid": tid, "device-id": oo.deviceID})
-			} else {
-				logger.Debugw(ctx, "reqMon: wait for response aborted",
-					log.Fields{"tid": tid, "device-id": oo.deviceID})
-			}
-			break loop
-		case <-time.After(time.Duration(timeout) * time.Second):
-			if retryCounter == retries {
-				logger.Errorw(ctx, "reqMon: timeout waiting for response - no of max retries reached!",
-					log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
+		oo.mutexMonReq.Lock()
+		oo.monitoredRequests[tid] = aOmciTxRequest
+		oo.mutexMonReq.Unlock()
+
+		retryCounter := 0
+	loop:
+		for retryCounter <= retries {
+
+			oo.mutexTxQueue.Lock()
+			oo.txQueue.PushBack(aOmciTxRequest) // enqueue
+			oo.mutexTxQueue.Unlock()
+			go oo.sendNextRequest(ctx)
+
+			select {
+			case success := <-chSuccess:
+				if success {
+					logger.Debugw(ctx, "reqMon: response received in time",
+						log.Fields{"tid": tid, "device-id": oo.deviceID})
+				} else {
+					logger.Debugw(ctx, "reqMon: wait for response aborted",
+						log.Fields{"tid": tid, "device-id": oo.deviceID})
+				}
 				break loop
-			} else {
-				logger.Infow(ctx, "reqMon: timeout waiting for response - retry",
-					log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
+			case <-time.After(time.Duration(timeout) * time.Second):
+				if retryCounter == retries {
+					logger.Errorw(ctx, "reqMon: timeout waiting for response - no of max retries reached!",
+						log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
+					break loop
+				} else {
+					logger.Infow(ctx, "reqMon: timeout waiting for response - retry",
+						log.Fields{"tid": tid, "retries": retryCounter, "device-id": oo.deviceID})
+				}
 			}
+			retryCounter++
 		}
-		retryCounter++
+		oo.mutexMonReq.Lock()
+		delete(oo.monitoredRequests, tid)
+		oo.mutexMonReq.Unlock()
 	}
-	oo.mutexMonReq.Lock()
-	delete(oo.monitoredRequests, tid)
-	oo.mutexMonReq.Unlock()
 }
 
 //CancelRequestMonitoring terminates monitoring of outstanding omci requests
diff --git a/internal/pkg/onuadaptercore/omci_onu_upgrade.go b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
index 58e78a4..1e542ce 100644
--- a/internal/pkg/onuadaptercore/omci_onu_upgrade.go
+++ b/internal/pkg/onuadaptercore/omci_onu_upgrade.go
@@ -19,8 +19,10 @@
 
 import (
 	"context"
+	"encoding/binary"
 	"fmt"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/boguslaw-wojcik/crc32a"
@@ -38,16 +40,17 @@
 	cOmciDownloadSectionSize     = 31 //in bytes
 	cOmciDownloadWindowSizeLimit = 31 //in sections for window offset (windowSize(32)-1)
 	//cOmciDownloadWindowRetryMax  = 2    // max attempts for a specific window
-	cOmciSectionInterleaveMilliseconds = 100 //DownloadSection interleave time in milliseconds
-	cOmciEndSwDlDelaySeconds           = 1   //End Software Download delay after last section (may be also configurable?)
-	cWaitCountEndSwDl                  = 6   //maximum number of EndSwDl requests
-	cWaitDelayEndSwDlSeconds           = 10  //duration, how long is waited before next request on EndSwDl
+	cOmciSectionInterleaveMilliseconds = 0  //DownloadSection interleave time in milliseconds (0 for no delay)
+	cOmciEndSwDlDelaySeconds           = 1  //End Software Download delay after last section (may be also configurable?)
+	cWaitCountEndSwDl                  = 6  //maximum number of EndSwDl requests
+	cWaitDelayEndSwDlSeconds           = 10 //duration, how long is waited before next request on EndSwDl
 	//cOmciDownloadCompleteTimeout = 5400 //in s for the complete timeout (may be better scale to image size/ noOfWindows)
 )
 
 const (
 	// events of config PON ANI port FSM
 	upgradeEvStart              = "upgradeEvStart"
+	upgradeEvAdapterDownload    = "upgradeEvAdapterDownload"
 	upgradeEvPrepareSwDownload  = "upgradeEvPrepareSwDownload"
 	upgradeEvRxStartSwDownload  = "upgradeEvRxStartSwDownload"
 	upgradeEvWaitWindowAck      = "upgradeEvWaitWindowAck"
@@ -55,6 +58,7 @@
 	upgradeEvEndSwDownload      = "upgradeEvEndSwDownload"
 	upgradeEvWaitEndDownload    = "upgradeEvWaitEndDownload"
 	upgradeEvContinueFinalize   = "upgradeEvContinueFinalize"
+	upgradeEvWaitForActivate    = "upgradeEvWaitForActivate"
 	upgradeEvRequestActivate    = "upgradeEvRequestActivate"
 	upgradeEvWaitForCommit      = "upgradeEvWaitForCommit"
 	upgradeEvCommitSw           = "upgradeEvCommitSw"
@@ -71,11 +75,13 @@
 	// states of config PON ANI port FSM
 	upgradeStDisabled           = "upgradeStDisabled"
 	upgradeStStarting           = "upgradeStStarting"
+	upgradeStWaitingAdapterDL   = "upgradeStWaitingAdapterDL"
 	upgradeStPreparingDL        = "upgradeStPreparingDL"
 	upgradeStDLSection          = "upgradeStDLSection"
 	upgradeStVerifyWindow       = "upgradeStVerifyWindow"
 	upgradeStFinalizeDL         = "upgradeStFinalizeDL"
 	upgradeStWaitEndDL          = "upgradeStWaitEndDL"
+	upgradeStWaitForActivate    = "upgradeStWaitForActivate"
 	upgradeStRequestingActivate = "upgradeStRequestingActivate"
 	upgradeStWaitForCommit      = "upgradeStWaitForCommit"
 	upgradeStCommitSw           = "upgradeStCommitSw"
@@ -90,32 +96,46 @@
 type OnuUpgradeFsm struct {
 	pDeviceHandler   *deviceHandler
 	pDownloadManager *adapterDownloadManager
+	pFileManager     *fileDownloadManager //used from R2.8 with new API version
 	deviceID         string
 	pOnuOmciDevice   *OnuDeviceEntry
 	pOmciCC          *omciCC
 	pOnuDB           *onuDeviceDB
 	requestEvent     OnuDeviceEvent
 	//omciMIdsResponseReceived chan bool //seperate channel needed for checking multiInstance OMCI message responses
-	pAdaptFsm                    *AdapterFsm
-	pImageDsc                    *voltha.ImageDownload
-	imageBuffer                  []byte
-	origImageLength              uint32        //as also limited by OMCI
-	imageCRC                     uint32        //as per OMCI - ITU I.363.5 crc
-	imageLength                  uint32        //including last bytes padding
-	omciDownloadWindowSizeLimit  uint8         //windowSize-1 in sections
-	omciDownloadWindowSizeLast   uint8         //number of sections in last window
-	noOfSections                 uint32        //uint32 range for sections should be sufficient for very long images
-	nextDownloadSectionsAbsolute uint32        //number of next section to download in overall image
-	nextDownloadSectionsWindow   uint8         //number of next section to download within current window
-	noOfWindows                  uint32        //uint32 range for windows should be sufficient for very long images
-	nextDownloadWindow           uint32        //number of next window to download
-	inactiveImageMeID            uint16        //ME-ID of the inactive image
-	omciSectionInterleaveDelay   time.Duration //DownloadSectionInterleave delay in milliseconds
-	delayEndSwDl                 bool          //flag to provide a delay between last section and EndSwDl
-	pLastTxMeInstance            *me.ManagedEntity
-	waitCountEndSwDl             uint8         //number, how often is waited for EndSwDl at maximum
-	waitDelayEndSwDl             time.Duration //duration, how long is waited before next request on EndSwDl
-	chReceiveExpectedResponse    chan bool
+	pAdaptFsm                        *AdapterFsm
+	pImageDsc                        *voltha.ImageDownload
+	imageBuffer                      []byte
+	origImageLength                  uint32        //as also limited by OMCI
+	imageCRC                         uint32        //as per OMCI - ITU I.363.5 crc
+	imageLength                      uint32        //including last bytes padding
+	omciDownloadWindowSizeLimit      uint8         //windowSize-1 in sections
+	omciDownloadWindowSizeLast       uint8         //number of sections in last window
+	noOfSections                     uint32        //uint32 range for sections should be sufficient for very long images
+	nextDownloadSectionsAbsolute     uint32        //number of next section to download in overall image
+	nextDownloadSectionsWindow       uint8         //number of next section to download within current window
+	noOfWindows                      uint32        //uint32 range for windows should be sufficient for very long images
+	nextDownloadWindow               uint32        //number of next window to download
+	inactiveImageMeID                uint16        //ME-ID of the inactive image
+	downloadToOnuTimeout4MB          time.Duration //timeout for downloading the image to the ONU for a 4MB image slice
+	omciSectionInterleaveDelay       time.Duration //DownloadSectionInterleave delay in milliseconds
+	delayEndSwDl                     bool          //flag to provide a delay between last section and EndSwDl
+	pLastTxMeInstance                *me.ManagedEntity
+	waitCountEndSwDl                 uint8         //number, how often is waited for EndSwDl at maximum
+	waitDelayEndSwDl                 time.Duration //duration, how long is waited before next request on EndSwDl
+	chReceiveExpectedResponse        chan bool
+	useAPIVersion43                  bool //flag for indication on which API version is used (and accordingly which specific methods)
+	mutexUpgradeParams               sync.RWMutex
+	imageVersion                     string //name of the image as used within OMCI (and on extrenal API interface)
+	imageIdentifier                  string //name of the image as used in the adapter
+	mutexIsAwaitingAdapterDlResponse sync.RWMutex
+	chAdapterDlReady                 chan bool
+	isWaitingForAdapterDlResponse    bool
+	mutexIsAwaitingOnuDlResponse     sync.RWMutex
+	chOnuDlReady                     chan bool
+	isWaitingForOnuDlResponse        bool
+	activateImage                    bool
+	commitImage                      bool
 }
 
 //NewOnuUpgradeFsm is the 'constructor' for the state machine to config the PON ANI ports
@@ -136,6 +156,8 @@
 		waitDelayEndSwDl:            cWaitDelayEndSwDlSeconds,
 	}
 	instFsm.chReceiveExpectedResponse = make(chan bool)
+	instFsm.chAdapterDlReady = make(chan bool)
+	instFsm.chOnuDlReady = make(chan bool)
 
 	instFsm.pAdaptFsm = NewAdapterFsm(aName, instFsm.deviceID, aCommChannel)
 	if instFsm.pAdaptFsm == nil {
@@ -147,17 +169,20 @@
 		upgradeStDisabled,
 		fsm.Events{
 			{Name: upgradeEvStart, Src: []string{upgradeStDisabled}, Dst: upgradeStStarting},
-			{Name: upgradeEvPrepareSwDownload, Src: []string{upgradeStStarting}, Dst: upgradeStPreparingDL},
+			{Name: upgradeEvAdapterDownload, Src: []string{upgradeStStarting}, Dst: upgradeStWaitingAdapterDL},
+			{Name: upgradeEvPrepareSwDownload, Src: []string{upgradeStStarting, upgradeStWaitingAdapterDL}, Dst: upgradeStPreparingDL},
 			{Name: upgradeEvRxStartSwDownload, Src: []string{upgradeStPreparingDL}, Dst: upgradeStDLSection},
 			{Name: upgradeEvWaitWindowAck, Src: []string{upgradeStDLSection}, Dst: upgradeStVerifyWindow},
 			{Name: upgradeEvContinueNextWindow, Src: []string{upgradeStVerifyWindow}, Dst: upgradeStDLSection},
 			{Name: upgradeEvEndSwDownload, Src: []string{upgradeStVerifyWindow}, Dst: upgradeStFinalizeDL},
 			{Name: upgradeEvWaitEndDownload, Src: []string{upgradeStFinalizeDL}, Dst: upgradeStWaitEndDL},
 			{Name: upgradeEvContinueFinalize, Src: []string{upgradeStWaitEndDL}, Dst: upgradeStFinalizeDL},
-			{Name: upgradeEvRequestActivate, Src: []string{upgradeStWaitEndDL}, Dst: upgradeStRequestingActivate},
+			{Name: upgradeEvWaitForActivate, Src: []string{upgradeStWaitEndDL}, Dst: upgradeStWaitForActivate},
+			{Name: upgradeEvRequestActivate, Src: []string{upgradeStStarting, upgradeStWaitEndDL, upgradeStWaitForActivate},
+				Dst: upgradeStRequestingActivate}, //allows also for direct activation (without download) [TODO!!!]
 			{Name: upgradeEvWaitForCommit, Src: []string{upgradeStRequestingActivate}, Dst: upgradeStWaitForCommit},
 			{Name: upgradeEvCommitSw, Src: []string{upgradeStStarting, upgradeStWaitForCommit},
-				Dst: upgradeStCommitSw},
+				Dst: upgradeStCommitSw}, //allows also for direct commitment (without download) [TODO!!!]
 			{Name: upgradeEvCheckCommitted, Src: []string{upgradeStCommitSw}, Dst: upgradeStCheckCommitted},
 
 			/*
@@ -167,19 +192,20 @@
 					upgradeStCreatingGemNCTPs, upgradeStCreatingGemIWs, upgradeStSettingPQs}, Dst: upgradeStStarting},
 			*/
 			// exceptional treatments
-			{Name: upgradeEvReset, Src: []string{upgradeStStarting, upgradeStPreparingDL, upgradeStDLSection,
-				upgradeStVerifyWindow, upgradeStDLSection, upgradeStFinalizeDL, upgradeStWaitEndDL, upgradeStRequestingActivate,
-				upgradeStCommitSw, upgradeStCheckCommitted}, //upgradeStWaitForCommit is not reset (later perhaps also not upgradeStWaitActivate)
+			{Name: upgradeEvReset, Src: []string{upgradeStStarting, upgradeStWaitingAdapterDL, upgradeStPreparingDL, upgradeStDLSection,
+				upgradeStVerifyWindow, upgradeStDLSection, upgradeStFinalizeDL, upgradeStWaitEndDL, upgradeStWaitForActivate,
+				upgradeStRequestingActivate, upgradeStCommitSw, upgradeStCheckCommitted}, //upgradeStWaitForCommit is not reset (later perhaps also not upgradeStWaitActivate)
 				Dst: upgradeStResetting},
-			{Name: upgradeEvAbort, Src: []string{upgradeStStarting, upgradeStPreparingDL, upgradeStDLSection,
-				upgradeStVerifyWindow, upgradeStDLSection, upgradeStFinalizeDL, upgradeStWaitEndDL, upgradeStRequestingActivate,
-				upgradeStWaitForCommit, upgradeStCommitSw, upgradeStCheckCommitted},
+			{Name: upgradeEvAbort, Src: []string{upgradeStStarting, upgradeStWaitingAdapterDL, upgradeStPreparingDL, upgradeStDLSection,
+				upgradeStVerifyWindow, upgradeStDLSection, upgradeStFinalizeDL, upgradeStWaitEndDL, upgradeStWaitForActivate,
+				upgradeStRequestingActivate, upgradeStWaitForCommit, upgradeStCommitSw, upgradeStCheckCommitted},
 				Dst: upgradeStResetting},
 			{Name: upgradeEvRestart, Src: []string{upgradeStResetting}, Dst: upgradeStDisabled},
 		},
 		fsm.Callbacks{
 			"enter_state":                          func(e *fsm.Event) { instFsm.pAdaptFsm.logFsmStateChange(ctx, e) },
 			"enter_" + upgradeStStarting:           func(e *fsm.Event) { instFsm.enterStarting(ctx, e) },
+			"enter_" + upgradeStWaitingAdapterDL:   func(e *fsm.Event) { instFsm.enterWaitingAdapterDL(ctx, e) },
 			"enter_" + upgradeStPreparingDL:        func(e *fsm.Event) { instFsm.enterPreparingDL(ctx, e) },
 			"enter_" + upgradeStDLSection:          func(e *fsm.Event) { instFsm.enterDownloadSection(ctx, e) },
 			"enter_" + upgradeStVerifyWindow:       func(e *fsm.Event) { instFsm.enterVerifyWindow(ctx, e) },
@@ -203,6 +229,7 @@
 }
 
 //SetDownloadParams configures the needed parameters for a specific download to the ONU
+//  called from 'old' API Activate_image_update()
 func (oFsm *OnuUpgradeFsm) SetDownloadParams(ctx context.Context, aInactiveImageID uint16,
 	apImageDsc *voltha.ImageDownload, apDownloadManager *adapterDownloadManager) error {
 	pBaseFsm := oFsm.pAdaptFsm.pFsm
@@ -214,7 +241,7 @@
 		oFsm.pDownloadManager = apDownloadManager
 
 		go func(aPBaseFsm *fsm.FSM) {
-			// let the upgrade FSm proceed to PreparinDL
+			// let the upgrade FSM proceed to PreparingDL
 			_ = aPBaseFsm.Event(upgradeEvPrepareSwDownload)
 		}(pBaseFsm)
 		return nil
@@ -224,6 +251,193 @@
 	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer or state for device-id: %s", oFsm.deviceID))
 }
 
+//SetDownloadParamsAfterDownload configures the needed parameters for a specific download to the ONU according to
+//  updated API interface with R2.8: start download to ONU if the image is downloaded to the adapter
+//  called from 'new' API Download_onu_image
+func (oFsm *OnuUpgradeFsm) SetDownloadParamsAfterDownload(ctx context.Context, aInactiveImageID uint16,
+	apImageRequest *voltha.DeviceImageDownloadRequest, apDownloadManager *fileDownloadManager,
+	aImageIdentifier string, aDownloadTimeout time.Duration) error {
+	oFsm.mutexUpgradeParams.Lock()
+	var pBaseFsm *fsm.FSM = nil
+	if oFsm.pAdaptFsm != nil {
+		pBaseFsm = oFsm.pAdaptFsm.pFsm
+	}
+	if pBaseFsm != nil && pBaseFsm.Is(upgradeStStarting) {
+		logger.Debugw(ctx, "OnuUpgradeFsm Parameter setting", log.Fields{
+			"device-id": oFsm.deviceID, "image-description": apImageRequest})
+		oFsm.useAPIVersion43 = true
+		oFsm.inactiveImageMeID = aInactiveImageID //upgrade state machines run on configured inactive ImageId
+		oFsm.pFileManager = apDownloadManager
+		oFsm.imageIdentifier = aImageIdentifier
+		oFsm.imageVersion = apImageRequest.Image.Version
+		oFsm.activateImage = apImageRequest.ActivateOnSuccess
+		oFsm.commitImage = apImageRequest.CommitOnSuccess
+		oFsm.downloadToOnuTimeout4MB = aDownloadTimeout
+		//TODO: currently straightforward options activate and commit are expected to be set and (unconditionally) done
+		//  for separate handling of these options the FSM must accordingly branch from the concerned states - later
+		oFsm.mutexUpgradeParams.Unlock()
+		_ = pBaseFsm.Event(upgradeEvAdapterDownload) //no need to call the FSM event in background here
+		return nil
+	}
+	oFsm.mutexUpgradeParams.Unlock()
+	logger.Errorw(ctx, "OnuUpgradeFsm abort: invalid FSM base pointer or state", log.Fields{
+		"device-id": oFsm.deviceID})
+	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer or state for device-id: %s", oFsm.deviceID))
+}
+
+//SetActivationParamsRunning sets the activate and commit flags for a running download to the ONU according to adapters rpc call
+//  called from 'new' API Activate_onu_image
+func (oFsm *OnuUpgradeFsm) SetActivationParamsRunning(ctx context.Context,
+	aImageIdentifier string, aCommit bool) error {
+	oFsm.mutexUpgradeParams.Lock()
+	//set activate/commit independent from state, if FSM is already beyond concerned states, then it does not matter anyway
+	//  (as long as the Imageidentifier is correct)
+	logger.Debugw(ctx, "OnuUpgradeFsm activate/commit parameter setting", log.Fields{
+		"device-id": oFsm.deviceID, "image-id": aImageIdentifier, "commit": aCommit})
+	if aImageIdentifier != oFsm.imageIdentifier {
+		logger.Errorw(ctx, "OnuUpgradeFsm abort: mismatching upgrade image", log.Fields{
+			"device-id": oFsm.deviceID, "request-image": aImageIdentifier, "fsm-image": oFsm.imageIdentifier})
+		oFsm.mutexUpgradeParams.Unlock()
+		return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm params ignored: requested image-name not used in current upgrade for device-id: %s",
+			oFsm.deviceID))
+	}
+	oFsm.activateImage = true
+	oFsm.commitImage = aCommit
+	oFsm.mutexUpgradeParams.Unlock()
+	var pBaseFsm *fsm.FSM = nil
+	if oFsm.pAdaptFsm != nil {
+		pBaseFsm = oFsm.pAdaptFsm.pFsm
+	}
+	if pBaseFsm != nil {
+		if pBaseFsm.Is(upgradeStWaitForActivate) {
+			logger.Debugw(ctx, "OnuUpgradeFsm finish waiting for activate", log.Fields{"device-id": oFsm.deviceID})
+			_ = pBaseFsm.Event(upgradeEvRequestActivate) //no need to call the FSM event in background here
+		}
+		return nil
+	}
+	logger.Errorw(ctx, "OnuUpgradeFsm abort: invalid FSM base pointer", log.Fields{
+		"device-id": oFsm.deviceID})
+	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer for device-id: %s", oFsm.deviceID))
+}
+
+//SetActivationParamsStart starts upgrade processing with immediate activation
+//  called from 'new' API Activate_onu_image
+func (oFsm *OnuUpgradeFsm) SetActivationParamsStart(ctx context.Context, aImageVersion string, aInactiveImageID uint16, aCommit bool) error {
+	oFsm.mutexUpgradeParams.Lock()
+	var pBaseFsm *fsm.FSM = nil
+	if oFsm.pAdaptFsm != nil {
+		pBaseFsm = oFsm.pAdaptFsm.pFsm
+	}
+	if pBaseFsm != nil && pBaseFsm.Is(upgradeStStarting) {
+		logger.Debugw(ctx, "OnuUpgradeFsm Parameter setting to start with activation", log.Fields{
+			"device-id": oFsm.deviceID, "image-version": aImageVersion})
+		oFsm.useAPIVersion43 = true
+		oFsm.inactiveImageMeID = aInactiveImageID //upgrade state machines run on configured inactive ImageId
+		oFsm.imageVersion = aImageVersion
+		oFsm.activateImage = true
+		oFsm.commitImage = aCommit
+		oFsm.mutexUpgradeParams.Unlock()
+		//directly request the FSM to activate the image
+		_ = pBaseFsm.Event(upgradeEvRequestActivate) //no need to call the FSM event in background here
+		return nil
+	}
+	oFsm.mutexUpgradeParams.Unlock()
+	logger.Errorw(ctx, "OnuUpgradeFsm abort: invalid FSM base pointer or state", log.Fields{
+		"device-id": oFsm.deviceID})
+	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer or state for device-id: %s", oFsm.deviceID))
+}
+
+//SetCommitmentParamsRunning sets the commit flag for a running download to the ONU according to adapters rpc call
+//  called from 'new' API Commit_onu_image
+func (oFsm *OnuUpgradeFsm) SetCommitmentParamsRunning(ctx context.Context, aImageIdentifier string) error {
+	oFsm.mutexUpgradeParams.Lock()
+	//set commit independent from state, if FSM is already beyond commit state (just ready), then it does not matter anyway
+	//  (as long as the Imageidentifier is correct)
+	logger.Debugw(ctx, "OnuUpgradeFsm commit parameter setting", log.Fields{
+		"device-id": oFsm.deviceID, "image-id": aImageIdentifier})
+	if aImageIdentifier != oFsm.imageIdentifier {
+		logger.Errorw(ctx, "OnuUpgradeFsm abort: mismatching upgrade image", log.Fields{
+			"device-id": oFsm.deviceID, "request-image": aImageIdentifier, "fsm-image": oFsm.imageIdentifier})
+		oFsm.mutexUpgradeParams.Unlock()
+		return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm params ignored: requested image-name not used in current upgrade for device-id: %s",
+			oFsm.deviceID))
+	}
+	oFsm.commitImage = true
+	oFsm.mutexUpgradeParams.Unlock()
+	var pBaseFsm *fsm.FSM = nil
+	if oFsm.pAdaptFsm != nil {
+		pBaseFsm = oFsm.pAdaptFsm.pFsm
+	}
+	if pBaseFsm != nil {
+		if pBaseFsm.Is(upgradeStWaitForCommit) {
+			logger.Debugw(ctx, "OnuUpgradeFsm finish waiting for commit", log.Fields{"device-id": oFsm.deviceID})
+			_ = pBaseFsm.Event(upgradeEvCommitSw) //no need to call the FSM event in background here
+		}
+		return nil
+	}
+	logger.Errorw(ctx, "OnuUpgradeFsm abort: invalid FSM base pointer", log.Fields{
+		"device-id": oFsm.deviceID})
+	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer for device-id: %s", oFsm.deviceID))
+}
+
+//SetCommitmentParamsStart starts upgrade processing with immediate commitment
+//  called from 'new' API Commit_onu_image
+func (oFsm *OnuUpgradeFsm) SetCommitmentParamsStart(ctx context.Context, aImageVersion string, aActiveImageID uint16) error {
+	oFsm.mutexUpgradeParams.Lock()
+	var pBaseFsm *fsm.FSM = nil
+	if oFsm.pAdaptFsm != nil {
+		pBaseFsm = oFsm.pAdaptFsm.pFsm
+	}
+	if pBaseFsm != nil && pBaseFsm.Is(upgradeStStarting) {
+		logger.Debugw(ctx, "OnuUpgradeFsm Parameter setting to start with commitment", log.Fields{
+			"device-id": oFsm.deviceID, "image-version": aImageVersion})
+		oFsm.useAPIVersion43 = true
+		oFsm.inactiveImageMeID = aActiveImageID //upgrade state machines inactive ImageId is the new active ImageId
+		oFsm.imageVersion = aImageVersion
+		oFsm.commitImage = true
+		oFsm.mutexUpgradeParams.Unlock()
+		//directly request the FSM to activate the image
+		_ = pBaseFsm.Event(upgradeEvCommitSw) //no need to call the FSM event in background here
+		return nil
+	}
+	oFsm.mutexUpgradeParams.Unlock()
+	logger.Errorw(ctx, "OnuUpgradeFsm abort: invalid FSM base pointer or state", log.Fields{
+		"device-id": oFsm.deviceID})
+	return fmt.Errorf(fmt.Sprintf("OnuUpgradeFsm abort: invalid FSM base pointer or state for device-id: %s", oFsm.deviceID))
+}
+
+//CancelProcessing ensures that suspended processing at waiting on some response is aborted and reset of FSM
+func (oFsm *OnuUpgradeFsm) CancelProcessing(ctx context.Context) {
+	//mutex protection is required for possible concurrent access to FSM members
+	//attention: for an unbuffered channel the sender is blocked until the value is received (processed)!
+	// accordingly the mutex must be released before sending to channel here (mutex acquired in receiver)
+	oFsm.mutexIsAwaitingAdapterDlResponse.RLock()
+	if oFsm.isWaitingForAdapterDlResponse {
+		oFsm.mutexIsAwaitingAdapterDlResponse.RUnlock()
+		//use channel to indicate that the download response waiting shall be aborted for this device (channel)
+		oFsm.chAdapterDlReady <- false
+	} else {
+		oFsm.mutexIsAwaitingAdapterDlResponse.RUnlock()
+	}
+	//chOnuDlReady is cleared as part of the FSM reset processing (from enterResetting())
+
+	// in any case (even if it might be automatically requested by above cancellation of waiting) ensure resetting the FSM
+	// specific here: If the FSM is in upgradeStWaitForCommit, it is left there for possibly later commit
+	// this possibly also refers later to (not yet existing) upgradeStWaitForActivate (with ctl API changes)
+	pAdaptFsm := oFsm.pAdaptFsm
+	if pAdaptFsm != nil {
+		// calling FSM events in background to avoid blocking of the caller
+		go func(aPAFsm *AdapterFsm) {
+			if aPAFsm.pFsm != nil {
+				if aPAFsm.pFsm.Is(upgradeStWaitEndDL) {
+					oFsm.chReceiveExpectedResponse <- false //which aborts the FSM (activate was not yet sent)
+				}
+				_ = aPAFsm.pFsm.Event(upgradeEvReset) //anyway and for all other states
+			} //else the FSM seems already to be in some released state
+		}(pAdaptFsm)
+	}
+}
+
 func (oFsm *OnuUpgradeFsm) enterStarting(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "OnuUpgradeFsm start", log.Fields{"in state": e.FSM.Current(),
 		"device-id": oFsm.deviceID})
@@ -232,11 +446,26 @@
 	go oFsm.processOmciUpgradeMessages(ctx)
 }
 
+//enterWaitingAdapterDL state can only be reached with useAPIVersion43
+func (oFsm *OnuUpgradeFsm) enterWaitingAdapterDL(ctx context.Context, e *fsm.Event) {
+	logger.Debugw(ctx, "OnuUpgradeFsm waiting for adapter download", log.Fields{"in state": e.FSM.Current(),
+		"device-id": oFsm.deviceID})
+	go oFsm.waitOnDownloadToAdapterReady(ctx, oFsm.chAdapterDlReady)
+	go oFsm.pFileManager.RequestDownloadReady(ctx, oFsm.imageIdentifier, oFsm.chAdapterDlReady)
+}
+
 func (oFsm *OnuUpgradeFsm) enterPreparingDL(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "OnuUpgradeFsm prepare Download to Onu", log.Fields{"in state": e.FSM.Current(),
 		"device-id": oFsm.deviceID})
 
-	fileLen, err := oFsm.pDownloadManager.getImageBufferLen(ctx, oFsm.pImageDsc.Name, oFsm.pImageDsc.LocalDir)
+	var fileLen int64
+	var err error
+	if oFsm.useAPIVersion43 {
+		//with the new API structure download to adapter is implicit and we have to wait until the image is available
+		fileLen, err = oFsm.pFileManager.GetImageBufferLen(ctx, oFsm.imageIdentifier)
+	} else {
+		fileLen, err = oFsm.pDownloadManager.getImageBufferLen(ctx, oFsm.pImageDsc.Name, oFsm.pImageDsc.LocalDir)
+	}
 	if err != nil || fileLen > int64(cMaxUint32) {
 		logger.Errorw(ctx, "OnuUpgradeFsm abort: problems getting image buffer length", log.Fields{
 			"device-id": oFsm.deviceID, "error": err, "length": fileLen})
@@ -248,8 +477,13 @@
 		return
 	}
 
+	//copy file content to buffer
 	oFsm.imageBuffer = make([]byte, fileLen)
-	oFsm.imageBuffer, err = oFsm.pDownloadManager.getDownloadImageBuffer(ctx, oFsm.pImageDsc.Name, oFsm.pImageDsc.LocalDir)
+	if oFsm.useAPIVersion43 {
+		oFsm.imageBuffer, err = oFsm.pFileManager.GetDownloadImageBuffer(ctx, oFsm.imageIdentifier)
+	} else {
+		oFsm.imageBuffer, err = oFsm.pDownloadManager.getDownloadImageBuffer(ctx, oFsm.pImageDsc.Name, oFsm.pImageDsc.LocalDir)
+	}
 	if err != nil {
 		logger.Errorw(ctx, "OnuUpgradeFsm abort: can't get image buffer", log.Fields{
 			"device-id": oFsm.deviceID, "error": err})
@@ -263,14 +497,16 @@
 
 	oFsm.noOfSections = uint32(fileLen / cOmciDownloadSectionSize)
 	if fileLen%cOmciDownloadSectionSize > 0 {
-		bufferPadding := make([]byte, cOmciDownloadSectionSize-uint32(fileLen%cOmciDownloadSectionSize))
+		bufferPadding := make([]byte, cOmciDownloadSectionSize-uint32((fileLen)%cOmciDownloadSectionSize))
 		//expand the imageBuffer to exactly fit multiples of cOmciDownloadSectionSize with padding
-		oFsm.imageBuffer = append(oFsm.imageBuffer[:fileLen], bufferPadding...)
+		oFsm.imageBuffer = append(oFsm.imageBuffer[:(fileLen)], bufferPadding...)
 		oFsm.noOfSections++
 	}
 	oFsm.origImageLength = uint32(fileLen)
 	oFsm.imageLength = uint32(len(oFsm.imageBuffer))
 
+	go oFsm.waitOnDownloadToOnuReady(ctx, oFsm.chOnuDlReady) // start supervision of the complete download-to-ONU procedure
+
 	logger.Infow(ctx, "OnuUpgradeFsm starts with StartSwDl values", log.Fields{
 		"MeId": oFsm.inactiveImageMeID, "windowSizeLimit": oFsm.omciDownloadWindowSizeLimit,
 		"ImageSize": oFsm.imageLength, "original file size": fileLen})
@@ -457,9 +693,17 @@
 		}
 		if success {
 			//answer received with ready indication
-			go func(a_pAFsm *AdapterFsm) {
-				_ = a_pAFsm.pFsm.Event(upgradeEvRequestActivate)
-			}(pBaseFsm)
+			if oFsm.activateImage {
+				//immediate activation requested
+				go func(a_pAFsm *AdapterFsm) {
+					_ = a_pAFsm.pFsm.Event(upgradeEvRequestActivate)
+				}(pBaseFsm)
+			} else {
+				//have to wait on explicit activation request
+				go func(a_pAFsm *AdapterFsm) {
+					_ = a_pAFsm.pFsm.Event(upgradeEvWaitForActivate)
+				}(pBaseFsm)
+			}
 			return
 		}
 		//timer was aborted
@@ -557,6 +801,16 @@
 func (oFsm *OnuUpgradeFsm) enterResetting(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "OnuUpgradeFsm resetting", log.Fields{"device-id": oFsm.deviceID})
 
+	// in case the download-to-ONU timer is still running - cancel it
+	oFsm.mutexIsAwaitingOnuDlResponse.RLock()
+	if oFsm.isWaitingForOnuDlResponse {
+		oFsm.mutexIsAwaitingOnuDlResponse.RUnlock()
+		//use channel to indicate that the download response waiting shall be aborted for this device (channel)
+		oFsm.chOnuDlReady <- false
+	} else {
+		oFsm.mutexIsAwaitingOnuDlResponse.RUnlock()
+	}
+
 	pConfigupgradeStateAFsm := oFsm.pAdaptFsm
 	if pConfigupgradeStateAFsm != nil {
 		// abort running message processing
@@ -580,12 +834,7 @@
 
 func (oFsm *OnuUpgradeFsm) enterDisabled(ctx context.Context, e *fsm.Event) {
 	logger.Debugw(ctx, "OnuUpgradeFsm enters disabled state", log.Fields{"device-id": oFsm.deviceID})
-	//flush possible left-over channels
-	select {
-	case <-oFsm.chReceiveExpectedResponse:
-		logger.Debug(ctx, "OnuUpgradeFsm chReceiveExpectedResponse flushed", log.Fields{"for device-id": oFsm.deviceID})
-	default:
-	}
+	// no need to flush possible channels here, Upgrade FSM will be completely removed, garbage collector should find its way
 	if oFsm.pDeviceHandler != nil {
 		//request removal of 'reference' in the Handler (completely clear the FSM and its data)
 		go oFsm.pDeviceHandler.removeOnuUpgradeFsm(ctx)
@@ -732,8 +981,13 @@
 						_ = oFsm.pAdaptFsm.pFsm.Event(upgradeEvAbort)
 						return
 					}
-					oFsm.delayEndSwDl = true                                                      //ensure a delay for the EndSwDl message
-					oFsm.imageCRC = crc32a.Checksum(oFsm.imageBuffer[:int(oFsm.origImageLength)]) //store internal for multiple usage
+					oFsm.delayEndSwDl = true //ensure a delay for the EndSwDl message
+					//CRC computation for all data bytes of the file
+					imageCRC := crc32a.Checksum(oFsm.imageBuffer[:int(oFsm.origImageLength)]) //store internal for multiple usage
+					//revert the retrieved CRC Byte Order (seems not to deliver NetworkByteOrder)
+					var byteSlice []byte = make([]byte, 4)
+					binary.LittleEndian.PutUint32(byteSlice, uint32(imageCRC))
+					oFsm.imageCRC = binary.BigEndian.Uint32(byteSlice)
 					_ = oFsm.pAdaptFsm.pFsm.Event(upgradeEvEndSwDownload)
 					return
 				}
@@ -792,6 +1046,14 @@
 			}
 			if msgObj.EntityInstance == oFsm.inactiveImageMeID {
 				logger.Debugw(ctx, "Expected EndSwDlResponse received", log.Fields{"device-id": oFsm.deviceID})
+				oFsm.mutexIsAwaitingOnuDlResponse.RLock()
+				if oFsm.isWaitingForOnuDlResponse {
+					oFsm.mutexIsAwaitingOnuDlResponse.RUnlock()
+					//use channel to indicate that the download to ONU was successful
+					oFsm.chOnuDlReady <- true
+				} else {
+					oFsm.mutexIsAwaitingOnuDlResponse.RUnlock()
+				}
 				oFsm.chReceiveExpectedResponse <- true //let the FSM proceed from the waitState
 				return
 			}
@@ -922,12 +1184,27 @@
 			logger.Debugw(ctx, "OnuUpgradeFsm - GetResponse Data for SoftwareImage",
 				log.Fields{"device-id": oFsm.deviceID, "entityID": msgObj.EntityInstance,
 					"version": imageVersion, "isActive": imageIsActive, "isCommitted": imageIsCommitted})
-
-			//a check on the delivered image version is not done, the ONU delivered version might be different from what might have been
-			//  indicated in the download image version string (version must be part of the image content itself)
-			//  so checking that might be quite unreliable
 			if msgObj.EntityInstance == oFsm.inactiveImageMeID && imageIsActive == swIsActive &&
 				imageIsCommitted == swIsCommitted {
+				//a check on the delivered image version is not done, the ONU delivered version might be different from what might have been
+				//  indicated in the download image version string (version must be part of the image content itself)
+				//  so checking that might be quite unreliable
+				//but with new API this was changed, assumption is that omci image version is known at download request and exactly that is used
+				//  in all the API references, so it can and should be checked here now
+				if oFsm.useAPIVersion43 {
+					if imageVersion != oFsm.imageVersion {
+						//new active version indicated on OMCI from ONU is not the expected version
+						logger.Errorw(ctx, "OnuUpgradeFsm SwImage GetResponse indications not matching requested upgrade",
+							log.Fields{"device-id": oFsm.deviceID, "ResponseMeId": msgObj.EntityInstance,
+								"onu-version": imageVersion, "expected-version": oFsm.imageVersion})
+						// TODO!!!: error treatment?
+						//TODO!!!: possibly send event information for aborted upgrade (aborted by omci processing)??
+						_ = oFsm.pAdaptFsm.pFsm.Event(upgradeEvAbort)
+						return
+					}
+					logger.Debugw(ctx, "OnuUpgradeFsm - expected ONU image version indicated by the ONU",
+						log.Fields{"device-id": oFsm.deviceID})
+				}
 				logger.Infow(ctx, "requested SW image committed, releasing OnuUpgrade", log.Fields{"device-id": oFsm.deviceID})
 				//releasing the upgrade FSM
 				_ = oFsm.pAdaptFsm.pFsm.Event(upgradeEvReset)
@@ -949,23 +1226,106 @@
 	}
 }
 
-/*
-func (oFsm *OnuUpgradeFsm) waitforOmciResponse(ctx context.Context) error {
+//waitOnDownloadToAdapterReady state can only be reached with useAPIVersion43 (usage of pFileManager)
+func (oFsm *OnuUpgradeFsm) waitOnDownloadToAdapterReady(ctx context.Context, aWaitChannel chan bool) {
+	downloadToAdapterTimeout := oFsm.pFileManager.GetDownloadTimeout(ctx)
+	oFsm.mutexIsAwaitingAdapterDlResponse.Lock()
+	oFsm.isWaitingForAdapterDlResponse = true
+	oFsm.mutexIsAwaitingAdapterDlResponse.Unlock()
 	select {
 	// maybe be also some outside cancel (but no context modeled for the moment ...)
 	// case <-ctx.Done():
-	// 		logger.Infow(ctx,"LockState-bridge-init message reception canceled", log.Fields{"for device-id": oFsm.deviceID})
-	case <-time.After(30 * time.Second): //AS FOR THE OTHER OMCI FSM's
-		logger.Warnw(ctx, "OnuUpgradeFsm multi entity timeout", log.Fields{"for device-id": oFsm.deviceID})
-		return fmt.Errorf("OnuUpgradeFsm multi entity timeout %s", oFsm.deviceID)
-	case success := <-oFsm.omciMIdsResponseReceived:
-		if success {
-			logger.Debug(ctx, "OnuUpgradeFsm multi entity response received")
-			return nil
+	// 		logger.Infow("OnuUpgradeFsm-waitOnDownloadToAdapterReady canceled", log.Fields{"for device-id": oFsm.deviceID})
+	case <-time.After(downloadToAdapterTimeout): //10s should be enough for downloading some image to the adapter
+		logger.Warnw(ctx, "OnuUpgradeFsm Waiting-adapter-download timeout", log.Fields{
+			"for device-id": oFsm.deviceID, "image-id": oFsm.imageIdentifier, "timeout": downloadToAdapterTimeout})
+		oFsm.pFileManager.RemoveReadyRequest(ctx, oFsm.imageIdentifier, aWaitChannel)
+		oFsm.mutexIsAwaitingAdapterDlResponse.Lock()
+		oFsm.isWaitingForAdapterDlResponse = false
+		oFsm.mutexIsAwaitingAdapterDlResponse.Unlock()
+		//the upgrade process has to be aborted
+		pUpgradeFsm := oFsm.pAdaptFsm
+		if pUpgradeFsm != nil {
+			_ = pUpgradeFsm.pFsm.Event(upgradeEvReset)
+		} else {
+			logger.Errorw(ctx, "pUpgradeFsm is nil", log.Fields{"device-id": oFsm.deviceID})
 		}
-		// should not happen so far
-		logger.Warnw(ctx, "OnuUpgradeFsm multi entity response error", log.Fields{"for device-id": oFsm.deviceID})
-		return fmt.Errorf("OnuUpgradeFsm multi entity responseError %s", oFsm.deviceID)
+		return
+
+	case success := <-aWaitChannel:
+		if success {
+			logger.Debugw(ctx, "OnuUpgradeFsm image-downloaded received", log.Fields{"device-id": oFsm.deviceID})
+			oFsm.mutexIsAwaitingAdapterDlResponse.Lock()
+			oFsm.isWaitingForAdapterDlResponse = false
+			oFsm.mutexIsAwaitingAdapterDlResponse.Unlock()
+			//let the upgrade process proceed
+			pUpgradeFsm := oFsm.pAdaptFsm
+			if pUpgradeFsm != nil {
+				_ = pUpgradeFsm.pFsm.Event(upgradeEvPrepareSwDownload)
+			} else {
+				logger.Errorw(ctx, "pUpgradeFsm is nil", log.Fields{"device-id": oFsm.deviceID})
+			}
+			return
+		}
+		// waiting was aborted (probably on external request)
+		logger.Debugw(ctx, "OnuUpgradeFsm Waiting-adapter-download aborted", log.Fields{"device-id": oFsm.deviceID})
+		oFsm.pFileManager.RemoveReadyRequest(ctx, oFsm.imageIdentifier, aWaitChannel)
+		oFsm.mutexIsAwaitingAdapterDlResponse.Lock()
+		oFsm.isWaitingForAdapterDlResponse = false
+		oFsm.mutexIsAwaitingAdapterDlResponse.Unlock()
+		//the upgrade process has to be aborted
+		pUpgradeFsm := oFsm.pAdaptFsm
+		if pUpgradeFsm != nil {
+			_ = pUpgradeFsm.pFsm.Event(upgradeEvAbort)
+		} else {
+			logger.Errorw(ctx, "pUpgradeFsm is nil", log.Fields{"device-id": oFsm.deviceID})
+		}
+		return
 	}
 }
-*/
+
+//waitOnDownloadToOnuReady state can only be reached with useAPIVersion43 (usage of pFileManager)
+func (oFsm *OnuUpgradeFsm) waitOnDownloadToOnuReady(ctx context.Context, aWaitChannel chan bool) {
+	downloadToOnuTimeout := time.Duration(1+(oFsm.imageLength/0x400000)) * oFsm.downloadToOnuTimeout4MB
+	logger.Debugw(ctx, "OnuUpgradeFsm start download-to-ONU timer", log.Fields{"device-id": oFsm.deviceID,
+		"duration": downloadToOnuTimeout})
+	oFsm.mutexIsAwaitingOnuDlResponse.Lock()
+	oFsm.isWaitingForOnuDlResponse = true
+	oFsm.mutexIsAwaitingOnuDlResponse.Unlock()
+	select {
+	// maybe be also some outside cancel (but no context modeled for the moment ...)
+	// case <-ctx.Done():
+	// 		logger.Infow("OnuUpgradeFsm-waitOnDownloadToOnuReady canceled", log.Fields{"for device-id": oFsm.deviceID})
+	case <-time.After(downloadToOnuTimeout): //using an image-size depending timout (in minutes)
+		logger.Warnw(ctx, "OnuUpgradeFsm Waiting-ONU-download timeout", log.Fields{
+			"for device-id": oFsm.deviceID, "image-id": oFsm.imageIdentifier, "timeout": downloadToOnuTimeout})
+		oFsm.mutexIsAwaitingOnuDlResponse.Lock()
+		oFsm.isWaitingForOnuDlResponse = false
+		oFsm.mutexIsAwaitingOnuDlResponse.Unlock()
+		//the upgrade process has to be aborted
+		pUpgradeFsm := oFsm.pAdaptFsm
+		if pUpgradeFsm != nil {
+			_ = pUpgradeFsm.pFsm.Event(upgradeEvAbort)
+		} else {
+			logger.Errorw(ctx, "pUpgradeFsm is nil", log.Fields{"device-id": oFsm.deviceID})
+		}
+		return
+
+	case success := <-aWaitChannel:
+		if success {
+			logger.Debugw(ctx, "OnuUpgradeFsm image-downloaded on ONU received", log.Fields{"device-id": oFsm.deviceID})
+			oFsm.mutexIsAwaitingOnuDlResponse.Lock()
+			oFsm.isWaitingForOnuDlResponse = false
+			oFsm.mutexIsAwaitingOnuDlResponse.Unlock()
+			//all fine, let the FSM proceed like defined from the sender of this event
+			return
+		}
+		// waiting was aborted (assumed here to be caused by
+		//   error detection or cancel at download after upgrade FSM reset/abort)
+		logger.Debugw(ctx, "OnuUpgradeFsm Waiting-ONU-download aborted", log.Fields{"device-id": oFsm.deviceID})
+		oFsm.mutexIsAwaitingOnuDlResponse.Lock()
+		oFsm.isWaitingForOnuDlResponse = false
+		oFsm.mutexIsAwaitingOnuDlResponse.Unlock()
+		return
+	}
+}
diff --git a/internal/pkg/onuadaptercore/openonu.go b/internal/pkg/onuadaptercore/openonu.go
index d1d6b09..c61ce5f 100644
--- a/internal/pkg/onuadaptercore/openonu.go
+++ b/internal/pkg/onuadaptercore/openonu.go
@@ -68,10 +68,12 @@
 	maxTimeoutInterAdapterComm time.Duration
 	maxTimeoutReconciling      time.Duration
 	pDownloadManager           *adapterDownloadManager
+	pFileManager               *fileDownloadManager //let coexist 'old and new' DownloadManager as long as 'old' does not get obsolete
 	metricsEnabled             bool
 	mibAuditInterval           time.Duration
 	omciTimeout                int // in seconds
 	alarmAuditInterval         time.Duration
+	dlToOnuTimeout4M           time.Duration
 }
 
 //NewOpenONUAC returns a new instance of OpenONU_AC
@@ -107,6 +109,7 @@
 	// since consumers of OMCI timeout value everywhere in code is in "int seconds", do this useful conversion
 	openOnuAc.omciTimeout = int(cfg.OmciTimeout.Seconds())
 	openOnuAc.alarmAuditInterval = cfg.AlarmAuditInterval
+	openOnuAc.dlToOnuTimeout4M = cfg.DownloadToOnuTimeout4MB
 
 	openOnuAc.pSupportedFsms = &OmciDeviceFsms{
 		"mib-synchronizer": {
@@ -126,6 +129,8 @@
 	}
 
 	openOnuAc.pDownloadManager = newAdapterDownloadManager(ctx)
+	openOnuAc.pFileManager = newFileDownloadManager(ctx)
+	openOnuAc.pFileManager.SetDownloadTimeout(ctx, cfg.DownloadToAdapterTimeout)
 
 	return &openOnuAc
 }
@@ -606,11 +611,87 @@
 }
 
 //if update >= 4.3.0
+// Note: already with the implementation of the 'old' download interface problems were detected when the argument name used here is not the same
+//   as defined in the adapter interface file. That sounds strange and the effects were strange as well.
+//   The reason for that was never finally investigated.
+//   To be on the safe side argument names are left here always as defined in iAdapter.go .
 
 // Download_onu_image downloads (and optionally activates and commits) the indicated ONU image to the requested ONU(s)
 //   if the image is not yet present on the adapter it has to be automatically downloaded
 func (oo *OpenONUAC) Download_onu_image(ctx context.Context, request *voltha.DeviceImageDownloadRequest) (*voltha.DeviceImageResponse, error) {
-	return nil, errors.New("unImplemented")
+	if request != nil && len((*request).DeviceId) > 0 && (*request).Image.Version != "" {
+		loResponse := voltha.DeviceImageResponse{}
+		imageIdentifier := (*request).Image.Version
+		//inform the deviceHandler about (possibly new) requested ONU download requests
+		firstDevice := true
+		var vendorID string
+		for _, pCommonID := range (*request).DeviceId {
+			loDeviceID := (*pCommonID).Id
+			onuVolthaDevice, err := oo.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx),
+				loDeviceID, loDeviceID)
+			if err != nil || onuVolthaDevice == nil {
+				logger.Warnw(ctx, "Failed to fetch Onu device for image download",
+					log.Fields{"device-id": loDeviceID, "err": err})
+				continue //try the work with next deviceId
+			}
+			if firstDevice {
+				//start/verify download of the image to the adapter based on first found device only
+				//  use the OnuVendor identification from first given device
+				firstDevice = false
+				vendorID = onuVolthaDevice.VendorId
+				imageIdentifier = vendorID + imageIdentifier //head on vendor ID of the ONU
+				logger.Debugw(ctx, "download request for file", log.Fields{"image-id": imageIdentifier})
+
+				if !oo.pFileManager.ImageExists(ctx, imageIdentifier) {
+					logger.Debugw(ctx, "start image download", log.Fields{"image-description": request})
+					// Download_image is not supposed to be blocking, anyway let's call the DownloadManager still synchronously to detect 'fast' problems
+					// the download itself is later done in background
+					if err := oo.pFileManager.StartDownload(ctx, imageIdentifier, (*request).Image.Url); err != nil {
+						return nil, err
+					}
+				}
+				// image already exists
+				logger.Debugw(ctx, "image already downloaded", log.Fields{"image-description": imageIdentifier})
+			} else {
+				//for all following devices verify the matching vendorID
+				if onuVolthaDevice.VendorId != vendorID {
+					logger.Warnw(ctx, "onu vendor id does not match image vendor id, device ignored",
+						log.Fields{"onu-vendor-id": onuVolthaDevice.VendorId, "image-vendor-id": vendorID})
+					continue //try the work with next deviceId
+				}
+			}
+			// start the ONU download activity for each possible device
+			// assumption here is, that the concerned device was already created (automatic start after device creation not supported)
+			if handler := oo.getDeviceHandler(ctx, loDeviceID, false); handler != nil {
+				logger.Debugw(ctx, "image download on omci requested", log.Fields{
+					"image-id": imageIdentifier, "device-id": loDeviceID})
+				//onu upgrade handling called in background without immediate error evaluation here
+				//  as the processing can be done for multiple ONU's and an error on one ONU should not stop processing for others
+				//  state/progress/success of the request has to be verified using the Get_onu_image_status() API
+				go handler.onuSwUpgradeAfterDownload(ctx, request, oo.pFileManager, imageIdentifier)
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = (*request).Image.Version
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_STARTED
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_NO_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_UNKNOWN
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			} else {
+				//cannot start ONU download for requested device
+				logger.Warnw(ctx, "no handler found for image activation", log.Fields{"device-id": loDeviceID})
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = (*request).Image.Version
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_FAILED
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_UNKNOWN_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_UNKNOWN
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			}
+		}
+		pImageResp := &loResponse
+		return pImageResp, nil
+	}
+	return nil, errors.New("invalid image download parameters")
 }
 
 // Get_onu_image_status delivers the adapter-related information about the download/activation/commitment
@@ -630,15 +711,93 @@
 }
 
 // Activate_onu_image initiates the activation of the image for the requested ONU(s)
-//  precondition: image downloaded and not yet activated
+//  precondition: image downloaded and not yet activated or image refers to current inactive image
 func (oo *OpenONUAC) Activate_onu_image(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
-	return nil, errors.New("unImplemented")
+	if in != nil && len((*in).DeviceId) > 0 && (*in).Version != "" {
+		loResponse := voltha.DeviceImageResponse{}
+		imageIdentifier := (*in).Version
+		//let the deviceHandler find the adequate way of requesting the image activation
+		for _, pCommonID := range (*in).DeviceId {
+			loDeviceID := (*pCommonID).Id
+			//compared to download procedure the vendorID (from device) is secondary here
+			//   and only needed in case the upgrade process is based on some ongoing download process (and can be retrieved in deviceHandler if needed)
+			// start image activation activity for each possible device
+			// assumption here is, that the concerned device was already created (automatic start after device creation not supported)
+			if handler := oo.getDeviceHandler(ctx, loDeviceID, false); handler != nil {
+				logger.Debugw(ctx, "onu image activation requested", log.Fields{
+					"image-id": imageIdentifier, "device-id": loDeviceID})
+				//onu activation handling called in background without immediate error evaluation here
+				//  as the processing can be done for multiple ONU's and an error on one ONU should not stop processing for others
+				//  state/progress/success of the request has to be verified using the Get_onu_image_status() API
+				go handler.onuSwActivateRequest(ctx, imageIdentifier, (*in).CommitOnSuccess)
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = imageIdentifier
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_NO_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_ACTIVATING
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			} else {
+				//cannot start SW activation for requested device
+				logger.Warnw(ctx, "no handler found for image activation", log.Fields{"device-id": loDeviceID})
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = imageIdentifier
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_UNKNOWN_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_ACTIVATION_ABORTED
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			}
+		}
+		pImageResp := &loResponse
+		return pImageResp, nil
+	}
+	return nil, errors.New("invalid image activation parameters")
 }
 
 // Commit_onu_image enforces the commitment of the image for the requested ONU(s)
 //  precondition: image activated and not yet committed
 func (oo *OpenONUAC) Commit_onu_image(ctx context.Context, in *voltha.DeviceImageRequest) (*voltha.DeviceImageResponse, error) {
-	return nil, errors.New("unImplemented")
+	if in != nil && len((*in).DeviceId) > 0 && (*in).Version != "" {
+		loResponse := voltha.DeviceImageResponse{}
+		imageIdentifier := (*in).Version
+		//let the deviceHandler find the adequate way of requesting the image activation
+		for _, pCommonID := range (*in).DeviceId {
+			loDeviceID := (*pCommonID).Id
+			//compared to download procedure the vendorID (from device) is secondary here
+			//   and only needed in case the upgrade process is based on some ongoing download process (and can be retrieved in deviceHandler if needed)
+			// start image activation activity for each possible device
+			// assumption here is, that the concerned device was already created (automatic start after device creation not supported)
+			if handler := oo.getDeviceHandler(ctx, loDeviceID, false); handler != nil {
+				logger.Debugw(ctx, "onu image commitment requested", log.Fields{
+					"image-id": imageIdentifier, "device-id": loDeviceID})
+				//onu commitment handling called in background without immediate error evaluation here
+				//  as the processing can be done for multiple ONU's and an error on one ONU should not stop processing for others
+				//  state/progress/success of the request has to be verified using the Get_onu_image_status() API
+				go handler.onuSwCommitRequest(ctx, imageIdentifier)
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = imageIdentifier
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_NO_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_COMMITTING
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			} else {
+				//cannot start SW commitment for requested device
+				logger.Warnw(ctx, "no handler found for image commitment", log.Fields{"device-id": loDeviceID})
+				loDeviceImageState := voltha.DeviceImageState{}
+				loDeviceImageState.DeviceId = loDeviceID
+				loDeviceImageState.ImageState.Version = imageIdentifier
+				loDeviceImageState.ImageState.DownloadState = voltha.ImageState_DOWNLOAD_UNKNOWN
+				loDeviceImageState.ImageState.Reason = voltha.ImageState_UNKNOWN_ERROR
+				loDeviceImageState.ImageState.ImageState = voltha.ImageState_IMAGE_COMMIT_ABORTED
+				loResponse.DeviceImageStates = append(loResponse.DeviceImageStates, &loDeviceImageState)
+			}
+		}
+		pImageResp := &loResponse
+		return pImageResp, nil
+	}
+	return nil, errors.New("invalid image commitment parameters")
 }
 
 // Adapter interface required methods ################ end #########