void rtl8192_hw_sleep_down(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); unsigned long flags = 0; #ifdef CONFIG_ASPM_OR_D3 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl)); #endif spin_lock_irqsave(&priv->rf_ps_lock,flags); if (priv->RFChangeInProgress) { spin_unlock_irqrestore(&priv->rf_ps_lock,flags); RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n"); printk("rtl8192_hw_sleep_down(): RF Change in progress!\n"); return; } spin_unlock_irqrestore(&priv->rf_ps_lock,flags); RT_TRACE(COMP_PS, "%s()============>come to sleep down\n", __FUNCTION__); #ifdef CONFIG_RTLWIFI_DEBUGFS if(priv->debug->hw_holding) { return; } #endif MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS,false); #ifdef CONFIG_ASPM_OR_D3 if(pPSC->RegRfPsLevel & RT_RF_LPS_LEVEL_ASPM) { RT_ENABLE_ASPM(dev); RT_SET_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM); } #endif }
void rtl8192_hw_wakeup(struct net_device* dev) { struct r8192_priv *priv = rtllib_priv(dev); unsigned long flags = 0; u8 queue_index = 0; unsigned long queue_len = 0; struct sk_buff* skb = NULL; #ifdef CONFIG_ASPM_OR_D3 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl)); #endif spin_lock_irqsave(&priv->rf_ps_lock,flags); if (priv->RFChangeInProgress) { spin_unlock_irqrestore(&priv->rf_ps_lock,flags); RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n"); printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n"); queue_delayed_work_rsl(priv->rtllib->wq,&priv->rtllib->hw_wakeup_wq,MSECS(10)); return; } spin_unlock_irqrestore(&priv->rf_ps_lock,flags); #ifdef CONFIG_ASPM_OR_D3 if (pPSC->RegRfPsLevel & RT_RF_LPS_LEVEL_ASPM) { RT_DISABLE_ASPM(dev); RT_CLEAR_PS_LEVEL(pPSC, RT_RF_LPS_LEVEL_ASPM); } #endif RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __FUNCTION__); MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS,false); for (queue_index=0; queue_index<=VO_QUEUE; queue_index++){ queue_len = skb_queue_len(&priv->rtllib->skb_waitQ[queue_index]); if (queue_len) { printk("=====>%s(): no need to ps,wake up!! %d queue is not empty\n", __FUNCTION__,queue_index); skb = skb_dequeue(&priv->rtllib->skb_waitQ[queue_index]); if (skb == NULL) { RT_TRACE(COMP_ERR,"rtl8192_hw_wakeup():skb is NULL\n"); return; } if ((priv->rtllib->b4ac_Uapsd & 0x0f) !=0) { if ( IsMgntQosData(skb->data) || IsMgntQosNull(skb->data) ) { if(!priv->rtllib->bin_service_period && get_qos_queueID_maskAPSD(queue_index, priv->rtllib->b4ac_Uapsd)) { RT_TRACE(COMP_PS, "rtl8192_hw_wakeup(): >>>>>>>>>> Enter APSD service period >>>>>>>>>>\n"); printk("rtl8192_hw_wakeup(): >>>>>>>>>> Enter APSD service period >>>>>>>>>>\n"); priv->rtllib->bin_service_period = true; } } } priv->rtllib->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/); } } }
int rtl8192E_suspend(struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); u32 ulRegRead; netdev_info(dev, "============> r8192E suspend call.\n"); del_timer_sync(&priv->gpio_polling_timer); cancel_delayed_work(&priv->gpio_change_rf_wq); priv->polling_timer_on = 0; if (!netif_running(dev)) { netdev_info(dev, "RTL819XE:UI is open out of suspend function\n"); goto out_pci_suspend; } if (dev->netdev_ops->ndo_stop) dev->netdev_ops->ndo_stop(dev); netif_device_detach(dev); if (!priv->rtllib->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT, true); ulRegRead = read_nic_dword(dev, CPU_GEN); ulRegRead |= CPU_GEN_SYSTEM_RESET; write_nic_dword(dev, CPU_GEN, ulRegRead); } else { write_nic_dword(dev, WFCRC0, 0xffffffff); write_nic_dword(dev, WFCRC1, 0xffffffff); write_nic_dword(dev, WFCRC2, 0xffffffff); write_nic_byte(dev, PMR, 0x5); write_nic_byte(dev, MacBlkCtrl, 0xa); } out_pci_suspend: netdev_info(dev, "WOL is %s\n", priv->rtllib->bSupportRemoteWakeUp ? "Supported" : "Not supported"); pci_save_state(pdev); pci_disable_device(pdev); pci_enable_wake(pdev, pci_choose_state(pdev, state), priv->rtllib->bSupportRemoteWakeUp ? 1 : 0); pci_set_power_state(pdev, pci_choose_state(pdev, state)); mdelay(20); return 0; }
int rtl8192E_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); int err; u32 val; netdev_info(dev, "================>r8192E resume call.\n"); pci_set_power_state(pdev, PCI_D0); err = pci_enable_device(pdev); if (err) { netdev_err(dev, "pci_enable_device failed on resume\n"); return err; } pci_restore_state(pdev); pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); pci_enable_wake(pdev, PCI_D0, 0); if (priv->polling_timer_on == 0) check_rfctrl_gpio_timer((unsigned long)dev); if (!netif_running(dev)) { netdev_info(dev, "RTL819XE:UI is open out of resume function\n"); goto out; } netif_device_attach(dev); if (dev->netdev_ops->ndo_open) dev->netdev_ops->ndo_open(dev); if (!priv->rtllib->bSupportRemoteWakeUp) MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT, true); out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); return 0; }
void InactivePsWorkItemCallback(struct net_device *dev) { struct r8192_priv *priv = rtllib_priv(dev); PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->rtllib->PowerSaveControl)); RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() ---------> \n"); pPSC->bSwRfProcessing = true; RT_TRACE(COMP_PS, "InactivePsWorkItemCallback(): Set RF to %s.\n", \ pPSC->eInactivePowerState == eRfOff?"OFF":"ON"); #ifdef CONFIG_ASPM_OR_D3 if(pPSC->eInactivePowerState == eRfOn) { if((pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_ASPM) && RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM)) { RT_DISABLE_ASPM(dev); RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM); } #ifdef TODO else if((pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_PCI_D3) && RT_IN_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_PCI_D3)) { RT_LEAVE_D3(dev, false); RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_PCI_D3); } #endif } #endif MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS,false); #ifdef CONFIG_ASPM_OR_D3 if(pPSC->eInactivePowerState == eRfOff) { if(pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_ASPM) { RT_ENABLE_ASPM(dev); RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_ASPM); } #ifdef TODO else if(pPSC->RegRfPsLevel & RT_RF_OFF_LEVL_PCI_D3) { RT_ENTER_D3(dev, false); RT_SET_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_PCI_D3); } #endif } #endif #if 0 if(pPSC->eInactivePowerState == eRfOn) { while( index < 4 ) { if( ( pMgntInfo->SecurityInfo.PairwiseEncAlgorithm == WEP104_Encryption ) || (pMgntInfo->SecurityInfo.PairwiseEncAlgorithm == WEP40_Encryption) ) { if( pMgntInfo->SecurityInfo.KeyLen[index] != 0) pAdapter->HalFunc.SetKeyHandler(pAdapter, index, 0, false, pMgntInfo->SecurityInfo.PairwiseEncAlgorithm, true, false); } index++; } } #endif pPSC->bSwRfProcessing = false; RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() <--------- \n"); }
void rtl8225z4_rf_wakeup(struct net_device *dev) { MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS); }
void rtl8225z4_rf_sleep(struct net_device *dev) { MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS); }
int rtl8192E_suspend (struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = ieee80211_priv(dev); u8 ucRegRead; u32 ulRegRead; RT_TRACE(COMP_POWER, "============> r8192E suspend call.\n"); if (!netif_running(dev)) goto out_pci_suspend; if (dev->netdev_ops->ndo_stop) dev->netdev_ops->ndo_stop(dev); #if 0 netif_carrier_off(dev); ieee80211_softmac_stop_protocol(priv->ieee80211); write_nic_byte(dev,MSR,(read_nic_byte(dev,MSR)&0xfc)|MSR_LINK_NONE); if(!priv->ieee80211->bSupportRemoteWakeUp) { write_nic_byte(dev, CMDR, 0); } write_nic_dword(dev,INTA_MASK,0); priv->irq_enabled = 0; write_nic_dword(dev,ISR,read_nic_dword(dev, ISR)); cancel_work_sync(&priv->reset_wq); del_timer_sync(&priv->fsync_timer); del_timer_sync(&priv->watch_dog_timer); cancel_delayed_work(&priv->watch_dog_wq); cancel_delayed_work(&priv->update_beacon_wq); cancel_work_sync(&priv->qos_activate); #endif if(!priv->ieee80211->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT); ulRegRead = read_nic_dword(dev, CPU_GEN); ulRegRead|=CPU_GEN_SYSTEM_RESET; write_nic_dword(dev, CPU_GEN, ulRegRead); } else { write_nic_dword(dev, WFCRC0, 0xffffffff); write_nic_dword(dev, WFCRC1, 0xffffffff); write_nic_dword(dev, WFCRC2, 0xffffffff); #ifdef RTL8190P ucRegRead = read_nic_byte(dev, GPO); ucRegRead |= BIT0; write_nic_byte(dev, GPO, ucRegRead); #endif write_nic_byte(dev, PMR, 0x5); write_nic_byte(dev, MacBlkCtrl, 0xa); } out_pci_suspend: RT_TRACE(COMP_POWER, "r8192E support WOL call??????????????????????\n"); if(priv->ieee80211->bSupportRemoteWakeUp) { RT_TRACE(COMP_POWER, "r8192E support WOL call!!!!!!!!!!!!!!!!!!.\n"); } netif_device_detach(dev); pci_save_state(pdev); pci_disable_device(pdev); pci_enable_wake(pdev, pci_choose_state(pdev,state),\ priv->ieee80211->bSupportRemoteWakeUp?1:0); pci_set_power_state(pdev,pci_choose_state(pdev,state)); return 0; }
int rtl8192E_suspend (struct pci_dev *pdev, pm_message_t state) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); #ifdef _RTL8192_EXT_PATCH_ struct net_device *meshdev = priv->rtllib->meshdev; #endif #if !(defined RTL8192SE || defined RTL8192CE) u32 ulRegRead; #endif RT_TRACE(COMP_POWER, "============> r8192E suspend call.\n"); printk("============> r8192E suspend call.\n"); #ifdef ENABLE_GPIO_RADIO_CTL del_timer_sync(&priv->gpio_polling_timer); cancel_delayed_work(&priv->gpio_change_rf_wq); priv->polling_timer_on = 0; #endif #ifdef _RTL8192_EXT_PATCH_ if ((!netif_running(dev)) && (!netif_running(meshdev))) #else if (!netif_running(dev)) #endif { printk("RTL819XE:UI is open out of suspend function\n"); goto out_pci_suspend; } #ifdef HAVE_NET_DEVICE_OPS if (!(priv->up)) { priv->rtllib->wlan_up_before_suspend = 0; } else { priv->rtllib->wlan_up_before_suspend = 1; printk("====>%s(2), stop wlan, wlan_up_before_suspend = %d\n", __func__, priv->rtllib->wlan_up_before_suspend); if (dev->netdev_ops->ndo_stop) dev->netdev_ops->ndo_stop(dev); } #ifdef _RTL8192_EXT_PATCH_ if (!(priv->mesh_up)) { printk("====>%s(1), stop wlan, wlan_up_before_suspend = %d\n", __func__, priv->rtllib->wlan_up_before_suspend); priv->rtllib->mesh_up_before_suspend = 0; } else { priv->rtllib->mesh_up_before_suspend = 1; if (meshdev->netdev_ops->ndo_stop) meshdev->netdev_ops->ndo_stop(meshdev); } #endif #else if (!(priv->up)) priv->rtllib->wlan_up_before_suspend = 0; else { priv->rtllib->wlan_up_before_suspend = 1; dev->stop(dev); } #ifdef _RTL8192_EXT_PATCH_ if (!(priv->mesh_up)) priv->rtllib->mesh_up_before_suspend = 0; else { priv->rtllib->mesh_up_before_suspend = 1; meshdev->stop(meshdev); } #endif #endif netif_device_detach(dev); #if !(defined RTL8192SE || defined RTL8192CE) if(!priv->rtllib->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT,true); ulRegRead = read_nic_dword(dev, CPU_GEN); ulRegRead|=CPU_GEN_SYSTEM_RESET; write_nic_dword(dev, CPU_GEN, ulRegRead); } else { write_nic_dword(dev, WFCRC0, 0xffffffff); write_nic_dword(dev, WFCRC1, 0xffffffff); write_nic_dword(dev, WFCRC2, 0xffffffff); #ifdef RTL8190P { u8 ucRegRead; ucRegRead = read_nic_byte(dev, GPO); ucRegRead |= BIT0; write_nic_byte(dev, GPO, ucRegRead); } #endif write_nic_byte(dev, PMR, 0x5); write_nic_byte(dev, MacBlkCtrl, 0xa); } #endif out_pci_suspend: RT_TRACE(COMP_POWER, "r8192E support WOL call??????????????????????\n"); printk("r8192E support WOL call??????????????????????\n"); if(priv->rtllib->bSupportRemoteWakeUp) { RT_TRACE(COMP_POWER, "r8192E support WOL call!!!!!!!!!!!!!!!!!!.\n"); } #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)) pci_save_state(pdev,&(priv->pci_state)); pci_disable_device(pdev); pci_enable_wake(pdev, state,\ priv->rtllib->bSupportRemoteWakeUp?1:0); pci_set_power_state(pdev,state); #else pci_save_state(pdev); pci_disable_device(pdev); pci_enable_wake(pdev, pci_choose_state(pdev,state),\ priv->rtllib->bSupportRemoteWakeUp?1:0); pci_set_power_state(pdev,pci_choose_state(pdev,state)); #endif mdelay(20); return 0; }
int rtl8192E_resume (struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); #ifdef _RTL8192_EXT_PATCH_ struct net_device *meshdev = priv->rtllib->meshdev; #endif int err; u32 val; RT_TRACE(COMP_POWER, "================>r8192E resume call."); printk("================>r8192E resume call.\n"); pci_set_power_state(pdev, PCI_D0); err = pci_enable_device(pdev); if(err) { printk(KERN_ERR "%s: pci_enable_device failed on resume\n", dev->name); return err; } #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)) pci_restore_state(pdev,&(priv->pci_state)); #else pci_restore_state(pdev); #endif pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) { pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); } pci_enable_wake(pdev, PCI_D0, 0); #ifdef ENABLE_GPIO_RADIO_CTL if(priv->polling_timer_on == 0){ check_rfctrl_gpio_timer((unsigned long)dev); } #endif #ifdef _RTL8192_EXT_PATCH_ if ((!netif_running(dev)) && (!netif_running(meshdev))) #else if(!netif_running(dev)) #endif { printk("RTL819XE:UI is open out of resume function\n"); goto out; } netif_device_attach(dev); #ifdef HAVE_NET_DEVICE_OPS if (priv->rtllib->wlan_up_before_suspend) { if (dev->netdev_ops->ndo_open) dev->netdev_ops->ndo_open(dev); } #ifdef _RTL8192_EXT_PATCH_ if (priv->rtllib->mesh_up_before_suspend) { if (meshdev->netdev_ops->ndo_open) meshdev->netdev_ops->ndo_open(meshdev); netif_carrier_on(meshdev); } #endif #else if (priv->rtllib->wlan_up_before_suspend) { dev->open(dev); } #ifdef _RTL8192_EXT_PATCH_ if (priv->rtllib->mesh_up_before_suspend) { meshdev->open(meshdev); netif_carrier_on(meshdev); } #endif #endif #if !(defined RTL8192SE || defined RTL8192CE) if(!priv->rtllib->bSupportRemoteWakeUp) { MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT,true); } #endif out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); return 0; }