sahpi_enum_utils.c

HIP 硬件设备管理标准接口

	
	found = 0;
	for (i=0; i<OH_MAX_ENTITYTYPE; i++) {
		if (strcasecmp(buffer->Data, entitytype_strings[i].str) == 0) {
			found++;
			break;
		}
	}

	if (found) {
		*type = entitytype_strings[i].entity_type;
	}
	else {
		return(SA_ERR_HPI_INVALID_DATA);
	}
	
	return(SA_OK);
}

/**
 * oh_lookup_sensortype:
 * @value: enum value of type SaHpiSensorTypeT.
 *
 * Converts @value into a string based on @value's HPI enum definition.
 * 
 * Returns:
 * string - normal operation.
 * NULL - if @value not a valid SaHpiSensorTypeT.
 **/
const char * oh_lookup_sensortype(SaHpiSensorTypeT value)
{
        switch (value) {
        case SAHPI_TEMPERATURE:
                return "TEMPERATURE";
        case SAHPI_VOLTAGE:
                return "VOLTAGE";
        case SAHPI_CURRENT:
                return "CURRENT";
        case SAHPI_FAN:
                return "FAN";
        case SAHPI_PHYSICAL_SECURITY:
                return "PHYSICAL_SECURITY";
        case SAHPI_PLATFORM_VIOLATION:
                return "PLATFORM_VIOLATION";
        case SAHPI_PROCESSOR:
                return "PROCESSOR";
        case SAHPI_POWER_SUPPLY:
                return "POWER_SUPPLY";
        case SAHPI_POWER_UNIT:
                return "POWER_UNIT";
        case SAHPI_COOLING_DEVICE:
                return "COOLING_DEVICE";
        case SAHPI_OTHER_UNITS_BASED_SENSOR:
                return "OTHER_UNITS_BASED_SENSOR";
        case SAHPI_MEMORY:
                return "MEMORY";
        case SAHPI_DRIVE_SLOT:
                return "DRIVE_SLOT";
        case SAHPI_POST_MEMORY_RESIZE:
                return "POST_MEMORY_RESIZE";
        case SAHPI_SYSTEM_FW_PROGRESS:
                return "SYSTEM_FW_PROGRESS";
        case SAHPI_EVENT_LOGGING_DISABLED:
                return "EVENT_LOGGING_DISABLED";
        case SAHPI_RESERVED1:
                return "RESERVED1";
        case SAHPI_SYSTEM_EVENT:
                return "SYSTEM_EVENT";
        case SAHPI_CRITICAL_INTERRUPT:
                return "CRITICAL_INTERRUPT";
        case SAHPI_BUTTON:
                return "BUTTON";
        case SAHPI_MODULE_BOARD:
                return "MODULE_BOARD";
        case SAHPI_MICROCONTROLLER_COPROCESSOR:
                return "MICROCONTROLLER_COPROCESSOR";
        case SAHPI_ADDIN_CARD:
                return "ADDIN_CARD";
        case SAHPI_CHASSIS:
                return "CHASSIS";
        case SAHPI_CHIP_SET:
                return "CHIP_SET";
        case SAHPI_OTHER_FRU:
                return "OTHER_FRU";
        case SAHPI_CABLE_INTERCONNECT:
                return "CABLE_INTERCONNECT";
        case SAHPI_TERMINATOR:
                return "TERMINATOR";
        case SAHPI_SYSTEM_BOOT_INITIATED:
                return "SYSTEM_BOOT_INITIATED";
        case SAHPI_BOOT_ERROR:
                return "BOOT_ERROR";
        case SAHPI_OS_BOOT:
                return "OS_BOOT";
        case SAHPI_OS_CRITICAL_STOP:
                return "OS_CRITICAL_STOP";
        case SAHPI_SLOT_CONNECTOR:
                return "SLOT_CONNECTOR";
        case SAHPI_SYSTEM_ACPI_POWER_STATE:
                return "SYSTEM_ACPI_POWER_STATE";
        case SAHPI_RESERVED2:
                return "RESERVED2";
        case SAHPI_PLATFORM_ALERT:
                return "PLATFORM_ALERT";
        case SAHPI_ENTITY_PRESENCE:
                return "ENTITY_PRESENCE";
        case SAHPI_MONITOR_ASIC_IC:
                return "MONITOR_ASIC_IC";
        case SAHPI_LAN:
                return "LAN";
        case SAHPI_MANAGEMENT_SUBSYSTEM_HEALTH:
                return "MANAGEMENT_SUBSYSTEM_HEALTH";
        case SAHPI_BATTERY:
                return "BATTERY";
        case SAHPI_OPERATIONAL:
                return "OPERATIONAL";
        case SAHPI_OEM_SENSOR:
                return "OEM_SENSOR";
        default:
                return NULL;
        }
}

