lw8/sys/sgenv.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2000 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_SGENV_H
#define _SYS_SGENV_H

#pragma ident   "%Z%%M% %I% %E% SMI"

#ifdef  __cplusplus
extern "C" {
#endif

/*
 * sgenv.h - Serengeti Environmental Driver
 *
 * This header file contains the environmental definitions for
 * the Serengeti platform.
 *
 * It contains all the information necessary to obtain the required
 * data from the kstats which export the environmental data. The
 * following information is exported.
 *
 *  o Board status information
 *  o Keyswitch position
 *  o Environmental Readings
 */

#include <sys/time.h>       /* hrtime_t */
#include <sys/sgenv_tag.h>  /* TagID information */
#include <sys/sgfrutypes.h> /* HPU type information */
#include <sys/serengeti.h>

#define SGENV_DRV_NAME      "sgenv"

/*
 * Board Status Information
 * ========================
 */

/* name of kstat returning board status info */
#define SG_BOARD_STATUS_KSTAT_NAME  "sg_board_status"

/* Masks to determine which LEDs are on */
#define SG_HOTPLUG_LED_MASK 0x1
#define SG_FAULT_LED_MASK   0x2
#define SG_POWER_LED_MASK   0x4

/*
 * Calculate the number of boards, who's info readings that were
 * returned by this kstat
 */
#define SGENV_NUM_BOARD_READINGS(ksp)   ((ksp)->ks_data_size /  \
                        (sizeof (sg_board_info_t)))

typedef union sg_led {
    struct {
        int _pad    :29,    /* MSB */
            power   :1,
            fault   :1,
            hotplug :1; /* LSB */
    } status;

    int led_status;

} sg_led_t;

typedef struct sg_board_info {
    int node_id;
    int board_num;

    int condition;  /* see <sbd_cond_t> in <sbdp_ioctl.h> */
    int assigned;
    int claimed;
    int present;    /* 1 if board is present in Domain */

    sg_led_t    led;

} sg_board_info_t;


/*
 * Keyswitch Information
 * =====================
 */

/* name of kstat returning keyswitch info */
#define SG_KEYSWITCH_KSTAT_NAME     "sg_keyswitch"

/*
 * Kstat structure used to pass Keyswitch data to userland.
 *
 * The position is stored in the 32-bit integer value of the
 * kstat_named_t union <keyswitch_position>.
 *
 * (i.e.  to get the position - read keyswitch_position.value.ui32)
 */
typedef struct {
    kstat_named_t   keyswitch_position; /* position */

} sg_keyswitch_kstat_t;


/*
 * Environmental Information
 * =========================
 *
 * the environmental kstat exports an array of env_sensor_t structs
 */

#define SG_ENV_INFO_KSTAT_NAME      "sg_env_info"


/*
 * sd_infostamp access macros and return values
 *
 * N.b. None of the values need shifting.  This means the
 *  UTC time in nanoseconds since The Epoch has, at best,
 *  a resolution of c.256 nanoseconds (since the lo-order
 *  c.8-bits are overlaid with other information).
 */

#define SG_INFO_TIMESTATUS(info)    ((int)((info) & _SG_INFO_TIMSTSMSK))
#define SG_INFO_VALUESTATUS(info)   ((int)((info) & _SG_INFO_VALSTSMSK))
#define SG_INFO_NANOSECONDS(info) ((hrtime_t)((info) & _SG_INFO_TIMVALMSK))

#define _SG_INFO_TIMSTSMSK      ((sensor_status_t)0x0F)
#define SG_INFO_TIME_OK         0x00  /* always 0 */
#define SG_INFO_TIME_NOT_KNOWN      0x01
#define SG_INFO_TIME_NOT_AVAILABLE  0x02

#define _SG_INFO_VALSTSMSK      ((sensor_status_t)0xF0)
#define SG_INFO_VALUE_OK        0x00  /* always 0 */
#define SG_INFO_VALUE_NOT_POSSIBLE  0x10
#define SG_INFO_VALUE_NOT_AVAILABLE 0x20

