path: root/src/include/usr/ipmi/ipmisensor.H

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/include/usr/ipmi/ipmisensor.H $                           */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2014,2018                        */
/* [+] Google Inc.                                                        */
/* [+] 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 ipmisensor.H
 *
 *  @brief Interface for the Sensor class
 *
 *  This header file contains the interfaces for the sensor class which
 *  is used to handle setting the virtual sensors maintained by the BMC.
 */

#include <initservice/initsvcstructs.H>
#include <attributeenums.H>
#include <targeting/common/target.H>
#include <errl/errlentry.H>
#include <targeting/common/targetservice.H>
#include <targeting/targplatutil.H>
#include <ipmi/ipmiif.H>

#ifndef __IPMI_IPMISENSOR_H
#define __IPMI_IPMISENSOR_H

namespace SENSOR
{

    const uint8_t INVALID_TYPE = 0xFF;

    /**
     * @brief Default reboot count value.
     */
    static const uint16_t DEFAULT_REBOOT_COUNT = 0x0002;

    /**
     *  @enum sensorReadingTypes
     *  Sensor specific completion codes, defined in IPMI Spec.
     *
     */
    enum sensorReadingType
    {
        THRESHOLD                   = 0x01,
        DIGITAL_ASSERT_DEASSERT     = 0x03,
        DIGITAL_ENABLE_DISABLE      = 0x09,
        SENSOR_SPECIFIC             = 0x6f,
    };


    /**
     *  @enum procStatusSensorOffsets
     *  Sensor specific completion codes, defined in IPMI Spec.
     *
     */
    enum procStatusSensorOffsets
    {
        IERR                            = 0x00,
        THERMAL_TRIP                    = 0x01,
        BIST_FAILURE                    = 0x02,
        HANG_IN_POST                    = 0x03,
        INIT_FAILURE                    = 0x04,
        PROC_CONFIG_ERROR               = 0x05,
        BIOS_ERROR                      = 0x06,
        PROC_PRESENCE_DETECTED          = 0x07,
        PROC_DISABLED                   = 0x08,
        TERMINATOR_PRESNCE_DETECTED     = 0x09,
        PROCESSOR_THROTTLED             = 0x0A,
        MACHINE_CHECK_EXCEPTION         = 0x0B,
        CORRECTABLE_MACHINE_CHECK       = 0x0C,
        INVALID_OFFSET                  = 0xFF,

    };

    /**
     *  @enum dimmStatusSensorOffsets
     *  Dimm specific offsets for status sensor, defined in IPMI Spec.
     *
     */
    enum dimmStatusSensorOffsets
    {
        CORRECTABLE_ECC_ERROR           = 0x00,
        UNCORRECTABLE_ECC_ERROR         = 0x01,
        PARITY_ERROR                    = 0x02,
        MEMORY_SCRUB_ERROR              = 0x03,
        MEMORY_DEVICE_DISABLED          = 0x04,
        CORRECTABLE_ECC_ER_LIMIT_REACH  = 0x05,
        MEM_DEVICE_PRESENCE_DETECTED    = 0x06,
        MEM_CONFIG_ERROR                = 0x07,
        SPARE                           = 0x08,
        MEMORY_AUTOMATICALLY_THROTTLED  = 0x09,
        CRITICAL_OVER_TEMP              = 0x0A,
    };

    /**
     *  @enum firmwareBootProgressSensorOffsets
     *  Boot progress specific offsets defined in IPMI Spec.
     *
     */
    enum firmwareProgressSensorOffsets
    {
        // offset 02h
        SYSTEM_FIRMWARE_PROGRESS = 0x02,
    };


    /**
     *  @enum systemEventSensorOffsets
     *  offSets specific to the system event sensor.
     *
     */
    enum systemEventSensorOffsets
    {
        // offset 02h
        UNDETERMINED_SYSTEM_HW_FAILURE = 0x02,
    };


