power_xwrL68xx.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 Texas Instruments Incorporated
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the
 * distribution.
 *
 * Neither the name of Texas Instruments Incorporated nor the names of
 * its contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef POWER_XWRL68XX_H
#define POWER_XWRL68XX_H
 
#include <stdint.h>
#include <drivers/utils/List.h>
#include <drivers/hw_include/hw_types.h>
#include <drivers/pinmux.h>
#include <drivers/power.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 *  Power events on the 64XX device
 *
 *  Each event must be a power of two, and the event IDs must be sequential
 *  without any gaps.
 */
#define POWER_ENTERING_LPDS       0x1
 
#define POWER_ENTERING_IDLE       0x4
 
#define POWER_AWAKE_LPDS          0x8
 
#define POWER_AWAKE_IDLE          0x20
 
/* \cond */
/* Number of pins that can be parked in LPDS */
#define POWER_NUMPINS             32U
/* \endcond */
 
typedef struct {
    uint32_t pin;
    uint32_t parkState;
} Power_ParkInfo;
 
typedef enum {
    POWER_GPIO_WAKEUP_LPDS,
    POWER_SYNCIN_IO_WAKEUP_LPDS
}Power_GPIO_SYNCIO_Wakeup_Enable;
 
typedef struct {
    Power_PolicyInitFxn policyInitFxn;
    Power_PolicyFxn policyFxn;
    void (*enterLPDSHookFxn)(void);
    void (*resumeLPDSHookFxn)(void);
 
    void (*enteridle3HookFxn)(void);
    void (*resumeidle3HookFxn)(void);
 
    bool enablePolicy;
 
    bool enableGPIOSyncIOWakeupLPDS;
 
    bool enableSleepCounterWakeupLPDS;
 
    bool enableUARTWakeupLPDS;
 
    bool enableRTCWakeupLPDS;
 
    bool enableFRCWakeupLPDS;
 
    Power_GPIO_SYNCIO_Wakeup_Enable selectGpioSyncIOLpds;
    uint32_t wakeupGPIOEdgeLPDS;
    uint32_t wakeupSyncIOEdgeLPDS;
 
    uint32_t wakeupUartEdgeLPDS;
 
    uint32_t ramRetentionMaskLPDS;
 
    Power_ParkInfo * pinParkDefs;
    uint32_t numPins;
    uint32_t LPDSThreshold;
    uint32_t totalLatencyForLPDS;
 
    uint32_t resumeLatencyForLPDS;
 
    uint32_t idleThreshold;
    uint32_t totalLatencyForIdle;
 
    uint32_t resumeLatencyForIdle;
 
} Power_ConfigV1;
 
 
typedef enum {
    POWER_PARK_LPDS,
    POWER_DONT_PARK,
    POWER_PARK_IDLE,
    POWER_PARK_IDLE_AND_LPDS
} Power_ParkState;
 
typedef enum {
    POWER_PIN_PAD_AA = PIN_PAD_AA,
    POWER_PIN_PAD_AB = PIN_PAD_AB,
    POWER_PIN_PAD_AC = PIN_PAD_AC,
    POWER_PIN_PAD_AD = PIN_PAD_AD,
    POWER_PIN_PAD_AE = PIN_PAD_AE,
    POWER_PIN_PAD_AF = PIN_PAD_AF,
    POWER_PIN_PAD_AG = PIN_PAD_AG,
    POWER_PIN_PAD_AH = PIN_PAD_AH,
    POWER_PIN_PAD_AI = PIN_PAD_AI,
    POWER_PIN_PAD_AJ = PIN_PAD_AJ,
    POWER_PIN_PAD_AK = PIN_PAD_AK,
    POWER_PIN_PAD_AL = PIN_PAD_AL,
    POWER_PIN_PAD_AM = PIN_PAD_AM,
    POWER_PIN_PAD_AN = PIN_PAD_AN,
    POWER_PIN_PAD_AO = PIN_PAD_AO,
    POWER_PIN_PAD_AP = PIN_PAD_AP,
    POWER_PIN_PAD_AQ = PIN_PAD_AQ,
    POWER_PIN_PAD_AR = PIN_PAD_AR,
    POWER_PIN_PAD_AS = PIN_PAD_AS,
    POWER_PIN_PAD_AT = PIN_PAD_AT,
    POWER_PIN_PAD_AU = PIN_PAD_AU,
    POWER_PIN_PAD_AV = PIN_PAD_AV,
    POWER_PIN_PAD_AW = PIN_PAD_AW,
    POWER_PIN_PAD_AX = PIN_PAD_AX,
    POWER_PIN_PAD_AY = PIN_PAD_AY,
    POWER_PIN_PAD_AZ = PIN_PAD_AZ,
    POWER_PIN_PAD_BA = PIN_PAD_BA,
    POWER_PIN_PAD_BB = PIN_PAD_BB,
    POWER_PIN_PAD_BC = PIN_PAD_BC,
    POWER_PIN_PAD_BD = PIN_PAD_BD,
    POWER_PIN_PAD_BE = PIN_PAD_BE,
    POWER_PIN_PAD_BF = PIN_PAD_BF,
 
} Power_Pin;
typedef struct {
 
    bool enableGPIOSyncIOWakeupLPDS;
    Power_GPIO_SYNCIO_Wakeup_Enable selectGpioSyncIOLpds;
    bool enableSleepCounterWakeupLPDS;
    bool enableUARTWakeupLPDS;
    bool enableRTCWakeupLPDS;
    bool enableFRCWakeupLPDS;
    uint32_t wakeupGPIOEdgeLPDS;
    uint32_t wakeupSyncIOEdgeLPDS;
    uint32_t wakeupUartEdgeLPDS;
} Power_Wakeup;
 
typedef struct {
    List_List notifyList;
    uint32_t state;
    bool enablePolicy;
    bool initialized;
    Power_PolicyFxn policyFxn;
    Power_Wakeup wakeupConfig;
} Power_ModuleState;
void Power_configureWakeup(Power_Wakeup *wakeup);
 
void Power_initPolicy(void);
 
void Power_getWakeup(Power_Wakeup *wakeup);
 
void Power_sleepPolicy(unsigned long long sleepTimeus);
 
 void Power_Idle3();
 
void Power_parkPins(uint32_t powerState);
 
/* \cond */
#define Power_getPerformanceLevel(void)   0
#define Power_setPerformanceLevel(level)  Power_EFAIL
/* \endcond */
 
#ifdef __cplusplus
}
#endif
 
#endif /* POWER_XWRL68XX_H */