uint32_t app_gpiote_user_register(app_gpiote_user_id_t * p_user_id, uint32_t pins_low_to_high_mask, uint32_t pins_high_to_low_mask, app_gpiote_event_handler_t event_handler) { //Check state and parameters. VERIFY_MODULE_INITIALIZED(); if (event_handler == NULL) { return NRF_ERROR_INVALID_PARAM; } if (m_user_count >= m_user_array_size) { return NRF_ERROR_NO_MEM; } //Allocate new user. mp_users[m_user_count].pins_mask = pins_low_to_high_mask | pins_high_to_low_mask; mp_users[m_user_count].pins_low_to_high_mask = pins_low_to_high_mask; mp_users[m_user_count].pins_high_to_low_mask = pins_high_to_low_mask; mp_users[m_user_count].event_handler = event_handler; *p_user_id = m_user_count++; //Make sure SENSE is disabled for all pins. pins_sense_disable(*p_user_id); return NRF_SUCCESS; }
uint32_t ble_db_discovery_evt_register(const ble_uuid_t * const p_uuid) { VERIFY_PARAM_NOT_NULL(p_uuid); VERIFY_MODULE_INITIALIZED(); return registered_handler_set(p_uuid, m_evt_handler); }
uint32_t pstorage_store(pstorage_handle_t * p_dest, uint8_t * p_src, pstorage_size_t size, pstorage_size_t offset) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_src); NULL_PARAM_CHECK(p_dest); MODULE_ID_RANGE_CHECK(p_dest); BLOCK_ID_RANGE_CHECK(p_dest); SIZE_CHECK(p_dest, size); OFFSET_CHECK(p_dest, offset, size); // Verify word alignment. if ((!is_word_aligned(p_src)) || (!is_word_aligned((void *)(uint32_t)offset))) { return NRF_ERROR_INVALID_ADDR; } uint32_t storage_addr = p_dest->block_id + offset; uint32_t retval = ble_flash_block_write((uint32_t *)storage_addr, (uint32_t *)p_src, (size /sizeof(uint32_t))); app_notify(p_dest, p_src, PSTORAGE_STORE_OP_CODE, size, retval); return retval; }
uint32_t ble_bondmngr_master_ids_get(uint16_t * p_master_ids, uint16_t * p_length) { VERIFY_MODULE_INITIALIZED(); if (p_length == NULL) { return NRF_ERROR_NULL; } if (*p_length < m_masters_in_db_count) { // Length of the input array is not enough to fit all known master identifiers. return NRF_ERROR_DATA_SIZE; } *p_length = m_masters_in_db_count; if (p_master_ids == NULL) { // Only the length field was required to be filled. return NRF_SUCCESS; } int i = 0; for (i = 0; i < m_masters_in_db_count; i++) { p_master_ids[i] = m_masters_db[i].bond.master_id_info.div; } return NRF_SUCCESS; }
uint32_t pstorage_load(uint8_t * p_dest, pstorage_handle_t * p_src, pstorage_size_t size, pstorage_size_t offset) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_src); NULL_PARAM_CHECK(p_dest); MODULE_ID_RANGE_CHECK (p_src); BLOCK_ID_RANGE_CHECK(p_src); SIZE_CHECK(p_src,size); OFFSET_CHECK(p_src,offset,size); // Verify word alignment. if ((!is_word_aligned(p_dest)) || (!is_word_aligned((void *)(uint32_t)offset))) { return NRF_ERROR_INVALID_ADDR; } memcpy(p_dest, (((uint8_t *)p_src->block_id) + offset), size); app_notify(p_src, p_dest, PSTORAGE_LOAD_OP_CODE, size, NRF_SUCCESS); return NRF_SUCCESS; }
uint32_t pstorage_clear(pstorage_handle_t * p_dest, pstorage_size_t size) { uint32_t page_addr; uint32_t retval; uint16_t page_count; VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_dest); MODULE_ID_RANGE_CHECK(p_dest); page_addr = p_dest->block_id / BLE_FLASH_PAGE_SIZE; retval = NRF_SUCCESS; for (page_count = 0; page_count < m_app_table[p_dest->module_id].no_of_pages; page_count++) { retval = ble_flash_page_erase(page_addr); page_addr++; if (retval != NRF_SUCCESS) { break; } } app_notify(p_dest, NULL, PSTORAGE_CLEAR_OP_CODE, size, retval); return retval; }
uint32_t pstorage_store(pstorage_handle_t * p_dest, uint8_t * p_src, pstorage_size_t size, pstorage_size_t offset) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_src); NULL_PARAM_CHECK(p_dest); MODULE_ID_RANGE_CHECK(p_dest); BLOCK_ID_RANGE_CHECK(p_dest); SIZE_CHECK(p_dest, size); OFFSET_CHECK(p_dest, offset,size); // Verify word alignment. if ((!is_word_aligned(p_src)) || (!is_word_aligned((void *)(uint32_t)offset))) { return NRF_ERROR_INVALID_ADDR; } if ((!is_word_aligned((uint32_t *)p_dest->block_id))) { return NRF_ERROR_INVALID_ADDR; } return cmd_queue_enqueue(PSTORAGE_STORE_OP_CODE, p_dest, p_src, size, offset); }
ret_code_t pm_peer_id_get(uint16_t conn_handle, pm_peer_id_t * p_peer_id) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_peer_id); *p_peer_id = im_peer_id_get_by_conn_handle(conn_handle); return NRF_SUCCESS; }
ret_code_t pm_peers_delete(void) { VERIFY_MODULE_INITIALIZED(); m_deleting_all = true; pm_peer_id_t current_peer_id = pdb_next_peer_id_get(PM_PEER_ID_INVALID); if (current_peer_id == PM_PEER_ID_INVALID) { // No peers bonded. m_deleting_all = false; pm_evt_t pm_delete_all_evt; memset(&pm_delete_all_evt, 0, sizeof(pm_evt_t)); pm_delete_all_evt.evt_id = PM_EVT_PEERS_DELETE_SUCCEEDED; pm_delete_all_evt.peer_id = PM_PEER_ID_INVALID; pm_delete_all_evt.conn_handle = BLE_CONN_HANDLE_INVALID; evt_send(&pm_delete_all_evt); } while (current_peer_id != PM_PEER_ID_INVALID) { ret_code_t err_code = pm_peer_delete(current_peer_id); if (err_code != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } current_peer_id = pdb_next_peer_id_get(current_peer_id); } return NRF_SUCCESS; }
ret_code_t pm_peer_data_load(pm_peer_id_t peer_id, pm_peer_data_id_t data_id, void * p_data, uint16_t * p_length) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_data); VERIFY_PARAM_NOT_NULL(p_length); if (ALIGN_NUM(4, *p_length) != *p_length) { return NRF_ERROR_INVALID_PARAM; } pm_peer_data_t peer_data; memset(&peer_data, 0, sizeof(peer_data)); peer_data.length_words = BYTES_TO_WORDS(*p_length); peer_data.data_id = data_id; peer_data.p_all_data = p_data; ret_code_t err_code = pdb_peer_data_load(peer_id, data_id, &peer_data); *p_length = peer_data.length_words * BYTES_PER_WORD; return err_code; }
ret_code_t pds_peer_data_write_prepare(pm_peer_data_const_t const * p_peer_data, pm_prepare_token_t * p_prepare_token) { ret_code_t retval; VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_peer_data); VERIFY_PEER_DATA_ID_IN_RANGE(p_peer_data->data_id); //VERIFY_PARAM_NOT_NULL(p_prepare_token); redundant, see fds_reserve(). retval = fds_reserve((fds_reserve_token_t*)p_prepare_token, p_peer_data->length_words); switch (retval) { case FDS_SUCCESS: return NRF_SUCCESS; case FDS_ERR_NULL_ARG: return NRF_ERROR_NULL; case FDS_ERR_RECORD_TOO_LARGE: return NRF_ERROR_INVALID_LENGTH; case FDS_ERR_NO_SPACE_IN_FLASH: return NRF_ERROR_NO_MEM; default: return NRF_ERROR_INTERNAL; } }
uint32_t app_timer_stop_all(void) { // Check state VERIFY_MODULE_INITIALIZED(); return timer_stop_op_schedule(NULL, TIMER_USER_OP_TYPE_STOP_ALL); }
uint32_t app_timer_create(app_timer_id_t const * p_timer_id, app_timer_mode_t mode, app_timer_timeout_handler_t timeout_handler) { // Check state and parameters VERIFY_MODULE_INITIALIZED(); if (timeout_handler == NULL) { return NRF_ERROR_INVALID_PARAM; } if (p_timer_id == NULL) { return NRF_ERROR_INVALID_PARAM; } if (((timer_node_t*)*p_timer_id)->is_running) { return NRF_ERROR_INVALID_STATE; } timer_node_t * p_node = (timer_node_t *)*p_timer_id; p_node->is_running = false; p_node->mode = mode; p_node->p_timeout_handler = timeout_handler; return NRF_SUCCESS; }
uint32_t app_timer_start(app_timer_id_t timer_id, uint32_t timeout_ticks, void * p_context) { uint32_t timeout_periodic; timer_node_t * p_node = (timer_node_t*)timer_id; // Check state and parameters VERIFY_MODULE_INITIALIZED(); if (timer_id == 0) { return NRF_ERROR_INVALID_STATE; } if (timeout_ticks < APP_TIMER_MIN_TIMEOUT_TICKS) { return NRF_ERROR_INVALID_PARAM; } if (p_node->p_timeout_handler == NULL) { return NRF_ERROR_INVALID_STATE; } // Schedule timer start operation timeout_periodic = (p_node->mode == APP_TIMER_MODE_REPEATED) ? timeout_ticks : 0; return timer_start_op_schedule(p_node, timeout_ticks, timeout_periodic, p_context); }
ret_code_t pdb_write_buf_store_prepare(pm_peer_id_t peer_id, pm_peer_data_id_t data_id) { VERIFY_MODULE_INITIALIZED(); ret_code_t err_code = NRF_SUCCESS; pdb_buffer_record_t * p_write_buffer_record; p_write_buffer_record = write_buffer_record_find(peer_id, data_id); if (p_write_buffer_record == NULL) { return NRF_ERROR_NOT_FOUND; } if (p_write_buffer_record->prepare_token == PDS_PREPARE_TOKEN_INVALID) { uint8_t * p_buffer_memory = pm_buffer_ptr_get(&m_pdb.write_buffer, p_write_buffer_record->buffer_block_id); pm_peer_data_const_t peer_data = {.data_type = data_id}; if (p_buffer_memory == NULL) { return NRF_ERROR_INTERNAL; } peer_data_const_point_to_buffer(&peer_data, data_id, p_buffer_memory, p_write_buffer_record->n_bufs); err_code = pds_peer_data_write_prepare(&peer_data, &p_write_buffer_record->prepare_token); if (err_code == NRF_ERROR_INVALID_LENGTH) { return NRF_ERROR_INTERNAL; } }
ret_code_t pdb_write_buf_release(pm_peer_id_t peer_id, pm_peer_data_id_t data_id) { VERIFY_MODULE_INITIALIZED(); ret_code_t err_code = NRF_SUCCESS; pdb_buffer_record_t * p_write_buffer_record; p_write_buffer_record = write_buffer_record_find(peer_id, data_id); if (p_write_buffer_record == NULL) { return NRF_ERROR_NOT_FOUND; } if (p_write_buffer_record->prepare_token != PDS_PREPARE_TOKEN_INVALID) { err_code = pds_peer_data_write_prepare_cancel(p_write_buffer_record->prepare_token); if (err_code != NRF_SUCCESS) { err_code = NRF_ERROR_INTERNAL; } } write_buffer_record_release(p_write_buffer_record); return err_code; }
ret_code_t pm_privacy_get(pm_privacy_params_t * p_privacy_params) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_privacy_params); VERIFY_PARAM_NOT_NULL(p_privacy_params->p_device_irk); return im_privacy_get(p_privacy_params); }
ret_code_t pds_peer_data_clear(pm_peer_id_t peer_id, pm_peer_data_id_t data_id) { ret_code_t retval; uint16_t file_id; uint16_t record_key; fds_record_desc_t record_desc; fds_find_token_t find_tok = {0}; VERIFY_MODULE_INITIALIZED(); VERIFY_PEER_ID_IN_RANGE(peer_id); VERIFY_PEER_DATA_ID_IN_RANGE(data_id); file_id = peer_id_to_file_id(peer_id); record_key = peer_data_id_to_record_key(data_id); retval = fds_record_find(file_id, record_key, &record_desc, &find_tok); if(retval != FDS_SUCCESS) { return NRF_ERROR_NOT_FOUND; } retval = fds_record_delete(&record_desc); switch (retval) { case FDS_SUCCESS: return NRF_SUCCESS; case FDS_ERR_NO_SPACE_IN_QUEUES: return NRF_ERROR_BUSY; default: return NRF_ERROR_INTERNAL; } }
ret_code_t pm_conn_handle_get(pm_peer_id_t peer_id, uint16_t * p_conn_handle) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_conn_handle); *p_conn_handle = im_conn_handle_get(peer_id); return NRF_SUCCESS; }
uint32_t pstorage_clear(pstorage_handle_t * p_dest, pstorage_size_t size) { uint32_t retval; VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_dest); MODULE_ID_RANGE_CHECK(p_dest); BLOCK_ID_RANGE_CHECK(p_dest); if ((!is_word_aligned((uint32_t *)p_dest->block_id))) { return NRF_ERROR_INVALID_ADDR; } if ( !( ((p_dest->block_id - m_app_table[p_dest->module_id].base_id) % m_app_table[p_dest->module_id].block_size) == 0 ) ) { return NRF_ERROR_INVALID_PARAM; } retval = cmd_queue_enqueue(PSTORAGE_CLEAR_OP_CODE, p_dest, NULL, size, 0); return retval; }
ret_code_t pm_peer_new(pm_peer_id_t * p_new_peer_id, pm_peer_data_bonding_t * p_bonding_data, pm_store_token_t * p_token) { ret_code_t err_code; pm_peer_id_t peer_id; pm_peer_data_flash_t peer_data; VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_bonding_data); VERIFY_PARAM_NOT_NULL(p_new_peer_id); memset(&peer_data, 0, sizeof(pm_peer_data_flash_t)); // Search through existing bonds to look for a duplicate. pds_peer_data_iterate_prepare(); // @note emdi: should maybe use a critical section, since data is not copied while iterating. while (pds_peer_data_iterate(PM_PEER_DATA_ID_BONDING, &peer_id, &peer_data)) { if (im_is_duplicate_bonding_data(p_bonding_data, peer_data.p_bonding_data)) { *p_new_peer_id = peer_id; return NRF_SUCCESS; } } // If no duplicate data is found, prepare to write a new bond to flash. *p_new_peer_id = pdb_peer_allocate(); if (*p_new_peer_id == PM_PEER_ID_INVALID) { return NRF_ERROR_NO_MEM; } memset(&peer_data, 0, sizeof(pm_peer_data_flash_t)); peer_data.data_id = PM_PEER_DATA_ID_BONDING; peer_data.p_bonding_data = p_bonding_data; peer_data.length_words = BYTES_TO_WORDS(sizeof(pm_peer_data_bonding_t)); err_code = pdb_raw_store(*p_new_peer_id, &peer_data, p_token); if (err_code != NRF_SUCCESS) { if (im_peer_free(*p_new_peer_id) != NRF_SUCCESS) { return NRF_ERROR_INTERNAL; } // NRF_ERROR_STORAGE_FULL, if no space in flash. // NRF_ERROR_BUSY, if flash filesystem was busy. // NRF_ERROR_INTENRAL, on internal error. return err_code; } return NRF_SUCCESS; }
uint32_t ble_bondmngr_is_link_encrypted (bool * status) { VERIFY_MODULE_INITIALIZED(); (*status) = ENCRYPTION_STATUS_GET(); return NRF_SUCCESS; }
ret_code_t gcm_remote_db_store(pm_peer_id_t peer_id, ble_gatt_db_srv_t * p_remote_db, uint32_t n_services) { VERIFY_MODULE_INITIALIZED(); return gccm_remote_db_store(peer_id, p_remote_db, n_services); }
ret_code_t pm_peer_rank_highest(pm_peer_id_t peer_id) { VERIFY_MODULE_INITIALIZED(); ret_code_t err_code; //lint -save -e65 -e64 pm_peer_data_flash_t peer_data = {.length_words = BYTES_TO_WORDS(sizeof(m_current_highest_peer_rank)), .data_id = PM_PEER_DATA_ID_PEER_RANK, .p_peer_rank = &m_current_highest_peer_rank}; //lint -restore if (!m_peer_rank_initialized) { rank_init(); } if (!m_peer_rank_initialized || (m_peer_rank_token != PM_STORE_TOKEN_INVALID)) { err_code = NRF_ERROR_BUSY; } else { if ((peer_id == m_highest_ranked_peer) && (m_current_highest_peer_rank > 0)) { pm_evt_t pm_evt; // The reported peer is already regarded as highest (provided it has an index at all) err_code = NRF_SUCCESS; memset(&pm_evt, 0, sizeof(pm_evt)); pm_evt.evt_id = PM_EVT_PEER_DATA_UPDATE_SUCCEEDED; pm_evt.conn_handle = im_conn_handle_get(peer_id); pm_evt.peer_id = peer_id; pm_evt.params.peer_data_update_succeeded.data_id = PM_PEER_DATA_ID_PEER_RANK; pm_evt.params.peer_data_update_succeeded.action = PM_PEER_DATA_OP_UPDATE; pm_evt.params.peer_data_update_succeeded.token = PM_STORE_TOKEN_INVALID; pm_evt.params.peer_data_update_succeeded.flash_changed = false; evt_send(&pm_evt); } else { m_current_highest_peer_rank += 1; err_code = pdb_raw_store(peer_id, &peer_data, &m_peer_rank_token); if (err_code != NRF_SUCCESS) { m_peer_rank_token = PM_STORE_TOKEN_INVALID; m_current_highest_peer_rank -= 1; { if ((err_code != NRF_ERROR_BUSY) && (err_code != NRF_ERROR_STORAGE_FULL)) err_code = NRF_ERROR_INTERNAL; } } } } return err_code; }
ret_code_t gcm_remote_db_retrieve(pm_peer_id_t peer_id, ble_gatt_db_srv_t * p_remote_db, uint32_t * p_n_services) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_NULL(p_remote_db); return gccm_remote_db_retrieve(peer_id, p_remote_db, p_n_services); }
ret_code_t pds_peer_data_verify(pm_store_token_t store_token) { VERIFY_MODULE_INITIALIZED(); VERIFY_PARAM_NOT_ZERO(store_token); // TODO: Not implemented in fds yet. return NRF_SUCCESS; }
uint32_t pstorage_access_status_get(uint32_t * p_count) { VERIFY_MODULE_INITIALIZED(); NULL_PARAM_CHECK(p_count); (*p_count) = m_cmd_queue.count; return NRF_SUCCESS; }
ret_code_t pdb_read_buf_get(pm_peer_id_t peer_id, pm_peer_data_id_t data_id, pm_peer_data_flash_t * p_peer_data, pm_store_token_t * p_token) { VERIFY_MODULE_INITIALIZED(); return pds_peer_data_read_ptr_get(peer_id, data_id, p_peer_data, p_token); }
uint32_t ble_bondmngr_bonded_masters_delete(void) { VERIFY_MODULE_INITIALIZED(); m_masters_in_db_count = 0; m_bond_info_in_flash_count = 0; m_sys_attr_in_flash_count = 0; return flash_pages_erase(); }
ret_code_t pm_conn_secure(uint16_t conn_handle, bool force_repairing) { VERIFY_MODULE_INITIALIZED(); ret_code_t err_code; err_code = sm_link_secure(conn_handle, force_repairing); return err_code; }