    /**
     *  @enum discrete09_Offsets
     *
     *      Offsets specific to IPMI sensor reading type 09
     *      digital discrete sensors. These offsets result in
     *      Device Enabled or Device Disabled events in the
     *      BMC event log.
     *
     */
    enum discrete09_Offsets
    {
        // offset 00h
        DEVICE_DISABLED = 0x0,

        //offset 01h
        DEVICE_ENABLED  = 0x1,
    };

     /**
     *  @enum discrete03_Offsets
     *
     *      Offsets specific to IPMI sensor reading type 03
     *      digital discrete sensors. These offsets result in generic
     *      State Asserted or State Deasserted events in the
     *      BMC event log.
     *
     */
    enum discrete03_Offsets
    {
        // offset 00h
        DEASSERTED = 0x00,

        //offset 01h
        ASSERTED   = 0x01,
    };

     /**
     *  @enum acpiPowerState_Offsets
     *
     *      Offsets specific to IPMI ACPI Power state
     *      senosrs. These offsets result in power
     *      state messages in the BMC event log.
     *
     */
    enum acpiPowerState_Offsets
    {
        // offset 0h
        S0_G0_WORKING   = 0x00,

        // offset 05h
        G5_SOFT_OFF     = 0x05,

        //offset 0Bh
        LEGACY_ON       = 0x0B,

    };

    //**  Bit definition for set sensor reading cmd operation field
    //      [7:6] 10b - write given values to event data bytes let BMC handle
    //                  offset in event data 1 when an external event is
    //                  triggered based on the new data.
    //      [5:4] 10b - a one causes a one in the corresponding position of
    //                  the event assertion bits, zeros are ignored.
    //      [3:2] 10b - a one causes a one in the  corresponding position of
    //                  the event deassertion bits, zeros are ignored.
    //      [0:1] 01b - write the given value to the sensor reading byte.
    //
    //      Note: Per AMI implementation bits 0:1 will force the assertion
    //            mask value as sent to be the new sensor value, all other bits
    //            are ignored.
    //
    //      default operation = 1010 1001
    static const uint8_t DEFAULT_OPERATION = 0xA8;  // see IPMI Spec. "Set

    // use this value for sensors which use assertion fields for sensor values
    // eg. Reboot count
    static const uint8_t SET_SENSOR_VALUE_OPERATION = 0x01;

    // Sensor Reading and Event
    // Status command" for
    // details on this byte.

    // Mask which preserves major type of the sensor
    static const uint16_t SENSOR_NAME_MAJOR_MASK = 0xFF00;

    // Mask which preserves minor type of the sensor
    static const uint16_t SENSOR_NAME_MINOR_MASK = 0x00FF;

    /**
     *   @struct setSensorReadingRequest
     *       structure holding the data for the set sensor reading command which
     *       Hostboot will send to the BMC to update sensor status/readings.
     *
     */
    struct setSensorReadingRequest
    {
        uint8_t   iv_sensor_number;
        uint8_t   iv_operation;
        uint8_t   iv_sensor_reading;
        uint16_t  iv_assertion_mask;
        uint16_t  iv_deassertion_mask;
        uint8_t   iv_event_data[3];

        // constructor for our data set
        setSensorReadingRequest()
            :iv_sensor_number(0),iv_operation(DEFAULT_OPERATION),
            iv_sensor_reading(0), iv_assertion_mask(0), iv_deassertion_mask(0)
        {
            memset(iv_event_data,0, sizeof(iv_event_data));
        };
    }PACKED;

    /**
     *   @struct getSensorReadingData
     *       structure holding the data returned by the get sensor reading
     *       command.
     *
     */
    struct getSensorReadingData
    {
        uint8_t   completion_code;
        uint8_t   sensor_status;
        uint8_t   sensor_reading;
        uint16_t  event_status;

        // constructor for our data set
        getSensorReadingData()
            :completion_code(0),sensor_status(0),
            sensor_reading(0), event_status(0)
        {

        };
    };