struct oh_sensortype_map sensortype_strings[] = {
       {SAHPI_TEMPERATURE, "TEMPERATURE"},
       {SAHPI_VOLTAGE, "VOLTAGE"},
       {SAHPI_CURRENT, "CURRENT"},
       {SAHPI_FAN, "FAN"},
       {SAHPI_PHYSICAL_SECURITY, "PHYSICAL_SECURITY"},
       {SAHPI_PLATFORM_VIOLATION, "PLATFORM_VIOLATION"},
       {SAHPI_PROCESSOR, "PROCESSOR"},
       {SAHPI_POWER_SUPPLY, "POWER_SUPPLY"},
       {SAHPI_POWER_UNIT, "POWER_UNIT"},
       {SAHPI_COOLING_DEVICE, "COOLING_DEVICE"},
       {SAHPI_OTHER_UNITS_BASED_SENSOR, "OTHER_UNITS_BASED_SENSOR"},
       {SAHPI_MEMORY, "MEMORY"},
       {SAHPI_DRIVE_SLOT, "DRIVE_SLOT"},
       {SAHPI_POST_MEMORY_RESIZE, "POST_MEMORY_RESIZE"},
       {SAHPI_SYSTEM_FW_PROGRESS, "SYSTEM_FW_PROGRESS"},
       {SAHPI_EVENT_LOGGING_DISABLED, "EVENT_LOGGING_DISABLED"},
       {SAHPI_RESERVED1, "RESERVED1"},
       {SAHPI_SYSTEM_EVENT, "SYSTEM_EVENT"},
       {SAHPI_CRITICAL_INTERRUPT, "CRITICAL_INTERRUPT"},
       {SAHPI_BUTTON, "BUTTON"},
       {SAHPI_MODULE_BOARD, "MODULE_BOARD"},
       {SAHPI_MICROCONTROLLER_COPROCESSOR, "MICROCONTROLLER_COPROCESSOR"},
       {SAHPI_ADDIN_CARD, "ADDIN_CARD"},
       {SAHPI_CHASSIS, "CHASSIS"},
       {SAHPI_CHIP_SET, "CHIP_SET"},
       {SAHPI_OTHER_FRU, "OTHER_FRU"},
       {SAHPI_CABLE_INTERCONNECT, "CABLE_INTERCONNECT"},
       {SAHPI_TERMINATOR, "TERMINATOR"},
       {SAHPI_SYSTEM_BOOT_INITIATED, "SYSTEM_BOOT_INITIATED"},
       {SAHPI_BOOT_ERROR, "BOOT_ERROR"},
       {SAHPI_OS_BOOT, "OS_BOOT"},
       {SAHPI_OS_CRITICAL_STOP, "OS_CRITICAL_STOP"},
       {SAHPI_SLOT_CONNECTOR, "SLOT_CONNECTOR"},
       {SAHPI_SYSTEM_ACPI_POWER_STATE, "SYSTEM_ACPI_POWER_STATE"},
       {SAHPI_RESERVED2, "RESERVED2"},
       {SAHPI_PLATFORM_ALERT, "PLATFORM_ALERT"},
       {SAHPI_ENTITY_PRESENCE, "ENTITY_PRESENCE"},
       {SAHPI_MONITOR_ASIC_IC, "MONITOR_ASIC_IC"},
       {SAHPI_LAN, "LAN"},
       {SAHPI_MANAGEMENT_SUBSYSTEM_HEALTH, "MANAGEMENT_SUBSYSTEM_HEALTH"},
       {SAHPI_BATTERY, "BATTERY"},
       {SAHPI_OPERATIONAL, "OPERATIONAL"},
       {SAHPI_OEM_SENSOR, "OEM_SENSOR"},
};

