%%%============================================================================= %%% Copyright (c) 2012 Lindenbaum GmbH %%% %%% Permission to use, copy, modify, and/or distribute this software for any %%% purpose with or without fee is hereby granted, provided that the above %%% copyright notice and this permission notice appear in all copies. %%% %%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES %%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF %%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR %%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES %%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN %%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF %%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. %%% %%% @doc %%% Sensor-related functions, e.g. mapping of reading/event type codes/offsets, %%% sensor name retrieval, etc. %%% @end %%%============================================================================= -module(eipmi_sensor). -export([ get_addr/1, get_type/2, get_value/6, get_entity/2, get_entity_id/1, get_unit/1, to_list/1 ]). -include("eipmi.hrl"). -type addr() :: {fru_id, non_neg_integer()} | {fru_lun, non_neg_integer()} | {sensor_addr, non_neg_integer()} | {sensor_lun, non_neg_integer()} | {bus_id, non_neg_integer()} | {channel, non_neg_integer()} | {software_id, non_neg_integer()}. -type entity_id() :: unspecified | other | unknown | processor | disk_or_disk_bay | peripheral_bay | system_management_module | system_board | memory_module | processor_module | power_supply | add_in_card | front_panel_board | back_panel_board | power_system_board | drive_backplane | system_internal_expansion_board | other_system_board | processor_board | power_unit | power_module | power_management | chassis_back_panel_board | system_chassis | sub_chassis | other_chassis_board | disk_drive_bay | peripheral_bay | device_bay | cooling_device | cooling_unit | interconnect | memory_device | system_management_software | system_firmware | operating_system | system_bus | group | remote_management_communication_device | external_environment | battery | processing_blade | connectivity_switch | processor_memory_module | io_module | processor_io_module | management_controller_firmware | ipmi_channel | pci_bus | pci_expresstm_bus | scsi_bus | sata_bus | front_side_bus | real_time_clock | air_inlet | air_inlet | processor | main_system_board | front_board | amc | mch | shelf_management_controller | filtration_unit | shelf_fru_information | alarm_panel | non_neg_integer(). -type entity() :: {entity_id, entity_id()} | {entity_type, logical | physical} | {entity_instance, non_neg_integer()}. -type reading() :: threshold | dmi_usage | state | predictive_failure | limit | performance | severity | availability0 | availability1 | availability2 | redundancy | acpi_power_state | specific | non_neg_integer(). -type type() :: temperature | voltage | current | fan | intrusion | violation_attempt | processor | power_supply | power_unit | cooling_unit | other_unit | memory | drive_slot | post_memory_resize | system_firmware | event_logging | watchdog_old | system_event | critical_interrupt | switch | board | microcontroller | add_in_card | chassis | chip_set | other_fru | interconnect | terminator | system_boot | boot_error | os_boot | os_shutdown | slot | system_acpi_power_state | watchdog | platform_alert | entity_presence | monitor_asic_ic | lan | management_subsystem_health | battery | session | version | fru_state | fru_hot_swap | ipmb_physical | module_hot_swap | power_channel | telco_alarm | non_neg_integer(). -type value() :: {sensor_value, term()} | {previous_value, term()} | {severity_value, term()} | term(). -type unit() :: celsius | fahrenheit | kelvin | volts | amps | watts | joules | coulombs | va | nits | lumen | lux | candela | kPa | psi | newton | cfm | rpm | hz | microsecond | millisecond | second | minute | hour | day | week | mil | inches | feet | cubic_inches | cubic_feet | mm | cm | m | cubic_cm | cubic_m | liters | fluid_ounce | radians | steradians | revolutions | cycles | gravities | ounce | pound | ft_lb | oz_inch | gauss | gilberts | henry | millihenry | farad | microfarad | ohms | siemens | mole | becquerel | ppm | reserved | decibels | dBA | dBC | gray | sievert | color_temperature_kelvin | bit | kilobit | megabit | gigabit | byte | kilobyte | megabyte | gigabyte | word | dword | qword | memory_line | hit | miss | retry | reset | overrun | underrun | collision | packets | messages | characters | error | correctable_error | uncorrectable_error | fatal_error | grams | unspecified. -export_type([ addr/0, entity_id/0, entity/0, reading/0, type/0, value/0, unit/0 ]). %%%============================================================================= %%% API %%%============================================================================= %%------------------------------------------------------------------------------ %% @doc %% Decodes the sensor from a 2 or 3 byte binary according to the encoding %% provided by SEL and SDR records. %% @end %%------------------------------------------------------------------------------ -spec get_addr(binary()) -> [addr()]. get_addr(<>) -> [{fru_id, FruId}, {sensor_lun, Lun}] ++ get_channel(C); get_addr(<>) -> [{sensor_addr, Addr}, {sensor_lun, Lun}] ++ get_channel(C); get_addr(<>) -> [{sensor_addr, Addr}, {sensor_lun, Lun}, {bus_id, Bus}] ++ get_channel(C); get_addr(<>) -> [{sensor_addr, Addr}, {sensor_lun, Lun}] ++ get_channel(C); get_addr(<>) -> [{sensor_addr, Addr}, {sensor_lun, Lun}, {fru_lun, FLun}] ++ get_channel(C); get_addr(<>) -> [{software_id, Id}] ++ get_channel(C); get_addr(<>) -> [{software_id, Id}, {fru_lun, FLun}] ++ get_channel(C). %%------------------------------------------------------------------------------ %% @doc %% Returns the sensor category and reading type from the given sensor and %% reading type. See sections 41 and 42 of the IPMI specification for more %% information. %% @end %%------------------------------------------------------------------------------ -spec get_type(non_neg_integer(), non_neg_integer()) -> {reading(), type()}. get_type(ReadingType, SensorType) -> {get_sensor_reading(ReadingType), get_sensor_type(SensorType)}. %%------------------------------------------------------------------------------ %% @doc %% Returns a (raw) sensor reading. The returned reading may have to be converted %% into human readable values (at least for threshold based sensors). %% @end %%------------------------------------------------------------------------------ -spec get_value(reading(), type(), non_neg_integer(), 0 | 1, 0..255, 0..255) -> [value()]. get_value(Reading, Type, Offset, Assertion, Value1, Value2) -> map(Type, Reading, Offset, Assertion, Value1, Value2). %%------------------------------------------------------------------------------ %% @doc %% Returns a list containing the decoded (human readable) entity properties. To %% retrieve only the entity id use {@link get_entity_id/1}. %% @end %%------------------------------------------------------------------------------ -spec get_entity(non_neg_integer(), binary() | non_neg_integer()) -> [entity()]. get_entity(Id, Instance) when is_integer(Instance) -> get_entity(Id, <>); get_entity(Id, <>) -> get_entity(get_entity_id(Id), Type, Instance). get_entity(Acc, 0, Instance) when Instance < 16#60 -> Acc ++ [{entity_type, physical}, {entity_instance, Instance}]; get_entity(Acc, 1, Instance) when Instance < 16#60 -> Acc ++ [{entity_type, logical}, {entity_instance, Instance}]; get_entity(Acc, 0, Instance) -> Acc ++ [{entity_type, physical}, {entity_instance, Instance - 16#60}]; get_entity(Acc, 1, Instance) -> Acc ++ [{entity_type, logical}, {entity_instance, Instance - 16#60}]. %%------------------------------------------------------------------------------ %% @doc %% Returns the human readable entity for a given entity id according to %% section 43.14 from the IPMI specification. For full entity decoding refer to %% {@link get_entity/2}. %% @end %%------------------------------------------------------------------------------ -spec get_entity_id(non_neg_integer()) -> [{entity_id, entity_id()}]. get_entity_id(16#00) -> [{entity_id, unspecified}]; get_entity_id(16#01) -> [{entity_id, other}]; get_entity_id(16#02) -> [{entity_id, unknown}]; get_entity_id(16#03) -> [{entity_id, processor}]; get_entity_id(16#04) -> [{entity_id, disk_or_disk_bay}]; get_entity_id(16#05) -> [{entity_id, peripheral_bay}]; get_entity_id(16#06) -> [{entity_id, system_management_module}]; get_entity_id(16#07) -> [{entity_id, system_board}]; get_entity_id(16#08) -> [{entity_id, memory_module}]; get_entity_id(16#09) -> [{entity_id, processor_module}]; get_entity_id(16#0a) -> [{entity_id, power_supply}]; get_entity_id(16#0b) -> [{entity_id, add_in_card}]; get_entity_id(16#0c) -> [{entity_id, front_panel_board}]; get_entity_id(16#0d) -> [{entity_id, back_panel_board}]; get_entity_id(16#0e) -> [{entity_id, power_system_board}]; get_entity_id(16#0f) -> [{entity_id, drive_backplane}]; get_entity_id(16#10) -> [{entity_id, system_internal_expansion_board}]; get_entity_id(16#11) -> [{entity_id, other_system_board}]; get_entity_id(16#12) -> [{entity_id, processor_board}]; get_entity_id(16#13) -> [{entity_id, power_unit}]; get_entity_id(16#14) -> [{entity_id, power_module}]; get_entity_id(16#15) -> [{entity_id, power_management}]; get_entity_id(16#16) -> [{entity_id, chassis_back_panel_board}]; get_entity_id(16#17) -> [{entity_id, system_chassis}]; get_entity_id(16#18) -> [{entity_id, sub_chassis}]; get_entity_id(16#19) -> [{entity_id, other_chassis_board}]; get_entity_id(16#1a) -> [{entity_id, disk_drive_bay}]; get_entity_id(16#1b) -> [{entity_id, peripheral_bay}]; get_entity_id(16#1c) -> [{entity_id, device_bay}]; get_entity_id(16#1d) -> [{entity_id, cooling_device}]; get_entity_id(16#1e) -> [{entity_id, cooling_unit}]; get_entity_id(16#1f) -> [{entity_id, interconnect}]; get_entity_id(16#20) -> [{entity_id, memory_device}]; get_entity_id(16#21) -> [{entity_id, system_management_software}]; get_entity_id(16#22) -> [{entity_id, system_firmware}]; get_entity_id(16#23) -> [{entity_id, operating_system}]; get_entity_id(16#24) -> [{entity_id, system_bus}]; get_entity_id(16#25) -> [{entity_id, group}]; get_entity_id(16#26) -> [{entity_id, remote_management_communication_device}]; get_entity_id(16#27) -> [{entity_id, external_environment}]; get_entity_id(16#28) -> [{entity_id, battery}]; get_entity_id(16#29) -> [{entity_id, processing_blade}]; get_entity_id(16#2a) -> [{entity_id, connectivity_switch}]; get_entity_id(16#2b) -> [{entity_id, processor_memory_module}]; get_entity_id(16#2c) -> [{entity_id, io_module}]; get_entity_id(16#2d) -> [{entity_id, processor_io_module}]; get_entity_id(16#2e) -> [{entity_id, management_controller_firmware}]; get_entity_id(16#2f) -> [{entity_id, ipmi_channel}]; get_entity_id(16#30) -> [{entity_id, pci_bus}]; get_entity_id(16#31) -> [{entity_id, pci_expresstm_bus}]; get_entity_id(16#32) -> [{entity_id, scsi_bus}]; get_entity_id(16#33) -> [{entity_id, sata_bus}]; get_entity_id(16#34) -> [{entity_id, front_side_bus}]; get_entity_id(16#35) -> [{entity_id, real_time_clock}]; get_entity_id(16#37) -> [{entity_id, air_inlet}]; get_entity_id(16#40) -> [{entity_id, air_inlet}]; get_entity_id(16#41) -> [{entity_id, processor}]; get_entity_id(16#42) -> [{entity_id, main_system_board}]; get_entity_id(16#a0) -> [{entity_id, front_board}]; get_entity_id(16#c1) -> [{entity_id, amc}]; get_entity_id(16#c2) -> [{entity_id, mch}]; get_entity_id(16#f0) -> [{entity_id, shelf_management_controller}]; get_entity_id(16#f1) -> [{entity_id, filtration_unit}]; get_entity_id(16#f2) -> [{entity_id, shelf_fru_information}]; get_entity_id(16#f3) -> [{entity_id, alarm_panel}]; get_entity_id(Id) -> [{entity_id, Id}]. %%------------------------------------------------------------------------------ %% @doc %% Returns the sensor unit from the given type code according to section 43.17 %% from the IPMI specification. %% @end %%------------------------------------------------------------------------------ -spec get_unit(non_neg_integer()) -> unit(). get_unit(1) -> celsius; get_unit(2) -> fahrenheit; get_unit(3) -> kelvin; get_unit(4) -> volts; get_unit(5) -> amps; get_unit(6) -> watts; get_unit(7) -> joules; get_unit(8) -> coulombs; get_unit(9) -> va; get_unit(10) -> nits; get_unit(11) -> lumen; get_unit(12) -> lux; get_unit(13) -> candela; get_unit(14) -> kPa; get_unit(15) -> psi; get_unit(16) -> newton; get_unit(17) -> cfm; get_unit(18) -> rpm; get_unit(19) -> hz; get_unit(20) -> microsecond; get_unit(21) -> millisecond; get_unit(22) -> second; get_unit(23) -> minute; get_unit(24) -> hour; get_unit(25) -> day; get_unit(26) -> week; get_unit(27) -> mil; get_unit(28) -> inches; get_unit(29) -> feet; get_unit(30) -> cubic_inches; get_unit(31) -> cubic_feet; get_unit(32) -> mm; get_unit(33) -> cm; get_unit(34) -> m; get_unit(35) -> cubic_cm; get_unit(36) -> cubic_m; get_unit(37) -> liters; get_unit(38) -> fluid_ounce; get_unit(39) -> radians; get_unit(40) -> steradians; get_unit(41) -> revolutions; get_unit(42) -> cycles; get_unit(43) -> gravities; get_unit(44) -> ounce; get_unit(45) -> pound; get_unit(46) -> ft_lb; get_unit(47) -> oz_inch; get_unit(48) -> gauss; get_unit(49) -> gilberts; get_unit(50) -> henry; get_unit(51) -> millihenry; get_unit(52) -> farad; get_unit(53) -> microfarad; get_unit(54) -> ohms; get_unit(55) -> siemens; get_unit(56) -> mole; get_unit(57) -> becquerel; get_unit(58) -> ppm; get_unit(59) -> reserved; get_unit(60) -> decibels; get_unit(61) -> dBA; get_unit(62) -> dBC; get_unit(63) -> gray; get_unit(64) -> sievert; get_unit(65) -> color_temperature_kelvin; get_unit(66) -> bit; get_unit(67) -> kilobit; get_unit(68) -> megabit; get_unit(69) -> gigabit; get_unit(70) -> byte; get_unit(71) -> kilobyte; get_unit(72) -> megabyte; get_unit(73) -> gigabyte; get_unit(74) -> word; get_unit(75) -> dword; get_unit(76) -> qword; get_unit(77) -> memory_line; get_unit(78) -> hit; get_unit(79) -> miss; get_unit(80) -> retry; get_unit(81) -> reset; get_unit(82) -> overrun; get_unit(83) -> underrun; get_unit(84) -> collision; get_unit(85) -> packets; get_unit(86) -> messages; get_unit(87) -> characters; get_unit(88) -> error; get_unit(89) -> correctable_error; get_unit(90) -> uncorrectable_error; get_unit(91) -> fatal_error; get_unit(92) -> grams; get_unit(_) -> unspecified. %%------------------------------------------------------------------------------ %% @doc %% Return the string representation of an entity id, a sensor type or a sensor %% unit. %% @end %%------------------------------------------------------------------------------ -spec to_list(atom() | string() | integer()) -> string(). to_list(Int) when is_integer(Int) -> to_list(integer_to_list(Int)); to_list(Atom) when is_atom(Atom) -> to_list(atom_to_list(Atom)); to_list(List) when is_list(List) -> string:to_upper(List). %%%============================================================================= %%% Internal functions %%%============================================================================= %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_sensor_type(16#01) -> temperature; get_sensor_type(16#02) -> voltage; get_sensor_type(16#03) -> current; get_sensor_type(16#04) -> fan; get_sensor_type(16#05) -> intrusion; get_sensor_type(16#06) -> violation_attempt; get_sensor_type(16#07) -> processor; get_sensor_type(16#08) -> power_supply; get_sensor_type(16#09) -> power_unit; get_sensor_type(16#0a) -> cooling_unit; get_sensor_type(16#0b) -> other_unit; get_sensor_type(16#0c) -> memory; get_sensor_type(16#0d) -> drive_slot; get_sensor_type(16#0e) -> post_memory_resize; get_sensor_type(16#0f) -> system_firmware; get_sensor_type(16#10) -> event_logging; get_sensor_type(16#11) -> watchdog_old; get_sensor_type(16#12) -> system_event; get_sensor_type(16#13) -> critical_interrupt; get_sensor_type(16#14) -> switch; get_sensor_type(16#15) -> board; get_sensor_type(16#16) -> microcontroller; get_sensor_type(16#17) -> add_in_card; get_sensor_type(16#18) -> chassis; get_sensor_type(16#19) -> chip_set; get_sensor_type(16#1a) -> other_fru; get_sensor_type(16#1b) -> interconnect; get_sensor_type(16#1c) -> terminator; get_sensor_type(16#1d) -> system_boot; get_sensor_type(16#1e) -> boot_error; get_sensor_type(16#1f) -> os_boot; get_sensor_type(16#20) -> os_shutdown; get_sensor_type(16#21) -> slot; get_sensor_type(16#22) -> system_acpi_power_state; get_sensor_type(16#23) -> watchdog; get_sensor_type(16#24) -> platform_alert; get_sensor_type(16#25) -> entity_presence; get_sensor_type(16#26) -> monitor_asic_ic; get_sensor_type(16#27) -> lan; get_sensor_type(16#28) -> management_subsystem_health; get_sensor_type(16#29) -> battery; get_sensor_type(16#2a) -> session; get_sensor_type(16#2b) -> version; get_sensor_type(16#2c) -> fru_state; get_sensor_type(16#f0) -> fru_hot_swap; get_sensor_type(16#f1) -> ipmb_physical; get_sensor_type(16#f2) -> module_hot_swap; get_sensor_type(16#f3) -> power_channel; get_sensor_type(16#f4) -> telco_alarm; get_sensor_type(Type) -> Type. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_sensor_reading(16#01) -> threshold; get_sensor_reading(16#02) -> dmi_usage; get_sensor_reading(16#03) -> state; get_sensor_reading(16#04) -> predictive_failure; get_sensor_reading(16#05) -> limit; get_sensor_reading(16#06) -> performance; get_sensor_reading(16#07) -> severity; get_sensor_reading(16#08) -> availability0; get_sensor_reading(16#09) -> availability1; get_sensor_reading(16#0a) -> availability2; get_sensor_reading(16#0b) -> redundancy; get_sensor_reading(16#0c) -> acpi_power_state; get_sensor_reading(16#6f) -> specific; get_sensor_reading(Reading) -> Reading. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ map(_, threshold, A, _, _, _) -> get_threshold(A); map(_, dmi_usage, A, _, _, _) -> get_dmi_usage(A); map(_, state, A, _, _, _) -> get_assertion(A); map(_, predictive_failure, A, _, _, _) -> get_assertion(A); map(_, limit, A, _, _, _) -> get_limit(A); map(_, performance, A, _, _, _) -> get_performance(A); map(_, severity, A, _, _, _) -> get_severity(A); map(_, availability0, A, _, _, _) -> get_availability08(A); map(_, availability1, A, _, _, _) -> get_availability09(A); map(_, availability2, A, _, _, _) -> get_availability0a(A); map(_, redundancy, A, _, _, _) -> get_redundancy(A); map(_, acpi_power_state, A, _, _, _) -> get_acpi_power_state(A); map(intrusion, specific, A, _, _, _) -> get_intrusion(A); map(violation_attempt, specific, A, _, _, _) -> get_violation_attempt(A); map(processor, specific, A, _, _, _) -> get_processor_failure(A); map(power_supply, specific, A, _, _, D) -> get_power_supply_event(A, D); map(power_unit, specific, A, _, _, _) -> get_power_unit_event(A); map(memory, specific, A, _, _, D) -> get_memory_event(A, D); map(drive_slot, specific, A, _, _, _) -> get_drive_slot_state(A); map(system_firmware, specific, A, _, C, _) -> get_system_firmware_event(A, C); map(event_logging, specific, A, _, C, D) -> get_event_logging_event(A, C, D); map(watchdog_old, specific, A, _, _, _) -> get_watchdog_old(A); map(system_event, specific, A, _, C, _) -> get_system_event(A, C); map(critical_interrupt, specific, A, _, _, _) -> get_critical_interrupt(A); map(switch, specific, A, _, _, _) -> get_switch_event(A); map(chip_set, specific, A, _, C, D) -> get_chip_set_event(A, C, D); map(interconnect, specific, A, _, _, _) -> get_interconnect(A); map(system_boot, specific, A, _, C, D) -> get_system_boot_event(A, C, D); map(boot_error, specific, A, _, _, _) -> get_boot_error(A); map(os_boot, specific, A, _, _, _) -> get_os_boot_event(A); map(os_shutdown, specific, A, _, _, _) -> get_os_shutdown_event(A); map(slot, specific, A, _, C, D) -> get_slot_event(A, C, D); map(system_acpi_power_state, specific, A, _, _, _) -> get_power_state(A); map(watchdog, specific, A, _, C, _) -> get_watchdog_new(A, C); map(platform_alert, specific, A, _, _, _) -> get_platform_alert(A); map(entity_presence, specific, A, B, _, _) -> get_entity_presence(A, B); map(lan, specific, A, _, _, _) -> get_lan_event(A); map(management_subsystem_health, specific, A, _, C, D) -> get_management_subsystem_health(A, C, D); map(battery, specific, A, _, _, _) -> get_battery_state(A); map(session, specific, A, _, C, D) -> get_session_event(A, C, D); map(version, specific, A, B, C, _) -> get_version_change(A, B, C); map(fru_state, specific, A, _, C, _) -> get_fru_event(A, C); map(fru_hot_swap, specific, A, _, C, D) -> get_fru_hot_swap_event(A, C, D); map(module_hot_swap, specific, A, _, _, _) -> get_module_hot_swap_event(A); map(power_channel, specific, A, _, C, D) -> get_power_channel_notification(A, C, D); map(_, _, A, B, C, D) -> [ {offset, A}, {data2, C}, {data3, D}, {asserted, not eipmi_util:get_bool(B)} ]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_threshold(16#00) -> [{sensor_value, lower_non_critical}, {tendency, going_low}]; get_threshold(16#01) -> [{sensor_value, lower_non_critical}, {tendency, going_high}]; get_threshold(16#02) -> [{sensor_value, lower_critical}, {tendency, going_low}]; get_threshold(16#03) -> [{sensor_value, lower_critical}, {tendency, going_high}]; get_threshold(16#04) -> [{sensor_value, lower_non_recoverable}, {tendency, going_low}]; get_threshold(16#05) -> [{sensor_value, lower_non_recoverable}, {tendency, going_high}]; get_threshold(16#06) -> [{sensor_value, upper_non_critical}, {tendency, going_low}]; get_threshold(16#07) -> [{sensor_value, upper_non_critical}, {tendency, going_high}]; get_threshold(16#08) -> [{sensor_value, upper_critical}, {tendency, going_low}]; get_threshold(16#09) -> [{sensor_value, upper_critical}, {tendency, going_high}]; get_threshold(16#0a) -> [{sensor_value, upper_non_recoverable}, {tendency, going_low}]; get_threshold(16#0b) -> [{sensor_value, upper_non_recoverable}, {tendency, going_high}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_dmi_usage(16#00) -> [{sensor_value, transition_to_idle}]; get_dmi_usage(16#01) -> [{sensor_value, transition_to_active}]; get_dmi_usage(16#02) -> [{sensor_value, transition_to_busy}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_assertion(16#00) -> [{sensor_value, deasserted}]; get_assertion(16#01) -> [{sensor_value, asserted}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_limit(16#00) -> [{sensor_value, not_exceeded}]; get_limit(16#01) -> [{sensor_value, exceeded}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_performance(16#00) -> [{sensor_value, met}]; get_performance(16#01) -> [{sensor_value, lags}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_severity(16#00) -> [{sensor_value, ok}]; get_severity(16#01) -> [{sensor_value, non_critical}]; get_severity(16#02) -> [{sensor_value, critical}]; get_severity(16#03) -> [{sensor_value, non_recoverable}]; get_severity(16#04) -> [{sensor_value, non_critical}]; get_severity(16#05) -> [{sensor_value, critical}]; get_severity(16#06) -> [{sensor_value, non_recoverable}]; get_severity(16#07) -> [{sensor_value, monitor}]; get_severity(16#08) -> [{sensor_value, informational}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_availability08(16#00) -> [{sensor_value, removed_or_absent}]; get_availability08(16#01) -> [{sensor_value, inserted_or_present}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_availability09(16#00) -> [{sensor_value, device_disabled}]; get_availability09(16#01) -> [{sensor_value, device_enabled}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_availability0a(16#00) -> [{sensor_value, to_running}]; get_availability0a(16#01) -> [{sensor_value, to_in_test}]; get_availability0a(16#02) -> [{sensor_value, to_power_off}]; get_availability0a(16#03) -> [{sensor_value, to_on_line}]; get_availability0a(16#04) -> [{sensor_value, to_off_line}]; get_availability0a(16#05) -> [{sensor_value, to_off_duty}]; get_availability0a(16#06) -> [{sensor_value, to_degraded}]; get_availability0a(16#07) -> [{sensor_value, to_power_save}]; get_availability0a(16#08) -> [{sensor_value, install_error}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_redundancy(16#00) -> [{sensor_value, full}]; get_redundancy(16#01) -> [{sensor_value, lost}]; get_redundancy(16#02) -> [{sensor_value, degraded}]; get_redundancy(16#03) -> [{sensor_value, none_from_degraded_or_full}]; get_redundancy(16#04) -> [{sensor_value, none_sufficient_resources}]; get_redundancy(16#05) -> [{sensor_value, none_insufficient_resources}]; get_redundancy(16#06) -> [{sensor_value, degraded_from_full}]; get_redundancy(16#07) -> [{sensor_value, degraded_from_none}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_acpi_power_state(16#00) -> [{sensor_value, d0}]; get_acpi_power_state(16#01) -> [{sensor_value, d1}]; get_acpi_power_state(16#02) -> [{sensor_value, d2}]; get_acpi_power_state(16#03) -> [{sensor_value, d3}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_intrusion(16#00) -> [{sensor_value, general_chassis}]; get_intrusion(16#01) -> [{sensor_value, drive_bay}]; get_intrusion(16#02) -> [{sensor_value, io_card_area}]; get_intrusion(16#03) -> [{sensor_value, processor_area}]; get_intrusion(16#04) -> [{sensor_value, lan_leash_lost}]; get_intrusion(16#05) -> [{sensor_value, unauthorized_dock}]; get_intrusion(16#06) -> [{sensor_value, fan_area}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_violation_attempt(16#00) -> [{sensor_value, secure_mode}]; get_violation_attempt(16#01) -> [{sensor_value, pre_boot_user_password}]; get_violation_attempt(16#02) -> [{sensor_value, pre_boot_setup_password}]; get_violation_attempt(16#03) -> [{sensor_value, pre_boot_network_password}]; get_violation_attempt(16#04) -> [{sensor_value, pre_boot_other_password}]; get_violation_attempt(16#05) -> [{sensor_value, pre_boot_out_of_band_access}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_processor_failure(16#00) -> [{sensor_value, internal_error}]; get_processor_failure(16#01) -> [{sensor_value, thermal_trip}]; get_processor_failure(16#02) -> [{sensor_value, frb1_bist_failure}]; get_processor_failure(16#03) -> [{sensor_value, frb2_hang_in_post_failure}]; get_processor_failure(16#04) -> [{sensor_value, frb3_startup_initialization_failure}]; get_processor_failure(16#05) -> [{sensor_value, configuration_error}]; get_processor_failure(16#06) -> [{sensor_value, uncorrectable_cpu_complex_error}]; get_processor_failure(16#07) -> [{sensor_value, presence_detected}]; get_processor_failure(16#08) -> [{sensor_value, disabled}]; get_processor_failure(16#09) -> [{sensor_value, terminator_presence_detected}]; get_processor_failure(16#0a) -> [{sensor_value, throttled_automatically}]; get_processor_failure(16#0b) -> [{sensor_value, uncorrectable_machine_check_error}]; get_processor_failure(16#0c) -> [{sensor_value, correctable_machine_check_error}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_power_supply_event(16#00, _) -> [{sensor_value, presence_detected}]; get_power_supply_event(16#01, _) -> [{sensor_value, failure_detected}]; get_power_supply_event(16#02, _) -> [{sensor_value, predictive_failure}]; get_power_supply_event(16#03, _) -> [{sensor_value, input_lost}]; get_power_supply_event(16#04, _) -> [{sensor_value, input_lost_or_out_of_range}]; get_power_supply_event(16#05, _) -> [{sensor_value, input_out_of_range_but_present}]; get_power_supply_event(16#06, 16#00) -> [{sensor_value, configuration_error}, {reason, vendor_mismatch}]; get_power_supply_event(16#06, 16#01) -> [{sensor_value, configuration_error}, {reason, revision_mismatch}]; get_power_supply_event(16#06, 16#02) -> [{sensor_value, configuration_error}, {reason, processor_missing}]; get_power_supply_event(16#06, 16#03) -> [ {sensor_value, configuration_error}, {reason, power_supply_rating_mismatch} ]; get_power_supply_event(16#06, 16#04) -> [{sensor_value, configuration_error}, {reason, voltage_rating_mismatch}]; get_power_supply_event(16#06, _) -> [{sensor_value, configuration_error}, {reason, unknown}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_power_unit_event(16#00) -> [{sensor_value, power_off}]; get_power_unit_event(16#01) -> [{sensor_value, power_cycle}]; get_power_unit_event(16#02) -> [{sensor_value, power_down_240va}]; get_power_unit_event(16#03) -> [{sensor_value, power_down_interlock}]; get_power_unit_event(16#04) -> [{sensor_value, power_input_lost}]; get_power_unit_event(16#05) -> [{sensor_value, soft_power_control_failure}]; get_power_unit_event(16#06) -> [{sensor_value, failure_detected}]; get_power_unit_event(16#07) -> [{sensor_value, predictive_failure}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_memory_event(16#00, _) -> [{sensor_value, correctable_ecc}]; get_memory_event(16#01, _) -> [{sensor_value, uncorrectable_ecc}]; get_memory_event(16#02, _) -> [{sensor_value, parity}]; get_memory_event(16#03, _) -> [{sensor_value, memory_scrub_failed}]; get_memory_event(16#04, _) -> [{sensor_value, device_disabled}]; get_memory_event(16#05, _) -> [{sensor_value, error_logging_limit_reached}]; get_memory_event(16#06, _) -> [{sensor_value, presence_detected}]; get_memory_event(16#07, _) -> [{sensor_value, configuration_error}]; get_memory_event(16#08, 16#ff) -> [{sensor_value, spare}]; get_memory_event(16#08, Id) -> [{sensor_value, spare}, {spare_id, Id}]; get_memory_event(16#09, _) -> [{sensor_value, throttled_automatically}]; get_memory_event(16#0a, _) -> [{sensor_value, critical_overtemperature}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_drive_slot_state(16#00) -> [{sensor_value, drive_presence}]; get_drive_slot_state(16#01) -> [{sensor_value, drive_fault}]; get_drive_slot_state(16#02) -> [{sensor_value, predictive_failure}]; get_drive_slot_state(16#03) -> [{sensor_value, hot_spare}]; get_drive_slot_state(16#04) -> [{sensor_value, consistency_check_in_progress}]; get_drive_slot_state(16#05) -> [{sensor_value, in_critical_array}]; get_drive_slot_state(16#06) -> [{sensor_value, in_failed_array}]; get_drive_slot_state(16#07) -> [{sensor_value, rebuild_in_progress}]; get_drive_slot_state(16#08) -> [{sensor_value, rebuild_aborted}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_system_firmware_event(16#00, 16#01) -> [{sensor_value, error}, {reason, no_memory_installed}]; get_system_firmware_event(16#00, 16#02) -> [{sensor_value, error}, {reason, no_memory_usable}]; get_system_firmware_event(16#00, 16#03) -> [{sensor_value, error}, {reason, hard_disk_failure}]; get_system_firmware_event(16#00, 16#04) -> [{sensor_value, error}, {reason, system_board_failure}]; get_system_firmware_event(16#00, 16#05) -> [{sensor_value, error}, {reason, diskette_subsystem_failure}]; get_system_firmware_event(16#00, 16#06) -> [{sensor_value, error}, {reason, hard_disk_controller_failure}]; get_system_firmware_event(16#00, 16#07) -> [{sensor_value, error}, {reason, keyboard_failure}]; get_system_firmware_event(16#00, 16#08) -> [{sensor_value, error}, {reason, boot_media_not_found}]; get_system_firmware_event(16#00, 16#09) -> [{sensor_value, error}, {reason, video_controller_failure}]; get_system_firmware_event(16#00, 16#0a) -> [{sensor_value, error}, {reason, no_video_device}]; get_system_firmware_event(16#00, 16#0b) -> [{sensor_value, error}, {reason, firmware_corrupted}]; get_system_firmware_event(16#00, 16#0c) -> [{sensor_value, error}, {reason, cpu_voltage_missing}]; get_system_firmware_event(16#00, 16#0d) -> [{sensor_value, error}, {reason, cpu_speed_matching_failure}]; get_system_firmware_event(16#00, _) -> [{sensor_value, error}, {reason, unspecified}]; get_system_firmware_event(16#01, _) -> [{sensor_value, hang}]; get_system_firmware_event(16#02, 16#01) -> [{sensor_value, progress}, {process, memory_initialization}]; get_system_firmware_event(16#02, 16#02) -> [{sensor_value, progress}, {process, hard_disk_initialization}]; get_system_firmware_event(16#02, 16#03) -> [{sensor_value, progress}, {process, sec_processor_initialization}]; get_system_firmware_event(16#02, 16#04) -> [{sensor_value, progress}, {process, user_authentication}]; get_system_firmware_event(16#02, 16#05) -> [{sensor_value, progress}, {process, user_initiated_system_setup}]; get_system_firmware_event(16#02, 16#06) -> [{sensor_value, progress}, {process, usb_resource_configuration}]; get_system_firmware_event(16#02, 16#07) -> [{sensor_value, progress}, {process, pci_resource_configuration}]; get_system_firmware_event(16#02, 16#08) -> [{sensor_value, progress}, {process, option_rom_initialization}]; get_system_firmware_event(16#02, 16#09) -> [{sensor_value, progress}, {process, video_initialization}]; get_system_firmware_event(16#02, 16#0a) -> [{sensor_value, progress}, {process, cache_initialization}]; get_system_firmware_event(16#02, 16#0b) -> [{sensor_value, progress}, {process, sm_bus_initialization}]; get_system_firmware_event(16#02, 16#0c) -> [{sensor_value, progress}, {process, keyboard_controller_initialization}]; get_system_firmware_event(16#02, 16#0d) -> [{sensor_value, progress}, {process, mgmt_controller_initialization}]; get_system_firmware_event(16#02, 16#0e) -> [{sensor_value, progress}, {process, docking_station_attachment}]; get_system_firmware_event(16#02, 16#0f) -> [{sensor_value, progress}, {process, enabling_docking_station}]; get_system_firmware_event(16#02, 16#10) -> [{sensor_value, progress}, {process, docking_station_ejection}]; get_system_firmware_event(16#02, 16#11) -> [{sensor_value, progress}, {process, disabling_docking_station}]; get_system_firmware_event(16#02, 16#12) -> [ {sensor_value, progress}, {process, calling_operating_system_wake_up_vector} ]; get_system_firmware_event(16#02, 16#13) -> [ {sensor_value, progress}, {process, starting_operating_system_boot_process} ]; get_system_firmware_event(16#02, 16#14) -> [{sensor_value, progress}, {process, baseboard_initialization}]; get_system_firmware_event(16#02, 16#16) -> [{sensor_value, progress}, {process, floppy_initialization}]; get_system_firmware_event(16#02, 16#17) -> [{sensor_value, progress}, {process, keyboard_test}]; get_system_firmware_event(16#02, 16#18) -> [{sensor_value, progress}, {process, pointing_device_test}]; get_system_firmware_event(16#02, 16#19) -> [{sensor_value, progress}, {process, prim_processor_initialization}]; get_system_firmware_event(16#02, _) -> [{sensor_value, progress}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_event_logging_event(16#00, 16#ff, _) -> [{sensor_value, disabled}, {component, memory}]; get_event_logging_event(16#00, Id, _) -> [{sensor_value, disabled}, {component, memory}, {component_id, Id}]; get_event_logging_event(16#02, _, _) -> [{sensor_value, log_area_cleared}]; get_event_logging_event(16#03, _, _) -> [{sensor_value, disabled_all}]; get_event_logging_event(16#04, _, _) -> [{sensor_value, sel_full}]; get_event_logging_event(16#05, _, 16#ff) -> [{sensor_value, sel_almost_full}, {level, unknown}]; get_event_logging_event(16#05, _, Fill) -> [{sensor_value, sel_almost_full}, {level, Fill}]; get_event_logging_event(16#06, 16#ff, 16#ff) -> [{sensor_value, disabled}, {component, correctable_machine_check}]; get_event_logging_event(16#06, Id, 16#80) -> [ {sensor_value, disabled}, {component, correctable_machine_check}, {processor, Id} ]; get_event_logging_event(16#06, Id, _) -> [ {sensor_value, disabled}, {component, correctable_machine_check}, {instance, Id} ]; get_event_logging_event(16#01, 16#ff, 16#ff) -> [{sensor_value, disabled}]; get_event_logging_event(16#01, RType, Byte) -> Event = get_event(RType, Byte band 16#0f, (Byte band 16#10) bsr 4), [{sensor_value, disabled}, {component, Event}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_event(ReadingType, Offset, Assertion) -> [ {reading_type, get_sensor_reading(ReadingType)}, {offset, Offset}, {asserted, not eipmi_util:get_bool(Assertion)} ]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_watchdog_old(16#00) -> [{sensor_value, bios_reset}]; get_watchdog_old(16#01) -> [{sensor_value, os_reset}]; get_watchdog_old(16#02) -> [{sensor_value, shut_down}]; get_watchdog_old(16#03) -> [{sensor_value, power_down}]; get_watchdog_old(16#04) -> [{sensor_value, power_cycle}]; get_watchdog_old(16#05) -> [{sensor_value, os_nmi}]; get_watchdog_old(16#06) -> [{sensor_value, expired}]; get_watchdog_old(16#07) -> [{sensor_value, os_non_nmi}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_system_event(16#00, _) -> [{sensor_value, system_reconfigured}]; get_system_event(16#01, _) -> [{sensor_value, oem_boot_event}]; get_system_event(16#02, _) -> [{sensor_value, hardware_failure}]; get_system_event(16#04, 16#ff) -> [{sensor_value, pef_actions}, {pef_actions, []}]; get_system_event(16#04, Data) -> [{sensor_value, pef_actions}, {pef_actions, get_pef_actions(Data)}]; get_system_event(16#03, 16#ff) -> [{sensor_value, auxiliary_log}]; get_system_event(16#03, Data) -> Type = get_auxiliary_log_type(Data band 16#0f), Action = get_auxiliary_log_action(Data band 16#f0 bsr 4), [{sensor_value, auxiliary_log}, {log_action, Action}, {log_type, Type}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_pef_actions(Actions) -> A = case Actions band 16#20 bsr 5 of 0 -> []; 1 -> diagnostic_interrupt end, B = case Actions band 16#10 bsr 4 of 0 -> []; 1 -> oem end, C = case Actions band 16#08 bsr 3 of 0 -> []; 1 -> power_cycle end, D = case Actions band 16#04 bsr 2 of 0 -> []; 1 -> reset end, E = case Actions band 16#02 bsr 1 of 0 -> []; 1 -> power_off end, F = case Actions band 16#01 of 0 -> []; 1 -> alert end, A ++ B ++ C ++ D ++ E ++ F. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_auxiliary_log_type(0) -> mca_log; get_auxiliary_log_type(1) -> oem1; get_auxiliary_log_type(2) -> oem2; get_auxiliary_log_type(_) -> unknown. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_auxiliary_log_action(0) -> entry_added; get_auxiliary_log_action(1) -> entry_added; get_auxiliary_log_action(2) -> entry_added; get_auxiliary_log_action(3) -> cleared; get_auxiliary_log_action(4) -> disabled; get_auxiliary_log_action(5) -> enabled; get_auxiliary_log_action(_) -> unknown. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_critical_interrupt(16#00) -> [{sensor_value, front_panel_nmi}]; get_critical_interrupt(16#01) -> [{sensor_value, bus_timeout}]; get_critical_interrupt(16#02) -> [{sensor_value, io_channel_check_nmi}]; get_critical_interrupt(16#03) -> [{sensor_value, software_nmi}]; get_critical_interrupt(16#04) -> [{sensor_value, pci_perr}]; get_critical_interrupt(16#05) -> [{sensor_value, pci_serr}]; get_critical_interrupt(16#06) -> [{sensor_value, eisa_fail_safe_timeout}]; get_critical_interrupt(16#07) -> [{sensor_value, bus_correctable_error}]; get_critical_interrupt(16#08) -> [{sensor_value, bus_uncorrectable_error}]; get_critical_interrupt(16#09) -> [{sensor_value, fatal_nmi}]; get_critical_interrupt(16#0a) -> [{sensor_value, bus_fatal_error}]; get_critical_interrupt(16#0b) -> [{sensor_value, bus_degraded}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_switch_event(16#00) -> [{sensor_value, power_button_pressed}]; get_switch_event(16#01) -> [{sensor_value, sleep_button_pressed}]; get_switch_event(16#02) -> [{sensor_value, reset_button_pressed}]; get_switch_event(16#03) -> [{sensor_value, fru_latch_open}]; get_switch_event(16#04) -> [{sensor_value, fru_service_request_button}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_chip_set_event(16#01, _, _) -> [{sensor_value, thermal_trip}]; get_chip_set_event(16#00, Requested, Actual) -> [{sensor_value, R}] = get_power_state(Requested), [{sensor_value, A}] = get_power_state(Actual), [{sensor_value, soft_power_control_failure}, {requested, R}, {actual, A}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_interconnect(16#00) -> [{sensor_value, connected}]; get_interconnect(16#01) -> [{sensor_value, configuration_error}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_system_boot_event(16#00, _, _) -> [{sensor_value, initiated_by_power_up}]; get_system_boot_event(16#01, _, _) -> [{sensor_value, initiated_by_hard_reset}]; get_system_boot_event(16#02, _, _) -> [{sensor_value, initiated_by_warm_reset}]; get_system_boot_event(16#03, _, _) -> [{sensor_value, user_requested_pxe_boot}]; get_system_boot_event(16#04, _, _) -> [{sensor_value, automatic_boot_to_diagnostic}]; get_system_boot_event(16#05, _, _) -> [{sensor_value, software_initiated_hard_reset}]; get_system_boot_event(16#06, _, _) -> [{sensor_value, software_initiated_warm_reset}]; get_system_boot_event(16#07, Cau, Chan) -> [ {sensor_value, system_restart}, {cause, get_system_restart_cause(Cau)} ] ++ case Chan of 16#ff -> []; _ -> [{channel, Chan}] end. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_system_restart_cause(16#01) -> chassis_control_command; get_system_restart_cause(16#02) -> reset_via_pushbutton; get_system_restart_cause(16#03) -> power_up_via_power_pushbutton; get_system_restart_cause(16#04) -> watchdog_expiration; get_system_restart_cause(16#05) -> oem; get_system_restart_cause(16#06) -> automatic_always_restore; get_system_restart_cause(16#07) -> automatic_restore_previous; get_system_restart_cause(16#08) -> reset_via_pef; get_system_restart_cause(16#09) -> power_cycle_via_pef; get_system_restart_cause(16#0a) -> soft_reset; get_system_restart_cause(16#0b) -> power_up_via_rtc; get_system_restart_cause(_) -> unknown. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_boot_error(16#00) -> [{sensor_value, no_bootable_media}]; get_boot_error(16#01) -> [{sensor_value, non_bootable_media_left_in_drive}]; get_boot_error(16#02) -> [{sensor_value, pxe_server_not_found}]; get_boot_error(16#03) -> [{sensor_value, invalid_boot_sector}]; get_boot_error(16#04) -> [{sensor_value, timeout_waiting_for_user}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_os_boot_event(16#00) -> [{sensor_value, completed_a}]; get_os_boot_event(16#01) -> [{sensor_value, completed_c}]; get_os_boot_event(16#02) -> [{sensor_value, completed_pxe}]; get_os_boot_event(16#03) -> [{sensor_value, completed_diagnostic}]; get_os_boot_event(16#04) -> [{sensor_value, completed_cdrom}]; get_os_boot_event(16#05) -> [{sensor_value, completed_rom}]; get_os_boot_event(16#06) -> [{sensor_value, completed}]; get_os_boot_event(16#07) -> [{sensor_value, installation_started}]; get_os_boot_event(16#08) -> [{sensor_value, installation_completed}]; get_os_boot_event(16#09) -> [{sensor_value, installation_aborted}]; get_os_boot_event(16#0a) -> [{sensor_value, installatino_failed}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_os_shutdown_event(16#00) -> [{sensor_value, critical_stop_during_startup}]; get_os_shutdown_event(16#01) -> [{sensor_value, critical_stop_during_runtime}]; get_os_shutdown_event(16#02) -> [{sensor_value, graceful_stop}]; get_os_shutdown_event(16#03) -> [{sensor_value, graceful_shutdown}]; get_os_shutdown_event(16#04) -> [{sensor_value, soft_shutdown}]; get_os_shutdown_event(16#05) -> [{sensor_value, agent_not_responding}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_slot_event(Value, Type, Num) -> T = get_slot_type(Type band 2#01111111), get_slot_event(Value) ++ [{slot_type, T}, {slot_number, Num}]. get_slot_event(16#00) -> [{sensor_value, fault_status_asserted}]; get_slot_event(16#01) -> [{sensor_value, identify_status_asserted}]; get_slot_event(16#02) -> [{sensor_value, installed}]; get_slot_event(16#03) -> [{sensor_value, ready_for_installation}]; get_slot_event(16#04) -> [{sensor_value, ready_for_removal}]; get_slot_event(16#05) -> [{sensor_value, off}]; get_slot_event(16#06) -> [{sensor_value, removal_request}]; get_slot_event(16#07) -> [{sensor_value, interlock_asserted}]; get_slot_event(16#08) -> [{sensor_value, disabled}]; get_slot_event(16#09) -> [{sensor_value, spare}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_slot_type(0) -> pci; get_slot_type(1) -> drive_array; get_slot_type(2) -> external_connector; get_slot_type(3) -> docking; get_slot_type(4) -> internal_expansion; get_slot_type(5) -> associated_with_entity_of_sensor; get_slot_type(6) -> atca; get_slot_type(7) -> memory; get_slot_type(8) -> fan; get_slot_type(9) -> pci_express; get_slot_type(10) -> scsi; get_slot_type(11) -> sata; get_slot_type(_) -> unknown. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_power_state(16#00) -> [{sensor_value, {s0_g0, working}}]; get_power_state(16#01) -> [{sensor_value, {s1, clocks_stopped}}]; get_power_state(16#02) -> [{sensor_value, {s2, clocks_stopped}}]; get_power_state(16#03) -> [{sensor_value, {s3, suspend_to_ram}}]; get_power_state(16#04) -> [{sensor_value, {s4, suspend_to_disk}}]; get_power_state(16#05) -> [{sensor_value, {s5_g2, soft_off}}]; get_power_state(16#06) -> [{sensor_value, {s4_s5, soft_off}}]; get_power_state(16#07) -> [{sensor_value, {g3, mechanical_off}}]; get_power_state(16#08) -> [{sensor_value, {s1_s2_s3, sleeping}}]; get_power_state(16#09) -> [{sensor_value, {g1, sleeping}}]; get_power_state(16#0a) -> [{sensor_value, {s5, override}}]; get_power_state(16#0b) -> [{sensor_value, legacy_on}]; get_power_state(16#0c) -> [{sensor_value, legacy_off}]; get_power_state(_) -> [{sensor_value, unknown}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_watchdog_new(Value, Data) -> get_watchdog_new(Value) ++ get_interrupt_type(Data band 16#f0 bsr 4) ++ get_timer_use(Data band 16#0f). get_watchdog_new(16#00) -> [{sensor_value, timer_expired}]; get_watchdog_new(16#01) -> [{sensor_value, hard_reset}]; get_watchdog_new(16#02) -> [{sensor_value, power_down}]; get_watchdog_new(16#03) -> [{sensor_value, power_cycle}]; get_watchdog_new(16#08) -> [{sensor_value, timer_interrupt}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_interrupt_type(0) -> [{interrupt, none}]; get_interrupt_type(1) -> [{interrupt, smi}]; get_interrupt_type(2) -> [{interrupt, nmi}]; get_interrupt_type(3) -> [{interrupt, messaging}]; get_interrupt_type(_) -> []. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_timer_use(1) -> [{timer_use, bios_frb2}]; get_timer_use(2) -> [{timer_use, bios}]; get_timer_use(3) -> [{timer_use, os_load}]; get_timer_use(4) -> [{timer_use, sms}]; get_timer_use(5) -> [{timer_use, oem}]; get_timer_use(_) -> []. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_platform_alert(16#00) -> [{sensor_value, generated_page}]; get_platform_alert(16#01) -> [{sensor_value, generated_lan_alert}]; get_platform_alert(16#02) -> [{sensor_value, generated_event_trap}]; get_platform_alert(16#03) -> [{sensor_value, generated_snmp_trap}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_entity_presence(16#00, _) -> [{sensor_value, present}]; get_entity_presence(16#01, _) -> [{sensor_value, absent}]; get_entity_presence(16#02, 0) -> [{sensor_value, disabled}]; get_entity_presence(16#02, 1) -> [{sensor_value, enabled}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_lan_event(16#00) -> [{sensor_value, heartbeat_lost}]; get_lan_event(16#01) -> [{sensor_value, heartbeat}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_management_subsystem_health(16#00, _, _) -> [{sensor_value, sensor_access_degraded}]; get_management_subsystem_health(16#01, _, _) -> [{sensor_value, controller_access_degraded}]; get_management_subsystem_health(16#02, _, _) -> [{sensor_value, controller_offline}]; get_management_subsystem_health(16#03, _, _) -> [{sensor_value, controller_unavailable}]; get_management_subsystem_health(16#04, 16#ff, _) -> [{sensor_value, sensor_failure}]; get_management_subsystem_health(16#04, Num, _) -> [{sensor_value, sensor_failure}, {failed_sensor_number, Num}]; get_management_subsystem_health(16#05, 16#ff, 16#ff) -> [{sensor_value, fru_failure}]; get_management_subsystem_health(16#05, Data1, Data2) -> [{sensor_value, fru_failure}] ++ get_addr(<>). %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_battery_state(16#00) -> [{sensor_value, low}]; get_battery_state(16#01) -> [{sensor_value, failed}]; get_battery_state(16#02) -> [{sensor_value, presence_detected}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_session_event(Value, User, Data) -> get_session_event(Value) ++ get_session_data(User, Data). get_session_event(16#00) -> [{sensor_value, activated}]; get_session_event(16#01) -> [{sensor_value, deactivated}]; get_session_event(16#02) -> [{sensor_value, invalid_user_or_password}]; get_session_event(16#03) -> [{sensor_value, invalid_password_disable}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_session_data(16#ff, 16#ff) -> []; get_session_data(A, B) -> get_session_data_(<>, <>). get_session_data_(<<_:2, UserId:6>>, <<_:2, 0:2, Channel:4>>) -> [{user_id, UserId}] ++ get_channel(Channel); get_session_data_(<<_:2, UserId:6>>, <<_:2, 1:2, Channel:4>>) -> [{user_id, UserId}, {cause, close_session_command}] ++ get_channel(Channel); get_session_data_(<<_:2, UserId:6>>, <<_:2, 2:2, Channel:4>>) -> [{user_id, UserId}, {cause, timeout}] ++ get_channel(Channel); get_session_data_(<<_:2, UserId:6>>, <<_:2, 3:2, Channel:4>>) -> [{user_id, UserId}, {cause, configuration_change}] ++ get_channel(Channel). %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_version_change(Val1, Val2, Type) -> get_version_change(Val1, Val2) ++ get_version_change_type(Type). get_version_change(16#00, _) -> [{sensor_value, hardware_change_detected}]; get_version_change(16#01, _) -> [{sensor_value, firmware_change_detected}]; get_version_change(16#02, _) -> [{sensor_value, hardware_incompatibility_detected}]; get_version_change(16#03, _) -> [{sensor_value, firmware_incompatibility_detected}]; get_version_change(16#04, _) -> [{sensor_value, unsupported_hardware_version}]; get_version_change(16#05, _) -> [{sensor_value, unsupported_firmware_version}]; get_version_change(16#06, 0) -> [{sensor_value, successful_hardware_change_detected}]; get_version_change(16#06, 1) -> [{sensor_value, unsuccessful_hardware_change_detected}]; get_version_change(16#07, 0) -> [{sensor_value, successful_firmware_change_detected}]; get_version_change(16#07, 1) -> [{sensor_value, unsuccessful_firmware_change_detected}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_version_change_type(16#01) -> [{change_type, management_controller_device_id}]; get_version_change_type(16#02) -> [{change_type, management_controller_firmware_revision}]; get_version_change_type(16#03) -> [{change_type, management_controller_device_revision}]; get_version_change_type(16#04) -> [{change_type, management_controller_manufacturer_id}]; get_version_change_type(16#05) -> [{change_type, management_controller_ipmi_version}]; get_version_change_type(16#06) -> [{change_type, management_controller_auxiliary_firmware_id}]; get_version_change_type(16#07) -> [{change_type, management_controller_firmware_boot_block}]; get_version_change_type(16#08) -> [{change_type, management_controller_firmware}]; get_version_change_type(16#09) -> [{change_type, system_firmware_change}]; get_version_change_type(16#0a) -> [{change_type, sm_bios_change}]; get_version_change_type(16#0b) -> [{change_type, operating_system_change}]; get_version_change_type(16#0c) -> [{change_type, operating_system_loader_change}]; get_version_change_type(16#0d) -> [{change_type, partition_change}]; get_version_change_type(16#0e) -> [{change_type, management_software_agent_change}]; get_version_change_type(16#0f) -> [{change_type, management_software_application_change}]; get_version_change_type(16#10) -> [{change_type, management_software_middleware_change}]; get_version_change_type(16#11) -> [{change_type, programmable_hardware_change}]; get_version_change_type(16#12) -> [{change_type, fru_module_change}]; get_version_change_type(16#13) -> [{change_type, fru_component_change}]; get_version_change_type(16#14) -> [{change_type, fru_replaced_with_equivalent_version}]; get_version_change_type(16#15) -> [{change_type, fru_replaced_with_newer_version}]; get_version_change_type(16#16) -> [{change_type, fru_replaced_with_older_version}]; get_version_change_type(16#17) -> [{change_type, fru_hardware_configuration_change}]; get_version_change_type(_) -> []. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_fru_event(Value, 16#ff) -> [{sensor_value, get_fru_state(Value)}]; get_fru_event(Value, Data) -> [{sensor_value, get_fru_state(Value)}] ++ get_fru_event(<>). get_fru_event(<>) -> get_fru_state_cause(Cause) ++ [{previous_value, get_fru_state(Prev)}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_fru_state(16#00) -> not_installed; get_fru_state(16#01) -> inactive; get_fru_state(16#02) -> activation_requested; get_fru_state(16#03) -> activation_in_progress; get_fru_state(16#04) -> active; get_fru_state(16#05) -> deactivation_requested; get_fru_state(16#06) -> deactivation_in_progress; get_fru_state(16#07) -> communication_lost. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_fru_state_cause(16#00) -> [{cause, normal_state_change}]; get_fru_state_cause(16#01) -> [{cause, external_software}]; get_fru_state_cause(16#02) -> [{cause, latch}]; get_fru_state_cause(16#03) -> [{cause, hot_swap}]; get_fru_state_cause(16#04) -> [{cause, internal_software}]; get_fru_state_cause(16#05) -> [{cause, communication_lost}]; get_fru_state_cause(16#06) -> [{cause, communication_lost}]; get_fru_state_cause(16#07) -> [{cause, unexpected_extraction}]; get_fru_state_cause(16#08) -> [{cause, update}]; get_fru_state_cause(16#09) -> [{cause, no_ipmb_address}]; get_fru_state_cause(16#0a) -> [{cause, unexpedcted_deactivation}]; get_fru_state_cause(_) -> [{cause, unknown}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_fru_hot_swap_event(Value, 16#ff, 16#ff) -> [{sensor_value, get_fru_state(Value)}]; get_fru_hot_swap_event(Value, Data, FruId) -> [{sensor_value, get_fru_state(Value)}, {fru_id, FruId}] ++ get_fru_hot_swap_event(<>). get_fru_hot_swap_event(<>) -> get_fru_hot_swap_state_cause(C) ++ [{previous_value, get_fru_state(P)}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_fru_hot_swap_state_cause(16#00) -> [{cause, normal}]; get_fru_hot_swap_state_cause(16#01) -> [{cause, shelf_manager}]; get_fru_hot_swap_state_cause(16#02) -> [{cause, operator}]; get_fru_hot_swap_state_cause(16#03) -> [{cause, fru_action}]; get_fru_hot_swap_state_cause(16#04) -> [{cause, communication_lost_or_regained}]; get_fru_hot_swap_state_cause(16#05) -> [{cause, communication_lost_or_regained_locally}]; get_fru_hot_swap_state_cause(16#06) -> [{cause, surprise}]; get_fru_hot_swap_state_cause(16#07) -> [{cause, provided_information}]; get_fru_hot_swap_state_cause(16#08) -> [{cause, invalid_hardware_address}]; get_fru_hot_swap_state_cause(_) -> [{cause, unknown}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_module_hot_swap_event(0) -> [{sensor_value, handle_closed}]; get_module_hot_swap_event(1) -> [{sensor_value, handle_opened}]; get_module_hot_swap_event(2) -> [{sensor_value, quiesced}]; get_module_hot_swap_event(3) -> [{sensor_value, backend_power_failure}]; get_module_hot_swap_event(4) -> [{sensor_value, backend_power_shutdown}]; get_module_hot_swap_event(5) -> [{sensor_value, rtm_present}]; get_module_hot_swap_event(6) -> [{sensor_value, rtm_absent}]; get_module_hot_swap_event(7) -> [{sensor_value, rtm_compatible}]; get_module_hot_swap_event(8) -> [{sensor_value, rtm_incompatible}]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_power_channel_notification(0, Bitfield, _) -> get_global_power_channel_notification(<>); get_power_channel_notification(1, Bitfield, Channel) -> get_local_power_channel_notification(<>, Channel). %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_global_power_channel_notification( <> ) -> [ {sensor_value, global_state_change}, {redundant_pm_provides_payload_power, eipmi_util:get_bool(A)}, {payload_power, case B of 0 -> not_good; _ -> good end}, {management_power, case C of 0 -> not_good; _ -> good end}, {role, case D of 0 -> redundant; _ -> primary end} ]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_local_power_channel_notification( <>, Channel ) -> [ {sensor_value, local_state_change}, {channel, Channel}, {power_on_asserted, eipmi_util:get_bool(A)}, {payload_power_overcurrent_detected, eipmi_util:get_bool(B)}, {payload_power_enabled, eipmi_util:get_bool(C)}, {enable_asserted, eipmi_util:get_bool(D)}, {management_power_overcurrent_detected, eipmi_util:get_bool(E)}, {management_power_enabled, eipmi_util:get_bool(F)}, {ps1_asserted, eipmi_util:get_bool(G)} ]. %%------------------------------------------------------------------------------ %% @private %%------------------------------------------------------------------------------ get_channel(0) -> []; get_channel(Channel) -> [{channel, Channel}].