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; }