static void get_sensor_event_enables(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_enables *enables_data; int rv; enables_data = cb_data; if (ignore_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)){ rv = ipmi_sensor_events_enable_get(sensor, enables_read, enables_data); if (rv) { dbg("Unable to sensor event enables: 0x%x\n", rv); enables_data->done = 1; return; } } else { dbg("Sensor do not support event"); enables_data->done = 1; } }
static void get_sensor_event_enable_masks(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_event_enable_masks *enable_data; int rv; enable_data = cb_data; if (ignore_sensor(sensor)) { dbg("sensor is ignored"); enable_data->done = 1; enable_data->rvalue = SA_ERR_HPI_NOT_PRESENT; return; } if ((ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_PER_STATE)|| (ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_ENTIRE_SENSOR)){ rv = ipmi_sensor_get_event_enables(sensor, event_enable_masks_read, enable_data); if (rv) { dbg("Unable to sensor event enable: 0x%x\n", rv); enable_data->rvalue = SA_ERR_HPI_INTERNAL_ERROR; return; } } else { dbg("Sensor do not support event"); enable_data->assert = 0; enable_data->deassert = 0; enable_data->enable = SAHPI_FALSE; enable_data->rvalue = SA_OK; enable_data->done = 1; } }
static void add_sensor_event_sensor_rec(ipmi_sensor_t *sensor, SaHpiSensorRecT *rec) { ipmi_entity_t *ent; rec->Type = (SaHpiSensorTypeT)ipmi_sensor_get_sensor_type(sensor); rec->Category = (SaHpiEventCategoryT) ohoi_sensor_get_event_reading_type(sensor); rec->EventCtrl = (SaHpiSensorEventCtrlT) ipmi_sensor_get_event_support(sensor); /* Cannot find Events in IPMI. */ rec->Events = 0xffff; ent = ipmi_sensor_get_entity(sensor); #if 0 if (ipmi_entity_is_present(ent)) rec->Ignore = SAHPI_FALSE; else rec->Ignore = SAHPI_TRUE; #endif add_sensor_event_data_format(sensor, rec); add_sensor_event_thresholds(sensor, rec); /* We do not care about oem. */ rec->Oem = 0; }
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 void add_sensor_event_rdr(ipmi_sensor_t *sensor, SaHpiRdrT *rdr, SaHpiEntityPathT parent_ep, SaHpiResourceIdT res_id) { char name[32]; //SaHpiEntityPathT rdr_ep; memset(name,'\0',32); rdr->RecordId = 0; rdr->RdrType = SAHPI_SENSOR_RDR; //rdr->Entity.Entry[0].EntityType = (SaHpiEntityTypeT)id; //rdr->Entity.Entry[0].EntityLocation = (SaHpiEntityLocationT)instance; //rdr->Entity.Entry[1].EntityType = 0; //rdr->Entity.Entry[1].EntityLocation = 0; rdr->Entity = parent_ep; /* append ep */ //string2entitypath(entity_root, &rdr_ep); //ep_concat (&rdr->Entity, &rdr_ep); add_sensor_event_sensor_rec(sensor, &rdr->RdrTypeUnion.SensorRec); ipmi_sensor_get_id(sensor, name, 32); rdr->IdString.DataType = SAHPI_TL_TYPE_ASCII6; rdr->IdString.Language = SAHPI_LANG_ENGLISH; rdr->IdString.DataLength = 32; switch ( ipmi_sensor_get_event_support(sensor) ) { case IPMI_EVENT_SUPPORT_PER_STATE: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_PER_EVENT; break; /*Fix Me*/ #if 0 case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_ENTIRE_SENSOR; break; case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_GLOBAL_DISABLE; break; case IPMI_EVENT_SUPPORT_NONE: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_NO_EVENTS; break; #else case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR: case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_READ_ONLY_MASKS; break; case IPMI_EVENT_SUPPORT_NONE: rdr->RdrTypeUnion.SensorRec.EventCtrl = SAHPI_SEC_READ_ONLY; break; #endif } memcpy(rdr->IdString.Data,name, strlen(name) + 1); }
static void add_sensor_event_sensor_rec(ipmi_sensor_t *sensor, SaHpiSensorRecT *rec) { rec->Type = (SaHpiSensorTypeT)ipmi_sensor_get_sensor_type(sensor); rec->Category = (SaHpiEventCategoryT) ohoi_sensor_get_event_reading_type(sensor); rec->EventCtrl = (SaHpiSensorEventCtrlT) ipmi_sensor_get_event_support(sensor); /* Cannot find Events in IPMI. */ rec->Events = 0xffff; rec->Ignore = (SaHpiBoolT)ipmi_sensor_get_ignore_if_no_entity(sensor); add_sensor_event_data_format(sensor, rec); add_sensor_event_thresholds(sensor, rec); /* We do not care about oem. */ rec->Oem = 0; }
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_dump(ipmi_sensor_t *sensor, ipmi_cmd_info_t *cmd_info) { ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int num, lun; char *str; const char *cstr; int event_support; int event_reading_type; int len; int rv; int val; event_reading_type = ipmi_sensor_get_event_reading_type(sensor); ipmi_sensor_get_num(sensor, &lun, &num); ipmi_cmdlang_out_int(cmd_info, "LUN", lun); ipmi_cmdlang_out_int(cmd_info, "Number", num); ipmi_cmdlang_out_int(cmd_info, "Event Reading Type", ipmi_sensor_get_event_reading_type(sensor)); ipmi_cmdlang_out(cmd_info, "Event Reading Type Name", ipmi_sensor_get_event_reading_type_string(sensor)); ipmi_cmdlang_out_int(cmd_info, "Type", ipmi_sensor_get_sensor_type(sensor)); ipmi_cmdlang_out(cmd_info, "Type Name", ipmi_sensor_get_sensor_type_string(sensor)); val = ipmi_sensor_get_sensor_direction(sensor); if (val != IPMI_SENSOR_DIRECTION_UNSPECIFIED) ipmi_cmdlang_out(cmd_info, "Direction", ipmi_get_sensor_direction_string(val)); event_support = ipmi_sensor_get_event_support(sensor); switch (event_support) { case IPMI_EVENT_SUPPORT_PER_STATE: ipmi_cmdlang_out(cmd_info, "Event Support", "per state"); break; case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR: ipmi_cmdlang_out(cmd_info, "Event Support", "entire sensor"); break; case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: ipmi_cmdlang_out(cmd_info, "Event Support", "global"); break; default: break; } ipmi_cmdlang_out_bool(cmd_info, "Init Scanning", ipmi_sensor_get_sensor_init_scanning(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Events", ipmi_sensor_get_sensor_init_events(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Thresholds", ipmi_sensor_get_sensor_init_thresholds(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Hysteresis", ipmi_sensor_get_sensor_init_hysteresis(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Type", ipmi_sensor_get_sensor_init_type(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Events", ipmi_sensor_get_sensor_init_pu_events(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Scanning", ipmi_sensor_get_sensor_init_pu_scanning(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Ignore If No Entity", ipmi_sensor_get_ignore_if_no_entity(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Auto Rearm", ipmi_sensor_get_supports_auto_rearm(sensor)); ipmi_cmdlang_out_int(cmd_info, "OEM1", ipmi_sensor_get_oem1(sensor)); len = ipmi_sensor_get_id_length(sensor); if (len) { str = ipmi_mem_alloc(len); if (!str) { cmdlang->err = ENOMEM; cmdlang->errstr = "Out of memory"; goto out_err; } len = ipmi_sensor_get_id(sensor, str, len); ipmi_cmdlang_out_type(cmd_info, "Id", ipmi_sensor_get_id_type(sensor), str, len); ipmi_mem_free(str); } if (event_reading_type == IPMI_EVENT_READING_TYPE_THRESHOLD) { int access = ipmi_sensor_get_threshold_access(sensor); enum ipmi_thresh_e thresh; enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; int rv; char th_name[50]; double dval; ipmi_cmdlang_out(cmd_info, "Threshold Access", ipmi_get_threshold_access_support_string(access)); for (thresh = IPMI_LOWER_NON_CRITICAL; thresh <= IPMI_UPPER_NON_RECOVERABLE; thresh++) { rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val); if ((rv) || !val) continue; ipmi_cmdlang_out(cmd_info, "Threshold", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Name", ipmi_get_threshold_string(thresh)); rv = ipmi_sensor_threshold_readable(sensor, thresh, &val); if (rv) val = 0; ipmi_cmdlang_out_bool(cmd_info, "Readable", val); rv = ipmi_sensor_threshold_settable(sensor, thresh, &val); if (rv) val = 0; ipmi_cmdlang_out_bool(cmd_info, "Settable", val); for (value_dir = IPMI_GOING_LOW; value_dir <= IPMI_GOING_HIGH; value_dir++) { for (dir = IPMI_ASSERTION; dir <= IPMI_DEASSERTION; dir++) { rv = ipmi_sensor_threshold_event_supported(sensor, thresh, value_dir, dir, &val); if (rv || !val) continue; snprintf(th_name, sizeof(th_name), "%s %s", ipmi_get_value_dir_string(value_dir), ipmi_get_event_dir_string(dir)); ipmi_cmdlang_out(cmd_info, "Supports", th_name); } } ipmi_cmdlang_up(cmd_info); } val = ipmi_sensor_get_hysteresis_support(sensor); ipmi_cmdlang_out(cmd_info, "Hysteresis Support", ipmi_get_hysteresis_support_string(val)); #if 0 /* FIXME - no accuracy handling */ int ipmi_sensor_get_accuracy(ipmi_sensor_t *sensor, int val, double *accuracy); #endif rv = ipmi_sensor_get_nominal_reading(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Nominal Reading", dval); rv = ipmi_sensor_get_normal_max(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Normal Max", dval); rv = ipmi_sensor_get_normal_min(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Normal Min", dval); rv = ipmi_sensor_get_sensor_max(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Sensor Max", dval); rv = ipmi_sensor_get_sensor_min(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Sensor Min", dval); ipmi_cmdlang_out_int(cmd_info, "Base Unit", ipmi_sensor_get_base_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Base Unit Name", ipmi_sensor_get_base_unit_string(sensor)); cstr = ipmi_sensor_get_rate_unit_string(sensor); if (strlen(cstr)) { ipmi_cmdlang_out_int(cmd_info, "Rate Unit", ipmi_sensor_get_rate_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Rate Unit Name", cstr); } switch (ipmi_sensor_get_modifier_unit_use(sensor)) { case IPMI_MODIFIER_UNIT_BASE_DIV_MOD: ipmi_cmdlang_out(cmd_info, "Modifier Use", "/"); ipmi_cmdlang_out_int(cmd_info, "Modifier Unit", ipmi_sensor_get_modifier_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Modifier Unit Name", ipmi_sensor_get_modifier_unit_string(sensor)); break; case IPMI_MODIFIER_UNIT_BASE_MULT_MOD: ipmi_cmdlang_out(cmd_info, "Modifier Use", "*"); ipmi_cmdlang_out_int(cmd_info, "Modifier Unit", ipmi_sensor_get_modifier_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Modifier Unit Name", ipmi_sensor_get_modifier_unit_string(sensor)); break; default: break; } if (ipmi_sensor_get_percentage(sensor)) ipmi_cmdlang_out(cmd_info, "Percentage", "%"); } else { int event; enum ipmi_event_dir_e dir; for (event=0; event<15; event++) { rv = ipmi_sensor_discrete_event_readable(sensor, event, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Event", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out_int(cmd_info, "Offset", event); cstr = ipmi_sensor_reading_name_string(sensor, event); if (strcmp(cstr, "unknown") != 0) ipmi_cmdlang_out(cmd_info, "Name", cstr); for (dir = IPMI_ASSERTION; dir <= IPMI_DEASSERTION; dir++) { rv = ipmi_sensor_discrete_event_supported(sensor, event, dir, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Supports", ipmi_get_event_dir_string(dir)); } ipmi_cmdlang_up(cmd_info); } } return; out_err: ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_dump)"; }
/* Whenever the status of a sensor changes, the function is called We display the information of the sensor if we find a new sensor */ static void sensor_change(enum ipmi_update_e op, ipmi_entity_t *ent, ipmi_sensor_t *sensor, void *cb_data) { sdata_t *sdata; int rv; if (op == IPMI_ADDED) { sdata = alloc_sdata(sensor); if (!sdata) { printf("Unable to allocate sensor name memory\n"); return; } printf("Sensor added: %s\n", sdata->name); /* Get the current reading. */ if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { use_sdata(sdata); rv = ipmi_sensor_get_reading(sensor, got_thresh_reading, sdata); if (rv) { printf("ipmi_reading_get returned error 0x%x for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } else { use_sdata(sdata); rv = ipmi_sensor_get_states(sensor, got_discrete_states, sdata); if (rv) { printf("ipmi_states_get returned error 0x%x for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } /* Set up events. */ sdata->state_sup = ipmi_sensor_get_event_support(sensor); switch (sdata->state_sup) { case IPMI_EVENT_SUPPORT_NONE: case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: /* No events to set up. */ printf("Sensor %s has no event support\n", sdata->name); goto get_thresh; } use_sdata(sdata); rv = ipmi_sensor_get_event_enables(sensor, got_events, sdata); if (rv) { printf("ipmi_sensor_events_enable_get returned error 0x%x" " for sensor %s\n", rv, sdata->name); release_sdata(sdata); } get_thresh: /* Handle the threshold settings. */ if (ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) /* Thresholds only for threshold sensors (duh) */ goto out; sdata->thresh_sup = ipmi_sensor_get_threshold_access(sensor); switch (sdata->thresh_sup) { case IPMI_THRESHOLD_ACCESS_SUPPORT_NONE: printf("Sensor %s has no threshold support\n", sdata->name); goto out; case IPMI_THRESHOLD_ACCESS_SUPPORT_FIXED: printf("Sensor %s has fixed threshold support\n", sdata->name); goto out; } use_sdata(sdata); rv = ipmi_sensor_get_thresholds(sensor, got_thresholds, sdata); if (rv) { printf("ipmi_thresholds_get returned error 0x%x" " for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } else if (op == IPMI_DELETED) { sdata = find_sdata(sensor); if (!sdata) { char name[120]; ipmi_sensor_get_name(sensor, name, sizeof(name)); printf("sensor %s was deleted but not found in the sensor db\n", name); goto out; } printf("sensor %s was deleted\n", sdata->name); release_sdata(sdata); } out: return; }
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; } }