static int voltage_from_req(struct vreg *vreg) { int uV = 0; if (vreg->part->uV.mask) uV = GET_PART(vreg, uV); else if (vreg->part->mV.mask) uV = MILLI_TO_MICRO(GET_PART(vreg, mV)); else if (vreg->part->enable_state.mask) uV = GET_PART(vreg, enable_state); else uV = MILLI_TO_MICRO(GET_PART(vreg, mV)); return uV; }
extern "C" cps_api_return_code_t cps_api_get_objs(cps_api_object_t filt, cps_api_object_list_t obj_list, size_t retry_count, size_t ms_delay_between) { cps_api_return_code_t rc; cps_api_get_params_t get_req; if ((rc=cps_api_get_request_init(&get_req))!=cps_api_ret_code_OK) return rc; cps_api_get_request_guard rg(&get_req); cps_api_object_t obj = cps_api_object_list_create_obj_and_append(get_req.filters); if (obj==nullptr) return cps_api_ret_code_ERR; if (!cps_api_object_clone(obj,filt)) return cps_api_ret_code_ERR; if (ms_delay_between==0) ms_delay_between = BASIC_WAIT_TIME; ms_delay_between = MILLI_TO_MICRO(ms_delay_between); cps_api_object_list_t _tmp_lst = get_req.list; get_req.list = obj_list; bool inf = retry_count==0; while (inf || (retry_count >0) ) { rc = cps_api_get(&get_req); if (rc==cps_api_ret_code_OK) break; if (!inf) --retry_count; std_usleep(ms_delay_between); } get_req.list = _tmp_lst; return rc; }
extern "C" cps_api_return_code_t cps_api_commit_one(cps_api_operation_types_t type, cps_api_object_t obj, size_t retry_count, size_t ms_delay_between) { cps_api_transaction_params_t tr; if (cps_api_transaction_init(&tr)!=cps_api_ret_code_OK) { return cps_api_ret_code_ERR; } cps_api_transaction_guard tr_g(&tr); cps_api_key_set_attr(cps_api_object_key(obj),type); if (!cps_api_object_list_append(tr.change_list,obj)) { return cps_api_ret_code_ERR; } bool inf = retry_count==0; if (ms_delay_between==0) ms_delay_between = BASIC_WAIT_TIME; ms_delay_between = MILLI_TO_MICRO(ms_delay_between); cps_api_return_code_t rc = cps_api_ret_code_ERR; while (inf || (retry_count >0) ) { rc = cps_api_commit(&tr); if (rc==cps_api_ret_code_OK) { //since this will be erased by the caller remove it from the transaction list break; } if (!inf) --retry_count; std_usleep(ms_delay_between); } cps_api_object_list_remove(tr.change_list,0); return rc; }
void nas_switch_wait_for_sys_base_mac(hal_mac_addr_t *mac_base) { while (true) { if (nas_switch_get_sys_mac_base(mac_base)== STD_ERR_OK) { break; } EV_LOG(TRACE,NAS_COM, 0, "NAS-COM-MAC","Failed to get system mac.."); std_usleep(MILLI_TO_MICRO(500)); } }
cps_api_return_code_t cps_api_timeout_wait(int handle, fd_set *r_template, size_t timeout_ms,const char *op) { fd_set _rset = *r_template; struct timeval tv; tv.tv_sec = timeout_ms / 1000; tv.tv_usec = MILLI_TO_MICRO(timeout_ms % 1000); //just the milliseconds portion int rc = std_select_ignore_intr(handle+1,&_rset,nullptr,nullptr,&tv,nullptr); if (rc==-1) { EV_LOG(ERR,DSAPI,0,op,"CPS Operation failed - application close"); return cps_api_ret_code_ERR; } if (rc==0) { EV_LOG(ERR,DSAPI,0,op,"CPS Operation failed - application time out"); return cps_api_ret_code_TIMEOUT; } return cps_api_ret_code_OK; }
static bool cache_connect(cps_api_key_t &key, cps_api_channel_t &handle) { std_mutex_simple_lock_guard lg(&cache_lock); cache_entry ce; if (_cache.find(&key,ce,true)) { const static int TM = MILLI_TO_MICRO(1000) * 20; //20 seconds bool expired = (std_get_uptime(nullptr) - ce.last_updated) > TM; if (!expired && (cps_api_connect_owner(&ce.owner, handle)==cps_api_ret_code_OK)) { return true; } else { char buff[SCRATCH_LOG_BUFF]; EV_LOG(TRACE,DSAPI,0,"CPS-NS-CACHE","cache expired for key:%s", cps_api_key_print(&key,buff,sizeof(buff))); _cache.erase(&key); } } return false; }
static cps_api_return_code_t _cps_api_event_service_publish_msg(cps_api_event_service_handle_t handle, cps_api_object_t msg) { STD_ASSERT(msg!=NULL); STD_ASSERT(handle!=NULL); cps_api_key_t *_okey = cps_api_object_key(msg); if (cps_api_key_get_len(_okey) < CPS_OBJ_KEY_SUBCAT_POS) { //likely invalid message return cps_api_ret_code_ERR; } std_event_key_t key; cps_api_to_std_key(&key,_okey); cps_api_to_std_event_map_t *p = handle_to_data(handle); int retry = (int)p->retry; for (; retry > 0 ; --retry) { std_mutex_simple_lock_guard lg(&p->lock); if (!__connect_to_service(handle)) { std_usleep(MILLI_TO_MICRO(1)); continue; } t_std_error rc = std_client_publish_msg_data( handle_to_std_handle(handle), &key, cps_api_object_array(msg), cps_api_object_to_array_len(msg)); if (rc!=STD_ERR_OK) { __close_channel(handle); } else { return cps_api_ret_code_OK; } } return cps_api_ret_code_ERR; }
static cps_api_return_code_t _cps_api_wait_for_event( cps_api_event_service_handle_t handle, cps_api_object_t msg) { std_event_msg_t m; while (true) { std_event_client_handle h; cps_api_to_std_event_map_t *p = handle_to_data(handle); { std_mutex_simple_lock_guard lg(&p->lock); if (!__connect_to_service(handle)) { //retry every 50ms std_usleep(MILLI_TO_MICRO(50)); continue; } h = handle_to_std_handle(handle); } if (std_client_wait_for_event_data(h,&m, cps_api_object_array(msg), cps_api_object_get_reserve_len(msg))!=STD_ERR_OK) { __close_channel(handle); continue; } if (!cps_api_object_received(msg,m.data_len)) { EV_LOG(ERR,DSAPI,0,"CPS-EV-RX","Invalid message received... returning to client"); __close_channel(handle); continue; } break; } return cps_api_ret_code_OK; }