path: root/src/usr/hwpf/hwp/pstates/pstates/pstates.c

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/hwpf/hwp/pstates/pstates/pstates.c $                  */
/*                                                                        */
/* IBM CONFIDENTIAL                                                       */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 2013,2014              */
/*                                                                        */
/* p1                                                                     */
/*                                                                        */
/* Object Code Only (OCO) source materials                                */
/* Licensed Internal Code Source Materials                                */
/* IBM HostBoot Licensed Internal Code                                    */
/*                                                                        */
/* The source code for this program is not published or otherwise         */
/* divested of its trade secrets, irrespective of what has been           */
/* deposited with the U.S. Copyright Office.                              */
/*                                                                        */
/* Origin: 30                                                             */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
// $Id: pstates.c,v 1.7 2014/02/18 16:07:35 jimyac Exp $

/// \file pstates.c
/// \brief Pstate routines required by OCC product firmware

#include "ssx.h"
#include "pgp_common.h"
#include "pstates.h"

/// Validate a VRM11 VID code
///
/// \param vid A VRM11 VID
///
/// \retval 0 The VID is valid
///
/// \retval -VID11_UNDERFLOW The Vid code is a low 'power off' VID (0 or 1)
///
/// \retval -VID11_OVERFLOW The Vid code is a high 'power off' VID (0xfe or 0xff)

int
vid11_validate(Vid11 vid)
{
    int rc;

    if (vid < VID11_MIN) {

        rc = -VID11_UNDERFLOW;

    } else if (vid > VID11_MAX) {

        rc = -VID11_OVERFLOW;

    } else {

        rc = 0;

    }

    return rc;
}


/// Bias a Pstate with saturation
///
/// \param pstate The initial Pstate to bias
///
/// \param bias The signed bias amount
///
/// \param biased_pstate The final biased Pstate
///
/// This API adds a signed bias to the \a pstate and returns the saturated sum
/// as \a biased_pstate.  Any application that biases Pstates should use this
/// API rather than simple addition/subtraction.
///
/// The following return codes are not considered errors:
///
/// \retval 0 Success
///
/// \retval -PSTATE_OVERFLOW The biased Pstate saturated at PSTATE_MAX.
///
/// \retval -PSTATE_UNDERFLOW The biased Pstate saturated at PSTATE_MIN.

int
bias_pstate(Pstate pstate, int bias, Pstate* biased_pstate)
{
    int rc, int_pstate;

    int_pstate = (int)pstate + bias;
    if (int_pstate != (Pstate)int_pstate) {
    if (bias < 0) {
        *biased_pstate = PSTATE_MIN;
            rc = -PSTATE_UNDERFLOW;
    } else {
        *biased_pstate = PSTATE_MAX;
            rc = -PSTATE_OVERFLOW;
    }
    } else {
    *biased_pstate = int_pstate;
    rc = 0;
    }

    return rc;
}


/// Bias a DPLL frequency code with saturation and bounds checking
///
/// \param fcode The initial frequency code to bias
///
/// \param bias The signed bias amount
///
/// \param biased_fcode The final biased frequency code
///
/// This API adds a signed bias to the \a fcode and returns the saturated and
/// bounded sum as \a biased_fcode.  Any application that biases frequency
/// codes should use this API rather than simple addition/subtraction.
///
/// The following return codes are not considered errors:
///
/// \retval 0 Success
///
/// \retval -DPLL_OVERFLOW The biased frequency code saturated at DPLL_MAX.
///
/// \retval -DPLL_UNDERFLOW The biased frequency code saturated at DPLL_MIN.

int
bias_frequency(DpllCode fcode, int bias, DpllCode* biased_fcode)
{
    int rc;
    unsigned uint_fcode;

    uint_fcode = (unsigned)fcode + bias;
    if (uint_fcode != (DpllCode)uint_fcode) {
    if (bias < 0) {
        *biased_fcode = DPLL_MIN;
            rc = -DPLL_UNDERFLOW;
    } else {
        *biased_fcode = DPLL_MAX;
            rc = -DPLL_OVERFLOW;
    }
    } else if (uint_fcode < DPLL_MIN) {
        *biased_fcode = DPLL_MIN;
        rc = -DPLL_UNDERFLOW;
    } else {
    *biased_fcode = uint_fcode;
    rc = 0;
    }

    return rc;
}