    /**
     *  @enum  completionCode
     *  Sensor specific completion codes, defined in IPMI Spec.
     *
     */
    enum completionCode
    {
        CC_SENSOR_READING_NOT_SETTABLE    = 0x80,
        CC_EVENT_DATA_BYTES_NOT_SETTABLE  = 0x81
    };
    /**
     * @enum SensorReadingValidEnum
     *
     *  enum defining masks used when reading a sensor
     *
     */
    enum SensorReadingValidEnum
    {
        SENSOR_DISABLED = 0x80,
        SENSOR_SCANNING_DISABLED = 0x40,
        READING_UNAVAILABLE = 0x20,
    };

    /**
     *  @class SensorBase
     *
     *  @brief Base class for sensors
     *
     *  @par Detailed Description:
     *      Provides the base functionality to set IPMI sensor from Hostboot
     *      including finding the sensor number given a specific target type.
     *      The constructor takes a SENSOR_NAME and a target pointer. If a null
     *      is passed in as the target pointer, the system target will be used
     *      to search for the requested sensor name.
     */
    class SensorBase
    {

        public:
            /**
             *  @brief Generic base class constructor for sensor objects
             *
             *  @brief Base class for sensor derivation - takes a sensor name,
             *  and a target* as input.
             *
             *  @par Detailed Description:
             */
            SensorBase(TARGETING::SENSOR_NAME i_name,
                    TARGETING::ConstTargetHandle_t i_target);

            /**
             *  @brief Destructor for the base sensor object
             *
             *  Destroys the sensor object and any owned resources, does not
             *  alter the state on the BMC
             *
             *  @post Sensor object is destroyed, and all resources are
             *        reclaimed
             */
            virtual  ~SensorBase();

            // low level communication to update sensor readings on the BMC

            /**
             * @brief write sensor data
             *    Low level interface to send the set sensor and event data
             *    reading command to the BMC through the BT interface.
             *
             * @return Errorlog handle
             *
             */
            virtual errlHndl_t  writeSensorData();

            /**
             * @brief read sensor data
             *    Low level interface to send get sensor and event data reading
             *    command to the BMC through the BT interface.
             *
             * @param[out] o_data - buffer containing the response data from the
             *                      BMC,
             *  NOTE: caller is responsible for deleting the memory pointed to
             *        by o_data.
             *
             * @return Errorlog handle
             *
             */
            virtual errlHndl_t readSensorData(getSensorReadingData& o_data);


            /**
             * @brief process completion codes
             *    Converts completion code values returned from the IPMI
             *    transport layer into an error log.
             *
             * @param[in] i_cc - completion code returned from the IPMI
             *                   transport layer.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t processCompletionCode(IPMI::completion_code i_cc);

            /**
             * @brief Send set sensor reading and event status command
             *    Helper function to send the sensor reading to the BMC, this
             *    command executes asynchronously.
             *
             * @param[in] i_data - Contains the command and data
             *                      to send to the BMC.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t sendSetSensorReading(
                    setSensorReadingRequest * i_data);

            /**
             * @brief helper function to get the sensor number
             */
            virtual uint32_t getSensorNumber( )
            {
                return TARGETING::UTIL::getSensorNumber(iv_target, iv_name );
            };


            // return the sensor type and event reading data
            static errlHndl_t getSensorType(uint32_t i_sensorNumber,
                                     uint8_t &o_sensorType,
                                     uint8_t &o_eventReadingType );

        protected:

            /**
             * @brief setup mask for event assertion/deassertion
             *
             * Translate the passed in offset into a mask for use in
             * as an assertion or deassertion mask.
             *
             * @param[in] = i_offset - offset for event do be signaled
             * @param[in] = i_swap   - indicates if mask should be
             *                         byteswapped before returning
             *                         true =  byte swap mask
             *                         false = do not byte swap the mask
             *
             * @return  eventMask - event status mask with correctly set bit
             *                      matching the offset passed in.
             *
             */
            static uint16_t setMask( uint8_t i_offset, bool i_swap = true );