#define _SG_INFO_TIMVALMSK  \
        (((hrtime_t)~0) & ~(_SG_INFO_TIMSTSMSK | _SG_INFO_VALSTSMSK))


/* Calculate the number of sensor readings that were returned by this kstat */
#define SGENV_NUM_ENV_READINGS(ksp) ((ksp)->ks_data_size /  \
                        (sizeof (env_sensor_t)))

/* used to calculate the status of a sensor reading from <sd_status> */
#define SG_STATUS_SHIFT             16
#define SG_STATUS_MASK              0xFFFF
#define SG_PREV_STATUS_MASK         0xFFFF0000

#define SG_GET_SENSOR_STATUS(status)        ((status) & SG_STATUS_MASK)
#define SG_GET_PREV_SENSOR_STATUS(status)   ((status) >> SG_STATUS_SHIFT)

#define SG_SET_SENSOR_STATUS(status, value) \
        status &= ~SG_STATUS_MASK; \
        status |= ((value) & SG_STATUS_MASK)

#define SG_SET_PREV_SENSOR_STATUS(status, value) \
        status &= ~SG_PREV_STATUS_MASK; \
        status |= (((value) & SG_STATUS_MASK) << SG_STATUS_SHIFT)


typedef int32_t     sensor_data_t;
typedef hrtime_t    sensor_status_t;

/*
 * The possible states a sensor reading can be in.
 */
typedef enum env_sensor_status {
    SG_SENSOR_STATUS_OK     = 0x01,
    SG_SENSOR_STATUS_LO_WARN    = 0x02,
    SG_SENSOR_STATUS_HI_WARN    = 0x04,
    SG_SENSOR_STATUS_LO_DANGER  = 0x08,
    SG_SENSOR_STATUS_HI_DANGER  = 0x10,
    SG_SENSOR_STATUS_FAN_OFF    = 0x100,
    SG_SENSOR_STATUS_FAN_LOW    = 0x200,
    SG_SENSOR_STATUS_FAN_HIGH   = 0x400,
    SG_SENSOR_STATUS_FAN_FAIL   = 0x800,
    SG_SENSOR_STATUS_UNKNOWN    = 0x1000

} env_sensor_status_t;


/*
 * The raw env. info. kstat is made up of an array of these structures.
 */
typedef struct env_sensor {
    sensor_id_t     sd_id;      /* defined in sensor_tag.h */
    sensor_data_t       sd_value;
    sensor_data_t       sd_lo;
    sensor_data_t       sd_hi;
    sensor_data_t       sd_lo_warn;
    sensor_data_t       sd_hi_warn;
    sensor_status_t     sd_infostamp;
    env_sensor_status_t sd_status;

} env_sensor_t;


/*
 * Events Information
 * ==================
 */
#define SGENV_FAN_SPEED_UNKNOWN     (-1)
#define SGENV_FAN_SPEED_OFF     0
#define SGENV_FAN_SPEED_LOW     1
#define SGENV_FAN_SPEED_HIGH        2

#define SGENV_FAN_SPEED_UNKNOWN_STR "Unknown"
#define SGENV_FAN_SPEED_OFF_STR     "Off"
#define SGENV_FAN_SPEED_LOW_STR     "Low"
#define SGENV_FAN_SPEED_HIGH_STR    "High"

#define SGENV_EVENT_MSG_OK      "returned to the normal operating range"
#define SGENV_EVENT_MSG_LO_WARN     "dropped below low warning threshold"
#define SGENV_EVENT_MSG_HI_WARN     "exceeded high warning threshold"
#define SGENV_EVENT_MSG_LO_DANGER   "dropped below low warning limit"
#define SGENV_EVENT_MSG_HI_DANGER   "exceeded high warning limit"
#define SGENV_EVENT_MSG_UNKNOWN     "changed to an unknown status"


#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_SGENV_H */