SaErrorT verifyTextBuffers(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiCtrlRecT * ctrlRec,
int numBytesFirstLine, SaHpiBoolT * success)
{
SaErrorT status;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
int lineNum;
int maxLines = ctrlRec->TypeUnion.Text.MaxLines;
SaHpiCtrlStateT ctrlState;
int maxBytes = getMaxBytes(ctrlRec);
*success = SAHPI_FALSE;
// Get the first text buffer line.
ctrlState.StateUnion.Text.Line = 1;
status =
saHpiControlGet(sessionId, resourceId, ctrlNum, NULL, &ctrlState);
if (status != SA_OK) {
e_print(saHpiControlGet, SA_OK, status);
} else {
// Verify that the text buffer matches what we expect.
*success =
matchesTextBuffer(&(ctrlState.StateUnion.Text.Text),
maxBytes, BYTE_VALUE_2,
numBytesFirstLine);
if (!(*success)) {
m_print("First line does match expected value!");
} else {
// Verify that all of the other lines are empty.
for (lineNum = 2; lineNum <= maxLines && *success;
lineNum++) {
ctrlState.StateUnion.Text.Line = lineNum;
status =
saHpiControlGet(sessionId, resourceId,
ctrlNum, NULL, &ctrlState);
if (status != SA_OK) {
e_print(saHpiControlGet, SA_OK, status);
break;
} else if (ctrlState.StateUnion.Text.Text.DataLength == maxBytes &&
isBlanks(&(ctrlState.StateUnion.Text.Text), 0, maxBytes)) {
// okay; do nothing
} else if (ctrlState.StateUnion.Text.Text.DataLength == 0) {
// okay; do nothing;
} else {
m_print("Text line %d is not blank!", lineNum);
*success = SAHPI_FALSE;
}
}
}
}
return status;
}
int processCtrlRdr(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiRdrT * rdr, SaHpiCtrlRecT * ctrlRec)
{
SaErrorT status;
int retval = SAF_TEST_NOTSUPPORT;
SaHpiCtrlStateT ctrlState;
SaHpiCtrlModeT ctrlMode;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
if (!ctrlRec->WriteOnly) {
status = saHpiControlGet(sessionId, resourceId, ctrlNum,
&ctrlMode, &ctrlState);
if (status != SA_OK) {
retval = SAF_TEST_FAIL;
e_print(saHpiControlGet, SA_OK, status);
} else {
if (!isValidCtrlMode(ctrlMode)) {
retval = SAF_TEST_FAIL;
m_print("Invalid Control Mode [0x%x]!",
ctrlMode);
} else if (!isValidCtrlType(ctrlState.Type)) {
retval = SAF_TEST_FAIL;
m_print("Invalid Contrl Type [0x%x]!",
ctrlState.Type);
} else {
retval = SAF_TEST_PASS;
}
}
}
return retval;
}
int run_test(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId, SaHpiCtrlRecT * ctrlRec)
{
SaErrorT status;
int retval = SAF_TEST_PASS;
int lineNum;
int maxLines = ctrlRec->TypeUnion.Text.MaxLines;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
int maxBytes = getMaxBytes(ctrlRec);
SaHpiCtrlStateT ctrlState;
for (lineNum = 1; lineNum <= maxLines && retval == SAF_TEST_PASS;
lineNum++) {
// Write the initial "long" string in the first line.
status =
setControlTextBuffer(sessionId, resourceId, ctrlRec,
lineNum, 4, BYTE_VALUE_1);
if (status != SA_OK) {
e_trace();
retval = SAF_TEST_UNRESOLVED;
} else {
// Write a "shorter" string with a different character.
status =
setControlTextBuffer(sessionId, resourceId, ctrlRec,
lineNum, 2, BYTE_VALUE_2);
if (status != SA_OK) {
e_trace();
retval = SAF_TEST_UNRESOLVED;
} else {
// Retrieve the latest text buffer and verify that it
// corresponds to the "shorter" string.
ctrlState.StateUnion.Text.Line = lineNum;
status =
saHpiControlGet(sessionId, resourceId,
ctrlNum, NULL, &ctrlState);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiControlGet, SA_OK, status);
} else
if (!matchesTextBuffer
(&(ctrlState.StateUnion.Text.Text),
maxBytes, BYTE_VALUE_2, 2)) {
retval = SAF_TEST_FAIL;
m_print("Text Buffer does not match!");
}
}
}
}
return retval;
}
static
SaErrorT getcontrolstate(SaHpiSessionIdT sessionid,
SaHpiResourceIdT l_resourceid,
SaHpiCtrlNumT num)
{
SaErrorT rv = SA_OK;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
rv = saHpiControlGet(sessionid, l_resourceid, num, &mode, &state);
if (rv == SA_OK)
oh_print_ctrlstate(&state, 4);
return(rv);
}
int main(int argc, char **argv)
{
SaHpiSessionIdT sid = 0;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
SaErrorT rc = SA_OK;
rc = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sid, NULL);
if (rc != SA_OK) {
dbg("Failed to open session");
return -1;
}
rc = saHpiDiscover(sid);
if (rc != SA_OK) {
dbg("Failed to run discover");
return -1;
}
/* get the resource id of the chassis */
SaHpiResourceIdT resid = get_resid(sid, SAHPI_ENT_SYSTEM_CHASSIS);
if (resid == 0) {
dbg("Couldn't find the resource id of the chassis");
return -1;
}
/* get control */
rc = saHpiControlGet(sid, resid, 1, &mode, &state);
if (rc != SA_OK) {
dbg("Couldn't get control type");
dbg("Error %s",oh_lookup_error(rc));
return -1;
}
/* set control */
rc = saHpiControlSet(sid, resid, 1, mode, &state);
if (rc != SA_OK) {
dbg("Couldn't set control");
dbg("Error %s",oh_lookup_error(rc));
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiRdrT rdr;
SaHpiCtrlNumT cid = 1;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl;
/* *************************************
* Find a resource with Control 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_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a control resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a control RDR
**************************/
entryid = SAHPI_FIRST_ENTRY;
foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
err("Did not find desired resource for test\n");
return(SA_OK);
} else {
cid = rdr.RdrTypeUnion.CtrlRec.Num;
}
/**************************
* Test 1: Normal get
*************************/
expected_err = SA_OK;
err = saHpiControlGet(sessionid, id, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 2: Get with no mode
* expected_err = SA_OK;
*************************/
err = saHpiControlGet(sessionid, id, cid, NULL, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 3: Get with no state
* expected_err = SA_OK;
*************************/
err = saHpiControlGet(sessionid, id, cid, &mode, NULL);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int main(int argc, char **argv)
{
/* ************************
* Local variables
* ***********************/
int testfail = 0;
SaErrorT err;
SaErrorT expected_err;
SaHpiRptEntryT rptentry;
SaHpiResourceIdT id;
SaHpiSessionIdT sessionid;
SaHpiRdrT rdr;
SaHpiCtrlNumT cid = 1;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
/* *************************************
* Find a resource with Control 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_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_TRUE);
if (err != SA_OK) {
printf("Can not find a control resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return SA_OK;
}
id = rptentry.ResourceId;
/**************************
* Test: find a control RDR
**************************/
SaHpiEntryIdT entryid = SAHPI_FIRST_ENTRY;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl = SAHPI_FALSE;
do {
err = saHpiRdrGet(sessionid,id,entryid,&nextentryid, &rdr);
if (err == SA_OK)
{
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
foundControl = SAHPI_TRUE;
break;
}
entryid = nextentryid;
}
} while ((err == SA_OK) && (entryid != SAHPI_LAST_ENTRY)) ;
if (!foundControl) {
dbg("Did not find desired resource for test\n");
return(SA_OK);
} else {
cid = rdr.RdrTypeUnion.CtrlRec.Num;
}
/**************************
* Test 1: Invalid Handle
*************************/
struct oh_handler_state l_handle;
memset(&l_handle, 0, sizeof(struct oh_handler_state));
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_get_control_state(NULL, id, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 2: Resource ID with no RPT
*************************/
expected_err = SA_ERR_HPI_INVALID_RESOURCE;
err = saHpiControlGet(sessionid, 5000, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 3: Control ID with no RDR
*************************/
expected_err = SA_ERR_HPI_NOT_PRESENT;
err = saHpiControlGet(sessionid, id, 5000, &mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 4: NULL mode and state
*************************/
expected_err = SA_OK;
err = saHpiControlGet(sessionid, id, cid, NULL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test: resource without SAHPI_CAPABILITY_CONTROL
*************************/
err = tfind_resource(&sessionid, SAHPI_CAPABILITY_CONTROL, SAHPI_FIRST_ENTRY, &rptentry, SAHPI_FALSE);
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;
}
expected_err = SA_ERR_HPI_CAPABILITY;
err = saHpiControlGet(sessionid, rptentry.ResourceId, cid, &mode, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
SaErrorT show_control_state(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiCtrlNumT num, hpi_ui_print_cb_t proc,
get_int_param_t get_int_param)
{
SaErrorT rv;
int i;
int res;
char *str;
char buf[SHOW_BUF_SZ];
char errbuf[SHOW_BUF_SZ];
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
SaHpiCtrlTypeT type;
SaHpiCtrlStateDigitalT digit;
SaHpiCtrlStateDiscreteT discr;
SaHpiCtrlStateAnalogT analog;
SaHpiCtrlStateStreamT *stream;
SaHpiCtrlStateTextT *text;
SaHpiCtrlStateOemT *oem;
rv = saHpiControlTypeGet(sessionid, resourceid, num, &type);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiControlTypeGet: error: %s\n", oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
state.Type = type;
if (type == SAHPI_CTRL_TYPE_TEXT) {
i = get_int_param("Line #(0 == all): ", &res);
if (i != 1) {
printf("Invalid value\n");
return SA_ERR_HPI_ERROR;
};
state.StateUnion.Text.Line = res;
}
rv = saHpiControlGet(sessionid, resourceid, num, &mode, &state);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiControlGet: error: %s\n", oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
type = state.Type;
snprintf(buf, SHOW_BUF_SZ, "Control(%d/%d) %s State: ",
resourceid, num, oh_lookup_ctrlmode(mode));
if (proc(buf) != HPI_UI_OK) return(SA_OK);
switch (type) {
case SAHPI_CTRL_TYPE_DIGITAL:
digit = state.StateUnion.Digital;
str = oh_lookup_ctrlstatedigital(digit);
if (str == (char *)NULL) {
snprintf(errbuf, SHOW_BUF_SZ, "Invalid value (0x%x)",
digit);
str = errbuf;
};
snprintf(buf, SHOW_BUF_SZ, "%s\n", str);
break;
case SAHPI_CTRL_TYPE_DISCRETE:
discr = state.StateUnion.Discrete;
snprintf(buf, SHOW_BUF_SZ, "%d\n", discr);
break;
case SAHPI_CTRL_TYPE_ANALOG:
analog = state.StateUnion.Analog;
snprintf(buf, SHOW_BUF_SZ, "%d\n", analog);
break;
case SAHPI_CTRL_TYPE_STREAM:
stream = &(state.StateUnion.Stream);
snprintf(buf, SHOW_BUF_SZ,
"Repeat = %d lendth = %d stream = %s\n",
stream->Repeat, stream->StreamLength, stream->Stream);
break;
case SAHPI_CTRL_TYPE_TEXT:
text = &(state.StateUnion.Text);
snprintf(buf, SHOW_BUF_SZ, "Line # = %d", text->Line);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
print_text_buffer_text(" Text = ", &(text->Text), "\n", proc);
return SA_OK;
case SAHPI_CTRL_TYPE_OEM:
oem = &(state.StateUnion.Oem);
snprintf(buf, SHOW_BUF_SZ, "MId = %d Body = ", oem->MId);
proc(buf);
str = (char *)(oem->Body);
for (i = 0; i < oem->BodyLength; i++)
sprintf(buf + i * 3, "%2.2X ", (unsigned char)(str[i]));
strcat(buf, "\n");
break;
default: strcpy(buf, "Unknown control type\n");
};
proc(buf);
return SA_OK;
}
int main(int argc, char **argv)
{
int testfail = 0;
gchar *rdr_name;
SaErrorT err, expected_err;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
SaHpiEntityPathT ep, vmm_ep;
SaHpiRdrT rdr;
SaHpiRptEntryT rpt;
SaHpiSessionIdT sessionid;
vmm_ep.Entry[0].EntityType = SAHPI_ENT_SYS_MGMNT_MODULE;
vmm_ep.Entry[0].EntityLocation = 0;
vmm_ep.Entry[1].EntityType = SAHPI_ENT_SYSTEM_CHASSIS;
vmm_ep.Entry[1].EntityLocation = 1;
vmm_ep.Entry[2].EntityType = SAHPI_ENT_ROOT;
vmm_ep.Entry[2].EntityLocation = 0;
rdr_name = "MM Failover Control";
/***********************
* Find the VMM resource
***********************/
err = tsetup(&sessionid);
if (err) {
printf("Error! Cannot open session for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
return -1;
}
oh_init_ep(&ep);
oh_concat_ep(&ep, &vmm_ep);
err = tfind_resource_by_ep(&sessionid, &ep, SAHPI_FIRST_ENTRY, &rpt);
if (err) {
printf("Cannot find resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return -1;
}
/**************************
* Find MM Failover control
**************************/
err = tfind_rdr_by_name(&sessionid, rpt.ResourceId, rdr_name, &rdr);
if (err) {
printf("Cannot find resource for test environment\n");
printf(" File=%s, Line=%d\n", __FILE__, __LINE__);
err = tcleanup(&sessionid);
return -1;
}
/***************************
* Test: Write Invalid State
***************************/
expected_err = SA_ERR_HPI_INVALID_REQUEST;
state.Type = SAHPI_CTRL_TYPE_DIGITAL;
state.StateUnion.Digital = SAHPI_CTRL_STATE_OFF;
err = saHpiControlSet(sessionid, rpt.ResourceId, rdr.RdrTypeUnion.CtrlRec.Num,
SAHPI_CTRL_MODE_MANUAL, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test: Write Invalid Mode
**************************/
expected_err = SA_ERR_HPI_READ_ONLY;
state.Type = SAHPI_CTRL_TYPE_DIGITAL;
state.StateUnion.Digital = SAHPI_CTRL_STATE_PULSE_ON;
err = saHpiControlSet(sessionid, rpt.ResourceId, rdr.RdrTypeUnion.CtrlRec.Num,
SAHPI_CTRL_MODE_AUTO, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Test: Write Valid State
***************************/
expected_err = SA_OK;
state.Type = SAHPI_CTRL_TYPE_DIGITAL;
state.StateUnion.Digital = SAHPI_CTRL_STATE_PULSE_ON;
err = saHpiControlSet(sessionid, rpt.ResourceId, rdr.RdrTypeUnion.CtrlRec.Num,
SAHPI_CTRL_MODE_MANUAL, &state);
checkstatus(err, expected_err, testfail);
/***********************
* Test: Read State/Mode
***********************/
err = saHpiControlGet(sessionid, rpt.ResourceId, rdr.RdrTypeUnion.CtrlRec.Num, &mode, &state);
if (mode != SAHPI_CTRL_MODE_MANUAL || state.StateUnion.Digital != SAHPI_CTRL_STATE_OFF) {
printf(" Error! Testcase failed. Line=%d\n", __LINE__);
printf("State=%s; Mode=%s\n", oh_lookup_ctrlmode(mode),
oh_lookup_ctrlstatedigital(state.StateUnion.Digital));
return -1;
}
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
int
main(int argc, char **argv)
{
int c;
SaErrorT rv;
SaHpiSessionIdT sessionid;
SaHpiRptEntryT rptentry;
SaHpiEntryIdT rptentryid;
SaHpiEntryIdT nextrptentryid;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiResourceIdT resourceid;
SaHpiRdrT rdr;
SaHpiCtrlTypeT ctltype;
SaHpiCtrlNumT ctlnum;
SaHpiCtrlStateT ctlstate;
int raw_val = 0;
int j;
uchar b = 0;
printf("%s ver %s\n", argv[0],progver);
while ( (c = getopt( argc, argv,"rxa:b:c:m:n:p:i:d:o?")) != EOF )
switch(c) {
case 'c': b = atoi(optarg); /* set crit alarm value */
leds[1].fset = 1;
leds[1].val = b;
break;
case 'm': b = atoi(optarg); /* set major alarm value */
leds[2].fset = 1;
leds[2].val = b;
break;
case 'n': b = atoi(optarg); /* set minor alarm value */
leds[3].fset = 1;
leds[3].val = b;
break;
case 'a': b = atoi(optarg); /* set disk a fault led */
leds[4].fset = 1;
leds[4].val = b;
break;
case 'b': b = atoi(optarg); /* set disk b fault led */
leds[5].fset = 1;
leds[5].val = b;
break;
case 'p': b = atoi(optarg); /* set power alarm value */
leds[0].fset = 1;
leds[0].val = b;
break;
case 'i': fid = atoi(optarg); /* set chassis id on/off */
fsetid = 1;
break;
case 'd': raw_val = atoi(optarg); /* set raw alarm byte */
break;
case 'o': fsetid=1; fid=0; /* set all alarms off */
for (j = 0; j < NLEDS; j++) {
leds[j].fset = 1;
leds[j].val = 0;
}
break;
case 'x': fdebug = 1; break; /* debug messages */
default:
printf("Usage: %s [-a -b -c -i -m -n -p -o -x]\n", argv[0]);
printf(" where -c1 sets Critical Alarm on\n");
printf(" -c0 sets Critical Alarm off\n");
printf(" -m1 sets Major Alarm on\n");
printf(" -m0 sets Major Alarm off\n");
printf(" -n1 sets Minor Alarm on\n");
printf(" -n0 sets Minor Alarm off\n");
printf(" -p1 sets Power Alarm on\n");
printf(" -p0 sets Power Alarm off\n");
printf(" -i5 sets Chassis ID on for 5 sec\n");
printf(" -i0 sets Chassis ID off\n");
printf(" -a1 sets Disk A fault on\n");
printf(" -a0 sets Disk A fault off\n");
printf(" -b1 sets Disk B fault on\n");
printf(" -b0 sets Disk B fault off\n");
printf(" -d[byte] sets raw Alarm byte\n");
printf(" -o sets all Alarms off\n");
printf(" -x show eXtra debug messages\n");
exit(1);
}
rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID,&sessionid,NULL);
if (rv != SA_OK) {
printf("saHpiSessionOpen error %d\n",rv);
exit(-1);
}
rv = saHpiDiscover(sessionid);
if (fdebug) printf("saHpiDiscover complete, rv = %d\n",rv);
/* walk the RPT list */
rptentryid = SAHPI_FIRST_ENTRY;
while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY))
{
rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry);
if (rv != SA_OK) printf("RptEntryGet: rv = %d\n",rv);
if (rv == SA_OK) {
/* Walk the RDR list for this RPT entry */
entryid = SAHPI_FIRST_ENTRY;
resourceid = rptentry.ResourceId;
/*
* Don't stringify here, since OpenHPI returns a valid string, but
* a DataLength of zero here (for processor, bios).
* rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0;
*/
//if (fdebug)
printf("rptentry[%d] resourceid=%d tlen=%d tag: %s\n",
entryid, resourceid, rptentry.ResourceTag.DataLength,
rptentry.ResourceTag.Data);
while ((rv == SA_OK) && (entryid != SAHPI_LAST_ENTRY))
{
rv = saHpiRdrGet(sessionid,resourceid,
entryid,&nextentryid, &rdr);
if (fdebug) printf("saHpiRdrGet[%d] rv = %d\n",entryid,rv);
if (rv == SA_OK) {
if (rdr.RdrType == SAHPI_CTRL_RDR) {
/*type 1 includes alarm LEDs*/
ctlnum = rdr.RdrTypeUnion.CtrlRec.Num;
rdr.IdString.Data[rdr.IdString.DataLength] = 0;
if (fdebug) printf("Ctl[%d]: %d %d %s\n",
ctlnum, rdr.RdrTypeUnion.CtrlRec.Type,
rdr.RdrTypeUnion.CtrlRec.OutputType,
rdr.IdString.Data);
rv = saHpiControlTypeGet(sessionid,resourceid,
ctlnum,&ctltype);
if (fdebug) printf("saHpiControlTypeGet[%d] rv = %d, type = %d\n",ctlnum,rv,ctltype);
rv = saHpiControlGet(sessionid, resourceid, ctlnum,
NULL, &ctlstate);
if (fdebug)
printf("saHpiControlStateGet[%d] rv = %d v = %x\n",
ctlnum,rv,ctlstate.StateUnion.Digital);
printf("RDR[%d]: ctltype=%d:%d oem=%02x %s \t",
rdr.RecordId,
rdr.RdrTypeUnion.CtrlRec.Type,
rdr.RdrTypeUnion.CtrlRec.OutputType,
rdr.RdrTypeUnion.CtrlRec.Oem,
rdr.IdString.Data);
if (rv == SA_OK) {
if (ctlstate.Type == SAHPI_CTRL_TYPE_ANALOG)
b = 2; /*Identify*/
else {
b = ctlstate.StateUnion.Digital;
if (b > 2) b = 2;
}
printf("state = %s\n",states[b]);
} else { printf("\n"); }
if (rdr.RdrTypeUnion.CtrlRec.Type == SAHPI_CTRL_TYPE_ANALOG &&
rdr.RdrTypeUnion.CtrlRec.OutputType == SAHPI_CTRL_LED) {
/* This is a Chassis Identify */
if (fsetid) {
printf("Setting ID led to %d sec\n", fid);
ctlstate.Type = SAHPI_CTRL_TYPE_ANALOG;
ctlstate.StateUnion.Analog = fid;
rv = saHpiControlSet(sessionid, resourceid,
ctlnum, SAHPI_CTRL_MODE_MANUAL,
&ctlstate);
printf("saHpiControlStateSet[%d] rv = %d\n",ctlnum,rv);
}
} else
if (rdr.RdrTypeUnion.CtrlRec.Type == SAHPI_CTRL_TYPE_DIGITAL &&
(rdr.RdrTypeUnion.CtrlRec.Oem & 0xf0) == SAHPI_OEM_ALARM_LED &&
rdr.RdrTypeUnion.CtrlRec.OutputType == SAHPI_CTRL_LED) {
/* this is an alarm LED */
b = (uchar)rdr.RdrTypeUnion.CtrlRec.Oem & 0x0f;
if ((b < NLEDS) && leds[b].fset) {
printf("Setting alarm led %d to %d\n",b,leds[b].val);
if (leds[b].val == 0)
ctlstate.StateUnion.Digital = SAHPI_CTRL_STATE_OFF;
else
ctlstate.StateUnion.Digital = SAHPI_CTRL_STATE_ON;
rv = saHpiControlSet(sessionid, resourceid,
ctlnum, SAHPI_CTRL_MODE_MANUAL,
&ctlstate);
/* if (fdebug) */
printf("saHpiControlStateSet[%d] rv = %d\n",ctlnum,rv);
}
}
else if (rdr.RdrTypeUnion.CtrlRec.Type == SAHPI_CTRL_TYPE_DIGITAL &&
(rdr.RdrTypeUnion.CtrlRec.Oem & 0xf0) == SAHPI_OEM_DISK_LED &&
rdr.RdrTypeUnion.CtrlRec.OutputType == SAHPI_CTRL_LED) {
/* this is a disk LED */
b = (uchar)rdr.RdrTypeUnion.CtrlRec.Oem & 0x0f;
if ((b < NLEDS) && leds[b].fset) {
printf("Setting disk led %d to %d\n",b,leds[b].val);
if (leds[b].val == 0)
ctlstate.StateUnion.Digital = SAHPI_CTRL_STATE_OFF;
else
ctlstate.StateUnion.Digital = SAHPI_CTRL_STATE_ON;
rv = saHpiControlSet(sessionid, resourceid,
ctlnum, SAHPI_CTRL_MODE_MANUAL,
&ctlstate);
printf("saHpiControlStateSet[%d] rv = %d\n",ctlnum,rv);
}
}
rv = SA_OK; /* ignore errors & continue */
}
j++;
entryid = nextentryid;
}
}
rptentryid = nextrptentryid;
}
}
rv = saHpiSessionClose(sessionid);
exit(0);
return(0);
}
int main(int argc, char **argv)
{
int number_resources = 0;
SaErrorT rv;
SaHpiSessionIdT sessionid;
SaHpiResourceIdT resourceid;
SaHpiResourceIdT resourceid_list[RESOURCE_CAP_LENGTH] = {0};
SaHpiCtrlNumT controlNumber = OA_SOAP_RES_CNTRL_NUM;
SaHpiCtrlModeT controlMode;
SaHpiCtrlStateT controlState;
SaHpiCapabilitiesT capability = SAHPI_CAPABILITY_CONTROL;
char *mode = NULL;
printf("saHpiControlGet: Test for hpi control get function\n");
rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID, &sessionid, NULL);
if (rv != SA_OK) {
printf("saHpiSessionOpen failed with error: %s\n",
oh_lookup_error(rv));
return rv;
}
/* Discover the resources with control capability */
printf("\nListing the resource with control capability\n");
rv = discover_resources(sessionid, capability, resourceid_list,
&number_resources);
if (rv != SA_OK) {
exit(-1);
}
printf("\nPlease enter the resource id: ");
scanf("%d", &resourceid);
printf("\nSupported controls on the resource are:");
printf("\nUID LED control(Press 0)");
printf("\nPower control(Press 1)");
printf("\nEnter your option:");
scanf("%d", &controlNumber);
rv = saHpiControlGet(sessionid, resourceid, controlNumber,
&controlMode, &controlState);
if (rv != SA_OK) {
printf("saHpiControlGet failed with error: %s\n",
oh_lookup_error(rv));
printf("Test case - FAIL\n");
}
else {
mode = oh_lookup_ctrlmode(controlMode);
if (mode == NULL) {
printf("Unknown control mode");
printf("Test case - Fail\n");
}
else {
printf("Control mode = %s\n",mode);
rv = oh_print_ctrlstate(&controlState,6);
if (rv != SA_OK) {
printf("Test case - FAIL\n");
}
}
printf("Test case - PASS\n");
}
rv = saHpiSessionClose(sessionid);
return 0;
}
int processCtrlRdr(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiRdrT * rdr, SaHpiCtrlRecT * ctrlRec)
{
SaErrorT status;
int retval = SAF_TEST_NOTSUPPORT;
int lineNum;
int maxLines;
int maxBytes;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
SaHpiCtrlModeT ctrlMode;
SaHpiCtrlStateT ctrlState;
ControlData controlData;
if (!ctrlRec->WriteOnly && isTextControl(ctrlRec)
&& canSetControlState(ctrlRec)) {
status =
readControlData(sessionId, resourceId, ctrlRec,
&controlData);
if (status != SA_OK) {
e_trace();
retval = SAF_TEST_UNRESOLVED;
} else {
// Change the return value if anything goes wrong.
retval = SAF_TEST_PASS;
maxLines = ctrlRec->TypeUnion.Text.MaxLines;
maxBytes = getMaxBytes(ctrlRec);
// Initialize the ctrl state information that is the same
// for each invocation of saHpiControlSet().
status =
setControlAllTextBuffers(sessionId, resourceId,
ctrlRec, BYTE_VALUE_1);
if (status != SA_OK) {
e_trace();
retval = SAF_TEST_FAIL;
} else {
// If we succesfully change each line of text, then read the
// text data to verify that the change really did occur.
for (lineNum = 1; lineNum <= maxLines;
lineNum++) {
ctrlState.StateUnion.Text.Line =
lineNum;
status =
saHpiControlGet(sessionId,
resourceId, ctrlNum,
&ctrlMode,
&ctrlState);
if (status != SA_OK) {
retval = SAF_TEST_UNRESOLVED;
e_print(saHpiControlGet, SA_OK,
status);
break;
} else
if (!matchesTextBuffer
(&ctrlState.StateUnion.Text.
Text, maxBytes, BYTE_VALUE_1,
maxBytes)) {
retval = SAF_TEST_FAIL;
m_print
("Text Buffers do not match!");
break;
}
}
}
restoreControlData(sessionId, resourceId, ctrlNum,
&controlData);
}
}
return retval;
}