            /**
             * @brief return the event offset from an assertion/deassertion mask
             *
             * Translate the assertion/deassertion mask into the correct event
             * offset.
             *
             * @param[in] = i_mask - offset for event do be signaled
             *
             * @return offset - offset of the bit which is set in the passed in
             *                  mask.
             *
             */
            static uint8_t getOffset( uint16_t i_mask );

            // Name of this sensor, name is used to find the sensor number in
            // the IPMI_SENSORS attribute.
            TARGETING::SENSOR_NAME iv_name;

            // Target associated with this sensor.
            TARGETING::ConstTargetHandle_t iv_target;

            // data structure for the send sensor reading command.
            setSensorReadingRequest * iv_msg;

        private:
            //disable default constructor, copy constructor and the assignment
            // operator.
            SensorBase();

            SensorBase& operator=(const SensorBase& i_right);

            SensorBase(const SensorBase& thing );

    };

    /**
     *  @class FirmwareProgressSensor
     *
     *  @brief Specialized sensor class for the firmware progress sensor
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the firmware progress
     *      virtual sensor maintained by the BMC.
     */
    class FirmwareProgressSensor : public SensorBase
    {

        public:

            /**
             *  @brief Constructor for the FirmwareProgressSensor
             *
             *  The firmware progress sensor is used to update the BMC
             *  with the current firmware phase.
             *  The system target holds the IPMI sensor number for this sensor.
             *
             */
            FirmwareProgressSensor();

            /**
             *  @brief destructor for the FirmwareProgressSensor
             *
             *  The firmware progress sensor is used to update the BMC
             */
            ~FirmwareProgressSensor();

            /**
             *
             * @brief Set the current firmware boot progress phase
             *    Interface used to update the event status for the system
             *    firmware progress sensor.  phases are defined by the enum
             *    firmware_progress_phase. Further information can be found in
             *    the IPMI specification.
             *
             * @param[in] i_phase - current firmware progress phase.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t setBootProgressPhase(
                            INITSERVICE::firmwareProgressPhase i_phase);

        private:
            // @enum firmwareProgressOfsets
            //
            // sensor specific offset used to specify that the event which is
            // being signaled is for the system firmware progress sensor.
            enum firmwareProgressOffsets
            {
                SYSTEM_FIRMWARE_PROGRESS    = 0x02  //< Sensor specific offset
                                                    //< for system firmware
                                                    //< progress event.
            };

    };

    /**
     *  @class HostStatusSensor
     *
     *  @brief Specialized class for the host status sensor.
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the Host_Status sensor also
     *      known as the ACPI power state. The Host_status sensor is a virtual
     *      sensor maintained by the BMC,
     */
    class HostStatusSensor : public SensorBase
    {
        public:

            /**
             * @enum hostStatus
             *      enum to define the ACPI power state of the system, this
             *      sensor will be updated by Hostboot and opal.
             */
            enum hostStatus
            {
                S0_G0_WORKING   = 0x00,  //< Host up
                S5_G2_SOFT_OFF  = 0x05,  //< Soft power off
                LEGACY_ON_STATE = 0x0B   //< Host not up, but started
            };

            /**
             *  @brief Constructor for the HostStatusSensor
             *
             *  The firmware progress sensor is used to update the BMC
             *  with the current ACIP power state of the system.
             *  The system target holds the IPMI sensor number for this sensor.
             *
             */
            HostStatusSensor();

            /**
             *  @brief Destructor for the HostStatusSensor
             *
             */
            ~HostStatusSensor();

            /**
             *
             * @brief Set the current HostStatus
             *    Interface used to update the event status for the ACPI
             *    power state of the system. States are defined by the enum
             *    host_status.  Further information can be found in the IPMI
             *    specification.
             *
             *
             * @param[in] i_phase - current firmware progress phase.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t updateHostStatus( hostStatus status );

    };

    /**
     *  @class RebootCountSensor
     *
     *  @brief Specialized class for the system reboot count.
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the reboot count. The
     *      reboot count is a special sensor maintained by the BMC.
     *
     *   Usage:
     *     reboot_count_t count = 3;
     *      RebootCountSensor l_sensor;
     *      l_sensor.setRebootCount( count );
     *
     */
    class RebootCountSensor : public SensorBase
    {