/// Bias a VRM11 VID code with saturation and bounds checking
///
/// \param vid The initial vid code to bias
///
/// \param bias The signed bias amount
///
/// \param biased_vid The final biased VID code
///
/// This API adds a signed bias to the \a vid and returns the saturated and
/// bounded sum as \a biased_vid.  Any application that biases VID codes
/// should use this API rather than simple addition/subtraction.
///
/// The following return codes are not considered errors:
///
/// \retval 0 Success
///
/// \retval -VID11_OVERFLOW The biased VID code saturated at VID11_MAX.
///
/// \retval -VID11_UNDERFLOW The biased VID code saturated at VID11__MIN.

int
bias_vid11(Vid11 vid, int bias, Vid11* biased_vid)
{
    int rc;
    unsigned uint_vid;

    uint_vid = (unsigned)vid + bias;
    if (uint_vid != (DpllCode)uint_vid) {
    if (bias < 0) {
        *biased_vid = VID11_MIN;
            rc = -VID11_UNDERFLOW;
    } else {
        *biased_vid = VID11_MAX;
            rc = -VID11_OVERFLOW;
    }
    } else {

        rc = vid11_validate(uint_vid);
    *biased_vid = uint_vid;

    }

    return rc;
}


/// Retrieve an entry from the Global Pstate Table abstraction
///
/// \param gpst An initialized GlobalPstateTable structure.
///
/// \param pstate The Pstate index of the entry to fetch
///
/// \param bias This is a signed bias. The entry searched is the \a pstate +
/// \a bias entry.
///
/// \param entry A pointer to a gpst_entry_t to hold the returned data.
///
/// This routine functions similar to PMC harwdare.  When a Pstate is
/// requested the index is first biased (under/over-volted) and clipped to the
/// defined bounds, then the Pstate entry is returned.
///
/// The following return codes are not considered errors:
///
/// \retval 0 Success
///
/// \retval -GPST_PSTATE_CLIPPED_HIGH The requested Pstate does not exist in
/// the table. The maximum Pstate entry in the table has been returned.
///
/// \retval -GPST_PSTATE_CLIPPED_LOW The requested Pstate does not exist in
/// the table. The minimum Pstate entry in the table has been returned.
///
/// The following return codes are considered errors:
///
/// \retval -GPST_INVALID_OBJECT The Global Pstate Table is either null (0) or
/// otherwise invalid.

int
gpst_entry(const GlobalPstateTable *gpst,
           const Pstate pstate,
           int bias,
           gpst_entry_t *entry)
{
    int rc, index;
    Pstate biased_pstate;

    if (gpst == 0) {
        return -GPST_INVALID_OBJECT;
    }

    rc = bias_pstate(pstate, bias, &biased_pstate);

    if ((rc == -PSTATE_UNDERFLOW) || (pstate < gpst_pmin(gpst))) {

    rc = -GPST_PSTATE_CLIPPED_LOW;
    index = 0;

    } else if ((rc == -PSTATE_OVERFLOW) || (pstate > gpst_pmax(gpst))) {

    rc = -GPST_PSTATE_CLIPPED_HIGH;
    index = gpst->entries - 1;

    } else {

    rc = 0;
    index = pstate - gpst_pmin(gpst);

    }

    *entry = gpst->pstate[index];

    return rc;
}


