| /* |
| <:copyright-BRCM:2016:DUAL/GPL:standard |
| |
| Broadcom Proprietary and Confidential.(c) 2016 Broadcom |
| All Rights Reserved |
| |
| Unless you and Broadcom execute a separate written software license |
| agreement governing use of this software, this software is licensed |
| to you under the terms of the GNU General Public License version 2 |
| (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php, |
| with the following added to such license: |
| |
| As a special exception, the copyright holders of this software give |
| you permission to link this software with independent modules, and |
| to copy and distribute the resulting executable under terms of your |
| choice, provided that you also meet, for each linked independent |
| module, the terms and conditions of the license of that module. |
| An independent module is a module which is not derived from this |
| software. The special exception does not apply to any modifications |
| of the software. |
| |
| Not withstanding the above, under no circumstances may you combine |
| this software in any way with any other Broadcom software provided |
| under a license other than the GPL, without Broadcom's express prior |
| written consent. |
| |
| :> |
| */ |
| |
| #include <bcmos_system.h> |
| #include <bcmolt_api.h> |
| #include <bcmolt_msg_pack.h> |
| #include <bcmolt_model_types.h> |
| #include <bcm_dev_log.h> |
| #include "bcmolt_user_appl_ps.h" |
| #include "bcmolt_user_appl_ps_internal.h" |
| |
| #ifndef SIMULATION_BUILD |
| #include <bcmolt_board.h> |
| #endif |
| |
| #define PS_DEFAULT_MAX_PAIRS 16 |
| #define PS_TASK_MSG_Q_SIZE 64 |
| |
| typedef struct |
| { |
| bcmolt_ps_pair pair; |
| bcmos_bool is_valid; |
| } ps_pair_state; |
| |
| typedef struct |
| { |
| bcmos_bool is_running; |
| bcmolt_ps_global_cfg cfg; |
| ps_pair_state *pairs; |
| uint32_t switch_start_time_us; |
| } ps_global_state; |
| |
| typedef struct |
| { |
| bcmos_msg os_msg; |
| bcmolt_ps_pon pon; |
| bcmolt_auto *ind; |
| } ps_task_msg; |
| |
| typedef enum |
| { |
| PS_PON_MODE_INVALID, |
| PS_PON_MODE_GPON, |
| PS_PON_MODE_EPON, |
| PS_PON_MODE_XGPON, |
| } ps_pon_mode; |
| |
| static ps_global_state ps_state = {}; |
| static bcmos_mutex ps_mutex; |
| static bcmos_task ps_task; |
| |
| #ifdef ENABLE_LOG |
| static dev_log_id ps_log_id; |
| dev_log_id ps_get_log_id(void) |
| { |
| return ps_log_id; |
| } |
| #endif |
| |
| static inline bcmos_bool ps_pon_equal(const bcmolt_ps_pon *a, const bcmolt_ps_pon *b) |
| { |
| return a->device_id == b->device_id && a->pon_id == b->pon_id; |
| } |
| |
| static inline bcmos_bool ps_pair_equal(const bcmolt_ps_pair *a, const bcmolt_ps_pair *b) |
| { |
| return ps_pon_equal(&a->standby, &b->standby) && ps_pon_equal(&a->working, &b->working); |
| } |
| |
| static bcmos_errno bcmolt_ps_pon_pair_get(const bcmolt_ps_pon *pon, bcmolt_ps_pair **pair) |
| { |
| uint16_t i; |
| |
| if (!ps_state.is_running) |
| { |
| *pair = NULL; |
| PS_ERR("PS application not running\n"); |
| return BCM_ERR_STATE; |
| } |
| |
| for (i = 0; i < ps_state.cfg.max_num_pairs; i++) |
| { |
| if (ps_state.pairs[i].is_valid) |
| { |
| if (ps_pon_equal(pon, &ps_state.pairs[i].pair.standby) || |
| ps_pon_equal(pon, &ps_state.pairs[i].pair.working)) |
| { |
| *pair = &ps_state.pairs[i].pair; |
| return BCM_ERR_OK; |
| } |
| } |
| } |
| |
| return BCM_ERR_NOENT; |
| } |
| |
| static bcmos_errno ps_init_task(void) |
| { |
| bcmos_task_parm task_params = |
| { |
| .name = "user_appl_ps", |
| .priority = TASK_PRIORITY_USER_APPL_PS, |
| .core = BCMOS_CPU_CORE_ANY, /* No CPU affinity */ |
| .init_handler = NULL |
| }; |
| |
| return bcmos_task_create(&ps_task, &task_params); |
| } |
| |
| static bcmos_errno ps_init_module(void) |
| { |
| bcmos_module_parm module_params = |
| { |
| .qparm = { .name = "user_appl_ps", .size = PS_TASK_MSG_Q_SIZE } |
| }; |
| |
| return bcmos_module_create(BCMOS_MODULE_ID_USER_APPL_PS, &ps_task, &module_params); |
| } |
| |
| static ps_pon_mode ps_pon_mode_get(bcmolt_devid dev) |
| { |
| bcmos_errno err; |
| bcmolt_system_mode system_mode; |
| |
| err = bcmolt_system_mode_get(dev, &system_mode); |
| if (err != BCM_ERR_OK) |
| { |
| return PS_PON_MODE_INVALID; |
| } |
| switch (system_mode) |
| { |
| case BCMOLT_SYSTEM_MODE_GPON__4_X: |
| case BCMOLT_SYSTEM_MODE_GPON__8_X: |
| case BCMOLT_SYSTEM_MODE_GPON__16_X: |
| return PS_PON_MODE_GPON; |
| case BCMOLT_SYSTEM_MODE_EPON__16_X: |
| case BCMOLT_SYSTEM_MODE_EPON__8_X: |
| case BCMOLT_SYSTEM_MODE_EPON__4_X: |
| case BCMOLT_SYSTEM_MODE_EPON__8_X_COEXISTENCE_TDMA: |
| case BCMOLT_SYSTEM_MODE_EPON__4_X_COEXISTENCE_TDMA: |
| case BCMOLT_SYSTEM_MODE_EPON__8_X_10_G: |
| case BCMOLT_SYSTEM_MODE_EPON__4_X_10_G: |
| case BCMOLT_SYSTEM_MODE_EPON__2_X_10_G: |
| return PS_PON_MODE_EPON; |
| case BCMOLT_SYSTEM_MODE_XGPON_1__4_X: |
| case BCMOLT_SYSTEM_MODE_XGPON_1__8_X: |
| case BCMOLT_SYSTEM_MODE_XGS__2_X_10_G: |
| case BCMOLT_SYSTEM_MODE_NGPON2__2_X_10_G: |
| return PS_PON_MODE_XGPON; |
| default: |
| return PS_PON_MODE_INVALID; |
| } |
| } |
| |
| static void ps_handle_msg(bcmos_module_id module_id, bcmos_msg *os_msg) |
| { |
| ps_task_msg *msg = (ps_task_msg *)os_msg; |
| bcmos_errno err; |
| |
| /* process the indication */ |
| if (msg->ind->hdr.obj_type == BCMOLT_OBJ_ID_DEVICE || msg->ind->hdr.obj_type == BCMOLT_OBJ_ID_DEBUG) |
| { |
| /* there's no need to mirror device-level indications */ |
| err = BCM_ERR_OK; |
| } |
| else |
| { |
| switch (ps_pon_mode_get(msg->pon.device_id)) |
| { |
| case PS_PON_MODE_GPON: |
| err = ps_process_ind_gpon(&msg->pon, msg->ind); |
| break; |
| case PS_PON_MODE_EPON: |
| err = ps_process_ind_epon(&msg->pon, msg->ind); |
| break; |
| case PS_PON_MODE_XGPON: |
| err = ps_process_ind_xgpon(&msg->pon, msg->ind); |
| break; |
| default: |
| err = BCM_ERR_STATE; /* not a supported system mode */ |
| break; |
| } |
| } |
| |
| if (err != BCM_ERR_OK) |
| { |
| bcmolt_auto *ind = msg->ind; |
| |
| PS_ERR("Error processing indication (obj_type=%u, subgroup=%u): %s\n", ind->hdr.obj_type, ind->hdr.subgroup, bcmos_strerror(err)); |
| } |
| |
| /* free the cloned indication since we're done processing it */ |
| bcmolt_msg_free(&msg->ind->hdr); |
| |
| /* free the internal OS message handle */ |
| bcmos_free(os_msg); |
| } |
| |
| void bcmolt_ps_appl_init(void) |
| { |
| bcmos_errno err; |
| |
| #ifdef ENABLE_LOG |
| ps_log_id = bcm_dev_log_id_register("user_appl_ps", DEV_LOG_LEVEL_INFO, DEV_LOG_ID_TYPE_BOTH); |
| #endif |
| |
| err = bcmos_mutex_create(&ps_mutex, 0, NULL); |
| BUG_ON(err != BCM_ERR_OK); |
| |
| err = ps_init_task(); |
| BUG_ON(err != BCM_ERR_OK); |
| |
| err = ps_init_module(); |
| BUG_ON(err != BCM_ERR_OK); |
| } |
| |
| bcmos_errno bcmolt_ps_appl_start(const bcmolt_ps_global_cfg *cfg) |
| { |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (ps_state.is_running) |
| { |
| bcmos_mutex_unlock(&ps_mutex); |
| PS_ERR("PS application already running\n"); |
| return BCM_ERR_STATE; |
| } |
| |
| ps_state.cfg = *cfg; |
| ps_state.cfg.max_num_pairs = (ps_state.cfg.max_num_pairs == 0) ? PS_DEFAULT_MAX_PAIRS : ps_state.cfg.max_num_pairs; |
| ps_state.pairs = bcmos_calloc(sizeof(*ps_state.pairs) * ps_state.cfg.max_num_pairs); |
| if (ps_state.pairs == NULL) |
| { |
| BCM_MEMZERO_STRUCT(&ps_state); |
| bcmos_mutex_unlock(&ps_mutex); |
| PS_ERR("memory allocation failed\n"); |
| return BCM_ERR_NOMEM; |
| } |
| |
| ps_state.is_running = BCMOS_TRUE; |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| PS_INFO("PS application started\n"); |
| return BCM_ERR_OK; |
| } |
| |
| bcmos_errno bcmolt_ps_appl_stop(void) |
| { |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| bcmos_mutex_unlock(&ps_mutex); |
| PS_ERR("PS application not running\n"); |
| return BCM_ERR_STATE; |
| } |
| |
| ps_state.is_running = BCMOS_FALSE; |
| |
| bcmos_free(ps_state.pairs); |
| BCM_MEMZERO_STRUCT(&ps_state); |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| PS_INFO("PS application stopped\n"); |
| return BCM_ERR_OK; |
| } |
| |
| bcmos_bool bcmolt_ps_appl_is_running(void) |
| { |
| bcmos_bool ret; |
| bcmos_mutex_lock(&ps_mutex); |
| ret = ps_state.is_running; |
| bcmos_mutex_unlock(&ps_mutex); |
| return ret; |
| } |
| |
| bcmos_errno bcmolt_ps_global_cfg_get(bcmolt_ps_global_cfg *cfg) |
| { |
| bcmos_errno err; |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| PS_ERR("PS application not running\n"); |
| err = BCM_ERR_STATE; |
| } |
| else |
| { |
| *cfg = ps_state.cfg; |
| err = BCM_ERR_OK; |
| } |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| return err; |
| } |
| |
| bcmos_errno bcmolt_ps_global_cfg_update(const bcmolt_ps_global_cfg *cfg) |
| { |
| bcmos_errno err; |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| PS_ERR("PS application not running\n"); |
| err = BCM_ERR_STATE; |
| } |
| else if (cfg->max_num_pairs != ps_state.cfg.max_num_pairs) |
| { |
| PS_ERR("cannot change max number of protected pairs while running\n"); |
| err = BCM_ERR_PARM; |
| } |
| else |
| { |
| ps_state.cfg = *cfg; |
| err = BCM_ERR_OK; |
| } |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| return err; |
| } |
| |
| bcmos_errno bcmolt_ps_pairs_get(uint16_t array_len, bcmolt_ps_pair *pairs, uint16_t *num_written) |
| { |
| bcmos_errno err; |
| uint16_t i; |
| |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| PS_ERR("PS application not running\n"); |
| err = BCM_ERR_STATE; |
| } |
| else |
| { |
| *num_written = 0; |
| err = BCM_ERR_OK; |
| for (i = 0; i < ps_state.cfg.max_num_pairs; i++) |
| { |
| if (ps_state.pairs[i].is_valid) |
| { |
| if (*num_written == array_len) |
| { |
| PS_ERR("array size too small to collect all pairs\n"); |
| err = BCM_ERR_PARM; |
| break; |
| } |
| pairs[*num_written] = ps_state.pairs[i].pair; |
| (*num_written)++; |
| } |
| } |
| } |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| return err; |
| } |
| |
| bcmos_errno bcmolt_ps_pair_add(const bcmolt_ps_pair *pair) |
| { |
| uint16_t i; |
| bcmos_errno err; |
| |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| PS_ERR("PS application not running\n"); |
| err = BCM_ERR_STATE; |
| } |
| else if (ps_pon_equal(&pair->working, &pair->standby)) |
| { |
| PS_ERR("A PON cannot protect itself\n"); |
| err = BCM_ERR_PARM; |
| } |
| else |
| { |
| err = BCM_ERR_OK; |
| for (i = 0; i < ps_state.cfg.max_num_pairs; i++) |
| { |
| if (ps_state.pairs[i].is_valid && |
| (ps_pon_equal(&pair->working, &ps_state.pairs[i].pair.working) || |
| ps_pon_equal(&pair->working, &ps_state.pairs[i].pair.standby) || |
| ps_pon_equal(&pair->standby, &ps_state.pairs[i].pair.working) || |
| ps_pon_equal(&pair->standby, &ps_state.pairs[i].pair.standby))) |
| { |
| PS_ERR("One of the PONs was already present in an existing pair\n"); |
| err = BCM_ERR_ALREADY; |
| break; |
| } |
| } |
| |
| if (err == BCM_ERR_OK) |
| { |
| err = BCM_ERR_NORES; |
| for (i = 0; i < ps_state.cfg.max_num_pairs; i++) |
| { |
| if (!ps_state.pairs[i].is_valid) |
| { |
| ps_state.pairs[i].pair = *pair; |
| ps_state.pairs[i].is_valid = BCMOS_TRUE; |
| err = BCM_ERR_OK; |
| break; |
| } |
| } |
| if (err == BCM_ERR_NORES) |
| { |
| PS_ERR("Not enough memory available to add pair\n"); |
| } |
| } |
| } |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| return err; |
| } |
| |
| bcmos_errno bcmolt_ps_pon_remove(const bcmolt_ps_pon *pon) |
| { |
| uint16_t i; |
| bcmos_errno err; |
| |
| bcmos_mutex_lock(&ps_mutex); |
| |
| if (!ps_state.is_running) |
| { |
| PS_ERR("PS application not running\n"); |
| err = BCM_ERR_STATE; |
| } |
| else |
| { |
| err = BCM_ERR_NOENT; |
| for (i = 0; i < ps_state.cfg.max_num_pairs; i++) |
| { |
| if (ps_state.pairs[i].is_valid && |
| (ps_pon_equal(pon, &ps_state.pairs[i].pair.working) || |
| ps_pon_equal(pon, &ps_state.pairs[i].pair.standby))) |
| { |
| ps_state.pairs[i].is_valid = BCMOS_FALSE; |
| err = BCM_ERR_OK; |
| break; |
| } |
| } |
| if (err == BCM_ERR_NOENT) |
| { |
| PS_ERR("Specified PON not found\n"); |
| } |
| } |
| |
| bcmos_mutex_unlock(&ps_mutex); |
| return err; |
| } |
| |
| bcmos_errno bcmolt_ps_pon_state_get(const bcmolt_ps_pon *pon, bcmolt_ps_pon_state *state, bcmolt_ps_pon *partner) |
| { |
| bcmos_errno err; |
| bcmolt_ps_pair *pair; |
| |
| bcmos_mutex_lock(&ps_mutex); |
| err = bcmolt_ps_pon_pair_get(pon, &pair); |
| bcmos_mutex_unlock(&ps_mutex); |
| |
| if (err == BCM_ERR_OK) |
| { |
| if (ps_pon_equal(pon, &pair->standby)) |
| { |
| *state = BCMOLT_PS_PON_STATE_STANDBY; |
| *partner = pair->working; |
| } |
| else |
| { |
| *state = BCMOLT_PS_PON_STATE_WORKING; |
| *partner = pair->standby; |
| } |
| return BCM_ERR_OK; |
| } |
| else if (err == BCM_ERR_NOENT) |
| { |
| *state = BCMOLT_PS_PON_STATE_UNASSOCIATED; |
| return BCM_ERR_OK; |
| } |
| else |
| { |
| return err; |
| } |
| } |
| |
| bcmos_errno bcmolt_ps_process_ind(const bcmolt_ps_pon *pon, bcmolt_auto *ind) |
| { |
| bcmos_errno err; |
| bcmolt_msg *ind_clone = NULL; |
| |
| if (!bcmolt_ps_appl_is_running()) |
| { |
| return BCM_ERR_OK; |
| } |
| |
| /* Make a copy of all indications received so they can be handled later asynchronously. We don't validate PON state |
| * here since it might change before we get around to handling it. |
| * |
| * Note that this could be optimized to filter out indications that aren't relevant for protection switching before |
| * copying them, but this is left out for simplicity. */ |
| err = bcmolt_msg_clone(&ind_clone, &ind->hdr); |
| if (err != BCM_ERR_OK) |
| { |
| PS_ERR("Indication clone failed: %s\n", bcmos_strerror(err)); |
| return err; |
| } |
| |
| /* send this indication to the internal task's message queue to be processed */ |
| ps_task_msg *msg = bcmos_calloc(sizeof(*msg)); |
| if (msg == NULL) |
| { |
| PS_ERR("Message calloc failed\n"); |
| bcmolt_msg_free(ind_clone); |
| return BCM_ERR_NOMEM; |
| } |
| |
| msg->os_msg.handler = ps_handle_msg; |
| msg->os_msg.release = bcmolt_os_msg_release_cb; |
| msg->pon = *pon; |
| msg->ind = (bcmolt_auto *)ind_clone; |
| |
| err = bcmos_msg_send_to_module(BCMOS_MODULE_ID_USER_APPL_PS, &msg->os_msg, 0); |
| if (err != BCM_ERR_OK) |
| { |
| PS_ERR("Message send failed: %s\n", bcmos_strerror(err)); |
| return err; |
| } |
| |
| return BCM_ERR_OK; |
| } |
| |
| static bcmos_errno bcmolt_ps_change_pon_to_standby(const bcmolt_ps_pon *pon) |
| { |
| bcmos_errno err; |
| |
| PS_INFO("Switching PON <%d:%d> working->standby\n", pon->device_id, pon->pon_id); |
| switch (ps_pon_mode_get(pon->device_id)) |
| { |
| case PS_PON_MODE_GPON: |
| err = ps_move_to_standby_gpon(pon); |
| break; |
| case PS_PON_MODE_EPON: |
| err = ps_move_to_standby_epon(pon); |
| break; |
| case PS_PON_MODE_XGPON: |
| err = ps_move_to_standby_xgpon(pon); |
| break; |
| default: |
| err = BCM_ERR_STATE; /* not a supported system mode */ |
| break; |
| } |
| if (err != BCM_ERR_OK) |
| { |
| PS_ERR("<%d:%d> working->standby API failed: %s\n", pon->device_id, pon->pon_id, bcmos_strerror(err)); |
| } |
| return err; |
| } |
| |
| static bcmos_errno bcmolt_ps_change_pon_to_working(const bcmolt_ps_pon *pon) |
| { |
| bcmos_errno err; |
| |
| PS_INFO("Switching PON <%d:%d> standby->working\n", pon->device_id, pon->pon_id); |
| switch (ps_pon_mode_get(pon->device_id)) |
| { |
| case PS_PON_MODE_GPON: |
| err = ps_move_to_working_gpon(pon); |
| break; |
| case PS_PON_MODE_EPON: |
| err = ps_move_to_working_epon(pon); |
| break; |
| case PS_PON_MODE_XGPON: |
| err = ps_move_to_working_xgpon(pon); |
| break; |
| default: |
| err = BCM_ERR_STATE; /* not a supported system mode */ |
| break; |
| } |
| if (err != BCM_ERR_OK) |
| { |
| PS_ERR("<%d:%d> standby->working API failed: %s\n", pon->device_id, pon->pon_id, bcmos_strerror(err)); |
| } |
| return err; |
| } |
| |
| static bcmos_errno bcmolt_ps_disable_tx_optics(const bcmolt_ps_pon *pon) |
| { |
| PS_INFO("Disabling TRX for PON <%d:%d:%d>\n", pon->device_id, pon->pon_id, pon->transceiver_id); |
| |
| /* This disables the TX optical channel on a given PON port on the BCM68620 SVK board. |
| For other boards, this must be changed to match the board design. */ |
| #ifndef SIMULATION_BUILD |
| return bcm_board_trx_enable(pon->transceiver_id, BCMOS_FALSE); |
| #else |
| return BCM_ERR_OK; |
| #endif |
| } |
| |
| static bcmos_errno bcmolt_ps_enable_tx_optics(const bcmolt_ps_pon *pon) |
| { |
| #ifndef SIMULATION_BUILD |
| bcmos_errno ret; |
| #endif |
| |
| PS_INFO("Enabling TRX for PON <%d:%d:%d>\n", pon->device_id, pon->pon_id, pon->transceiver_id); |
| |
| /* This enables the TX optical channel on a given PON port on the BCM68620 SVK board. |
| For other boards, this must be changed to match the board design. */ |
| #ifndef SIMULATION_BUILD |
| ret = bcm_board_trx_enable(pon->transceiver_id, BCMOS_TRUE); |
| bcmos_usleep(ps_state.cfg.trx_warming_delay); |
| return ret; |
| #else |
| return BCM_ERR_OK; |
| #endif |
| } |
| |
| bcmos_errno bcmolt_ps_switch_perform(const bcmolt_ps_pon *pon) |
| { |
| bcmos_errno err; |
| bcmolt_ps_pair *pair; |
| bcmolt_ps_pon temp_pon; |
| |
| bcmos_mutex_lock(&ps_mutex); |
| ps_state.switch_start_time_us = bcmos_timestamp(); |
| err = bcmolt_ps_pon_pair_get(pon, &pair); |
| bcmos_mutex_unlock(&ps_mutex); |
| |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| if (ps_state.cfg.switch_sequence == BCMOLT_PS_SWITCH_SEQUENCE_TRX_FIRST) |
| { |
| /* step 1: disable optical TX channel of the working PON */ |
| err = bcmolt_ps_disable_tx_optics(&pair->working); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 2: enable optical TX channel of the standby PON */ |
| err = bcmolt_ps_enable_tx_optics(&pair->standby); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 3: change the standby PON state to working */ |
| err = bcmolt_ps_change_pon_to_working(&pair->standby); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 4: change the working PON state to standby */ |
| err = bcmolt_ps_change_pon_to_standby(&pair->working); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| } |
| else /* ps_state.cfg.switch_sequence == BCMOLT_PS_SWITCH_SEQUENCE_STANDARD */ |
| { |
| /* step 1: change the working PON state to standby */ |
| err = bcmolt_ps_change_pon_to_standby(&pair->working); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 2: disable optical TX channel of the working PON */ |
| err = bcmolt_ps_disable_tx_optics(&pair->working); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 3: enable optical TX channel of the standby PON */ |
| err = bcmolt_ps_enable_tx_optics(&pair->standby); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| |
| /* step 4: change the standby PON state to working */ |
| err = bcmolt_ps_change_pon_to_working(&pair->standby); |
| if (err != BCM_ERR_OK) |
| { |
| goto exit; |
| } |
| } |
| |
| /* step 5: update internal database for new PON states */ |
| bcmos_mutex_lock(&ps_mutex); |
| temp_pon = pair->working; |
| pair->working = pair->standby; |
| pair->standby = temp_pon; |
| bcmos_mutex_unlock(&ps_mutex); |
| |
| exit: |
| if (err == BCM_ERR_OK) |
| { |
| PS_INFO( |
| "<%d:%d> switchover started successfully (<%d:%d> is now standby)\n", |
| pair->working.device_id, |
| pair->working.pon_id, |
| pair->standby.device_id, |
| pair->standby.pon_id); |
| } |
| else if (pair) |
| { |
| PS_INFO( |
| "<%d:%d> switchover encountered an error: %s\n", |
| pair->working.device_id, |
| pair->working.pon_id, |
| bcmos_strerror(err)); |
| } |
| |
| return err; |
| } |
| |
| uint32_t ps_get_last_switch_start_time_us(void) |
| { |
| uint32_t ret; |
| bcmos_mutex_lock(&ps_mutex); |
| ret = ps_state.switch_start_time_us; |
| bcmos_mutex_unlock(&ps_mutex); |
| return ret; |
| } |