        public:

            /**
             *  @brief Constructor for the RebootCountSensor
             *
             *  The reboot count sensor is used to update the reboot count
             *  sensor maintained by the BMC.
             *
             *  The system target holds the IPMI sensor number for this sensor.
             *
             */
            RebootCountSensor();

            /**
             *  @brief Destructor for the RebootCountSensor
             *
             */
            ~RebootCountSensor();

            /**
             * @brief Set the value for the reboot count to the BMC.
             *
             * @param[in] i_count - new reboot count value.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t setRebootCount( uint16_t i_count );

            /**
             * @brief get the value of the reboot count from the BMC.
             *
             * @param[o] o_rebootCount - new reboot count value.
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t getRebootCount( uint16_t& o_rebootCount );

    };

    /**
     *  @class RebootControlSensor
     *
     *  @brief Specialized class for the system reboot control
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to enable/disable auto reboot
     *      control controlled by the BMC.
     *
     *   Usage:
     *      RebootControlSensor l_rbotCtl;
     *      l_rbotCtl.setRebootControl( autoRebootSetting::ENABLE_REBOOTS );
     *      l_rbotCtl.setRebootControl( autoRebootSetting::DISABLE_REBOOTS );
     *
     */
    class RebootControlSensor : public SensorBase
    {

        public:
            /**
             * @enum autoRebootSetting
             *      enum to define the control sensor state
             *      Note: bit based setting: 0 -> 0x01
             *                               1 -> 0x02
             */
            enum autoRebootSetting
            {
                DISABLE_REBOOTS = 0x01, // keep current state
                ENABLE_REBOOTS  = 0x02, // allow reboot for FIRDATA analysis
            };

            /**
             *  @brief Constructor for the RebootControlSensor
             *
             *  The system target holds the IPMI sensor number for this sensor.
             *
             */
            RebootControlSensor();

            /**
             *  @brief Destructor for the RebootControlSensor
             *
             */
            ~RebootControlSensor();

            /**
             * @brief Set reboots to enabled or disabled
             *
             * @param[in] i_setting - enable/disable
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t setRebootControl( autoRebootSetting i_setting );

            /**
             * @brief get the value of the reboot control from the BMC.
             *
             * @param[o] i_setting - reboot control value
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t getRebootControl( autoRebootSetting& o_setting );

    };


    /**
     *  @class StatusSensor
     *
     *  @brief Specialized class to handle DIMM, PROC and Core status.
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the status of DIMMS, Cores,
     *      and processors.  The object will determine from the Target* what
     *      sensor offsets should be used, and configure itself accordingly.
     */

    class StatusSensor : public SensorBase
    {

        public:

            /**
             * @enum statusEnum
             *
             *  enum defining the status of targets which use the
             *  status sensor to report functional and present states.
             */
            enum statusEnum
            {
                NOT_PRESENT             = 0x0000,
                PRESENT                 = 0x0001,
                FUNCTIONAL              = 0x0002,
                PRESENT_FUNCTIONAL      = 0x0003,
                NON_FUNCTIONAL          = 0x0004,
                PRESENT_NONFUNCTIONAL   = 0x0005,
            };

            /**
             *  @brief Constructor for a status sensor
             *
             *  The status sensor is used for DIMMS, Cores and Procs. Hostboot
             *  will update the present and functional state for the status
             *  sensor associated with each instance of these target types.
             *
             *
             *  The IPMI sensor number for these sensors are associated with
             *  each instance of the DIMM, CORE and Processor targets.
             *
             */
            StatusSensor( TARGETING::ConstTargetHandle_t );

            /**
             *  @brief Destructor for the StatusSensor
             *
             */
            ~StatusSensor();

