SaErrorT show_sensor_status(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiSensorNumT sensornum, hpi_ui_print_cb_t proc)
{
SaErrorT rv;
SaHpiEventStateT assert;
SaHpiEventStateT deassert;
SaHpiBoolT status;
char buf[1024];
rv = saHpiSensorEventEnableGet(sessionid, resourceid, sensornum, &status);
if (rv != SA_OK) {
snprintf(buf, 1024, "ERROR: saHpiSensorEventEnableGet error = %s\n",
oh_lookup_error(rv));
proc(buf);
return -1;
}
rv = saHpiSensorEventMasksGet(
sessionid, resourceid, sensornum, &assert, &deassert);
if (rv != SA_OK) {
snprintf(buf, 1024, "ERROR: saHpiSensorEventMasksGet error %s\n",
oh_lookup_error(rv));
proc(buf);
return -1;
}
snprintf(buf, 1024, "Sensor Event Masks: \nSensor Event Status: %x\n"
"Assert Events: %x\nDeassert Events: %x\n", status, assert, deassert);
proc(buf);
return SA_OK;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT assertMask;
SaHpiEventStateT deassertMask;
/* ***************************************
* Find a resource with No Sensor type rdr
* ***************************************/
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_FALSE);
if (err != SA_OK) {
dbg("Error! Can not find resources for test environment\n");
dbg(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test Capability checking
**************************/
expected_err = SA_ERR_HPI_CAPABILITY;
err = saHpiSensorEventMasksGet(sessionid, id, sid, &assertMask, &deassertMask);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int testSensor(SaHpiSessionIdT session, SaHpiResourceIdT resource, SaHpiRdrT *rdr)
{
int retval = SAF_TEST_NOTSUPPORT;
SaErrorT status;
SaHpiSensorNumT s_num;
SaHpiEventStateT Assertsaved, Deassertsaved;
s_num = rdr->RdrTypeUnion.SensorRec.Num;
status = saHpiSensorEventMasksGet(session, resource, s_num,
&Assertsaved, &Deassertsaved);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiSensorEventMasksGet, SA_OK, status);
} else {
sensorData[sensorCount].resourceId = resource;
sensorData[sensorCount].sensorNum = s_num;
sensorData[sensorCount].mask = rdr->RdrTypeUnion.SensorRec.Events;
sensorData[sensorCount].asserted = Assertsaved;
sensorData[sensorCount].deasserted = Deassertsaved;
sensorData[sensorCount].stateIndex = 0;
if (Assertsaved == 0) {
sensorData[sensorCount].state[0] = STATE_ADD;
sensorData[sensorCount].state[1] = STATE_REMOVE;
retval = change_event_masks(session, resource, s_num,
SAHPI_SENS_ADD_EVENTS_TO_MASKS);
} else {
sensorData[sensorCount].state[0] = STATE_REMOVE;
sensorData[sensorCount].state[1] = STATE_ADD;
retval = change_event_masks(session, resource, s_num,
SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS);
}
sensorCount++;
}
if (retval == SAF_TEST_PASS && sensorCount % POLL_COUNT == 0) {
retval = checkForEvents(session);
}
return retval;
}
SaErrorT show_sensor(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiSensorNumT sensornum, hpi_ui_print_cb_t proc)
{
SaHpiSensorReadingT reading;
SaHpiEventStateT status, assert, deassert;
SaHpiRdrT rdr;
SaErrorT rv;
SaHpiBoolT val;
char buf[SHOW_BUF_SZ];
char errbuf[SHOW_BUF_SZ];
Pr_ret_t res;
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid, SAHPI_SENSOR_RDR,
sensornum, &rdr);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiRdrGetByInstrumentId: error: %s\n",
oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
snprintf(buf, SHOW_BUF_SZ, "Sensor(%d/%d) %s", resourceid, sensornum,
oh_lookup_sensortype(rdr.RdrTypeUnion.SensorRec.Type));
proc(buf);
res = print_text_buffer_text(" ", &(rdr.IdString), "\n", proc);
if (res != HPI_UI_OK) return(SA_OK);
rv = saHpiSensorEnableGet(sessionid, resourceid, sensornum, &val);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEnableGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
if (val) res = proc("Enable ");
else res = proc("Disable ");
if (res != HPI_UI_OK) return(SA_OK);
};
rv = saHpiSensorEventEnableGet(sessionid, resourceid, sensornum, &val);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEventEnableGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
if (proc(" event : ") != HPI_UI_OK) return(SA_OK);
if (val) res = proc("Enable");
else res = proc("Disable");
if (res != HPI_UI_OK) return(SA_OK);
};
rv = saHpiSensorEventMasksGet(sessionid, resourceid, sensornum,
&assert, &deassert);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorEventMasksGet: error: %s\n",
oh_lookup_error(rv));
if (proc(errbuf) != HPI_UI_OK) return(rv);
} else {
snprintf(buf, SHOW_BUF_SZ,
" supported: 0x%4.4x masks: assert = 0x%4.4x"
" deassert = 0x%4.4x\n",
rdr.RdrTypeUnion.SensorRec.Events, assert, deassert);
if (proc(buf) != HPI_UI_OK) return(rv);
};
rv = saHpiSensorReadingGet(sessionid, resourceid, sensornum,
&reading, &status);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiSensorReadingGet: error: %s\n",
oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
snprintf(buf, SHOW_BUF_SZ, "\tEvent states = 0x%x\n", status);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
if (reading.IsSupported) {
res = print_thres_value(&reading, "\tReading Value =",
NULL, 0, proc);
if (res == HPI_UI_END) return(SA_OK);
} else {
if (proc("\tReading not supported\n") != HPI_UI_OK) return(SA_OK);
}
show_threshold(sessionid, resourceid, sensornum,
&(rdr.RdrTypeUnion.SensorRec), proc);
return SA_OK;
}
int Test_Case_Rdr(SaHpiSessionIdT session, SaHpiResourceIdT resourceId,
SaHpiRdrT rdr)
{
int ret = SAF_TEST_UNKNOWN;
SaErrorT status;
SaHpiSensorNumT sensorNum;
SaHpiEventStateT assertMaskOld, assertMaskNew;
SaHpiEventStateT deassertMaskOld, deassertMaskNew;
SaHpiEventStateT assertSaved, deassertSaved;
// -------- Restore the default values --------
status = saHpiParmControl(session, resourceId, SAHPI_DEFAULT_PARM);
if (status != SA_OK) // The function works abnormally
{
e_print(saHpiParmControl, SA_OK, status);
ret = SAF_TEST_FAIL;
return ret;
}
if (rdr.RdrType == SAHPI_SENSOR_RDR) {
if (rdr.RdrTypeUnion.SensorRec.EventCtrl != SAHPI_SEC_PER_EVENT) {
ret = SAF_TEST_NOTSUPPORT;
return ret;
}
sensorNum = rdr.RdrTypeUnion.SensorRec.Num;
// ------ Get the state of the sensor ------
status =
saHpiSensorEventMasksGet(session, resourceId, sensorNum,
&assertMaskOld, &deassertMaskOld);
if (status != SA_OK) {
e_print(saHpiSensorEventMasksGet, SA_OK, status);
ret = SAF_TEST_UNRESOLVED;
return ret;
}
assertSaved = assertMaskOld + 5;
deassertSaved = deassertMaskOld + 5;
status =
saHpiSensorEventMasksSet(session, resourceId, sensorNum,
SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS,
assertSaved, deassertSaved);
if (status != SA_OK) {
e_print(saHpiSensorEventMasksSet, SA_OK, status);
ret = SAF_TEST_UNRESOLVED;
return ret;
}
// ------- Call saHpiParmControl with valid parameters -------
status =
saHpiParmControl(session, resourceId, SAHPI_DEFAULT_PARM);
if (status != SA_OK) {
e_print(saHpiParmControl, SA_OK, status);
ret = SAF_TEST_FAIL;
return ret;
}
// ------ Get the state of the sensor ------
status =
saHpiSensorEventMasksGet(session, resourceId, sensorNum,
&assertMaskNew, &deassertMaskNew);
if (status != SA_OK) {
e_print(saHpiSensorEventMasksGet, SA_OK, status);
ret = SAF_TEST_UNRESOLVED;
return ret;
}
// -------- Compare the old values with the new values --------
if ((assertMaskOld != assertMaskNew)
|| (deassertMaskOld != deassertMaskNew))
ret = SAF_TEST_FAIL;
else
ret = SAF_TEST_PASS;
} else {
ret = SAF_TEST_NOTSUPPORT;
}
return ret;
}
int run_test(SaHpiSessionIdT sessionId, SaHpiResourceIdT resourceId,
SaHpiSensorRecT * sensorRec)
{
SaErrorT status;
int retval;
SaHpiEventStateT assertEventMask;
SaHpiEventStateT deassertEventMask;
status = saHpiSensorEventMasksGet(sessionId, resourceId, sensorRec->Num,
&assertEventMask, &deassertEventMask);
if (status == SA_ERR_HPI_ENTITY_NOT_PRESENT) {
retval = SAF_TEST_NOTSUPPORT;
} else if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiSensorEnableGet, SA_OK, status);
} else if (assertEventMask & SAHPI_ES_UPPER_MINOR
&& deassertEventMask & SAHPI_ES_UPPER_MINOR) {
retval = generateAssertEvents(sessionId, resourceId, sensorRec);
} else if (sensorRec->EventCtrl == SAHPI_SEC_PER_EVENT) {
status =
saHpiSensorEventMasksSet(sessionId, resourceId,
sensorRec->Num,
SAHPI_SENS_ADD_EVENTS_TO_MASKS,
SAHPI_ES_UPPER_MINOR,
SAHPI_ES_UPPER_MINOR);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiSensorEventMasksSet, SA_OK, status);
} else {
retval = generateAssertEvents(sessionId, resourceId, sensorRec);
if (retval == SAF_TEST_PASS) {
sensorData[sensorCount-1].restoreMasks = SAHPI_TRUE;
sensorData[sensorCount-1].assertEventMask = assertEventMask;
sensorData[sensorCount-1].deassertEventMask = deassertEventMask;
} else {
// restore event masks
if (!(assertEventMask & SAHPI_ES_UPPER_MINOR)) {
status =
saHpiSensorEventMasksSet(sessionId,
resourceId,
sensorRec->Num,
SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS,
SAHPI_ES_UPPER_MINOR,
0x0);
if (status != SA_OK) {
e_print(saHpiSensorEventMasksSet, SA_OK,
status);
}
}
if (!(deassertEventMask & SAHPI_ES_UPPER_MINOR)) {
status =
saHpiSensorEventMasksSet(sessionId,
resourceId,
sensorRec->Num,
SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS,
0x0,
SAHPI_ES_UPPER_MINOR);
if (status != SA_OK) {
e_print(saHpiSensorEventMasksSet, SA_OK,
status);
}
}
}
}
} else {
retval = SAF_TEST_NOTSUPPORT;
}
return retval;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiSensorNumT sid = 0;
SaHpiEventStateT assertMask;
SaHpiEventStateT deassertMask;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundSensor;
/* *************************************
* Find a resource with Sensor type rdr
* ************************************* */
err = tsetup(&sessionid);
if (err != SA_OK) {
printf("Error! Can not open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
err = tfind_resource(&sessionid,SAHPI_CAPABILITY_SENSOR,SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Error! Can not find resources for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a sensor with desired property
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundSensor = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if ((rdr.RdrType == SAHPI_SENSOR_RDR) &&
(rdr.RdrTypeUnion.SensorRec.DataFormat.IsSupported == SAHPI_FALSE))
{
foundSensor = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundSensor) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
sid = rdr.RdrTypeUnion.SensorRec.Num;
}
/**************************
* Test: Invalid sensor id
**************************/
expected_err = SA_ERR_HPI_NOT_PRESENT;
err = saHpiSensorEventMasksGet(sessionid, id, 5000, &assertMask, &deassertMask);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Normal path
**************************/
expected_err = SA_OK;
err = saHpiSensorEventMasksGet(sessionid, id, sid, &assertMask, &deassertMask);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
