rtl_ps.c

Go to the documentation of this file.

/******************************************************************************
 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
 *
 * Based on the r8180 driver, which is:
 * Copyright 2004-2005 Andrea Merello <[email protected]>, et al.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 * wlanfae <[email protected]>
 *****************************************************************************/
#include "rtl_ps.h"
#include "rtl_core.h"
#include "r8192E_phy.h"
#include "r8192E_phyreg.h"
#include "r8190P_rtl8256.h" /* RTL8225 Radio frontend */
#include "r8192E_cmdpkt.h"

static void rtl8192_hw_sleep_down(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    unsigned long flags = 0;
    spin_lock_irqsave(&priv->rf_ps_lock, flags);
    if (priv->RFChangeInProgress) {
        spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
        RT_TRACE(COMP_DBG, "rtl8192_hw_sleep_down(): RF Change in "
             "progress!\n");
        return;
    }
    spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
    RT_TRACE(COMP_DBG, "%s()============>come to sleep down\n", __func__);

    MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS, false);
}

void rtl8192_hw_sleep_wq(void *data)
{
    struct rtllib_device *ieee = container_of_dwork_rsl(data,
                     struct rtllib_device, hw_sleep_wq);
    struct net_device *dev = ieee->dev;
    rtl8192_hw_sleep_down(dev);
}

void rtl8192_hw_wakeup(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    unsigned long flags = 0;
    spin_lock_irqsave(&priv->rf_ps_lock, flags);
    if (priv->RFChangeInProgress) {
        spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
        RT_TRACE(COMP_DBG, "rtl8192_hw_wakeup(): RF Change in "
             "progress!\n");
        queue_delayed_work_rsl(priv->rtllib->wq,
                       &priv->rtllib->hw_wakeup_wq, MSECS(10));
        return;
    }
    spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
    RT_TRACE(COMP_PS, "%s()============>come to wake up\n", __func__);
    MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS, false);
}

void rtl8192_hw_wakeup_wq(void *data)
{
    struct rtllib_device *ieee = container_of_dwork_rsl(data,
                     struct rtllib_device, hw_wakeup_wq);
    struct net_device *dev = ieee->dev;
    rtl8192_hw_wakeup(dev);

}

#define MIN_SLEEP_TIME 50
#define MAX_SLEEP_TIME 10000
void rtl8192_hw_to_sleep(struct net_device *dev, u64 time)
{
    struct r8192_priv *priv = rtllib_priv(dev);

    u32 tmp;
    unsigned long flags;

    spin_lock_irqsave(&priv->ps_lock, flags);

    time -= MSECS(8+16+7);

    if ((time - jiffies) <= MSECS(MIN_SLEEP_TIME)) {
        spin_unlock_irqrestore(&priv->ps_lock, flags);
        printk(KERN_INFO "too short to sleep::%lld < %ld\n",
               time - jiffies, MSECS(MIN_SLEEP_TIME));
        return;
    }

    if ((time - jiffies) > MSECS(MAX_SLEEP_TIME)) {
        printk(KERN_INFO "========>too long to sleep:%lld > %ld\n",
               time - jiffies,  MSECS(MAX_SLEEP_TIME));
        spin_unlock_irqrestore(&priv->ps_lock, flags);
        return;
    }
    tmp = time - jiffies;
    queue_delayed_work_rsl(priv->rtllib->wq,
            &priv->rtllib->hw_wakeup_wq, tmp);
    queue_delayed_work_rsl(priv->rtllib->wq,
            (void *)&priv->rtllib->hw_sleep_wq, 0);
    spin_unlock_irqrestore(&priv->ps_lock, flags);
}

static void InactivePsWorkItemCallback(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
                    &(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");
    MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS,
                false);

    pPSC->bSwRfProcessing = false;
    RT_TRACE(COMP_PS, "InactivePsWorkItemCallback() <---------\n");
}

void IPSEnter(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
                    &(priv->rtllib->PowerSaveControl);
    enum rt_rf_power_state rtState;

    if (pPSC->bInactivePs) {
        rtState = priv->rtllib->eRFPowerState;
        if (rtState == eRfOn && !pPSC->bSwRfProcessing &&
            (priv->rtllib->state != RTLLIB_LINKED) &&
            (priv->rtllib->iw_mode != IW_MODE_MASTER)) {
            RT_TRACE(COMP_PS, "IPSEnter(): Turn off RF.\n");
            pPSC->eInactivePowerState = eRfOff;
            priv->isRFOff = true;
            priv->bInPowerSaveMode = true;
            InactivePsWorkItemCallback(dev);
        }
    }
}