            errlHndl_t setStatus( statusEnum status );

        protected:
            // internal offset data which is configured based on target type
            // used in construction.
            uint8_t iv_presentOffset;
            uint8_t iv_functionalOffset;

        private:
            // disable the default constructor
            StatusSensor();
    };

    /**
     *  @class FaultSensor
     *
     *  @brief Specialized class implementing a simple fault sensor
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to assert or deassert a fault
     *      condition for a given target.  These are typically used for
     *      things that have failed which may not have a full targeting
     *      implementation.  Implemented using a 0x03 'digital' discrete
     *      generic sensor profile.
     */
    class FaultSensor : public SensorBase
    {
        public:

            /**
             *  @enum FAULT_SENSOR_OFFSET
             *
             *  Indicates the correct sensor offset to use for sensor fault
             *  assertions/deassertions.
             */
            enum FAULT_SENSOR_OFFSET
            {
                FAULT_DEASSERTED_OFFSET = 0x00,
                FAULT_ASSERTED_OFFSET   = 0x01,
            };

            /**
             *  @enum FAULT_STATE
             *
             *  Enum indicating whether the fault sensor is asserted or not
             */
            enum FAULT_STATE
            {
                FAULT_STATE_DEASSERTED = 0x00,
                FAULT_STATE_ASSERTED   = 0x01,
            };

            /**
             *  @brief Constructor for a fault sensor
             *
             *  @param[in] i_pTarget
             *      Target associated with the fault sensor.  Must not be NULL.
             */
            FaultSensor(TARGETING::ConstTargetHandle_t i_pTarget);

            /**
             *  @brief Constructor for a fault sensor, used to differentiate
             *      multiple sensors of similar type on same target
             *
             *  @param[in] i_pTarget
             *      Target associated with the fault sensor.  Must not be NULL.
             *
             *  @param[in] i_associatedType
             *      Type of non-instantiated target linked to the main target
             *      for which this sensor provides readings.
             */
            FaultSensor(TARGETING::ConstTargetHandle_t i_pTarget,
                TARGETING::ENTITY_ID i_associatedType =
                                            TARGETING::ENTITY_ID_NA);

            /**
             *  @brief Destructor for a fault sensor
             *
             */
            ~FaultSensor();

            /**
             *  @brief Set the fault sensor to faulted or non-faulted
             *
             *  @param[in] i_faultState
             *      Whether sensor is faulted or not
             *
             *  @return Error log handle
             *  @retval NULL  Status set successfully
             *  @retval !NULL Failed to set status
             */
            errlHndl_t setStatus(FAULT_STATE i_faultState);

        private:

            // Disable the default constructor
            FaultSensor();

            // Disable assignment operator
            FaultSensor& operator=(const FaultSensor& i_rhs);

            // Disable copy constructor
            FaultSensor(const FaultSensor& i_rhs);
    };


    /**
     *  @class GpuSensor
     *
     *  @brief Specialized class to handle GPU sensor status.
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the status of GPU sensors.
     */
    class GpuSensor : public StatusSensor
    {

        public:

            /**
             *  @brief Constructor for a gpu sensor
             *
             *  The status sensor is used for GPUs attached to Procs. Hostboot
             *  will update the present and functional state for the status
             *  sensor associated with each instance of these target types.
             *
             *  @param[in] - Sensor name enum
             *  @param[in] - number identifying particular sensor
             *  @param[in] - Processor target that contains the sensors
             */
            GpuSensor(TARGETING::SENSOR_NAME i_name, uint16_t i_num,
                      TARGETING::ConstTargetHandle_t i_target );

            /**
             *  @brief return the unique number identifying this sensor
             */
            uint32_t getSensorNumber() override
            {
                return iv_sensorNumber;
            };

            /**
             *  @brief Destructor for the GpuSensor
             */
            ~GpuSensor();

        private:
            /**
             *  @brief unique number identifying this particular gpu sensor
             */
            uint16_t iv_sensorNumber;

