void nrf_drv_clock_hfclk_request(nrf_drv_clock_handler_item_t * p_handler_item)
{
ASSERT(m_clock_cb.module_initialized);
if (m_clock_cb.hfclk_on)
{
if (p_handler_item)
{
p_handler_item->event_handler(NRF_DRV_CLOCK_EVT_HFCLK_STARTED);
}
CRITICAL_REGION_ENTER();
++(m_clock_cb.hfclk_requests);
CRITICAL_REGION_EXIT();
}
else
{
CRITICAL_REGION_ENTER();
if (p_handler_item)
{
item_enqueue((nrf_drv_clock_handler_item_t **)&m_clock_cb.p_hf_head,
p_handler_item);
}
if (m_clock_cb.hfclk_requests == 0)
{
hfclk_start();
}
++(m_clock_cb.hfclk_requests);
CRITICAL_REGION_EXIT();
}
ASSERT(m_clock_cb.hfclk_requests > 0);
}
uint32_t nrf_drv_ppi_channel_include_in_group(nrf_ppi_channel_t channel,
nrf_ppi_channel_group_t group)
{
uint32_t err_code;
#if (NRF_PPI_RESTRICTED > 0)
uint32_t ch_mask;
#endif
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else if (!is_app_channel(channel))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
#if (NRF_PPI_RESTRICTED > 0)
CRITICAL_REGION_ENTER();
err_code = sd_ppi_group_get((uint8_t) group, &ch_mask);
if (err_code != NRF_SUCCESS)
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
ch_mask |= channel_to_mask(channel);
err_code = sd_ppi_group_assign((uint8_t) group, ch_mask);
if (err_code != NRF_SUCCESS)
{
err_code = NRF_ERROR_INVALID_PARAM;
}
}
CRITICAL_REGION_EXIT();
#else
CRITICAL_REGION_ENTER();
nrf_ppi_channel_include_in_group(channel, group);
CRITICAL_REGION_EXIT();
err_code = NRF_SUCCESS;
#endif
}
return err_code;
}
uint32_t nrf_drv_ppi_channels_remove_from_group(uint32_t channel_mask,
nrf_ppi_channel_group_t group)
{
uint32_t err_code;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else if (!are_app_channels(channel_mask))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
#if (NRF_PPI_RESTRICTED > 0)
uint32_t channels_in_group = 0;
CRITICAL_REGION_ENTER();
err_code = sd_ppi_group_get((uint8_t) group, &channels_in_group);
if (err_code != NRF_SUCCESS)
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
channels_in_group &= ~channel_mask;
err_code = sd_ppi_group_assign((uint8_t) group, channels_in_group);
if (err_code != NRF_SUCCESS)
{
err_code = NRF_ERROR_INVALID_PARAM;
}
}
CRITICAL_REGION_EXIT();
#else
CRITICAL_REGION_ENTER();
nrf_ppi_channels_remove_from_group(channel_mask, group);
CRITICAL_REGION_EXIT();
err_code = NRF_SUCCESS;
#endif
}
return err_code;
}
ret_code_t nrf_drv_clock_calibration_abort(void)
{
#if CALIBRATION_SUPPORT
CRITICAL_REGION_ENTER();
switch(m_clock_cb.cal_state)
{
case CAL_STATE_CT:
nrf_clock_int_disable(NRF_CLOCK_INT_CTTO_MASK);
nrf_clock_task_trigger(NRF_CLOCK_TASK_CTSTOP);
m_clock_cb.cal_state = CAL_STATE_IDLE;
if (m_clock_cb.cal_done_handler)
{
m_clock_cb.cal_done_handler(NRF_DRV_CLOCK_EVT_CAL_ABORTED);
}
break;
case CAL_STATE_HFCLK_REQ:
/* fall through. */
case CAL_STATE_CAL:
m_clock_cb.cal_state = CAL_STATE_ABORT;
break;
default:
break;
}
CRITICAL_REGION_EXIT();
return NRF_SUCCESS;
#else //CALIBRATION_SUPPORT
return NRF_ERROR_FORBIDDEN;
#endif
}
void nrf_drv_clock_lfclk_request(nrf_drv_clock_handler_item_t * p_handler_item)
{
ASSERT(m_clock_cb.module_initialized);
#ifndef SOFTDEVICE_PRESENT
ASSERT(m_clock_cb.lfclk_requests != INT_MAX);
CRITICAL_REGION_ENTER();
if (m_clock_cb.lfclk_on)
{
if (p_handler_item)
{
p_handler_item->event_handler(NRF_DRV_CLOCK_EVT_LFCLK_STARTED);
}
}
else
{
if (p_handler_item)
{
item_enqueue((nrf_drv_clock_handler_item_t **)&m_clock_cb.p_lf_head, p_handler_item);
}
if (m_clock_cb.lfclk_requests == 0)
{
lfclk_start();
}
}
m_clock_cb.lfclk_requests++;
CRITICAL_REGION_EXIT();
#else
if (p_handler_item)
{
p_handler_item->event_handler(NRF_DRV_CLOCK_EVT_LFCLK_STARTED);
}
#endif // SOFTDEVICE_PRESENT
}
/**@brief Function for scheduling a Timer Stop operation.
*
* @param[in] timer_id Id of timer to stop.
* @param[in] op_type Type of stop operation
*
* @return NRF_SUCCESS on successful scheduling a timer stop operation. NRF_ERROR_NO_MEM when there
* is no memory left to schedule the timer stop operation.
*/
static uint32_t timer_stop_op_schedule(timer_node_t * p_node,
timer_user_op_type_t op_type)
{
uint8_t last_index;
uint32_t err_code = NRF_SUCCESS;
CRITICAL_REGION_ENTER();
timer_user_op_t * p_user_op = user_op_alloc(&last_index);
if (p_user_op == NULL)
{
err_code = NRF_ERROR_NO_MEM;
}
else
{
p_user_op->op_type = op_type;
p_user_op->p_node = p_node;
user_op_enque(last_index);
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
timer_list_handler_sched();
}
return err_code;
}
static uint32_t timer_start_op_schedule(timer_node_t * p_node,
uint32_t timeout_initial,
uint32_t timeout_periodic,
void * p_context)
{
uint8_t last_index;
uint32_t err_code = NRF_SUCCESS;
CRITICAL_REGION_ENTER();
timer_user_op_t * p_user_op = user_op_alloc(&last_index);
if (p_user_op == NULL)
{
err_code = NRF_ERROR_NO_MEM;
}
else
{
p_user_op->op_type = TIMER_USER_OP_TYPE_START;
p_user_op->p_node = p_node;
p_user_op->params.start.ticks_at_start = rtc1_counter_get();
p_user_op->params.start.ticks_first_interval = timeout_initial;
p_user_op->params.start.ticks_periodic_interval = timeout_periodic;
p_user_op->params.start.p_context = p_context;
user_op_enque(last_index);
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
timer_list_handler_sched();
}
return err_code;
}
/**
* @brief @ref app_usbd_hid_interface_t::hid_kbd_on_set_report
*/
static ret_code_t hid_kbd_on_set_report(app_usbd_class_inst_t const * p_inst,
app_usbd_setup_evt_t const * p_setup_ev)
{
app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
/*Request setup data*/
app_usbd_hid_report_buffer_t const * p_rep_buff;
p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_kbd->specific.inst.hid_inst);
p_rep_buff->p_buff[0] = 0;
NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff + 1, p_rep_buff->size - 1);
ret_code_t ret;
CRITICAL_REGION_ENTER();
ret = app_usbd_core_setup_data_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
if (ret == NRF_SUCCESS)
{
app_usbd_core_setup_data_handler_desc_t desc = {
.handler = hid_kbd_on_set_report_data_cb,
.p_context = (app_usbd_hid_kbd_t *)p_kbd
};
ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
}
CRITICAL_REGION_EXIT();
return ret;
}
/**
* @brief Triggers IN endpoint transfer.
*
* @param[in] p_kbd HID keyboard instance.
*
* @return Standard error code.
*/
static inline ret_code_t hid_kbd_transfer_set(app_usbd_hid_kbd_t const * p_kbd)
{
app_usbd_class_inst_t const * p_inst = (app_usbd_class_inst_t const *)p_kbd;
app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
if (!hid_kbd_transfer_next(p_kbd))
{
/* Transfer buffer hasn't changed since last transfer. No need to setup
* next transfer.
* */
return NRF_SUCCESS;
}
app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
ret_code_t ret;
CRITICAL_REGION_ENTER();
ret = app_usbd_core_ep_transfer(ep_addr, &transfer);
if (ret == NRF_SUCCESS)
{
app_usbd_hid_state_flag_set(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
}
CRITICAL_REGION_EXIT();
return ret;
}
ret_code_t nrf_drv_clock_calibration_abort(void)
{
ret_code_t err_code = NRF_SUCCESS;
#if CALIBRATION_SUPPORT
CRITICAL_REGION_ENTER();
switch (m_clock_cb.cal_state)
{
case CAL_STATE_CT:
nrf_clock_int_disable(NRF_CLOCK_INT_CTTO_MASK);
nrf_clock_task_trigger(NRF_CLOCK_TASK_CTSTOP);
m_clock_cb.cal_state = CAL_STATE_IDLE;
if (m_clock_cb.cal_done_handler)
{
m_clock_cb.cal_done_handler(NRF_DRV_CLOCK_EVT_CAL_ABORTED);
}
break;
case CAL_STATE_HFCLK_REQ:
/* fall through. */
case CAL_STATE_CAL:
m_clock_cb.cal_state = CAL_STATE_ABORT;
break;
default:
break;
}
CRITICAL_REGION_EXIT();
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
#else
err_code = NRF_ERROR_FORBIDDEN;
NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
#endif // CALIBRATION_SUPPORT
}
/* ser_phy API function */
uint32_t ser_phy_tx_pkt_send(const uint8_t * p_buffer, uint16_t num_of_bytes)
{
if (p_buffer == NULL)
{
return NRF_ERROR_NULL;
}
if (num_of_bytes == 0)
{
return NRF_ERROR_INVALID_PARAM;
}
if (mp_tx_buffer != NULL)
{
return NRF_ERROR_BUSY;
}
//ser_phy_interrupts_disable();
CRITICAL_REGION_ENTER();
mp_tx_buffer = (uint8_t *)p_buffer;
m_tx_buf_len = num_of_bytes;
m_pend_tx_api_flag = true;
SET_PendSV();
//ser_phy_interrupts_enable();
CRITICAL_REGION_EXIT();
return NRF_SUCCESS;
}
size_t nrf_queue_in(nrf_queue_t const * p_queue,
void * p_data,
size_t element_count)
{
ASSERT(p_queue != NULL);
ASSERT(p_data != NULL);
if (element_count == 0)
{
return 0;
}
CRITICAL_REGION_ENTER();
if (p_queue->mode == NRF_QUEUE_MODE_OVERFLOW)
{
element_count = MIN(element_count, p_queue->size);
}
else
{
size_t available = nrf_queue_available_get(p_queue);
element_count = MIN(element_count, available);
}
queue_write(p_queue, p_data, element_count);
CRITICAL_REGION_EXIT();
return element_count;
}
/**
* @brief Allocates chunk in a buffer for one entry and injects overflow if
* there is no room for requested entry.
*
* @param nargs Number of 32bit arguments. In case of allocating for hex dump it
* is the size of the buffer in 32bit words (ceiled).
* @param p_wr_idx Pointer to write index.
*
* @return True if successful allocation, false otherwise.
*
*/
static inline bool buf_prealloc(uint32_t nargs, uint32_t * p_wr_idx)
{
nargs += HEADER_SIZE;
uint32_t ovflw_tag_size = HEADER_SIZE;
bool ret = true;
CRITICAL_REGION_ENTER();
*p_wr_idx = m_log_data.wr_idx;
uint32_t available_words = (m_log_data.mask + 1) - (m_log_data.wr_idx - m_log_data.rd_idx);
uint32_t required_words = nargs + ovflw_tag_size; // room for current entry and overflow
if (required_words > available_words)
{
if (available_words >= HEADER_SIZE)
{
// Overflow entry is injected
STD_HEADER_DEF(header, m_overflow_info, NRF_LOG_LEVEL_INTERNAL, 0);
m_log_data.buffer[m_log_data.wr_idx++ & m_log_data.mask] =
header.raw;
#if NRF_LOG_USES_TIMESTAMP
m_log_data.buffer[m_log_data.wr_idx++ & m_log_data.mask] =
m_log_data.timestamp_func();
#endif //NRF_LOG_USES_TIMESTAMP
}
// overflow case
ret = false;
}
else
{
m_log_data.wr_idx += nargs;
}
CRITICAL_REGION_EXIT();
return ret;
}
uint32_t nrf_drv_ppi_channel_alloc(nrf_ppi_channel_t * p_channel)
{
uint32_t err_code = NRF_SUCCESS;
nrf_ppi_channel_t channel;
uint32_t mask = 0;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_PROG_APP_CHANNELS_MASK;
for (channel = NRF_PPI_CHANNEL0; mask != 0; mask &= ~nrf_drv_ppi_channel_to_mask(channel), channel++)
{
CRITICAL_REGION_ENTER();
if ((mask & nrf_drv_ppi_channel_to_mask(channel)) && (!is_allocated_channel(channel)))
{
channel_allocated_set(channel);
*p_channel = channel;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Allocated channel: %d.\r\n", channel);
break;
}
}
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_group_free(nrf_ppi_channel_group_t group)
{
uint32_t err_code;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else
{
#if (NRF_PPI_RESTRICTED > 0)
err_code = sd_ppi_group_task_disable((uint8_t) group);
#else
nrf_ppi_group_disable(group);
err_code = NRF_SUCCESS;
#endif
CRITICAL_REGION_ENTER();
group_allocated_clr(group);
CRITICAL_REGION_EXIT();
}
return err_code;
}
ret_code_t nrf_queue_write(nrf_queue_t const * p_queue,
void const * p_data,
size_t element_count)
{
ret_code_t status = NRF_SUCCESS;
ASSERT(p_queue != NULL);
ASSERT(p_data != NULL);
ASSERT(element_count <= p_queue->size);
if (element_count == 0)
{
return NRF_SUCCESS;
}
CRITICAL_REGION_ENTER();
if ((nrf_queue_available_get(p_queue) >= element_count)
|| (p_queue->mode == NRF_QUEUE_MODE_OVERFLOW))
{
queue_write(p_queue, p_data, element_count);
}
else
{
status = NRF_ERROR_NO_MEM;
}
CRITICAL_REGION_EXIT();
return status;
}
uint32_t nrf_drv_ppi_group_alloc(nrf_ppi_channel_group_t * p_group)
{
uint32_t err_code;
uint32_t mask = 0;
nrf_ppi_channel_group_t group;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_ALL_APP_GROUPS_MASK;
for (group = NRF_PPI_CHANNEL_GROUP0; mask != 0; mask &= ~group_to_mask(group), group++)
{
CRITICAL_REGION_ENTER();
if ((mask & group_to_mask(group)) && (!is_allocated_group(group)))
{
group_allocated_set(group);
*p_group = group;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Allocated group: %d.\r\n", group);
break;
}
}
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
ret_code_t nrf_queue_read(nrf_queue_t const * p_queue,
void * p_data,
size_t element_count)
{
ret_code_t status = NRF_SUCCESS;
ASSERT(p_queue != NULL);
ASSERT(p_data != NULL);
if (element_count == 0)
{
return NRF_SUCCESS;
}
CRITICAL_REGION_ENTER();
if (element_count <= queue_utilization_get(p_queue))
{
queue_read(p_queue, p_data, element_count);
}
else
{
status = NRF_ERROR_NOT_FOUND;
}
CRITICAL_REGION_EXIT();
return status;
}
uint32_t nrf_drv_ppi_channels_include_in_group(uint32_t channel_mask,
nrf_ppi_channel_group_t group)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else if (!are_app_channels(channel_mask))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
CRITICAL_REGION_ENTER();
nrf_ppi_channels_include_in_group(channel_mask, group);
CRITICAL_REGION_EXIT();
}
NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)ERR_TO_STR(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_group_alloc(nrf_ppi_channel_group_t * p_group)
{
uint32_t err_code;
uint32_t mask = 0;
nrf_ppi_channel_group_t group;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_ALL_APP_GROUPS_MASK;
for (group = NRF_PPI_CHANNEL_GROUP0; mask != 0; mask &= ~group_to_mask(group), group++)
{
CRITICAL_REGION_ENTER();
if ((mask & group_to_mask(group)) && (!is_allocated_group(group)))
{
group_allocated_set(group);
*p_group = group;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
break;
}
}
return err_code;
}
uint32_t nrf_drv_ppi_channel_alloc(nrf_ppi_channel_t * p_channel)
{
uint32_t err_code;
nrf_ppi_channel_t channel;
uint32_t mask = 0;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_PROG_APP_CHANNELS_MASK;
for (channel = NRF_PPI_CHANNEL0; mask != 0; mask &= ~nrf_drv_ppi_channel_to_mask(channel), channel++)
{
CRITICAL_REGION_ENTER();
if ((mask & nrf_drv_ppi_channel_to_mask(channel)) && (!is_allocated_channel(channel)))
{
channel_allocated_set(channel);
*p_channel = channel;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
break;
}
}
return err_code;
}
uint32_t app_sched_event_put(void * p_event_data,
uint16_t event_data_size,
app_sched_event_handler_t handler)
{
uint32_t err_code;
if (event_data_size <= m_queue_event_size)
{
uint16_t event_index = 0xFFFF;
CRITICAL_REGION_ENTER();
if (!APP_SCHED_QUEUE_FULL())
{
event_index = m_queue_end_index;
m_queue_end_index = next_index(m_queue_end_index);
#ifdef APP_SCHEDULER_WITH_PROFILER
// This function call must be protected with critical region because
// it modifies 'm_max_queue_utilization'.
queue_utilization_check();
#endif
}
CRITICAL_REGION_EXIT();
if (event_index != 0xFFFF)
{
// NOTE: This can be done outside the critical region since the event consumer will
// always be called from the main loop, and will thus never interrupt this code.
m_queue_event_headers[event_index].handler = handler;
if ((p_event_data != NULL) && (event_data_size > 0))
{
memcpy(&m_queue_event_data[event_index * m_queue_event_size],
p_event_data,
event_data_size);
m_queue_event_headers[event_index].event_data_size = event_data_size;
}
else
{
m_queue_event_headers[event_index].event_data_size = 0;
}
err_code = NRF_SUCCESS;
}
else
{
err_code = NRF_ERROR_NO_MEM;
}
}
else
{
err_code = NRF_ERROR_INVALID_LENGTH;
}
return err_code;
}
void lumen_task_led_show(void * context, uint16_t size) {
CRITICAL_REGION_ENTER();
lumen_leds_show();
CRITICAL_REGION_EXIT();
}
ret_code_t nrf_queue_generic_pop(nrf_queue_t const * p_queue,
void * p_element,
bool just_peek)
{
ret_code_t status = NRF_SUCCESS;
ASSERT(p_queue != NULL);
ASSERT(p_element != NULL);
CRITICAL_REGION_ENTER();
if (!nrf_queue_is_empty(p_queue))
{
// Get read position.
size_t read_pos = p_queue->p_cb->front;
// Update next read position.
if (!just_peek)
{
p_queue->p_cb->front = nrf_queue_next_idx(p_queue, p_queue->p_cb->front);
}
// Read element.
switch (p_queue->element_size)
{
case sizeof(uint8_t):
*((uint8_t *)p_element) = ((uint8_t *)p_queue->p_buffer)[read_pos];
break;
case sizeof(uint16_t):
*((uint16_t *)p_element) = ((uint16_t *)p_queue->p_buffer)[read_pos];
break;
case sizeof(uint32_t):
*((uint32_t *)p_element) = ((uint32_t *)p_queue->p_buffer)[read_pos];
break;
case sizeof(uint64_t):
*((uint64_t *)p_element) = ((uint64_t *)p_queue->p_buffer)[read_pos];
break;
default:
memcpy(p_element,
(void const *)((size_t)p_queue->p_buffer + read_pos * p_queue->element_size),
p_queue->element_size);
break;
}
}
else
{
status = NRF_ERROR_NOT_FOUND;
}
CRITICAL_REGION_EXIT();
return status;
}
uint32_t ser_phy_hci_slip_tx_pkt_send(const ser_phy_hci_pkt_params_t * p_header,
const ser_phy_hci_pkt_params_t * p_payload,
const ser_phy_hci_pkt_params_t * p_crc)
{
/* Block TXRDY interrupts at this point*/
// NRF_UART0->INTENCLR = (UART_INTENCLR_TXDRDY_Clear << UART_INTENCLR_TXDRDY_Pos);
CRITICAL_REGION_ENTER();
if (p_header == NULL)
{
return NRF_ERROR_NULL;
}
/* Check if no tx is ongoing */
if (!m_tx_busy)
{
m_header = *p_header;
if (p_payload != NULL)
{
m_payload = *p_payload;
}
if (p_crc != NULL)
{
m_crc = *p_crc;
}
}
/* Tx is ongoing, schedule transmission as pending */
else
{
if (p_crc != NULL)
{
m_crc_pending = *p_crc;
}
if (p_payload != NULL)
{
m_payload_pending = *p_payload;
}
m_header_pending = *p_header;
}
/* Start packet transmission only if no other tx is ongoing */
if (!m_tx_busy)
{
m_tx_busy = true;
(void)ser_phy_hci_tx_byte();
}
/* Enable TXRDY interrupts at this point*/
// NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
CRITICAL_REGION_EXIT();
return NRF_SUCCESS;
}
void app_sched_resume(void)
{
CRITICAL_REGION_ENTER();
if (m_scheduler_paused_counter > 0)
{
m_scheduler_paused_counter--;
}
CRITICAL_REGION_EXIT();
}
void app_sched_pause(void)
{
CRITICAL_REGION_ENTER();
if (m_scheduler_paused_counter < UINT32_MAX)
{
m_scheduler_paused_counter++;
}
CRITICAL_REGION_EXIT();
}
void nrf_queue_reset(nrf_queue_t const * p_queue)
{
ASSERT(p_queue != NULL);
CRITICAL_REGION_ENTER();
memset(p_queue->p_cb, 0, sizeof(nrf_queue_cb_t));
CRITICAL_REGION_EXIT();
}
ret_code_t app_usbd_cdc_acm_serial_state_notify(app_usbd_cdc_acm_t const * p_cdc_acm,
app_usbd_cdc_acm_serial_state_t serial_state,
bool value)
{
app_usbd_cdc_acm_ctx_t * p_cdc_acm_ctx = cdc_acm_ctx_get(p_cdc_acm);
ret_code_t ret;
CRITICAL_REGION_ENTER();
ret = NRF_SUCCESS;
switch (serial_state)
{
case APP_USBD_CDC_ACM_SERIAL_STATE_DCD:
case APP_USBD_CDC_ACM_SERIAL_STATE_DSR:
case APP_USBD_CDC_ACM_SERIAL_STATE_BREAK:
case APP_USBD_CDC_ACM_SERIAL_STATE_RING:
case APP_USBD_CDC_ACM_SERIAL_STATE_FRAMING:
case APP_USBD_CDC_ACM_SERIAL_STATE_PARITY:
case APP_USBD_CDC_ACM_SERIAL_STATE_OVERRUN:
if (value)
{
p_cdc_acm_ctx->serial_state |= serial_state;
}
else
{
p_cdc_acm_ctx->serial_state &= ~serial_state;
}
break;
default:
ret = NRF_ERROR_NOT_SUPPORTED;
break;
}
if (ret == NRF_SUCCESS)
{
app_usbd_cdc_acm_notify_t * notify = &p_cdc_acm_ctx->request.payload.notify;
notify->cdc_notify.bmRequestType = app_usbd_setup_req_val(APP_USBD_SETUP_REQREC_INTERFACE,
APP_USBD_SETUP_REQTYPE_CLASS,
APP_USBD_SETUP_REQDIR_IN);
notify->cdc_notify.bmRequest = APP_USBD_CDC_NOTIF_SERIAL_STATE;
notify->cdc_notify.wValue = 0;
notify->cdc_notify.wIndex = 0;
notify->cdc_notify.wLength = sizeof(notify->serial_state);
notify->serial_state = p_cdc_acm_ctx->serial_state;
ret = cdc_acm_serial_state_notify(p_cdc_acm);
}
CRITICAL_REGION_EXIT();
return ret;
}
uint32_t nrf_drv_ppi_channel_free(nrf_ppi_channel_t channel)
{
if (!is_programmable_app_channel(channel))
{
return NRF_ERROR_INVALID_PARAM;
}
// First disable this channel
nrf_ppi_channel_disable(channel);
CRITICAL_REGION_ENTER();
channel_allocated_clr(channel);
CRITICAL_REGION_EXIT();
return NRF_SUCCESS;
}
