static int ccmni_open(struct net_device *dev)
{
ccmni_instance_t *ccmni = (ccmni_instance_t *)netdev_priv(dev);
ccmni_ctl_block_t *ccmni_ctl = ccmni_ctl_blk[ccmni->md_id];
ccmni_instance_t *ccmni_tmp = NULL;
if (unlikely(ccmni_ctl == NULL)) {
CCMNI_ERR_MSG(ccmni->md_id, "%s_Open: MD%d ctlb is NULL\n", dev->name, ccmni->md_id);
return -1;
}
if (ccmni_ctl->ccci_ops->md_ability & MODEM_CAP_CCMNI_MQ)
netif_tx_start_all_queues(dev);
else
netif_start_queue(dev);
if (unlikely(ccmni_ctl->ccci_ops->md_ability & MODEM_CAP_NAPI)) {
napi_enable(&ccmni->napi);
napi_schedule(&ccmni->napi);
}
atomic_inc(&ccmni->usage);
ccmni_tmp = ccmni_ctl->ccmni_inst[ccmni->index];
if (ccmni != ccmni_tmp)
atomic_inc(&ccmni_tmp->usage);
CCMNI_INF_MSG(ccmni->md_id, "%s_Open: cnt=(%d,%d), md_ab=0x%X\n",
dev->name, atomic_read(&ccmni->usage),
atomic_read(&ccmni_tmp->usage), ccmni_ctl->ccci_ops->md_ability);
return 0;
}
static int hfi1_vnic_up(struct hfi1_vnic_vport_info *vinfo)
{
struct hfi1_devdata *dd = vinfo->dd;
struct net_device *netdev = vinfo->netdev;
int i, rc;
/* ensure virtual eth switch id is valid */
if (!vinfo->vesw_id)
return -EINVAL;
rc = idr_alloc(&dd->vnic.vesw_idr, vinfo, vinfo->vesw_id,
vinfo->vesw_id + 1, GFP_NOWAIT);
if (rc < 0)
return rc;
for (i = 0; i < vinfo->num_rx_q; i++) {
struct hfi1_vnic_rx_queue *rxq = &vinfo->rxq[i];
skb_queue_head_init(&rxq->skbq);
napi_enable(&rxq->napi);
}
netif_carrier_on(netdev);
netif_tx_start_all_queues(netdev);
set_bit(HFI1_VNIC_UP, &vinfo->flags);
return 0;
}
static int netvsc_open(struct net_device *net)
{
struct net_device_context *net_device_ctx = netdev_priv(net);
struct hv_device *device_obj = net_device_ctx->device_ctx;
struct netvsc_device *nvdev;
struct rndis_device *rdev;
int ret = 0;
netif_carrier_off(net);
/* Open up the device */
ret = rndis_filter_open(device_obj);
if (ret != 0) {
netdev_err(net, "unable to open device (ret %d).\n", ret);
return ret;
}
netif_tx_start_all_queues(net);
nvdev = hv_get_drvdata(device_obj);
rdev = nvdev->extension;
if (!rdev->link_state)
netif_carrier_on(net);
return ret;
}
static int xlgmac_start(struct xlgmac_pdata *pdata)
{
struct xlgmac_hw_ops *hw_ops = &pdata->hw_ops;
struct net_device *netdev = pdata->netdev;
int ret;
hw_ops->init(pdata);
xlgmac_napi_enable(pdata, 1);
ret = xlgmac_request_irqs(pdata);
if (ret)
goto err_napi;
hw_ops->enable_tx(pdata);
hw_ops->enable_rx(pdata);
netif_tx_start_all_queues(netdev);
return 0;
err_napi:
xlgmac_napi_disable(pdata, 1);
hw_ops->exit(pdata);
return ret;
}
static int xenvif_open(struct net_device *dev)
{
struct xenvif *vif = netdev_priv(dev);
if (test_bit(VIF_STATUS_CONNECTED, &vif->status))
xenvif_up(vif);
netif_tx_start_all_queues(dev);
return 0;
}
static int xenvif_open(struct net_device *dev)
{
struct xenvif *vif = netdev_priv(dev);
if (netif_carrier_ok(dev))
xenvif_up(vif);
netif_tx_start_all_queues(dev);
return 0;
}
static struct sk_buff* hdd_mon_tx_fetch_pkt(hdd_adapter_t* pAdapter)
{
skb_list_node_t *pktNode = NULL;
struct sk_buff *skb = NULL;
v_SIZE_t size = 0;
WLANTL_ACEnumType ac = 0;
VOS_STATUS status = VOS_STATUS_E_FAILURE;
hdd_list_node_t *anchor = NULL;
if( NULL == pAdapter )
{
VOS_ASSERT(0);
return NULL;
}
// do we have any packets pending in this AC?
hdd_list_size( &pAdapter->wmm_tx_queue[ac], &size );
if( size == 0 )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
"%s: NO Packet Pending", __FUNCTION__);
return NULL;
}
//Remove the packet from the queue
spin_lock_bh(&pAdapter->wmm_tx_queue[ac].lock);
status = hdd_list_remove_front( &pAdapter->wmm_tx_queue[ac], &anchor );
spin_unlock_bh(&pAdapter->wmm_tx_queue[ac].lock);
if(VOS_STATUS_SUCCESS == status)
{
//If success then we got a valid packet from some AC
pktNode = list_entry(anchor, skb_list_node_t, anchor);
skb = pktNode->skb;
}
else
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
"%s: Not able to remove Packet from the list",
__FUNCTION__);
return NULL;
}
// if we are in a backpressure situation see if we can turn the hose back on
if ( (pAdapter->isTxSuspended[ac]) &&
(size <= HDD_TX_QUEUE_LOW_WATER_MARK) )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,
"%s: TX queue[%d] re-enabled", __FUNCTION__, ac);
pAdapter->isTxSuspended[ac] = VOS_FALSE;
/* Enable Queues which we have disabled earlier */
netif_tx_start_all_queues( pAdapter->dev );
}
return skb;
}
static int ixgbevf_set_tso(struct net_device *netdev, u32 data)
{
if (data) {
netdev->features |= NETIF_F_TSO;
netdev->features |= NETIF_F_TSO6;
} else {
netif_tx_stop_all_queues(netdev);
netdev->features &= ~NETIF_F_TSO;
netdev->features &= ~NETIF_F_TSO6;
netif_tx_start_all_queues(netdev);
}
return 0;
}
/*----------------------------------------------------------------------------*/
static int bowOpen(IN struct net_device *prDev)
{
P_GLUE_INFO_T prGlueInfo = NULL;
P_ADAPTER_T prAdapter = NULL;
ASSERT(prDev);
prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev));
ASSERT(prGlueInfo);
prAdapter = prGlueInfo->prAdapter;
ASSERT(prAdapter);
/* 2. carrier on & start TX queue */
netif_carrier_on(prDev);
netif_tx_start_all_queues(prDev);
return 0; /* success */
}
/*----------------------------------------------------------------------------
@brief TX frame block timeout handler
Resume TX, and reset TX frame count
@param hdd_context_t pHddCtx
Global hdd context
@return NONE
----------------------------------------------------------------------------*/
void hddDevTmTxBlockTimeoutHandler(void *usrData)
{
hdd_context_t *pHddCtx = (hdd_context_t *)usrData;
hdd_adapter_t *staAdapater;
/* Sanity, This should not happen */
if(NULL == pHddCtx)
{
VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR,
"%s: NULL Context", __func__);
VOS_ASSERT(0);
return;
}
staAdapater = hdd_get_adapter(pHddCtx, WLAN_HDD_INFRA_STATION);
if(NULL == staAdapater)
{
VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR,
"%s: NULL Adapter", __func__);
VOS_ASSERT(0);
return;
}
if(mutex_lock_interruptible(&pHddCtx->tmInfo.tmOperationLock))
{
VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR,
"%s: Aquire lock fail", __func__);
return;
}
pHddCtx->tmInfo.txFrameCount = 0;
/* Resume TX flow */
netif_tx_start_all_queues(staAdapater->dev);
mutex_unlock(&pHddCtx->tmInfo.tmOperationLock);
return;
}
/* fjes_open - Called when a network interface is made active */
static int fjes_open(struct net_device *netdev)
{
struct fjes_adapter *adapter = netdev_priv(netdev);
struct fjes_hw *hw = &adapter->hw;
int result;
if (adapter->open_guard)
return -ENXIO;
result = fjes_setup_resources(adapter);
if (result)
goto err_setup_res;
hw->txrx_stop_req_bit = 0;
hw->epstop_req_bit = 0;
napi_enable(&adapter->napi);
fjes_hw_capture_interrupt_status(hw);
result = fjes_request_irq(adapter);
if (result)
goto err_req_irq;
fjes_hw_set_irqmask(hw, REG_ICTL_MASK_ALL, false);
netif_tx_start_all_queues(netdev);
netif_carrier_on(netdev);
return 0;
err_req_irq:
fjes_free_irq(adapter);
napi_disable(&adapter->napi);
err_setup_res:
fjes_free_resources(adapter);
return result;
}
static int epping_start_adapter(epping_adapter_t *pAdapter)
{
if (!pAdapter) {
EPPING_LOG(CDF_TRACE_LEVEL_FATAL,
"%s: pAdapter= NULL\n", __func__);
return -1;
}
if (!pAdapter->started) {
#if defined(MSM_PLATFORM) && defined(HIF_PCI) && defined(CONFIG_CNSS)
cnss_request_bus_bandwidth(CNSS_BUS_WIDTH_HIGH);
#endif
netif_carrier_on(pAdapter->dev);
EPPING_LOG(LOG1, FL("Enabling queues"));
netif_tx_start_all_queues(pAdapter->dev);
pAdapter->started = true;
} else {
EPPING_LOG(CDF_TRACE_LEVEL_WARN,
"%s: pAdapter %p already started\n", __func__,
pAdapter);
}
return 0;
}
int rtw_hw_resume23a(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct net_device *pnetdev = padapter->pnetdev;
if (padapter) { /* system resume */
DBG_8723A("==> rtw_hw_resume23a\n");
down(&pwrpriv->lock);
pwrpriv->bips_processing = true;
rtw_reset_drv_sw23a(padapter);
if (pm_netdev_open23a(pnetdev, false)) {
up(&pwrpriv->lock);
goto error_exit;
}
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
if (!rtw_netif_queue_stopped(pnetdev))
netif_tx_start_all_queues(pnetdev);
else
netif_tx_wake_all_queues(pnetdev);
pwrpriv->bkeepfwalive = false;
pwrpriv->rf_pwrstate = rf_on;
pwrpriv->bips_processing = false;
up(&pwrpriv->lock);
} else {
goto error_exit;
}
return 0;
error_exit:
DBG_8723A("%s, Open net dev failed\n", __func__);
return -1;
}
/*
* CFG802.11 network device handler for open.
*
* Starts the data queue.
*/
static int
mwifiex_open(struct net_device *dev)
{
netif_tx_start_all_queues(dev);
return 0;
}
static void r92su_bss_connect_work(struct work_struct *work)
{
struct r92su *r92su;
struct c2h_join_bss_event *join_bss = NULL;
struct cfg80211_bss *cfg_bss = NULL;
struct r92su_bss_priv *bss_priv;
u8 *resp_ie = NULL;
unsigned int resp_ie_len = 0;
u16 status = WLAN_STATUS_UNSPECIFIED_FAILURE;
r92su = container_of(work, struct r92su, connect_bss_work);
mutex_lock(&r92su->lock);
if (!r92su_is_open(r92su))
goto out;
cfg_bss = r92su->want_connect_bss;
join_bss = r92su->connect_result;
if (!cfg_bss || !join_bss)
goto out;
bss_priv = r92su_get_bss_priv(cfg_bss);
r92su->connect_result = NULL;
if (le32_to_cpu(join_bss->bss.ie_length) < 12)
goto report_cfg80211;
if (join_bss->join_result) {
struct r92su_bss_priv *bss_priv = r92su_get_bss_priv(cfg_bss);
struct r92su_sta *sta;
sta = r92su_sta_alloc(r92su, join_bss->bss.bssid,
BSS_MACID,
le32_to_cpu(join_bss->aid), GFP_KERNEL);
if (!sta)
goto report_cfg80211;
resp_ie = join_bss->bss.ies.ie;
resp_ie_len = le32_to_cpu(join_bss->bss.ie_length) - 12;
sta->enc_sta = le32_to_cpu(join_bss->bss.privacy) ?
true : false;
sta->qos_sta = r92su_parse_wmm_cap_ie(r92su, resp_ie,
resp_ie_len);
/* The 802.11-2012 spec says that a HT STA has to be QoS STA
* as well. So in theory we should do instead:
* sta->qos_sta |= sta->ht_sta;
* However, the QoS parameters are needed for legacy STAs as
* well. Therefore, there's no excuse for a HT STA to forget
* the WMM IE!
*/
if (sta->qos_sta)
sta->ht_sta = r92su_parse_ht_cap_ie(r92su, resp_ie,
resp_ie_len);
status = WLAN_STATUS_SUCCESS;
bss_priv->sta = sta;
rcu_assign_pointer(r92su->connect_bss, cfg_bss);
r92su->want_connect_bss = NULL;
r92su_set_state(r92su, R92SU_CONNECTED);
}
report_cfg80211:
switch (r92su->wdev.iftype) {
case NL80211_IFTYPE_STATION:
cfg80211_connect_result(r92su->wdev.netdev,
join_bss->bss.bssid, bss_priv->assoc_ie,
bss_priv->assoc_ie_len, resp_ie, resp_ie_len,
status, GFP_KERNEL);
if (status == WLAN_STATUS_SUCCESS)
r92su_set_power(r92su, true);
break;
case NL80211_IFTYPE_ADHOC:
if (status == WLAN_STATUS_SUCCESS) {
cfg80211_ibss_joined(r92su->wdev.netdev,
join_bss->bss.bssid,
cfg_bss->channel, GFP_KERNEL);
}
break;
default:
WARN(1, "unsupported network type %d\n", r92su->wdev.iftype);
break;
}
kfree(bss_priv->assoc_ie);
bss_priv->assoc_ie = NULL;
out:
mutex_unlock(&r92su->lock);
kfree(join_bss);
if (status == WLAN_STATUS_SUCCESS) {
netif_tx_start_all_queues(r92su->wdev.netdev);
netif_carrier_on(r92su->wdev.netdev);
} else {
r92su_bss_free(r92su, cfg_bss);
}
}
int _netdev_open(struct net_device *pnetdev)
{
uint status;
struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n"));
DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup);
if (pwrctrlpriv->ps_flag) {
padapter->net_closed = false;
goto netdev_open_normal_process;
}
if (!padapter->bup) {
padapter->bDriverStopped = false;
padapter->bSurpriseRemoved = false;
status = rtw_hal_init(padapter);
if (status == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n"));
goto netdev_open_error;
}
pr_info("MAC Address = %pM\n", pnetdev->dev_addr);
status = rtw_start_drv_threads(padapter);
if (status == _FAIL) {
pr_info("Initialize driver software resource Failed!\n");
goto netdev_open_error;
}
if (init_hw_mlme_ext(padapter) == _FAIL) {
pr_info("can't init mlme_ext_priv\n");
goto netdev_open_error;
}
if (padapter->intf_start)
padapter->intf_start(padapter);
rtw_proc_init_one(pnetdev);
rtw_led_control(padapter, LED_CTL_NO_LINK);
padapter->bup = true;
}
padapter->net_closed = false;
_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
padapter->pwrctrlpriv.bips_processing = false;
rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
if (!rtw_netif_queue_stopped(pnetdev))
netif_tx_start_all_queues(pnetdev);
else
netif_tx_wake_all_queues(pnetdev);
netdev_open_normal_process:
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n"));
DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup);
return 0;
netdev_open_error:
padapter->bup = false;
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n"));
DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup);
return -1;
}
static void hdd_wlan_tx_complete( hdd_adapter_t* pAdapter,
hdd_cfg80211_state_t* cfgState,
tANI_BOOLEAN actionSendSuccess )
{
struct ieee80211_radiotap_header *rthdr;
unsigned char *pos;
struct sk_buff *skb = cfgState->skb;
#ifdef WLAN_FEATURE_HOLD_RX_WAKELOCK
hdd_context_t *pHddCtx = (hdd_context_t*)(pAdapter->pHddCtx);
#endif
/* 2 Byte for TX flags and 1 Byte for Retry count */
u32 rtHdrLen = sizeof(*rthdr) + 3;
u8 *data;
/* We have to return skb with Data starting with MAC header. We have
* copied SKB data starting with MAC header to cfgState->buf. We will pull
* entire skb->len from skb and then we will push cfgState->buf to skb
* */
if( NULL == skb_pull(skb, skb->len) )
{
hddLog( LOGE, FL("Not Able to Pull %d byte from skb"), skb->len);
kfree_skb(cfgState->skb);
return;
}
data = skb_push( skb, cfgState->len );
if (data == NULL)
{
hddLog( LOGE, FL("Not Able to Push %d byte to skb"), cfgState->len);
kfree_skb( cfgState->skb );
return;
}
memcpy( data, cfgState->buf, cfgState->len );
/* send frame to monitor interfaces now */
if( skb_headroom(skb) < rtHdrLen )
{
hddLog( LOGE, FL("No headroom for rtap header"));
kfree_skb(cfgState->skb);
return;
}
rthdr = (struct ieee80211_radiotap_header*) skb_push( skb, rtHdrLen );
memset( rthdr, 0, rtHdrLen );
rthdr->it_len = cpu_to_le16( rtHdrLen );
rthdr->it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
(1 << IEEE80211_RADIOTAP_DATA_RETRIES)
);
pos = (unsigned char *)( rthdr+1 );
// Fill TX flags
*pos = actionSendSuccess;
pos += 2;
// Fill retry count
*pos = 0;
pos++;
skb_set_mac_header( skb, 0 );
skb->ip_summed = CHECKSUM_NONE;
skb->pkt_type = PACKET_OTHERHOST;
skb->protocol = htons(ETH_P_802_2);
memset( skb->cb, 0, sizeof( skb->cb ) );
#ifdef WLAN_FEATURE_HOLD_RX_WAKELOCK
wake_lock_timeout(&pHddCtx->rx_wake_lock, HDD_WAKE_LOCK_DURATION);
#endif
if (in_interrupt())
netif_rx( skb );
else
netif_rx_ni( skb );
/* Enable Queues which we have disabled earlier */
netif_tx_start_all_queues( pAdapter->dev );
}
int netdev_open23a(struct net_device *pnetdev)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv;
int ret = 0;
int status;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+871x_drv - dev_open\n"));
DBG_8723A("+871x_drv - drv_open, bup =%d\n", padapter->bup);
mutex_lock(&adapter_to_dvobj(padapter)->hw_init_mutex);
pwrctrlpriv = &padapter->pwrctrlpriv;
if (pwrctrlpriv->ps_flag) {
padapter->net_closed = false;
goto netdev_open23a_normal_process;
}
if (!padapter->bup) {
padapter->bDriverStopped = false;
padapter->bSurpriseRemoved = false;
padapter->bCardDisableWOHSM = false;
status = rtw_hal_init23a(padapter);
if (status == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("rtl871x_hal_init(): Can't init h/w!\n"));
goto netdev_open23a_error;
}
DBG_8723A("MAC Address = "MAC_FMT"\n",
MAC_ARG(pnetdev->dev_addr));
if (init_hw_mlme_ext23a(padapter) == _FAIL) {
DBG_8723A("can't init mlme_ext_priv\n");
goto netdev_open23a_error;
}
rtl8723au_inirp_init(padapter);
rtw_cfg80211_init_wiphy(padapter);
rtw_led_control(padapter, LED_CTL_NO_LINK);
padapter->bup = true;
}
padapter->net_closed = false;
mod_timer(&padapter->mlmepriv.dynamic_chk_timer,
jiffies + msecs_to_jiffies(2000));
padapter->pwrctrlpriv.bips_processing = false;
rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
/* netif_carrier_on(pnetdev);call this func when
rtw23a_joinbss_event_cb return success */
if (!rtw_netif_queue_stopped(pnetdev))
netif_tx_start_all_queues(pnetdev);
else
netif_tx_wake_all_queues(pnetdev);
netdev_open23a_normal_process:
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - dev_open\n"));
DBG_8723A("-871x_drv - drv_open, bup =%d\n", padapter->bup);
exit:
mutex_unlock(&adapter_to_dvobj(padapter)->hw_init_mutex);
return ret;
netdev_open23a_error:
padapter->bup = false;
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("-871x_drv - dev_open, fail!\n"));
DBG_8723A("-871x_drv - drv_open fail, bup =%d\n", padapter->bup);
ret = -1;
goto exit;
}
