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