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; } }