Netra CP2300 cPSB Board Programming Guide

The Netra CP2300 board uses an intelligent fault detection environmental monitoring system that increases uptime and manageability of the board. The System Management Controller (SMC) module on the Netra CP2300 supports the temperature and voltage environmental monitoring functions. This chapter describes the specific environmental monitoring functions of the Netra CP2300.

This chapter includes the following sections:

• Environmental Monitoring Component Compatibility
• Typical Environmental Monitoring System Application
• Typical Cycle From Power Up to Shutdown
• Hardware Environmental Monitoring Functions
• Adjusting the Environmental Monitoring Warning, Critical, and Shutdown Parameter Settings on the Board
• OpenBoot PROM Environmental Parameters
• OpenBoot PROM Environmental Monitoring
• Environmental Monitoring Application Programming

---

Environmental Monitoring Component Compatibility

TABLE 2-1 lists the compatible environmental monitoring hardware, OpenBoot PROM, and Solaris operating environment for the Netra CP2300.

---

Typical Environmental Monitoring System Application

FIGURE 2-1 illustrates the Netra CP2300 environmental monitoring application block diagram. For locations of the temperature sensors, see FIGURE 2-2 and FIGURE 2-3.

 FIGURE 2-1 Typical Environmental Monitoring Application Block Diagram

The Netra CP2300 functions as a node board in a cPSB system rack. The Netra CP2300 monitors its CPU diode temperature and issues warnings at both the OpenBoot PROM and Solaris operating environment levels when these environmental readings are out of limits. At the Solaris operating environment level, the application program monitors and issues warnings for the board. At the OBP level, the CPU diode temperature is monitored if the NVRAM variable
env-monitor is enabled.

---

Typical Cycle From Power Up to Shutdown

This section describes a typical environmental monitoring cycle from power up to shutdown.

Environmental Monitoring Protection at the OpenBoot PROM

The OpenBoot PROM monitors the CPU diode temperature at the fixed polling rate of 10 seconds and displays warning messages on the default output device whenever the measured temperature exceeds the pre-programmed NVRAM module configurable variable warning temperature (the warning-temperature parameter), the critical temperature (the critical-temperature parameter), or the shutdown temperature (the shutdown-temperature parameter). See OpenBoot PROM Environmental Parameters for information on changing these pre-programmed parameters.

OpenBoot PROM-level protection takes place only when the env-monitor parameter is enabled (it is the default setting). If the NVRAM variable env-monitor is set to enabled-with-shutdown
(env-monitor=enabled-with-shutdown), and if the board temperature exceeds the shutdown temperature, the OpenBoot PROM will shut down power to the Netra CP2300 CPU. If the NVRAM variable env-monitor is set to enabled (env-monitor=enabled), the OpenBoot PROM will send a warning, critical, or shutdown temperature message to the user that the Netra CP2300 is overheating.

Disabling env-monitor completely disables environmental monitoring protection at the OpenBoot PROM level but does not affect environmental monitoring protection at the Solaris operating environment level.

Environmental Monitoring Protection at the Operating Environment Level

Monitoring changes in the sensor temperatures can be a useful tool for determining problems with the room where the system is installed, functional problems with the system, or problems on the board. Establishing baseline temperatures early in deployment and operation could be used to trigger alarms if the temperatures from the sensors increase or decrease dramatically. If all the sensors go to room ambient, power has probably been lost to the host system. If one or more sensors rise in temperature substantially, there may be a system fan malfunction, the system cooling may have been compromised, or room air conditioning may have failed.

Protection at the operating environment level takes place when the PICL environmental monitoring program (envmond) is running. The environmental monitoring program is part of a Unix daemon that runs automatically when Solaris boots up.

In a typical environmental monitoring application program, the software reads the CPU, inlet, and exhaust temperature sensors once every polling cycle. The program then compares the measured CPU diode temperature with the warning temperature and displays a warning message on the default output device whenever the warning temperature is exceeded.

