path: root/src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/import/chips/p9/procedures/hwp/pm/p9_pstate_parameter_block.H $ */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2015,2018                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* Licensed under the Apache License, Version 2.0 (the "License");        */
/* you may not use this file except in compliance with the License.       */
/* You may obtain a copy of the License at                                */
/*                                                                        */
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
/*                                                                        */
/* Unless required by applicable law or agreed to in writing, software    */
/* distributed under the License is distributed on an "AS IS" BASIS,      */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
/* implied. See the License for the specific language governing           */
/* permissions and limitations under the License.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/// @file  p9_pstate_parameter_block.H
/// @brief Definitons of paramater information used to process pstates
///
// *HWP HW Owner        : Greg Still <stillgs@us.ibm.com>
// *HWP FW Owner        : Prasad Bg Ranganath <prasadbgr@in.ibm.com>
// *HWP Team            : PM
// *HWP Level           : 3
// *HWP Consumed by     : PGPE, OCC

#ifndef __P9_PSTATE_PARAMETER_BLOCK_H__
#define __P9_PSTATE_PARAMETER_BLOCK_H__

#include <p9_pm_utils.H>
#include <p9_pstates_common.h>
#include <p9_pstates_pgpe.h>
#include <p9_pstates_cmeqm.h>
#include <p9_pstates_occ.h>
#include "p9_pm_get_poundv_bucket.H"

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_ACTIVE_CORES 24

#define HOMER_WOF_TABLE_SIZE 258176

/// An internal operating point
///
/// Internal operating points include characterization (both the original,
/// unbiased values and biased by external attributes) and load-line corrected
/// voltages for the external VRM.  For the internal VRM, effective e-voltages
/// and maxreg voltages are stored.  All voltages are stored as
/// uV. Characterization currents are in mA. Frequencies are in KHz. The
/// Pstate of the operating point (as a potentially out-of-bounds value) is
/// also stored.

typedef struct
{

    uint32_t vdd_uv;
    uint32_t vcs_uv;
    uint32_t vdd_corrected_uv;
    uint32_t vcs_corrected_uv;
    uint32_t vdd_corrected_wof_uv[MAX_ACTIVE_CORES];
    uint32_t vcs_corrected_wof_uv[MAX_ACTIVE_CORES];
    uint32_t vdd_ivrm_effective_uv;
    uint32_t vcs_ivrm_effective_uv;
    uint32_t vdd_maxreg_uv;
    uint32_t vcs_maxreg_uv;
    uint32_t idd_ma;
    uint32_t ics_ma;
    uint32_t frequency_khz;
    int32_t  pstate;

} OperatingPoint;


typedef struct
{
    bool iv_pstates_enabled;
    bool iv_resclk_enabled;
    bool iv_vdm_enabled;
    bool iv_ivrm_enabled;
    bool iv_wof_enabled;
} PSTATE_attribute_state;

// Safe mode frequency and voltage params

typedef struct
{
    uint32_t safe_op_freq_mhz;
    uint8_t  safe_op_ps;
    uint32_t safe_vdm_jump_value;
    uint32_t safe_mode_freq_mhz;
    uint8_t  safe_mode_ps;
    uint32_t safe_mode_mv;
    uint32_t boot_mode_mv;
} Safe_mode_parameters;


/// Constants required to compute and interpolate operating points
///
/// The nominal frequency and frequency step-size is given in Hz. Load-line
/// and on-chip distribution resistances are given in micro-Ohms.
///

typedef struct
{
    uint32_t reference_frequency_khz;
    uint32_t frequency_step_khz;   // This is the reference frequency / DPPL_DIVIDER
    // Load line parameters, This is also called Rloadline
    uint32_t vdd_r_loadline_uohm;
    uint32_t vcs_r_loadline_uohm;
    uint32_t vdn_r_loadline_uohm;
    // Distribution loss parameters, This is also called Rpath
    uint32_t vdd_r_distloss_uohm;
    uint32_t vcs_r_distloss_uohm;
    uint32_t vdn_r_distloss_uohm;
    uint32_t vdd_voffset_uv;
    uint32_t vcs_voffset_uv;
    uint32_t vdn_voffset_uv;
} SystemParameters;


/// A chip characterization

typedef struct
{

    VpdOperatingPoint* vpd;
    VpdOperatingPoint* vpd_unbiased;
    OperatingPoint* ops;
    SystemParameters* parameters;
    uint32_t points;
    uint32_t max_cores;                     // Needed for WOF

} ChipCharacterization;


//Section added back by ssrivath
// START OF PARMS REQUIRED VPD parsing procedures
#define PSTATE_STEPSIZE    1
#define EVRM_DELAY_NS      100
#define DEAD_ZONE_5MV      20       // 100mV
#define PDV_BUFFER_SIZE    51
#define PDV_BUFFER_ALLOC   512

#define POUND_W_VERSION_2_BUCKET_SIZE 60
#define PDM_BUFFER_SIZE    257      // Value is for version 3 @ 256 + 1 for version number
#define PDM_BUFFER_ALLOC   513      // Value is for version 2 @ 512 + 1 for version number
#define BIAS_PCT_UNIT      0.5
#define BOOST_PCT_UNIT     0.001
#define POUNDM_POINTS      13
#define POUNDM_MEASUREMENTS_PER_POINT   4

// #V 2 dimensional array values (5x5) - 5 operating point and 5 values per operating point
#define PV_D 5
#define PV_W 5

// IQ Keyword Sizes
#define IQ_BUFFER_SIZE      9
#define IQ_BUFFER_ALLOC     255
// END OF PARMS REQUIRED VPD parsing procedures


// Structure contatining all attributes required by Pstate Parameter block
typedef struct
{

    uint32_t attr_freq_core_ceiling_mhz;

// Loadline, Distribution loss and Distribution offset attVpdOpributes
    uint32_t attr_proc_r_loadline_vdd_uohm;
    uint32_t attr_proc_r_distloss_vdd_uohm;
    uint32_t attr_proc_vrm_voffset_vdd_uv;
    uint32_t attr_proc_r_loadline_vdn_uohm;
    uint32_t attr_proc_r_distloss_vdn_uohm;
    uint32_t attr_proc_vrm_voffset_vdn_uv;
    uint32_t attr_proc_r_loadline_vcs_uohm;
    uint32_t attr_proc_r_distloss_vcs_uohm;
    uint32_t attr_proc_vrm_voffset_vcs_uv;

    uint32_t attr_freq_proc_refclock_khz;
    uint32_t attr_proc_dpll_divider;
    uint32_t attr_nest_frequency_mhz;

// Frequency Bias attributes
    int8_t attr_freq_bias_ultraturbo;
    int8_t attr_freq_bias_turbo;
    int8_t attr_freq_bias_nominal;
    int8_t attr_freq_bias_powersave;

// External Voltage Timing attributes
    uint32_t attr_ext_vrm_transition_start_ns;
    uint32_t attr_ext_vrm_transition_rate_inc_uv_per_us;
    uint32_t attr_ext_vrm_transition_rate_dec_uv_per_us;
    uint32_t attr_ext_vrm_stabilization_time_us;
    uint32_t attr_ext_vrm_step_size_mv;

// Voltage Bias attributes
    int8_t attr_voltage_ext_vdd_bias_ultraturbo;
    int8_t attr_voltage_ext_vdd_bias_turbo;
    int8_t attr_voltage_ext_vdd_bias_nominal;
    int8_t attr_voltage_ext_vdd_bias_powersave;
    int8_t attr_voltage_ext_vcs_bias;
    int8_t attr_voltage_ext_vdn_bias;

    int8_t attr_voltage_int_vdd_bias_ultraturbo;
    int8_t attr_voltage_int_vdd_bias_turbo;
    int8_t attr_voltage_int_vdd_bias_nominal;
    int8_t attr_voltage_int_vdd_bias_powersave;

    uint32_t attr_dpll_bias;
    uint32_t attr_undervolting;
    uint32_t attr_pm_safe_frequency_mhz;
    uint32_t attr_pm_safe_voltage_mv;

    uint32_t attr_freq_core_floor;
    uint32_t attr_freq_core_floor_mhz;
    uint32_t attr_boot_freq_mhz;
    uint32_t attr_nest_freq_mhz;

// Resonant clock frequency attributes
    uint32_t attr_pm_resonant_clock_full_clock_sector_buffer_frequency_khz;
    uint32_t attr_pm_resonant_clock_low_band_lower_frequency_khz;
    uint32_t attr_pm_resonant_clock_low_band_upper_frequency_khz;
    uint32_t attr_pm_resonant_clock_high_band_lower_frequency_khz;
    uint32_t attr_pm_resonant_clock_high_band_upper_frequency_khz;

    uint32_t attr_tdp_rdp_current_factor;

    uint8_t attr_resclk_disable;
    uint8_t attr_dpll_vdm_response;
    uint8_t attr_nest_leakage_percent;

// Control attributes
    uint8_t attr_system_ivrm_disable;
    uint8_t attr_systemp_resclk_disable;
    uint8_t attr_system_wof_disable;
    uint8_t attr_system_vdm_disable;

    uint8_t attr_dd_wof_not_supported;
    uint8_t attr_dd_vdm_not_supported;
    uint8_t attr_pstate_mode;

// AVSBus attributes
    uint8_t vdd_bus_num;
    uint8_t vdd_rail_select;
    uint8_t vdn_bus_num;
    uint8_t vdn_rail_select;
    uint8_t vcs_bus_num;
    uint8_t vcs_rail_select;
    uint32_t vcs_voltage_mv;
    uint32_t vdd_voltage_mv;
    uint32_t vdn_voltage_mv;
    uint32_t r_loadline_vdd_uohm;
    uint32_t r_distloss_vdd_uohm;
    uint32_t vrm_voffset_vdd_uv;
    uint32_t r_loadline_vdn_uohm;
    uint32_t r_distloss_vdn_uohm;
    uint32_t vrm_voffset_vdn_uv;
    uint32_t r_loadline_vcs_uohm;
    uint32_t r_distloss_vcs_uohm;
    uint32_t vrm_voffset_vcs_uv;
    uint32_t freq_proc_refclock_khz;
    uint32_t proc_dpll_divider;

} AttributeList;

/// The layout of the various Pstate Parameter Blocks (PPBs) passed a single
/// structure for data movement.
///
/// This structure is only used for passing Pstate data from
/// p9_pstate_parameter_block to it caller for placement into HOMER for
/// consumption by into OCC, the Pstate PGPE and CME. Therefore there is no
/// alignment requirement.

typedef struct
{

    /// Magic Number
    uint64_t magic;

    // PGPE content
    GlobalPstateParmBlock globalppb;

    // CME content
    LocalPstateParmBlock localppb;

    // OCC content
    OCCPstateParmBlock occppb;

} PstateSuperStructure;

// Start of function declarations

// ----------------------------------------------------------------------
// Function prototypes
// ----------------------------------------------------------------------

/// ----------------------------------------------------------------
/// @brief Get #V data and put into array
/// @param[i] i_target            Proc Target
/// @param[o] o_attr_mvpd_data    5x5 array to hold the #V data
/// @param[o] o_valid_pdv_points  No of Valid VPD points
/// @param[o] o_present_chiplets  No of functional chiplets
/// @param[o] o_bucketId          bucket id that got selected
/// @param[o] o_poundv_data       PoundV data
/// @paran[o] o_state             pstate attribute state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------
fapi2::ReturnCode
proc_get_mvpd_data ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                     uint32_t o_attr_mvpd_data[PV_D][PV_W],
                     uint32_t* o_valid_pdv_points,
                     uint8_t* o_present_chiplets,
                     uint8_t&      o_bucketId,
                     fapi2::voltageBucketData_t* o_poundv_data,
                     PSTATE_attribute_state* o_state);

/// -------------------------------------------------------------------
/// @brief Perform data validity check on #V data
/// @param[i] i_target            Proc Target
/// @param[i] i_chiplet_mvpd_data Pointer to array of #V data
/// @param[o] o_valid_pdv_points  No of Valid VPD points
/// @param[i] i_chiplet_num       Chiplet number
/// @param[i] i_bucket_id         Bucket ID
/// @param[o] o_state             pstate attribute state
/// @param[i] i_biased_state      biased validity check state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------

fapi2::ReturnCode
proc_chk_valid_poundv ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                        const uint32_t i_chiplet_mvpd_data[PV_D][PV_W],
                        uint32_t* o_valid_pdv_points,
                        const uint8_t i_chiplet_num,
                        const uint8_t i_bucket_id,
                        PSTATE_attribute_state* o_state,
                        const bool i_biased_state = false);


/// ----------------------------------------------------------------
/// @brief Get IQ (IDDQ) data and put into array
/// @param[in]    i_target          => Proc Target
/// @param[inout] iddqt             => IDDQ table to hold MVPD IDDQ data
/// @param[out]   o_state           => pstate attribute state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------

fapi2::ReturnCode
proc_get_mvpd_iddq ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                     IddqTable* io_iddqt,
                     PSTATE_attribute_state* o_state);
/// ----------------------------------------------------------------
/// @brief Get #W data and put into array
/// @param[in]    i_target          => Proc Target
/// @param[in]    i_poundv_bucketId => #V bucket id
/// @param[out]   o_vdmpb           => Vdmparamblock data
/// @param[out]   o_poundw_data     => #W data
/// @paramg[in]   i_poundv_data     => #V data
/// @param[o]     o_state           => pstate attribute state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------
fapi2::ReturnCode
proc_get_mvpd_poundw(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                     uint8_t       i_poundv_bucketId,
                     LP_VDMParmBlock* o_vdmpb,
                     PoundW_data* o_poundw_data,
                     fapi2::voltageBucketData_t i_poundv_data,
                     PSTATE_attribute_state* o_state
                    );
/// -----------------------------------------------------------------------
/// @brief Get needed attributes
/// @param[in]     i_target          => Proc Target
/// @param[in/out] io_attr           => pointer to attribute list structure
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -----------------------------------------------------------------------
fapi2::ReturnCode
proc_get_attributes ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      AttributeList* io_attr);


/// -----------------------------------------------------------------------
/// @brief Load attribute content into the Global Parameter Block
/// @param[in] i_attr               => Reference to attribute list structure
/// @param[out] o_globalppb         => Pointer to Global Parameter Block
/// -----------------------------------------------------------------------
void
load_gppb_attrs(const AttributeList*   i_attr,
                GlobalPstateParmBlock* o_globalppb);

//
/// -----------------------------------------------------------------------
/// @brief Apply system parameters to a VPD value
/// @param[in] i_vpd_mv             => Reference to attribute list structure
/// @param[in] i_vpd_ma             = Reference to attribute list structure
/// @param[in] i_loadline_uohm      => Reference to attribute list structure
/// @param[in] i_distloss_uohm      => Reference to attribute list structure
/// @param[in] i_distoffset_uohm    => Reference to attribute list structure
/// @return[out] uplifted voltage with system parameters added
/// -----------------------------------------------------------------------
uint32_t
sysparm_uplift(const uint32_t i_vpd_mv,
               const uint32_t i_vpd_ma,
               const uint32_t i_loadline_uohm,
               const uint32_t i_distloss_uohm,
               const uint32_t i_distoffset_uohm);

/// ---------------------------------------------------------------------------
/// @brief Check and process #V bias attributes for external and internal
/// @param[in/out]  io_attr_mvpd_data       => 5x5 array to hold the #V data
/// @param[in]      i_attr                  => pointer to attribute list structure
/// @param[out]     o_vpdbias               => Voltage/Frequency bias values
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ---------------------------------------------------------------------------

fapi2::ReturnCode
proc_get_extint_bias ( uint32_t io_attr_mvpd_data[PV_D][PV_W],
                       const AttributeList* i_attr,
                       VpdBias o_vpdbias[NUM_OP_POINTS] );

/// -------------------------------------------------------------------
/// @brief Boost max frequency in pstate table based on boost attribute
/// @param[in/out] io_pss               => pointer to pstate superstructure
/// @param[in]    i_attr_boost_percent  => Boost percentage attribute
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------

fapi2::ReturnCode
proc_boost_gpst ( PstateSuperStructure* io_pss,
                  uint32_t i_attr_boost_percent);

/// ------------------------------------------------------------
/// @brief Update Psafe_pstate
/// @param[in/out] *io_pss   => pointer to pstate superstructure
/// @param[in]     *i_attr  => pointer to attribute list structure
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ------------------------------------------------------------

fapi2::ReturnCode
proc_upd_psafe_ps ( PstateSuperStructure* io_pss,
                    const AttributeList* i_attr);

/// ------------------------------------------------------------
/// @brief Update Floor_pstate
/// @param[inout] *io_pss   => pointer to pstate superstructure
/// @param[in]    *i_attr  => pointer to attribute list structure
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ------------------------------------------------------------

fapi2::ReturnCode
proc_upd_floor_ps ( PstateSuperStructure* io_pss,
                    const AttributeList* i_attr);

/// -------------------------------------------------------------------
/// @brief Convert Resonant Clocking attributes to pstate values and update superstructure with those values
/// @param[inout] *io_pss   => pointer to pstate superstructure
/// @param[in]    *i_attr  => pointer to attribute list structure
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------

fapi2::ReturnCode
proc_res_clock    ( PstateSuperStructure* io_pss,
                    AttributeList* i_attr);

/// ------------------------------------------------------------
/// @brief Populate a subset of the WOFElements structure from Attributes
/// @param[inout] *io_pss   => pointer to pstate superstructure
/// @param[in]    *i_attr  => pointer to attribute list structure
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ------------------------------------------------------------

fapi2::ReturnCode
load_wof_attributes ( PstateSuperStructure* io_pss,
                      const AttributeList* i_attr);

/// ------------------------------------------------------------
/// @brief Copy VPD operating point into destination in assending order
/// @param[in]    i_src[NUM_OP_POINTS]   => Source VPD structure (array)
/// @param[out] * o_dest[NUM_OP_POINTS]  => pointer to destination VpdOperatingPoint structure
/// @param[in]    i_frequency_step_khz   => frequency step size
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ------------------------------------------------------------

fapi2::ReturnCode
load_mvpd_operating_point ( const uint32_t i_src[PV_D][PV_W],
                            VpdOperatingPoint* o_dest,
                            uint32_t i_frequency_step_khz);

/// ------------------------------------------------------------
/// @brief Copy out of operating point set into a destination operating point
/// @param[in]  &i_op_pt_set          => reference to array of VpdOperatingPoint sets
/// @param[out] *dest[NUM_OP_POINTS]  => pointer to destination VpdOperatingPoint structure
/// @param[in]  i_frequency_step_khz  => Base frequency value for pstate calculation
/// ------------------------------------------------------------
fapi2::ReturnCode
get_operating_point ( const VpdOperatingPoint  i_op_pt_set[NUM_VPD_PTS_SET][NUM_OP_POINTS],
                      uint32_t                 i_set,
                      VpdOperatingPoint*       o_op_pt);

/// ----------------------------------------------------------------
/// @brief Get VDM parameters from attributes
/// @param[in]    i_target          => Proc Target
/// @param[in]   *i_attr            => pointer to attribute list structure
/// @param[out]   o_vdmpb           => VDM parameter block
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------

fapi2::ReturnCode
proc_get_vdm_parms ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                     const AttributeList* i_attr,
                     GP_VDMParmBlock* o_vdmpb);

/// ----------------------------------------------------------------
/// @brief Get resonant clocking parameters from attributes
/// @param[in]    i_target          => Proc Target
/// @param[out]   o_resclk_setup    => Resonant clocking setup
/// @param[in]    i_gppb            => The Global Pstate Parameter Block
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------

fapi2::ReturnCode
proc_res_clock_setup ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                       ResonantClockingSetup* o_resclk_setup,
                       const GlobalPstateParmBlock* i_gppb);

/// ----------------------------------------------------------------
/// @brief Get IVRM parameters from attributes
/// @param[in]     i_target          => Proc Target
/// @param[in]    *i_attr            => pointer to attribute list structure
/// @param[out]    o_ivrmpb          => IVRM parameter block
/// @param[o]      o_state           => pstate attribute state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// ----------------------------------------------------------------

fapi2::ReturnCode
proc_get_ivrm_parms ( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                      const AttributeList* i_attr,
                      IvrmParmBlock* o_ivrmpb,
                      PSTATE_attribute_state* o_state);

/// -------------------------------------------------------------------
/// @brief Set Resonant Clocking "array"/"table" attributes using p9_resclk_defines.h
/// @param[in]    i_target          => Proc Target
/// @param[in]    o_state           => resclck attribute state
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------
fapi2::ReturnCode
proc_set_resclk_table_attrs(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                            PSTATE_attribute_state* o_state);

/// -------------------------------------------------------------------
/// @brief  Compute VPD points for different regions
/// @param[out]    o_operating_points =>  VPD operating points
/// @param[in]    i_gppb             => Global pstate structure
/// @param[in]    i_raw_vpd_pts      => Raw vpd operating points data
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_vpd_pts(VpdOperatingPoint (*o_operating_points)[NUM_OP_POINTS],
                               GlobalPstateParmBlock* i_gppb,
                               VpdOperatingPoint* i_raw_vpd_pts);
//
// p9_pstate_compute_PsV_slopes
//
// Computes slope of voltage-PState curve and PState-voltage
//
// PState(Frequency) on y-axis, Voltage is on x-axis for VF curve
// Interpolation formula: (y-y0)/(x-x0) = (y1-y0)/(x1-x0)
// m   = (x1-x0)/(y1-y0), then use this to calculate voltage, x = (y-y0)*m + x0
// 1/m = (y1-y0)/(x1-x0) here, then use this to calculate pstate(frequency), y = (x-x0)*m + y0
// Region 0 is b/w POWERSAVE and NOMINAL
// Region 1 is b/w NOMINAL and TURBO
// Region 2 is between TURBO and ULTRA_TURBO
//
// Inflection Point 3 is ULTRA_TURBO
// Inflection Point 2 is TURBO
// Inflection Point 1 is NOMINAL
// Inflection Point 0 is POWERSAVE
//
/// -------------------------------------------------------------------
/// @brief  Compute Pstate slope values for different frequencies and pstates
/// @param[in]    i_operating_points =>  VPD operating points
/// @param[out]   o_gppb             => Global pstate structure
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_PsV_slopes(VpdOperatingPoint i_operating_points[][4],
                                  GlobalPstateParmBlock* o_gppb);

/// -------------------------------------------------------------------
/// @brief  Compute Pstate slope values for different frequencies and pstates
/// @param[in]    i_operating_points =>  VPD operating points
/// @param[out]   o_gppb             => Global pstate structure
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_PStateV_slope(VpdOperatingPoint i_operating_points[][4],
                                     GlobalPstateParmBlock* o_gppb);


/// -------------------------------------------------------------------
/// @brief  Print a GlobalPstateParameterBlock structure on a given stream
/// @param[in]  i_gppb    The Global Pstate Parameter Block to print
/// @return void
/// -------------------------------------------------------------------
void
gppb_print(GlobalPstateParmBlock* i_gppb);


/// -------------------------------------------------------------------
/// @brief  Print a OCCPstateParameterBlock structure on a given stream
/// @param[in]  i_oppb The OCC Pstate Parameter Block to print
/// @return void
/// -------------------------------------------------------------------
void
oppb_print(OCCPstateParmBlock* i_oppb);

/// -------------------------------------------------------------------
/// @brief  Print an iddq_print structure on a given stream
/// @param[in]  i_iddqt pointer to Iddq structure to output
/// @return void
/// -------------------------------------------------------------------
void
iddq_print(IddqTable* i_iddqt);



enum FREQ2PSTATE_ROUNDING
{
    ROUND_FAST,
    ROUND_SLOW
};


/// -------------------------------------------------------------------
/// @brief Convert frequency to Pstate number
/// @param[in]     i_gppb     The Global Pstate Parameter Block
/// @param[in]     i_freq_khz Input frequency to convert
/// @param[out]    o_pstate   Computed Pstate
/// @param[out]    i_round    Pstate rounding (ROUND_FAST, ROUND_SLOW)
// @return  pstate state value whether it's lesser than min or greater than max
/// -------------------------------------------------------------------

int freq2pState (const GlobalPstateParmBlock* i_gppb,
                 const uint32_t             i_freq_khz,
                 Pstate*                    o_pstate,
                 const FREQ2PSTATE_ROUNDING i_round = ROUND_SLOW);

/// -------------------------------------------------------------------
/// @brief Convert Pstate number to frequency
/// @param[in]     i_gppb     The Global Pstate Parameter Block
/// @param[in]     i_pstate   Computed Pstate to convert
/// @param[out]    o_freq_khz Computed frequency
/// -------------------------------------------------------------------
int pState2freq (const GlobalPstateParmBlock* gppb,
                 const Pstate i_pstate,
                 uint32_t*    o_freq_khz);

/// -------------------------------------------------------------------
/// @brief Pstate VFRT initialization
/// @param[in] i_target     proc chip target
/// @param[in] i_gppb       The Global Pstate Parameter Block
/// @param[in] i_pBuffer    VFRT data coming from HB
/// @param[out] o_vfrt_data Homer VFRT version
/// @param[in] i_reference_freq  Ultra frequency  @todo get this from the gppb
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------
fapi2::ReturnCode
p9_pstate_update_vfrt(
    const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
    const GlobalPstateParmBlock*  i_gppb,
    uint8_t* i_pBuffer,
    HomerVFRTLayout_t* o_vfrt_data,
    uint32_t i_reference_freq);

///Compute VID points
/// -------------------------------------------------------------------
/// @brief  Compute VDM threshold points based on pound W data
/// @param[in]       i_data   => Pound W data
/// @param[in/out]   io_lppb  => local pstate structure data
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_vdm_threshold_pts(PoundW_data i_data,
        LocalPstateParmBlock* io_lppb);

///Biased slope calculation
/// -------------------------------------------------------------------
/// @brief  Compute VID compare slope values
/// @param[in]       i_data   => Pound W data
/// @param[in/out]   io_lppb  => local pstate structure data
/// @param[in]       i_pstate => pstate values
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_PsVIDCompSlopes_slopes(PoundW_data i_data,
        LocalPstateParmBlock* io_lppb,
        uint8_t* i_pstate);

// p9_pstate_compute_PsVDMThreshSlopes
//
/// -------------------------------------------------------------------
/// @brief  Compute VDM threshold slope values
/// @param[in/out]   io_lppb  => local pstate structure data
/// @param[in]       i_pstate => pstate values
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_PsVDMThreshSlopes(LocalPstateParmBlock* io_lppb,
        uint8_t* i_pstate);

// p9_pstate_compute_PsVDMJumpSlopes
//
/// -------------------------------------------------------------------
/// @brief  Compute VDM jump slope values
/// @param[in/out]   io_lppb  => local pstate structure data
/// @param[in]       i_pstate => pstate values
/// @return void
/// -------------------------------------------------------------------
void p9_pstate_compute_PsVDMJumpSlopes(
    LocalPstateParmBlock* io_lppb,
    uint8_t* i_pstate);


// p9_pstate_wof_initialization
/// -------------------------------------------------------------------
/// @brief  WOF table initialization
/// @param[in]     i_target               => proc chip target
/// @param[in]     i_gppb                 => pointer to GPPB strucure
/// @param[out]    o_buf                  => wof data
/// @param[in/out] io_size                => total wof data size
/// @param[out]    o_state                => pstate attribute values
/// @param[in]     i_base_state_frequency => base frequency value
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------
fapi2::ReturnCode
p9_pstate_wof_initialization(
    const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
    const GlobalPstateParmBlock* i_gppb,
    uint8_t* o_buf,
    uint32_t& io_size,
    PSTATE_attribute_state* o_state,
    const uint32_t i_base_state_frequency);

/// -------------------------------------------------------------------
/// @brief This function computes the safe mode frequency and voltage value
/// @param[in] i_target  proc chip target
/// @param[in] i_attr_mvpd_data #V vpd data
/// @param[in] i_reference_freq proc reference freq
/// @param[in] i_step_frequency Step frequency
/// @param[in] i_ps_pstate power save pstate
/// @param[out] o_safe_mode_values safe mode values
/// @param[in] i_poundw_data  Pound W vpd data
/// @return FAPI2::SUCCESS
fapi2::ReturnCode
p9_pstate_safe_mode_computation(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                                const VpdOperatingPoint i_operating_points[NUM_VPD_PTS_SET][NUM_OP_POINTS],
                                const uint32_t i_reference_freq,
                                const uint32_t i_step_frequency,
                                const Pstate i_ps_pstate,
                                Safe_mode_parameters* o_safe_mode_values,
                                const PoundW_data i_poundw_data);


/// -------------------------------------------------------------------
/// @brief This function provides ncessary #W data in the event of access failures
/// @paramgin] o_poundw_data  Pound W vpd data
/// @return None
void
large_jump_defaults(PoundW_data* o_poundw_data);


/// -------------------------------------------------------------------
/// @brief For a given pstate.. gets the vdd voltge value
/// @param[in] i_pstate  safe mode pstate
/// @param[in] i_attr_mvpd_data #V vpd data
/// @param[in] i_step_frequency Step frequency
/// @return uint32_t vdd voltage value
uint32_t pstate2voltage(const Pstate i_pstate,
                        const uint32_t i_attr_mvpd_data[PV_D][PV_W],
                        const uint32_t i_step_frequency);

/// -------------------------------------------------------------------
/// @brief This function calculates large jump value.. for the given pstate
//         values and jump values read from the pound w vpd.
/// @param[in] i_pstate  safe mode pstate
/// @param[in] i_attr_mvpd_data #V vpd data
/// @param[in] i_step_frequency Step frequency
/// @param[in] i_ps_pstate power save pstate
/// @paramgin] i_data  Pound W vpd data
/// @return uint32_t jump value
uint32_t large_jump_interpolate(const Pstate i_pstate,
                                const VpdOperatingPoint i_operating_points[NUM_OP_POINTS],
                                const uint32_t i_step_frequency,
                                Pstate i_ps_pstate,
                                const PoundW_data i_data);

/// -------------------------------------------------------------------
/// @brief Interpolate the currents based on frequency
/// @param[in]      i_biased_vpd - Data to interpolate
/// @param[in]      i_freq_mhz   - Index grequency
/// @param[out]     o_current_ma - Interpolated Current
/// @return true or false
///
void
interpolate_current( const uint32_t i_biased_vpd[PV_D][PV_W],
                     const uint32_t i_freq_mhz,
                     uint32_t*      o_current_ma);

// p9_pstate_set_global_feature_attributes
/// -------------------------------------------------------------------
/// @brief  Set the global pstate attributes
/// @param[in]    i_target   => Proc target
/// @param[in]    i_state    => pstate attribute states
/// @param[out]   o_qm_flags => Quad manager flags
/// @return fapi::ReturnCode: FAPI2_RC_SUCCESS if success, else error code.
/// -------------------------------------------------------------------
fapi2::ReturnCode
p9_pstate_set_global_feature_attributes(
    const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
    PSTATE_attribute_state i_state,
    QuadManagerFlags* o_qm_flags);

/// @typedef p9_pstate_parameter_block_FP_t
/// function pointer typedef definition for HWP call support
typedef fapi2::ReturnCode (*p9_pstate_parameter_block_FP_t) (
    const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>&,
    PstateSuperStructure*, uint8_t*, uint32_t&);

extern "C"
{

/// -------------------------------------------------------------------
/// @brief Populate Pstate super structure from VPD data
/// @param[in]    i_target          => Chip Target
/// @param[inout] *io_pss           => pointer to pstate superstructure
/// @param[out]   *o_buf            => wof table data
/// @param[inout] &io_size          => wof table data size
/// @return   FAPI2::SUCCESS
/// -------------------------------------------------------------------
    fapi2::ReturnCode
    p9_pstate_parameter_block( const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
                               PstateSuperStructure* io_pss, uint8_t* o_buf, uint32_t& io_size);

} // extern C


// End of function declarations

#ifdef __cplusplus
} // end extern C
#endif

#endif  // __P9_PSTATE_PARAMETER_BLOCK_H__