*/ DEVICE_CMD Close_DNS(REBREQ *sock) /* ** Note: valid even if not open. ** ***********************************************************************/ { // Terminate a pending request: #ifdef HAS_ASYNC_DNS if (GET_FLAG(sock->flags, RRF_PENDING)) { CLR_FLAG(sock->flags, RRF_PENDING); if (sock->requestee.handle) WSACancelAsyncRequest(sock->requestee.handle); } #endif if (sock->special.net.host_info) OS_FREE(sock->special.net.host_info); sock->special.net.host_info = 0; sock->requestee.handle = 0; SET_CLOSED(sock); return DR_DONE; // Removes it from device's pending list (if needed) }
/* This is user space implementation of osal_firmware_release() It frees malloced buffer and update the size and buffer pointer in fw_ctxt. */ osal_result os_firmware_release(os_firmware_t *fw_ctxt) { osal_result os_ret = OSAL_ERROR; if (NULL != fw_ctxt) { if (NULL != fw_ctxt->fw_address) { OS_FREE(fw_ctxt->fw_address); /*Release fw buffer's memory */ fw_ctxt->fw_address = NULL; fw_ctxt->fw_size = 0; os_ret = OSAL_SUCCESS; } } else { os_ret = OSAL_INVALID_PARAM; } return os_ret; }
/* * Delete the given frequency/chwidth from the NOL. */ static void dfs_nol_delete(struct ath_dfs *dfs, u_int16_t delfreq, u_int16_t delchwidth) { struct dfs_nolelem *nol,**prev_next; if (dfs == NULL) { DFS_DPRINTK(dfs, ATH_DEBUG_DFS, "%s: sc_dfs is NULL\n", __func__); return; } DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL, "%s: remove channel=%d/%d MHz from NOL\n", __func__, delfreq, delchwidth); prev_next = &(dfs->dfs_nol); nol = dfs->dfs_nol; while (nol != NULL) { if (nol->nol_freq == delfreq && nol->nol_chwidth == delchwidth) { *prev_next = nol->nol_next; DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL, "%s removing channel %d/%dMHz from NOL tstamp=%d\n", __func__, nol->nol_freq, nol->nol_chwidth, (adf_os_ticks_to_msecs(adf_os_ticks()) / 1000)); OS_CANCEL_TIMER(&nol->nol_timer); OS_FREE(nol); nol = NULL; nol = *prev_next; /* Update the NOL counter */ dfs->dfs_nol_count--; /* Be paranoid! */ if (dfs->dfs_nol_count < 0) { DFS_PRINTK("%s: dfs_nol_count < 0; eek!\n", __func__); dfs->dfs_nol_count = 0; } } else { prev_next = &(nol->nol_next); nol = nol->nol_next; } } }
ble_error_t ble_l2cap_conn_param_update(uint16_t conn_idx, const gap_conn_params_t *conn_params) { irb_ble_l2cap_conn_param_update_cmd_t *cmd; irb_ble_l2cap_conn_param_update_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_L2CAP_CONN_PARAM_UPDATE_CMD, sizeof(*cmd)); cmd->conn_idx = conn_idx; cmd->conn_params = conn_params; if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
void *log_open(const char *file_name, const char *version, const char *dir, uint32_t mode) { log_t *log = NULL; uint32_t i = 0; if ((NULL == file_name) || (NULL == version) || (NULL == dir)) { return NULL; } log = (log_t *)OS_MALLOC(sizeof(log_t)); if (NULL == log) { return NULL; } memset(log, 0, sizeof(log_t)); OS_RWLOCK_INIT(&log->rwlock); strncpy(log->dir, dir, LOG_NAME_LEN); log->dir[LOG_NAME_LEN - 1] = 0; strncpy(log->name, file_name, LOG_NAME_LEN); log->name[LOG_NAME_LEN - 1] = 0; strncpy(log->version, version, LOG_NAME_LEN); log->version[LOG_NAME_LEN - 1] = 0; log->mode = mode; for (i = 0; i < PIDS_NUM; i++) { log->levels[i] = DEFAULT_LEVEL; } if (0 > backup_log(log)) { OS_FREE(log); return NULL; } return log; }
int pd_print(const char *funcname, const int error, const int error_exit, const char *format, ...) { #ifdef DEBUG_BUILD_TYPE va_list ap; unsigned int *blah; char *priority = error ? KERN_ERR : EMGD_DEBUG_MSG_PRIORITY; char *fmt = NULL; /* Can't directly use the EMGD_DEBUG_S macro (because "format" is a string * variable), so duplicate some of it here: */ if (!(emgd_debug && emgd_debug-> MODULE_NAME)) { return 0; } va_start(ap, format); blah = (unsigned int *)ap; if (error_exit) { EMGD_DEBUG("EXIT With Error..."); } /* Create a new format string, with all of the correct parts: */ fmt = OS_ALLOC(strlen(priority) + strlen(funcname) + strlen(format) + 2); if (fmt == NULL) { printk(format, blah[0], blah[1], blah[2], blah[3], blah[4], blah[5], blah[6], blah[7], blah[8], blah[9]); } else { sprintf(fmt, "%s%s %s", priority, funcname, format); printk(fmt, blah[0], blah[1], blah[2], blah[3], blah[4], blah[5], blah[6], blah[7], blah[8], blah[9]); OS_FREE(fmt); } printk("\n"); va_end(ap); return 0; #endif }
ble_error_t ble_gatts_write_cfm(uint16_t conn_idx, uint16_t handle, att_error_t status) { irb_ble_gatts_write_cfm_cmd_t *cmd; irb_ble_gatts_write_cfm_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_WRITE_CFM_CMD, sizeof(*cmd)); cmd->conn_idx = conn_idx; cmd->handle = handle; cmd->status = status; if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
ble_error_t ble_gatts_set_value(uint16_t handle, uint16_t length, const void *value) { irb_ble_gatts_set_value_cmd_t *cmd; irb_ble_gatts_set_value_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SET_VALUE_CMD, sizeof(*cmd) + length); cmd->handle = handle; cmd->length = length; memcpy(cmd->value, value, length); if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
ble_error_t ble_gatts_add_service(const att_uuid_t *uuid, const gatt_service_t type, uint16_t num_attrs) { irb_ble_gatts_service_add_cmd_t *cmd; irb_ble_gatts_service_add_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SERVICE_ADD_CMD, sizeof(*cmd)); cmd->uuid = *uuid; cmd->type = type; cmd->num_attrs = num_attrs; if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
ble_error_t ble_gatts_disable_service(uint16_t handle) { irb_ble_gatts_service_disable_cmd_t *cmd; irb_ble_gatts_service_disable_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SERVICE_DISABLE_CMD, sizeof(*cmd)); cmd->handle = handle; if (!irb_execute(cmd, (void **) &rsp)) { return ret; } ret = rsp->status; /* free message */ OS_FREE(rsp); return ret; }
/*! * This function is exported directly. It will shutdown an instance * of the HAL that was initialized with igd_driver_init. * * Since the symbol is exported as part of the documented API it must * always exist, however it becomes an empty function when the init * module is not fully included. * * @param driver_handle * * @return void */ void igd_driver_shutdown(igd_driver_h driver_handle) { igd_context_t *context = (igd_context_t *)driver_handle; EMGD_TRACE_ENTER; EMGD_ASSERT(context, "Null Driver Handle", ); /* Shutdown the device context */ init_dispatch->shutdown(context); /* release the driver's context */ if(context) { EMGD_DEBUG("Freeing context"); OS_FREE(context); } EMGD_TRACE_EXIT; return; }
void log_close(void *log) { log_t *tmp_log = (log_t *)log; if (NULL == tmp_log) { return; } if (NULL != tmp_log->disk_hnd) { char date_time[DATA_TIME_STR_LEN]; os_get_date_time_string(date_time, DATA_TIME_STR_LEN); os_file_printf(tmp_log->disk_hnd, "%s %s\n", date_time, "NOTE: LOG FILE CLOSE!!!"); os_file_close(tmp_log->disk_hnd); tmp_log->disk_hnd = NULL; } OS_RWLOCK_DESTROY(&tmp_log->rwlock); OS_FREE(tmp_log); }
ble_error_t ble_gatts_service_changed_ind(uint16_t conn_idx, uint16_t start_handle, uint16_t end_handle) { irb_ble_gatts_service_changed_ind_cmd_t *cmd; irb_ble_gatts_service_changed_ind_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SERVICE_CHANGED_IND_CMD, sizeof(*cmd)); cmd->conn_idx = conn_idx; cmd->start_handle = start_handle; cmd->end_handle = end_handle; if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
os_lock_t os_create_lock(void) { os_lock_pvt_t *p_lock = NULL; if(NULL == (p_lock = OS_ALLOC(sizeof(os_lock_pvt_t)))) { OS_ERROR("OS_ALLOC failed\n"); goto error; } if(NULL == (p_lock->p_sema = OS_ALLOC(sizeof(os_sema_t)))) { OS_ERROR("OS_ALLOC failed\n"); goto error; } os_sema_init(p_lock->p_sema, 1); return ((os_lock_t)p_lock); error: if(p_lock != NULL) { OS_FREE(p_lock); } return (NULL); }
void uds_set_db_increment(ble_service_t *svc, uint16_t src_conn_idx, uint32_t increment, bool notify) { uint8_t num_conn; uint16_t *conn_idx; uint8_t user_id; user_id = uds_get_user_id(svc, src_conn_idx); ble_gap_get_connected(&num_conn, &conn_idx); while (num_conn--) { set_db_increment(svc, conn_idx[num_conn], user_id, increment); } if (conn_idx) { OS_FREE(conn_idx); } if (!notify) { return; } notify_db_increment(svc, src_conn_idx, user_id, increment); }
ble_error_t ble_gatts_set_characteristic_prop(uint16_t handle, gatt_prop_t prop, att_perm_t perm) { irb_ble_gatts_service_characteristic_set_prop_cmd_t *cmd; irb_ble_gatts_service_characteristic_set_prop_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SERVICE_CHARACTERISTIC_SET_PROP_CMD, sizeof(*cmd)); cmd->handle = handle; cmd->prop = prop; cmd->perm = perm; if (!irb_execute(cmd, (void **) &rsp)) { return ret; } ret = rsp->status; /* free message */ OS_FREE(rsp); return ret; }
ble_error_t ble_gatts_register_service(uint16_t *handle, ...) { va_list ap; irb_ble_gatts_service_register_cmd_t *cmd; irb_ble_gatts_service_register_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SERVICE_REGISTER_CMD, sizeof(*cmd)); if (!irb_execute(cmd, (void **) &rsp)) { return ret; } ret = rsp->status; if (handle) { *handle = rsp->handle; } va_start(ap, handle); for (;;) { uint16_t *h = va_arg(ap, uint16_t*); if (!h) { break; } *h = *h + rsp->handle; } va_end(ap); /* free message */ OS_FREE(rsp); return ret; }
void _ath_htc_netdeferfn_cleanup(struct ieee80211com *ic) { wbuf_t wbuf = ADF_NBUF_NULL ; nawds_dentry_t * nawds_entry = NULL ; /* Freeing MGMT defer buffer */ do { OS_MGMT_LOCKBH(&ic->ic_mgmt_lock); wbuf = adf_nbuf_queue_remove(&ic->ic_mgmt_nbufqueue); OS_MGMT_UNLOCKBH(&ic->ic_mgmt_lock); if(!wbuf) break; wbuf_free(wbuf); }while(wbuf); atomic_set(&ic->ic_mgmt_deferflags, DEFER_DONE); do { OS_NAWDSDEFER_LOCKBH(&ic->ic_nawdsdefer_lock); nawds_entry = TAILQ_FIRST(&ic->ic_nawdslearnlist); if(nawds_entry) TAILQ_REMOVE(&ic->ic_nawdslearnlist,nawds_entry,nawds_dlist); OS_NAWDSDEFER_UNLOCKBH(&ic->ic_nawdsdefer_lock); if(!nawds_entry) break; OS_FREE(nawds_entry); }while(1); atomic_set(&ic->ic_nawds_deferflags, DEFER_DONE); }
/* * delete the p2p schedule module. */ int ieee80211_p2p_go_schedule_delete( ieee80211_p2p_go_schedule_t go_scheduler) { IEEE80211_DPRINTF_IC(go_scheduler->ic, IEEE80211_VERBOSE_FUNCTION, IEEE80211_MSG_P2P_GO_SCH, "%s: called.\n", __func__); // free the tsf timer. Blocked to wait for any existing callbacks to end. if (ieee80211_tsftimer_free(go_scheduler->h_tsftimer, true)) { IEEE80211_DPRINTF_IC(go_scheduler->ic, IEEE80211_VERBOSE_SERIOUS, IEEE80211_MSG_P2P_GO_SCH, "%s: 0 ieee80211_tsftimer_free returns error.\n", __func__); } ASSERT(!go_scheduler->callback_active); OS_MESGQ_DESTROY(&go_scheduler->cmd_mesg_q); IEEE80211_P2P_GOSCHE_LOCK_DESTROY(go_scheduler); // free the structure ieee80211_p2p_go_schedule_t OS_FREE(go_scheduler); return 0; }
ble_error_t ble_gatts_send_event(uint16_t conn_idx, uint16_t handle, gatt_event_t type, uint16_t length, const void *value) { irb_ble_gatts_send_event_cmd_t *cmd; irb_ble_gatts_send_event_rsp_t *rsp; ble_error_t ret = BLE_ERROR_FAILED; /* setup IRB with new message and fill it */ cmd = alloc_ble_msg(IRB_BLE_GATTS_SEND_EVENT_CMD, sizeof(*cmd) + length); cmd->conn_idx = conn_idx; cmd->handle = handle; cmd->type = type; cmd->length = length; memcpy(cmd->value, value, length); if (!irb_execute(cmd, (void **) &rsp)) { return BLE_ERROR_FAILED; } ret = rsp->status; OS_FREE(rsp); return ret; }
/* * crete an instance of the p2p schedule module. */ ieee80211_p2p_go_schedule_t ieee80211_p2p_go_schedule_create( osdev_t os_handle, wlan_if_t vap) { struct ieee80211com *ic; ieee80211_p2p_go_schedule_t h_schedule = NULL; bool bad_return = false; tsftimer_handle_t h_tsftimer = NULL; bool msg_queue_init = false; ASSERT(vap); ic = vap->iv_ic; IEEE80211_DPRINTF_IC(ic, IEEE80211_VERBOSE_FUNCTION, IEEE80211_MSG_P2P_GO_SCH, "%s: called.\n", __func__); do { // alloc the mem for structure of ieee80211_p2p_go_schedule h_schedule = (ieee80211_p2p_go_schedule_t) OS_MALLOC(os_handle, sizeof(struct ieee80211_p2p_go_schedule), 0); if (h_schedule == NULL) { IEEE80211_DPRINTF_IC(ic, IEEE80211_VERBOSE_SERIOUS, IEEE80211_MSG_P2P_GO_SCH, "%s: Failed to alloc memory (size=%d).\n", __func__, sizeof(struct ieee80211_p2p_go_schedule)); bad_return = true; break; } // zero out and then init. the contents OS_MEMZERO(h_schedule, sizeof(struct ieee80211_p2p_go_schedule)); h_schedule->vap = vap; h_schedule->ic = ic; h_schedule->os_handle = os_handle; IEEE80211_P2P_GOSCHE_LOCK_INIT(h_schedule); h_schedule->go_present = true; /* GO start off from being awake */ if (OS_MESGQ_INIT(os_handle, &h_schedule->cmd_mesg_q, sizeof(ieee80211_p2p_go_schedule_req) * P2P_GO_PS_MAX_NUM_SCHEDULE_REQ, P2P_GO_SCH_MAX_EVENT_QUEUE_DEPTH, ieee80211_p2p_go_schedule_mesgq_event_handler, h_schedule, MESGQ_PRIORITY_NORMAL, MESGQ_ASYNCHRONOUS_EVENT_DELIVERY) != 0) { IEEE80211_DPRINTF_IC(h_schedule->ic, IEEE80211_VERBOSE_SERIOUS, IEEE80211_MSG_P2P_GO_SCH, "%s : OS_MESGQ_INIT failed.\n", __func__); bad_return = true; break; } msg_queue_init = true; /* alloc a tsf timer */ h_tsftimer = ieee80211_tsftimer_alloc(ic->ic_tsf_timer, 0, my_tsftimer_timeout, P2P_GO_SCH_CB_ID, h_schedule, my_tsftimer_resync); if (h_tsftimer == NULL) { IEEE80211_DPRINTF_IC(h_schedule->ic, IEEE80211_VERBOSE_SERIOUS, IEEE80211_MSG_P2P_GO_SCH, "%s: 0 ieee80211_tsftimer_alloc returns error.\n", __func__); bad_return = true; break; } h_schedule->h_tsftimer = h_tsftimer; h_schedule->tsftimer_started = false; h_schedule->paused = false; } while ( FALSE ); if (!bad_return) { return h_schedule; } else { /* Free the TSF Timer */ if (h_tsftimer) { if (ieee80211_tsftimer_free(h_tsftimer, true)) { IEEE80211_DPRINTF_IC(h_schedule->ic, IEEE80211_VERBOSE_SERIOUS, IEEE80211_MSG_P2P_GO_SCH, "%s: 0 ieee80211_tsftimer_free returns error.\n", __func__); } h_tsftimer = NULL; } if (msg_queue_init) { OS_MESGQ_DESTROY(&h_schedule->cmd_mesg_q); msg_queue_init = false; } /* Free structure of ieee80211_p2p_go_schedule */ if (h_schedule) { IEEE80211_P2P_GOSCHE_LOCK_DESTROY(h_schedule); OS_FREE(h_schedule); h_schedule = NULL; } return NULL; } }
int ath_descdma_setup( struct ath_softc *sc, struct ath_descdma *dd, ath_bufhead *head, const char *name, int nbuf, int ndesc, int is_tx, int frag_per_msdu) { #define DS2PHYS(_dd, _ds) \ ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc)) #define ATH_DESC_4KB_BOUND_CHECK(_daddr, _len) ((((u_int32_t)(_daddr) & 0xFFF) > (0x1000 - (_len))) ? 1 : 0) #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096) u_int8_t *ds; struct ath_buf *bf; int i, bsize, error, desc_len; uint32_t nbuf_left, nbuf_alloc, alloc_size, buf_arr_size; int j, k; struct ath_buf **bf_arr; if (is_tx) { desc_len = sc->sc_txdesclen; /* legacy tx descriptor needs to be allocated for each fragment */ if (sc->sc_num_txmaps == 1) { nbuf = nbuf * frag_per_msdu; /*ATH_FRAG_PER_MSDU;*/ } } else { desc_len = sizeof(struct ath_desc); } DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA: %u buffers %u desc/buf %d desc_len\n", __func__, name, nbuf, ndesc, desc_len); /* ath_desc must be a multiple of DWORDs */ if ((desc_len % 4) != 0) { DPRINTF(sc, ATH_DEBUG_FATAL, "%s: ath_desc not DWORD aligned\n", __func__ ); ASSERT((desc_len % 4) == 0); error = -ENOMEM; goto fail; } dd->dd_name = name; dd->dd_desc_len = desc_len * nbuf * ndesc; /* * WAR for bug 30982 (Merlin) * Need additional DMA memory because we can't use descriptors that cross the * 4K page boundary. Assume one skipped descriptor per 4K page. */ if (!ath_hal_has4kbsplittrans(sc->sc_ah)) { int numdescpage = 4096/(desc_len*ndesc); dd->dd_desc_len = (nbuf/numdescpage + 1 ) * 4096; } #if ATH_SUPPORT_DESC_CACHABLE if ((strcmp(name, "tx") == 0) && sc->sc_enhanceddmasupport) { dd->dd_desc = (void *)OS_MALLOC_NONCONSISTENT(sc->sc_osdev, dd->dd_desc_len, &dd->dd_desc_paddr, OS_GET_DMA_MEM_CONTEXT(dd, dd_dmacontext), sc->sc_reg_parm.shMemAllocRetry); } else #endif { /* allocate descriptors */ dd->dd_desc = (void *)OS_MALLOC_CONSISTENT(sc->sc_osdev, dd->dd_desc_len, &dd->dd_desc_paddr, OS_GET_DMA_MEM_CONTEXT(dd, dd_dmacontext), sc->sc_reg_parm.shMemAllocRetry); } if (dd->dd_desc == NULL) { error = -ENOMEM; goto fail; } ds = dd->dd_desc; DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA map: %p (%u) -> %llx (%u)\n", __func__, dd->dd_name, ds, (u_int32_t) dd->dd_desc_len, ito64(dd->dd_desc_paddr), /*XXX*/ (u_int32_t) dd->dd_desc_len); /* allocate buffers */ bsize = sizeof(struct ath_buf) * nbuf; buf_arr_size = ((nbuf * sizeof(struct ath_buf))/MAX_BUF_MEM_ALLOC_SIZE + 2) ; /* one extra element is reserved at end to indicate the end of array */ bf_arr = (struct ath_buf **)OS_MALLOC(sc->sc_osdev, (sizeof(struct ath_buf *) * buf_arr_size), GFP_KERNEL); if(!bf_arr) { error = -ENOMEM; goto fail2; } OS_MEMZERO(bf_arr, (buf_arr_size * sizeof(struct ath_buf *))); TAILQ_INIT(head); nbuf_left = nbuf; nbuf_alloc = (MAX_BUF_MEM_ALLOC_SIZE / (sizeof(struct ath_buf))); for(j = 0; (nbuf_left && (j < (buf_arr_size-1))); j++) { nbuf_alloc = MIN(nbuf_left, nbuf_alloc); alloc_size = (nbuf_alloc * sizeof(struct ath_buf)); bf_arr[j] = (struct ath_buf *)OS_MALLOC(sc->sc_osdev, alloc_size, GFP_KERNEL); if(bf_arr[j] == NULL) { for(k = 0; k < j; k++) { OS_FREE(bf_arr[k]); bf_arr[k] = NULL; } error = -ENOMEM; goto fail2; } else { OS_MEMZERO(bf_arr[j], alloc_size); nbuf_left -= nbuf_alloc; bf = bf_arr[j]; for (i = 0; i < nbuf_alloc; i++, bf++, ds += (desc_len * ndesc)) { bf->bf_desc = ds; bf->bf_daddr = DS2PHYS(dd, ds); if (!ath_hal_has4kbsplittrans(sc->sc_ah)) { /* * WAR for bug 30982. * Skip descriptor addresses which can cause 4KB boundary crossing (addr + length) * with a 32 dword descriptor fetch. */ if (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr, desc_len * ndesc)) { ds += 0x1000 - (bf->bf_daddr & 0xFFF); /* start from the next page */ bf->bf_desc = ds; bf->bf_daddr = DS2PHYS(dd, ds); } } TAILQ_INSERT_TAIL(head, bf, bf_list); } } } dd->dd_bufptr = bf_arr; #ifdef ATH_DEBUG_MEM_LEAK dd->dd_num_buf = nbuf; #endif /* * For OS's that need to allocate dma context to be used to * send down to hw, do that here. (BSD is the only one that needs * it currently.) */ ALLOC_DMA_CONTEXT_POOL(sc->sc_osdev, name, nbuf); return 0; fail2: #if ATH_SUPPORT_DESC_CACHABLE if ((strcmp(name, "tx") == 0) && sc->sc_enhanceddmasupport) { OS_FREE_NONCONSISTENT(sc->sc_osdev, dd->dd_desc_len, dd->dd_desc, dd->dd_desc_paddr, OS_GET_DMA_MEM_CONTEXT(dd, dd_dmacontext)); }else #endif { OS_FREE_CONSISTENT(sc->sc_osdev, dd->dd_desc_len, dd->dd_desc, dd->dd_desc_paddr, OS_GET_DMA_MEM_CONTEXT(dd, dd_dmacontext)); } if (bf_arr) { OS_FREE(bf_arr); } fail: OS_MEMZERO(dd, sizeof(*dd)); return error; #undef ATH_DESC_4KB_BOUND_CHECK #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED #undef DS2PHYS }
/* This function Initialize the radar filter tables * if the ath dfs domain is uninitalized or * ath dfs domain is different from hal dfs domain */ int dfs_init_radar_filters(struct ieee80211com *ic, struct ath_dfs_radar_tab_info *radar_info) { u_int32_t T, Tmax; int numpulses,p,n, i; int numradars = 0, numb5radars = 0; struct ath_dfs *dfs = (struct ath_dfs *)ic->ic_dfs; struct dfs_filtertype *ft = NULL; struct dfs_filter *rf=NULL; struct dfs_pulse *dfs_radars; struct dfs_bin5pulse *b5pulses=NULL; int32_t min_rssithresh=DFS_MAX_RSSI_VALUE; u_int32_t max_pulsedur=0; if (dfs == NULL) { VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_ERROR, "%s[%d]: dfs is NULL", __func__, __LINE__); return DFS_STATUS_FAIL; } /* clear up the dfs domain flag first */ #ifndef ATH_DFS_RADAR_DETECTION_ONLY dfs->ath_dfs_isdfsregdomain = 0; #endif /* * If radar_info is NULL or dfsdomain is NULL, treat * the rest of the radar configuration as suspect. */ if (radar_info == NULL || radar_info->dfsdomain == 0) { VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_ERROR, "%s[%d]: Unknown dfs domain %d ", __func__, __LINE__, dfs->dfsdomain); /* Disable radar detection since we don't have a radar domain */ dfs->dfs_proc_phyerr &= ~DFS_RADAR_EN; /* Returning success though we are not completing init. A failure * will fail dfs_attach also. */ return DFS_STATUS_SUCCESS; } VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO, "%s[%d]:dfsdomain=%d, numradars=%d, numb5radars=%d", __func__, __LINE__, radar_info->dfsdomain, radar_info->numradars, radar_info->numb5radars); dfs->dfsdomain = radar_info->dfsdomain; dfs_radars = radar_info->dfs_radars; numradars = radar_info->numradars; b5pulses = radar_info->b5pulses; numb5radars = radar_info->numb5radars; /* XXX this should be an explicit copy of some sort! */ dfs->dfs_defaultparams = radar_info->dfs_defaultparams; #ifndef ATH_DFS_RADAR_DETECTION_ONLY dfs->ath_dfs_isdfsregdomain = 1; #endif dfs->dfs_rinfo.rn_numradars = 0; /* Clear filter type table */ for (n = 0; n < 256; n++) { for (i=0;i<DFS_MAX_RADAR_OVERLAP; i++) (dfs->dfs_radartable[n])[i] = -1; } /* Now, initialize the radar filters */ for (p=0; p<numradars; p++) { ft = NULL; for (n=0; n<dfs->dfs_rinfo.rn_numradars; n++) { if ((dfs_radars[p].rp_pulsedur == dfs->dfs_radarf[n]->ft_filterdur) && (dfs_radars[p].rp_numpulses == dfs->dfs_radarf[n]->ft_numpulses) && (dfs_radars[p].rp_mindur == dfs->dfs_radarf[n]->ft_mindur) && (dfs_radars[p].rp_maxdur == dfs->dfs_radarf[n]->ft_maxdur)) { ft = dfs->dfs_radarf[n]; break; } } if (ft == NULL) { /* No filter of the appropriate dur was found */ if ((dfs->dfs_rinfo.rn_numradars+1) >DFS_MAX_RADAR_TYPES) { DFS_DPRINTK(dfs, ATH_DEBUG_DFS, "%s: Too many filter types", __func__); goto bad4; } ft = dfs->dfs_radarf[dfs->dfs_rinfo.rn_numradars]; ft->ft_numfilters = 0; ft->ft_numpulses = dfs_radars[p].rp_numpulses; ft->ft_patterntype = dfs_radars[p].rp_patterntype; ft->ft_mindur = dfs_radars[p].rp_mindur; ft->ft_maxdur = dfs_radars[p].rp_maxdur; ft->ft_filterdur = dfs_radars[p].rp_pulsedur; ft->ft_rssithresh = dfs_radars[p].rp_rssithresh; ft->ft_rssimargin = dfs_radars[p].rp_rssimargin; ft->ft_minpri = 1000000; if (ft->ft_rssithresh < min_rssithresh) min_rssithresh = ft->ft_rssithresh; if (ft->ft_maxdur > max_pulsedur) max_pulsedur = ft->ft_maxdur; for (i=ft->ft_mindur; i<=ft->ft_maxdur; i++) { u_int32_t stop=0,tableindex=0; while ((tableindex < DFS_MAX_RADAR_OVERLAP) && (!stop)) { if ((dfs->dfs_radartable[i])[tableindex] == -1) stop = 1; else tableindex++; } if (stop) { (dfs->dfs_radartable[i])[tableindex] = (int8_t) (dfs->dfs_rinfo.rn_numradars); } else { DFS_DPRINTK(dfs, ATH_DEBUG_DFS, "%s: Too many overlapping radar filters", __func__); goto bad4; } } dfs->dfs_rinfo.rn_numradars++; } rf = &(ft->ft_filters[ft->ft_numfilters++]); dfs_reset_delayline(&rf->rf_dl); numpulses = dfs_radars[p].rp_numpulses; rf->rf_numpulses = numpulses; rf->rf_patterntype = dfs_radars[p].rp_patterntype; rf->rf_pulseid = dfs_radars[p].rp_pulseid; rf->rf_mindur = dfs_radars[p].rp_mindur; rf->rf_maxdur = dfs_radars[p].rp_maxdur; rf->rf_numpulses = dfs_radars[p].rp_numpulses; rf->rf_ignore_pri_window = dfs_radars[p].rp_ignore_pri_window; T = (100000000/dfs_radars[p].rp_max_pulsefreq) - 100*(dfs_radars[p].rp_meanoffset); rf->rf_minpri = dfs_round((int32_t)T - (100*(dfs_radars[p].rp_pulsevar))); Tmax = (100000000/dfs_radars[p].rp_pulsefreq) - 100*(dfs_radars[p].rp_meanoffset); rf->rf_maxpri = dfs_round((int32_t)Tmax + (100*(dfs_radars[p].rp_pulsevar))); if( rf->rf_minpri < ft->ft_minpri ) ft->ft_minpri = rf->rf_minpri; rf->rf_fixed_pri_radar_pulse = ( dfs_radars[p].rp_max_pulsefreq == dfs_radars[p].rp_pulsefreq ) ? 1 : 0; rf->rf_threshold = dfs_radars[p].rp_threshold; rf->rf_filterlen = rf->rf_maxpri * rf->rf_numpulses; VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO, "%s[%d]: minprf = %d maxprf = %d pulsevar = %d thresh=%d", __func__,__LINE__,dfs_radars[p].rp_pulsefreq, dfs_radars[p].rp_max_pulsefreq, dfs_radars[p].rp_pulsevar, rf->rf_threshold); VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO, "%s[%d]:minpri = %d maxpri = %d filterlen = %d filterID = %d",__func__,__LINE__, rf->rf_minpri, rf->rf_maxpri, rf->rf_filterlen, rf->rf_pulseid); } #ifdef DFS_DEBUG dfs_print_filters(ic); #endif dfs->dfs_rinfo.rn_numbin5radars = numb5radars; if (dfs->dfs_b5radars != NULL) OS_FREE(dfs->dfs_b5radars); dfs->dfs_b5radars = (struct dfs_bin5radars *)OS_MALLOC(NULL, numb5radars * sizeof(struct dfs_bin5radars), GFP_KERNEL); if (dfs->dfs_b5radars == NULL) { DFS_DPRINTK(dfs, ATH_DEBUG_DFS, "%s: cannot allocate memory for bin5 radars", __func__); goto bad4; } for (n=0; n<numb5radars; n++) { dfs->dfs_b5radars[n].br_pulse = b5pulses[n]; dfs->dfs_b5radars[n].br_pulse.b5_timewindow *= 1000000; if (dfs->dfs_b5radars[n].br_pulse.b5_rssithresh < min_rssithresh) min_rssithresh = dfs->dfs_b5radars[n].br_pulse.b5_rssithresh; if (dfs->dfs_b5radars[n].br_pulse.b5_maxdur > max_pulsedur) max_pulsedur = dfs->dfs_b5radars[n].br_pulse.b5_maxdur; } dfs_reset_alldelaylines(dfs); dfs_reset_radarq(dfs); dfs->dfs_curchan_radindex = -1; dfs->dfs_extchan_radindex = -1; dfs->dfs_rinfo.rn_minrssithresh = min_rssithresh; /* Convert durations to TSF ticks */ dfs->dfs_rinfo.rn_maxpulsedur = dfs_round((int32_t)((max_pulsedur*100/80)*100)); /* relax the max pulse duration a little bit due to inaccuracy caused by chirping. */ dfs->dfs_rinfo.rn_maxpulsedur = dfs->dfs_rinfo.rn_maxpulsedur +20; VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO, "%s[%d]: DFS min filter rssiThresh = %d", __func__, __LINE__, min_rssithresh); VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO, "%s[%d]:DFS max pulse dur = %d ticks", __func__ ,__LINE__, dfs->dfs_rinfo.rn_maxpulsedur); return DFS_STATUS_SUCCESS; bad4: return DFS_STATUS_FAIL; }
int spectral_retrieve_raw_capture(ath_dev_t dev, void* outdata, u_int32_t *outsize) { struct ath_softc *sc = ATH_DEV_TO_SC(dev); SPECTRAL_ADC_DATA *rparams = (SPECTRAL_ADC_DATA *)outdata; int error = 0; u_int32_t max_samples; HAL_STATUS status; SPECTRAL_ADC_DC_FILTER* dcf = NULL; if (!sc->sc_raw_adc_capture_enabled) { DPRINTF(sc, ATH_DEBUG_ANY, "%s[%d]: called while not in raw capture mode!\n", __func__, __LINE__); return -ENOTCONN; } if (sc->sc_opmode != HAL_M_RAW_ADC_CAPTURE) { spectral_exit_raw_capture_mode(dev); DPRINTF(sc, ATH_DEBUG_ANY, "%s[%d]: called while HAL mode not raw capture!\n", __func__, __LINE__); return -ESTALE; } if (*outsize < sizeof(SPECTRAL_ADC_DATA) || !outdata) { DPRINTF(sc, ATH_DEBUG_ANY, "%s[%d]: too small: expect >= %d, got %d\n", __func__, __LINE__, sizeof(SPECTRAL_ADC_DATA), *outsize); return -EINVAL; } if (sc->sc_invalid) { DPRINTF(sc, ATH_DEBUG_ANY, "%s[%d]: called but device is invalid or removed!\n", __func__, __LINE__); return -ENXIO; } if (!(sc->sc_adc_capture_flags & SPECTRAL_ADC_CAPTURE_FLAG_DISABLE_DC_FILTER)) { dcf = (SPECTRAL_ADC_DC_FILTER *) OS_MALLOC(dev, sizeof(SPECTRAL_ADC_DC_FILTER), GPF_KERNEL); if (dcf) { OS_MEMZERO(dcf, sizeof(SPECTRAL_ADC_DC_FILTER)); } else { DPRINTF(sc, ATH_DEBUG_ANY, "%s: alloc DC filter failed!\n", __func__); } } DPRINTF(sc, ATH_DEBUG_RECV, "%s[%d]: chain_mask=0x%x capture_flags=0x%x\n", __func__, __LINE__, sc->sc_adc_chain_mask, sc->sc_adc_capture_flags); ath_hal_begin_adc_capture(sc->sc_ah, (sc->sc_adc_capture_flags & SPECTRAL_ADC_CAPTURE_FLAG_AGC_AUTO)); rparams->cap.version = SPECTRAL_ADC_API_VERSION; rparams->duration = SPECTRAL_RAW_ADC_SAMPLES_PER_CALL / SPECTRAL_RAW_ADC_SAMPLES_FREQUENCY_MHZ; rparams->sample_len = max_samples = (*outsize - sizeof(SPECTRAL_ADC_DATA))/sizeof(SPECTRAL_ADC_SAMPLE); rparams->cap.chain_info.num_chains = sc->sc_adc_num_chains; rparams->cap.freq = sc->sc_adc_freq; rparams->cap.ieee = sc->sc_adc_ieee; rparams->cap.chan_flags = sc->sc_adc_chan_flags; rparams->cap.chain_info.chain_mask = sc->sc_adc_chain_mask; rparams->cap.capture_flags = sc->sc_adc_capture_flags; ath_hal_calculate_adc_ref_powers(sc->sc_ah, sc->sc_adc_freq, &rparams->min_sample_val, &rparams->max_sample_val, rparams->ref_power, sizeof(rparams->ref_power)/sizeof(rparams->ref_power[0])); if ((status = ath_hal_retrieve_capture_data(sc->sc_ah, sc->sc_adc_chain_mask, 1, /* disable dc filt here - now we do it after call */ rparams->data, &rparams->sample_len)) != HAL_OK) { DPRINTF(sc, ATH_DEBUG_ANY, "%s[%d]: ath_hal_retrieve_capture_data failed[%d]: cnt passed was %d[%d]\n", __func__, __LINE__, status, max_samples, rparams->sample_len); error = (status == HAL_ENOMEM) ? -ENOMEM : -EIO; } else { if (!(sc->sc_adc_capture_flags & SPECTRAL_ADC_CAPTURE_FLAG_DISABLE_DC_FILTER) && dcf) { DPRINTF(sc, ATH_DEBUG_RECV, "%s: running DC filter [wnd=%d] over %d chains now...\n", __func__, DC_FILT_WINDOW, sc->sc_adc_num_chains); spectral_run_dc_filter(dev, rparams, dcf); } *outsize = sizeof(SPECTRAL_ADC_DATA) + rparams->sample_len*sizeof(SPECTRAL_ADC_SAMPLE); } if (dcf) { OS_FREE(dcf); } return error; }
/* Set application defined IEs */ int wlan_mlme_set_appie(wlan_if_t vaphandle, ieee80211_frame_type ftype, u_int8_t *buf, u_int16_t buflen) { struct ieee80211vap *vap = vaphandle; struct ieee80211com *ic = vap->iv_ic; int error = 0; u_int8_t *iebuf = NULL; bool alloc_iebuf = FALSE; IEEE80211_DPRINTF(vap, IEEE80211_MSG_MLME, "%s\n", __func__); ASSERT(ftype < IEEE80211_FRAME_TYPE_MAX); if (ftype >= IEEE80211_FRAME_TYPE_MAX) { error = -EINVAL; goto exit; } #if ATH_SUPPORT_HS20 buflen = wlan_mlme_parse_appie(vap, ftype, buf, buflen); #endif if (buflen > vap->iv_app_ie_maxlen[ftype]) { /* Allocate ie buffer */ iebuf = OS_MALLOC(ic->ic_osdev, buflen, 0); if (iebuf == NULL) { error = -ENOMEM; goto exit; } alloc_iebuf = TRUE; vap->iv_app_ie_maxlen[ftype] = buflen; } else { iebuf = vap->iv_app_ie[ftype].ie; } IEEE80211_VAP_LOCK(vap); /* * Temp: reduce window of race with beacon update in Linux AP. * In Linux AP, ieee80211_beacon_update is called in ISR, so * iv_lock is not acquired. */ IEEE80211_VAP_APPIE_UPDATE_DISABLE(vap); /* Free existing buffer */ if (alloc_iebuf == TRUE && vap->iv_app_ie[ftype].ie) { OS_FREE(vap->iv_app_ie[ftype].ie); } vap->iv_app_ie[ftype].ie = iebuf; vap->iv_app_ie[ftype].length = buflen; if (buflen) { ASSERT(buf); if (buf == NULL) { IEEE80211_VAP_UNLOCK(vap); error = -EINVAL; goto exit; } /* Copy app ie contents and save pointer/length */ OS_MEMCPY(iebuf, buf, buflen); } /* Set appropriate flag so that the IE gets updated in the next beacon */ IEEE80211_VAP_APPIE_UPDATE_ENABLE(vap); IEEE80211_VAP_UNLOCK(vap); exit: return error; }
/** * \brief BLE manager task */ static void ble_mgr_task(void *pvParameters) { ad_ble_hdr_t *msg_rx; uint32_t ulNotifiedValue; OS_BASE_TYPE xResult; int8_t wdog_id; /* Register task to be monitored by watch dog. */ wdog_id = sys_watchdog_register(false); for (;;) { /* Notify watch dog on each loop since there's no other trigger for this. */ sys_watchdog_notify(wdog_id); /* Suspend monitoring while task is blocked on OS_TASK_NOTIFY_WAIT(). */ sys_watchdog_suspend(wdog_id); /* * Wait on any of the event group bits, then clear them all. */ xResult = OS_TASK_NOTIFY_WAIT(0x0, OS_TASK_NOTIFY_ALL_BITS, &ulNotifiedValue, OS_TASK_NOTIFY_FOREVER); OS_ASSERT(xResult == OS_OK); /* Resume watch dog monitoring. */ sys_watchdog_notify_and_resume(wdog_id); if (ulNotifiedValue & mainBIT_ADAPTER_EVENT_QUEUE) { /* Make sure there are messages waiting on the queue. */ if (!uxQueueMessagesWaiting(adapter_if->evt_q)) { goto no_event; } /* Check if there is free space on BLE manager's event queue. */ if (uxQueueSpacesAvailable(mgr_if.evt_q)) { /* Get message from queue. */ OS_QUEUE_GET(adapter_if->evt_q, &msg_rx, 0); OS_ASSERT(msg_rx->op_code < AD_BLE_OP_CODE_LAST); #ifdef BLE_STACK_PASSTHROUGH_MODE { OS_IRB new_irb; /* Fill-in new IRB fields. */ new_irb.status = IRB_PENDING; new_irb.class_id = IRB_BLE; new_irb.ptr_buf = msg_rx; /* Send directly to BLE manager's event queue. */ ble_mgr_event_queue_send(&new_irb, OS_QUEUE_FOREVER); } #else if (msg_rx->op_code == AD_BLE_OP_CODE_STACK_MSG) { irb_ble_stack_msg_t *stack_msg = (irb_ble_stack_msg_t*) msg_rx; /* In non-passthrough we only expect GTL messages. */ OS_ASSERT(stack_msg->msg_type == GTL_MSG); /* * during reset we ignore messages other than GAPM_CMP_EVT * and GAPM_RESET operation */ if (reset) { struct gapm_cmp_evt *evt; if (stack_msg->msg.gtl.msg_id != GAPM_CMP_EVT) { goto rx_done; } evt = (void *) stack_msg->msg.gtl.param; if (evt->operation != GAPM_RESET) { goto rx_done; } } /* * Check if someone is waiting for this message. * if not, try to handle message as an event. */ if (!ble_gtl_waitqueue_match(&stack_msg->msg.gtl)) { if (!ble_gtl_handle_event(&stack_msg->msg.gtl)) { /* Stack message is not handled by the manager. */ #ifdef DEBUG configASSERT(0); #endif } } } else if (msg_rx->op_code == AD_BLE_OP_CODE_ADAPTER_MSG) { ad_ble_msg_t *ad_msg = (ad_ble_msg_t *) msg_rx; /* In non-passthrough we only expect GTL messages. */ OS_ASSERT(ad_msg->operation < AD_BLE_OP_LAST); /* Check if someone is waiting for this message. */ ble_ad_msg_waitqueue_match(ad_msg); } rx_done: OS_FREE(msg_rx); #endif /* * Check if there are more messages waiting in the BLE adapter's * event queue. */ if (uxQueueMessagesWaiting(adapter_if->evt_q)) { OS_TASK_NOTIFY(mgr_if.task, mainBIT_ADAPTER_EVENT_QUEUE, OS_NOTIFY_SET_BITS); } } else { /* Set blocked flag to true. */ ble_mgr_blocked = true; } } no_event: if (ulNotifiedValue & mainBIT_MANAGER_COMMAND_QUEUE) { if (uxQueueMessagesWaiting(mgr_if.cmd_q)) { OS_IRB irb_rx; /* Get IRB from the queue. */ OS_QUEUE_GET(mgr_if.cmd_q, &irb_rx, 0); if (irb_rx.status == IRB_COMPLETED) { /* Free message buffer if it was not freed by application. */ irb_ble_free_msg(&irb_rx); } else if (irb_rx.status == IRB_ERROR) { ble_mgr_event_queue_send(&irb_rx, OS_QUEUE_FOREVER); } else if (irb_rx.status == IRB_PENDING) { /* New IRB from application. */ if (!ble_irb_handle_msg(&irb_rx)) { /* * No handler found for IRB - free command buffer * because nothing else will free it. */ OS_FREE(irb_rx.ptr_buf); irb_rx.ptr_buf = NULL; } } /* Check if blocked and if there is space on the event queue. */ if (ble_mgr_blocked && uxQueueSpacesAvailable(mgr_if.evt_q)) { /* Set flag to false. */ ble_mgr_blocked = false; /* Notify task to resume getting BLE adapter events. */ OS_TASK_NOTIFY(mgr_if.task, mainBIT_ADAPTER_EVENT_QUEUE, OS_NOTIFY_SET_BITS); } /* Check if there are messages waiting in the command queue. */ if (uxQueueMessagesWaiting(mgr_if.cmd_q)) { OS_TASK_NOTIFY(mgr_if.task, mainBIT_MANAGER_COMMAND_QUEUE, OS_NOTIFY_SET_BITS); } } } /* * Check this bit as last one since previous commands may also update storage. In * such case changes will be written to flash already and there's no need to execute * this twice in a row. */ if (ulNotifiedValue & mainBIT_COMMIT_STORAGE) { /* * To commit anything modified in storage it's enough to acquire and then * immediately release lock - if dirty flag was set, contents of storage * will be written to flash automatically. */ storage_acquire(); storage_release(); } /* Check if BLE adapter is blocked and if there is free space on its event queue. */ if (ble_mgr_adapter_is_blocked() && uxQueueSpacesAvailable(adapter_if->evt_q)) { /* Notify BLE adapter that there is free space on its event queue. */ ad_ble_notify_event_queue_avail(); } } }
/* Interface functions */ static struct ieee80211_node * ol_ath_node_alloc(struct ieee80211vap *vap, const u_int8_t *macaddr, bool tmpnode) { struct ieee80211com *ic = vap->iv_ic; struct ol_ath_vap_net80211 *avn = OL_ATH_VAP_NET80211(vap); struct ol_ath_softc_net80211 *scn = OL_ATH_SOFTC_NET80211(ic); struct ol_ath_node_net80211 *anode; adf_os_spin_lock_bh(&scn->scn_lock); scn->peer_count++; if (scn->peer_count > scn->wlan_resource_config.num_peers) { adf_os_spin_unlock_bh(&scn->scn_lock); printk("%s: vap (%p) scn (%p) the peer count exceeds the supported number %d \n", __func__, vap, scn, scn->wlan_resource_config.num_peers); goto err_node_alloc; } adf_os_spin_unlock_bh(&scn->scn_lock); anode = (struct ol_ath_node_net80211 *)OS_MALLOC(scn->sc_osdev, sizeof(struct ol_ath_node_net80211), GFP_ATOMIC); if (anode == NULL) goto err_node_alloc; OS_MEMZERO(anode, sizeof(struct ol_ath_node_net80211)); anode->an_node.ni_vap = vap; /* do not create/delete peer on target for temp nodes and self-peers */ if (!tmpnode && !is_node_self_peer(vap, macaddr)) { if (wmi_unified_peer_create_send(scn->wmi_handle, macaddr,avn->av_if_id)) { printk("%s : Unable to create peer in Target \n", __func__); OS_FREE(anode); goto err_node_alloc; } adf_os_spin_lock_bh(&scn->scn_lock); anode->an_txrx_handle = ol_txrx_peer_attach(scn->pdev_txrx_handle, avn->av_txrx_handle, (u_int8_t *) macaddr); if (anode->an_txrx_handle == NULL) { adf_os_spin_unlock_bh(&scn->scn_lock); printk("%s : Unable to attach txrx peer\n", __func__); OS_FREE(anode); goto err_node_alloc; } adf_os_spin_unlock_bh(&scn->scn_lock); /* static wep keys stored in vap needs to be * pushed to all nodes except self node */ if(IEEE80211_VAP_IS_PRIVACY_ENABLED(vap) && (OS_MEMCMP(macaddr,vap->iv_myaddr,IEEE80211_ADDR_LEN) != 0 )) { set_node_wep_keys(vap,macaddr); } } return &anode->an_node; err_node_alloc: adf_os_spin_lock_bh(&scn->scn_lock); scn->peer_count--; adf_os_spin_unlock_bh(&scn->scn_lock); return NULL; }
/*! * This function is directly exported. * * @param found_device * @param pdev * * @return igd_driver_h * @return NULL on failure */ igd_driver_h igd_driver_init( igd_init_info_t *init_info ) { igd_context_t *context; os_pci_dev_t pdev = (os_pci_dev_t)NULL; os_pci_dev_t vga_disable_dev; iegd_pci_t *found_device; int ret; int i; EMGD_TRACE_ENTER; /* Allocate a context */ context = (void *) OS_ALLOC(sizeof(igd_context_t)); fixme_vbios_context = context; if(!context) { EMGD_ERROR_EXIT("igd_driver_init failed to create context"); return NULL; } OS_MEMSET(context, 0, sizeof(igd_context_t)); /* Search VGA devices for a supported one */ ret = detect_device(&found_device, &pdev); if(ret) { OS_FREE(context); return NULL; } /* * Some platforms (currently only Atom E6xx) use two PCI devices (the * second device being for SDVO) and this causes the VGA arbiter to get * involved. Legacy VGA decoding must be disabled for all PCI devices * except one, otherwise the VGA arbiter will prevent DRI usage in the * X server. */ for (i = 0; i < MAX_LEGACY_VGA_DISABLE; i++) { vga_disable_dev = os_pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_SDVO_TNC, 0xFFFF, 0, 0, NULL); if (vga_disable_dev) { printk(KERN_INFO "VGA arbiter detected; disabling legacy VGA" " decoding on SDVO device\n"); os_pci_disable_legacy_vga_decoding(vga_disable_dev); os_pci_free_device(vga_disable_dev); } } context->device_context.did = found_device->device_id; init_dispatch = (init_dispatch_t *)dispatch_acquire(context, init_dispatch_table); if(!init_dispatch) { EMGD_ERROR_EXIT("No dispatch found for listed device"); return NULL; } ret = init_dispatch->query(context, init_dispatch, pdev, &init_info->bus, &init_info->slot, &init_info->func); if(ret) { OS_FREE(context); EMGD_ERROR_EXIT("Device Dependent Query Failed"); return NULL; } /* init info */ init_info->vendor_id = found_device->vendor_id; init_info->device_id = found_device->device_id; init_info->name = init_dispatch->name; init_info->chipset = init_dispatch->chipset; init_info->default_pd_list = init_dispatch->default_pd_list; EMGD_TRACE_EXIT; return (igd_driver_h)context; }
void dfs_detach(struct ieee80211com *ic) { struct ath_dfs *dfs = (struct ath_dfs *)ic->ic_dfs; int n, empty; if (dfs == NULL) { DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, "%s: ic_dfs is NULL\n", __func__); return; } /* Bug 29099 make sure all outstanding timers are cancelled*/ if (dfs->ath_radar_tasksched) { OS_CANCEL_TIMER(&dfs->ath_dfs_task_timer); dfs->ath_radar_tasksched = 0; } if (dfs->ath_dfstest) { OS_CANCEL_TIMER(&dfs->ath_dfstesttimer); dfs->ath_dfstest = 0; } #if 0 #ifndef ATH_DFS_RADAR_DETECTION_ONLY if (dfs->ic_dfswait) { OS_CANCEL_TIMER(&dfs->ic_dfswaittimer); dfs->ath_dfswait = 0; } OS_CANCEL_TIMER(&dfs->sc_dfs_war_timer); if (dfs->dfs_nol != NULL) { struct dfs_nolelem *nol, *next; nol = dfs->dfs_nol; /* Bug 29099 - each NOL element has its own timer, cancel it and free the element*/ while (nol != NULL) { OS_CANCEL_TIMER(&nol->nol_timer); next = nol->nol_next; OS_FREE(nol); nol = next; } dfs->dfs_nol = NULL; } #endif #endif /* Return radar events to free q*/ dfs_reset_radarq(dfs); dfs_reset_alldelaylines(dfs); /* Free up pulse log*/ if (dfs->pulses != NULL) { OS_FREE(dfs->pulses); dfs->pulses = NULL; } for (n=0; n<DFS_MAX_RADAR_TYPES;n++) { if (dfs->dfs_radarf[n] != NULL) { OS_FREE(dfs->dfs_radarf[n]); dfs->dfs_radarf[n] = NULL; } } if (dfs->dfs_radartable != NULL) { for (n=0; n<256; n++) { if (dfs->dfs_radartable[n] != NULL) { OS_FREE(dfs->dfs_radartable[n]); dfs->dfs_radartable[n] = NULL; } } OS_FREE(dfs->dfs_radartable); dfs->dfs_radartable = NULL; #ifndef ATH_DFS_RADAR_DETECTION_ONLY dfs->ath_dfs_isdfsregdomain = 0; #endif } if (dfs->dfs_b5radars != NULL) { OS_FREE(dfs->dfs_b5radars); dfs->dfs_b5radars=NULL; } dfs_reset_ar(dfs); ATH_ARQ_LOCK(dfs); empty = STAILQ_EMPTY(&(dfs->dfs_arq)); ATH_ARQ_UNLOCK(dfs); if (!empty) { dfs_reset_arq(dfs); } if (dfs->events != NULL) { OS_FREE(dfs->events); dfs->events = NULL; } dfs_nol_timer_cleanup(dfs); OS_FREE(dfs); /* XXX? */ ic->ic_dfs = NULL; }
/* * create a HSM and return a handle to it. */ ieee80211_hsm_t ieee80211_sm_create(osdev_t oshandle, const char *name, void *ctx, u_int8_t init_state, const ieee80211_state_info *state_info, u_int8_t num_states, u_int8_t max_queued_events, u_int16_t event_data_len, mesgq_priority_t priority, u_int32_t flags, void (*ieee80211_debug_print) (void *ctx,const char *fmt,...), const char **event_names, u_int32_t num_event_names) { ieee80211_hsm_t hsm; u_int32_t i; mesgq_event_delivery_type mq_type; #ifdef ATH_DISABLE_DBG_PRINT #define ieee80211_debug_print(ctx,fmt...) #endif if (num_states > IEEE80211_HSM_MAX_STATES) { return NULL; } /* * validate the state_info table. * the entries need to be valid and also * need to be in order. */ for (i = 0; i < num_states; ++i) { u_int8_t state_visited[IEEE80211_HSM_MAX_STATES] = {0}; u_int8_t state,next_state; /* * make sure that the state definitions are in order */ if ((state_info[i].state >= IEEE80211_HSM_MAX_STATES) || (state_info[i].state != i)) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : entry %d has invalid state %d \n", name, i,state_info[i].state); return NULL; } if ((state_info[i].has_substates) && (state_info[i].initial_substate == IEEE80211_HSM_STATE_NONE)) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : entry %d is marked as super state but has no initial sub state \n", name, i); return NULL; } if ((!state_info[i].has_substates) && (state_info[i].initial_substate != IEEE80211_HSM_STATE_NONE)) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : entry %d is not a super state but has initial sub state \n", name, i); return NULL; } if ((state_info[i].has_substates) && (state_info[state_info[i].initial_substate].parent_state != i)) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : entry %d initial sub state is not a sub state \n", name, i); return NULL; } /* detect if there is any loop in the hierarichy */ state = state_info[i].state; while(state != IEEE80211_HSM_STATE_NONE) { if (state_visited[state]) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : detected a loop with entry %d \n", name, i); return NULL; } state_visited[state] = 1; next_state = state_info[state].parent_state; if (next_state != IEEE80211_HSM_STATE_NONE) { if (!state_info[next_state].has_substates) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : state %d is marked as perent of %d but is not a super state \n", name,next_state,state); return NULL; } } state = next_state; } } hsm = (ieee80211_hsm_t) OS_MALLOC(oshandle, sizeof(ieee80211_hsm), 0); if (hsm == NULL) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : hsm allocation failed \n", name); return NULL; } /* Clear hsm structure */ OS_MEMZERO(hsm, sizeof(ieee80211_hsm)); if(flags & IEEE80211_HSM_SYNCHRONOUS) { mq_type = MESGQ_SYNCHRONOUS_EVENT_DELIVERY; } else { mq_type = MESGQ_ASYNCHRONOUS_EVENT_DELIVERY; } if (OS_MESGQ_INIT(oshandle, &hsm->mesg_q, event_data_len, max_queued_events, ieee80211_sm_dispatch_sync_internal, hsm, priority, mq_type) != 0) { if (ieee80211_debug_print) ieee80211_debug_print(ctx, "HSM: %s : OS_MESGQ_INIT failed \n", name); OS_FREE(hsm); return NULL; } #if ENABLE_HSM_HISTORY hsm_history_init(hsm); #endif /* ENABLE_HISTORY */ #ifndef ATH_DISABLE_DBG_PRINT #undef ieee80211_debug_print #endif hsm->cur_state = init_state; hsm->num_states = num_states; hsm->oshandle = oshandle; hsm->state_info = state_info; hsm->ctx = ctx; hsm->last_event = IEEE80211_HSM_EVENT_NONE; hsm->ieee80211_hsm_debug_print = ieee80211_debug_print; hsm->in_state_transition = false; hsm->event_names = event_names; hsm->num_event_names = num_event_names; /* strncpy - don't forget the string terminator */ i = 0; while ((name[i] != '\0') && (i < IEEE80211_HSM_MAX_NAME)) { hsm->name[i] = name[i]; ++i; } if (i < IEEE80211_HSM_MAX_NAME) { hsm->name[i] = '\0'; } return hsm; }