/// Translate a Vdd VID code to the closest Pstate in a Global Pstate table.
///
/// \param gpst The GlobalPstateTable to search
///
/// \param vdd A VID code representing an external VDD voltage
///
/// \param pstate The Pstate most closely matching the \a vid.
///
/// \param entry The GlobalPstateTable entry of the returned \a pstate.
///
/// This routine assumes that Pstate voltages increase monotonically from
/// lower to higher Pstates.  The algorithm operates from lowest to highest
/// voltage, scanning until the Pstate voltage is >= the VID voltage.  Thus
/// the algorithm effectively rounds up voltage (unless clipped at the highest
/// Pstate).
///
/// The following return codes are not considered errors:
///
/// \retval 0 Success
///
/// \retval -GPST_PSTATE_CLIPPED_HIGH The requested voltage does not exist in
/// the table. The highest legal Pstate is returned.
///
/// \retval -GPST_PSTATE_CLIPPED_LOW The requested voltage does not exist in
/// the table.  The lowest legal Pstate in the table is returned.
///
/// The following return codes are considered errors:
///
/// \retval -VRM_INVALID_VOLTAGE The \a vid is invalid.
///
/// \retval -GPST_INVALID_OBJECT The \a gpst argument is NULL (0).

// Recall that VID codes _decrease_ as voltage _increases_

#ifdef _BIG_ENDIAN

#define revle16(x) x
#define revle32(x) x
#define revle64(x) x

#else

uint16_t revle16(uint16_t i_x);
uint32_t revle32(uint32_t i_x);
uint64_t revle64(uint64_t i_x);

#endif

int
gpst_vdd2pstate(const GlobalPstateTable* gpst,
                const Vid11 vdd,
                Pstate* pstate,
                gpst_entry_t* entry)
{
    size_t i;
    int rc;
    gpst_entry_t         entry_rev;       // jwy
  

    if (gpst == 0) {
         return -GPST_INVALID_OBJECT;
    }

    do {
        rc =vid11_validate(vdd);
        if (rc) break;

        // Search for the Pstate that contains (close to) the requested
        // voltage, then handle special cases.

        for (i = 0; i < gpst->entries; i++) {
            entry_rev.value = revle64(gpst->pstate[i].value);       // jwy

            if (entry_rev.fields.evid_vdd <= vdd) {                 // jwy
                break;
            }
        }

        if (i == gpst->entries) {

            *pstate = gpst_pmax(gpst);
            *entry = gpst->pstate[i - 1];
            rc = -GPST_PSTATE_CLIPPED_HIGH;

        } else if ((i == 0) && (entry_rev.fields.evid_vdd < vdd)) {

            *pstate = gpst_pmin(gpst);
            *entry = gpst->pstate[0];
            rc = -GPST_PSTATE_CLIPPED_LOW;

        } else {

            rc = bias_pstate(gpst_pmin(gpst), i, pstate);
            if (rc) break;

            *entry = gpst->pstate[i];
        }
    } while (0);
    return rc;
}

int freq2pState (const GlobalPstateTable* gpst, 
                 const uint32_t freq_khz,
                 Pstate* pstate) 
{
  int rc = 0;
  int32_t pstate32 = 0;
  
  // ----------------------------------
  // compute pstate for given frequency
  // ----------------------------------  
  pstate32 = ((int32_t)((freq_khz - revle32(gpst->pstate0_frequency_khz)))) / (int32_t)revle32(gpst->frequency_step_khz);
  *pstate    = (Pstate)pstate32;
  
  // ------------------------------
  // perform pstate bounds checking
  // ------------------------------
  if (pstate32 < PSTATE_MIN)
     rc = -PSTATE_LT_PSTATE_MIN;
    
  if (pstate32 > PSTATE_MAX)
     rc = -PSTATE_GT_PSTATE_MAX;  
 
  return rc;
}



int pstate_minmax_chk (const GlobalPstateTable* gpst, 
                       Pstate* pstate) 
{
  int rc = 0;
  
   // if pstate is greater than pmax, generate an error
   if (*pstate > gpst_pmax(gpst))
     rc = -GPST_PSTATE_GT_GPST_PMAX;                                                                                               
   
   // if pstate is less than than pmin, clip pstate to pmin
   if (*pstate < gpst_pmin(gpst) )                                                                       
     *pstate = gpst_pmin(gpst);                                      
 
  return rc;
}