static void set_sensor_event_enable_masks(ipmi_sensor_t *sensor,
void *cb_data)
{
struct ohoi_sensor_event_enable_masks *enable_data;
int rv;
ipmi_event_state_t info;
enable_data = cb_data;
if (ignore_sensor(sensor)) {
dbg("sensor is ignored");
enable_data->done = 1;
enable_data->rvalue = SA_ERR_HPI_INTERNAL_ERROR;
return;
}
ipmi_event_state_init(&info);
if (enable_data->enable == SAHPI_TRUE)
ipmi_event_state_set_events_enabled(&info, 1);
else
ipmi_event_state_set_events_enabled(&info, 0);
if ((ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_PER_STATE)||
(ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_ENTIRE_SENSOR)) {
int i;
for (i = 0; i < 32 ; i++) {
if (enable_data->assert & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_ASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_ASSERTION);
if (enable_data->deassert & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_DEASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_DEASSERTION);
}
}
rv = ipmi_sensor_events_enable_set(sensor, &info, set_data,
&enable_data->done);
if (rv) {
dbg("Unable to sensor event enable: 0x%x\n", rv);
enable_data->done = 1;
enable_data->rvalue = SA_ERR_HPI_INTERNAL_ERROR;
}
}
static int insert_events_to_ipmi_event_state(
ipmi_sensor_t *sensor,
ipmi_event_state_t *state,
SaHpiEventStateT a_mask,
SaHpiEventStateT d_mask,
unsigned int a_sup,
unsigned int d_sup)
{
int i;
if (ipmi_sensor_get_event_support(sensor) !=
IPMI_EVENT_SUPPORT_PER_STATE) {
return 0;
}
if (ipmi_sensor_get_event_reading_type(sensor) !=
IPMI_EVENT_READING_TYPE_THRESHOLD) {
// discrete sensor. map states 1:1
if ((a_mask &~a_sup) || (d_mask & ~d_sup)) {
return 1;
}
for (i = 0; i < 15; i++) {
if (a_mask & (1 << i)) {
ipmi_discrete_event_set(state, i,
IPMI_ASSERTION);
}
if (d_mask & (1 << i)) {
ipmi_discrete_event_set(state, i,
IPMI_DEASSERTION);
}
}
return 0;
}
// threhold sensor;
// set assertion mask
if (a_mask & SAHPI_ES_LOWER_MINOR) {
if (a_sup & OHOI_THS_LMINL) {
ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL,
IPMI_GOING_LOW, IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_LMINH) {
ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL,
IPMI_GOING_HIGH, IPMI_DEASSERTION);
} else {
return 1;
}
}
if (a_mask & SAHPI_ES_LOWER_MAJOR) {
if (a_sup & OHOI_THS_LMAJL) {
ipmi_threshold_event_set(state, IPMI_LOWER_CRITICAL,
IPMI_GOING_LOW, IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_LMAJH) {
ipmi_threshold_event_set(state, IPMI_LOWER_CRITICAL,
IPMI_GOING_HIGH, IPMI_DEASSERTION);
} else {
return 1;
}
}
if (a_mask & SAHPI_ES_LOWER_CRIT) {
if (a_sup & OHOI_THS_LCRTL) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW,
IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_LCRTH) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH,
IPMI_DEASSERTION);
} else {
return 1;
}
}
if (a_mask & SAHPI_ES_UPPER_MINOR) {
if (a_sup & OHOI_THS_UMINH) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH,
IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_UMINL) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW,
IPMI_DEASSERTION);
} else {
return 1;
}
}
if (a_mask & SAHPI_ES_UPPER_MAJOR) {
if (a_sup & OHOI_THS_UMAJH) {
ipmi_threshold_event_set(state, IPMI_UPPER_CRITICAL,
IPMI_GOING_HIGH, IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_UMAJL) {
ipmi_threshold_event_set(state, IPMI_UPPER_CRITICAL,
IPMI_GOING_LOW, IPMI_DEASSERTION);
} else {
return 1;
}
}
if (a_mask & SAHPI_ES_UPPER_CRIT) {
if (a_sup & OHOI_THS_UCRTH) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH,
IPMI_ASSERTION);
} else if (d_sup & OHOI_THS_UCRTL) {
ipmi_threshold_event_set(state, IPMI_GOING_LOW,
IPMI_UPPER_NON_RECOVERABLE, IPMI_DEASSERTION);
} else {
return 1;
}
}
// set deassertion mask
if (d_mask & SAHPI_ES_LOWER_MINOR) {
if (d_sup & OHOI_THS_LMINL) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_CRITICAL, IPMI_GOING_LOW,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_LMINH) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_CRITICAL, IPMI_GOING_HIGH,
IPMI_ASSERTION);
} else {
return 1;
}
}
if (d_mask & SAHPI_ES_LOWER_MAJOR) {
if (d_sup & OHOI_THS_LMAJL) {
ipmi_threshold_event_set(state,
IPMI_LOWER_CRITICAL, IPMI_GOING_LOW,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_LMAJH) {
ipmi_threshold_event_set(state, IPMI_GOING_HIGH,
IPMI_LOWER_CRITICAL, IPMI_ASSERTION);
} else {
return 1;
}
}
if (d_mask & SAHPI_ES_LOWER_CRIT) {
if (d_sup & OHOI_THS_LCRTL) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_LCRTH) {
ipmi_threshold_event_set(state,
IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH,
IPMI_ASSERTION);
} else {
return 1;
}
}
if (d_mask & SAHPI_ES_UPPER_MINOR) {
if (d_sup & OHOI_THS_UMINH) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_UMINL) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW,
IPMI_ASSERTION);
} else {
return 1;
}
}
if (d_mask & SAHPI_ES_UPPER_MAJOR) {
if (d_sup & OHOI_THS_UMAJH) {
ipmi_threshold_event_set(state,
IPMI_UPPER_CRITICAL, IPMI_GOING_HIGH,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_UMAJL) {
ipmi_threshold_event_set(state, IPMI_GOING_LOW,
IPMI_UPPER_CRITICAL, IPMI_ASSERTION);
} else {
return 1;
}
}
if (d_mask & SAHPI_ES_UPPER_CRIT) {
if (d_sup & OHOI_THS_UCRTH) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH,
IPMI_DEASSERTION);
} else if (a_sup & OHOI_THS_UCRTL) {
ipmi_threshold_event_set(state,
IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_LOW,
IPMI_ASSERTION);
} else {
return 1;
}
}
return 0;
}
static void
sensor_rearm(ipmi_sensor_t *sensor, void *cb_data)
{
ipmi_cmd_info_t *cmd_info = cb_data;
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
int rv;
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
int argc = ipmi_cmdlang_get_argc(cmd_info);
char **argv = ipmi_cmdlang_get_argv(cmd_info);
int global;
ipmi_event_state_t *s = NULL;
if ((argc - curr_arg) < 1) {
cmdlang->errstr = "Not enough parameters";
cmdlang->err = EINVAL;
goto out_err;
}
if (strcmp(argv[curr_arg], "global") == 0) {
global = 1;
} else {
global = 0;
s = ipmi_mem_alloc(ipmi_event_state_size());
if (!s) {
cmdlang->errstr = "Out of memory";
cmdlang->err = ENOMEM;
goto out_err;
}
ipmi_event_state_init(s);
if (ipmi_sensor_get_event_reading_type(sensor)
== IPMI_EVENT_READING_TYPE_THRESHOLD)
{
enum ipmi_thresh_e thresh;
enum ipmi_event_value_dir_e value_dir;
enum ipmi_event_dir_e dir;
while (curr_arg < argc) {
ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh,
&value_dir, &dir, cmd_info);
if (cmdlang->err) {
goto out_err;
}
ipmi_threshold_event_set(s, thresh, value_dir, dir);
curr_arg++;
}
} else {
int offset;
enum ipmi_event_dir_e dir;
while (curr_arg < argc) {
ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset,
&dir, cmd_info);
if (cmdlang->err) {
goto out_err;
}
ipmi_discrete_event_set(s, offset, dir);
curr_arg++;
}
}
}
ipmi_cmdlang_cmd_info_get(cmd_info);
rv = ipmi_sensor_rearm(sensor, global, s, sensor_rearm_done, cmd_info);
if (rv) {
ipmi_cmdlang_cmd_info_put(cmd_info);
cmdlang->err = rv;
cmdlang->errstr = "Error rearming sensor";
goto out_err;
}
if (s)
ipmi_mem_free(s);
return;
out_err:
ipmi_sensor_get_name(sensor, cmdlang->objstr,
cmdlang->objstr_len);
cmdlang->location = "cmd_sensor.c(sensor_rearm)";
if (s)
ipmi_mem_free(s);
}
static void
mod_event_enables(ipmi_sensor_t *sensor, void *cb_data, enum ev_en_kind kind)
{
ipmi_cmd_info_t *cmd_info = cb_data;
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
int rv;
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
int argc = ipmi_cmdlang_get_argc(cmd_info);
char **argv = ipmi_cmdlang_get_argv(cmd_info);
ipmi_event_state_t *s = NULL;
if ((argc - curr_arg) < 2) {
/* Not enough parameters */
cmdlang->errstr = "Not enough parameters";
cmdlang->err = EINVAL;
goto out_err;
}
s = ipmi_mem_alloc(ipmi_states_size());
if (!s) {
cmdlang->errstr = "Out of memory";
cmdlang->err = ENOMEM;
goto out_err;
}
ipmi_event_state_init(s);
if (strcmp(argv[curr_arg], "msg") == 0)
ipmi_event_state_set_events_enabled(s, 1);
else if (strcmp(argv[curr_arg], "nomsg") == 0)
ipmi_event_state_set_events_enabled(s, 0);
else {
cmdlang->errstr = "Invalid message enable setting";
cmdlang->err = EINVAL;
goto out_err;
}
curr_arg++;
if (strcmp(argv[curr_arg], "scan") == 0)
ipmi_event_state_set_scanning_enabled(s, 1);
else if (strcmp(argv[curr_arg], "noscan") == 0)
ipmi_event_state_set_scanning_enabled(s, 0);
else {
cmdlang->errstr = "Invalid scanning enable setting";
cmdlang->err = EINVAL;
goto out_err;
}
curr_arg++;
if (ipmi_sensor_get_event_reading_type(sensor)
== IPMI_EVENT_READING_TYPE_THRESHOLD)
{
while (curr_arg < argc) {
enum ipmi_thresh_e thresh;
enum ipmi_event_value_dir_e value_dir;
enum ipmi_event_dir_e dir;
ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh,
&value_dir, &dir, cmd_info);
if (cmdlang->err) {
goto out_err;
}
ipmi_threshold_event_set(s, thresh, value_dir, dir);
curr_arg++;
}
} else {
while (curr_arg < argc) {
int offset;
enum ipmi_event_dir_e dir;
ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset,
&dir, cmd_info);
if (cmdlang->err) {
goto out_err;
}
ipmi_discrete_event_set(s, offset, dir);
curr_arg++;
}
}
ipmi_cmdlang_cmd_info_get(cmd_info);
switch (kind) {
case ev_en_set:
rv = ipmi_sensor_set_event_enables(sensor, s,
sensor_set_event_enables_done,
cmd_info);
break;
case ev_en_enable:
rv = ipmi_sensor_enable_events(sensor, s,
sensor_set_event_enables_done,
cmd_info);
break;
case ev_en_disable:
rv = ipmi_sensor_disable_events(sensor, s,
sensor_set_event_enables_done,
cmd_info);
break;
default:
rv = EINVAL;
}
if (rv) {
ipmi_cmdlang_cmd_info_put(cmd_info);
cmdlang->err = rv;
cmdlang->errstr = "Error setting event enables";
goto out_err;
}
ipmi_mem_free(s);
return;
out_err:
ipmi_sensor_get_name(sensor, cmdlang->objstr,
cmdlang->objstr_len);
cmdlang->location = "cmd_sensor.c(sensor_set_event_enables)";
if (s)
ipmi_mem_free(s);
}
static void
got_events(ipmi_sensor_t *sensor,
int err,
ipmi_event_state_t *states,
void *cb_data)
{
sdata_t *sdata = cb_data;
int rv;
if (err) {
printf("Error 0x%x getting events for sensor %s\n", err, sdata->name);
goto out_err;
}
/* Turn on the general events for a sensor, since this at
least supports per-sensor enables. */
ipmi_event_state_set_events_enabled(sdata->es, 1);
ipmi_event_state_set_scanning_enabled(sdata->es, 1);
printf("Sensor %s event settings:\n", sdata->name);
if (sdata->state_sup != IPMI_EVENT_SUPPORT_PER_STATE) {
/* No per-state sensors, just do the global enable. */
} else if (ipmi_sensor_get_event_reading_type(sensor)
== IPMI_EVENT_READING_TYPE_THRESHOLD)
{
/* Check each event, print out the current state, and turn it
on in the events to set if it is available. */
enum ipmi_event_value_dir_e value_dir;
enum ipmi_event_dir_e dir;
enum ipmi_thresh_e thresh;
int val;
for (value_dir=IPMI_GOING_LOW; value_dir<=IPMI_GOING_HIGH; value_dir++)
{
for (dir=IPMI_ASSERTION; dir<=IPMI_DEASSERTION; dir++) {
for (thresh=IPMI_LOWER_NON_CRITICAL;
thresh<=IPMI_UPPER_NON_RECOVERABLE;
thresh++)
{
char *v;
rv = ipmi_sensor_threshold_event_supported
(sensor, thresh, value_dir, dir, &val);
if (rv || !val)
continue;
if (ipmi_is_threshold_event_set(states, thresh,
value_dir, dir))
v = "";
else
v = " not";
printf(" %s %s %s was%s enabled\n",
ipmi_get_threshold_string(thresh),
ipmi_get_value_dir_string(value_dir),
ipmi_get_event_dir_string(dir),
v);
ipmi_threshold_event_set(sdata->es, thresh,
value_dir, dir);
}
}
}
} else {
/* Check each event, print out the current state, and turn it
on in the events to set if it is available. */
enum ipmi_event_dir_e dir;
int i;
for (dir=IPMI_ASSERTION; dir<=IPMI_DEASSERTION; dir++) {
for (i=0; i<15; i++) {
char *v;
int val;
rv = ipmi_sensor_discrete_event_supported
(sensor, i, dir, &val);
if (rv || !val)
continue;
if (ipmi_is_discrete_event_set(states, i, dir))
v = "";
else
v = " not";
printf(" bit %d %s was%s enabled\n",
i,
ipmi_get_event_dir_string(dir),
v);
ipmi_discrete_event_set(sdata->es, i, dir);
}
}
}
rv = ipmi_sensor_set_event_enables(sensor, sdata->es,
event_set_done, sdata);
if (rv) {
printf("Error 0x%x enabling events for sensor %s\n", err, sdata->name);
goto out_err;
}
return;
out_err:
release_sdata(sdata);
}
static void set_sensor_event_enables(ipmi_sensor_t *sensor,
void *cb_data)
{
struct ohoi_sensor_enables *enables_data;
int rv;
ipmi_event_state_t info;
enables_data = cb_data;
if (ignore_sensor(sensor)) {
dbg("sensor is ignored");
enables_data->done = 1;
return;
}
ipmi_event_state_init(&info);
if (*enables_data->enables == SAHPI_TRUE)
ipmi_event_state_set_events_enabled(&info, 1);
else
ipmi_event_state_set_events_enabled(&info, 0);
rv = ipmi_sensor_events_enable_set(sensor, &info, set_data,
&enables_data->done);
if (rv) {
dbg("Unable to sensor event enables: 0x%x\n", rv);
enables_data->done = 1;
}
#if 0
if ((ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_PER_STATE)||
(ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_ENTIRE_SENSOR)) {
ipmi_event_state_init(&info);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_EVENTS_ENABLED)
ipmi_event_state_set_events_enabled(&info, 1);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_SCAN_ENABLED)
ipmi_event_state_set_scanning_enabled(&info, 1);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_BUSY)
ipmi_event_state_set_busy(&info, 1);
for (i = 0; i < 32; i++) {
if (enables_data->sensor_enables->AssertEvents & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_ASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_ASSERTION);
if (enables_data->sensor_enables->DeassertEvents & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_DEASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_DEASSERTION);
}
rv = ipmi_sensor_events_enable_set(sensor, &info, set_data,
&enables_data->done);
if (rv) {
dbg("Unable to sensor event enables: 0x%x\n", rv);
enables_data->done = 1;
}
} else {
dbg("%#x", ipmi_sensor_get_event_support(sensor));
enables_data->done = 1;
}
#endif
}
static void set_sensor_event_enables(ipmi_sensor_t *sensor,
void *cb_data)
{
struct ohoi_sensor_enables *enables_data;
int rv;
ipmi_event_state_t info;
int i;
enables_data = cb_data;
if (is_ignored_sensor(sensor)) {
dbg("sensor is ignored");
enables_data->done = 1;
return;
}
if ((ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_PER_STATE)||
(ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_ENTIRE_SENSOR)) {
ipmi_event_state_init(&info);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_EVENTS_ENABLED)
ipmi_event_state_set_events_enabled(&info, 1);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_SCAN_ENABLED)
ipmi_event_state_set_scanning_enabled(&info, 1);
if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_BUSY)
ipmi_event_state_set_busy(&info, 1);
#if 0
if ( enables_data->sensor_enables->AssertEvents == 0xffff ) {
/* enable all assertion events */
info.__assertion_events = 0;
for( i = 0; i < 12; i++ ) {
int val = 0;
if ( ipmi_sensor_get_event_reading_type( sensor ) == IPMI_EVENT_READING_TYPE_THRESHOLD )
ipmi_sensor_threshold_assertion_event_supported( sensor, 0, i, &val );
else
ipmi_sensor_discrete_assertion_event_supported( sensor, i, &val );
if ( val )
info.__assertion_events |= (1 << i);
}
} else
info.__assertion_events = enables_data->sensor_enables->AssertEvents;
if ( enables_data->sensor_enables->DeassertEvents == 0xffff ) {
/* enable all deassertion events */
info.__deassertion_events = 0;
for( i = 0; i < 12; i++ ) {
int val = 0;
if ( ipmi_sensor_get_event_reading_type( sensor ) == IPMI_EVENT_READING_TYPE_THRESHOLD )
ipmi_sensor_threshold_deassertion_event_supported( sensor, 0, i, &val );
else
ipmi_sensor_discrete_deassertion_event_supported( sensor, i, &val );
if ( val )
info.__deassertion_events |= (1 << i);
}
} else
info.__deassertion_events = enables_data->sensor_enables->DeassertEvents;
#endif
for (i = 0; i < 32; i++) {
if (enables_data->sensor_enables->AssertEvents & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_ASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_ASSERTION);
if (enables_data->sensor_enables->DeassertEvents & 1<<i )
ipmi_discrete_event_set(&info, i, IPMI_DEASSERTION);
else
ipmi_discrete_event_clear(&info, i, IPMI_DEASSERTION);
}
rv = ipmi_sensor_events_enable_set(sensor, &info, set_data,
&enables_data->done);
if (rv) {
dbg("Unable to sensor event enables: 0x%x\n", rv);
enables_data->done = 1;
}
} else {
dbg("%#x", ipmi_sensor_get_event_support(sensor));
enables_data->done = 1;
}
}
