/space/home/slher/rel/Beken/v6_4_5/macsw/ip/lmac/src/ps/ps.h

Go to the documentation of this file.

#ifndef _PS_H_
#define _PS_H_

/*
 * INCLUDE FILES
 ****************************************************************************************
 */

// for software configuration
#include "rwnx_config.h"
// for linked list definitions
#include "co_list.h"
// for mac_addr and other structure definitions
#include "mac.h"
// for VIF definitions
#include "vif_mgmt.h"
#include "reg_mac_pl.h"
#include "co_math.h"
#if (NX_P2P)
#include "p2p.h"
#endif //(NX_P2P)
#if (RW_UMESH_EN)
#include "mesh_ps.h"
#endif //(RW_UMESH_EN)

#if NX_POWERSAVE

/*
 * DEFINES
 ****************************************************************************************
 */

// Definition of bits preventing from going to sleep (per VIF)
#define PS_VIF_WAITING_BCN         CO_BIT(0)
#define PS_VIF_WAITING_BCMC        CO_BIT(1)
#define PS_VIF_WAITING_UC          CO_BIT(2)
#define PS_VIF_WAITING_EOSP        CO_BIT(3)
#define PS_VIF_ASSOCIATING         CO_BIT(4)
#define PS_VIF_P2P_GO_PRESENT      CO_BIT(5)
#define PS_VIF_P2P_WAIT_TBTT       CO_BIT(6)
#define PS_VIF_MONITOR             CO_BIT(7)

// Definition of bits preventing from going to sleep (global)
#define PS_TX_CFM_UPLOADING        CO_BIT(0)
#define PS_SCAN_ONGOING            CO_BIT(1)
#define PS_IDLE_REQ_PENDING        CO_BIT(2)
#define PS_PSM_PAUSED              CO_BIT(3)
#define PS_CAC_STARTED             CO_BIT(4)

#define PS_ALL_UAPSD_ACS           0x0F

#define PS_SP_INTERRUPTED          0xff

/*
 * MACROS
 ****************************************************************************************
 */

#if (NX_DPSM)
#define PS_DPSM_STATE_GET(bit_pos) \
        (ps_env.dpsm_state & (1 << PS_DPSM_STATE_ ## bit_pos))
#define PS_DPSM_STATE_SET(bit_pos) \
        (ps_env.dpsm_state |= (1 << PS_DPSM_STATE_ ## bit_pos))
#define PS_DPSM_STATE_CLEAR(bit_pos) \
        (ps_env.dpsm_state &= ~(1 << PS_DPSM_STATE_ ## bit_pos))
#endif //(NX_DPSM)

#endif //(NX_POWERSAVE)

/*
 * ENUMERATIONS
 ****************************************************************************************
 */

enum
{
    PS_MODE_OFF,
    PS_MODE_ON,
    PS_MODE_ON_DYN,
};

#if (NX_POWERSAVE)

#if NX_UAPSD
enum
{
    PS_UAPSD_TMR_START,
    PS_UAPSD_TMR_STOP,
};
#endif

#if (NX_DPSM)
enum ps_dpsm_state_bit_pos
{
    PS_DPSM_STATE_ON                = 0,
    PS_DPSM_STATE_PAUSING,
    PS_DPSM_STATE_RESUMING,
    PS_DPSM_STATE_PAUSE,
    /*
     * Indicate if MM_SET_PS_MODE_REQ has been received from UMAC while pausing/resuming
     * Mode required by UMAC will be stored in ps_env.dpsm_new_mode
     */
    PS_DPSM_STATE_SET_MODE_REQ,
};
#endif //(NX_DPSM)

/*
 * TYPE DEFINITIONS
 ****************************************************************************************
 */

struct ps_env_tag
{
    bool ps_on;
    ke_task_id_t taskid;
    uint32_t prevent_sleep;
    uint8_t cfm_cnt;

    #if NX_UAPSD
    struct mm_timer_tag uapsd_timer;
    bool uapsd_tmr_on;
    bool uapsd_on;
    uint32_t uapsd_timeout;
    #endif

    #if (NX_DPSM)
    uint8_t dpsm_state;
    uint8_t next_mode;
    #endif //(NX_DPSM)
};

/*
 * GLOBAL VARIABLES
 ****************************************************************************************
 */
extern struct ps_env_tag ps_env;

/*
 * FUNCTION PROTOTYPES
 ****************************************************************************************
 */
#if NX_UAPSD

__INLINE bool ps_uapsd_enabled(void)
{
    return (ps_env.uapsd_timeout != 0);
}
#endif

__INLINE bool ps_sleep_check(void)
{
    struct vif_info_tag *vif;
    bool sleep_allowed = false;

    do
    {
        #if (RW_UMESH_EN)
        if (mesh_ps_sleep_check())
        {
            sleep_allowed = true;
            break;
        }
        #endif //(RW_UMESH_EN)

        // No sleep if PS is not enabled
        if (!ps_env.ps_on
            #if (NX_P2P_GO)
            && (!p2p_go_check_ps_mode())
            #endif //(NX_P2P_GO)
            )
        {
            break;
        }

        // No sleep if a global procedure is ongoing
        if (ps_env.prevent_sleep)
            break;

        // Go through the list of VIFs
        sleep_allowed = true;
        vif = (struct vif_info_tag *)co_list_pick(&vif_mgmt_env.used_list);
        while (vif != NULL)
        {
            if (vif->prevent_sleep)
            {
                sleep_allowed = false;
                break;
            }

            vif = (struct vif_info_tag *)co_list_next(&vif->list_hdr);
        }
    } while (0);

    // For profiling
    if (sleep_allowed)
    {
        PROF_PS_SLEEP_SET();
    }
    else
    {
        PROF_PS_SLEEP_CLR();
    }

    return (sleep_allowed);
}
void ps_init(void);


void ps_set_mode(uint8_t mode, ke_task_id_t taskid);

#if (RW_MESH_EN)
bool ps_check_tim(uint32_t a_tim, uint16_t aid);
#endif //(!RW_MESH_EN)

void ps_check_beacon(uint32_t tim, uint16_t len, struct vif_info_tag *vif);

void ps_check_frame(uint8_t *frame, uint32_t statinfo, struct vif_info_tag *vif);

#if (NX_UAPSD)

void ps_uapsd_set(struct vif_info_tag *vif, uint8_t hw_queue, bool uapsd);
#endif //(NX_UAPSD)

#if (NX_UAPSD || NX_DPSM)

bool ps_check_tx_frame(uint8_t staid, uint8_t tid);
#endif //(NX_UAPSD || NX_DPSM)

#if (NX_UAPSD && NX_UMAC_PRESENT)

void ps_check_tx_trigger_sent(struct hostdesc *hostdesc, uint32_t tx_status);
#endif //(NX_UAPSD && NX_UMAC_PRESENT)

#if (NX_DPSM)

void ps_traffic_status_update(uint8_t vif_index, uint8_t new_status);
#endif //(NX_DPSM)

#if (NX_P2P && NX_UAPSD)

void ps_p2p_absence_update(struct vif_info_tag *vif, bool absent);
#endif //(NX_P2P && NX_UAPSD)

#endif // NX_POWERSAVE


#endif // _PS_H_

---