void IPSLeave(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
                    &(priv->rtllib->PowerSaveControl);
    enum rt_rf_power_state rtState;

    if (pPSC->bInactivePs) {
        rtState = priv->rtllib->eRFPowerState;
        if (rtState != eRfOn  && !pPSC->bSwRfProcessing &&
            priv->rtllib->RfOffReason <= RF_CHANGE_BY_IPS) {
            RT_TRACE(COMP_PS, "IPSLeave(): Turn on RF.\n");
            pPSC->eInactivePowerState = eRfOn;
            priv->bInPowerSaveMode = false;
            InactivePsWorkItemCallback(dev);
        }
    }
}

void IPSLeave_wq(void *data)
{
    struct rtllib_device *ieee = container_of_work_rsl(data,
                     struct rtllib_device, ips_leave_wq);
    struct net_device *dev = ieee->dev;
    struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
    down(&priv->rtllib->ips_sem);
    IPSLeave(dev);
    up(&priv->rtllib->ips_sem);
}

void rtllib_ips_leave_wq(struct net_device *dev)
{
    struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
    enum rt_rf_power_state rtState;
    rtState = priv->rtllib->eRFPowerState;

    if (priv->rtllib->PowerSaveControl.bInactivePs) {
        if (rtState == eRfOff) {
            if (priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) {
                RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",
                     __func__);
                return;
            } else {
                printk(KERN_INFO "=========>%s(): IPSLeave\n",
                       __func__);
                queue_work_rsl(priv->rtllib->wq,
                           &priv->rtllib->ips_leave_wq);
            }
        }
    }
}

void rtllib_ips_leave(struct net_device *dev)
{
    struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
    down(&priv->rtllib->ips_sem);
    IPSLeave(dev);
    up(&priv->rtllib->ips_sem);
}

static bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev,
                        u8 rtPsMode)
{
    struct r8192_priv *priv = rtllib_priv(dev);

    if (priv->rtllib->iw_mode == IW_MODE_ADHOC)
        return false;

    RT_TRACE(COMP_LPS, "%s(): set ieee->ps = %x\n", __func__, rtPsMode);
    if (!priv->ps_force)
        priv->rtllib->ps = rtPsMode;
    if (priv->rtllib->sta_sleep != LPS_IS_WAKE &&
        rtPsMode == RTLLIB_PS_DISABLED) {
        unsigned long flags;

        rtl8192_hw_wakeup(dev);
        priv->rtllib->sta_sleep = LPS_IS_WAKE;

        spin_lock_irqsave(&(priv->rtllib->mgmt_tx_lock), flags);
        RT_TRACE(COMP_DBG, "LPS leave: notify AP we are awaked"
             " ++++++++++ SendNullFunctionData\n");
        rtllib_sta_ps_send_null_frame(priv->rtllib, 0);
        spin_unlock_irqrestore(&(priv->rtllib->mgmt_tx_lock), flags);
    }

    return true;
}

void LeisurePSEnter(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
                    &(priv->rtllib->PowerSaveControl);

    RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
    RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdle"
         "Count is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
         pPSC->bLeisurePs, priv->rtllib->ps, pPSC->LpsIdleCount,
         RT_CHECK_FOR_HANG_PERIOD);

    if (!((priv->rtllib->iw_mode == IW_MODE_INFRA) &&
        (priv->rtllib->state == RTLLIB_LINKED))
        || (priv->rtllib->iw_mode == IW_MODE_ADHOC) ||
        (priv->rtllib->iw_mode == IW_MODE_MASTER))
        return;

    if (pPSC->bLeisurePs) {
        if (pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) {

            if (priv->rtllib->ps == RTLLIB_PS_DISABLED) {

                RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter "
                     "802.11 power save mode...\n");

                if (!pPSC->bFwCtrlLPS) {
                    if (priv->rtllib->SetFwCmdHandler)
                        priv->rtllib->SetFwCmdHandler(
                            dev, FW_CMD_LPS_ENTER);
                }
                MgntActSet_802_11_PowerSaveMode(dev,
                             RTLLIB_PS_MBCAST |
                             RTLLIB_PS_UNICAST);
            }
        } else
            pPSC->LpsIdleCount++;
    }
}

void LeisurePSLeave(struct net_device *dev)
{
    struct r8192_priv *priv = rtllib_priv(dev);
    struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
                    &(priv->rtllib->PowerSaveControl);


    RT_TRACE(COMP_PS, "LeisurePSLeave()...\n");
    RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d\n",
        pPSC->bLeisurePs, priv->rtllib->ps);

    if (pPSC->bLeisurePs) {
        if (priv->rtllib->ps != RTLLIB_PS_DISABLED) {
            RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , "
                 "Leave 802.11 power save..\n");
            MgntActSet_802_11_PowerSaveMode(dev,
                     RTLLIB_PS_DISABLED);

            if (!pPSC->bFwCtrlLPS) {
                if (priv->rtllib->SetFwCmdHandler)
                    priv->rtllib->SetFwCmdHandler(dev,
                             FW_CMD_LPS_LEAVE);
            }
        }
    }
}