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); }