int ncvarget( int ncid, int varid, const long* start, const long* count, void* value ) { NDIMS_DECL A_DECL(stp, size_t, ndims, start); A_DECL(cntp, size_t, ndims, count); A_INIT(stp, size_t, ndims, start); A_INIT(cntp, size_t, ndims, count); { const int status = nc_get_vara(ncid, varid, stp, cntp, value); A_FREE(cntp); A_FREE(stp); if(status != NC_NOERR) { nc_advise("ncvarget", status, "ncid %d; varid %d", ncid, varid); return -1; } } return 0; }
/* cleanup the HTC instance */ static void HTCCleanup(HTC_TARGET *target) { A_INT32 i; DevCleanup(&target->Device); for (i = 0;i < NUM_CONTROL_BUFFERS;i++) { if (target->HTCControlBuffers[i].Buffer) { A_FREE(target->HTCControlBuffers[i].Buffer); } } if (A_IS_MUTEX_VALID(&target->HTCLock)) { A_MUTEX_DELETE(&target->HTCLock); } if (A_IS_MUTEX_VALID(&target->HTCRxLock)) { A_MUTEX_DELETE(&target->HTCRxLock); } if (A_IS_MUTEX_VALID(&target->HTCTxLock)) { A_MUTEX_DELETE(&target->HTCTxLock); } /* free our instance */ A_FREE(target); }
A_STATUS BMIDone(A_VOID *pCxt) { A_STATUS status; A_UINT32 cid; if (bmiDone) { return A_OK; } bmiDone = TRUE; cid = A_CPU2LE32(BMI_DONE); status = bmiBufferSend(pCxt, (A_UCHAR *)&cid, sizeof(cid)); if (status != A_OK) { return A_ERROR; } if (pBMICmdCredits) { A_FREE(pBMICmdCredits, MALLOC_ID_TEMPORARY); pBMICmdCredits = NULL; } if (pBMICmdBuf) { A_FREE(pBMICmdBuf, MALLOC_ID_TEMPORARY); pBMICmdBuf = NULL; } return A_OK; }
/* clean up scatter support */ void CleanupHIFScatterResources(HIF_DEVICE *device) { HIF_SCATTER_REQ_PRIV *pReqPriv; HIF_SCATTER_REQ *pReq; /* empty the free list */ while (1) { pReq = AllocScatterReq(device); if (NULL == pReq) { break; } pReqPriv = (HIF_SCATTER_REQ_PRIV *)pReq->HIFPrivate[0]; A_ASSERT(pReqPriv != NULL); if (pReqPriv->busrequest != NULL) { pReqPriv->busrequest->pScatterReq = NULL; /* free bus request */ hifFreeBusRequest(device, pReqPriv->busrequest); pReqPriv->busrequest = NULL; } if (pReqPriv->pHifScatterReq != NULL) { A_FREE(pReqPriv->pHifScatterReq); pReqPriv->pHifScatterReq = NULL; } A_FREE(pReqPriv); } }
int BMIDone(struct hif_device *device) { int status; u32 cid; if (bmiDone) { AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped\n")); return 0; } AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Enter (device: 0x%p)\n", device)); bmiDone = true; cid = BMI_DONE; status = bmiBufferSend(device, (u8 *)&cid, sizeof(cid)); if (status) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to write to the device\n")); return A_ERROR; } if (pBMICmdCredits) { A_FREE(pBMICmdCredits); pBMICmdCredits = NULL; } if (pBMICmdBuf) { A_FREE(pBMICmdBuf); pBMICmdBuf = NULL; } AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Exit\n")); return 0; }
void ar6000_cleanup_hci(AR_SOFTC_T *ar) #endif { #ifdef EXPORT_HCI_BRIDGE_INTERFACE AR6K_HCI_BRIDGE_INFO *pHcidevInfo = g_pHcidevInfo; #else AR6K_HCI_BRIDGE_INFO *pHcidevInfo = (AR6K_HCI_BRIDGE_INFO *)ar->hcidev_info; #endif if (pHcidevInfo != NULL) { bt_cleanup_hci(pHcidevInfo); if (pHcidevInfo->pHCIDev != NULL) { HCI_TransportStop(pHcidevInfo->pHCIDev); HCI_TransportDetach(pHcidevInfo->pHCIDev); pHcidevInfo->pHCIDev = NULL; } if (pHcidevInfo->pHTCStructAlloc != NULL) { A_FREE(pHcidevInfo->pHTCStructAlloc); pHcidevInfo->pHTCStructAlloc = NULL; } A_FREE(pHcidevInfo); #ifndef EXPORT_HCI_BRIDGE_INTERFACE ar->hcidev_info = NULL; ar->exitCallback = NULL; #endif } }
int ncvargets( int ncid, int varid, const long* start, const long* count, const long* stride, void* value ) { if(stride == NULL) return ncvarget(ncid, varid, start, count, value); /* else */ { NDIMS_DECL A_DECL(stp, size_t, ndims, start); A_DECL(cntp, size_t, ndims, count); A_DECL(strdp, ptrdiff_t, ndims, stride); A_INIT(stp, size_t, ndims, start); A_INIT(cntp, size_t, ndims, count); A_INIT(strdp, ptrdiff_t, ndims, stride); { const int status = nc_get_vars(ncid, varid, stp, cntp, strdp, value); A_FREE(strdp); A_FREE(cntp); A_FREE(stp); if(status != NC_NOERR) { nc_advise("ncvargets", status, "ncid %d", ncid); return -1; } } return 0; } }
void wlan_node_free(bss_t *ni) { if (ni->ni_buf != NULL) { A_FREE(ni->ni_buf); } A_FREE(ni); }
static void hif_usb_remove(struct usb_interface *interface) { HIF_DEVICE_USB *device = usb_get_intfdata(interface); struct hif_usb_softc *sc = device->sc; struct ol_softc *scn; /* Attach did not succeed, all resources have been * freed in error handler */ if (!sc) return; /* wait __hdd_wlan_exit until finished and no more than 4 seconds*/ while(usb_sc->hdd_removed_processing == 1 && usb_sc->hdd_removed_wait_cnt < 20) { set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(msecs_to_jiffies(DELAY_INT_FOR_HDD_REMOVE)); set_current_state(TASK_RUNNING); usb_sc->hdd_removed_wait_cnt ++; } /* do cold reset */ HIFDiagWriteCOLDRESET(sc->hif_device); /* wait for target jump to boot code and finish the initialization */ set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(msecs_to_jiffies(DELAY_FOR_TARGET_READY)); set_current_state(TASK_RUNNING); if (usb_sc->local_state.event != 0) { hif_usb_resume(usb_sc->interface); usb_sc->local_state.event = 0; } unregister_reboot_notifier(&sc->reboot_notifier); usb_put_dev(interface_to_usbdev(interface)); if (atomic_read(&hif_usb_unload_state) == HIF_USB_UNLOAD_STATE_DRV_DEREG) atomic_set(&hif_usb_unload_state, HIF_USB_UNLOAD_STATE_TARGET_RESET); scn = sc->ol_sc; if (usb_sc->hdd_removed == 0) { usb_sc->hdd_removed_processing = 1; #ifndef REMOVE_PKT_LOG if (vos_get_conparam() != VOS_FTM_MODE && !WLAN_IS_EPPING_ENABLED(vos_get_conparam())) pktlogmod_exit(scn); #endif __hdd_wlan_exit(); usb_sc->hdd_removed_processing = 0; usb_sc->hdd_removed = 1; } hif_nointrs(sc); HIF_USBDeviceDetached(interface, 1); A_FREE(scn); A_FREE(sc); usb_sc = NULL; pr_info("hif_usb_remove!!!!!!\n"); }
void BMICleanup(void) { if (pBMICmdCredits) { A_FREE(pBMICmdCredits); pBMICmdCredits = NULL; } if (pBMICmdBuf) { A_FREE(pBMICmdBuf); pBMICmdBuf = NULL; } }
void BMICleanup(void) { if (pBMICmdCredits) { A_FREE(pBMICmdCredits, MALLOC_ID_TEMPORARY); pBMICmdCredits = NULL; } if (pBMICmdBuf) { A_FREE(pBMICmdBuf, MALLOC_ID_TEMPORARY); pBMICmdBuf = NULL; } }
void BMICleanup(void) { #if 0 if (pBMICmdCredits) { A_FREE(pBMICmdCredits); pBMICmdCredits = NULL; } #endif if (pBMICmdBuf) { A_FREE(pBMICmdBuf); pBMICmdBuf = NULL; } }
void wlan_node_free(bss_t *ni) { if (ni->ni_buf != NULL) { A_FREE(ni->ni_buf); ni->ni_buf = NULL; } #ifdef P2P if (ni->p2p_dev) { p2p_device_free(ni->p2p_dev); } #endif /* P2P */ A_FREE(ni); ni = NULL; }
void cmp_model_reload(const char* filepath, reshandle_t hdl, int manual) { reshandle_t nhdl; uint cnt; struct allocator* tmp_alloc = tsk_get_tmpalloc(0); cmp_t c = cmp_findtype(cmp_model_type); const struct cmp_instance_desc** insts = cmp_get_allinstances(c, &cnt, tmp_alloc); /* reload model and refresh all model component data */ cmp_model_destroyinstances(hdl, insts, cnt); if (!manual) nhdl = rs_load_model(filepath, RS_LOAD_REFRESH); else nhdl = hdl; if (nhdl != INVALID_HANDLE) { if (rs_get_model(nhdl) != NULL) cmp_model_rebuildhinstances(eng_get_dataalloc(), tmp_alloc, hdl, insts, cnt); else cmp_model_clearinstances(hdl, insts, cnt, FALSE); } else { cmp_model_clearinstances(hdl, insts, cnt, TRUE); /* this happens when model-reload fails we have to invalidate handles */ } A_FREE(tmp_alloc, insts); }
static HTC_PACKET *BuildHTCTxCtrlPacket(adf_os_device_t osdev) { HTC_PACKET *pPacket = NULL; adf_nbuf_t netbuf; do { pPacket = (HTC_PACKET *)A_MALLOC(sizeof(HTC_PACKET)); if (NULL == pPacket) { break; } A_MEMZERO(pPacket,sizeof(HTC_PACKET)); #ifdef ATH_USE_NCNB netbuf = adf_nbuf_alloc_ncnb(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, TRUE); #else netbuf = adf_nbuf_alloc(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, TRUE); #endif if (NULL == netbuf) { A_FREE(pPacket); pPacket = NULL; adf_os_print("%s: nbuf alloc failed\n",__func__); break; } AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("alloc ctrl netbuf :0x%p \n", netbuf)); SET_HTC_PACKET_NET_BUF_CONTEXT(pPacket, netbuf); } while (FALSE); return pPacket; }
A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr,int type) { A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; A_UINT8 *event; A_UINT8 *bufferToFree = NULL; A_STATUS result = A_ERROR; int inc,outc; if (type == BDADDR_TYPE_STRING) str2ba(bdaddr,&bdaddr_cmd[7]); else { /* Bdaddr has to be sent as LAP first */ for(inc = 5 ,outc = 7; inc >=0; inc--, outc++) bdaddr_cmd[outc] = bdaddr[inc]; } if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd, sizeof(bdaddr_cmd), &event,&bufferToFree)) { if(event[4] == 0xFC && event[5] == 0x00){ if(event[3] == 0x0B){ result = A_OK; } } } if(bufferToFree != NULL) { A_FREE(bufferToFree); } return result; }
A_STATUS write_bdaddr(AR3K_CONFIG_INFO *pConfig,A_UCHAR *bdaddr) { A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; A_UINT8 *event; A_UINT8 *bufferToFree = NULL; A_STATUS result = A_ERROR; str2ba(bdaddr,&bdaddr_cmd[7]); if(A_OK == SendHCICommandWaitCommandComplete(pConfig,bdaddr_cmd, sizeof(bdaddr_cmd), &event,&bufferToFree)) { if(event[4] == 0xFC && event[5] == 0x00){ if(event[3] == 0x0B){ result = A_OK; } } } if(bufferToFree != NULL) { A_FREE(bufferToFree); } return result; }
/* Update the buffer alone, not the entire node. * This involves, * 1) Freeing the buffer alone. * 2) Allocating a new buffer * 3) Update the node timestamp with the current time. */ A_STATUS wlan_node_buf_update(struct ieee80211_node_table *nt, bss_t *ni, A_UINT32 len) { IEEE80211_NODE_LOCK(nt); /* Free the ni_buf alone. */ if (ni->ni_buf != NULL) { A_FREE(ni->ni_buf); ni->ni_buf = NULL; } /* Allocate ni_buf for the new length. */ if (len) { ni->ni_buf = A_MALLOC_NOWAIT(len); if (ni->ni_buf == NULL) { IEEE80211_NODE_UNLOCK(nt); return A_ERROR; } else { A_MEMZERO(ni->ni_buf, len); } } /* Update the Node's timestamp. */ wlan_node_update_timestamp(nt, ni); IEEE80211_NODE_UNLOCK(nt); return A_OK; }
void model_unloadocc(struct gfx_model_occ* occ, struct allocator* alloc) { if (occ->indexes != NULL) A_FREE(alloc, occ->indexes); if (occ->poss != NULL) A_ALIGNED_FREE(alloc, occ->poss); }
void Abf_WlanStackNotificationDeInit(ATH_BT_FILTER_INSTANCE *pInstance) { ATHBT_FILTER_INFO *pInfo = (ATHBT_FILTER_INFO *)pInstance->pContext; ABF_WLAN_INFO *pAbfWlanInfo = pInfo->pWlanInfo; if (!pAbfWlanInfo) return; /* Terminate and wait for the WLAN Event Handler task to finish */ A_MUTEX_LOCK(&pAbfWlanInfo->hWaitEventLock); if (pAbfWlanInfo->Loop) { pAbfWlanInfo->Loop = FALSE; A_COND_WAIT(&pAbfWlanInfo->hWaitEvent, &pAbfWlanInfo->hWaitEventLock, WAITFOREVER); } A_MUTEX_UNLOCK(&pAbfWlanInfo->hWaitEventLock); /* Flush all the BT actions from the filter core */ HandleAdapterEvent(pInfo, ATH_ADAPTER_REMOVED); pInfo->pWlanInfo = NULL; A_MUTEX_DEINIT(&pAbfWlanInfo->hWaitEventLock); A_COND_DEINIT(&pAbfWlanInfo->hWaitEvent); A_MEMZERO(pAbfWlanInfo, sizeof(ABF_WLAN_INFO)); A_FREE(pAbfWlanInfo); A_INFO("WLAN Stack Notification de-init complete\n"); }
bss_t * wlan_node_alloc(struct ieee80211_node_table *nt, A_INT32 wh_size) { bss_t *ni; ni = A_MALLOC(sizeof(bss_t)); if (ni != NULL) { ni->ni_buf = A_MALLOC(wh_size); if (ni->ni_buf == NULL) { A_FREE(ni); ni = NULL; } } /* Make sure our lists are clean */ if (ni) { ni->ni_list_next = NULL; ni->ni_list_prev = NULL; ni->ni_hash_next = NULL; ni->ni_hash_prev = NULL; } return ni; }
A_STATUS BMIDone(HIF_DEVICE *device) { A_STATUS status; A_UINT32 cid; if (bmiDone) { AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped\n")); return A_OK; } AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Enter (device: 0x%p)\n", device)); bmiDone = TRUE; cid = BMI_DONE; A_MEMCPY(pBMICmdBuf,&cid,sizeof(cid)); status = HIFExchangeBMIMsg(device, pBMICmdBuf, sizeof(cid), NULL, NULL, 0); if (status != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to write to the device\n")); return A_ERROR; } if (pBMICmdBuf) { A_FREE(pBMICmdBuf); pBMICmdBuf = NULL; } AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Done: Exit\n")); return A_OK; }
static A_STATUS SendHCICommand(AR3K_CONFIG_INFO *pConfig, A_UINT8 *pBuffer, int Length) { HTC_PACKET *pPacket = NULL; A_STATUS status = A_OK; do { pPacket = (HTC_PACKET *)A_MALLOC(sizeof(HTC_PACKET)); if (NULL == pPacket) { status = A_NO_MEMORY; break; } A_MEMZERO(pPacket,sizeof(HTC_PACKET)); SET_HTC_PACKET_INFO_TX(pPacket, NULL, pBuffer, Length, HCI_COMMAND_TYPE, AR6K_CONTROL_PKT_TAG); /* issue synchronously */ status = HCI_TransportSendPkt(pConfig->pHCIDev,pPacket,TRUE); } while (FALSE); if (pPacket != NULL) { A_FREE(pPacket); } return status; }
void cmp_anim_destroybind(struct cmp_anim* a) { if (a->alloc != NULL) { if (a->bindmap != NULL) { A_FREE(a->alloc, a->bindmap); } if (a->root_idxs != NULL) { A_FREE(a->alloc, a->root_idxs); } } a->root_idxs = NULL; a->pose = NULL; a->bindmap = NULL; a->root_cnt = 0; }
void android_release_firmware(const struct firmware *firmware) { if (firmware) { if (firmware->data) vfree(firmware->data); A_FREE((struct firmware *)firmware); } }
void load_pak(struct paki_args* args) { result_t r; struct pak_file pak; char filename[DH_PATH_MAX]; path_norm(args->pakfile, args->pakfile); path_tounix(args->path, args->path); r = pak_open(&pak, mem_heap(), args->pakfile, 0); if (IS_FAIL(r)) { err_sendtolog(FALSE); return; } uint file_id = pak_findfile(&pak, args->path); if (file_id == INVALID_INDEX) { printf(TERM_BOLDRED "Extract failed: file '%s' not found in pak.\n" TERM_RESET, args->path); pak_close(&pak); return; } path_getfullfilename(filename, args->path); file_t f = fio_createdisk(filename); if (f == NULL) { printf(TERM_BOLDRED "Extract failed: could not create '%s' for writing.\n" TERM_RESET, filename); pak_close(&pak); err_sendtolog(FALSE); return; } file_t src_file = pak_getfile(&pak, mem_heap(), mem_heap(), file_id, 0); if (src_file == NULL) { pak_close(&pak); fio_close(f); err_sendtolog(FALSE); return; } size_t size; struct allocator* alloc; void* buffer = fio_detachmem(src_file, &size, &alloc); fio_write(f, buffer, size, 1); A_FREE(alloc, buffer); fio_close(f); pak_close(&pak); if (BIT_CHECK(args->usage, PAKI_USAGE_VERBOSE)) { printf(TERM_WHITE "%s -> %s\n" TERM_RESET, args->path, filename); } args->file_cnt ++; // report printf(TERM_BOLDWHITE "Finished: total %d file(s) - %d error(s), %d warning(s)\n" TERM_RESET, args->file_cnt, args->err_cnt, args->warn_cnt); }
A_STATUS FCore_ModifyControlActionString(BT_FILTER_CORE_INFO *pCore, ATHBT_STATE_INDICATION Indication, ATHBT_STATE State, A_CHAR *pAction, int StringLength, ATHBT_MODIFY_CONTROL_ACTION ModifyAction) { BT_CONTROL_ACTION_DESC *pNewDesc; BT_CONTROL_ACTION_DESC *pDescHead; A_CHAR *pString; /* get first entry at the head */ pDescHead = &pCore->ActionDescriptors[Indication].Action[State]; /* allocate and assemble an entry for this action */ pNewDesc = (BT_CONTROL_ACTION_DESC *)A_MALLOC(sizeof(BT_CONTROL_ACTION_DESC) + StringLength + 1); if (NULL == pNewDesc) { return A_NO_MEMORY; } A_MEMZERO(pNewDesc,sizeof(BT_CONTROL_ACTION_DESC)); /* setup and copy string */ pString = (A_CHAR *)((A_UINT8 *)pNewDesc + sizeof(BT_CONTROL_ACTION_DESC)); A_MEMCPY(pString,pAction,StringLength); pString[StringLength] = 0; pNewDesc->pActionString = pString; /* mark that it was allocated so we can clean it up later */ pNewDesc->Flags = BT_CA_DESC_FLAGS_ALLOCATED; switch (ModifyAction) { case ATHBT_MODIFY_CONTROL_ACTION_APPEND: /* append to the end of the list */ while (pDescHead->pNext != NULL) { pDescHead = pDescHead->pNext; } pDescHead->pNext = pNewDesc; break; case ATHBT_MODIFY_CONTROL_ACTION_REPLACE: /* remove any existing replacements or append operations */ CleanupModifiedControlActionDescChain(pDescHead); /* ignore the first entry's action string */ pDescHead->pActionString = NULL; /* add new replacement */ pDescHead->pNext = pNewDesc; break; default: A_FREE(pNewDesc); break; } return A_OK; }
int android_request_firmware(const struct firmware **firmware_p, const char *name, struct device *device) { int ret = 0; struct firmware *firmware; char filename[256]; const char *raw_filename = name; *firmware_p = firmware = A_MALLOC(sizeof(*firmware)); if (!firmware) return -ENOMEM; A_MEMZERO(firmware, sizeof(*firmware)); sprintf(filename, "%s/%s", fwpath, raw_filename); #ifdef TARGET_EUROPA if (strcmp(raw_filename, "softmac")==0) { sprintf(filename, "/data/.nvmac.info"); } #endif /* TARGET_EUROPA */ do { size_t length, bufsize, bmisize; if ( (ret=android_readwrite_file(filename, NULL, NULL, 0)) < 0) { break; } else { length = ret; } bufsize = ALIGN(length, PAGE_SIZE); bmisize = A_ROUND_UP(length, 4); bufsize = max(bmisize, bufsize); firmware->data = vmalloc(bufsize); firmware->size = length; if (!firmware->data) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: Cannot allocate buffer for firmware\n", __FUNCTION__)); ret = -ENOMEM; break; } if ( (ret=android_readwrite_file(filename, (char*)firmware->data, NULL, length)) != length) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: file read error, ret %d request %d\n", __FUNCTION__, ret, length)); ret = -1; break; } } while (0); if (ret<0) { if (firmware) { if (firmware->data) vfree(firmware->data); A_FREE(firmware); } *firmware_p = NULL; } else { ret = 0; } return ret; }
void mt_event_destroy(mt_event e) { for (int i = 0; i < e->signals.item_cnt; i++) { HANDLE ehdl = ((HANDLE*)e->signals.buffer)[i]; if (ehdl != NULL) CloseHandle(ehdl); } arr_destroy(&e->signals); A_FREE(e->alloc, e); }
static void DestroyHTCTxCtrlPacket(HTC_PACKET *pPacket) { adf_nbuf_t netbuf; netbuf = (adf_nbuf_t)GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("free ctrl netbuf :0x%p \n", netbuf)); if (netbuf != NULL) { adf_nbuf_free(netbuf); } A_FREE(pPacket); }