The program can also issue a shutdown message on the default output device whenever the measured CPU diode temperature exceeds the shutdown temperature. In addition, the envmond application program can be programmed to sync and shut down the Solaris operating environment when conditions warrant.

Refer to Sample Application Program for an example of how a simple envmond program can be implemented.

The power module is controlled by the SMC subsystem (except for automatic controls such as overcurrent shutdown or voltage regulation). The functions controlled are core voltage output level and power sequencing/monitor.

Post Shutdown Recovery

The onboard voltage controller is a hardware function that is not controlled by either firmware or software. At the OpenBoot PROM level, if the NVRAM variable env-monitor is set to enabled-with-shutdown (env-monitor=enabled-with-shutdown), and if the board temperature exceeds the shutdown temperature, the OpenBoot PROM will shut down power to the Netra CP2300 CPU.

There is no mechanism for the Solaris operating environment to either recover or restore power to the Netra CP2300 when an unusual condition occurs (for example, if the CPU diode temperature exceeds its maximum recommended level). In either case, the end user must intervene and manually recover the Netra CP2300 as well as the cPSB system through hardware control. Once a shutdown has occurred, you can recover the board using a cold-reset IPMI command to SMC or by extracting and reinserting the board.

---

Hardware Environmental Monitoring Functions

This section summarizes the hardware environmental monitoring features on the Netra CP2300 board. TABLE 2-2 lists the environmental monitoring functions on a Netra CP2300 board.

TABLE 2-3 shows the I²C components.

FIGURE 2-2 and FIGURE 2-3 show the location of the environmental monitoring hardware on the Netra CP2300.

 FIGURE 2-2 Location of Environmental Monitoring Hardware on the Netra CP2300 cPSB Board (Top Side)

 FIGURE 2-3 Location of Environmental Monitoring Hardware on the Netra CP2300 cPSB Board (Bottom Side)

FIGURE 2-4 is a block diagram of the environmental monitoring functions.

 FIGURE 2-4 Netra CP2300 cPSB Board Environmental Monitoring Functional Block Diagram

Power On/Off Switching

The onboard voltage controller allows power to the CPU of the Netra CP2300 only when the following conditions are met:

• The VDD core-1.7-volt supply voltage is greater than 1.53 volts (within 10% of nominal).
• The 12-volt supply voltage is greater than 10.8 volts (within 10% of nominal).
• The 5-volt supply voltage is greater than 4.5 volts (within 10% of nominal)
• The 3.3-volt supply voltage is greater than 3.0 volts (within 10% of nominal).

The controller requires these conditions to be true for at least 100 milliseconds to help ensure the supply voltages are stable. If any of these conditions become untrue, the voltage monitoring circuit shuts down the CPU power of the board.

Inlet, Exhaust, and CPU Temperature Monitoring

The CPU diode sensor reading may vary from slot to slot and from board to board in a system, and is dependent primarily on system cooling. As an example, a system may have sensor readings for the CPU diode from 35°C to 49°C with an ambient inlet of 21°C across many boards, with a variety of configurations and positions within a chassis. Care must be taken when setting the alarm and shutdown temperatures based on the CPU diode sensor value. This sensor typically is linear across the operating range of the board.

The exhaust sensor measures the local air temperature at the trailing edge of the board for systems with bottom to top airflow. This value depends on the character and volume of the airflow across the board. Typical values in a chassis may range from a delta over inlet ambient of 0°C to 12°C, depending on the power dissipation of the board configuration and the position in the chassis. The exhaust sensor is nonlinear with respect to ambient inlet temperature.

The inlet sensor measures the local air temperature at the leading edge of the board on the solder-side under the solder-side cover. This value typically can range from a reading of 0°C to 13°C above inlet system ambient in a chassis; care must be taken to understand the application and installation of the board to use this temperature sensor.

A sudden drop of all temperature sensors close to or near room ambient temperature can mean loss of power to one or more Netra CP2300s.

