static void set_thresholds_sensor_misc_event(ipmi_event_t *event,
SaHpiSensorEventT *e)
{
unsigned int type;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
type = data[10] >> 6;
if (type == EVENT_DATA_1) {
e->TriggerReading.IsSupported = SAHPI_TRUE;
e->TriggerReading.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
e->TriggerReading.Value.SensorUint64 = data[11];
}
else if (type == EVENT_DATA_2)
e->Oem = data[11];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[11];
type = (data[10] & 0x30) >> 4;
if (type == EVENT_DATA_1) {
e->TriggerReading.IsSupported = SAHPI_TRUE;
e->TriggerReading.Type = SAHPI_SENSOR_READING_TYPE_UINT64;
e->TriggerReading.Value.SensorUint64 = data[12];
}
else if (type == EVENT_DATA_2)
e->Oem = data[12];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[12];
}
static void set_thresholds_sensor_misc_event(ipmi_event_t *event,
SaHpiSensorEventT *e)
{
unsigned int type;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
type = data[10] >> 6;
if (type == EVENT_DATA_1) {
e->TriggerReading.ValuesPresent = SAHPI_SRF_RAW;
e->TriggerReading.Raw = data[11];
}
else if (type == EVENT_DATA_2)
e->Oem = data[11];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[11];
type = (data[10] & 0x30) >> 4;
if (type == EVENT_DATA_1) {
e->TriggerThreshold.ValuesPresent = SAHPI_SRF_RAW;
e->TriggerThreshold.Raw = data[12];
}
else if (type == EVENT_DATA_2)
e->Oem = data[12];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[12];
}
static void sensor_discrete_event(ipmi_sensor_t *sensor,
enum ipmi_event_dir_e dir,
int offset,
int severity,
int prev_severity,
void *cb_data,
ipmi_event_t *event)
{
struct oh_event *e;
struct oh_handler_state *handler;
ipmi_entity_id_t entity_id;
SaHpiRptEntryT *rpt_entry;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
handler = cb_data;
entity_id = ipmi_entity_convert_to_id(ipmi_sensor_get_entity(sensor));
rpt_entry = ohoi_get_resource_by_entityid(handler->rptcache, &entity_id);
if (!rpt_entry) {
dump_entity_id("Discrete Sensor without RPT?!", entity_id);
return;
}
e = malloc(sizeof(*e));
if (!e) {
dbg("Out of space");
return;
}
memset(e, 0, sizeof(*e));
e->type = OH_ET_HPI;
e->u.hpi_event.parent = rpt_entry->ResourceId;
e->u.hpi_event.event.Source = rpt_entry->ResourceId;
/* Do not find EventType in IPMI */
e->u.hpi_event.event.EventType = SAHPI_ET_SENSOR;
e->u.hpi_event.event.Timestamp
= (SaHpiTimeT)ipmi_get_uint32(data) * 1000000000;
e->u.hpi_event.event.Severity = (SaHpiSeverityT)severity;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorNum = 0;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorType = data[7];
e->u.hpi_event.event.EventDataUnion.SensorEvent.EventCategory
= data[9] & 0x7f;
e->u.hpi_event.event.EventDataUnion.SensorEvent.Assertion
= !(dir);
e->u.hpi_event.event.EventDataUnion.SensorEvent.EventState = severity;
e->u.hpi_event.event.EventDataUnion.SensorEvent.PreviousState = prev_severity;
set_discrete_sensor_misc_event
(event, &e->u.hpi_event.event.EventDataUnion.SensorEvent);
handler->eventq = g_slist_append(handler->eventq, e);
}
ipmi_sensor_id_t
ipmi_event_get_generating_sensor_id(ipmi_domain_t *domain,
ipmi_mc_t *sel_mc,
const ipmi_event_t *event)
{
ipmi_sensor_id_t id;
ipmi_mc_t *mc;
const unsigned char *data;
unsigned int type = ipmi_event_get_type(event);
if (type != 0x02)
/* It's not a standard IPMI event. */
goto out_invalid;
mc = _ipmi_event_get_generating_mc(domain, sel_mc, event);
if (!mc)
goto out_invalid;
data = ipmi_event_get_data_ptr(event);
id.mcid = ipmi_mc_convert_to_id(mc);
id.lun = data[5] & 0x3;
id.sensor_num = data[8];
_ipmi_mc_put(mc);
return id;
out_invalid:
ipmi_sensor_id_set_invalid(&id);
return id;
}
void
event_handler(ipmi_con_t *ipmi,
const ipmi_addr_t *addr,
unsigned int addr_len,
ipmi_event_t *event,
void *cb_data)
{
unsigned int record_id = ipmi_event_get_record_id(event);
unsigned int type = ipmi_event_get_type(event);
unsigned int data_len = ipmi_event_get_data_len(event);
const unsigned char *data = ipmi_event_get_data_ptr(event);
unsigned int i;
printf("Got event:\n");
printf(" %4.4x (%2.2x):", record_id, type);
for (i=0; i<data_len; i++)
printf(" %2.2x", data[i]);
printf("\n");
}
static void set_discrete_sensor_misc_event(ipmi_event_t *event,
SaHpiSensorEventT *e)
{
enum ohoi_event_type type;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
type = data[10] >> 6;
if (type == EVENT_DATA_2)
e->Oem = data[11];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[11];
type = (data[10] & 0x30) >> 4;
if (type == EVENT_DATA_2)
e->Oem = data[12];
else if (type == EVENT_DATA_3)
e->SensorSpecific = data[12];
}
ipmi_mc_t *
_ipmi_event_get_generating_mc(ipmi_domain_t *domain,
ipmi_mc_t *sel_mc,
const ipmi_event_t *event)
{
ipmi_ipmb_addr_t addr;
const unsigned char *data;
unsigned int type = ipmi_event_get_type(event);
if (type != 0x02)
/* It's not a standard IPMI event. */
return NULL;
data = ipmi_event_get_data_ptr(event);
addr.addr_type = IPMI_IPMB_ADDR_TYPE;
/* See if the MC has an OEM handler for this. */
if (data[6] == 0x03) {
addr.channel = 0;
} else {
addr.channel = data[5] >> 4;
}
if ((data[4] & 0x01) == 0) {
addr.slave_addr = data[4];
} else if (sel_mc) {
/* A software ID, assume it comes from the MC where we go it. */
ipmi_addr_t iaddr;
ipmi_mc_get_ipmi_address(sel_mc, &iaddr, NULL);
addr.slave_addr = ipmi_addr_get_slave_addr(&iaddr);
if (addr.slave_addr == 0)
/* A system interface, just assume it's the BMC. */
addr.slave_addr = 0x20;
} else {
return NULL;
}
addr.lun = 0;
return _ipmi_find_mc_by_addr(domain, (ipmi_addr_t *) &addr, sizeof(addr));
}
static void
set_discrete_sensor_event_state(ipmi_event_t *event,
SaHpiEventStateT *state)
{
enum ohoi_discrete_e e;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
e = data[10] & 0x7;
switch (e) {
case IPMI_TRANS_IDLE:
*state = SAHPI_ES_IDLE;
break;
case IPMI_TRANS_ACTIVE:
*state = SAHPI_ES_ACTIVE;
break;
case IPMI_TRANS_BUSY:
*state = SAHPI_ES_BUSY;
break;
}
}
static void sensor_threshold_event(ipmi_sensor_t *sensor,
enum ipmi_event_dir_e dir,
enum ipmi_thresh_e threshold,
enum ipmi_event_value_dir_e high_low,
enum ipmi_value_present_e value_present,
unsigned int raw_value,
double value,
void *cb_data,
ipmi_event_t *event)
{
struct oh_event *e;
struct oh_handler_state *handler;
ipmi_entity_id_t entity_id;
ipmi_sensor_id_t sensor_id;
SaHpiSeverityT severity;
SaHpiRptEntryT *rpt_entry;
SaHpiRdrT *rdr;
unsigned char *data;
data = ipmi_event_get_data_ptr(event);
handler = cb_data;
entity_id = ipmi_entity_convert_to_id(ipmi_sensor_get_entity(sensor));
sensor_id = ipmi_sensor_convert_to_id(sensor);
rpt_entry = ohoi_get_resource_by_entityid(handler->rptcache, &entity_id);
rdr = ohoi_get_rdr_by_data(handler->rptcache,
rpt_entry->ResourceId,
SAHPI_SENSOR_RDR,
&sensor_id);
if (!rdr) {
dbg("No rdr in resource:%d\n", rpt_entry->ResourceId);
return;
}
e = malloc(sizeof(*e));
if (!e) {
dbg("Out of space");
return;
}
memset(e, 0, sizeof(*e));
e->type = OH_ET_HPI;
e->u.hpi_event.parent = rpt_entry->ResourceId;
e->u.hpi_event.event.Source = 0;
/* Do not find EventType in IPMI */
e->u.hpi_event.event.EventType = SAHPI_ET_SENSOR;
e->u.hpi_event.event.Timestamp
= (SaHpiTimeT)ipmi_get_uint32(data) * 1000000000;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorNum
= rdr->RdrTypeUnion.SensorRec.Num;
e->u.hpi_event.event.EventDataUnion.SensorEvent.SensorType
= data[7];
e->u.hpi_event.event.EventDataUnion.SensorEvent.EventCategory
= data[9] & 0x7f;
set_thresholed_sensor_event_state(threshold, dir, high_low,
&e->u.hpi_event.event.EventDataUnion.SensorEvent,
&severity);
e->u.hpi_event.event.Severity = severity;
set_thresholds_sensor_misc_event
(event, &e->u.hpi_event.event.EventDataUnion.SensorEvent);
handler->eventq = g_slist_append(handler->eventq, e);
}
static void entity_presence(ipmi_entity_t *entity,
int present,
void *cb_data,
ipmi_event_t *event)
{
struct oh_handler_state *handler = (struct oh_handler_state *)cb_data;
SaHpiRptEntryT *rpt;
SaHpiResourceIdT rid;
ipmi_entity_id_t ent_id;
ent_id = ipmi_entity_convert_to_id(entity);
rpt = ohoi_get_resource_by_entityid(handler->rptcache, &ent_id);
if (!rpt) {
dbg("No rpt");
return;
}
rid = rpt->ResourceId;
dbg("%s %s",ipmi_entity_get_entity_id_string(entity), present?"present":"not present");
entity_update_rpt(handler->rptcache, rid, present);
#if 0
/*
The following code is masked by Racing. The reasons are listed as:
1. The hotswap event is not populated to HPI
2. The param 3 is changed to handler
in ipmi_entity_set_presence_handler(entity, entity_presence, handler);
3. The orignal param (&entry.ResourceID) is a bug. Because entity_presence
is callback function and entry.ResourceID is local variable, it may cause
segment fault
*/
struct oh_event *e;
SaHpiResourceIdT *rid = cb_data;
e = malloc(sizeof(*e));
if (!e) {
dbg("Out of space");
return;
}
memset(e, 0, sizeof(*e));
e->type = OH_ET_HPI;
e->u.hpi_event.parent = *rid;
e->u.hpi_event.id = 0;
e->u.hpi_event.event.Source = 0;
/* Do not find EventType in IPMI */
e->u.hpi_event.event.EventType = SAHPI_ET_HOTSWAP;
/* FIXIT! */
if (event)
e->u.hpi_event.event.Timestamp
= ipmi_get_uint32(ipmi_event_get_data_ptr(event));
/* Do not find the severity of hotswap event */
e->u.hpi_event.event.Severity = SAHPI_MAJOR;
if (present)
e->u.hpi_event.event.EventDataUnion.HotSwapEvent.HotSwapState
= SAHPI_HS_STATE_ACTIVE_HEALTHY;
else
e->u.hpi_event.event.EventDataUnion.HotSwapEvent.HotSwapState
= SAHPI_HS_STATE_NOT_PRESENT;
#endif
}
