static void
nffs_lock(void)
{
int rc;
rc = os_mutex_pend(&nffs_mutex, 0xffffffff);
assert(rc == 0 || rc == OS_NOT_STARTED);
}
static void
os_malloc_lock(void)
{
int rc;
if (g_os_started) {
rc = os_mutex_pend(&os_malloc_mutex, 0xffffffff);
assert(rc == 0);
}
}
void
ble_hs_lock(void)
{
int rc;
BLE_HS_DBG_ASSERT(!ble_hs_locked_by_cur_task());
rc = os_mutex_pend(&ble_hs_mutex, 0xffffffff);
BLE_HS_DBG_ASSERT_EVAL(rc == 0 || rc == OS_NOT_STARTED);
}
int
fcb_getnext(struct fcb *fcb, struct fcb_entry *loc)
{
int rc;
rc = os_mutex_pend(&fcb->f_mtx, OS_WAIT_FOREVER);
if (rc && rc != OS_NOT_STARTED) {
return FCB_ERR_ARGS;
}
rc = fcb_getnext_nolock(fcb, loc);
os_mutex_release(&fcb->f_mtx);
return rc;
}
void
ble_hs_lock(void)
{
int rc;
BLE_HS_DBG_ASSERT(!ble_hs_locked_by_cur_task());
#if BLE_HS_DEBUG
if (!os_started()) {
ble_hs_dbg_mutex_locked = 1;
return;
}
#endif
rc = os_mutex_pend(&ble_hs_mutex, 0xffffffff);
BLE_HS_DBG_ASSERT_EVAL(rc == 0 || rc == OS_NOT_STARTED);
}
int
cbmem_lock_acquire(struct cbmem *cbmem)
{
int rc;
if (!os_started()) {
return (0);
}
rc = os_mutex_pend(&cbmem->c_lock, OS_WAIT_FOREVER);
if (rc != 0) {
goto err;
}
return (0);
err:
return (rc);
}
/**
* Open the NRF52 ADC device
*
* This function locks the device for access from other tasks.
*
* @param odev The OS device to open
* @param wait The time in MS to wait. If 0 specified, returns immediately
* if resource unavailable. If OS_WAIT_FOREVER specified, blocks
* until resource is available.
* @param arg Argument provided by higher layer to open, in this case
* it can be a nrfx_saadc_config_t, to override the default
* configuration.
*
* @return 0 on success, non-zero on failure.
*/
static int
nrf52_adc_open(struct os_dev *odev, uint32_t wait, void *arg)
{
struct adc_dev *dev;
struct nrf52_adc_dev_cfg *cfg = arg;
int rc;
dev = (struct adc_dev *) odev;
if (os_started()) {
rc = os_mutex_pend(&dev->ad_lock, wait);
if (rc != OS_OK) {
goto err;
}
}
if (odev->od_flags & OS_DEV_F_STATUS_OPEN) {
os_mutex_release(&dev->ad_lock);
rc = OS_EBUSY;
goto err;
}
/* If user did not provide config let us use init */
if (!cfg) {
cfg = init_adc_config;
}
/* Initialize the device */
rc = nrfx_saadc_init(&cfg->saadc_cfg, nrf52_saadc_event_handler);
if (rc != NRFX_SUCCESS) {
goto err;
}
global_adc_dev = dev;
global_adc_config = arg;
return (0);
err:
return (rc);
}
/**
* Lock access to the charge_control_itf specified by cci. Blocks until lock acquired.
*
* @param The charge_ctrl_itf to lock
* @param The timeout
*
* @return 0 on success, non-zero on failure.
*/
static int
ad5061_itf_lock(struct charge_control_itf *cci, uint32_t timeout)
{
int rc;
os_time_t ticks;
if (!cci->cci_lock) {
return 0;
}
rc = os_time_ms_to_ticks(timeout, &ticks);
if (rc) {
return rc;
}
rc = os_mutex_pend(cci->cci_lock, ticks);
if (rc == 0 || rc == OS_NOT_STARTED) {
return (0);
}
return (rc);
}
/**
* Open the STM32F4 ADC device
*
* This function locks the device for access from other tasks.
*
* @param odev The OS device to open
* @param wait The time in MS to wait. If 0 specified, returns immediately
* if resource unavailable. If OS_WAIT_FOREVER specified, blocks
* until resource is available.
* @param arg Argument provided by higher layer to open.
*
* @return 0 on success, non-zero on failure.
*/
static int
stm32f4_adc_open(struct os_dev *odev, uint32_t wait, void *arg)
{
DMA_HandleTypeDef *hdma;
ADC_HandleTypeDef *hadc;
struct stm32f4_adc_dev_cfg *cfg;
struct adc_dev *dev;
int rc;
assert(odev);
rc = OS_OK;
dev = (struct adc_dev *) odev;
if (os_started()) {
rc = os_mutex_pend(&dev->ad_lock, wait);
if (rc != OS_OK) {
goto err;
}
}
if (odev->od_flags & OS_DEV_F_STATUS_OPEN) {
os_mutex_release(&dev->ad_lock);
rc = OS_EBUSY;
goto err;
}
stm32f4_adc_init(dev);
cfg = (struct stm32f4_adc_dev_cfg *)dev->ad_dev.od_init_arg;
hadc = cfg->sac_adc_handle;
hdma = hadc->DMA_Handle;
adc_dma[stm32f4_resolve_dma_handle_idx(hdma)] = dev;
return (OS_OK);
err:
return (rc);
}
