/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This file contains the environmental PICL plug-in module.
*/
/*
* This plugin sets up the PICLTREE for Enchilada WS.
* It provides functionality to get/set temperatures and
* fan speeds.
*
* The environmental policy defaults to the auto mode
* as programmed by OBP at boot time.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysmacros.h>
#include <limits.h>
#include <string.h>
#include <strings.h>
#include <stdarg.h>
#include <alloca.h>
#include <unistd.h>
#include <sys/processor.h>
#include <syslog.h>
#include <errno.h>
#include <fcntl.h>
#include <picl.h>
#include <picltree.h>
#include <picldefs.h>
#include <pthread.h>
#include <signal.h>
#include <libdevinfo.h>
#include <sys/pm.h>
#include <sys/open.h>
#include <sys/time.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <note.h>
#include <sys/i2c/clients/i2c_client.h>
#include <sys/i2c/clients/adm1031.h>
#include <sys/i2c/clients/pic16f819_reg.h>
#include "envd.h"
#include <sys/scsi/scsi.h>
#include <sys/scsi/generic/commands.h>
/*
* PICL plugin entry points
*/
static void piclenvd_register(void);
static void piclenvd_init(void);
static void piclenvd_fini(void);
/*
* Env setup routines
*/
extern void env_picl_setup(void);
extern void env_picl_destroy(void);
extern int env_picl_setup_tuneables(void);
/*
* Sleep routine used for polling
*/
static int get_dimm_fan_speed(int, fanspeed_t *);
static int is_dimm_fan_failed(void);
#pragma init(piclenvd_register)
/*
* Plugin registration information
*/
static picld_plugin_reg_t my_reg_info = {
PICLD_PLUGIN_VERSION,
PICLD_PLUGIN_CRITICAL,
"SUNW_piclenvd",
piclenvd_init,
piclenvd_fini,
};
#define REGISTER_INFORMATION_STRING_LENGTH 16
static char dimm_fan_rpm_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_status_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_command_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static char dimm_fan_debug_string[REGISTER_INFORMATION_STRING_LENGTH] = {0};
static int scsi_log_sense(int fd, uchar_t page_code, uchar_t *pagebuf,
uint16_t pagelen);
static int get_disk_temp(env_disk_t *);
/*
* ES Segment data structures
*/
static sensor_ctrl_blk_t sensor_ctrl[MAX_SENSORS];
static fan_ctrl_blk_t fan_ctrl[MAX_FANS];
static fruenvseg_t *envfru = NULL;
/*
* Env thread variables
*/
static boolean_t system_shutdown_started = B_FALSE;
static boolean_t ovtemp_thr1_created = B_FALSE;
static pthread_t ovtemp_thr1_id;
static pthread_attr_t thr_attr;
static boolean_t ovtemp_thr2_created = B_FALSE;
static pthread_t ovtemp_thr2_id;
static boolean_t dimm_fan_thr_created = B_FALSE;
static pthread_t dimm_fan_thr_id;
static boolean_t disk_temp_thr_created = B_FALSE;
static pthread_t disk_temp_thr_id;
/*
* PM thread related variables
*/
static pthread_t pmthr_tid; /* pmthr thread ID */
static int pm_fd = -1; /* PM device file descriptor */
static boolean_t pmthr_created = B_FALSE;
static int cur_lpstate; /* cur low power state */
/*
* Envd plug-in verbose flag set by SUNW_PICLENVD_DEBUG environment var
* Setting the verbose tuneable also enables debugging for better
* control
*/
int env_debug = 0;
/*
* Fan devices
*/
static env_fan_t envd_sys_out_fan = {
ENV_SYSTEM_OUT_FAN, ENV_SYSTEM_OUT_FAN_DEVFS, NULL,
SYSTEM_OUT_FAN_ID, SYSTEM_OUT_FAN_SPEED_MIN, SYSTEM_OUT_FAN_SPEED_MAX,
-1, -1,
};
static env_fan_t envd_sys_in_fan = {
ENV_SYSTEM_INTAKE_FAN, ENV_SYSTEM_INTAKE_FAN_DEVFS, NULL,
SYSTEM_INTAKE_FAN_ID, SYSTEM_INTAKE_FAN_SPEED_MIN,
SYSTEM_INTAKE_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_cpu0_fan = {
ENV_CPU0_FAN, ENV_CPU0_FAN_DEVFS, NULL,
CPU0_FAN_ID, CPU_FAN_SPEED_MIN, CPU_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_cpu1_fan = {
ENV_CPU1_FAN, ENV_CPU1_FAN_DEVFS, NULL,
CPU1_FAN_ID, CPU_FAN_SPEED_MIN, CPU_FAN_SPEED_MAX, -1, -1,
};
static env_fan_t envd_dimm_fan = {
ENV_DIMM_FAN, ENV_DIMM_FAN_DEVFS, NULL,
DIMM_FAN_ID, 100, 100, -1, -1,
};
static env_disk_t envd_disk0 = {
ENV_DISK0, ENV_DISK0_DEVFS, DISK0_PHYSPATH, DISK0_NODE_PATH,
DISK0_ID, -1, -1,
};
static env_disk_t envd_disk1 = {
ENV_DISK1, ENV_DISK1_DEVFS, DISK1_PHYSPATH, DISK1_NODE_PATH,
DISK1_ID, -1, -1,
};
/*
* The vendor-id and device-id are the properties associated with
* the SCSI controller. This is used to identify a particular controller
* like LSI1030.
*/
#define VENDOR_ID "vendor-id"
#define DEVICE_ID "device-id"
/*
* The implementation for SCSI disk drives to supply info. about
* temperature is not mandatory. Hence we first determine if the
* temperature page is supported. To do this we need to scan the list
* of pages supported.
*/
#define SUPPORTED_LPAGES 0
#define TEMPERATURE_PAGE 0x0D
#define LOGPAGEHDRSIZE 4
/*
* NULL terminated array of fans
*/
static env_fan_t *envd_fans[] = {
&envd_cpu0_fan,
&envd_cpu1_fan,
&envd_sys_out_fan,
&envd_sys_in_fan,
&envd_dimm_fan,
NULL
};
static env_disk_t *envd_disks[] = {
&envd_disk0,
&envd_disk1,
NULL
};
/*
* ADM1031 speedrange map is indexed by a 2-bit value
*/
static int adm_speedrange_map[] = {1, 2, 4, 8};
/*
* ADM1031 devices
*/
static char *hwm_devs[] = {
CPU_HWM_DEVFS, /* CPU_HWM_ID */
SYS_HWM_DEVFS /* SYS_HWM_ID */
};
/*
* Fan names associated with each ADM1031 hwms - used to
* print fault messages.
*/
static char *hwm_fans[MAX_HWMS][2] = {
{ENV_CPU0_FAN, ENV_CPU1_FAN},
{ENV_SYSTEM_INTAKE_FAN, ENV_SYSTEM_OUT_FAN}
};
/*
* Temperature sensors
*/
static env_sensor_t envd_sensors[] = {
{ SENSOR_CPU0_DIE, SENSOR_CPU0_DIE_DEVFS, NULL,
CPU0_SENSOR_ID, CPU_HWM_ID, (void *)&envd_cpu0_fan, -1},
{ SENSOR_CPU1_DIE, SENSOR_CPU1_DIE_DEVFS, NULL,
CPU1_SENSOR_ID, CPU_HWM_ID, (void *)&envd_cpu1_fan, -1},
{ SENSOR_INT_AMB_0, SENSOR_INT_AMB_0_DEVFS, NULL,
INT_AMB0_SENSOR_ID, CPU_HWM_ID, NULL, -1},
{ SENSOR_SYS_OUT, SENSOR_SYS_OUT_DEVFS, NULL,
SYS_OUT_SENSOR_ID, SYS_HWM_ID, (void *)&envd_sys_out_fan, -1},
{ SENSOR_INT_AMB_1, SENSOR_INT_AMB_1_DEVFS, NULL,
INT_AMB1_SENSOR_ID, SYS_HWM_ID, NULL, -1},
{ SENSOR_SYS_IN, SENSOR_SYS_IN_DEVFS, NULL,
SYS_IN_SENSOR_ID, SYS_HWM_ID, (void *)&envd_sys_in_fan, -1},
};
#define N_ENVD_SENSORS (sizeof (envd_sensors)/sizeof (envd_sensors[0]))
#define NOT_AVAILABLE "NA"
/*
* ADM1031 macros
*/
#define TACH_UNKNOWN 255
#define FAN_OUT_OF_RANGE (TACH_UNKNOWN)
#define ADM_HYSTERISIS 5
#define N_SEQ_TACH 15
#define TMIN_MASK (0xF8)
#define TMIN_SHIFT (3)
#define TMIN_UNITS (4) /* increments of 4 degrees celsius */
#define TRANGE_MASK (0x7)
#define TMIN(regval) (((regval & TMIN_MASK) >> TMIN_SHIFT) * TMIN_UNITS)
#define TRANGE(regval) (regval & TRANGE_MASK)
#define GET_TMIN_RANGE(tmin, trange) \
((((tmin / TMIN_UNITS) & TMIN_MASK) << TMIN_SHIFT) | \
(trange & TRANGE_MASK))
#define TACH_ENABLE_MASK (0x0C)
#define ADM_SETFANSPEED_CONV(speed) (15 * speed / 100)
/*
* Tuneables
*/
#define ENABLE 1
#define DISABLE 0
int monitor_disk_temp = 1; /* enabled */
static int disk_high_warn_temperature = DISK_HIGH_WARN_TEMPERATURE;
static int disk_low_warn_temperature = DISK_LOW_WARN_TEMPERATURE;
static int disk_high_shutdown_temperature =
DISK_HIGH_SHUTDOWN_TEMPERATURE;
static int disk_low_shutdown_temperature = DISK_LOW_SHUTDOWN_TEMPERATURE;
static int disk_scan_interval = DISK_SCAN_INTERVAL;
static int get_monitor_cpu_mode(ptree_rarg_t *parg, void *buf);
static int set_monitor_cpu_mode(ptree_warg_t *parg, const void *buf);
static int get_monitor_sys_mode(ptree_rarg_t *parg, void *buf);
static int set_monitor_sys_mode(ptree_warg_t *parg, const void *buf);
static int get_int_val(ptree_rarg_t *parg, void *buf);
static int set_int_val(ptree_warg_t *parg, const void *buf);
static int get_string_val(ptree_rarg_t *parg, void *buf);
static int set_string_val(ptree_warg_t *parg, const void *buf);
static int get_cpu_tach(ptree_rarg_t *parg, void *buf);
static int set_cpu_tach(ptree_warg_t *parg, const void *buf);
static int get_sys_tach(ptree_rarg_t *parg, void *buf);
static int set_sys_tach(ptree_warg_t *parg, const void *buf);
static int shutdown_override = 0;
static int sensor_poll_interval = SENSORPOLL_INTERVAL;
static int warning_interval = WARNING_INTERVAL;
static int disk_warning_interval = DISK_WARNING_INTERVAL;
static int disk_warning_duration = DISK_WARNING_DURATION;
static int shutdown_interval = SHUTDOWN_INTERVAL;
static int disk_shutdown_interval = DISK_SHUTDOWN_INTERVAL;
static int ovtemp_monitor = 1; /* enabled */
static int pm_monitor = 1; /* enabled */
static int mon_fanstat = 1; /* enabled */
static int cpu_mode;
static int sys_mode;
static int cpu_tach;
static int sys_tach;
static char shutdown_cmd[] = SHUTDOWN_CMD;
env_tuneable_t tuneables[] = {
{"ovtemp-monitor", PICL_PTYPE_INT, &ovtemp_monitor,
&get_int_val, &set_int_val, sizeof (int)},
{"pm-monitor", PICL_PTYPE_INT, &pm_monitor,
&get_int_val, &set_int_val, sizeof (int)},
{"shutdown-override", PICL_PTYPE_INT, &shutdown_override,
&get_int_val, &set_int_val, sizeof (int)},
{"cpu-hm-automode-enable", PICL_PTYPE_INT, &cpu_mode,
&get_monitor_cpu_mode, &set_monitor_cpu_mode,
sizeof (int)},
{"sys-hm-automode-enable", PICL_PTYPE_INT, &sys_mode,
&get_monitor_sys_mode, &set_monitor_sys_mode,
sizeof (int)},
{"sensor-poll-interval", PICL_PTYPE_INT,
&sensor_poll_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"disk-scan-interval", PICL_PTYPE_INT,
&disk_scan_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"warning-interval", PICL_PTYPE_INT, &warning_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"shutdown-interval", PICL_PTYPE_INT, &shutdown_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"disk_warning-interval", PICL_PTYPE_INT, &disk_warning_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"disk_warning-duration", PICL_PTYPE_INT, &disk_warning_duration,
&get_int_val, &set_int_val,
sizeof (int)},
{"disk_shutdown-interval", PICL_PTYPE_INT, &disk_shutdown_interval,
&get_int_val, &set_int_val,
sizeof (int)},
{"shutdown-command", PICL_PTYPE_CHARSTRING, shutdown_cmd,
&get_string_val, &set_string_val,
sizeof (shutdown_cmd)},
{"cpu-tach-enable", PICL_PTYPE_INT, &cpu_tach,
&get_cpu_tach, &set_cpu_tach,
sizeof (int)},
{"sys-tach-enable", PICL_PTYPE_INT, &sys_tach,
&get_sys_tach, &set_sys_tach,
sizeof (int)},
{"monitor-fanstat", PICL_PTYPE_INT, &mon_fanstat,
&get_int_val, &set_int_val, sizeof (int)},
{"monitor-disk-temp", PICL_PTYPE_INT, &monitor_disk_temp,
&get_int_val, &set_int_val, sizeof (int)},
{"disk-high-warn-temperature", PICL_PTYPE_INT,
&disk_high_warn_temperature, &get_int_val,
&set_int_val, sizeof (int)},
{"disk-low-warn-temperature", PICL_PTYPE_INT,
&disk_low_warn_temperature, &get_int_val,
&set_int_val, sizeof (int)},
{"disk-high-shutdown-temperature", PICL_PTYPE_INT,
&disk_high_shutdown_temperature, &get_int_val,
&set_int_val, sizeof (int)},
{"disk-low-shutdown-temperature", PICL_PTYPE_INT,
&disk_low_shutdown_temperature, &get_int_val,
&set_int_val, sizeof (int)},
{"verbose", PICL_PTYPE_INT, &env_debug,
&get_int_val, &set_int_val, sizeof (int)},
};
/*
* We use this to figure out how many tuneables there are
* This is variable because the publishing routine needs this info
* in piclenvsetup.c
*/
int ntuneables = (sizeof (tuneables)/sizeof (tuneables[0]));
/*
* Table Handling Code
*/
static void
fini_table(table_t *tblp)
{
if (tblp == NULL)
return;
free(tblp->xymap);
free(tblp);
}
static table_t *
init_table(int npoints)
{
table_t *tblp;
point_t *xy;
if (npoints == 0)
return (NULL);
if ((tblp = malloc(sizeof (*tblp))) == NULL)
return (NULL);
if ((xy = malloc(sizeof (*xy) * npoints)) == NULL) {
free(tblp);
return (NULL);
}
tblp->nentries = npoints;
tblp->xymap = xy;
return (tblp);
}
/*
* function: calculates y for a given x based on a table of points
* for monotonically increasing x values.
* 'tbl' specifies the table to use, 'val' specifies the 'x', returns 'y'
*/
static int
y_of_x(table_t *tbl, int xval)
{
int i;
int entries;
point_t *xymap;
float newval;
float dy, dx, slope;
entries = tbl->nentries;
xymap = tbl->xymap;
/*
* If the temperature is outside the correction table
* then simply return the original value.
*/
if ((xval < xymap[0].x) || (xval > xymap[entries - 1].x))
return (xval);
if (xval == xymap[0].x)
return (xymap[0].y);
if (xval == xymap[entries - 1].x)
return (xymap[entries - 1].y);
for (i = 1; i < entries - 1; i++) {
if (xval == xymap[i].x)
return (xymap[i].y);
if (xval < xymap[i].x)
break;
}
/*
* Use linear interpolation
*/
dy = (float)(xymap[i].y - xymap[i-1].y);
dx = (float)(xymap[i].x - xymap[i-1].x);
slope = dy/dx;
newval = xymap[i - 1].y + slope * (xval - xymap[i - 1].x);
return ((int)(newval + (newval >= 0 ? 0.5 : -0.5)));
}
/*
* Get environmental segment from the specified FRU SEEPROM
*/
static int
get_envseg(int fd, void **envsegp, int *envseglenp)
{
int i, segcnt, envseglen;
section_layout_t section;
segment_layout_t segment;
uint8_t *envseg;
if (lseek(fd, (long)SECTION_HDR_OFFSET, 0) == -1L ||
read(fd, &section, sizeof (section)) != sizeof (section)) {
return (EINVAL);
}
/*
* Verify we have the correct section and contents are valid
* For now, we don't verify the CRC.
*/
if (section.header_tag != SECTION_HDR_TAG ||
GET_UNALIGN16(&section.header_version[0]) != SECTION_HDR_VER) {
if (env_debug)
envd_log(LOG_INFO,
"Invalid section header tag:%x version:%x\n",
section.header_tag,
GET_UNALIGN16(&section.header_version));
return (EINVAL);
}
/*
* Locate our environmental segment
*/
segcnt = section.segment_count;
for (i = 0; i < segcnt; i++) {
if (read(fd, &segment, sizeof (segment)) != sizeof (segment)) {
return (EINVAL);
}
if (env_debug)
envd_log(LOG_INFO,
"Seg name: %x desc:%x off:%x len:%x\n",
GET_UNALIGN16(&segment.name),
GET_UNALIGN32(&segment.descriptor[0]),
GET_UNALIGN16(&segment.offset),
GET_UNALIGN16(&segment.length));
if (GET_UNALIGN16(&segment.name) == ENVSEG_NAME)
break;
}
if (i >= segcnt) {
return (ENOENT);
}
/*
* Allocate memory to hold the environmental segment data.
*/
envseglen = GET_UNALIGN16(&segment.length);
if ((envseg = malloc(envseglen)) == NULL) {
return (ENOMEM);
}
if (lseek(fd, (long)GET_UNALIGN16(&segment.offset), 0) == -1L ||
read(fd, envseg, envseglen) != envseglen) {
(void) free(envseg);
return (EIO);
}
*envsegp = envseg;
*envseglenp = envseglen;
return (0);
}
/*
* Get all environmental segments
* Return NULL on error
*/
static fruenvseg_t *
get_fru_envsegs(void)
{
fruenvseg_t *fruenvsegs;
envseg_layout_t *envsegp;
void *envsegbufp;
int fd, envseglen, hdrlen;
char path[PATH_MAX];
fruenvsegs = NULL;
fruenvsegs = malloc(sizeof (*fruenvsegs));
if (fruenvsegs == NULL) {
return (NULL);
}
/*
* Now get the environmental segment from this FRU
*/
(void) snprintf(path, sizeof (path), "%s%s", I2C_DEVFS, MBFRU_DEV);
fd = open(path, O_RDONLY);
if (fd == -1) {
envd_log(LOG_ERR, ENV_FRU_OPEN_FAIL, errno, path);
free(fruenvsegs);
return (NULL);
}
/*
* Read environmental segment from this FRU SEEPROM
*/
if (get_envseg(fd, &envsegbufp, &envseglen) != 0) {
envd_log(LOG_ERR, ENV_FRU_BAD_ENVSEG, path);
free(fruenvsegs);
(void) close(fd);
return (NULL);
}
/*
* Validate envseg version number and header length
*/
envsegp = (envseg_layout_t *)envsegbufp;
hdrlen = sizeof (envseg_layout_t) -
sizeof (envseg_sensor_t) +
(envsegp->sensor_count) * sizeof (envseg_sensor_t);
if (envsegp->version != ENVSEG_VERSION ||
envseglen < hdrlen) {
/*
* version mismatch or header not big enough
*/
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
if (envsegbufp != NULL)
(void) free(envsegbufp);
free(fruenvsegs);
(void) close(fd);
return (NULL);
}
fruenvsegs->envseglen = envseglen;
fruenvsegs->envsegbufp = envsegbufp;
(void) close(fd);
return (fruenvsegs);
}
static int
process_fru_seeprom(unsigned char *buff)
{
id_off_t id;
int i;
int id_offset = 0;
int nsensors;
int nfans;
env_fan_t *fnodep;
env_sensor_t *snodep;
#define NSENSOR_OFFSET 1
#define ID_OFF_SIZE 6
#define NFANS_OFFSET(x) ((x * ID_OFF_SIZE) + 2)
nsensors = (int)buff[NSENSOR_OFFSET];
if (nsensors != MAX_SENSORS) {
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
return (-1);
}
nfans = (int)buff[NFANS_OFFSET(nsensors)];
if (nfans != MAX_FANS) {
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
return (-1);
}
while (nsensors > 0) {
(void) memcpy((char *)&id,
(char *)&buff[id_offset + 2],
ID_OFF_SIZE);
if (env_debug)
envd_log(LOG_ERR, "\n Sensor Id %x offset %x",
id.id, id.offset);
if (id.id > MAX_SENSOR_ID) {
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
FRU_SEEPROM_NAME);
return (-1);
}
/*
* Copy into the sensor control block array according to the
* sensor ID
*/
(void) memcpy((char *)&sensor_ctrl[id.id],
(char *)&buff[id.offset],
sizeof (sensor_ctrl_blk_t));
nsensors--;
id_offset += ID_OFF_SIZE;
}
/*
* Skip past no of Fan entry(single byte)
*/
id_offset++;
while (nfans > 0) {
(void) memcpy((char *)&id, (char *)&buff[id_offset + 2],
ID_OFF_SIZE);
if (env_debug)
envd_log(LOG_ERR, "\n Fan Id %x offset %x", id.id,
id.offset);
if (id.id > 3) {
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
FRU_SEEPROM_NAME);
return (-1);
}
(void) memcpy((char *)&fan_ctrl[id.id],
(char *)&buff[id.offset], sizeof (fan_ctrl_blk_t));
nfans--;
id_offset += ID_OFF_SIZE;
}
/*
* Match Sensor/ES ID and point correct data
* based on IDs
*/
for (i = 0; i < N_ENVD_SENSORS; i++) {
snodep = &envd_sensors[i];
snodep->es_ptr = &sensor_ctrl[snodep->id];
}
/*
* Match Fan/ES ID and point to correct ES Data
* based on IDs
*/
for (i = 0; (fnodep = envd_fans[i]) != NULL; i++)
fnodep->es_ptr = &fan_ctrl[fnodep->id];
return (0);
}
static int
envd_es_setup(void)
{
envfru = get_fru_envsegs();
if (envfru == NULL) {
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG, FRU_SEEPROM_NAME);
return (-1);
}
return (process_fru_seeprom((uchar_t *)envfru->envsegbufp));
}
static void
envd_es_destroy(void)
{
if (envfru != NULL)
free(envfru->envsegbufp);
}
/*
* Lookup fan and return a pointer to env_fan_t data structure.
*/
env_fan_t *
fan_lookup(char *name)
{
int i;
env_fan_t *fanp;
for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
if (strcmp(fanp->name, name) == 0)
return (fanp);
}
return (NULL);
}
/*
* Lookup sensor and return a pointer to env_sensor_t data structure.
*/
env_sensor_t *
sensor_lookup(char *name)
{
env_sensor_t *sensorp;
int i;
for (i = 0; i < N_ENVD_SENSORS; ++i) {
sensorp = &envd_sensors[i];
if (strcmp(sensorp->name, name) == 0)
return (sensorp);
}
return (NULL);
}
/*
* Lookup disk and return a pointer to env_disk_t data structure.
*/
env_disk_t *
disk_lookup(char *name)
{
int i;
env_disk_t *diskp;
for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
if (strncmp(diskp->name, name, strlen(name)) == 0)
return (diskp);
}
return (NULL);
}
/*
* Get current temperature
* Returns -1 on error, 0 if successful
*/
int
get_temperature(env_sensor_t *sensorp, tempr_t *temp)
{
int fd = sensorp->fd;
int retval = 0;
if (fd == -1)
retval = -1;
else if (ioctl(fd, I2C_GET_TEMPERATURE, temp) == -1) {
retval = -1;
if (sensorp->error == 0) {
sensorp->error = 1;
envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_FAIL,
sensorp->name, errno, strerror(errno));
}
} else if (sensorp->error != 0) {
sensorp->error = 0;
envd_log(LOG_WARNING, ENV_SENSOR_ACCESS_OK, sensorp->name);
}
if (sensorp->crtbl != NULL) {
*temp = (tempr_t)y_of_x(sensorp->crtbl, *temp);
}
return (retval);
}
/*
* Get current disk temperature
* Returns -1 on error, 0 if successful
*/
int
disk_temperature(env_disk_t *diskp, tempr_t *temp)
{
int retval = 0;
if (diskp == NULL)
retval = -1;
else {
*temp = diskp->current_temp;
}
return (retval);
}
/*
* Get uncorrected current temperature
* Returns -1 on error, 0 if successful
*/
static int
get_raw_temperature(env_sensor_t *sensorp, tempr_t *temp)
{
int fd = sensorp->fd;
int retval = 0;
if (fd == -1)
retval = -1;
else if (ioctl(fd, I2C_GET_TEMPERATURE, temp) == -1) {
retval = -1;
}
return (retval);
}
/*
* Return Fan RPM given N & tach
* count and N are retrived from the
* ADM1031 chip.
*/
static int
tach_to_rpm(int n, uint8_t tach)
{
if (n * tach == 0)
return (0);
return ((ADCSAMPLE * 60) / (n * tach));
}
static int
get_raw_fan_speed(env_fan_t *fanp, uint8_t *fanspeedp)
{
int fan_fd;
int retval = 0;
fan_fd = fanp->fd;
if (fan_fd == -1)
retval = -1;
else if (ioctl(fan_fd, I2C_GET_FAN_SPEED, fanspeedp) == -1) {
retval = -1;
}
return (retval);
}
/*
* Get current fan speed
* This function returns a RPM value for fanspeed
* in fanspeedp.
* Returns -1 on error, 0 if successful
*/
int
get_fan_speed(env_fan_t *fanp, fanspeed_t *fanspeedp)
{
int fan_fd;
uint8_t tach;
fan_fd = fanp->fd;
if (fan_fd == -1)
return (-1);
if (fanp->id == DIMM_FAN_ID) {
return (get_dimm_fan_speed(fan_fd, fanspeedp));
}
if (ioctl(fan_fd, I2C_GET_FAN_SPEED, &tach) == -1) {
return (-1);
}
/*
* Fanspeeds are reported as 0
* if the tach is out of range or fan status is off
* and if monitoring fan status is enabled.
*/
if (mon_fanstat && (!fanp->fanstat || tach == FAN_OUT_OF_RANGE)) {
*fanspeedp = 0;
} else {
*fanspeedp =
tach_to_rpm(fanp->speedrange, tach);
}
return (0);
}
/*
* Set fan speed
* This function accepts a percentage of fan speed
* from 0-100 and programs the HW monitor fans to the corresponding
* fanspeed value.
* Returns -1 on error, -2 on invalid args passed, 0 if successful
*/
int
set_fan_speed(env_fan_t *fanp, fanspeed_t fanspeed)
{
int fan_fd;
int retval = 0;
uint8_t speed;
fan_fd = fanp->fd;
if (fan_fd == -1)
return (-1);
if (fanspeed < 0 || fanspeed > 100)
return (-2);
speed = (uint8_t)ADM_SETFANSPEED_CONV(fanspeed);
if (ioctl(fan_fd, I2C_SET_FAN_SPEED, &speed) == -1) {
retval = -1;
}
return (retval);
}
/*
* close all fan devices
*/
static void
envd_close_fans(void)
{
int i;
env_fan_t *fanp;
for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
if (fanp->fd != -1) {
(void) close(fanp->fd);
fanp->fd = -1;
}
}
}
/*
* Close sensor devices and freeup resources
*/
static void
envd_close_sensors(void)
{
env_sensor_t *sensorp;
int i;
for (i = 0; i < N_ENVD_SENSORS; ++i) {
sensorp = &envd_sensors[i];
if (sensorp->fd != -1) {
(void) close(sensorp->fd);
sensorp->fd = -1;
}
if (sensorp->crtbl != NULL)
fini_table(sensorp->crtbl);
}
}
/*
* Open fan devices and initialize per fan data structure.
* Returns #fans found.
*/
static int
envd_setup_fans(void)
{
int i, fd;
env_fan_t *fanp;
char path[PATH_MAX];
int fancnt = 0;
uint8_t n = 0;
picl_nodehdl_t tnodeh;
i2c_reg_t i2c_reg;
for (i = 0; (fanp = envd_fans[i]) != NULL; i++) {
/* make sure cpu0/1 present for validating cpu fans */
if (fanp->id == CPU0_FAN_ID) {
if (ptree_get_node_by_path(CPU0_PATH, &tnodeh) !=
PICL_SUCCESS) {
fanp->present = B_FALSE;
continue;
}
}
if (fanp->id == CPU1_FAN_ID) {
if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
PICL_SUCCESS) {
fanp->present = B_FALSE;
continue;
}
}
if (fanp->id == DIMM_FAN_ID) {
if (ptree_get_node_by_path(DIMM_FAN_CONTROLLER_PATH,
&tnodeh) != PICL_SUCCESS) {
if (env_debug)
envd_log(LOG_ERR,
"dimm Fan not found in the system.\n");
fanp->present = B_FALSE;
continue;
}
}
(void) strcpy(path, "/devices");
(void) strlcat(path, fanp->devfs_path, sizeof (path));
fd = open(path, O_RDWR);
if (fd == -1) {
envd_log(LOG_CRIT,
ENV_FAN_OPEN_FAIL, fanp->name,
fanp->devfs_path, errno, strerror(errno));
fanp->present = B_FALSE;
continue;
}
fanp->fd = fd;
if (fanp->id == DIMM_FAN_ID) {
/*
* set the SW aware bit in command register.
* Clear the Fan fault latch bit.
*/
i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
i2c_reg.reg_value = (PIC16F819_SW_AWARE_MODE |
PIC16F819_FAN_FAULT_CLEAR);
if (ioctl(fd, I2C_SET_REG, &i2c_reg) == -1) {
if (env_debug)
envd_log(LOG_ERR,
"Error in writing to COMMAND reg. of DIMM FAN controller\n");
}
} else {
/* Get speed range value */
if (ioctl(fd, ADM1031_GET_FAN_FEATURE, &n) != -1) {
fanp->speedrange =
adm_speedrange_map[(n >> 6) & 0x03];
} else {
fanp->speedrange = FAN_RANGE_DEFAULT;
}
}
fanp->present = B_TRUE;
fanp->fanstat = 0;
fanp->cspeed = TACH_UNKNOWN;
fanp->lspeed = TACH_UNKNOWN;
fanp->conccnt = 0;
fancnt++;
}
return (fancnt);
}
static int
envd_setup_disks(void)
{
int ret, i, page_index, page_len;
picl_nodehdl_t tnodeh;
env_disk_t *diskp;
uint_t vendor_id;
uint_t device_id;
uchar_t log_page[256];
/*
* Check if the SCSi controller on the system is 1010 or 1030
*/
if (ptree_get_node_by_path(SCSI_CONTROLLER_NODE_PATH,
&tnodeh) != PICL_SUCCESS) {
if (env_debug)
envd_log(LOG_ERR,
"On-Board SCSI controller not found in the system.\n");
monitor_disk_temp = 0;
return (-1);
}
if ((ret = ptree_get_propval_by_name(tnodeh, VENDOR_ID,
&vendor_id,
sizeof (vendor_id))) != 0) {
if (env_debug)
envd_log(LOG_ERR,
"Error in getting vendor-id for SCSI controller. ret = %d errno = 0x%d\n",
ret, errno);
monitor_disk_temp = 0;
return (-1);
}
if ((ret = ptree_get_propval_by_name(tnodeh, DEVICE_ID,
&device_id,
sizeof (device_id))) != 0) {
if (env_debug)
envd_log(LOG_ERR,
"Error in getting device-id for SCSI controller. ret = %d errno = 0x%d\n",
ret, errno);
monitor_disk_temp = 0;
return (-1);
}
if (env_debug)
envd_log(LOG_ERR, "vendor-id=0x%x device-id=0x%x\n",
vendor_id, device_id);
if ((vendor_id != LSI1030_VENDOR_ID) ||
(device_id != LSI1030_DEVICE_ID)) {
monitor_disk_temp = 0;
return (-1);
}
/*
* We have found LSI1030 SCSi controller onboard.
*/
for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
if (ptree_get_node_by_path(diskp->nodepath,
&tnodeh) != PICL_SUCCESS) {
diskp->present = B_FALSE;
if (env_debug)
envd_log(LOG_ERR,
"DISK %d not found in the system.\n",
diskp->id);
continue;
}
diskp->fd = open(diskp->devfs_path, O_RDONLY);
if (diskp->fd == -1) {
diskp->present = B_FALSE;
envd_log(LOG_ERR,
"Error in opening %s errno = 0x%x\n",
diskp->devfs_path, errno);
continue;
}
diskp->present = B_TRUE;
diskp->tpage_supported = B_FALSE;
/*
* Find out if the Temperature page is supported by the disk.
*/
ret = scsi_log_sense(diskp->fd, SUPPORTED_LPAGES,
log_page, sizeof (log_page));
if (ret != 0) {
continue;
}
page_len = ((log_page[2] << 8) & 0xFF00) | log_page[3];
for (page_index = LOGPAGEHDRSIZE;
page_index < page_len + LOGPAGEHDRSIZE; page_index++) {
switch (log_page[page_index]) {
case TEMPERATURE_PAGE:
diskp->tpage_supported = B_TRUE;
if (env_debug)
envd_log(LOG_ERR,
"tpage supported for %s\n",
diskp->nodepath);
default:
break;
}
}
diskp->warning_tstamp = 0;
diskp->shutdown_tstamp = 0;
diskp->high_warning = disk_high_warn_temperature;
diskp->low_warning = disk_low_warn_temperature;
diskp->high_shutdown = disk_high_shutdown_temperature;
diskp->low_shutdown = disk_low_shutdown_temperature;
ret = get_disk_temp(diskp);
}
return (0);
}
/*
* Open temperature sensor devices and initialize per sensor data structure.
* Returns #sensors found.
*/
static int
envd_setup_sensors(void)
{
env_sensor_t *sensorp;
sensor_ctrl_blk_t *es_ptr;
table_t *tblp;
char path[PATH_MAX];
int sensorcnt = 0;
int i, j, nentries;
int16_t tmin = 0;
picl_nodehdl_t tnodeh;
for (i = 0; i < N_ENVD_SENSORS; ++i) {
sensorp = &envd_sensors[i];
/* Initialize sensor's initial state */
sensorp->shutdown_initiated = B_FALSE;
sensorp->warning_tstamp = 0;
sensorp->shutdown_tstamp = 0;
sensorp->error = 0;
sensorp->crtbl = NULL;
/* make sure cpu0/1 sensors are present */
if (sensorp->id == CPU0_SENSOR_ID) {
if (ptree_get_node_by_path(CPU0_PATH, &tnodeh) !=
PICL_SUCCESS) {
sensorp->present = B_FALSE;
continue;
}
}
if (sensorp->id == CPU1_SENSOR_ID) {
if (ptree_get_node_by_path(CPU1_PATH, &tnodeh) !=
PICL_SUCCESS) {
sensorp->present = B_FALSE;
continue;
}
}
(void) strcpy(path, "/devices");
(void) strlcat(path, sensorp->devfs_path,
sizeof (path));
sensorp->fd = open(path, O_RDWR);
if (sensorp->fd == -1) {
envd_log(LOG_ERR, ENV_SENSOR_OPEN_FAIL,
sensorp->name, sensorp->devfs_path,
errno, strerror(errno));
sensorp->present = B_FALSE;
continue;
}
sensorp->present = B_TRUE;
sensorcnt++;
/*
* Get Tmin
*/
if (ioctl(sensorp->fd, ADM1031_GET_TEMP_MIN_RANGE,
&tmin) != -1) {
sensorp->tmin = TMIN(tmin);
} else {
sensorp->tmin = -1;
}
if (env_debug)
envd_log(LOG_ERR, "Sensor %s tmin %d",
sensorp->name, sensorp->tmin);
/*
* Create a correction table
* if correction pairs are present in es
* segment.
*/
es_ptr = sensorp->es_ptr;
if (es_ptr == NULL) {
continue;
}
nentries = es_ptr->correctionEntries;
if (nentries <= 2) {
if (env_debug)
envd_log(LOG_CRIT, "sensor correction <2");
continue;
}
sensorp->crtbl = init_table(nentries);
if (sensorp->crtbl == NULL)
continue;
tblp = sensorp->crtbl;
tblp->xymap[0].x =
(char)es_ptr->correctionPair[0].measured;
tblp->xymap[0].y =
(char)es_ptr->correctionPair[0].corrected;
for (j = 1; j < nentries; ++j) {
tblp->xymap[j].x =
(char)es_ptr->correctionPair[j].measured;
tblp->xymap[j].y =
(char)es_ptr->correctionPair[j].corrected;
if (tblp->xymap[j].x <= tblp->xymap[j - 1].x) {
fini_table(tblp);
sensorp->crtbl = NULL;
envd_log(LOG_CRIT, ENV_FRU_BAD_ENVSEG,
FRU_SEEPROM_NAME);
break;
}
}
if (env_debug) {
envd_log(LOG_CRIT, "Sensor correction %s",
sensorp->name);
for (j = 0; j < nentries; j++)
envd_log(LOG_CRIT, " %d %d",
tblp->xymap[j].x, tblp->xymap[j].y);
}
}
return (sensorcnt);
}
/*
* Modify ADM Tmin/ranges depending what power level
* we are from.
*/
static void
updateadm_ranges(char *name, uchar_t cur_lpstate)
{
env_sensor_t *sensorp;
fan_ctrl_blk_t *fanctl;
uchar_t tmin;
uchar_t trange;
uint16_t tdata;
int sysfd;
uchar_t sys_id = SYS_HWM_ID;
uint8_t mode;
static uint16_t tsave[2] = {0, 0};
/* Index of saved Tmin/Trange for two sensors */
uint16_t tindex = 0;
sensorp = sensor_lookup(name);
if (sensorp == NULL)
return;
/*
* If there is only one Control pairs then return
*/
fanctl = ((env_fan_t *)sensorp->fanp)->es_ptr;
if (fanctl != NULL && fanctl->no_ctl_pairs <= 1)
return;
/*
* if fan control specifies that ranges are same then
* we skip re-programming adm chip.
*/
tmin = fanctl->fan_ctl_pairs[0].tMin;
trange = fanctl->fan_ctl_pairs[0].tRange;
if ((tmin == fanctl->fan_ctl_pairs[1].tMin) &&
(trange == fanctl->fan_ctl_pairs[1].tRange))
return;
sysfd = open(hwm_devs[sys_id], O_RDWR);
if (sysfd == -1) {
if (env_debug)
envd_log(LOG_ERR, ENV_ADM_OPEN_FAIL, hwm_devs[sys_id],
errno, strerror(errno));
return;
}
tindex = ((strcmp(name, SENSOR_SYS_IN) == 0) ? 0 : 1);
/* Read ADM default value only for the first time */
if (tsave[tindex] == 0) {
if (ioctl(sensorp->fd, ADM1031_GET_TEMP_MIN_RANGE,
&tsave[tindex]) == -1) {
if (env_debug)
envd_log(LOG_ERR,
"read tminrange ioctl failed");
(void) close(sysfd);
return;
}
}
/*
* Need to reinit ADM to manual mode for Tmin range to be
* effective.
*/
mode = ADM1031_MANUAL_MODE;
if (ioctl(sysfd, ADM1031_SET_MONITOR_MODE, &mode) == -1) {
if (env_debug)
envd_log(LOG_ERR, ENV_ADM_MANUAL_MODE);
(void) close(sysfd);
return;
}
if (cur_lpstate == 1) {
/*
* ADM 1031 Tmin/Trange register need to be reprogrammed.
*/
tdata = ((fanctl->fan_ctl_pairs[cur_lpstate].tMin / TMIN_UNITS)
<< TMIN_SHIFT);
/* Need to pack tRange in ADM bits 2:0 */
switch (fanctl->fan_ctl_pairs[cur_lpstate].tRange) {
case 5:
break;
case 10:
tdata |= 1;
break;
case 20:
tdata |= 2;
break;
case 40:
tdata |= 3;
break;
case 80:
tdata |= 4;
break;
}
} else
tdata = tsave[tindex];
if (ioctl(sensorp->fd, ADM1031_SET_TEMP_MIN_RANGE,
&tdata) != -1)
sensorp->tmin = TMIN(tdata);
mode = ADM1031_AUTO_MODE;
if (ioctl(sysfd, ADM1031_SET_MONITOR_MODE, &mode) == -1) {
if (env_debug)
envd_log(LOG_ERR, ENV_ADM_AUTO_MODE);
}
(void) close(sysfd);
}
/* ARGSUSED */
static void *
pmthr(void *args)
{
pm_state_change_t pmstate;
char physpath[PATH_MAX];
int pre_lpstate;
pmstate.physpath = physpath;
pmstate.size = sizeof (physpath);
cur_lpstate = 0;
pre_lpstate = 1;
pm_fd = open(PM_DEVICE, O_RDWR);
if (pm_fd == -1) {
envd_log(LOG_ERR, PM_THREAD_EXITING, errno, strerror(errno));
return (NULL);
}
for (;;) {
/*
* Get PM state change events to check if the system
* is in lowest power state and adjust ADM hardware
* monitor's fan speed settings.
*
* To minimize polling, we use the blocking interface
* to get the power state change event here.
*/
if (ioctl(pm_fd, PM_GET_STATE_CHANGE_WAIT, &pmstate) != 0) {
if (errno != EINTR)
break;
continue;
}
do {
if (env_debug) {
envd_log(LOG_INFO,
"pmstate event:0x%x flags:%x"
"comp:%d oldval:%d newval:%d path:%s\n",
pmstate.event, pmstate.flags,
pmstate.component,
pmstate.old_level,
pmstate.new_level,
pmstate.physpath);
}
cur_lpstate =
(pmstate.flags & PSC_ALL_LOWEST) ? 1 : 0;
} while (ioctl(pm_fd, PM_GET_STATE_CHANGE, &pmstate) == 0);
/*
* Change ADM ranges as per E* Requirements. Update
* happens only for valid state changes.
*/
if (pre_lpstate != cur_lpstate) {
pre_lpstate = cur_lpstate;
updateadm_ranges(SENSOR_SYS_OUT, cur_lpstate);
updateadm_ranges(SENSOR_SYS_IN, cur_lpstate);
}
}
/* Not reached */
return (NULL);
}
/*
* This function is used to reasonably predict the
* state of the fan (ON/OFF) using tmin and current temperature.
*
* We know the fan is on if temp >= tmin and fan is off if
* temp < (Tmin - Hysterisis).
*
* When the temperature is in between we don't know if the fan is on/off
* because the temperature could be decreasing and not have crossed
* Tmin - hysterisis and vice a versa.
*
* FAN ON
* Tmin
* -------------------------------------------
*
* FAN ON/OFF
*
* --------------------------------------------
* Tmin - Hysterisis
* FAN OFF
*
* To solve the problem of finding out if the fan is on/off in our gray region
* we keep track of the last read tach and the current read tach. From
* experimentation and from discussions with analog devices it is unlikely that
* if the fans are on we will get a constant tach reading more than 5 times in
* a row. This is not but the most fool proof approach but the best we can do.
*
* This routine implements the above logic for a sensor with an
* associated fan. The caller garauntees sensorp and fanp are not null.
*/
static void
check_fanstat(env_sensor_t *sensorp)
{
env_fan_t *fanp = sensorp->fanp;
tempr_t temp;
uint8_t fanspeed;
if (get_raw_temperature(sensorp, &temp) == -1)
return;
if (temp < (sensorp->tmin - ADM_HYSTERISIS)) {
fanp->fanstat = 0; /* Fan off */
fanp->lspeed = TACH_UNKNOWN; /* Reset Last read tach */
fanp->conccnt = 0;
} else if (temp >= sensorp->tmin) {
fanp->fanstat = 1; /* Fan on */
fanp->lspeed = TACH_UNKNOWN;
fanp->conccnt = 0;
} else {
if (get_raw_fan_speed(fanp, &fanspeed) == -1)
return;
fanp->cspeed = fanspeed;
/*
* First time in the gray area
* set last read speed to current speed
*/
if (fanp->lspeed == TACH_UNKNOWN) {
fanp->lspeed = fanspeed;
} else {
if (fanp->lspeed != fanp->cspeed) {
fanp->conccnt = 0;
fanp->fanstat = 1;
} else {
fanp->conccnt++;
if (fanp->conccnt >= N_SEQ_TACH)
fanp->fanstat = 0;
}
fanp->lspeed = fanp->cspeed;
}
}
}
/*
* There is an issue with the ADM1031 chip that causes the chip
* to not update the tach register in case the fan stops. The
* fans stop when the temperature measured (temp) drops below
* Tmin - Hysterisis and turn on when the temp >= Tmin.
*
* Since the tach registers don't update and remain stuck at the
* last read tach value our get_fan_speed function always returns
* a non-zero RPM reading.
*
* To fix this we need to figure out when the fans will be on/off
* depending on the current temperature. Currently we poll for
* interrupts, we can use that loop to determine what the current
* temperature is and if the fans should be on/off.
*
* We get current temperature and check the fans.
*/
static void
monitor_fanstat(void)
{
env_sensor_t *sensorp;
env_fan_t *fanp;
int i;
for (i = 0; i < N_ENVD_SENSORS; i++) {
sensorp = &envd_sensors[i];
if (!sensorp)
continue;
fanp = sensorp->fanp;
if (!(fanp && fanp->present))
continue;
if (sensorp->tmin != -1) {
check_fanstat(sensorp);
} else {
fanp->fanstat = 1;
}
}
}
static int
handle_overtemp_interrupt(int hwm_id)
{
env_sensor_t *sensorp;
tempr_t temp;
uchar_t smap[MAX_SENSORS];
time_t ct;
uchar_t i;
char msgbuf[BUFSIZ];
char syscmd[BUFSIZ];
boolean_t return_flag;
int ret;
timespec_t to;
pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t env_monitor_cv = PTHREAD_COND_INITIALIZER;
/* Clear Map of Sensor Entries */
(void) memset(smap, SENSOR_OK, sizeof (smap));
for (;;) {
for (i = 0; i < N_ENVD_SENSORS; i++) {
sensorp = &envd_sensors[i];
/*
* Check whether the sensor belongs to the
* interrupting ADM hardware monitor
*/
if (sensorp->hwm_id != hwm_id)
continue;
if (sensorp->present == B_FALSE)
continue;
/*
* if shutdown is initiated then we simply loop
* through the sensors until shutdown
*/
if (sensorp->shutdown_initiated == B_TRUE)
continue;
/* get current temp for this sensor */
if (get_temperature(sensorp, &temp) == -1)
continue;
sensorp->cur_temp = temp;
if (env_debug)
envd_log(LOG_ERR,
"sensor name %s, cur temp %d, "
"HW %d LW %d SD %d LS %d\n",
sensorp->name, temp,
sensorp->es_ptr->high_warning,
(int)sensorp->es_ptr->low_warning,
sensorp->es_ptr->high_shutdown,
(int)sensorp->es_ptr->low_shutdown);
if (TEMP_IN_WARNING_RANGE(sensorp->cur_temp, sensorp)) {
/*
* Log on warning atmost one second
*/
ct = (time_t)(gethrtime() / NANOSEC);
if ((ct - sensorp->warning_tstamp) >=
warning_interval) {
envd_log(LOG_CRIT,
ENV_WARNING_MSG, sensorp->name,
temp,
sensorp->es_ptr->low_warning,
sensorp->es_ptr->high_warning);
sensorp->warning_tstamp = ct;
}
smap[i] = SENSOR_WARN;
} else {
/*
* We will fall in this caterory only if
* Temperature drops/increases from warning
* threshold. If so we set sensor map to
* OK so that we can exit the loop if
* shutdown not initiated.
*/
smap[i] = SENSOR_OK;
}
if (TEMP_IN_SHUTDOWN_RANGE(temp, sensorp) &&
!shutdown_override) {
ct = (time_t)(gethrtime() / NANOSEC);
if (sensorp->shutdown_tstamp == 0)
sensorp->shutdown_tstamp = ct;
if ((ct - sensorp->shutdown_tstamp) >=
shutdown_interval) {
sensorp->shutdown_initiated = B_TRUE;
(void) snprintf(msgbuf, sizeof (msgbuf),
ENV_SHUTDOWN_MSG, sensorp->name,
temp,
sensorp->es_ptr->low_shutdown,
sensorp->es_ptr->high_shutdown);
envd_log(LOG_ALERT, msgbuf);
}
if (system_shutdown_started == B_FALSE) {
(void) snprintf(syscmd, sizeof (syscmd),
"%s \"%s\"", SHUTDOWN_CMD, msgbuf);
envd_log(LOG_ALERT, syscmd);
system_shutdown_started = B_TRUE;
(void) system(syscmd);
}
} else if (sensorp->shutdown_tstamp != 0)
sensorp->shutdown_tstamp = 0;
}
/*
* Sweep thorugh Sensor Map and if warnings OR shutdown
* are not logged then return to caller.
*/
return_flag = B_TRUE;
for (i = 0; i < N_ENVD_SENSORS; i++)
if (smap[i] == SENSOR_WARN)
return_flag = B_FALSE;
if ((return_flag == B_TRUE) &&
(system_shutdown_started == B_FALSE)) {
return (1);
}
wait_till_timeout:
/*
* We use pthread_cond_reltimedwait_np to sleep for
* fixed interval of time.
* earlier implementation used alarm() call which
* fails in Multi threaded environment. If multiple
* threads call alarm() only one of the threads is
* sent the SIGALRM signal.
*/
(void) pthread_mutex_lock(&env_monitor_mutex);
ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
&env_monitor_mutex, &to);
to.tv_sec = SENSORPOLL_INTERVAL;
to.tv_nsec = 0;
if (ret != ETIMEDOUT) {
(void) pthread_mutex_unlock(&env_monitor_mutex);
goto wait_till_timeout;
}
(void) pthread_mutex_unlock(&env_monitor_mutex);
}
}
/*
* This is env thread which monitors the current temperature when
* warning threshold is exceeded. The job is to make sure it does
* not execced/decrease shutdown threshold. If it does it will start
* forced shutdown to avoid reaching hardware poweroff via THERM interrupt.
* For Enchilada there will be two threads, one for each ADM chip.
*/
static void *
ovtemp_thr(void *args)
{
int fd;
uint8_t stat[2];
int hwm_id = (int)args;
int err;
env_fan_t *fanp;
timespec_t to;
int ret;
pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t env_monitor_cv = PTHREAD_COND_INITIALIZER;
fd = open(hwm_devs[hwm_id], O_RDWR);
if (fd == -1) {
envd_log(LOG_ERR, ENV_ADM_OPEN_FAIL, hwm_devs[hwm_id],
errno, strerror(errno));
return (NULL);
}
if (env_debug)
envd_log(LOG_ERR, "ovtemp thread for %s running...\n",
hwm_devs[hwm_id]);
for (;;) {
/*
* Sleep for specified seconds before issuing IOCTL
* again.
*/
/*
* We use pthread_cond_reltimedwait_np to sleep for
* fixed interval of time.
* earlier implementation used alarm() call which
* fails in Multi threaded environment. If multiple
* threads call alarm() only one of the threads is
* sent the SIGALRM signal.
*/
(void) pthread_mutex_lock(&env_monitor_mutex);
ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
&env_monitor_mutex, &to);
to.tv_sec = INTERRUPTPOLL_INTERVAL;
to.tv_nsec = 0;
if (ret != ETIMEDOUT) {
(void) pthread_mutex_unlock(&env_monitor_mutex);
continue;
}
(void) pthread_mutex_unlock(&env_monitor_mutex);
/*
* Monitor the sensors to update fan status
*/
if (mon_fanstat)
monitor_fanstat();
/*
* Read ADM1031 two Status Registers to determine source
* of Interrupts.
*/
if ((err = ioctl(fd, ADM1031_GET_STATUS_1, &stat[0])) != -1)
err = ioctl(fd, ADM1031_GET_STATUS_2, &stat[1]);
if (err == -1) {
if (env_debug)
envd_log(LOG_ERR,
"OverTemp: Status Error");
continue;
}
if (env_debug)
envd_log(LOG_ERR, "INTR %s, Stat1 %x, Stat2 %x",
hwm_devs[hwm_id], stat[0], stat[1]);
if (stat[0] & FANFAULT) {
fanp = fan_lookup(hwm_fans[hwm_id][HWM_FAN1]);
if (fanp && fanp->present)
envd_log(LOG_ERR, ENV_FAN_FAULT,
hwm_devs[hwm_id],
hwm_fans[hwm_id][HWM_FAN1]);
}
if (stat[1] & FANFAULT) {
fanp = fan_lookup(hwm_fans[hwm_id][HWM_FAN2]);
if (fanp && fanp->present)
envd_log(LOG_ERR, ENV_FAN_FAULT,
hwm_devs[hwm_id],
hwm_fans[hwm_id][HWM_FAN2]);
}
/*
* Check respective Remote/Local High, Low before start
* manual monitoring
*/
if ((stat[0] & STAT1MASK) || (stat[1] & STAT2MASK))
(void) handle_overtemp_interrupt(hwm_id);
} /* end of for ever loop */
/*NOTREACHED*/
return (NULL);
}
static void *
dimm_fan_thr(void *args)
{
char syscmd[BUFSIZ];
char msgbuf[BUFSIZ];
i2c_reg_t i2c_reg;
timespec_t to;
int ret;
pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t env_monitor_cv = PTHREAD_COND_INITIALIZER;
#ifdef __lint
args = args;
#endif
for (;;) {
/*
* Sleep for specified seconds before issuing IOCTL
* again.
*/
(void) pthread_mutex_lock(&env_monitor_mutex);
ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
&env_monitor_mutex, &to);
to.tv_sec = INTERRUPTPOLL_INTERVAL;
to.tv_nsec = 0;
if (ret != ETIMEDOUT) {
(void) pthread_mutex_unlock(&env_monitor_mutex);
continue;
}
(void) pthread_mutex_unlock(&env_monitor_mutex);
/*
* We write to the comand register periodically
* to inform the PIC firmware that Solaris is
* Monitoring the dimm fan periodically.
*/
i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
i2c_reg.reg_value = PIC16F819_SW_AWARE_MODE;
if (ioctl(envd_dimm_fan.fd,
I2C_SET_REG, &i2c_reg) == -1) {
if (env_debug)
envd_log(LOG_ERR,
"Error in writing to COMMAND reg. of DIMM FAN controller\n");
}
/*
* We initiate shutdown if fan status indicates
* failure.
*/
if (is_dimm_fan_failed() != 0) {
/*
* Mark Dimm fan present as False so that we
* do not WARN the user of the Fan failure
* repeatedly.
*/
envd_dimm_fan.present = B_FALSE;
(void) snprintf(msgbuf, sizeof (msgbuf),
ENV_DIMM_FAN_FAILURE_SHUTDOWN_MSG,
ENV_DIMM_FAN,
dimm_fan_rpm_string, dimm_fan_status_string,
dimm_fan_command_string,
dimm_fan_debug_string);
envd_log(LOG_ALERT, msgbuf);
if (system_shutdown_started == B_FALSE) {
system_shutdown_started = B_TRUE;
(void) snprintf(syscmd, sizeof (syscmd),
"%s \"%s\"",
SHUTDOWN_CMD,
msgbuf);
envd_log(LOG_ALERT, syscmd);
(void) system(syscmd);
}
}
}
/*NOTREACHED*/
return (NULL);
}
static int
scsi_log_sense(int fd, uchar_t page_code, uchar_t *pagebuf, uint16_t pagelen)
{
struct uscsi_cmd ucmd_buf;
uchar_t cdb_buf[CDB_GROUP1];
struct scsi_extended_sense sense_buf;
int ret_val;
bzero((void *)&cdb_buf, sizeof (cdb_buf));
bzero((void *)&ucmd_buf, sizeof (ucmd_buf));
bzero((void *)&sense_buf, sizeof (sense_buf));
cdb_buf[0] = SCMD_LOG_SENSE_G1;
cdb_buf[2] = (0x01 << 6) | page_code;
cdb_buf[7] = (uchar_t)((pagelen & 0xFF00) >> 8);
cdb_buf[8] = (uchar_t)(pagelen & 0x00FF);
ucmd_buf.uscsi_cdb = (char *)cdb_buf;
ucmd_buf.uscsi_cdblen = sizeof (cdb_buf);
ucmd_buf.uscsi_bufaddr = (caddr_t)pagebuf;
ucmd_buf.uscsi_buflen = pagelen;
ucmd_buf.uscsi_rqbuf = (caddr_t)&sense_buf;
ucmd_buf.uscsi_rqlen = sizeof (struct scsi_extended_sense);
ucmd_buf.uscsi_flags = USCSI_RQENABLE | USCSI_READ | USCSI_SILENT;
ucmd_buf.uscsi_timeout = 60;
ret_val = ioctl(fd, USCSICMD, ucmd_buf);
if (ret_val == 0 && ucmd_buf.uscsi_status == 0) {
if (env_debug)
envd_log(LOG_ERR,
"log sense command for page_code 0x%x succeeded\n", page_code);
return (ret_val);
}
if (env_debug)
envd_log(LOG_ERR,
"log sense command failed.ret_val = 0x%x status = 0x%x errno = 0x%x\n",
ret_val, ucmd_buf.uscsi_status, errno);
return (1);
}
static int
get_disk_temp(env_disk_t *diskp)
{
int ret;
uchar_t tpage[256];
ret = scsi_log_sense(diskp->fd,
TEMPERATURE_PAGE,
tpage, sizeof (tpage));
if (ret != 0) {
diskp->current_temp = DISK_INVALID_TEMP;
diskp->ref_temp = DISK_INVALID_TEMP;
return (-1);
}
/*
* For the current temperature verify that the parameter
* length is 0x02 and the parameter code is 0x00
* Temperature value of 255(0xFF) is considered INVALID.
*/
if ((tpage[7] == 0x02) && (tpage[4] == 0x00) &&
(tpage[5] == 0x00)) {
if (tpage[9] == 0xFF) {
diskp->current_temp = DISK_INVALID_TEMP;
return (-1);
} else {
diskp->current_temp = tpage[9];
}
}
/*
* For the reference temperature verify that the parameter
* length is 0x02 and the parameter code is 0x01
* Temperature value of 255(0xFF) is considered INVALID.
*/
if ((tpage[13] == 0x02) && (tpage[10] == 0x00) &&
(tpage[11] == 0x01)) {
if (tpage[15] == 0xFF) {
diskp->ref_temp = DISK_INVALID_TEMP;
} else {
diskp->ref_temp = tpage[15];
}
}
return (0);
}
/* ARGSUSED */
static void *
disk_temp_thr(void *args)
{
char syscmd[BUFSIZ];
char msgbuf[BUFSIZ];
timespec_t to;
int ret, i;
env_disk_t *diskp;
pthread_mutex_t env_monitor_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t env_monitor_cv = PTHREAD_COND_INITIALIZER;
pm_state_change_t pmstate;
int idle_time;
int disk_pm_fd;
time_t ct;
disk_pm_fd = open(PM_DEVICE, O_RDWR);
if (disk_pm_fd == -1) {
envd_log(LOG_ERR,
DISK_TEMP_THREAD_EXITING,
errno, strerror(errno));
return (NULL);
}
for (;;) {
/*
* Sleep for specified seconds before issuing IOCTL
* again.
*/
(void) pthread_mutex_lock(&env_monitor_mutex);
ret = pthread_cond_reltimedwait_np(&env_monitor_cv,
&env_monitor_mutex, &to);
to.tv_sec = disk_scan_interval;
to.tv_nsec = 0;
if (ret != ETIMEDOUT) {
(void) pthread_mutex_unlock(&env_monitor_mutex);
continue;
}
(void) pthread_mutex_unlock(&env_monitor_mutex);
for (i = 0; (diskp = envd_disks[i]) != NULL; i++) {
if (diskp->present == B_FALSE)
continue;
if (diskp->tpage_supported == B_FALSE)
continue;
/*
* If the disk temperature is above the warning threshold
* continue monitoring until the temperature drops below
* warning threshold.
* if the temperature is in the NORMAL range monitor only
* when the disk is BUSY.
* We do not want to read the disk temperature if the disk is
* is idling. The reason for this is disk will never get into
* lowest power mode if we scan the disk temperature
* peridoically. To avoid this situation we first determine
* the idle_time of the disk. If the disk has been IDLE since
* we scanned the temperature last time we will not read the
* temperature.
*/
if (!DISK_TEMP_IN_WARNING_RANGE(diskp->current_temp, diskp)) {
pmstate.physpath = diskp->physpath;
pmstate.size = strlen(diskp->physpath);
pmstate.component = 0;
if ((idle_time =
ioctl(disk_pm_fd,
PM_GET_TIME_IDLE, &pmstate)) == -1) {
if (errno != EINTR) {
if (env_debug)
envd_log(LOG_ERR,
"ioctl PM_GET_TIME_IDLE failed for DISK0. errno=0x%x\n",
errno);
continue;
}
continue;
}
if (idle_time >= (disk_scan_interval/2)) {
if (env_debug) {
envd_log(LOG_ERR,
"%s idle time = %d\n",
diskp->name, idle_time);
}
continue;
}
}
ret = get_disk_temp(diskp);
if (ret != 0)
continue;
if (env_debug) {
envd_log(LOG_ERR,
"%s temp = %d ref. temp = %d\n",
diskp->name, diskp->current_temp, diskp->ref_temp);
}
/*
* If this disk already triggered system shutdown, don't
* log any more shutdown/warning messages for it.
*/
if (diskp->shutdown_initiated)
continue;
/*
* Check for the temperature in warning and shutdown range
* and take appropriate action.
*/
if (DISK_TEMP_IN_WARNING_RANGE(diskp->current_temp, diskp)) {
/*
* Check if the temperature has been in warning
* range during last disk_warning_duration interval.
* If so, the temperature is truly in warning
* range and we need to log a warning message,
* but no more than once every disk_warning_interval
* seconds.
*/
time_t wtstamp = diskp->warning_tstamp;
ct = (time_t)(gethrtime() / NANOSEC);
if (diskp->warning_start == 0)
diskp->warning_start = ct;
if (((ct - diskp->warning_start) >=
disk_warning_duration) && (wtstamp == 0 ||
(ct - wtstamp) >= disk_warning_interval)) {
envd_log(LOG_CRIT, ENV_WARNING_MSG,
diskp->name, diskp->current_temp,
diskp->low_warning,
diskp->high_warning);
diskp->warning_tstamp = ct;
}
} else if (diskp->warning_start != 0)
diskp->warning_start = 0;
if (!shutdown_override &&
DISK_TEMP_IN_SHUTDOWN_RANGE(diskp->current_temp, diskp)) {
ct = (time_t)(gethrtime() / NANOSEC);
if (diskp->shutdown_tstamp == 0)
diskp->shutdown_tstamp = ct;
/*
* Shutdown the system if the temperature remains
* in the shutdown range for over disk_shutdown_interval
* seconds.
*/
if ((ct - diskp->shutdown_tstamp) >=
disk_shutdown_interval) {
/* log error */
diskp->shutdown_initiated = B_TRUE;
(void) snprintf(msgbuf, sizeof (msgbuf),
ENV_SHUTDOWN_MSG, diskp->name,
diskp->current_temp, diskp->low_shutdown,
diskp->high_shutdown);
envd_log(LOG_ALERT, msgbuf);
/* shutdown the system (only once) */
if (system_shutdown_started == B_FALSE) {
(void) snprintf(syscmd, sizeof (syscmd),
"%s \"%s\"", shutdown_cmd, msgbuf);
envd_log(LOG_ALERT, syscmd);
system_shutdown_started = B_TRUE;
(void) system(syscmd);
}
}
} else if (diskp->shutdown_tstamp != 0)
diskp->shutdown_tstamp = 0;
}
} /* end of forever loop */
}
/*
* Setup envrionmental monitor state and start threads to monitor
* temperature and power management state.
* Returns -1 on error, 0 if successful.
*/
static int
envd_setup(void)
{
int ret;
if (getenv("SUNW_piclenvd_debug") != NULL)
env_debug = 1;
if (pthread_attr_init(&thr_attr) != 0 ||
pthread_attr_setscope(&thr_attr, PTHREAD_SCOPE_SYSTEM) != 0) {
return (-1);
}
ret = envd_es_setup();
if (ret < 0) {
ovtemp_monitor = 0;
pm_monitor = 0;
}
/*
* Setup temperature sensors and fail if we can't open
* at least one sensor.
*/
if (envd_setup_sensors() <= 0) {
return (NULL);
}
/*
* Setup fan device (don't fail even if we can't access
* the fan as we can still monitor temeperature.
*/
(void) envd_setup_fans();
(void) envd_setup_disks();
/* If ES Segment setup failed,don't create thread */
if (ovtemp_monitor && ovtemp_thr1_created == B_FALSE) {
if (pthread_create(&ovtemp_thr1_id, &thr_attr, ovtemp_thr,
(void *)CPU_HWM_ID) != 0)
envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
else
ovtemp_thr1_created = B_TRUE;
}
if (ovtemp_monitor && ovtemp_thr2_created == B_FALSE) {
if (pthread_create(&ovtemp_thr2_id, &thr_attr, ovtemp_thr,
(void *)SYS_HWM_ID) != 0)
envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
else
ovtemp_thr2_created = B_TRUE;
}
if (envd_dimm_fan.present) {
if (dimm_fan_thr_created == B_FALSE) {
if (pthread_create(&dimm_fan_thr_id, &thr_attr, dimm_fan_thr,
NULL) != 0)
envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
else
dimm_fan_thr_created = B_TRUE;
}
}
/*
* Create a thread to monitor PM state
*/
if (pm_monitor && pmthr_created == B_FALSE) {
if (pthread_create(&pmthr_tid, &thr_attr, pmthr,
NULL) != 0)
envd_log(LOG_CRIT, PM_THREAD_CREATE_FAILED);
else
pmthr_created = B_TRUE;
}
if (monitor_disk_temp) {
if (disk_temp_thr_created == B_FALSE) {
if (pthread_create(&disk_temp_thr_id, &thr_attr, disk_temp_thr,
NULL) != 0)
envd_log(LOG_ERR, ENVTHR_THREAD_CREATE_FAILED);
else
disk_temp_thr_created = B_TRUE;
}
}
return (0);
}
static void
piclenvd_register(void)
{
picld_plugin_register(&my_reg_info);
}
static void
piclenvd_init(void)
{
(void) env_picl_setup_tuneables();
/*
* Setup the environmental data structures
*/
if (envd_setup() != 0) {
envd_log(LOG_CRIT, ENVD_PLUGIN_INIT_FAILED);
return;
}
/*
* Now setup/populate PICL tree
*/
env_picl_setup();
}
static void
piclenvd_fini(void)
{
/*
* Invoke env_picl_destroy() to remove any PICL nodes/properties
* (including volatile properties) we created. Once this call
* returns, there can't be any more calls from the PICL framework
* to get current temperature or fan speed.
*/
env_picl_destroy();
envd_close_sensors();
envd_close_fans();
envd_es_destroy();
}
/*VARARGS2*/
void
envd_log(int pri, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vsyslog(pri, fmt, ap);
va_end(ap);
}
/*
* Tunables support functions
*/
static env_tuneable_t *
tuneable_lookup(picl_prophdl_t proph)
{
int i;
env_tuneable_t *tuneablep = NULL;
for (i = 0; i < ntuneables; i++) {
tuneablep = &tuneables[i];
if (tuneablep->proph == proph)
return (tuneablep);
}
return (NULL);
}
static int
get_cpu_tach(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd;
int8_t cfg;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(CPU_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
if ((cfg & TACH_ENABLE_MASK) == TACH_ENABLE_MASK) {
*((int *)tuneablep->value) = ENABLE;
} else {
*((int *)tuneablep->value) = DISABLE;
}
(void) memcpy(buf, tuneablep->value,
tuneablep->nbytes);
(void) close(fd);
return (PICL_SUCCESS);
}
static int
set_cpu_tach(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd, val;
int8_t cfg;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(CPU_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
(void) memcpy(&val, (caddr_t)buf, sizeof (val));
if (val == ENABLE) {
cfg |= TACH_ENABLE_MASK;
} else if (val == DISABLE) {
cfg &= ~TACH_ENABLE_MASK;
}
if (ioctl(fd, ADM1031_SET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
(void) close(fd);
return (PICL_SUCCESS);
}
static int
get_sys_tach(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd;
int8_t cfg;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(SYS_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
if ((cfg & TACH_ENABLE_MASK) == TACH_ENABLE_MASK) {
*((int *)tuneablep->value) = ENABLE;
} else {
*((int *)tuneablep->value) = DISABLE;
}
(void) memcpy(buf, tuneablep->value,
tuneablep->nbytes);
(void) close(fd);
return (PICL_SUCCESS);
}
static int
set_sys_tach(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd, val;
int8_t cfg;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(SYS_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
(void) memcpy(&val, buf, sizeof (val));
if (val == ENABLE) {
cfg |= TACH_ENABLE_MASK;
} else if (val == DISABLE) {
cfg &= ~TACH_ENABLE_MASK;
}
if (ioctl(fd, ADM1031_SET_CONFIG_2, &cfg) == -1) {
return (PICL_FAILURE);
}
(void) close(fd);
return (PICL_SUCCESS);
}
static int
get_monitor_cpu_mode(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd;
int8_t mmode;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(CPU_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_MONITOR_MODE, &mmode) == -1) {
return (PICL_FAILURE);
}
if (mmode == ADM1031_AUTO_MODE) {
*((int *)tuneablep->value) = ENABLE;
} else {
*((int *)tuneablep->value) = DISABLE;
}
(void) memcpy(buf, tuneablep->value,
tuneablep->nbytes);
(void) close(fd);
return (PICL_SUCCESS);
}
static int
set_monitor_cpu_mode(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd, val;
int8_t mmode;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(CPU_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
(void) memcpy(&val, buf, sizeof (val));
if (val == ENABLE) {
mmode = ADM1031_AUTO_MODE;
} else if (val == DISABLE) {
mmode = ADM1031_MANUAL_MODE;
}
if (ioctl(fd, ADM1031_SET_MONITOR_MODE, &mmode) == -1) {
return (PICL_FAILURE);
}
(void) close(fd);
return (PICL_SUCCESS);
}
static int
get_monitor_sys_mode(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd;
int8_t mmode;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(SYS_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
if (ioctl(fd, ADM1031_GET_MONITOR_MODE, &mmode) == -1) {
return (PICL_FAILURE);
}
if (mmode == ADM1031_AUTO_MODE) {
*((int *)tuneablep->value) = ENABLE;
} else {
*((int *)tuneablep->value) = DISABLE;
}
(void) memcpy(buf, tuneablep->value,
tuneablep->nbytes);
(void) close(fd);
return (PICL_SUCCESS);
}
static int
set_monitor_sys_mode(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
int fd, val;
int8_t mmode;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
fd = open(SYS_HWM_DEVFS, O_RDWR);
if (fd == -1) {
return (PICL_FAILURE);
}
(void) memcpy(&val, buf, sizeof (val));
if (val == ENABLE) {
mmode = ADM1031_AUTO_MODE;
} else if (val == DISABLE) {
mmode = ADM1031_MANUAL_MODE;
}
if (ioctl(fd, ADM1031_SET_MONITOR_MODE, &mmode) == -1) {
return (PICL_FAILURE);
}
(void) close(fd);
return (PICL_SUCCESS);
}
static int
get_string_val(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
(void) memcpy(buf, (caddr_t)tuneablep->value,
tuneablep->nbytes);
return (PICL_SUCCESS);
}
static int
set_string_val(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
(void) memcpy((caddr_t)tuneables->value, (caddr_t)buf,
tuneables->nbytes);
return (PICL_SUCCESS);
}
static int
get_int_val(ptree_rarg_t *parg, void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
(void) memcpy((int *)buf, (int *)tuneablep->value,
tuneablep->nbytes);
return (PICL_SUCCESS);
}
static int
set_int_val(ptree_warg_t *parg, const void *buf)
{
picl_prophdl_t proph;
env_tuneable_t *tuneablep;
if (parg->cred.dc_euid != 0)
return (PICL_PERMDENIED);
proph = parg->proph;
tuneablep = tuneable_lookup(proph);
if (tuneablep == NULL)
return (PICL_FAILURE);
(void) memcpy((int *)tuneablep->value, (int *)buf,
tuneablep->nbytes);
return (PICL_SUCCESS);
}
int
get_dimm_fan_speed(int fan_fd, fanspeed_t *fanspeedp)
{
int16_t dimm_fan_period;
i2c_reg_t i2c_reg;
/*
* The dimm fan period is 16 bit value and we need to read
* registers 2 and 3 to get the LSB and MSB values.
*/
i2c_reg.reg_num = PIC16F819_FAN_PERIOD_MSB_REGISTER;
if (ioctl(fan_fd, I2C_GET_REG, &i2c_reg) == -1) {
if (env_debug)
envd_log(LOG_ERR,
"Error in reading FAN_PERIOD MSB REGISTER\n");
return (-1);
}
dimm_fan_period = (i2c_reg.reg_value << 8);
i2c_reg.reg_num = PIC16F819_FAN_PERIOD_LSB_REGISTER;
if (ioctl(fan_fd, I2C_GET_REG, &i2c_reg) == -1) {
if (env_debug)
envd_log(LOG_ERR,
"Error in reading FAN_PERIOD LSB REGISTER\n");
return (-1);
}
dimm_fan_period |= i2c_reg.reg_value;
if (env_debug)
envd_log(LOG_ERR,
" dimm fan tach period is 0x%x\n", dimm_fan_period);
if (dimm_fan_period == 0) {
if (env_debug)
envd_log(LOG_ERR,
"dimm fan tach period read as zero. Illegal value.\n");
return (-1);
}
*fanspeedp = PIC16F819_FAN_TACH_TO_RPM(dimm_fan_period);
return (0);
}
int
is_dimm_fan_failed(void)
{
i2c_reg_t i2c_reg;
fanspeed_t fan_speed;
int retry_count;
if (envd_dimm_fan.fd == -1)
return (-1);
/*
* read register 1 to look at Fan fault bit.
*/
i2c_reg.reg_num = PIC16F819_STATUS_REGISTER;
retry_count = MAX_RETRIES_FOR_PIC16F819_REG_READ;
while (retry_count > 0) {
if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
retry_count--;
continue;
} else break;
}
if (retry_count != MAX_RETRIES_FOR_PIC16F819_REG_READ) {
if (env_debug)
envd_log(LOG_ERR,
"%d retries attempted in reading STATUS register.\n",
(MAX_RETRIES_FOR_PIC16F819_REG_READ - retry_count));
}
if (retry_count == 0) {
(void) strncpy(dimm_fan_status_string, NOT_AVAILABLE,
sizeof (dimm_fan_status_string));
(void) strncpy(dimm_fan_command_string, NOT_AVAILABLE,
sizeof (dimm_fan_command_string));
(void) strncpy(dimm_fan_debug_string, NOT_AVAILABLE,
sizeof (dimm_fan_debug_string));
(void) strncpy(dimm_fan_rpm_string, NOT_AVAILABLE,
sizeof (dimm_fan_rpm_string));
return (-1);
}
if (env_debug)
envd_log(LOG_ERR,
"DIMM FAN STATUS reg = 0x%x\n", i2c_reg.reg_value);
if (i2c_reg.reg_value & PIC16F819_FAN_FAILED) {
(void) snprintf(dimm_fan_status_string,
sizeof (dimm_fan_status_string), "0x%x",
i2c_reg.reg_value);
i2c_reg.reg_num = PIC16F819_DEBUG_REGISTER;
if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
(void) strncpy(dimm_fan_debug_string, NOT_AVAILABLE,
sizeof (dimm_fan_debug_string));
} else {
(void) snprintf(dimm_fan_debug_string,
sizeof (dimm_fan_debug_string),
"0x%x", i2c_reg.reg_value);
}
i2c_reg.reg_num = PIC16F819_COMMAND_REGISTER;
if (ioctl(envd_dimm_fan.fd, I2C_GET_REG, &i2c_reg) == -1) {
(void) strncpy(dimm_fan_command_string, NOT_AVAILABLE,
sizeof (dimm_fan_command_string));
} else {
(void) snprintf(dimm_fan_command_string,
sizeof (dimm_fan_command_string),
"0x%x", i2c_reg.reg_value);
}
if (get_dimm_fan_speed(envd_dimm_fan.fd, &fan_speed) == -1) {
(void) strncpy(dimm_fan_rpm_string, NOT_AVAILABLE,
sizeof (dimm_fan_rpm_string));
} else {
(void) snprintf(dimm_fan_rpm_string,
sizeof (dimm_fan_rpm_string),
"%d", fan_speed);
}
return (1);
} else return (0);
}