            // disable the default constructor
            GpuSensor();
    };


    /**
     *  @class HbVolatileSensor
     *
     *  @brief Specialized class for the hostboot volatile memory setup
     *
     *  @par Detailed Description:
     *      Provides the functionality needed by OpenBMC to set hostboot
     *      section as volatile or not
     *
     *   Usage:
     *      HbVolatileSensor l_hbVolatileCtl;
     *      l_hbVolatileCtl.setHbVolatile( HbVolatileSensor::ENABLE_VOLATILE );
     *      l_hbVolatileCtl.setHbVolatile( HbVolatileSensor::DISABLE_VOLATILE );
     *
     */
    class HbVolatileSensor : public SensorBase
    {

        public:

            /**
             * @enum hbVolatileSetting
             *      enum to define the HB volatile sensor setting
             *      Note: bit based setting: BMC 0 -> 0x01 (off)
             *                               BMC 1 -> 0x02 (on)
             */
            enum hbVolatileSetting
            {
                DISABLE_VOLATILE = 0x01, // (default)
                ENABLE_VOLATILE  = 0x02, // allow volatile memory to be cleared
            };

            /**
             *  @brief Constructor for the HbVolatileSensor
             *
             *  The system target holds the IPMI sensor number for this sensor.
             *
             */
            HbVolatileSensor();

            /**
             *  @brief Destructor for the HbVolatileSensor
             *
             */
            ~HbVolatileSensor();

            /**
             * @brief Set hostboot volatile section to volatile or not
             *
             * @param[in] i_setting - enable/disable volatility of section
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t setHbVolatile( hbVolatileSetting i_setting );

            /**
             * @brief get the value of the hostboot volatile
             *        section from the BMC.
             *
             * @param[o] i_setting - value = volatile or not
             *
             * @return Errorlog handle
             *
             */
            errlHndl_t getHbVolatile( hbVolatileSetting & o_setting );

    };

    /**
     *  @brief Updates initial state of Hostboot relevant fault sensors on the
     *      BMC
     *
     *  @par Detailed Description:
     *      Updates initial state of Hostboot relevant fault sensors on the
     *      BMC to "not faulted" for all applicable fault sensors detected in
     *      the system.  All errors will be internally committed.
     */
    void updateBMCFaultSensorStatus(void);

    /*
     *  @class OCCActiveSensor
     *
     *  @brief Specialized class to handle OCC_Active sensors.
     *
     *  @par Detailed Description:
     *      Provides the functionality needed to set the functional status of
     *      the OCCs.  The object will determine from the Target* which of
     *      the OCC sensors to set.  The OCC_Active sensor is defined as a
     *      processor type sensor so it will use the offsets defined in the
     *      ipmi spec for that type of sensor.
     */

    class OCCActiveSensor : public SensorBase
    {

        public:

            /**
             * @enum OccStateEnum
             *
             *  enum defining the state of the OCC sensor
             */
            enum OccStateEnum
            {
                OCC_NOT_ACTIVE          = 0x00,
                OCC_ACTIVE              = 0x01
            };


            /**
             *  @brief Constructor for an OccActive sensor
             *
             *  The OCCActiveSensor sensor is used to mark the OCC as functional
             *
             *  The IPMI sensor number for this sensor is associated with
             *  each instance of a Processor target.
             *
             */
            OCCActiveSensor( TARGETING::Target * );

            /**
             *  @brief Destructor for OCC_Active
             *
             */
            ~OCCActiveSensor();

            /**
             *  @brief Interface to set the state of the OCC
             *  active sensor.
             *
             */
            errlHndl_t setState( OccStateEnum i_state );

            /**
             *  @brief Interface to determine if the OCC associated
             *  with the passed in target is active.
             *
             */
            bool isActive();

        private:
            // disable the default constructor
            OCCActiveSensor();

    };