A gradual increase in the delta temperature from inlet to outlet can be due to dust clogging system filters. This feature can be used to set service levels for filter cleaning or changing.

The CPU diode temperature can be used to prevent damage to the board by shutting the board down if this sensor exceeds predetermined limits.

---

Adjusting the Environmental Monitoring Warning, Critical, and Shutdown Parameter Settings on the Board

The Netra CP2300 uses the environmental monitoring detection system to monitor the temperature of the board. The environmental monitoring system will display messages if the board temperature exceeds the set warning, critical, and shutdown settings. Because the on-board sensors may report different temperature readings for different system configurations and airflows, you may want to adjust the warning, critical, and shutdown temperature parameter settings.

The Netra CP2300 determines the board temperature by retrieving temperature data from sensors located on the board. A board sensor reads the temperature of the immediate area around the sensor. Although the software may appear to report the temperature of a specific hardware component, the software is actually reporting the temperature of the area near the sensor. For example, the CPU diode sensor reads the temperature at the location of the sensor and not on the actual CPU heat sink. The board's OpenBoot PROM collects the temperature readings from each board sensor at regular intervals. You can display these temperature readings using the show-sensors OpenBoot PROM command. See show-sensors Command at OpenBoot PROM.

The temperature read by the CPU sensor will trigger OpenBoot PROM warning, critical, and shutdown messages. When the CPU sensor reads a temperature greater than the warning parameter setting, the OpenBoot PROM will display a warning message. Likewise, when the sensor reads a temperature greater than the shutdown setting, the OpenBoot PROM will display a shutdown message.

Many factors affect the temperature readings of the sensors, including the airflow through the system, the ambient temperature of the room, and the system configuration. These factors may contribute to the sensors reporting different temperature readings than expected.

TABLE 2-4 shows the sensor readings of a Netra CP2300 operating in a Sun server in a room with an ambient temperature of 21°C. The temperature readings were reported using the show-sensors OpenBoot PROM command. Note that the reported temperatures are higher than the ambient room temperature.

Since the temperature reported by the CPU diode sensor might be different than the actual CPU temperature, you may want to adjust the settings for the warning-temperature, critical-temperature, and shutdown-temperature OpenBoot PROM parameters. The default values of these parameters have been conservatively set at 74°C for the warning temperature, 79°C for the critical temperature, and 91°C for the shutdown temperature.

---

OpenBoot PROM Environmental Parameters

This section describes how to change the OpenBoot PROM environmental monitoring parameters. These global OpenBoot PROM parameters do not apply at the Solaris level. Instead, the environmental monitoring application program provides equivalent parameters that do not necessarily have to be set to the same values as their OpenBoot PROM counterparts. Refer to Environmental Monitoring Application Programming for information about using environmental monitoring at the Solaris level. The OpenBoot PROM polling rate is at fixed intervals of 10 seconds.

OpenBoot PROM Warning Temperature Parameter

OBP programs SMC for temperature monitoring using the sensor commands. On a Netra CP2300, there are three NVRAM variables that provide different temperature levels. The critical-temperature limit lies between warning and shutdown thresholds. The default values of these temperature thresholds and corresponding action are shown in TABLE 2-5.

Note that there is a lower limit of 50° C on shutdown-temperature value. If you try to set the temperature to a value lower than 50° C, OpenBoot PROM will not accept it. This safeguards a user from setting the shutdown-temperature lower than the room temperature and thereby causing the CPU processor and the Netra CP2300 to be powered off by SMC on the next reset.

The warning-temperature global OpenBoot PROM parameter determines the temperature at which a warning is displayed. The shutdown-temperature global OpenBoot PROM parameter determines the temperature at which the system is shut down. The temperature monitoring environment variables can be modified at the OpenBoot PROM command level as shown in examples below:

ok setenv warning-temperature 75

or:

ok setenv shutdown-temperature 90

The critical-temperature is a second-level warning temperature with a default value of 79° C. This variable can be modified using the OpenBoot PROM level setenv command as shown in example below:

ok setenv critical-temperature 80

---

OpenBoot PROM Environmental Monitoring

This section describes the OpenBoot PROM environmental monitoring functions.

CPU Monitoring

The following NVRAM module environmental monitoring variables are in OpenBoot PROM.

• NVRAM module variable name: env-monitor
• Function: enables or disables environment monitoring at OpenBoot PROM
• Data type: string
• Valid values: disabled or enabled
• Default value: enabled
• OpenBoot PROM Usage:

ok setenv env-monitor disabled or enabled

• NVRAM module variable name: warning-temperature
• Function: sets the CPU warning temperature threshold
• Data type: byte
• Unit: decimal
• Default value:74
• OpenBoot PROM Usage:

ok setenv warning-temperature temperature-value

• NVRAM module variable name: critical-temperature
• Function: sets the CPU critical temperature threshold
• Data type: byte
• Unit: decimal
• Default value: 79
• OpenBoot PROM Usage:

ok setenv critical-temperature temperature-value

• NVRAM module variable name: shutdown-temperature
• Function: sets the CPU shutdown temperature threshold
• Data type: byte
• Unit: decimal
• Default value: 91
• OpenBoot PROM Usage:

ok setenv shutdown-temperature temperature-value

Caution - Exercise caution while setting the above two parameters. Setting these values too high will leave the system unprotected against system over-heat. Setting these values too low will power down the system in an unpredictable manner.

Warning Temperature Response at OpenBoot PROM

When the CPU diode temperature reaches "warning-temperature," a similar message is displayed at the ok prompt at a regular interval:

Temperature sensor #2 has threshold event of

<<< WARNING!!! Upper Non-critical - going high >>>

The current threshold setting is : 74

The current temperature is : 75

Critical Temperature Response at OpenBoot PROM

When the CPU diode temperature reaches "critical-temperature," a similar message is displayed at the ok prompt at a regular interval:

Temperature sensor #2 has threshold event of

<<< !!! ALERT!!! Upper Critical - going high >>>

The current threshold setting is : 79

The current temperature is : 80

show-sensors Command at OpenBoot PROM

The show-sensors command at OpenBoot PROM displays the readings of all the temperature sensors on the board. A sample output for typical sensor readings for a Netra CP2300 is as follows:

ok show-sensors

Sensor#    Sensor Name                           Sensor Reading

=======    ====================================  ===================

   1       EP 5v                     Sensor      (d7)  5.112 volts

   2       EP 3.3v                   Sensor      (8e)  3.408 volts

   3       BP +12v                   Sensor      (d3)  12.048 volts

   4       BP -12v                   Sensor      (62)  -12.020 volts

   5       IPMB Power                Sensor      (d7)  5.088 volts

   6       SMC Power                 Sensor      (d7)  5.088 volts

   7       VDD 3.3v                  Sensor      (ac)  3.3368 volts

   8       VCCP                      Sensor      (90)  1.6992 volts

   9       +12v                      Sensor      (c2)  12.1250 volts

   a       -12v                      Sensor      (37)  -11.968 volts

   b       +5v                       Sensor      (c4)  5.096 volts

   c       Standby 3.3v              Sensor      (bf)  3.2852 volts

   d       Main 3.3v                 Sensor      (bf)  3.2852 volts

   e       External I  temp (CPU)    Sensor      (29)  41 degree C

   f       External II temp (Outlet) Sensor      (1b)  31 degree C

  10       Internal    temp (Inlet)  Sensor      (1b)  29 degree C

Verifying Access to EEPROMs :

IPMI FRU EEPROM (EEPROM id 00) : Passed

SUN FRU EEPROM  (EEPROM id 20) : Passed

FRU EEPROM      (EEPROM id 21) : Passed

ADM chip EEPROM (EEPROM id 22) : Passed

ok 

IPMI Command Examples at OpenBoot PROM

The Intelligent Platform Management Interface (IPMI) commands can be used to enable the sensors monitoring and subsequent event generation from other boards in the system.

