void
print_system_info(picl_nodehdl_t nodeh, int verbose)
{
int ret, i;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
if (verbose) {
prt_node_props(nodeh);
return;
}
PRINTF(" Manufacturer:SUN\n");
i = 1;
while (system_prop[i]) {
if (system_info[i]) {
PRINTF(" %s:", system_info[i]);
} else {
PRINTF(" %s:", system_prop[i]);
}
ret = picl_get_propinfo_by_name(nodeh, system_prop[i],
&pinfo, &proph);
if (ret == 0) {
prt_prop_val(proph, &pinfo);
}
PRINTF("\n");
i++;
}
}
/*
* return the first compatible value
*/
static int
montoya_get_first_compatible_value(picl_nodehdl_t nodeh, char **outbuf)
{
int err;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
picl_prophdl_t tblh;
picl_prophdl_t rowproph;
char *pval;
err = picl_get_propinfo_by_name(nodeh, OBP_PROP_COMPATIBLE,
&pinfo, &proph);
if (err != PICL_SUCCESS)
return (err);
if (pinfo.type == PICL_PTYPE_CHARSTRING) {
pval = malloc(pinfo.size);
if (pval == NULL)
return (PICL_FAILURE);
err = picl_get_propval(proph, pval, pinfo.size);
if (err != PICL_SUCCESS) {
free(pval);
return (err);
}
*outbuf = pval;
return (PICL_SUCCESS);
}
if (pinfo.type != PICL_PTYPE_TABLE)
return (PICL_FAILURE);
/* get first string from table */
err = picl_get_propval(proph, &tblh, pinfo.size);
if (err != PICL_SUCCESS)
return (err);
err = picl_get_next_by_row(tblh, &rowproph);
if (err != PICL_SUCCESS)
return (err);
err = picl_get_propinfo(rowproph, &pinfo);
if (err != PICL_SUCCESS)
return (err);
pval = malloc(pinfo.size);
if (pval == NULL)
return (PICL_FAILURE);
err = picl_get_propval(rowproph, pval, pinfo.size);
if (err != PICL_SUCCESS) {
free(pval);
return (err);
}
*outbuf = pval;
return (PICL_SUCCESS);
}
static int
process_switch(picl_nodehdl_t childh,
char propname[PICL_PROPNAMELEN_MAX])
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
char state[32];
int st_cnt;
char *switch_settings[]={"OFF","ON","NORMAL","LOCKED","UNKNOWN",
"DIAG","SECURE"};
u_int value;
u_int found = 0;
int max_key_posns = 7;
int typ = 3; /*other*/
if (sensor_array[typ].n >= MAX_SENSORS){
DEBUGMSG(("ucd-snmp/lmSensors",
"There are too many sensors of type %d\n",typ));
}
else{
picl_errno_t error_code,ec2;
error_code = (picl_get_propinfo_by_name(childh,
"State",&sensor_info,&sensorh));
if (error_code == PICL_SUCCESS) {
ec2 = picl_get_propval(sensorh,&state,sensor_info.size);
if (ec2 == PICL_SUCCESS){
for (st_cnt=0;st_cnt < max_key_posns;st_cnt++){
if (strncmp(state,switch_settings[st_cnt],
strlen(switch_settings[st_cnt])) == 0){
value = st_cnt;
found = 1;
break;
} /* end if */
} /* end for */
if (found==0)
value = 99;
sensor_array[typ].sensor[sensor_array[typ].n].value = value;
snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
(PICL_PROPNAMELEN_MAX - 1),"%s",propname);
sensor_array[typ].sensor[sensor_array[typ].n].
name[PICL_PROPNAMELEN_MAX - 1] = '\0';
sensor_array[typ].n++;
} /*end if ec2*/
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor value read error code->%d\n",ec2));
} /* end if */
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor lookup failed error code->%d\n",error_code));
}
} /*process switch*/
static int
process_i2c(picl_nodehdl_t childh,
char propname[PICL_PROPNAMELEN_MAX])
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
char state[32];
int st_cnt;
char *i2c_settings[]={"OK"};
u_int value;
u_int found = 0;
int max_i2c_posns = 1;
int typ = 3;
picl_errno_t error_code,ec2;
if (sensor_array[typ].n >= MAX_SENSORS){
DEBUGMSG(("ucd-snmp/lmSensors",
"There are too many sensors of type %d\n",typ));
}
else{
error_code = (picl_get_propinfo_by_name(childh,
"State",&sensor_info,&sensorh));
if (error_code == PICL_SUCCESS) {
ec2 = picl_get_propval(sensorh,&state,sensor_info.size);
if (ec2 == PICL_SUCCESS){
for (st_cnt=0;st_cnt < max_i2c_posns;st_cnt++){
if (strncmp(state,i2c_settings[st_cnt],
strlen(i2c_settings[st_cnt])) == 0){
value=st_cnt;
found = 1;
break;
}
}
if (found==0)
value = 99;
sensor_array[typ].sensor[sensor_array[typ].n].value = value;
snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
(PICL_PROPNAMELEN_MAX - 1),"%s",propname);
sensor_array[typ].sensor[sensor_array[typ].n].
name[PICL_PROPNAMELEN_MAX - 1] = '\0';
sensor_array[typ].n++;
}
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor value read error code->%d\n",ec2));
}
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor lookup failed error code->%d\n",error_code));
}
}
int
print_processor_info(picl_nodehdl_t nodeh, void *args)
{
int ret, i;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
PRINTF(" Processor %d:\n", cpu_num);
cpu_num++;
i = *(int *)args;
if (i) {
prt_node_props(nodeh);
return (PICL_WALK_CONTINUE);
}
i = 0;
while (processor_prop[i]) {
if (processor_name[i]) {
PRINTF(" %s: ", processor_name[i]);
} else {
PRINTF(" %s: ", processor_prop[i]);
}
ret = picl_get_propinfo_by_name(nodeh, processor_prop[i],
&pinfo, &proph);
if (ret == 0) {
if (i == 4) {
granu = 1000000;
}
prt_prop_val(proph, &pinfo);
if (i == 4) {
granu = 1;
PRINTF("MHZ");
}
}
PRINTF("\n");
i++;
}
PRINTF("\n");
return (PICL_WALK_CONTINUE);
}
static int64_t
montoya_get_int_propval(picl_nodehdl_t modh, char *prop_name, int *ret)
{
int err;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
int8_t int8v;
int16_t int16v;
int32_t int32v;
int64_t int64v;
err = picl_get_propinfo_by_name(modh, prop_name, &pinfo, &proph);
if (err != PICL_SUCCESS) {
*ret = err;
return (0);
}
/*
* If it is not an int, uint or byte array prop, return failure
*/
if ((pinfo.type != PICL_PTYPE_INT) &&
(pinfo.type != PICL_PTYPE_UNSIGNED_INT) &&
(pinfo.type != PICL_PTYPE_BYTEARRAY)) {
*ret = PICL_FAILURE;
return (0);
}
switch (pinfo.size) {
case sizeof (int8_t):
err = picl_get_propval(proph, &int8v, sizeof (int8v));
*ret = err;
return (int8v);
case sizeof (int16_t):
err = picl_get_propval(proph, &int16v, sizeof (int16v));
*ret = err;
return (int16v);
case sizeof (int32_t):
err = picl_get_propval(proph, &int32v, sizeof (int32v));
*ret = err;
return (int32v);
case sizeof (int64_t):
err = picl_get_propval(proph, &int64v, sizeof (int64v));
*ret = err;
return (int64v);
default: /* not supported size */
*ret = PICL_FAILURE;
return (0);
}
}
int
print_memory_info(picl_nodehdl_t nodeh, void *args)
{
int ret, i;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
i = *(int *)args;
if (i) {
prt_node_props(nodeh);
return (PICL_WALK_CONTINUE);
}
i = 0;
while (mem_prop[i]) {
if (mem_info[i]) {
PRINTF(" %s: ", mem_info[i]);
} else {
PRINTF(" %s: ", mem_prop[i]);
}
ret = picl_get_propinfo_by_name(nodeh, mem_prop[i],
&pinfo, &proph);
if (ret == 0) {
if (i == 1) {
granu = 1024 * 1024;
}
prt_prop_val(proph, &pinfo);
if (i == 1) {
granu = 1;
PRINTF("M");
}
}
PRINTF("\n");
i++;
}
PRINTF("\n");
return (PICL_WALK_CONTINUE);
}
static int
read_enum_sensor( picl_nodehdl_t childh, float *value, const char **options )
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
picl_errno_t error_code;
char state[PICL_PROPSIZE_MAX];
int i;
/*
* Retrieve the specified sensor information and value
*/
error_code = picl_get_propinfo_by_name(childh, "State", &sensor_info, &sensorh);
if ( error_code != PICL_SUCCESS ) {
DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n",
error_code));
return( error_code );
}
error_code = picl_get_propval(sensorh, state, sensor_info.size);
if ( error_code != PICL_SUCCESS ) {
DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n",
error_code));
return( error_code );
}
/*
* Try to find a matching entry in the list of options.
* Note that some platforms may use upper or lower case
* versions of these enumeration values
* (so the checks are case insensitive)
*/
*value = 99; /* Dummy value */
for ( i=0; options[i] != NULL; i++ ) {
if (strncasecmp(state, options[i], strlen(options[i])) == 0) {
*value = i;
return 0;
}
}
DEBUGMSGTL(("sensors:arch:detail", "Enumeration state %s not matched\n",
state));
return 0; /* Or an error ? */
}
static int
read_enum_sensor(picl_nodehdl_t childh, const char **options, u_int *value)
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
picl_errno_t error_code;
char state[PICL_PROPSIZE_MAX];
int i;
error_code = (picl_get_propinfo_by_name(childh, "State",
&sensor_info, &sensorh));
if (error_code != PICL_SUCCESS) {
DEBUGMSGTL(("ucd-snmp/lmSensors",
"sensor info lookup failed in read_enum_sensor - error code->%d\n", error_code));
return(error_code);
}
error_code = picl_get_propval(sensorh, state, sensor_info.size);
if (error_code != PICL_SUCCESS) {
DEBUGMSGTL(("ucd-snmp/lmSensors",
"sensor value lookup failed in read_enum_sensor - error code->%d\n", error_code));
return(error_code);
}
/* Start with error value, then try to fill in something better.
Use case-insensitive match to find the right value since platforms
may return either case.
*/
*value = 99;
for (i = 0; options[i] != NULL; i++){
if (strncasecmp(state, options[i], strlen(options[i])) == 0){
*value = i;
break;
}
}
DEBUGMSGTL(("ucd-snmp/lmSensors", "read_enum_sensor value is %d\n", *value));
return(error_code);
} /* end of read_enum_sensor() */
static int
process_digital_sensor(picl_nodehdl_t childh,
char propname[PICL_PROPNAMELEN_MAX])
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
int temp; /*volts?*/
int typ = 2; /*volts*/
picl_errno_t error_code,ec2;
if (sensor_array[typ].n >= MAX_SENSORS){
DEBUGMSG(("ucd-snmp/lmSensors",
"There are too many sensors of type %d\n",typ));
}
else{
error_code = (picl_get_propinfo_by_name(childh,
"AtoDSensorValue",&sensor_info,&sensorh));
if (error_code == PICL_SUCCESS) {
ec2 = picl_get_propval(sensorh,&temp,sizeof(temp));
if (ec2 == PICL_SUCCESS){
sensor_array[typ].sensor[sensor_array[typ].n].value = temp;
snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
(PICL_PROPNAMELEN_MAX - 1),"%s",propname);
sensor_array[typ].sensor[sensor_array[typ].n].
name[PICL_PROPNAMELEN_MAX - 1] = '\0';
sensor_array[typ].n++;
}
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor value read error code->%d\n",ec2));
} /* end if */
else
DEBUGMSG(("ucd-snmp/lmSensors",
"sensor lookup failed error code->%d\n",error_code));
}
} /* process digital sensor */
static int
walk_callback(picl_nodehdl_t nodeh, void *args)
{
char vga[10];
picl_propinfo_t pinfo;
picl_prophdl_t ph;
/*int i;*/
if (picl_get_propval_by_name(nodeh, "driver-name", vga, 10) != 0) {
return (PICL_WALK_CONTINUE);
}
if (strcmp(vga, "vgatext") != 0) {
return (PICL_WALK_CONTINUE);
}
if (picl_get_propinfo_by_name(nodeh, "display-edif-block",
&pinfo, &ph) != 0) {
return (PICL_WALK_TERMINATE);
}
mem = (unsigned char *)malloc(pinfo.size);
if (mem == NULL) {
return (PICL_WALK_TERMINATE);
}
if (picl_get_propval(ph, mem, pinfo.size)) {
(void) printf("Unable to get block\n");
return (PICL_WALK_TERMINATE);
}
/*(void) printf("display-edif-block = ");
for (i = 0; i < pinfo.size; i++)
(void) printf("%02x.", mem[i]);
(void) putchar('\n');*/
return (PICL_WALK_TERMINATE);
}
void
print_bios_info(picl_nodehdl_t nodeh, int verbose)
{
int ret, i;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
if (verbose) {
prt_node_props(nodeh);
return;
}
PRINTF(" Vendor:\n");
i = 1;
while (prom_prop[i]) {
if (prom_info[i]) {
PRINTF(" %s:", prom_info[i]);
} else {
PRINTF(" %s:", prom_prop[i]);
}
ret = picl_get_propinfo_by_name(nodeh, prom_prop[i],
&pinfo, &proph);
if (ret == 0) {
prt_prop_val(proph, &pinfo);
}
PRINTF("\n");
i++;
}
PRINTF(" Release Date:\n");
PRINTF(" BIOS Revision:\n");
PRINTF(" Firmware Revision:\n");
}
/*
* Handle a numeric-valued sensor
*/
static int
read_num_sensor( picl_nodehdl_t childh, const char *propval, float *value )
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
picl_errno_t error_code;
union valu {
char buf[PICL_PROPSIZE_MAX];
uint32_t us4;
uint16_t us2;
int32_t is4;
int16_t is2;
float f;
} val;
/*
* Retrieve the specified sensor information and value
*/
error_code = picl_get_propinfo_by_name(childh, propval, &sensor_info, &sensorh);
if ( error_code != PICL_SUCCESS ) {
DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n",
error_code));
return( error_code );
}
error_code = picl_get_propval(sensorh, &val.buf, sensor_info.size);
if ( error_code != PICL_SUCCESS ) {
DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n",
error_code));
return( error_code );
}
/*
* Check the validity (type and size) of this value
*/
if ( sensor_info.type == PICL_PTYPE_FLOAT ) {
*value = val.f;
} else if ( sensor_info.type == PICL_PTYPE_UNSIGNED_INT ) {
/* 16-bit or 32-bit unsigned integers */
if ( sensor_info.size == 2 ) {
*value = val.us2;
} else if ( sensor_info.size == 4 ) {
*value = val.us4;
} else {
DEBUGMSGTL(("sensors:arch:detail", "unsigned integer (%d bit)\n",
sensor_info.size * 8));
return PICL_FAILURE;
}
} else if ( sensor_info.type == PICL_PTYPE_INT ) {
/* 16-bit or 32-bit signed integers */
if ( sensor_info.size == 2 ) {
*value = val.is2;
} else if ( sensor_info.size == 4 ) {
*value = val.is4;
} else {
DEBUGMSGTL(("sensors:arch:detail", "signed integer (%d bit)\n",
sensor_info.size * 8));
return PICL_FAILURE;
}
} else {
DEBUGMSGTL(("sensors:arch:detail", "unrecognised type (%d)\n",
sensor_info.type));
return PICL_FAILURE;
}
return error_code;
}
int
prt_mem_bank_size(picl_nodehdl_t nodeh, void *args)
{
int ret;
void *data;
u_longlong_t value;
unsigned long size;
picl_prophdl_t proph;
picl_propinfo_t pinfo;
char c;
ret = picl_get_propinfo_by_name(nodeh, mem_prop[1],
&pinfo, &proph);
if (ret) {
return (PICL_WALK_CONTINUE);
}
if (!(pinfo.accessmode & PICL_READ)) {
return (PICL_WALK_CONTINUE);
}
if (pinfo.size == 0) {
return (PICL_WALK_CONTINUE);
}
data = malloc(pinfo.size);
if (data == NULL) {
return (PICL_WALK_CONTINUE);
}
ret = picl_get_propval(proph, data, pinfo.size);
if (ret) {
(void) free(data);
return (PICL_WALK_CONTINUE);
}
if ((pinfo.type == PICL_PTYPE_INT) ||
(pinfo.type == PICL_PTYPE_UNSIGNED_INT)) {
switch (pinfo.size) {
case sizeof (char):
value = *(unsigned char *)data;
break;
case sizeof (short):
value = *(unsigned short *)data;
break;
case sizeof (int):
value = *(unsigned int *)data;
break;
case sizeof (long long):
value = *(unsigned long long *)data;
break;
default:
break;
}
}
if (value == 0) {
(void) free(data);
return (PICL_WALK_CONTINUE);
}
if (*(int *)args == 0) {
PRINTF("(");
} else {
PRINTF(" + ");
}
value = value >> 10;
if (value >= 1024) {
value = value >> 10;
if (value >= 1024) {
size = (unsigned long) (value & 0x3ff);
value = value >> 10;
c = 'G';
} else {
static int
read_num_sensor(picl_nodehdl_t childh, const char *prop, int scale, int *value)
{
picl_nodehdl_t sensorh;
picl_propinfo_t sensor_info;
picl_errno_t error_code;
int valid = 1;
union valu {
char buf[PICL_PROPSIZE_MAX];
uint32_t us4;
uint16_t us2;
int32_t is4;
int16_t is2;
float f;
} val;
error_code = (picl_get_propinfo_by_name(childh, prop,
&sensor_info, &sensorh));
if (error_code != PICL_SUCCESS) {
DEBUGMSGTL(("ucd-snmp/lmSensors",
"sensor info lookup failed in read_num_sensor - error code->%d\n", error_code));
return(error_code);
}
error_code = picl_get_propval(sensorh, &val.buf, sensor_info.size);
if (error_code != PICL_SUCCESS) {
DEBUGMSGTL(("ucd-snmp/lmSensors",
"sensor value lookup failed in read_num_sensor - error code->%d\n", error_code));
return(error_code);
}
/* Can't make assumptions about the type or size of the value we get... */
if (sensor_info.type == PICL_PTYPE_FLOAT) {
*value = (int)(val.f*scale);
} else if (sensor_info.type == PICL_PTYPE_UNSIGNED_INT) {
if (sensor_info.size == 2) {
*value = (int)(val.us2 * scale);
} else if (sensor_info.size == 4) {
*value = (int)(val.us4 * scale);
} else
valid = 0;
} else if (sensor_info.type == PICL_PTYPE_INT) {
if (sensor_info.size == 2) {
*value = (int)(val.is2 * scale);
} else if (sensor_info.size == 4) {
*value = (int)(val.is4 * scale);
} else
valid = 0;
} else
valid = 0;
if (valid == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors",
"Don't know how to handle data type %d with length %d\n",
sensor_info.type, sensor_info.size));
error_code = PICL_FAILURE;
} else
DEBUGMSGTL(("ucd-snmp/lmSensors", "read_num_sensor value is %d\n", *value));
return(error_code);
} /* end of read_num_sensor() */
