update_client_hub_event_handlers.c

00001 // ----------------------------------------------------------------------------
00002 // Copyright 2016-2017 ARM Ltd.
00003 //
00004 // SPDX-License-Identifier: Apache-2.0
00005 //
00006 // Licensed under the Apache License, Version 2.0 (the "License");
00007 // you may not use this file except in compliance with the License.
00008 // You may obtain a copy of the License at
00009 //
00010 //     http://www.apache.org/licenses/LICENSE-2.0
00011 //
00012 // Unless required by applicable law or agreed to in writing, software
00013 // distributed under the License is distributed on an "AS IS" BASIS,
00014 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00015 // See the License for the specific language governing permissions and
00016 // limitations under the License.
00017 // ----------------------------------------------------------------------------
00018 
00019 #include "update_client_hub_event_handlers.h"
00020 #include "update_client_hub_error_handler.h"
00021 
00022 #include "update_client_hub_state_machine.h"
00023 
00024 #include "update-client-common/arm_uc_common.h"
00025 #include "update-client-firmware-manager/arm_uc_firmware_manager.h"
00026 #include "update-client-manifest-manager/update-client-manifest-manager.h"
00027 #include "update-client-source-manager/arm_uc_source_manager.h"
00028 #include "update-client-control-center/arm_uc_control_center.h"
00029 
00030 /**
00031  * @brief event handler registered with the firmware manager
00032  *        events drive state changes of the state machine
00033  */
00034 void ARM_UC_HUB_FirmwareManagerEventHandler(uint32_t event)
00035 {
00036     arm_uc_hub_state_t arm_uc_hub_state = ARM_UC_HUB_getState();
00037 
00038     switch(event)
00039     {
00040         /* Firmware writing setup complete */
00041         case UCFM_EVENT_PREPARE_DONE:
00042             UC_HUB_TRACE("UCFM_EVENT_PREPARE_DONE");
00043 
00044             /* Storage prepared for firmware. Download first fragment. */
00045             if (arm_uc_hub_state == ARM_UC_HUB_STATE_SETUP_FIRMWARE)
00046             {
00047                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_FETCH_FIRST_FRAGMENT);
00048             }
00049             else
00050             {
00051                 /* Invalid state, abort and report error. */
00052                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00053             }
00054             break;
00055 
00056         /* Firmware fragment written */
00057         case UCFM_EVENT_WRITE_DONE:
00058             UC_HUB_TRACE("UCFM_EVENT_WRITE_DONE");
00059 
00060             /* Firmware fragment stored */
00061 
00062             /* Fragment stored before network could finish,
00063                i.e., network is the bottleneck:
00064                Action:
00065                 - wait for network to complete
00066             */
00067             if (arm_uc_hub_state == ARM_UC_HUB_STATE_STORE_AND_DOWNLOAD)
00068             {
00069                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_WAIT_FOR_NETWORK);
00070             }
00071             /* Fragment stored after network finished,
00072                i.e, storage is the bottleneck:
00073                Action:
00074                 - store fragment
00075                 - download next fragment
00076             */
00077             else if (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_STORAGE)
00078             {
00079                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_STORE_AND_DOWNLOAD);
00080             }
00081             /* Last fragment stored.
00082                Action:
00083                 - finalize storage
00084             */
00085             else if (arm_uc_hub_state == ARM_UC_HUB_STATE_STORE_LAST_FRAGMENT)
00086             {
00087                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_FINALIZE_STORAGE);
00088             }
00089             else
00090             {
00091                 /* Invalid state, abort and report error. */
00092                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00093             }
00094             break;
00095 
00096         /* Final firmware fragment written and commited */
00097         case UCFM_EVENT_FINALIZE_DONE:
00098             UC_HUB_TRACE("UCFM_EVENT_FINALIZE_DONE");
00099 
00100             /* Firmware stored and verified. */
00101             if (arm_uc_hub_state == ARM_UC_HUB_STATE_FINALIZE_STORAGE)
00102             {
00103                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_STORAGE_FINALIZED);
00104             }
00105             else
00106             {
00107                 /* Invalid state, abort and report error. */
00108                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00109             }
00110             break;
00111 
00112         /* Firmware image marked as active or installed */
00113         case UCFM_EVENT_ACTIVATE_DONE:
00114             UC_HUB_TRACE("UCFM_EVENT_ACTIVATE_DONE");
00115 
00116             /* Firmware activated. Reboot system. */
00117             if (arm_uc_hub_state == ARM_UC_HUB_STATE_ACTIVATE_FIRMWARE)
00118             {
00119                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_REBOOT);
00120             }
00121             else
00122             {
00123                 /* Invalid state, abort and report error. */
00124                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00125             }
00126             break;
00127 
00128         case UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_DONE:
00129             UC_HUB_TRACE("UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_DONE");
00130 
00131             ARM_UC_HUB_setState(ARM_UC_HUB_STATE_REPORT_ACTIVE_HASH);
00132             break;
00133 
00134         case UCFM_EVENT_GET_INSTALLER_DETAILS_DONE:
00135             UC_HUB_TRACE("UCFM_EVENT_GET_INSTALLER_DETAILS_DONE");
00136 
00137             ARM_UC_HUB_setState(ARM_UC_HUB_STATE_REPORT_INSTALLER_DETAILS);
00138             break;
00139 
00140         /* Encountered error while writing firmware */
00141         case UCFM_EVENT_WRITE_ERROR:
00142             UC_HUB_TRACE("UCFM_EVENT_WRITE_ERROR");
00143 
00144             if ((arm_uc_hub_state == ARM_UC_HUB_STATE_STORE_AND_DOWNLOAD) ||
00145                 (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_STORAGE) ||
00146                 (arm_uc_hub_state == ARM_UC_HUB_STATE_STORE_LAST_FRAGMENT))
00147             {
00148                 /* write error. */
00149                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_WRITE, arm_uc_hub_state);
00150             }
00151             else
00152             {
00153                 /* Invalid state, abort and report error. */
00154                 ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00155             }
00156             break;
00157 
00158         /* Encountered error while committing final firmware fragment */
00159         case UCFM_EVENT_FINALIZE_ERROR:
00160             UC_HUB_TRACE("UCFM_EVENT_FINALIZE_ERROR");
00161 
00162             /* Invalid state, abort and report error. */
00163             ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00164             break;
00165 
00166 
00167         /* Got an unexpected hash of the firmare image */
00168         case UCFM_EVENT_FINALIZE_INVALID_HASH_ERROR:
00169             UC_HUB_TRACE("UCFM_EVENT_FINALIZE_INVALID_HASH_ERROR");
00170 
00171             /* Invalid state, abort and report error. */
00172             ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_HASH, arm_uc_hub_state);
00173             break;
00174 
00175         /* Encountered error while trying to activate or install firmware image */
00176         case UCFM_EVENT_ACTIVATE_ERROR:
00177             UC_HUB_TRACE("UCFM_EVENT_ACTIVATE_ERROR");
00178 
00179             /* Invalid state, abort and report error. */
00180             ARM_UC_HUB_ErrorHandler(FIRM_ERR_ACTIVATE, arm_uc_hub_state);
00181             break;
00182 
00183         case UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_ERROR:
00184             /* client should be able to proceed as normal */
00185             UC_HUB_TRACE("UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_ERROR");
00186 
00187             ARM_UC_HUB_setState(ARM_UC_HUB_STATE_GET_INSTALLER_DETAILS);
00188             break;
00189 
00190         case UCFM_EVENT_GET_INSTALLER_DETAILS_ERROR:
00191             /* client should be able to proceed as normal */
00192             UC_HUB_TRACE("UCFM_EVENT_GET_INSTALLER_DETAILS_ERROR");
00193 
00194             ARM_UC_HUB_setState(ARM_UC_HUB_STATE_IDLE);
00195             break;
00196 
00197         case UCFM_EVENT_INITIALIZE_DONE:
00198             /* TODO Fix whole call chain to support async init */
00199             /* swallow async init done event here */
00200             UC_HUB_TRACE("UCFM_EVENT_INITIALIZE_DONE");
00201             break;
00202 
00203         case UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE:
00204             UC_HUB_TRACE("UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE");
00205             break;
00206 
00207         case UCFM_EVENT_INITIALIZE_ERROR:
00208             UC_HUB_TRACE("UCFM_EVENT_INITIALIZE_ERROR");
00209             break;
00210 
00211         case UCFM_EVENT_PREPARE_ERROR:
00212             UC_HUB_TRACE("UCFM_EVENT_PREPARE_ERROR");
00213             break;
00214 
00215         case UCFM_EVENT_GET_FIRMWARE_DETAILS_ERROR:
00216             UC_HUB_TRACE("UCFM_EVENT_GET_FIRMWARE_DETAILS_ERROR");
00217             break;
00218 
00219         default:
00220             UC_HUB_TRACE("Firmware Manager: Invalid Event: %" PRIu32, event);
00221 
00222             /* Invalid state, abort and report error. */
00223             ARM_UC_HUB_ErrorHandler(FIRM_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00224             break;
00225     }
00226 }
00227 
00228 /**
00229  * @brief event handler registered with the manifest manager
00230  *        events drive state changes of the state machine
00231  */
00232 void ARM_UC_HUB_ManifestManagerEventHandler(uint32_t event)
00233 {
00234     arm_uc_hub_state_t arm_uc_hub_state = ARM_UC_HUB_getState();
00235 
00236     if (event == ARM_UC_MM_RC_ERROR && arm_uc_hub_state == ARM_UC_HUB_STATE_INITIALIZING)
00237     {
00238         // TODO: An empty config store may be an error in the future.
00239         if (ARM_UC_mmGetError().code == MFST_ERR_NO_MANIFEST)
00240         {
00241             event = ARM_UC_MM_RC_DONE;
00242         }
00243     }
00244     switch(event)
00245     {
00246         /* Status: The manifest manager failed during the previous operation.
00247            Extract further error information using ARM_UC_mmGetError.
00248         */
00249         case ARM_UC_MM_RC_ERROR:
00250             UC_HUB_TRACE("ARM_UC_MM_RC_ERROR");
00251 
00252             /* Report error. */
00253             ARM_UC_HUB_ErrorHandler(ARM_UC_mmGetError().code, arm_uc_hub_state);
00254             break;
00255 
00256         /* Unused */
00257         case ARM_UC_MM_RC_NONE:
00258             UC_HUB_TRACE("ARM_UC_MM_RC_NONE");
00259 
00260             /* Invalid state, abort and report error. */
00261             ARM_UC_HUB_ErrorHandler(MFST_ERR_INVALID_STATE, arm_uc_hub_state);
00262             break;
00263 
00264         /* Action: The firmware manager needs the manifest specified by
00265            ARM_UC_mmGetCurrentManifestDependency in order to keep processing
00266            the firmware update.
00267         */
00268         case ARM_UC_MM_RC_NEED_DEP:
00269             UC_HUB_TRACE("ARM_UC_MM_RC_NEED_DEP");
00270 
00271             /* Invalid state, abort and report error. */
00272             ARM_UC_HUB_ErrorHandler(MFST_ERR_NO_MANIFEST, arm_uc_hub_state);
00273             break;
00274 
00275         /* Action: The firmware manager needs the firmware specified by
00276            ARM_UC_mmGetFirmwareInfo in order to keep processing the firmware
00277            update.
00278         */
00279         case ARM_UC_MM_RC_NEED_FW:
00280             UC_HUB_TRACE("ARM_UC_MM_RC_NEED_FW");
00281 
00282             /* Download firmware by first reading information from manifest */
00283             if(arm_uc_hub_state == ARM_UC_HUB_STATE_MANIFEST_COMPLETE)
00284             {
00285                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_CHECK_VERSION);
00286             }
00287             else
00288             {
00289                 /* Invalid state, abort and report error. */
00290                 ARM_UC_HUB_ErrorHandler(MFST_ERR_INVALID_STATE, arm_uc_hub_state);
00291             }
00292             break;
00293 
00294         /* Status: The last operation completed successfully */
00295         case ARM_UC_MM_RC_DONE:
00296             UC_HUB_TRACE("ARM_UC_MM_RC_DONE");
00297 
00298             /* Update Hub has been initialized. */
00299             if(arm_uc_hub_state == ARM_UC_HUB_STATE_INITIALIZING)
00300             {
00301                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_INITIALIZED);
00302             }
00303             /* Manifest processed */
00304             else if(arm_uc_hub_state == ARM_UC_HUB_STATE_MANIFEST_FETCHED)
00305             {
00306                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_MANIFEST_COMPLETE);
00307             }
00308             else
00309             {
00310                 /* Invalid state, abort and report error. */
00311                 ARM_UC_HUB_ErrorHandler(MFST_ERR_INVALID_STATE, arm_uc_hub_state);
00312             }
00313             break;
00314 
00315         default:
00316             UC_HUB_TRACE("Manifest Manager: Invalid Event");
00317 
00318             /* Invalid state, abort and report error. */
00319             ARM_UC_HUB_ErrorHandler(MFST_ERR_BAD_EVENT, arm_uc_hub_state);
00320             break;
00321     }
00322 }
00323 
00324 /**
00325  * @brief event handler registered with the source manager
00326  *        events drive state changes of the state machine
00327  */
00328 void ARM_UC_HUB_SourceManagerEventHandler(uint32_t event)
00329 {
00330     arm_uc_hub_state_t arm_uc_hub_state = ARM_UC_HUB_getState();
00331 
00332     switch(event)
00333     {
00334         /* Received notification */
00335         case ARM_UC_SM_EVENT_NOTIFICATION:
00336             UC_HUB_TRACE("ARM_UC_SM_EVENT_NOTIFICATION");
00337 
00338             /* Fetch manifest */
00339             if(arm_uc_hub_state == ARM_UC_HUB_STATE_IDLE)
00340             {
00341                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_NOTIFIED);
00342             }
00343             /* No else. All notifications are ignored during an ongoing update. */
00344             break;
00345 
00346         /* Downloaded manifest */
00347         case ARM_UC_SM_EVENT_MANIFEST:
00348             UC_HUB_TRACE("ARM_UC_SM_EVENT_MANIFEST");
00349 
00350             /* Process the newly downloaded manifest */
00351             if (arm_uc_hub_state == ARM_UC_HUB_STATE_NOTIFIED)
00352             {
00353                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_MANIFEST_FETCHED);
00354             }
00355             else
00356             {
00357                 /* Invalid state, abort and report error. */
00358                 ARM_UC_HUB_ErrorHandler(SOMA_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00359             }
00360             break;
00361 
00362         /* Downloaded firmware fragment */
00363         case ARM_UC_SM_EVENT_FIRMWARE:
00364             UC_HUB_TRACE("ARM_UC_SM_EVENT_FIRMWARE");
00365 
00366             /* Received firmware fragment */
00367 
00368             /* 1. First fragment received, source and storage idle, or,
00369                2. N fragment received after storage went idle.
00370                Action:
00371                 - store fragment
00372                 - download next fragment
00373             */
00374             if ((arm_uc_hub_state == ARM_UC_HUB_STATE_FETCH_FIRST_FRAGMENT) ||
00375                 (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_NETWORK))
00376             {
00377                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_STORE_AND_DOWNLOAD);
00378             }
00379             /* 1. N fragment received, storing still in progress,
00380                i.e., the storage is the bottleneck:
00381                - All buffers are in use, wait for storage
00382             */
00383             else if (arm_uc_hub_state == ARM_UC_HUB_STATE_STORE_AND_DOWNLOAD)
00384             {
00385                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_WAIT_FOR_STORAGE);
00386             }
00387             /* Invalid state, abort and report error. */
00388             else
00389             {
00390                 ARM_UC_HUB_ErrorHandler(SOMA_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00391             }
00392             break;
00393 
00394         /* Downloaded keytable */
00395         case ARM_UC_SM_EVENT_KEYTABLE:
00396             UC_HUB_TRACE("ARM_UC_SM_EVENT_KEYTABLE");
00397 
00398             /* Invalid state, abort and report error. */
00399             ARM_UC_HUB_ErrorHandler(SOMA_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00400             break;
00401 
00402         /* Source Manager encountered an error */
00403         case ARM_UC_SM_EVENT_ERROR:
00404             UC_HUB_TRACE("ARM_UC_SM_EVENT_ERROR");
00405 
00406             /* Invalid state, abort and report error. */
00407             ARM_UC_HUB_ErrorHandler(SOMA_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00408             break;
00409 
00410         default:
00411             UC_HUB_TRACE("Source Manager: Invalid Event");
00412 
00413             /* Invalid state, abort and report error. */
00414             ARM_UC_HUB_ErrorHandler(SOMA_ERR_INVALID_PARAMETER, arm_uc_hub_state);
00415             break;
00416     }
00417 }
00418 
00419 void ARM_UC_HUB_ControlCenterEventHandler(uint32_t event)
00420 {
00421     arm_uc_hub_state_t arm_uc_hub_state = ARM_UC_HUB_getState();
00422 
00423     switch(event)
00424     {
00425         case ARM_UCCC_EVENT_AUTHORIZE_DOWNLOAD:
00426             UC_HUB_TRACE("ARM_UCCC_EVENT_AUTHORIZE_DOWNLOAD");
00427 
00428             if (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_DOWNLOAD_AUTHORIZATION)
00429             {
00430                 /* Download approved. Download firmware. */
00431                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_DOWNLOAD_AUTHORIZED);
00432             }
00433             break;
00434 
00435         case ARM_UCCC_EVENT_AUTHORIZE_INSTALL:
00436             UC_HUB_TRACE("ARM_UCCC_EVENT_AUTHORIZE_INSTALL");
00437 
00438             if (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_INSTALL_AUTHORIZATION)
00439             {
00440                 /* Installation approved. Set firmware as active image and reboot. */
00441                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_INSTALL_AUTHORIZED);
00442             }
00443             break;
00444 
00445         case ARM_UCCC_EVENT_MONITOR_SEND_DONE:
00446             UC_HUB_TRACE("ARM_UCCC_EVENT_MONITOR_SEND_DONE");
00447 
00448             if (arm_uc_hub_state == ARM_UC_HUB_STATE_WAIT_FOR_ERROR_ACK)
00449             {
00450                 /* Switch to 'idle' after receiving report notification */
00451                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_IDLE);
00452             }
00453 
00454 /* TODO: use timeout to ensure callback doesn't stall reboot */
00455 #if 0
00456             if (arm_uc_hub_state == ARM_UC_HUB_STATE_INSTALL_AUTHORIZED)
00457             {
00458                 ARM_UC_HUB_setState(ARM_UC_HUB_STATE_REBOOT);
00459             }
00460 #endif
00461             break;
00462 
00463         default:
00464             UC_HUB_TRACE("Control Center: Invalid Event");
00465 
00466             /* Invalid state, abort and report error. */
00467             ARM_UC_HUB_ErrorHandler(ERR_INVALID_PARAMETER, arm_uc_hub_state);
00468             break;
00469     }
00470 }