The IPMI command examples provided in this section are based on the IPMI Specification Version 1.0. Please use the IPMI Specification for additional information on how to implement these IPMI commands.

The command execute-smc-cmd is available in SMC controller device mode
(/pci@1f,0/pci@1,1/isa@7/sysmgmt@0,8010 alias hsc). You need to go to the sysmgmt node before executing the command execute-smc-cmd using the following:

ok dev hsc

1. Set the thresholds for the sensors.

See Set Sensor Threshold. If no threshold is set, the default threshold operates:

ok packet bytes number-of-bytes-in-packet 34 execute-smc-cmd

2. Follow instructions in Check Whether the IPMI Commands Are Executed Properly to check proper execution of the command.

1. To execute a command to enable events from the sensor, type:

ok packet bytes number-of-bytes-in-packet 34 execute-smc-cmd

See Set Sensor Event Enable Command and Get Sensor Event Enable.

There are supporting commands for any sensor and the corresponding packets at these commands: get sensor threshold, get sensor reading, and get sensor event enable.

2. Follow instructions in Check Whether the IPMI Commands Are Executed Properly to check proper execution of the command.

1. Check whether the stack on the ok prompt displays 0 when the command is issued.

A 0 indicates that the command packet sent to the board was successful.

2. Type execute-smc-cmd (cmd 33) command at the ok prompt as follows:

ok 0 33 execute-smc-cmd

This command verifies that the target satellite board received and executed the command and sent a response.

3. Check the completion code which is the seventh byte from left.

If the completion code is 0, then the target board successfully executed the command. Otherwise the command was not successfully executed by the board.

4. Check that rsSA and rqSA are swapped in the response packet.

The rsSA is the responder slave address and the rqSA is the requestor slave address.

5. (Optional) If command not correctly executed, resend the IPMI command.

Examples of IPMI Command Packets

The following packets are IPMI command packets that can be sent from the OpenBoot PROM ok prompt:

Set Sensor Threshold

A typical example of the sensor command is as follows:

37 0 41 10 0 0 3 1b 0 26 12 20 34 12 ba 0 10 34 execute-smc-cmd

Get Sensor Threshold

A typical example of the sensor command is as follows

a5 0 27 12 20 34 12 ba 0 9 34 execute-smc-cmd

Get Sensor Reading

A typical example of the sensor command is as follows:

93 e 2d 12 20 34 12 ba 0 9 34 execute-smc-cmd

Set Sensor Event Enable Command

A typical example of the sensor command is as follows:

24 0 0 0 0 80 2 28 12 20 34 12 ba 0 e 34 execute-smc-cmd

Get Sensor Event Enable

A typical example of the sensor command is as follows:

a3 2 29 12 20 34 12 ba 0 9 34 execute-smc-cmd

---

Environmental Monitoring Application Programming

The following sections describe how to use the environmental monitoring functions in an application program.

For the environmental monitoring application program (envmond) to monitor the hardware environment, the following conditions must be met:

• The system controller device driver must be installed.
• The environmental monitoring application program (envmond) must be installed and running.

The environmental monitoring parameter values in the application program apply when the system is running at the Solaris level and do not necessarily have to be the same as the corresponding to the parameter settings in the OpenBoot PROM.

To change the environmental monitoring parameter setting at the OpenBoot PROM level, see OpenBoot PROM Environmental Parameters for the procedure. The OpenBoot PROM environmental monitoring parameter values only apply when the system is running at the OpenBoot PROM level.

Reading Temperature Sensor States Using the PICL API

Temperature sensor states may be read using the libpicl API. The following properties are supported in a PICL temperature sensor class node:

The PICL plug-in receives these sensor events and updates the State property based on the information extracted from the IPMI message. It then posts a PICL event.

Threshold levels of the PICL node class temperature sensor are:

• Warning
• Critical
• Shutdown

To obtain a reading of temperature sensor states, use the prtpicl -v command:

