/*
* int set_table_ctrl_digital_state (saHpiCtrlDigitalTable_context * ctx)
*/
int set_table_ctrl_digital_state (saHpiCtrlDigitalTable_context *row_ctx)
{
SaErrorT rc = SA_OK;
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlStateT ctrl_state;
if (!row_ctx)
return AGENT_ERR_NULL_DATA;
session_id = get_session_id(row_ctx->index.oids[saHpiCtrlDigitalDomainId_INDEX]);
resource_id = row_ctx->index.oids[saHpiCtrlDigitalResourceEntryId_INDEX];
ctrl_state.StateUnion.Digital = row_ctx->saHpiCtrlDigitalState - 1;
ctrl_state.Type = SAHPI_CTRL_TYPE_DIGITAL;
rc = saHpiControlSet(session_id, resource_id,
row_ctx->saHpiCtrlDigitalNum,
row_ctx->saHpiCtrlDigitalMode - 1,
&ctrl_state);
if (rc != SA_OK) {
snmp_log (LOG_ERR,
"Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc));
DEBUGMSGTL ((AGENT,
"Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc)));
return get_snmp_error(rc);
}
return SNMP_ERR_NOERROR;
}
/*
* SaErrorT set_table_ctrl_text()
*/
int set_table_ctrl_text (saHpiCtrlTextTable_context *row_ctx)
{
SaErrorT rc = SA_OK;
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlStateT ctrl_state;
DEBUGMSGTL ((AGENT, "set_table_ctrl_text, called\n"));
if (!row_ctx)
return AGENT_ERR_NULL_DATA;
session_id = get_session_id(row_ctx->index.oids[saHpiDomainId_INDEX]);
resource_id = row_ctx->index.oids[saHpiResourceEntryId_INDEX];
/* line */
ctrl_state.StateUnion.Text.Line = row_ctx->saHpiCtrlTextLine;
/* data, len */
memset(ctrl_state.StateUnion.Text.Text.Data, 0,
sizeof(ctrl_state.StateUnion.Text.Text.Data));
memcpy(ctrl_state.StateUnion.Text.Text.Data,
row_ctx->saHpiCtrlTextState,
row_ctx->saHpiCtrlTextState_len);
ctrl_state.StateUnion.Text.Text.DataLength =
row_ctx->saHpiCtrlTextState_len;
/* Datatype */
ctrl_state.StateUnion.Text.Text.DataType =
row_ctx->saHpiCtrlTextType - 1;
/* language */
ctrl_state.StateUnion.Text.Text.Language =
row_ctx->saHpiCtrlTextLanguage - 1;
/* type */
ctrl_state.Type = SAHPI_CTRL_TYPE_TEXT;
rc = saHpiControlSet(session_id, resource_id,
row_ctx->saHpiCtrlTextNum,
row_ctx->saHpiCtrlTextMode - 1,
&ctrl_state);
if (rc != SA_OK) {
snmp_log (LOG_ERR,
"SAHPI_CTRL_TYPE_TEXT: Call to saHpiControlSet failed to set Mode rc: %s.\n",
oh_lookup_error(rc));
DEBUGMSGTL ((AGENT,
"SAHPI_CTRL_TYPE_TEXT: Call to saHpiControlSet failed to set Mode rc: %s.\n",
oh_lookup_error(rc)));
return get_snmp_error(rc);
}
return SNMP_ERR_NOERROR;
}
/*
* int set_table_ctrl_analog_mode();
*/
int set_table_ctrl_stream (saHpiCtrlStreamTable_context *row_ctx)
{
SaErrorT rc = SA_OK;
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlStateT ctrl_state;
DEBUGMSGTL ((AGENT, "set_table_ctrl_stream_mode, called\n"));
if (!row_ctx)
return AGENT_ERR_NULL_DATA;
session_id = get_session_id(row_ctx->index.oids[saHpiCtrlStreamDomainId_INDEX]);
resource_id = row_ctx->index.oids[saHpiCtrlStreamResourceEntryId_INDEX];
/* repeat */
ctrl_state.StateUnion.Stream.Repeat = row_ctx->saHpiCtrlStreamRepeat;
/* stream */
memset(ctrl_state.StateUnion.Stream.Stream, 0,
sizeof(ctrl_state.StateUnion.Stream.Stream));
memcpy(ctrl_state.StateUnion.Stream.Stream,
row_ctx->saHpiCtrlStreamState,
row_ctx->saHpiCtrlStreamState_len);
/* stream length */
ctrl_state.StateUnion.Stream.StreamLength = row_ctx->saHpiCtrlStreamState_len;
/* type */
ctrl_state.Type = SAHPI_CTRL_TYPE_STREAM;
rc = saHpiControlSet(session_id, resource_id,
row_ctx->saHpiCtrlStreamNum,
row_ctx->saHpiCtrlStreamMode - 1,
&ctrl_state);
if (rc != SA_OK) {
snmp_log (LOG_ERR,
"SAHPI_CTRL_TYPE_STREAM: Call to saHpiControlSet failed to set Mode rc: %s.\n",
oh_lookup_error(rc));
DEBUGMSGTL ((AGENT,
"SAHPI_CTRL_TYPE_STREAM: Call to saHpiControlSet failed to set Mode rc: %s.\n",
oh_lookup_error(rc)));
return get_snmp_error(rc);
}
return SNMP_ERR_NOERROR;
}
SaErrorT setAnalogState(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiCtrlRecT * ctrlRec, SaHpiInt32T value)
{
SaErrorT status;
SaHpiCtrlStateT ctrlState;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
setDefaultCtrlState(ctrlRec, &ctrlState);
ctrlState.StateUnion.Analog = value;
status = saHpiControlSet(sessionId, resourceId, ctrlNum,
SAHPI_CTRL_MODE_MANUAL, &ctrlState);
return status;
}
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 set_table_ctrl_analog_state (saHpiCtrlAnalogTable_context *row_ctx)
{
DEBUGMSGTL ((AGENT, "set_table_ctrl_analog_state, called\n"));
SaErrorT rc = SA_OK;
SaHpiSessionIdT session_id;
SaHpiResourceIdT resource_id;
SaHpiCtrlStateT ctrl_state;
if (!row_ctx)
return AGENT_ERR_NULL_DATA;
session_id = get_session_id(row_ctx->index.oids[saHpiDomainId_INDEX]);
resource_id = row_ctx->index.oids[saHpiResourceEntryId_INDEX];
ctrl_state.StateUnion.Analog = row_ctx->saHpiCtrlAnalogState;
ctrl_state.Type = SAHPI_CTRL_TYPE_ANALOG;
rc = saHpiControlSet(session_id, resource_id,
row_ctx->saHpiCtrlAnalogNum,
row_ctx->saHpiCtrlAnalogMode - 1,
&ctrl_state);
if (rc != SA_OK) {
snmp_log (LOG_ERR,
"SAHPI_CTRL_TYPE_ANALOG: Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc));
DEBUGMSGTL ((AGENT,
"SAHPI_CTRL_TYPE_ANALOG: Call to saHpiControlSet failed to set State rc: %s.\n",
oh_lookup_error(rc)));
return get_snmp_error(rc);
}
return SNMP_ERR_NOERROR;
}
int processCtrlRdr(SaHpiSessionIdT sessionId,
SaHpiResourceIdT resourceId,
SaHpiRdrT * rdr, SaHpiCtrlRecT * ctrlRec)
{
SaErrorT status;
int retval = SAF_TEST_NOTSUPPORT;
SaHpiCtrlNumT ctrlNum = ctrlRec->Num;
SaHpiCtrlStateT ctrlState;
if (isTextControl(ctrlRec) && canSetControlState(ctrlRec)) {
if (isAscii6DataType(ctrlRec) || isBcdPlusDataType(ctrlRec)
|| isUnicodeDataType(ctrlRec)) {
setDefaultCtrlState(ctrlRec, &ctrlState);
ctrlState.StateUnion.Text.Text.DataLength = 1;
ctrlState.StateUnion.Text.Text.Data[0] =
CARRIAGE_RETURN;
status = saHpiControlSet(sessionId, resourceId, ctrlNum,
SAHPI_CTRL_MODE_MANUAL,
&ctrlState);
if (status == SA_ERR_HPI_INVALID_PARAMS) {
retval = SAF_TEST_PASS;
} else {
retval = SAF_TEST_FAIL;
e_print(saHpiControlSet,
SA_ERR_HPI_INVALID_PARAMS, status);
}
}
}
return retval;
}
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 = SAHPI_CTRL_MODE_AUTO;
SaHpiCtrlStateT state;
SaHpiEntryIdT entryid;
SaHpiEntryIdT nextentryid;
SaHpiBoolT foundControl;
struct oh_handler_state l_handle;
/* *************************************
* 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: Invalid Handle
*************************/
memset(&l_handle, 0, sizeof(struct oh_handler_state));
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = snmp_bc_set_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 = saHpiControlSet(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 = saHpiControlSet(sessionid, id, 5000, mode, &state);
checkstatus(err, expected_err, testfail);
/**************************
* Test 4: NULL state with AUTO mode
*************************/
expected_err = SA_ERR_HPI_READ_ONLY;
err = saHpiControlSet(sessionid, id, cid, mode, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test 5: NULL state with AUTO mode
*************************/
expected_err = SA_ERR_HPI_INVALID_PARAMS;
err = saHpiControlSet(sessionid, id, cid, SAHPI_CTRL_MODE_MANUAL, NULL);
checkstatus(err, expected_err, testfail);
/**************************
* Test 6: Invalid Capability
*************************/
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 = saHpiControlSet(sessionid, rptentry.ResourceId, cid, mode, &state);
checkstatus(err, expected_err, testfail);
/***************************
* Cleanup after all tests
***************************/
err = tcleanup(&sessionid);
return testfail;
}
static ret_code_t set_control_state(SaHpiSessionIdT sessionid,
SaHpiResourceIdT resourceid, SaHpiCtrlNumT num)
{
SaErrorT rv;
SaHpiRdrT rdr;
SaHpiCtrlRecT *ctrl;
SaHpiCtrlTypeT type;
SaHpiCtrlStateDigitalT state_val = 0;
SaHpiCtrlModeT mode;
SaHpiCtrlStateT state;
char buf[SAHPI_MAX_TEXT_BUFFER_LENGTH];
char *str;
int i, res;
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid, SAHPI_CTRL_RDR,
num, &rdr);
if (rv != SA_OK) {
printf("saHpiRdrGetByInstrumentId: error: %s\n", oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
memset(&state, 0, sizeof(SaHpiCtrlStateT));
i = get_string_param("Mode(auto|manual): ", buf, 7);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
if (strcmp(buf, "auto") == 0) mode = SAHPI_CTRL_MODE_AUTO;
else if (strcmp(buf, "manual") == 0) mode = SAHPI_CTRL_MODE_MANUAL;
else return(HPI_SHELL_CMD_ERROR);
if (mode == SAHPI_CTRL_MODE_AUTO) {
rv = saHpiControlSet(sessionid, resourceid, num,
mode, (SaHpiCtrlStateT *)NULL);
if (rv != SA_OK) {
printf("saHpiControlSet: error: %s\n",
oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return(HPI_SHELL_OK);
};
ctrl = &(rdr.RdrTypeUnion.CtrlRec);
type = ctrl->Type;
state.Type = type;
switch (type) {
case SAHPI_CTRL_TYPE_DIGITAL:
i = get_string_param(
"New state(on|off|pulseon|pulseoff): ", buf, 9);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
if (strcmp(buf, "on") == 0) state_val = SAHPI_CTRL_STATE_ON;
if (strcmp(buf, "off") == 0) state_val = SAHPI_CTRL_STATE_OFF;
if (strcmp(buf, "pulseon") == 0)
state_val = SAHPI_CTRL_STATE_PULSE_ON;
if (strcmp(buf, "pulseoff") == 0)
state_val = SAHPI_CTRL_STATE_PULSE_OFF;
state.StateUnion.Digital = state_val;
break;
case SAHPI_CTRL_TYPE_DISCRETE:
i = get_int_param("Value ==> ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Discrete = res;
break;
case SAHPI_CTRL_TYPE_ANALOG:
i = get_int_param("Value ==> ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Analog = res;
break;
case SAHPI_CTRL_TYPE_STREAM:
i = get_string_param("Repeat(yes|no): ", buf, 4);
if (i != 0) return(HPI_SHELL_CMD_ERROR);
str = buf;
while (*str == ' ') str++;
if (strncmp(str, "yes", 3) == 0)
state.StateUnion.Stream.Repeat = 1;
i = get_string_param("Stream: ", buf, 4);
i = strlen(buf);
if (i > 4) i = 4;
state.StateUnion.Stream.StreamLength = i;
strncpy((char *)(state.StateUnion.Stream.Stream), buf, i);
break;
case SAHPI_CTRL_TYPE_TEXT:
i = get_int_param("Line #: ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Text.Line = res;
printf("Text: ");
i = set_text_buffer(&(state.StateUnion.Text.Text));
if (i != 0) {
printf("Invalid text\n");
return(HPI_SHELL_CMD_ERROR);
};
break;
case SAHPI_CTRL_TYPE_OEM:
i = get_int_param("Manufacturer Id: ", &res);
if (i != 1) {
printf("Invalid value\n");
return HPI_SHELL_CMD_ERROR;
};
state.StateUnion.Oem.MId = res;
memset(state.StateUnion.Oem.Body, 0,
SAHPI_CTRL_MAX_OEM_BODY_LENGTH);
i = get_hex_string_param("Oem body: ",
(char *)(state.StateUnion.Oem.Body),
SAHPI_CTRL_MAX_OEM_BODY_LENGTH);
state.StateUnion.Oem.BodyLength = i;
break;
default:
strcpy(buf, "Unknown control type\n");
return(HPI_SHELL_CMD_ERROR);
};
rv = saHpiControlSet(sessionid, resourceid, num,
SAHPI_CTRL_MODE_MANUAL, &state);
if (rv != SA_OK) {
printf("saHpiControlSet: error: %s\n",
oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
return(HPI_SHELL_OK);
}
int main(int argc, char **argv)
{
int number_resources = 0, modeOption;
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;
SaHpiCtrlTypeT control_type = SAHPI_CTRL_TYPE_DIGITAL;
SaHpiRdrT rdr;
SaHpiCtrlRecT *ctrl;
SaHpiCtrlRecAnalogT *analog;
printf("saHpiControlSet: Test for hpi control set 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\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:");
if (resourceid == powerSubsystemResId) {
printf("\nPower mode control(Press 3)");
printf("\nDynamic power mode control(Press 4)");
printf("\nPower limit mode control(Press 5)");
printf("\nStatic power limit control(Press 6)");
printf("\nDynamic power cap control(Press 7)");
printf("\nDerated circuit cap control(Press 8)");
printf("\nRated circuit cap control(Press 9)");
}
else {
printf("\nUID LED control(Press 0)");
printf("\nPower control(Press 1)");
}
printf("\nEnter your option:");
scanf("%d", &controlNumber);
if (resourceid == powerSubsystemResId) {
switch (controlNumber) {
case OA_SOAP_DYNAMIC_PWR_CNTRL:
control_type = SAHPI_CTRL_TYPE_DIGITAL;
break;
case OA_SOAP_PWR_MODE_CNTRL:
case OA_SOAP_PWR_LIMIT_MODE_CNTRL:
control_type = SAHPI_CTRL_TYPE_DISCRETE;
break;
case OA_SOAP_STATIC_PWR_LIMIT_CNTRL:
case OA_SOAP_DYNAMIC_PWR_CAP_CNTRL:
case OA_SOAP_DERATED_CIRCUIT_CAP_CNTRL:
case OA_SOAP_RATED_CIRCUIT_CAP_CNTRL:
control_type = SAHPI_CTRL_TYPE_ANALOG;
break;
}
}
printf("Possible control mode options are: \n");
printf("\tPress 1 for AUTO MODE \n");
printf("\tPress 2 for MANUAL MODE \n");
printf("Please enter your option: ");
scanf("%d", &modeOption);
if (modeOption == 1)
controlMode=SAHPI_CTRL_MODE_AUTO;
else if (modeOption == 2)
controlMode=SAHPI_CTRL_MODE_MANUAL;
else {
printf("Wrong option selected. Exiting");
exit (-1);
}
controlState.Type = control_type;
switch (control_type) {
case SAHPI_CTRL_TYPE_DIGITAL:
printf("Possible control state options are: \n");
printf("\tPress 1 for ON \n");
printf("\tPress 2 for OFF \n");
printf("Please enter your option: ");
scanf("%d", &modeOption);
switch (modeOption) {
case 1 :
controlState.StateUnion.Digital =
SAHPI_CTRL_STATE_ON;
break;
case 2 :
controlState.StateUnion.Digital =
SAHPI_CTRL_STATE_OFF;
break;
default :
printf("Wrong option selected. Exiting");
exit (-1);
}
break;
case SAHPI_CTRL_TYPE_DISCRETE:
printf("Possible control state options are: \n");
if (controlNumber == OA_SOAP_PWR_MODE_CNTRL) {
printf("\tPress 1 for C7000_PWR_NON_REDUNDANT \n");
printf("\tPress 2 for C7000_PWR_AC_REDUNDANT \n");
printf("\tPress 3 for C7000_PWR_SUPPLY_REDUNDANT \n");
} else {
printf("\tPress 0 for C7000_PWR_LIMIT_NONE \n");
printf("\tPress 1 for C7000_PWR_LIMIT_STATIC \n");
printf("\tPress 2 for C7000_PWR_LIMIT_DYNAMIC_CAP \n");
}
printf("Please enter your option: ");
scanf("%d", &modeOption);
controlState.StateUnion.Discrete = modeOption;
break;
case SAHPI_CTRL_TYPE_ANALOG:
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid,
SAHPI_CTRL_RDR,
controlNumber, &rdr);
if (rv != SA_OK) {
printf("Error: cannot get ctrl rdr by instrument id. Exiting");
exit (-1);
};
ctrl = &(rdr.RdrTypeUnion.CtrlRec);
analog = &(ctrl->TypeUnion.Analog);
printf("Choose an analog value for the control (range = %d - %d): \
\n", analog->Min, analog->Max);
scanf("%d", &modeOption);
controlState.StateUnion.Analog = modeOption;
break;
}
rv = saHpiControlSet(sessionid, resourceid, controlNumber,
controlMode, &controlState);
/* Print the test case status*/
if (rv != SA_OK) {
printf("saHpiControlSet returns %s\n",oh_lookup_error(rv));
printf("Test case - FAIL\n");
}
else
printf("Test case - PASS\n");
rv = saHpiSessionClose(sessionid);
return 0;
}
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);
}
