uint32_t sd_ble_gap_adv_stop(void)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_ADV_STOP;
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_ADV_STOP);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_device_name_get(uint8_t * const p_dev_name, uint16_t * const p_len)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_DEVICE_NAME_GET;
if (p_len != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += uint16_encode(*p_len, &g_cmd_buffer[index]);
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
g_cmd_buffer[index++] = (p_dev_name != NULL) ? RPC_BLE_FIELD_PRESENT :
RPC_BLE_FIELD_NOT_PRESENT;
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_DEVICE_NAME_GET);
if (p_len != NULL)
{
*p_len = uint16_decode(&(g_cmd_response_buf[BLE_OP_CODE_SIZE +
BLE_PKT_TYPE_SIZE +
RPC_ERR_CODE_SIZE]));
if (p_dev_name != NULL)
{
memcpy(p_dev_name,
&(g_cmd_response_buf[BLE_OP_CODE_SIZE +
BLE_PKT_TYPE_SIZE +
RPC_ERR_CODE_SIZE +
sizeof(*p_len)]),
*p_len);
}
}
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_device_name_set(ble_gap_conn_sec_mode_t const * const p_write_perm,
uint8_t const * const p_dev_name,
uint16_t len)
{
uint32_t i;
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_DEVICE_NAME_SET;
if (p_write_perm != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
g_cmd_buffer[index++] = (uint8_t) ((p_write_perm->sm) | (p_write_perm->lv << 4));
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
index += uint16_encode(len, &g_cmd_buffer[index]);
if (p_dev_name != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
for (i = 0; i < len; i++)
{
g_cmd_buffer[index++] = p_dev_name[i];
}
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_DEVICE_NAME_SET);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_appearance_set(uint16_t appearance)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_APPEARANCE_SET;
index += uint16_encode(appearance, &g_cmd_buffer[index]);
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_APPEARANCE_SET);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_sec_info_reply(uint16_t conn_handle,
ble_gap_enc_info_t const * const p_enc_info,
ble_gap_sign_info_t const * const p_sign_info)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_SEC_INFO_REPLY;
index += uint16_encode(conn_handle, &g_cmd_buffer[index]);
if (p_enc_info != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += uint16_encode(p_enc_info->div, &g_cmd_buffer[index]);
memcpy(&g_cmd_buffer[index], p_enc_info->ltk, BLE_GAP_SEC_KEY_LEN);
index += BLE_GAP_SEC_KEY_LEN;
g_cmd_buffer[index++] = (p_enc_info->auth | (p_enc_info->ltk_len << 1));
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
if (p_sign_info != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
memcpy(&g_cmd_buffer[index], p_sign_info->csrk, BLE_GAP_SEC_KEY_LEN);
index += BLE_GAP_SEC_KEY_LEN;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_SEC_INFO_REPLY);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_adv_start(ble_gap_adv_params_t const * const p_adv_params)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_ADV_START;
g_cmd_buffer[index++] = p_adv_params->type;
if (p_adv_params->p_peer_addr == NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += peer_address_encode(&g_cmd_buffer[index],
p_adv_params->p_peer_addr);
}
g_cmd_buffer[index++] = p_adv_params->fp;
if (p_adv_params->p_whitelist == NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += whitelist_encode(&g_cmd_buffer[index], p_adv_params->p_whitelist);
}
index += uint16_encode(p_adv_params->interval, &g_cmd_buffer[index]);
index += uint16_encode(p_adv_params->timeout, &g_cmd_buffer[index]);
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_ADV_START);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_disconnect(uint16_t conn_handle, uint8_t hci_status_code)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_DISCONNECT;
index += uint16_encode(conn_handle, &g_cmd_buffer[index]);
g_cmd_buffer[index++] = hci_status_code;
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_DISCONNECT);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_gap_sec_params_reply(uint16_t conn_handle,
uint8_t sec_status,
ble_gap_sec_params_t const * const p_sec_params)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_SEC_PARAMS_REPLY;
index += uint16_encode(conn_handle, &g_cmd_buffer[index]);
g_cmd_buffer[index++] = sec_status;
if (p_sec_params != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += uint16_encode(p_sec_params->timeout, &g_cmd_buffer[index]);
g_cmd_buffer[index++] = (
(p_sec_params->oob << 5) |
(p_sec_params->io_caps << 2) |
(p_sec_params->mitm << 1) |
(p_sec_params->bond << 0)
);
g_cmd_buffer[index++] = p_sec_params->min_key_size;
g_cmd_buffer[index++] = p_sec_params->max_key_size;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_SEC_PARAMS_REPLY);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t ble_rpc_cmd_resp_data_send(uint8_t op_code,
uint8_t status,
const uint8_t * const p_data,
uint16_t data_len)
{
uint8_t * p_buffer;
uint32_t err_code;
uint32_t index = 0;
// Allocate a memory buffer from HCI transport layer for transmitting the Command Response.
// Loop until a buffer is available.
do
{
err_code = hci_transport_tx_alloc(&p_buffer);
}
while (err_code == NRF_ERROR_NO_MEM);
if (err_code == NRF_SUCCESS)
{
// Encode packet type.
p_buffer[index++] = BLE_RPC_PKT_RESP;
// Encode Op Code.
p_buffer[index++] = op_code;
// Encode Status.
index += uint32_encode(status, &(p_buffer[index]));
// Additional data in response packet.
memcpy(&p_buffer[index], p_data, data_len);
index += data_len;
return hci_transport_pkt_write(p_buffer, index);
}
return err_code;
}
uint32_t sd_ble_gap_conn_param_update(uint16_t conn_handle,
ble_gap_conn_params_t const * const p_conn_params)
{
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_GAP_CONN_PARAM_UPDATE;
index += uint16_encode(conn_handle, &g_cmd_buffer[index]);
if (p_conn_params != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += uint16_encode(p_conn_params->min_conn_interval,
&g_cmd_buffer[index]);
index += uint16_encode(p_conn_params->max_conn_interval,
&g_cmd_buffer[index]);
index += uint16_encode(p_conn_params->slave_latency,
&g_cmd_buffer[index]);
index += uint16_encode(p_conn_params->conn_sup_timeout,
&g_cmd_buffer[index]);
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
uint32_t err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_GAP_CONN_PARAM_UPDATE);
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
uint32_t sd_ble_uuid_encode(ble_uuid_t const * const p_uuid,
uint8_t * const p_uuid_le_len,
uint8_t * const p_uuid_le)
{
uint32_t err_code;
uint32_t index = 0;
g_cmd_buffer[index++] = BLE_RPC_PKT_CMD;
g_cmd_buffer[index++] = SD_BLE_UUID_ENCODE;
if (p_uuid != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
index += uint16_encode(p_uuid->uuid, &g_cmd_buffer[index]);
g_cmd_buffer[index++] = p_uuid->type;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
if (p_uuid_le_len != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
if (p_uuid_le != NULL)
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_PRESENT;
}
else
{
g_cmd_buffer[index++] = RPC_BLE_FIELD_NOT_PRESENT;
}
err_code = hci_transport_pkt_write(g_cmd_buffer, index);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = ble_rpc_cmd_resp_wait(SD_BLE_UUID_ENCODE);
if (p_uuid_le_len != NULL)
{
*p_uuid_le_len = g_cmd_response_buf[BLE_OP_CODE_SIZE +
BLE_PKT_TYPE_SIZE +
RPC_ERR_CODE_SIZE];
}
if ((p_uuid_le != NULL) && (p_uuid_le_len != NULL))
{
memcpy(p_uuid_le,
&(g_cmd_response_buf[BLE_OP_CODE_SIZE +
BLE_PKT_TYPE_SIZE +
RPC_ERR_CODE_SIZE +
sizeof(*p_uuid_le_len)]),
*p_uuid_le_len);
}
UNUSED_VARIABLE(hci_transport_rx_pkt_consume(g_cmd_response_buf));
return err_code;
}