# prtpicl -c temperature-sensor -v

PICL output of temperature sensors on a Netra CT system is shown in CODE EXAMPLE 2-1.

# prtpicl -c temperature-sensor -v

 CPU-sensor (temperature-sensor, 450000039e)

            :State         ok 

            :LowPowerOffThreshold  -20 

            :HighWarningThreshold  74 

            :HighShutdownThreshold         79 

            :HighPowerOffThreshold         91 

            :LowWarningThreshold   -10

            :LowShutdownThreshold  -13 

            :Temperature            59 

            :GeoAddr       0xe  

            :Label         Ambient 

            :_class        temperature-sensor 

            :name          CPU-sensor

Solaris Driver Interface

The PICL envmond plug-in opens a SMC driver stream and requests sensor events. The SMC monitors the sensors and generates an event when it detects a change at a particular sensor which meets one of the specified thresholds and generates an event to local Solaris software. This event is captured by the SMC driver (as an IPMI message) and is sent on an open STREAM that has requested sensor events. The sensor events are received by the PICL plug-in. The PICL plug-in updates the State property based on the information it extracts from the IPMI message and posts a PICL event.

Sample Application Program

This section presents a sample environmental monitoring (envmond) application that monitors the CPU diode temperature.

/*

 * sensor_readwrite.c

 *

 * compile: cc sensor_readwrite.c -lthread -lpicl -o sensor_readwrite

 */

#include <stdio.h>

#include <picl.h>

#define HI_POWEROFF_THRESHOLD   "HighPowerOffThreshold"

#define HI_SHUTDOWN_THRESHOLD   "HighShutdownThreshold"

#define HI_WARNING_THRESHOLD    "HighWarningThreshold"

#define LO_POWEROFF_THRESHOLD   "LowPowerOffThreshold"

#define LO_SHUTDOWN_THRESHOLD   "LowShutdownThreshold"

#define LO_WARNING_THRESHOLD    "LowWarningThreshold"

#define CURRENT_TEMPERATURE     "Temperature"

static int

get_child_by_name(picl_nodehdl_t nodeh, char *name, picl_nodehdl_t *resulth)

{

        picl_nodehdl_t  childh;

        picl_nodehdl_t  nexth;

        char            propname[PICL_PROPNAMELEN_MAX];

        picl_errno_t    rc;

        /* look up first child node */

        rc = picl_get_propval_by_name(nodeh, PICL_PROP_CHILD, &childh,

                                        sizeof (picl_nodehdl_t));

        if (rc != PICL_SUCCESS) {

                return (rc);

        }

        /* step through child nodes looking for named node */

        while (rc == PICL_SUCCESS) {

                rc = picl_get_propval_by_name(childh, PICL_PROP_NAME,

                                                propname, sizeof (propname));

                if (rc != PICL_SUCCESS) {

                        return (rc);

                }

                if (name && strcmp(propname, name) == 0) {

                        /* yes - got it */

                        *resulth = childh;

                        return (PICL_SUCCESS);

                }

                if (get_child_by_name(childh, name, resulth) == PICL_SUCCESS) {

                        return (PICL_SUCCESS);

                }

                /* get next child node */

                rc = picl_get_propval_by_name(childh, PICL_PROP_PEER,

                                        &nexth, sizeof (picl_nodehdl_t));

                if (rc != PICL_SUCCESS) {

                        return (rc);

                }

                childh = nexth;

        }

        return (rc);

}

void

get_sensor_thresholds(picl_nodehdl_t nodeh)