/**
 * oh_encode_sensortype:
 * @buffer: Pointer to SaHpiTextBufferT that contains enum's string representation.
 * @type: Location (of SaHpiSensorTypeT) to place encoded result.
 * 
 * Converts a @buffer->Data string, generated by oh_lookup_sensortype(), back 
 * into an SaHpiSensorTypeT type. 
 *
 * Returns:
 * SaHpiSensorTypeT value - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - if @buffer or @type is NULL or @buffer->Data empty.
 * SA_ERR_HPI_INVALID_DATA - if @buffer->Data is invalid.
 **/
SaErrorT oh_encode_sensortype(SaHpiTextBufferT *buffer, SaHpiSensorTypeT *type)
{
	int i, found;

	if (!buffer || !type || buffer->Data == NULL || buffer->Data[0] == '\0') {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	found = 0;
	for (i=0; i<OH_MAX_SENSORTYPE; i++) {
		if (strcasecmp(buffer->Data, sensortype_strings[i].str) == 0) {
			found++;
			break;
		}
	}

	if (found) {
		*type = sensortype_strings[i].entity_type;
	}
	else {
		return(SA_ERR_HPI_INVALID_DATA);
	}
	
	return(SA_OK);
}

/**
 * oh_lookup_sensorreadingtype:
 * @value: enum value of type SaHpiSensorReadingTypeT.
 *
 * Converts @value into a string based on @value's HPI enum definition.
 * 
 * Returns:
 * string - normal operation.
 * NULL - if @value not a valid SaHpiSensorReadingTypeT.
 **/
const char * oh_lookup_sensorreadingtype(SaHpiSensorReadingTypeT value)
{
        switch (value) {
        case SAHPI_SENSOR_READING_TYPE_INT64:
                return "INT64";
        case SAHPI_SENSOR_READING_TYPE_UINT64:
                return "UINT64";
        case SAHPI_SENSOR_READING_TYPE_FLOAT64:
                return "FLOAT64";
        case SAHPI_SENSOR_READING_TYPE_BUFFER:
                return "BUFFER";
        default:
                return NULL;
        }
}

struct oh_sensorreadingtype_map sensorreadingtype_strings[] = {
       {SAHPI_SENSOR_READING_TYPE_INT64, "INT64"},
       {SAHPI_SENSOR_READING_TYPE_UINT64, "UINT64"},
       {SAHPI_SENSOR_READING_TYPE_FLOAT64, "FLOAT64"},
       {SAHPI_SENSOR_READING_TYPE_BUFFER, "BUFFER"},
};

/**
 * oh_encode_sensorreadingtype:
 * @buffer: Pointer to SaHpiTextBufferT that contains enum's string representation.
 * @type: Location (of SaHpiSensorReadingTypeT) to place encoded result.
 * 
 * Converts a @buffer->Data string, generated by oh_lookup_sensorreadingtype(), back 
 * into an SaHpiSensorReadingTypeT type. 
 *
 * Returns:
 * SaHpiSensorReadingTypeT value - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - if @buffer or @type is NULL or @buffer->Data empty.
 * SA_ERR_HPI_INVALID_DATA - if @buffer->Data is invalid.
 **/
SaErrorT oh_encode_sensorreadingtype(SaHpiTextBufferT *buffer, SaHpiSensorReadingTypeT *type)
{
	int i, found;

	if (!buffer || !type || buffer->Data == NULL || buffer->Data[0] == '\0') {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	found = 0;
	for (i=0; i<OH_MAX_SENSORREADINGTYPE; i++) {
		if (strcasecmp(buffer->Data, sensorreadingtype_strings[i].str) == 0) {
			found++;
			break;
		}
	}

	if (found) {
		*type = sensorreadingtype_strings[i].entity_type;
	}
	else {
		return(SA_ERR_HPI_INVALID_DATA);
	}
	
	return(SA_OK);
}

/**
 * oh_lookup_sensoreventmaskaction:
 * @value: enum value of type SaHpiSensorEventMaskActionT.
 *
 * Converts @value into a string based on @value's HPI enum definition.
 * 
 * Returns:
 * string - normal operation.
 * NULL - if @value not a valid SaHpiSensorEventMaskActionT.
 **/
const char * oh_lookup_sensoreventmaskaction(SaHpiSensorEventMaskActionT value)
{
        switch (value) {
        case SAHPI_SENS_ADD_EVENTS_TO_MASKS:
                return "ADD_EVENTS_TO_MASKS";
        case SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS:
                return "REMOVE_EVENTS_FROM_MASKS";
        default:
                return NULL;
        }
}

struct oh_sensoreventmaskaction_map sensoreventmaskaction_strings[] = {
       {SAHPI_SENS_ADD_EVENTS_TO_MASKS, "ADD_EVENTS_TO_MASKS"},
       {SAHPI_SENS_REMOVE_EVENTS_FROM_MASKS, "REMOVE_EVENTS_FROM_MASKS"},
};

/**
 * oh_encode_sensoreventmaskaction:
 * @buffer: Pointer to SaHpiTextBufferT that contains enum's string representation.
 * @type: Location (of SaHpiSensorEventMaskActionT) to place encoded result.
 * 
 * Converts a @buffer->Data string, generated by oh_lookup_sensoreventmaskaction(), back 
 * into an SaHpiSensorEventMaskActionT type. 
 *
 * Returns:
 * SaHpiSensorEventMaskActionT value - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - if @buffer or @type is NULL or @buffer->Data empty.
 * SA_ERR_HPI_INVALID_DATA - if @buffer->Data is invalid.
 **/
SaErrorT oh_encode_sensoreventmaskaction(SaHpiTextBufferT *buffer, SaHpiSensorEventMaskActionT *type)
{
	int i, found;

	if (!buffer || !type || buffer->Data == NULL || buffer->Data[0] == '\0') {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}
	
	found = 0;
	for (i=0; i<OH_MAX_SENSOREVENTMASKACTION; i++) {
		if (strcasecmp(buffer->Data, sensoreventmaskaction_strings[i].str) == 0) {
			found++;
			break;
		}
	}

	if (found) {
		*type = sensoreventmaskaction_strings[i].entity_type;
	}
	else {
		return(SA_ERR_HPI_INVALID_DATA);
	}
	
	return(SA_OK);
}

/**
 * oh_lookup_sensorunits:
 * @value: enum value of type SaHpiSensorUnitsT.
 *
 * Converts @value into a string based on @value's HPI enum definition.
 * 
 * Returns:
 * string - normal operation.
 * NULL - if @value not a valid SaHpiSensorUnitsT.
 **/
const char * oh_lookup_sensorunits(SaHpiSensorUnitsT value)
{
        switch (value) {
        case SAHPI_SU_UNSPECIFIED:
                return "Unspecified";
        case SAHPI_SU_DEGREES_C:
                return "Degrees C";
        case SAHPI_SU_DEGREES_F:
                return "Degrees F";
        case SAHPI_SU_DEGREES_K:
                return "Degrees K";
        case SAHPI_SU_VOLTS:
                return "Volts";
        case SAHPI_SU_AMPS:
                return "Amps";
        case SAHPI_SU_WATTS:
                return "Watts";
        case SAHPI_SU_JOULES:
                return "Joules";
        case SAHPI_SU_COULOMBS:
                return "Coulombs";
        case SAHPI_SU_VA:
                return "Va";
        case SAHPI_SU_NITS:
                return "Nits";
        case SAHPI_SU_LUMEN:
                return "Lumen";
        case SAHPI_SU_LUX:
                return "Lux";
        case SAHPI_SU_CANDELA:
                return "Candela";
        case SAHPI_SU_KPA:
                return "Kpa";
        case SAHPI_SU_PSI:
                return "Psi";
        case SAHPI_SU_NEWTON:
                return "Newton";
        case SAHPI_SU_CFM:
                return "Cfm";
        case SAHPI_SU_RPM:
                return "Rpm";
        case SAHPI_SU_HZ:
                return "Hz";
        case SAHPI_SU_MICROSECOND:
                return "Microsecond";
        case SAHPI_SU_MILLISECOND:
                return "Millisecond";
        case SAHPI_SU_SECOND:
                return "Second";
        case SAHPI_SU_MINUTE:
                return "Minute";