/*========================================================================== FUNCTION WDA_DS_GetTxFlowMask DESCRIPTION return TX flow mask control value DEPENDENCIES PARAMETERS IN pvosGCtx VOS context OUT uFlowMask TX channel mask for flow control Defined in WDA_TXFlowEnumType RETURN VALUE VOS_STATUS_E_INVAL: pointer is NULL and other errors VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WDA_DS_GetTxFlowMask ( v_PVOID_t pvosGCtx, v_U8_t* puFlowMask ) { tWDA_CbContext* wdaContext = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( ( NULL == pvosGCtx ) || ( NULL == puFlowMask ) ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid parameter sent on WDA_DS_GetTxFlowMask" ); return VOS_STATUS_E_INVAL; } wdaContext = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pvosGCtx ); if ( NULL == wdaContext ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid context on WDA_DS_GetTxFlowMask" ); return VOS_STATUS_E_INVAL; } *puFlowMask = wdaContext->uTxFlowMask; return VOS_STATUS_SUCCESS; }
void epping_driver_exit(v_CONTEXT_t pVosContext) { epping_context_t *pEpping_ctx; pr_info("%s: unloading driver\n", __func__); pEpping_ctx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if(!pEpping_ctx) { EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: module exit called before probe",__func__); } else { vos_set_unload_in_progress(TRUE); vos_set_load_unload_in_progress(VOS_MODULE_ID_VOSS, TRUE); } hif_unregister_driver(); vos_mem_free(pEpping_ctx); vos_preClose( &pVosContext ); #ifdef MEMORY_DEBUG adf_net_buf_debug_exit(); vos_mem_exit(); #endif #ifdef TIMER_MANAGER vos_timer_exit(); #endif pr_info("%s: driver unloaded\n", __func__); }
// Caller of this function MUST dynamically allocate memory for pBuf // because this funciton will free the memory. eHalStatus palSendMBMessage(tHddHandle hHdd, void *pBuf) { eHalStatus halStatus = eHAL_STATUS_FAILURE; tSirRetStatus sirStatus; v_CONTEXT_t vosContext; v_VOID_t *hHal; vosContext = vos_get_global_context( VOS_MODULE_ID_HDD, hHdd ); if (NULL == vosContext) { VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_ERROR, "%s: invalid vosContext", __func__); } else { hHal = vos_get_context( VOS_MODULE_ID_SME, vosContext ); if (NULL == hHal) { VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_ERROR, "%s: invalid hHal", __func__); } else { sirStatus = uMacPostCtrlMsg( hHal, pBuf ); if ( eSIR_SUCCESS == sirStatus ) { halStatus = eHAL_STATUS_SUCCESS; } } } vos_mem_free( pBuf ); return( halStatus ); }
VOS_STATUS vos_wlanRestart(void) { VOS_STATUS vstatus; hdd_context_t *pHddCtx = NULL; v_CONTEXT_t pVosContext = NULL; if(vos_is_load_unload_in_progress( VOS_MODULE_ID_VOSS, NULL)) { VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Driver load/unload is in progress, retry later.", __func__); return VOS_STATUS_E_AGAIN; } pVosContext = vos_get_global_context(VOS_MODULE_ID_VOSS, NULL); if(!pVosContext) { VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL, "%s: Global VOS context is Null", __func__); return VOS_STATUS_E_FAILURE; } pHddCtx = (hdd_context_t *)vos_get_context(VOS_MODULE_ID_HDD, pVosContext ); if(!pHddCtx) { VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL, "%s: HDD context is Null", __func__); return VOS_STATUS_E_FAILURE; } vstatus = wlan_hdd_restart_driver(pHddCtx); return vstatus; }
static VOS_STATUS sys_SendHalInitStartReqMsg( v_CONTEXT_t pVosContext ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; tSirMbMsg msg; tSirRetStatus sirStatus = eSIR_SUCCESS; tSirMbMsg *pMsg = &msg; v_VOID_t *hHal; do { // get the HAL context... hHal = vos_get_context( VOS_MODULE_ID_HAL, pVosContext ); if ( NULL == hHal ) break; // format the Init start request message. This message has // the hal handle in the 'data' portion of the message. pMsg->type = WDA_INIT_START_REQ; pMsg->data[0] = (tANI_U32)hHal; // message length is 4 greater than the config data size // need to add in an extra 4 for the message header. pMsg->msgLen = sizeof( tHalHandle ) + FIELD_OFFSET( tSirMbMsg, data ); // Send the HAL Init Start Request message... sirStatus = uMacPostCtrlMsg( hHal, pMsg ); if ( eSIR_SUCCESS != sirStatus ) { vosStatus = VOS_STATUS_E_FAILURE; } } while( 0 ); return( vosStatus ); }
void *epping_get_adf_ctx(void) { VosContextType *pVosContext = NULL; adf_os_device_t *pAdfCtx; pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL); pAdfCtx = vos_get_context(VOS_MODULE_ID_ADF, pVosContext); return pAdfCtx; }
void wmi_set_d0wow_flag(wmi_unified_t wmi_handle, A_BOOL flag) { tp_wma_handle wma = wmi_handle->scn_handle; struct ol_softc *scn = vos_get_context(VOS_MODULE_ID_HIF, wma->vos_context); adf_os_atomic_set(&scn->hif_sc->in_d0wow, flag); }
A_BOOL wmi_get_d0wow_flag(wmi_unified_t wmi_handle) { tp_wma_handle wma = wmi_handle->scn_handle; struct ol_softc *scn = vos_get_context(VOS_MODULE_ID_HIF, wma->vos_context); return adf_os_atomic_read(&scn->hif_sc->in_d0wow); }
/*========================================================================== FUNCTION WLANBAP_ReadMacConfig DESCRIPTION This function sets the MAC config (Address and SSID to BT-AMP context DEPENDENCIES PARAMETERS pvosGCtx: pointer to the global vos context; a handle to BAP's control block can be extracted from its context RETURN VALUE None SIDE EFFECTS ============================================================================*/ void WLANBAP_ReadMacConfig ( ptBtampContext pBtampCtx ) { tANI_U32 len = WNI_CFG_BSSID_LEN; tHalHandle pMac = NULL; /*------------------------------------------------------------------------ Temporary method to get the self MAC address ------------------------------------------------------------------------*/ if (NULL == pBtampCtx) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "pBtampCtx is NULL in %s", __func__); return; } pMac = (tHalHandle)vos_get_context( VOS_MODULE_ID_SME, pBtampCtx->pvosGCtx); if (NULL == pMac) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "pMac is NULL in %s", __func__); return; } ccmCfgGetStr( pMac, WNI_CFG_STA_ID, pBtStaOwnMacAddr, &len ); VOS_ASSERT( WNI_CFG_BSSID_LEN == len ); /* Form the SSID from Mac address */ VOS_SNPRINTF( pBtStaOwnSsid, WLAN_BAP_SSID_MAX_LEN, "AMP-%02x-%02x-%02x-%02x-%02x-%02x", pBtStaOwnMacAddr[0], pBtStaOwnMacAddr[1], pBtStaOwnMacAddr[2], pBtStaOwnMacAddr[3], pBtStaOwnMacAddr[4], pBtStaOwnMacAddr[5]); /*------------------------------------------------------------------------ Set the MAC address for this instance ------------------------------------------------------------------------*/ vos_mem_copy( pBtampCtx->self_mac_addr, pBtStaOwnMacAddr, sizeof(pBtampCtx->self_mac_addr)); /*------------------------------------------------------------------------ Set our SSID value ------------------------------------------------------------------------*/ pBtampCtx->ownSsidLen = 21; vos_mem_copy( pBtampCtx->ownSsid, pBtStaOwnSsid, pBtampCtx->ownSsidLen); }
void WLANBAP_NeedBTCoexPriority ( ptBtampContext pBtampCtx, v_U32_t needCoexPriority ) { tHalHandle pMac = NULL; tSmeBtAmpEvent btAmpEvent; /*------------------------------------------------------------------------ Retrieve the pMac (HAL context) ------------------------------------------------------------------------*/ pMac = (tHalHandle)vos_get_context( VOS_MODULE_ID_SME, pBtampCtx->pvosGCtx); // Is re-entrancy protection needed for this? if (needCoexPriority != gBapCoexPriority) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO_HIGH, "Calling %s with needCoexPriority=%d.", __func__, needCoexPriority); gBapCoexPriority = needCoexPriority; switch ( needCoexPriority) { case 0: /* Idle */ btAmpEvent.btAmpEventType = BTAMP_EVENT_CONNECTION_TERMINATED; pBtampCtx->btamp_session_on = FALSE; sme_sendBTAmpEvent(pMac, btAmpEvent); break; case 1: /* Associating */ btAmpEvent.btAmpEventType = BTAMP_EVENT_CONNECTION_START; pBtampCtx->btamp_session_on = TRUE; sme_sendBTAmpEvent(pMac, btAmpEvent); break; case 2: /* Post-assoc */ btAmpEvent.btAmpEventType = BTAMP_EVENT_CONNECTION_STOP; sme_sendBTAmpEvent(pMac, btAmpEvent); break; default: VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "%s: Invalid Coexistence priority request: %d", __func__, needCoexPriority); } } }
static int hif_usb_suspend(struct usb_interface *interface, pm_message_t state) { HIF_DEVICE_USB *device = usb_get_intfdata(interface); struct hif_usb_softc *sc = device->sc; void *vos = vos_get_global_context(VOS_MODULE_ID_HIF, NULL); v_VOID_t * temp_module; if (vos == NULL) return 0; /* No need to send WMI_PDEV_SUSPEND_CMDID to FW if WOW is enabled */ temp_module = vos_get_context(VOS_MODULE_ID_WDA, vos); if (!temp_module) { printk("%s: WDA module is NULL\n", __func__); return (-1); } if (wma_check_scan_in_progress(temp_module)) { printk("%s: Scan in progress. Aborting suspend\n", __func__); return (-1); } sc->local_state = state; /* No need to send WMI_PDEV_SUSPEND_CMDID to FW if WOW is enabled */ if (wma_is_wow_mode_selected(temp_module)) { if (wma_enable_wow_in_fw(temp_module, 0)) { pr_warn("%s[%d]: fail\n", __func__, __LINE__); return -1; } } else if ((PM_EVENT_FREEZE & state.event) == PM_EVENT_FREEZE || (PM_EVENT_SUSPEND & state.event) == PM_EVENT_SUSPEND || (PM_EVENT_HIBERNATE & state.event) == PM_EVENT_HIBERNATE) { if (wma_suspend_target (vos_get_context(VOS_MODULE_ID_WDA, vos), 0)) { pr_warn("%s[%d]: fail\n", __func__, __LINE__); return -1; } } usb_hif_flush_all(device); return 0; }
/* --------------------------------------------------------- * FUNCTION: wdaGetGlobalSystemRole() * * Get the global HAL system role. * --------------------------------------------------------- */ tBssSystemRole wdaGetGlobalSystemRole(tpAniSirGlobal pMac) { v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL); tWDA_CbContext *wdaContext = vos_get_context(VOS_MODULE_ID_WDA, pVosContext); if(NULL == wdaContext) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "%s:WDA context is NULL", __func__); VOS_ASSERT(0); return eSYSTEM_UNKNOWN_ROLE; } return wdaContext->wdaGlobalSystemRole; }
void vos_clear_concurrent_session_count(void) { v_U8_t i = 0; hdd_context_t *pHddCtx; v_CONTEXT_t pVosContext = vos_get_global_context(VOS_MODULE_ID_HDD, NULL); if (NULL != pVosContext) { pHddCtx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { for (i = 0; i < VOS_MAX_NO_OF_MODE; i++) pHddCtx->no_of_active_sessions[i] = 0; } } }
/**============================================================================ @brief hdd_tx_complete_cbk() - Callback function invoked by TL to indicate that a packet has been transmitted across the SDIO bus succesfully. OS packet resources can be released after this cbk. @param vosContext : [in] pointer to VOS context @param pVosPacket : [in] pointer to VOS packet (containing skb) @param vosStatusIn : [in] status of the transmission @return : VOS_STATUS_E_FAILURE if any errors encountered : VOS_STATUS_SUCCESS otherwise ===========================================================================*/ VOS_STATUS hdd_tx_complete_cbk( v_VOID_t *vosContext, vos_pkt_t *pVosPacket, VOS_STATUS vosStatusIn ) { VOS_STATUS status = VOS_STATUS_SUCCESS; hdd_adapter_t *pAdapter = NULL; hdd_context_t *pHddCtx = NULL; void* pOsPkt = NULL; if( ( NULL == vosContext ) || ( NULL == pVosPacket ) ) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Null params being passed", __FUNCTION__); return VOS_STATUS_E_FAILURE; } //Return the skb to the OS status = vos_pkt_get_os_packet( pVosPacket, &pOsPkt, VOS_TRUE ); if(!VOS_IS_STATUS_SUCCESS( status )) { //This is bad but still try to free the VOSS resources if we can VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure extracting skb from vos pkt", __FUNCTION__); vos_pkt_return_packet( pVosPacket ); return VOS_STATUS_E_FAILURE; } //Get the HDD context. pHddCtx = (hdd_context_t *)vos_get_context( VOS_MODULE_ID_HDD, vosContext ); //Get the Adapter context. pAdapter = hdd_get_adapter(pHddCtx,WLAN_HDD_INFRA_STATION); if(pAdapter == NULL) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,"%s: HDD adapter context is Null", __FUNCTION__); } else { ++pAdapter->hdd_stats.hddTxRxStats.txCompleted; } kfree_skb((struct sk_buff *)pOsPkt); //Return the VOS packet resources. status = vos_pkt_return_packet( pVosPacket ); if(!VOS_IS_STATUS_SUCCESS( status )) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Could not return VOS packet to the pool", __FUNCTION__); } return status; }
/**--------------------------------------------------------------------------- * * \brief vos_is_multiple_active_sta_sessions() * * This function checks for presence of multiple active sta connections * and it returns TRUE if the more than 1 active sta connection exists. * * \param - None * * \return - TRUE or FALSE * * --------------------------------------------------------------------------*/ v_BOOL_t vos_is_multiple_active_sta_sessions (void) { hdd_context_t *pHddCtx; v_U8_t j = 0; v_CONTEXT_t pVosContext = vos_get_global_context(VOS_MODULE_ID_HDD, NULL); if (NULL != pVosContext) { pHddCtx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { j = pHddCtx->no_of_active_sessions[VOS_STA_MODE]; } } return (j > 1); }
/**--------------------------------------------------------------------------- * * \brief vos_is_sta_active_connection_exists() * * This function checks for the presence of active sta connection * and it returns TRUE if exists. * * \param - None * * \return - VOS_TRUE or VOS_FALSE * * --------------------------------------------------------------------------*/ v_BOOL_t vos_is_sta_active_connection_exists (void) { hdd_context_t *pHddCtx; v_U8_t j = 0; v_CONTEXT_t pVosContext = vos_get_global_context(VOS_MODULE_ID_HDD, NULL); if (NULL != pVosContext) { pHddCtx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { j = pHddCtx->no_of_active_sessions[VOS_STA_MODE]; } } return (j ? VOS_TRUE : VOS_FALSE); }
static void epping_target_suspend_acknowledge(void *context) { void *vos_context = vos_get_global_context(VOS_MODULE_ID_WDA, NULL); epping_context_t *pEpping_ctx = vos_get_context(VOS_MODULE_ID_HDD, vos_context); int wow_nack = *((int *)context); if (NULL == pEpping_ctx) { EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: epping_ctx is NULL", __func__); return; } /* EPPING_TODO: do we need wow_nack? */ pEpping_ctx->wow_nack = wow_nack; }
void regdmn_set_regval(struct regulatory *reg) { void *vos_context = vos_get_global_context(VOS_MODULE_ID_WDA, NULL); tp_wma_handle wma = vos_get_context(VOS_MODULE_ID_WDA, vos_context); u_int32_t modeSelect = 0xFFFFFFFF; if (!wma) { WMA_LOGE("%s: Unable to get WMA handle", __func__); return; } wma_get_modeselect(wma, &modeSelect); regdmn_get_ctl_info(reg, wma->reg_cap.wireless_modes, modeSelect); return; }
/* --------------------------------------------------------- * FUNCTION: wdaGetGlobalSystemRole() * * Get the global HAL system role. * --------------------------------------------------------- */ tBssSystemRole wdaGetGlobalSystemRole(tpAniSirGlobal pMac) { v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL); tWDA_CbContext *wdaContext = vos_get_context(VOS_MODULE_ID_WDA, pVosContext); if(NULL == wdaContext) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "%s:WDA context is NULL", __FUNCTION__); VOS_ASSERT(0); return eSYSTEM_UNKNOWN_ROLE; } WDALOG1( wdaLog(pMac, LOG1, FL(" returning %d role\n"), wdaContext->wdaGlobalSystemRole)); return wdaContext->wdaGlobalSystemRole; }
/** * hdd_state_info_dump() - prints state information of hdd layer */ static void hdd_state_info_dump(void) { v_CONTEXT_t vos_ctx_ptr; hdd_context_t *hdd_ctx_ptr = NULL; hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL; VOS_STATUS status; hdd_station_ctx_t *hdd_sta_ctx = NULL; hdd_adapter_t *adapter =NULL; /* get the global voss context */ vos_ctx_ptr = vos_get_global_context(VOS_MODULE_ID_VOSS, NULL); if (NULL != vos_ctx_ptr) { hdd_ctx_ptr = vos_get_context(VOS_MODULE_ID_HDD, vos_ctx_ptr); } else { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Invalid Global VOSS Context", __func__); VOS_ASSERT(0); return; } hddLog(LOG1, FL("mScanPending %d isWlanSuspended %d disable_dfs_flag %d"), hdd_ctx_ptr->scan_info.mScanPending, hdd_ctx_ptr->isWlanSuspended, hdd_ctx_ptr->disable_dfs_flag); status = hdd_get_front_adapter(hdd_ctx_ptr, &adapter_node); while (NULL != adapter_node && VOS_STATUS_SUCCESS == status) { adapter = adapter_node->pAdapter; if (adapter->dev) hddLog(LOG1, FL("device name: %s"), adapter->dev->name); switch (adapter->device_mode) { case WLAN_HDD_INFRA_STATION: case WLAN_HDD_P2P_CLIENT: hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter); hddLog(LOG1, FL("connState: %d device_mode: %d"), hdd_sta_ctx->conn_info.connState, adapter->device_mode); break; default: break; } status = hdd_get_next_adapter(hdd_ctx_ptr, adapter_node, &next); adapter_node = next; } }
v_BOOL_t vos_concurrent_sap_sessions_running(v_VOID_t) { v_U8_t i=0; hdd_context_t *pHddCtx; v_CONTEXT_t pVosContext = vos_get_global_context( VOS_MODULE_ID_HDD, NULL ); if (NULL != pVosContext) { pHddCtx = vos_get_context( VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { i = pHddCtx->no_of_open_sessions[VOS_STA_SAP_MODE]; } } return (i>1); }
/* --------------------------------------------------------- * FUNCTION: WMAGetGlobalSystemRole() * * Get the global HAL system role. * --------------------------------------------------------- */ tBssSystemRole WMAGetGlobalSystemRole(tpAniSirGlobal pMac) { v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WMA, NULL); t_wma_handle *wmaContext = vos_get_context(VOS_MODULE_ID_WMA, pVosContext); if(NULL == wmaContext) { VOS_TRACE( VOS_MODULE_ID_WMA, VOS_TRACE_LEVEL_ERROR, "%s:WMA context is NULL", __func__); VOS_ASSERT(0); return eSYSTEM_UNKNOWN_ROLE; } #ifdef FEATURE_WLAN_INTEGRATED_SOC WMA_LOGD(" returning %d role\n",wmaContext->wmaGlobalSystemRole); #endif /* #ifdef FEATURE_WLAN_INTEGRATED_SOC */ return wmaContext->wmaGlobalSystemRole; }
/**--------------------------------------------------------------------------- * * \brief vos_max_concurrent_connections_reached() * * This function checks for presence of concurrency where more than * one connection exists and it returns TRUE if the max concurrency is * reached. * * Example: * STA + STA (wlan0 and wlan1 are connected) - returns TRUE * STA + STA (wlan0 connected and wlan1 disconnected) - returns FALSE * DUT with P2P-GO + P2P-CLIENT connection) - returns TRUE * * \param - None * * \return - VOS_TRUE or VOS_FALSE * * --------------------------------------------------------------------------*/ v_BOOL_t vos_max_concurrent_connections_reached (void) { v_U8_t i = 0, j = 0; hdd_context_t *pHddCtx; v_CONTEXT_t pVosContext = vos_get_global_context(VOS_MODULE_ID_HDD, NULL); if (NULL != pVosContext) { pHddCtx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { for (i = 0; i < VOS_MAX_NO_OF_MODE; i++) j += pHddCtx->no_of_active_sessions[i]; return (j > (pHddCtx->cfg_ini->gMaxConcurrentActiveSessions - 1)); } } return VOS_FALSE; }
/*========================================================================== FUNCTION WDA_DS_GetRssi DESCRIPTION Get RSSI TODO It returns hardcoded value in the meantime since WDA/WDI does nothing support it yet for Prima. DEPENDENCIES PARAMETERS IN vosDataBuff vos data buffer OUT puRssi RSSI RETURN VALUE VOS_STATUS_E_FAULT: pointer is NULL and other errors VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WDA_DS_GetRssi ( v_PVOID_t pvosGCtx, v_S7_t* puRssi ) { #if defined( FEATURE_WLAN_INTEGRATED_SOC ) VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WDA:halPS_GetRssi no longer supported. Need replacement"); *puRssi = -30; return VOS_STATUS_SUCCESS; #else /* FEATURE_WLAN_INTEGRATED_SOC */ halPS_GetRssi(vos_get_context(VOS_MODULE_ID_SME, pvosGCtx), puRssi); return VOS_STATUS_SUCCESS; #endif /* FEATURE_WLAN_INTEGRATED_SOC */ }
v_VOID_t WDA_DS_TxCompleteCB ( v_PVOID_t pvosGCtx, v_PVOID_t pFrameDataBuff ) { tWDA_CbContext* wdaContext = NULL; WDI_DS_TxMetaInfoType* pTxMetadata; VOS_STATUS vosStatus; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( ( NULL == pvosGCtx ) || ( NULL == pFrameDataBuff ) ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid parameter sent on WDA_DS_TxCompleteCB" ); return; } wdaContext = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pvosGCtx ); if ( NULL == wdaContext ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid context on WDA_DS_TxCompleteCB" ); return; } // extract metadata from PAL packet pTxMetadata = WDI_DS_ExtractTxMetaData( (wpt_packet*)pFrameDataBuff ); if ( eWLAN_PAL_STATUS_SUCCESS == pTxMetadata->txCompleteStatus ) vosStatus = VOS_STATUS_SUCCESS; else vosStatus = VOS_STATUS_E_FAILURE; wdaContext->pfnTxCompleteCallback( pvosGCtx, pFrameDataBuff, vosStatus ); }
v_BOOL_t vos_concurrent_open_sessions_running(void) { v_U8_t i=0; v_U8_t j=0; hdd_context_t *pHddCtx; v_CONTEXT_t pVosContext = vos_get_global_context( VOS_MODULE_ID_HDD, NULL ); if (NULL != pVosContext) { pHddCtx = vos_get_context( VOS_MODULE_ID_HDD, pVosContext); if (NULL != pHddCtx) { for (i=0; i < VOS_MAX_NO_OF_MODE; i++) { j += pHddCtx->no_of_open_sessions[i]; } } } return (j>1); }
void vos_abort_mac_scan(void) { hdd_context_t *pHddCtx = NULL; v_CONTEXT_t pVosContext = NULL; pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL); if(!pVosContext) { hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Global VOS context is Null", __func__); return; } pHddCtx = (hdd_context_t *)vos_get_context(VOS_MODULE_ID_HDD, pVosContext ); if(!pHddCtx) { hddLog(VOS_TRACE_LEVEL_FATAL, "%s: HDD context is Null", __func__); return; } hdd_abort_mac_scan(pHddCtx, eCSR_SCAN_ABORT_DEFAULT); return; }
void epping_exit(v_CONTEXT_t pVosContext) { epping_context_t *pEpping_ctx; VosContextType *gpVosContext; pEpping_ctx = vos_get_context(VOS_MODULE_ID_HDD, pVosContext); if (pEpping_ctx == NULL) { EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: error: pEpping_ctx = NULL", __func__); return; } gpVosContext = pEpping_ctx->pVosContext; if (pVosContext == NULL) { EPPING_LOG(VOS_TRACE_LEVEL_FATAL, "%s: error: pVosContext = NULL", __func__); return; } if (pEpping_ctx->epping_adapter) { epping_destroy_adapter(pEpping_ctx->epping_adapter); pEpping_ctx->epping_adapter = NULL; } hif_disable_isr(gpVosContext->pHIFContext); hif_reset_soc(gpVosContext->pHIFContext); HTCStop(gpVosContext->htc_ctx); HTCDestroy(gpVosContext->htc_ctx); gpVosContext->htc_ctx = NULL; #ifdef HIF_PCI { int i; for (i = 0; i < EPPING_MAX_NUM_EPIDS; i++) { epping_unregister_tx_copier(i, pEpping_ctx); } } #endif /* HIF_PCI */ epping_cookie_cleanup(pEpping_ctx); }
/*========================================================================== FUNCTION WDA_DS_GetTxFlowMask DESCRIPTION return TX flow mask control value DEPENDENCIES PARAMETERS IN pvosGCtx VOS context OUT uFlowMask TX channel mask for flow control Defined in WDA_TXFlowEnumType RETURN VALUE VOS_STATUS_E_INVAL: pointer is NULL and other errors VOS_STATUS_SUCCESS: Everything is good :) SIDE EFFECTS ============================================================================*/ VOS_STATUS WDA_DS_GetTxFlowMask ( v_PVOID_t pvosGCtx, v_U8_t* puFlowMask ) { #if defined( FEATURE_WLAN_INTEGRATED_SOC ) tWDA_CbContext* wdaContext = NULL; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check ------------------------------------------------------------------------*/ if ( ( NULL == pvosGCtx ) || ( NULL == puFlowMask ) ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid parameter sent on WDA_DS_GetTxFlowMask" ); return VOS_STATUS_E_INVAL; } wdaContext = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pvosGCtx ); if ( NULL == wdaContext ) { VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "WDA: Invalid context on WDA_DS_GetTxFlowMask" ); return VOS_STATUS_E_INVAL; } *puFlowMask = wdaContext->uTxFlowMask; return VOS_STATUS_SUCCESS; #else *puFlowMask = WDA_TXFLOWMASK; return VOS_STATUS_SUCCESS; #endif /* FEATURE_WLAN_INTEGRATED_SOC */ }
static int hif_usb_resume(struct usb_interface *interface) { HIF_DEVICE_USB *device = usb_get_intfdata(interface); struct hif_usb_softc *sc = device->sc; void *vos = vos_get_global_context(VOS_MODULE_ID_HIF, NULL); v_VOID_t * temp_module; if (vos == NULL) return 0; /* No need to send WMI_PDEV_SUSPEND_CMDID to FW if WOW is enabled */ temp_module = vos_get_context(VOS_MODULE_ID_WDA, vos); if (!temp_module) { printk("%s: WDA module is NULL\n", __func__); return (-1); } if (wma_check_scan_in_progress(temp_module)) { printk("%s: Scan in progress. Aborting suspend\n", __func__); return (-1); } sc->local_state.event = 0; usb_hif_start_recv_pipes(device); #ifdef USB_HIF_TEST_INTERRUPT_IN usb_hif_post_recv_transfers(&device->pipes[HIF_RX_INT_PIPE], HIF_USB_RX_BUFFER_SIZE); #endif /* No need to send WMI_PDEV_RESUME_CMDID to FW if WOW is enabled */ if (!wma_is_wow_mode_selected(temp_module)) { wma_resume_target(temp_module, 0); } else if (wma_disable_wow_in_fw(temp_module, 0)) { pr_warn("%s[%d]: fail\n", __func__, __LINE__); return (-1); } return 0; }