    /*
     *   @brief Return the fault sensor number for a target
     *   Will return either the status sensor or Fault sensor number for a
     *   given target.  If the target passed in does not have either of those
     *   sensor types, the "System Error" sensor number will be returned.
     *
     */
    uint32_t getFaultSensorNumber(TARGETING::ConstTargetHandle_t i_pTarget );


    /**
     *   @brief Update DIMM/CORE/Processor status sensors on the BMC.
     *   Update the present/functional status on the BMC for status sensors
     *   monitored by Hostboot.  The sensor will be updated based on the
     *   HWAS state of the target. Currently handles DIMM/CORE/PROC present
     *   and functional status.
     *
     */
    void updateBMCSensorStatus(void);


    /**
     *   Helper function to update the status sensor for a specific target
     *   type.  Currently supports DIMM, CORE and Processor target types.
     *
     *  @param[in] - i_type, target type to set the status for
     *
     */
    void updateBMCSensorStatus( TARGETING::TYPE i_type );

    /**
     *   Helper function to return the system power limit from the BMC.
     *   This limit is set by the system administrator to limit the amout
     *   of power the system can use.
     *
     *  @param[out] - o_powerLimit  - user defined power limit setting.
     *  @param[out] - o_limitActive - indicates the limit has been activated
     *                                using the dcmi "activate power limit"
     *                                command.
     *
     *  @return Errorlog handle
     */
    errlHndl_t getUserPowerLimit( uint16_t &o_powerLimit,
                                  bool &o_activeActive );

    /**
     *   Helper function to return the system power limit from the BMC.
     *   This limit is set by the system administrator to limit the amount
     *   of power the system can use.
     *
     *  @param[out] - o_sensor_numbers - pointer to a static array containing
     *                                   the sensor numbers for each of the 16
     *                                   apss channels
     *
     *  @return Errorlog handle
     *
     */
    errlHndl_t getAPSSChannelSensorNumbers(
                                     const uint32_t (* &o_sensor_numbers)[16]);

    /**
     *   Helper function to return a mask of the supported masks for the
     *   sensor passed in.
     *
     *  @param[i] - sensor name to determine the offset for.
     *  @param[o] - sensor reading type, defined in IPMI spec for the
     *              passed in sensor number.
     *
     *
     *  @return sensor offsets
     */
    uint16_t getSensorOffsets(TARGETING::SENSOR_NAME i_name,
                              sensorReadingType &o_readType );

    /**
     *   Helper function to return the backplane fault sensor
     *
     *  @return sensor number
     */
    uint8_t getBackPlaneFaultSensor();

    /**
     * @brief Maximum GPU sensors on a single processor
     */
    static const uint8_t MAX_GPU_SENSORS_PER_PROCESSOR = 3;

    /**
     *  @brief Grab the GPU sensor type IDs for a particular processor target
     *
     *   Will return all sensor ids that match the type for a given target.
     *
     *  @param[in] - i_proc  - processor target
     *  @param[in] - i_type  - Functional/state, gpucoretemp, gpumemtemp
     *  @param[out] - o_num_ids - number of valid IDs returned in o_ids
     *  @param[out] - o_ids     - ordered list of sensor IDs
     *
     *  @return Errorlog handle
     */
    errlHndl_t getGpuSensors( TARGETING::Target* i_proc,
                              HWAS::sensorTypeEnum i_type,
                              uint8_t & o_num_ids,
                              uint32_t o_ids[MAX_GPU_SENSORS_PER_PROCESSOR] );

    /**
     * @brief Maximum number of GPUs associated with a processor
     */
    static const uint8_t MAX_PROCESSOR_GPUS = 3;

    /**
     *  @brief  Updates GPU sensor status for GPUs on this
     *          particular processor target
     *
     *  @param[in] - i_proc       - processor target
     *  @param[in] - i_gpu_status - status of GPU0, GPU1 and GPU2
     */
    void updateGpuSensorStatus( TARGETING::Target* i_proc,
                    StatusSensor::statusEnum i_gpu_status[MAX_PROCESSOR_GPUS] );


}; // end namespace

#endif