{

        int8_t  threshold;

        if (picl_get_propval_by_name(nodeh, HI_POWEROFF_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read high power-off threshold.");

        } else

                fprintf(stdout, "High power-off threshold = %d\n", threshold);

        if (picl_get_propval_by_name(nodeh, HI_SHUTDOWN_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read high shutdown threshold.");

        } else

                fprintf(stdout, "High shutdown threshold = %d\n", threshold);

        if (picl_get_propval_by_name(nodeh, HI_WARNING_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read high warning threshold.");

        } else

                fprintf(stdout, "High warning threshold = %d\n", threshold);

        if (picl_get_propval_by_name(nodeh, LO_POWEROFF_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read low power-off threshold.");

        } else

                fprintf(stdout, "Low shutdown threshold = %d\n", threshold);

        if (picl_get_propval_by_name(nodeh, LO_SHUTDOWN_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read low shutdown threshold.");

        } else

                fprintf(stdout, "Low shutdown threshold = %d\n", threshold);

        if (picl_get_propval_by_name(nodeh, LO_WARNING_THRESHOLD,

                &threshold, sizeof (threshold)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read low warning threshold.");

        } else

                fprintf(stderr, "Low warning threshold = %d\n", threshold);

}

void

set_sensor_thresholds(picl_nodehdl_t nodeh, char *threshold, int8_t value)

{

        int8_t  new_value = value;

        if (picl_set_propval_by_name(nodeh, threshold, &new_value,

                                sizeof (new_value)) != PICL_SUCCESS)

                fprintf(stderr, "Failed to set *s\n", threshold);

}

int

main(void)

{

        int     warning_temp;

        int8_t  temp;

        char    *sensor = "CPU-sensor";

        picl_nodehdl_t  rooth;

        picl_nodehdl_t  platformh;

        picl_nodehdl_t  childh;

        if (picl_initialize() != PICL_SUCCESS) {

                fprintf(stderr, "Failed to initialise picl\n");

                return (1);

        }

        if (picl_get_root(&rooth) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to get root node\n");

                picl_shutdown();

                return (1);

        }

        if (get_child_by_name(rooth, "platform", &platformh) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to get platform node\n");

                picl_shutdown();

                return (1);

        }

        if (get_child_by_name(platformh, sensor, &childh) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to get %s sensor.", sensor);

                picl_shutdown();

                return (1);

        }

        get_sensor_thresholds(childh);

        /* Read current sensor temperature */

        if (picl_get_propval_by_name(childh, CURRENT_TEMPERATURE,

                &temp, sizeof (temp)) != PICL_SUCCESS) {

                fprintf(stderr, "Failed to read current temperature\n");

        } else

                fprintf(stdout, "Current temperature = %d\n", temp);

        set_sensor_threshold(childh, HI_WARNING_THRESHOLD, temp+5);

        picl_shutdown();

        return (0);

 }

Reading the CPU Temperature and OpenBoot PROM Temperature Limits

You can access the CPU temperature sensor current readings and environmental monitoring settings from the Solaris prompt by typing the following commands. Sample output is listed after each command.

prtpicl command example:

# prtpicl -v -c temperature-sensor

CPU-sensor (temperature-sensor, 36000005ce)

  :State         ok 

  :HighWarningThreshold   74

  :HighShutdownThreshold  79

  :HighPowerOffThreshold  91

  :LowWarningThreshold   -10

  :LowShutdownThreshold  -13 

  :LowPowerOffThreshold  -20 

  :Temperature   53 

  :GeoAddr       0xe 

  :Label         Ambient 

  :_class        temperature-sensor 

  :name  CPU-sensor 

prtdiag command example:

# prtdiag -v

CPU Node Temperature Information

--------------------------------

Temperature Reading: 53

Critical Threshold Information

------------------------------

High Power-Off Threshold           91

High Shutdown Threshold            79

High Warning Threshold             74

Low Power Off Threshold           -20

Low Shutdown Threshold            -13

Low Warning Threshold             -10

eeprom command example:

# eeprom | grep temp

shutdown-temperature=91

critical-temperature=79

warning-temperature=74

TABLE 2-7 shows which Solaris commands correspond to the environmental monitoring warning that runs when the CPU temperature exceeds the set limit.

Netra CP2300 cPSB Board Programming Guide

817-1331-12

Copyright © 2004, Sun Microsystems, Inc. All rights reserved.