void cHpiSubProviderEntity::GetInstrumentEntries( SaHpiRdrTypeT type,
std::deque<HpiEntry>& entries ) const
{
SaErrorT rv;
// TODO update_cnt
SaHpiUint32T update_cnt;
SaHpiResourceIdT rid;
SaHpiInstrumentIdT instr_id;
SaHpiRdrT rdr;
SaHpiUint32T i = SAHPI_FIRST_ENTRY;
while( i != SAHPI_LAST_ENTRY ) {
SaHpiUint32T instance_id = i;
rv = saHpiGetIdByEntityPath( m_ctx.session_id,
m_ctx.entity_path,
type,
&i,
&rid,
&instr_id,
&update_cnt );
if( rv != SA_OK ) {
break;
}
rv = saHpiRdrGetByInstrumentId( m_ctx.session_id, rid, type, instr_id, &rdr );
if( rv != SA_OK ) {
break;
}
std::wstring name;
MakeNameForInstrument( rdr, name );
entries.push_back( HpiEntry( RdrType2EntryType( type ), instance_id, name ) );
}
}
ret_code_t ctrl_block(void)
{
SaHpiRdrT rdr_entry;
SaHpiResourceIdT rptid;
SaHpiInstrumentIdT rdrnum;
SaHpiRdrTypeT type;
SaErrorT rv;
char buf[256];
ret_code_t ret;
term_def_t *term;
int res;
ret = ask_rpt(&rptid);
if (ret != HPI_SHELL_OK) return(ret);
type = SAHPI_CTRL_RDR;
ret = ask_rdr(rptid, type, &rdrnum);
if (ret != HPI_SHELL_OK) return(ret);
rv = saHpiRdrGetByInstrumentId(Domain->sessionId, rptid, type, rdrnum,
&rdr_entry);
if (rv != SA_OK) {
printf("saHpiRdrGetByInstrumentId error %s\n", oh_lookup_error(rv));
printf("ERROR!!! Can not get rdr: ResourceId=%d RdrType=%d RdrNum=%d\n",
rptid, type, rdrnum);
return(HPI_SHELL_CMD_ERROR);
};
show_control(Domain->sessionId, rptid, rdrnum, ui_print);
for (;;) {
block_type = CTRL_COM;
res = get_new_command("control block ==> ");
if (res == 2) {
unget_term();
return HPI_SHELL_OK;
};
term = get_next_term();
if (term == NULL) continue;
snprintf(buf, 256, "%s", term->term);
if ((strcmp(buf, "q") == 0) || (strcmp(buf, "quit") == 0)) break;
if (strcmp(buf, "state") == 0) {
show_control_state(Domain->sessionId, rptid, rdrnum, ui_print);
continue;
};
if (strcmp(buf, "setstate") == 0) {
set_control_state(Domain->sessionId, rptid, rdrnum);
continue;
};
if (strcmp(buf, "show") == 0) {
show_control(Domain->sessionId, rptid, rdrnum, ui_print);
continue;
}
};
block_type = MAIN_COM;
return SA_OK;
}
ret_code_t fumi_block( void )
{
SaErrorT rv;
ret_code_t ret;
SaHpiResourceIdT rptid;
SaHpiInstrumentIdT rdrnum;
SaHpiRdrT rdr;
ret = ask_rpt( &rptid );
if ( ret != HPI_SHELL_OK ) {
return ret;
};
ret = ask_rdr( rptid, SAHPI_FUMI_RDR, &rdrnum );
if ( ret != HPI_SHELL_OK ) {
return ret;
}
rv = saHpiRdrGetByInstrumentId( Domain->sessionId, rptid, SAHPI_FUMI_RDR, rdrnum, &rdr );
if ( rv != SA_OK ) {
printf( "ERROR!!! saHpiRdrGetByInstrumentId"
"(Rpt=%d RdrType=%d Rdr=%d): %s\n",
rptid, SAHPI_FUMI_RDR, rdrnum,
oh_lookup_error( rv )
);
return HPI_SHELL_CMD_ERROR;
};
fumi_block_env.rptid = rptid;
fumi_block_env.fuminum = rdr.RdrTypeUnion.FumiRec.Num;
block_type = FUMI_COM;
for ( ;; ) {
int res;
term_def_t * term ;
char buf[256];
res = get_new_command( "FUMI block ==> " );
if ( res == 2 ) {
unget_term();
break;
};
term = get_next_term();
if ( term == NULL ) continue;
snprintf( buf, 256, "%s", term->term );
if ( ( strcmp( buf, "q" ) == 0) || ( strcmp( buf, "quit" ) == 0 ) ) {
break;
}
}
block_type = MAIN_COM;
return HPI_SHELL_OK;
}
void cHpiSubProviderWatchdog::GetInfo( std::deque<HpiInfo>& info ) const
{
info.clear();
SaErrorT rv;
SaHpiRdrT rdr;
rv = saHpiRdrGetByInstrumentId( m_ctx.session_id,
m_ctx.resource_id,
SAHPI_WATCHDOG_RDR,
m_ctx.instrument_id,
&rdr );
if ( rv != SA_OK ) {
Line( info, L"saHpiRdrGetByInstrumentId failed", rv, I32_SaError );
return;
}
Line( info, L"Resource Id", m_ctx.resource_id, UI32_SaHpiResourceId );
Line( info, L"Entity", rdr.Entity );
Line( info, L"IsFru", rdr.IsFru, UI8_SaHpiBool );
const SaHpiWatchdogRecT& wr = rdr.RdrTypeUnion.WatchdogRec;
Line( info, L"Watchdog Num", wr.WatchdogNum, UI32_SaHpiWatchdogNum );
Line( info, L"OEM", wr.Oem );
Line( info, L"IdString", rdr.IdString );
SaHpiWatchdogT w;
rv = saHpiWatchdogTimerGet( m_ctx.session_id,
m_ctx.resource_id,
m_ctx.instrument_id,
&w );
if ( rv != SA_OK ) {
Line( info, L"saHpiWatchdogTimerGet failed", rv, I32_SaError );
return;
}
Line( info, L"Current Settings and Configuration", L"" );
Line( info, L" Log", w.Log, UI8_SaHpiBool );
Line( info, L" Running", w.Running, UI8_SaHpiBool );
Line( info, L" Timer Use", w.TimerUse );
Line( info, L" Timer Action", w.TimerAction );
Line( info, L" Pre-Timer Interrupt", w.PretimerInterrupt );
Line( info, L" Pre-Timeout Interval, ms", w.PreTimeoutInterval );
Line( info, L" Timer Use Expiration Flags",
w.TimerUseExpFlags,
UI8_SaHpiWatchdogExpFlags );
Line( info, L" Initial Count", w.InitialCount );
Line( info, L" Present Count", w.PresentCount );
}
ret_code_t ann_block(void)
{
SaHpiResourceIdT rptid;
SaHpiInstrumentIdT rdrnum;
SaHpiRdrTypeT type;
SaErrorT rv;
char buf[256];
ret_code_t ret;
term_def_t *term;
int res;
ret = ask_rpt(&rptid);
if (ret != HPI_SHELL_OK) return(ret);
type = SAHPI_ANNUNCIATOR_RDR;
ret = ask_rdr(rptid, type, &rdrnum);
if (ret != HPI_SHELL_OK) return(ret);
rv = saHpiRdrGetByInstrumentId(Domain->sessionId, rptid, type, rdrnum,
&(ann_block_env.rdr_entry));
if (rv != SA_OK) {
printf("saHpiRdrGetByInstrumentId error %s\n", oh_lookup_error(rv));
printf("ERROR!!! Can not get rdr: ResourceId=%d RdrType=%d RdrNum=%d\n",
rptid, type, rdrnum);
return(HPI_SHELL_CMD_ERROR);
};
ann_block_env.rptid = rptid;
ann_block_env.rdrnum = rdrnum;
show_rdr_attrs(&(ann_block_env.rdr_entry));
for (;;) {
block_type = ANN_COM;
res = get_new_command("annunciator block ==> ");
if (res == 2) {
unget_term();
block_type = MAIN_COM;
return HPI_SHELL_OK;
};
term = get_next_term();
if (term == NULL) continue;
snprintf(buf, 256, "%s", term->term);
if ((strcmp(buf, "q") == 0) || (strcmp(buf, "quit") == 0)) break;
};
block_type = MAIN_COM;
return HPI_SHELL_OK;
}
void cHpiSubProviderIdr::GetInfo( std::deque<HpiInfo>& info ) const
{
info.clear();
SaErrorT rv;
SaHpiRdrT rdr;
rv = saHpiRdrGetByInstrumentId( m_ctx.session_id,
m_ctx.resource_id,
SAHPI_INVENTORY_RDR,
m_ctx.instrument_id,
&rdr );
if ( rv != SA_OK ) {
Line( info, L"saHpiRdrGetByInstrumentId failed", rv, I32_SaError );
return;
}
Line( info, L"Resource Id", m_ctx.resource_id, UI32_SaHpiResourceId );
Line( info, L"Entity", rdr.Entity );
Line( info, L"IsFru", rdr.IsFru, UI8_SaHpiBool );
const SaHpiInventoryRecT& ir = rdr.RdrTypeUnion.InventoryRec;
Line( info, L"Idr Id", ir.IdrId, UI32_SaHpiIdrId );
Line( info, L"Persistent", ir.Persistent, UI8_SaHpiBool );
Line( info, L"OEM", ir.Oem );
Line( info, L"IdString", rdr.IdString );
SaHpiIdrInfoT idr_info;
rv = saHpiIdrInfoGet( m_ctx.session_id,
m_ctx.resource_id,
m_ctx.instrument_id,
&idr_info );
if ( rv != SA_OK ) {
Line( info, L"saHpiIdrInfoGet failed", rv, I32_SaError );
return;
}
Line( info, L"Update Count", idr_info.UpdateCount );
Line( info, L"Read Only", idr_info.ReadOnly, UI8_SaHpiBool );
Line( info, L"Number of Areas", idr_info.NumAreas );
}
int Test_Resource(SaHpiSessionIdT session_id, SaHpiRptEntryT rpt_entry,
callback2_t func)
{
SaErrorT status;
int retval = SAF_TEST_UNKNOWN;
SaHpiRdrT newRdr;
if (!(rpt_entry.ResourceCapabilities & SAHPI_CAPABILITY_RDR)) {
status = saHpiRdrGetByInstrumentId(session_id,
rpt_entry.ResourceId,
SAHPI_SENSOR_RDR,
0, &newRdr);
if (status != SA_ERR_HPI_CAPABILITY) {
e_print(saHpiRdrGetByInstrumentId,
SA_ERR_HPI_CAPABILITY, status);
retval = SAF_TEST_FAIL;
} else {
retval = SAF_TEST_PASS;
}
} else //Resource Does not support RDR's
retval = SAF_TEST_NOTSUPPORT;
return (retval);
}
static ret_code_t show_rdr(void)
{
Rdr_t tmp_rdr;
SaHpiRdrT rdr_entry;
SaHpiResourceIdT rptid = 0;
SaHpiInstrumentIdT rdrnum;
SaHpiRdrTypeT type;
SaErrorT rv;
int i;
char buf[10], t;
term_def_t *term;
ret_code_t ret;
term = get_next_term();
if (term == NULL) {
if (read_file) return(HPI_SHELL_CMD_ERROR);
i = show_rpt_list(Domain, SHOW_ALL_RPT, rptid, ui_print);
if (i == 0) {
printf("NO rpt!\n");
return(HPI_SHELL_CMD_ERROR);
};
i = get_string_param("RPT (ID | all) ==> ", buf, 9);
if (i != 0) return HPI_SHELL_CMD_ERROR;
if (strncmp(buf, "all", 3) == 0) {
show_rpt_list(Domain, SHOW_ALL_RDR, rptid, ui_print);
return(HPI_SHELL_OK);
};
rptid = (SaHpiResourceIdT)atoi(buf);
} else {
if (strcmp(term->term, "all") == 0) {
show_rpt_list(Domain, SHOW_ALL_RDR, rptid, ui_print);
return(HPI_SHELL_OK);
};
if (isdigit(term->term[0]))
rptid = (SaHpiResourceIdT)atoi(term->term);
else
return HPI_SHELL_PARM_ERROR;
};
term = get_next_term();
if (term == NULL) {
if (read_file) return(HPI_SHELL_CMD_ERROR);
i = get_string_param("RDR Type (s|a|c|w|i|all) ==> ",
buf, 9);
if (i != 0) return HPI_SHELL_PARM_ERROR;
} else {
memset(buf, 0, 10);
strncpy(buf, term->term, 3);
};
if (strncmp(buf, "all", 3) == 0) t = 'n';
else t = *buf;
if (t == 'c') type = SAHPI_CTRL_RDR;
else if (t == 's') type = SAHPI_SENSOR_RDR;
else if (t == 'i') type = SAHPI_INVENTORY_RDR;
else if (t == 'w') type = SAHPI_WATCHDOG_RDR;
else if (t == 'a') type = SAHPI_ANNUNCIATOR_RDR;
else type = SAHPI_NO_RECORD;
ret = ask_rdr(rptid, type, &rdrnum);
if (ret != HPI_SHELL_OK) return(ret);
if (type == SAHPI_NO_RECORD)
rv = find_rdr_by_num(Domain->sessionId, rptid,
rdrnum, type, 0, &rdr_entry);
else
rv = saHpiRdrGetByInstrumentId(Domain->sessionId,
rptid, type, rdrnum, &rdr_entry);
if (rv != SA_OK) {
printf("ERROR!!! Get rdr: ResourceId=%d RdrType=%d"
"RdrNum=%d: %s\n",
rptid, type, rdrnum, oh_lookup_error(rv));
return(HPI_SHELL_CMD_ERROR);
};
make_attrs_rdr(&tmp_rdr, &rdr_entry);
show_Rdr(&tmp_rdr, ui_print);
free_attrs(&(tmp_rdr.Attrutes));
return HPI_SHELL_OK;
}
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;
}
SaErrorT show_control(SaHpiSessionIdT sessionid, SaHpiResourceIdT resourceid,
SaHpiCtrlNumT num, hpi_ui_print_cb_t proc)
{
SaErrorT rv;
SaHpiRdrT rdr;
SaHpiCtrlRecT *ctrl;
char *str, *str1;
char buf[SHOW_BUF_SZ];
char errbuf[SHOW_BUF_SZ];
SaHpiCtrlTypeT type;
SaHpiCtrlRecDigitalT *digit;
SaHpiCtrlRecDiscreteT *discr;
SaHpiCtrlRecAnalogT *analog;
SaHpiCtrlRecStreamT *stream;
SaHpiCtrlRecTextT *text;
SaHpiCtrlRecOemT *oem;
int i;
rv = saHpiRdrGetByInstrumentId(sessionid, resourceid, SAHPI_CTRL_RDR,
num, &rdr);
if (rv != SA_OK) {
snprintf(errbuf, SHOW_BUF_SZ,
"\nERROR: saHpiRdrGetByInstrumentId: error: %s\n",
oh_lookup_error(rv));
proc(errbuf);
return(rv);
};
ctrl = &(rdr.RdrTypeUnion.CtrlRec);
type = ctrl->Type;
if (ctrl->WriteOnly) str = "(Write Only)";
else str = " ";
snprintf(buf, SHOW_BUF_SZ, "Control(%d/%d) Type: %s %s Output: %s\n",
resourceid, num, oh_lookup_ctrltype(type), str,
oh_lookup_ctrloutputtype(ctrl->OutputType));
if (proc(buf) != HPI_UI_OK) return(SA_OK);
if (ctrl->DefaultMode.ReadOnly) str = "(Read Only)";
else str = " ";
snprintf(buf, SHOW_BUF_SZ, " Mode: %s %s\n",
oh_lookup_ctrlmode(ctrl->DefaultMode.Mode), str);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
if (proc("Data:\n") != HPI_UI_OK) return(SA_OK);
switch (type) {
case SAHPI_CTRL_TYPE_DIGITAL:
digit = &(ctrl->TypeUnion.Digital);
str = oh_lookup_ctrlstatedigital(digit->Default);
if (str == (char *)NULL) {
snprintf(errbuf, SHOW_BUF_SZ, "Invalid value (0x%x)",
digit->Default);
str = errbuf;
};
snprintf(buf, SHOW_BUF_SZ, "\tDefault: %s\n", str);
break;
case SAHPI_CTRL_TYPE_DISCRETE:
discr = &(ctrl->TypeUnion.Discrete);
snprintf(buf, SHOW_BUF_SZ, "\tDefault: %d\n", discr->Default);
break;
case SAHPI_CTRL_TYPE_ANALOG:
analog = &(ctrl->TypeUnion.Analog);
snprintf(buf, SHOW_BUF_SZ,
"\tDefault: %d (min = %d max = %d)\n",
analog->Default, analog->Min, analog->Max);
break;
case SAHPI_CTRL_TYPE_STREAM:
stream = &(ctrl->TypeUnion.Stream);
snprintf(buf, SHOW_BUF_SZ,
"\tDefault: Repeat = %d lendth = %d stream = %s\n",
stream->Default.Repeat, stream->Default.StreamLength,
stream->Default.Stream);
break;
case SAHPI_CTRL_TYPE_TEXT:
text = &(ctrl->TypeUnion.Text);
snprintf(buf, SHOW_BUF_SZ, "\tMaxChars = %d MaxLines = %d\n",
text->MaxChars, text->MaxLines);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
str = oh_lookup_language(text->Language);
if (str == (char *)NULL) str = "UNKNOWN";
str1 = oh_lookup_texttype(text->DataType);
if (str1 == (char *)NULL) str1 = "UNKNOWN";
snprintf(buf, SHOW_BUF_SZ,
"\tLanguage = %s DataType = %s\n", str, str1);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
snprintf(buf, SHOW_BUF_SZ, "\tDefault: Line # = %d",
text->Default.Line);
if (proc(buf) != HPI_UI_OK) return(SA_OK);
print_text_buffer_text(" Text = ", &(text->Default.Text),
"\n", proc);
return SA_OK;
case SAHPI_CTRL_TYPE_OEM:
oem = &(ctrl->TypeUnion.Oem);
snprintf(buf, SHOW_BUF_SZ, "\tMId = %d Config data = ",
oem->MId);
proc(buf);
str = (char *)(oem->ConfigData);
for (i = 0; i < SAHPI_CTRL_OEM_CONFIG_LENGTH; i++)
sprintf(buf + i * 3, "%2.2X ", (unsigned char)(str[i]));
strcat(buf, "\n\t");
if (proc(buf) != HPI_UI_OK) return(SA_OK);
sprintf(buf, "Default: MId = %d Body = ", oem->MId);
str = (char *)(oem->Default.Body);
for (i = 0; i < oem->Default.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;
}
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 Test_Resource(SaHpiSessionIdT session_id, SaHpiRptEntryT rpt_entry,
callback2_t func)
{
SaErrorT status;
int retval = SAF_TEST_UNKNOWN;
SaHpiEntryIdT CurrRdr, NextRdr;
SaHpiRdrT Rdr, newRdr;
SaHpiInstrumentIdT Id;
SaHpiRdrTypeT Type;
if (rpt_entry.ResourceCapabilities & SAHPI_CAPABILITY_RDR) {
NextRdr = SAHPI_FIRST_ENTRY;
while (NextRdr != SAHPI_LAST_ENTRY) {
CurrRdr = NextRdr;
status = saHpiRdrGet(session_id,
rpt_entry.ResourceId,
CurrRdr, &NextRdr, &Rdr);
if (status != SA_OK) {
e_print(saHpiRdrGet, SA_OK, status);
retval = SAF_TEST_UNRESOLVED;
break;
}
if ((Type = Rdr.RdrType) == SAHPI_NO_RECORD) {
m_print("No Rdr Record found.");
retval = SAF_TEST_UNRESOLVED;
break;
}
switch (Type) {
case SAHPI_SENSOR_RDR:
Id = (SaHpiInstrumentIdT) Rdr.RdrTypeUnion.
SensorRec.Num;
break;
case SAHPI_CTRL_RDR:
Id = (SaHpiInstrumentIdT) Rdr.RdrTypeUnion.
CtrlRec.Num;
break;
case SAHPI_INVENTORY_RDR:
Id = (SaHpiInstrumentIdT) Rdr.RdrTypeUnion.
InventoryRec.IdrId;
break;
case SAHPI_WATCHDOG_RDR:
Id = (SaHpiInstrumentIdT) Rdr.RdrTypeUnion.
WatchdogRec.WatchdogNum;
break;
case SAHPI_ANNUNCIATOR_RDR:
Id = (SaHpiInstrumentIdT) Rdr.RdrTypeUnion.
AnnunciatorRec.AnnunciatorNum;
break;
default:
break;
}
if (Type != SAHPI_NO_RECORD) {
status = saHpiRdrGetByInstrumentId(session_id,
rpt_entry.
ResourceId,
SAHPI_NO_RECORD,
Id, &newRdr);
if (status != SA_ERR_HPI_INVALID_PARAMS) {
e_print(saHpiRdrGetByInstrumentId,
SA_ERR_HPI_INVALID_PARAMS,
status);
retval = SAF_TEST_FAIL;
break;
} else {
retval = SAF_TEST_PASS;
break;
}
}
}
if (retval == SAF_TEST_UNKNOWN)
retval = SAF_TEST_PASS;
} else //Resource Does not support RDR's
retval = SAF_TEST_NOTSUPPORT;
return (retval);
}
ret_code_t ann_block(void)
{
SaHpiRdrT rdr_entry;
SaHpiResourceIdT rptid;
SaHpiInstrumentIdT rdrnum;
SaHpiAnnunciatorModeT mode;
SaHpiRdrTypeT type;
SaErrorT rv;
char buf[256];
char *str;
ret_code_t ret;
term_def_t *term;
int res, val;
ret = ask_rpt(&rptid);
if (ret != HPI_SHELL_OK) return(ret);
type = SAHPI_ANNUNCIATOR_RDR;
ret = ask_rdr(rptid, type, &rdrnum);
if (ret != HPI_SHELL_OK) return(ret);
rv = saHpiRdrGetByInstrumentId(Domain->sessionId, rptid, type, rdrnum,
&rdr_entry);
if (rv != SA_OK) {
printf("saHpiRdrGetByInstrumentId error %s\n", oh_lookup_error(rv));
printf("ERROR!!! Can not get rdr: ResourceId=%d RdrType=%d RdrNum=%d\n",
rptid, type, rdrnum);
return(HPI_SHELL_CMD_ERROR);
};
show_rdr_attrs(&rdr_entry);
for (;;) {
block_type = ANN_COM;
res = get_new_command("annunciator block ==> ");
if (res == 2) {
unget_term();
block_type = MAIN_COM;
return HPI_SHELL_OK;
};
term = get_next_term();
if (term == NULL) continue;
snprintf(buf, 256, "%s", term->term);
if ((strcmp(buf, "q") == 0) || (strcmp(buf, "quit") == 0)) break;
if (strcmp(buf, "acknow") == 0) {
set_acknowledge(rptid, rdrnum);
continue;
};
if (strcmp(buf, "list") == 0) {
list_cond(rptid, rdrnum);
continue;
};
if (strcmp(buf, "add") == 0) {
add_announ(rptid, rdrnum);
continue;
};
if (strcmp(buf, "delete") == 0) {
delete_announ(rptid, rdrnum);
continue;
};
if (strcmp(buf, "modeget") == 0) {
rv = saHpiAnnunciatorModeGet(Domain->sessionId, rptid,
rdrnum, &mode);
if (rv != SA_OK) {
printf("saHpiAnnunciatorModeGet error %s\n",
oh_lookup_error(rv));
continue;
};
switch (mode) {
case SAHPI_ANNUNCIATOR_MODE_AUTO:
str = "AUTO"; break;
case SAHPI_ANNUNCIATOR_MODE_USER:
str = "USER"; break;
case SAHPI_ANNUNCIATOR_MODE_SHARED:
str = "SHARED"; break;
default: str = "Unknown"; break;
};
printf("Annunciator Mode: %s\n", str);
continue;
};
if (strcmp(buf, "modeset") == 0) {
res = get_string_param("Mode(auto|user|shared): ",
buf, 10);
if (res != 0) {
printf("Invalid mode: %s\n", buf);
continue;
};
if (strcmp(buf, "auto") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_AUTO;
else if (strcmp(buf, "user") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_USER;
else if (strcmp(buf, "shared") == 0)
mode = SAHPI_ANNUNCIATOR_MODE_SHARED;
else {
printf("Invalid mode: %s\n", buf);
continue;
};
rv = saHpiAnnunciatorModeSet(Domain->sessionId, rptid,
rdrnum, mode);
if (rv != SA_OK) {
printf("saHpiAnnunciatorModeSet error %s\n",
oh_lookup_error(rv));
};
continue;
};
if (strcmp(buf, "show") == 0) {
term = get_next_term();
if (term == NULL) {
show_rdr_attrs(&rdr_entry);
continue;
};
unget_term();
res = get_int_param(" ", &val);
if (res != 1) unget_term();
else show_cond(rptid, rdrnum, val);
continue;
}
};
block_type = MAIN_COM;
return SA_OK;
}