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