/* * 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 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); } }
/***************************************************************************** Gets called by probe_cpu. Cycles through the table values until we find what we are looking for. *****************************************************************************/ static void search_table(int index, picl_prophdl_t table_hdl) { picl_prophdl_t col_hdl; picl_prophdl_t row_hdl; picl_propinfo_t p_info; int val; char string_val[PICL_PROPNAMELEN_MAX]; for (val = picl_get_next_by_col(table_hdl, &row_hdl); val != PICL_ENDOFLIST; val = picl_get_next_by_col(row_hdl, &row_hdl)) { if (val == PICL_SUCCESS) { for (col_hdl = row_hdl; val != PICL_ENDOFLIST; val = picl_get_next_by_row(col_hdl, &col_hdl)) { if (val == PICL_SUCCESS) { val = picl_get_propinfo(col_hdl, &p_info); if (val == PICL_SUCCESS) { if (p_info.type == PICL_PTYPE_CHARSTRING) { val = picl_get_propval(col_hdl, &string_val, sizeof(string_val)); if (val == PICL_SUCCESS) { assign_string_value(index, string_val); } } } } } } } }
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)); } }
static int change_locator_state(picl_nodehdl_t locator_node, locator_info_t *locator_info) { picl_prophdl_t state_prop; char state[PICL_PROPNAMELEN_MAX]; int err; char *new_state; err = picl_get_prop_by_name(locator_node, "State", &state_prop); if (err != PICL_SUCCESS) { (void) fprintf(stderr, gettext("picl_get_prop_by_name failed: %s\n"), picl_strerror(err)); return (err); } err = picl_get_propval(state_prop, state, sizeof (state)); if (err != PICL_SUCCESS) { (void) fprintf(stderr, gettext("picl_get_propval failed: %s\n"), picl_strerror(err)); return (err); } new_state = (locator_info->new_state) ? locator_info->on : locator_info->off; if (strcmp(state, new_state) != 0) { picl_propinfo_t prop_info; err = picl_get_propinfo(state_prop, &prop_info); if (err != PICL_SUCCESS) { (void) fprintf(stderr, gettext("picl_get_propinfo failed: %s\n"), picl_strerror(err)); return (err); } err = picl_set_propval(state_prop, new_state, prop_info.size); if (err != PICL_SUCCESS) { (void) fprintf(stderr, gettext("picl_set_propval failed: %s\n"), picl_strerror(err)); return (err); } } return (err); }
int32_t fill_device_from_id(picl_nodehdl_t device_id, char *assoc_id, picl_nodehdl_t *device) { int32_t err; picl_prophdl_t tbl_hdl; picl_prophdl_t reference_property; err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl, sizeof (picl_prophdl_t)); if (err != PICL_SUCCESS) { #ifdef WORKFILE_DEBUG if (err != PICL_INVALIDHANDLE) { log_printf(dgettext(TEXT_DOMAIN, "fill_device_from_id failure in " "picl_get_propval_by_name err is %s\n"), picl_strerror(err)); } #endif return (err); } err = picl_get_next_by_row(tbl_hdl, &reference_property); if (err != PICL_SUCCESS) { #ifdef WORKFILE_DEBUG log_printf(dgettext(TEXT_DOMAIN, "fill_device_from_id failure in picl_get_next_by_row" " err is %s\n"), picl_strerror(err)); #endif return (err); } /* get node associated with reference property */ err = picl_get_propval(reference_property, &(*device), sizeof (picl_nodehdl_t)); #ifdef WORKFILE_DEBUG if (err != 0) { log_printf(dgettext(TEXT_DOMAIN, "fill_device_from_id failure in picl_get_propval" " err is %s\n"), picl_strerror(err)); } #endif return (err); }
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); }
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 {
void prt_prop_val(picl_prophdl_t proph, picl_propinfo_t *pinfo) { int ret; void *data; char *str; if (!(pinfo->accessmode & PICL_READ)) { return; } if (pinfo->size == 0) { return; } data = malloc(pinfo->size); if (data == NULL) { return; } ret = picl_get_propval(proph, data, pinfo->size); if (ret) { (void) free(data); return; } switch (pinfo->type) { case PICL_PTYPE_CHARSTRING: PRINTF("%s", (char *)data); break; case PICL_PTYPE_INT: switch (pinfo->size) { case sizeof (char): PRINTF("%d", *(char *)data / granu); break; case sizeof (short): PRINTF("%hd", *(short *)data / granu); break; case sizeof (int): PRINTF("%d", *(int *)data / granu); break; case sizeof (long long): PRINTF("%lld", *(long long *)data / granu); break; default: PRINTF("err"); } break; case PICL_PTYPE_UNSIGNED_INT: switch (pinfo->size) { case sizeof (unsigned char): PRINTF("%x", *(unsigned char *)data / granu); break; case sizeof (unsigned short): PRINTF("%hx", *(unsigned short *)data / granu); break; case sizeof (unsigned int): PRINTF("%u", *(unsigned int *)data / granu); break; case sizeof (unsigned long long): PRINTF("%llu", *(unsigned long long *)data / granu); break; default: PRINTF("err"); } break; case PICL_PTYPE_FLOAT: switch (pinfo->size) { case sizeof (float): PRINTF("%f", *(float *)data); break; case sizeof (double): PRINTF("%f", *(double *)data); break; default: PRINTF("err"); } break; case PICL_PTYPE_TIMESTAMP: str = ctime((time_t *)data); if (str) { str[strlen(str) - 1] = '\0'; PRINTF("%s", str); } break; case PICL_PTYPE_TABLE: PRINTF("TBL"); break; case PICL_PTYPE_REFERENCE: PRINTF("REF"); break; case PICL_PTYPE_BYTEARRAY: PRINTF("BIN"); break; default: PRINTF("unknown"); } (void) free(data); }
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() */
int32_t fill_device_array_from_id(picl_nodehdl_t device_id, char *assoc_id, int32_t *number_of_devices, picl_nodehdl_t *device_array[]) { int32_t err; int i; picl_prophdl_t tbl_hdl; picl_prophdl_t entry; int devs = 0; err = picl_get_propval_by_name(device_id, assoc_id, &tbl_hdl, sizeof (picl_prophdl_t)); if ((err != PICL_SUCCESS) && (err != PICL_INVALIDHANDLE)) { #ifdef WORKFILE_DEBUG log_printf(dgettext(TEXT_DOMAIN, "fill_device_array_from_id failure in " "picl_get_propval_by_name err is %s\n"), picl_strerror(err)); #endif return (err); } entry = tbl_hdl; while (picl_get_next_by_row(entry, &entry) == 0) ++devs; *device_array = calloc((devs), sizeof (picl_nodehdl_t)); if (*device_array == NULL) { #ifdef WORFILE_DEBUG log_printf(dgettext(TEXT_DOMAIN, "fill_device_array_from_id failure getting memory" " for array\n")); #endif return (PICL_FAILURE); } entry = tbl_hdl; for (i = 0; i < devs; i++) { err = picl_get_next_by_row(entry, &entry); if (err != 0) { #ifdef WORKFILE_DEBUG log_printf(dgettext(TEXT_DOMAIN, "fill_device_array_from_id failure in " "picl_get_next_by_row err is %s\n"), picl_strerror(err)); #endif return (err); } /* get node associated with reference property */ err = picl_get_propval(entry, &((*device_array)[i]), sizeof (picl_nodehdl_t)); if (err != 0) { #ifdef WORKFILE_DEBUG log_printf(dgettext(TEXT_DOMAIN, "fill_device_array_from_id failure in " "picl_get_propval err is %s\n"), picl_strerror(err)); #endif return (err); } } *number_of_devices = devs; return (err); }
/* * 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; }
/***************************************************************************** Gets called by picl_walk_tree_by_class. Then it cycles through the properties until we find what we are looking for. Once we are done, we return PICL_WALK_TERMINATE to stop picl_walk_tree_by_class from traversing the tree. Note that PICL_PTYPE_UNSIGNED_INT and PICL_PTYPE_INT can either be 4-bytes or 8-bytes. *****************************************************************************/ static int probe_cpu(picl_nodehdl_t node_hdl, void* dummy_arg) { picl_prophdl_t p_hdl; picl_prophdl_t table_hdl; picl_propinfo_t p_info; long long long_long_val; unsigned int uint_val; int index; int int_val; int val; char string_val[PICL_PROPNAMELEN_MAX]; val = picl_get_first_prop(node_hdl, &p_hdl); while (val == PICL_SUCCESS) { called_cpu_probe = 1; val = picl_get_propinfo(p_hdl, &p_info); if (val == PICL_SUCCESS) { for (index = 0; index < NUM_ITEMS; index++) { if (strcasecmp(p_info.name, items[index]) == 0) { if (p_info.type == PICL_PTYPE_UNSIGNED_INT) { if (p_info.size == sizeof(uint_val)) { val = picl_get_propval(p_hdl, &uint_val, sizeof(uint_val)); if (val == PICL_SUCCESS) { long_long_val = uint_val; assign_value(index, long_long_val); } } else if (p_info.size == sizeof(long_long_val)) { val = picl_get_propval(p_hdl, &long_long_val, sizeof(long_long_val)); if (val == PICL_SUCCESS) { assign_value(index, long_long_val); } } } else if (p_info.type == PICL_PTYPE_INT) { if (p_info.size == sizeof(int_val)) { val = picl_get_propval(p_hdl, &int_val, sizeof(int_val)); if (val == PICL_SUCCESS) { long_long_val = int_val; assign_value(index, long_long_val); } } else if (p_info.size == sizeof(long_long_val)) { val = picl_get_propval(p_hdl, &long_long_val, sizeof(long_long_val)); if (val == PICL_SUCCESS) { assign_value(index, long_long_val); } } } else if (p_info.type == PICL_PTYPE_CHARSTRING) { val = picl_get_propval(p_hdl, &string_val, sizeof(string_val)); if (val == PICL_SUCCESS) { assign_string_value(index, string_val); } } else if (p_info.type == PICL_PTYPE_TABLE) { val = picl_get_propval(p_hdl, &table_hdl, p_info.size); if (val == PICL_SUCCESS) { search_table(index, table_hdl); } } break; } else if (index == NUM_ITEMS-1) { if (p_info.type == PICL_PTYPE_CHARSTRING) { val = picl_get_propval(p_hdl, &string_val, sizeof(string_val)); if (val == PICL_SUCCESS) { } } } } } val = picl_get_next_prop(p_hdl, &p_hdl); } return PICL_WALK_TERMINATE; }