#include #include #include #include #include "hw_sensors_private.h" #include #include void netsnmp_sensor_arch_init( void ) { DEBUGMSGTL(("sensors:arch", "Initialise PICLd Sensors module\n")); picl_initialize(); } /* * 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; } static int process_num_sensor( picl_nodehdl_t childh, const char *propname, const char *propval, int typ ) { netsnmp_sensor_info *sp; float value; picl_errno_t error_code; sp = sensor_by_name( propname, typ ); if ( !sp ) { return -1; } error_code = read_num_sensor( childh, propval, &value ); if ( error_code == PICL_SUCCESS ) { sp->value = value; sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; } else { DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", propname, error_code)); return -1; } return 0; } /* * Handle an enumeration-valued sensor */ const char *switch_settings[] = { "OFF","ON","NORMAL","LOCKED", "UNKNOWN","DIAG","SECURE", NULL }; const char *led_settings[] = { "OFF","ON","BLINK", NULL }; const char *i2c_settings[] = { "OK", NULL }; 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 process_enum_sensor( picl_nodehdl_t childh, const char *propname, int typ, const char **options ) { netsnmp_sensor_info *sp; float value; picl_errno_t error_code; sp = sensor_by_name( propname, typ ); if ( !sp ) { return -1; } error_code = read_enum_sensor( childh, &value, options ); if ( error_code == PICL_SUCCESS ) { sp->value = value; sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; } else { DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", propname, error_code)); return -1; } return 0; } /* * Recursively walk through the tree of sensors */ static int process_sensors( int level, picl_nodehdl_t nodeh ) { picl_nodehdl_t childh, nexth; char propname[ PICL_PROPNAMELEN_MAX ]; char propclass[ PICL_CLASSNAMELEN_MAX ]; picl_errno_t error_code; level++; DEBUGMSGTL(("sensors:arch:detail", "process_sensors - level %d\n", level)); /* Look up the first child node at this level */ error_code = picl_get_propval_by_name( nodeh, PICL_PROP_CHILD, &childh, sizeof(childh)); if ( error_code != PICL_SUCCESS ) { DEBUGMSGTL(("sensors:arch:detail", "Failed to get first child node (%d)\n", error_code)); return( error_code ); } /* Step through the child nodes, retrieving the name and class of each one */ while ( error_code == PICL_SUCCESS ) { error_code = picl_get_propval_by_name( childh, PICL_PROP_NAME, propname, sizeof(propname)-1); if ( error_code != PICL_SUCCESS ) { /* The Node With No Name */ DEBUGMSGTL(("sensors:arch:detail", "get property name failed (%d)\n", error_code)); return( error_code ); } error_code = picl_get_propval_by_name( childh, PICL_PROP_CLASSNAME, propclass, sizeof(propclass)-1); if ( error_code != PICL_SUCCESS ) { /* The Classless Society */ DEBUGMSGTL(("sensors:arch:detail", "get property class failed (%d)\n", error_code)); return( error_code ); } DEBUGMSGTL(("sensors:arch:detail", "Name: %s, Class %s\n", propname, propclass )); /* * Three classes represent further groups of sensors, etc. * Call 'process_sensors' recursively to handle this next level */ if (( strstr( propclass, "picl" )) || ( strstr( propclass, "frutree" )) || ( strstr( propclass, "obp" ))) { process_sensors( level, childh ); } /* * Otherwise retrieve the value appropriately based on the * class of the sensor. * * We need to specify the name of the PICL property to retrieve * for this class of sensor, and the Net-SNMP sensor type. */ else if ( strstr( propclass, "fan-tachometer" )) { process_num_sensor( childh, propname, "AtoDSensorValue", NETSNMP_SENSOR_TYPE_RPM ); } else if ( strstr( propclass, "fan" )) { process_num_sensor( childh, propname, "Speed", NETSNMP_SENSOR_TYPE_RPM ); } else if ( strstr( propclass, "temperature-sensor" )) { process_num_sensor( childh, propname, "Temperature", NETSNMP_SENSOR_TYPE_TEMPERATURE ); } else if ( strstr( propclass, "voltage-sensor" )) { process_num_sensor( childh, propname, "Voltage", /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); } else if ( strstr( propclass, "digital-sensor" )) { process_num_sensor( childh, propname, "AtoDSensorValue", /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); /* * Enumeration-valued sensors use a fixed PICL property ("State"), * but take a list of the values appropriate for that sensor, * as well as the Net-SNMP sensor type. */ } else if ( strstr( propclass, "switch" )) { process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, switch_settings ); } else if ( strstr( propclass, "led" )) { process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, led_settings ); } else if ( strstr( propclass, "i2c" )) { process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_BOOLEAN, /* ?? */ i2c_settings ); } else { /* Skip other classes of sensor */ DEBUGMSGTL(("sensors:arch:detail", "Skipping class %s\n", propclass )); } /* * Move on to the next child node at the current level (if any) */ error_code = picl_get_propval_by_name( childh, PICL_PROP_PEER, &nexth, sizeof(nexth)); if ( error_code != PICL_SUCCESS ) { /* That's All Folks! */ return (( error_code == PICL_PROPNOTFOUND ) ? PICL_SUCCESS : error_code ); } childh = nexth; } return error_code; } int netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { int error_code; picl_nodehdl_t rooth; DEBUGMSGTL(("sensors:arch", "Reload PICLd Sensors module\n")); error_code = picl_get_root(&rooth); if ( error_code != PICL_SUCCESS) { DEBUGMSGTL(("sensors:arch", "Couldn't get root node (error %d)\n", error_code)); return 1; } error_code = process_sensors(0, rooth); if ( error_code != 255 ) if ( error_code != 7 ) /* ignore PICL_PROPNOTFOUND error */ DEBUGMSGTL(("sensors:arch", "Internal PICLd problem (error %d)\n", error_code)); return 0; } void netsnmp_sensor_arch_shutdown( void ) { DEBUGMSGTL(("sensors:arch", "Shutdown PicLD Sensors module\n")); picl_shutdown(); }