eipmi

%%%=============================================================================
%%% 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
%%% A module providing FRU reading and decoding functionality according to the
%%% official IPMI Platform Management FRU Information Storage Definition.
%%% @end
%%%=============================================================================

-module(eipmi_fru).

-export([read/2,
         to_list/1]).

-include("eipmi.hrl").

-define(OLD_ENGLISH, 0).
-define(ENGLISH, 25).
-define(EOFIELDS, 16#c1).
-define(MAX_READ_COUNT, 23).

-define(READ, {?IPMI_NETFN_STORAGE_REQUEST, ?READ_FRU_DATA}).
-define(GET_INFO, {?IPMI_NETFN_STORAGE_REQUEST, ?GET_FRU_INVENTORY_AREA_INFO}).

-type chassis_info() ::
        {type, non_neg_integer()} |
        {part_number, string()} |
        {serial_number, string()} |
        {custom, term()}.

-type board_info() ::
        {manufacturing_date, non_neg_integer()} |
        {manufacturer, string()} |
        {name, string()} |
        {serial_number, string()} |
        {part_number, string()} |
        {fru_file_id, string()} |
        {custom, term()}.

-type product_info() ::
        board_info() |
        {version, string()} |
        {asset_tag, string()} |
        {custom, term()}.

-type multi_record() ::
        {power_supply, proplists:proplist()} |
        {dc_output, proplists:proplist()} |
        {dc_load, proplists:proplist()} |
        {management_access, proplists:proplist()} |
        {base_compatibility, proplists:proplist()} |
        {extended_compatibility, proplists:proplist()} |
        {amc_p2p_connectivity, proplists:proplist()} |
        {mtca_carrier_information, proplists:proplist()} |
        {oem, proplists:proplist()}.

-type info() ::
        {fru_data,
         [{fru_id, 0..255} |
          {chassis_area, [chassis_info()]} |
          {board_area, [board_info()]} |
          {product_area, [product_info()]} |
          {record_area, [multi_record()]}]}.

-export_type([chassis_info/0,
              board_info/0,
              product_info/0,
              multi_record/0,
              info/0]).

%%%=============================================================================
%%% API
%%%=============================================================================

%%------------------------------------------------------------------------------
%% @doc
%% Read and decode FRU inventory data for a specific FRU id using the provided
%% IPMI session. The returned FRU information is a property list that does only
%% contain the available and checksum error free fields of the inventory.
%% If no FRU data is available for a specific id the returned inventory data is
%% the empty list.
%% @end
%%------------------------------------------------------------------------------
-spec read(pid(), 0..254) -> {ok, info()} | {error, term()}.
read(SessionPid, FruId) ->
    FruInfo = eipmi_session:rpc(SessionPid, ?GET_INFO, [{fru_id, FruId}]),
    do_read(FruInfo, SessionPid, FruId).

%%------------------------------------------------------------------------------
%% @doc
%% Returns a string representation of one or more FRU inventory entries.
%% @end
%%------------------------------------------------------------------------------
-spec to_list(info() | [info()]) -> string().
to_list(FruInventory) when is_list(FruInventory) ->
    eipmi_util:join_nl([to_list(FruInfo) || FruInfo <- FruInventory]);
to_list({fru_data, Properties}) ->
    FruId = integer_to_list(proplists:get_value(fru_id, Properties, -1)),
    eipmi_util:join_nl(
      ["---------------------------------------",
       "FRU Info for device " ++ FruId ++ ":",
       "---------------------------------------",
       to_list_chassis(proplists:get_value(chassis_area, Properties, [])),
       "---------------------------------------",
       to_list_board(proplists:get_value(board_area, Properties, [])),
       "---------------------------------------",
       to_list_product(proplists:get_value(product_area, Properties, []))]).

%%%=============================================================================
%%% Internal functions
%%%=============================================================================

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
do_read({error, {bmc_error, parameter_out_of_range}}, _SessionPid, _FruId) ->
    {ok, []};
do_read(Error = {error, _}, _SessionPid, _FruId) ->
    Error;
do_read({ok, FruInfo}, SessionPid, FruId) ->
    Access = proplists:get_value(access, FruInfo),
    Div = case Access of by_words -> 2; by_bytes -> 1 end,
    AreaSize = proplists:get_value(area_size, FruInfo) div Div,
    decode(FruId, do_read(SessionPid, FruId, AreaSize, ?MAX_READ_COUNT div Div)).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
do_read(SessionPid, FruId, Size, BlockSize) ->
    do_read(SessionPid, FruId, Size, BlockSize, {0, <<>>}).
do_read(_SessionPid, _FruId, Size, _BlockSize, {Size, Acc}) ->
    Acc;
do_read(SessionPid, FruId, Size, BlockSize, {Offset, Acc})
  when Offset + BlockSize =< Size ->
    NewAcc = read_raw(SessionPid, FruId, Offset, BlockSize, Acc),
    do_read(SessionPid, FruId, Size, BlockSize, NewAcc);
do_read(SessionPid, FruId, Size, BlockSize, {Offset, Acc}) ->
    NewAcc = read_raw(SessionPid, FruId, Offset, Size - Offset, Acc),
    do_read(SessionPid, FruId, Size, BlockSize, NewAcc).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
read_raw(SessionPid, FruId, Offset, Count, Acc) ->
    Ps = [{fru_id, FruId}, {offset, Offset}, {count, Count}],
    {ok, R} = eipmi_session:rpc(SessionPid, ?READ, Ps),
    Data = proplists:get_value(data, R),
    {Offset + proplists:get_value(count, R), <<Acc/binary, Data/binary>>}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode(FruId, <<>>) ->
    {ok, {fru_data, [{fru_id, FruId}]}};
decode(FruId, D = <<?EIPMI_RESERVED:4, ?FRU_VERSION:4, O:5/binary, _/binary>>) ->
    OffsetTuple = list_to_tuple(binary_to_list(O)),
    decode(is_header_sane(D), OffsetTuple, FruId, D);
decode(_FruId, _FruData) ->
    {error, unsupported_fru_data}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode(false, _Offsets, _FruId, _FruData) ->
    {error, incorrect_header_checksum};
decode(true, {_, C, B, P, M}, FruId, FruData) ->
    {ok, {fru_data,
          [{fru_id, FruId}]
          ++ decode_chassis(get_area(C, non_zero([B, P, M]), FruData))
          ++ decode_board(get_area(B, non_zero([P, M]), FruData))
          ++ decode_product(get_area(P, non_zero([M]), FruData))
          ++ decode_multi_record(get_area(M, [], FruData))}}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_chassis(<<>>) ->
    [];
decode_chassis(Area = <<?EIPMI_RESERVED:4, ?FRU_VERSION:4, _:8, Data/binary>>) ->
    decode_chassis(is_binary_sane(Area), Data).
decode_chassis(false, _Data) ->
    [];
decode_chassis(true, <<Type:8, Rest/binary>>) ->
    {PartNumber, Rest1} = decode_field(part_number, ?ENGLISH, Rest),
    {SerialNumber, Rest2} = decode_field(serial_number, ?ENGLISH, Rest1),
    CustomFields =  decode_fields(custom, ?ENGLISH, Rest2),
    [{chassis_area,
      [{type, Type}]
      ++ PartNumber
      ++ SerialNumber
      ++ CustomFields}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_board(<<>>) ->
    [];
decode_board(Area = <<?EIPMI_RESERVED:4, ?FRU_VERSION:4, _:8, Data/binary>>) ->
    decode_board(is_binary_sane(Area), Data).
decode_board(false, _Data) ->
    [];
decode_board(true, <<Lang:8, MfgDate:24/little, Rest/binary>>) ->
    {Manufacturer, Rest1} = decode_field(manufacturer, Lang, Rest),
    {Name, Rest2} = decode_field(name, Lang, Rest1),
    {SerialNumber, Rest3} = decode_field(serial_number, ?ENGLISH, Rest2),
    {PartNumber, Rest4} = decode_field(part_number, Lang, Rest3),
    {FruFileId, Rest5} = decode_field(fru_file_id, ?ENGLISH, Rest4),
    CustomFields = decode_fields(custom, Lang, Rest5),
    [{board_area,
      [{manufacturing_date, MfgDate}]
      ++ Manufacturer
      ++ Name
      ++ SerialNumber
      ++ PartNumber
      ++ FruFileId
      ++ CustomFields}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_product(<<>>) ->
    [];
decode_product(Area = <<?EIPMI_RESERVED:4, ?FRU_VERSION:4, _:8, Data/binary>>) ->
    decode_product(is_binary_sane(Area), Data).
decode_product(false, _Data) ->
    [];
decode_product(true, <<Lang:8, Rest/binary>>) ->
    {Manufacturer, Rest1} = decode_field(manufacturer, Lang, Rest),
    {Name, Rest2} = decode_field(name, Lang, Rest1),
    {PartNumber, Rest3} = decode_field(part_number, Lang, Rest2),
    {Version, Rest4} = decode_field(version, Lang, Rest3),
    {SerialNumber, Rest5} = decode_field(serial_number, ?ENGLISH, Rest4),
    {AssetTag, Rest6} = decode_field(asset_tag, Lang, Rest5),
    {FruFileId, Rest7} = decode_field(fru_file_id, Lang, Rest6),
    CustomFields = decode_fields(custom, Lang, Rest7),
    [{product_area,
      Manufacturer
      ++ Name
      ++ PartNumber
      ++ Version
      ++ SerialNumber
      ++ AssetTag
      ++ FruFileId
      ++ CustomFields}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_multi_record(<<>>) ->
    [];
decode_multi_record(RecordData) ->
    decode_multi_record([], RecordData).
decode_multi_record(Records, <<>>) ->
    [{record_area, lists:reverse(Records)}];
decode_multi_record(Records, RestData) ->
    {Record, NewRestData} = decode_record(RestData),
    decode_multi_record(Record ++ Records, NewRestData).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_record(<<>>) ->
    {[], <<>>};
decode_record(Binary = <<Header:5/binary, _/binary>>) ->
    decode_record(is_binary_sane(Header), Binary).
decode_record(false, _Binary) ->
    {[], <<>>};
decode_record(true, <<T:8, 1:1, _:7, L:8, C:8, _:8, D:L/binary, _/binary>>) ->
    {decode_record(sum(D, C) =:= 0, T, D), <<>>};
decode_record(true, <<T:8, 0:1, _:7, L:8, C:8, _:8, D:L/binary, R/binary>>) ->
    {decode_record(sum(D, C) =:= 0, T, D), R}.
decode_record(false, _Type, _Data) ->
    [];
decode_record(true, Type, Data) ->
    decode_record_field_definition(Type, Data).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_record_field_definition(16#00, Data) ->
    [{power_supply, decode_power_supply(Data)}];
decode_record_field_definition(16#01, Data) ->
    [{dc_output, decode_dc_output(Data)}];
decode_record_field_definition(16#02, Data) ->
    [{dc_load, decode_dc_load(Data)}];
decode_record_field_definition(16#03, Data) ->
    [{management_access, decode_management_access(Data)}];
decode_record_field_definition(16#04, Data) ->
    [{base_compatibility, decode_compatibility(Data)}];
decode_record_field_definition(16#05, Data) ->
    [{extended_compatibility, decode_compatibility(Data)}];
decode_record_field_definition(16#c0, <<?PICMG_MID:24/little, Rest/binary>>) ->
    decode_picmg_record(Rest);
decode_record_field_definition(Type, <<ManufaturerId:24/little, Rest/binary>>)
  when Type >= 16#c0 andalso Type =< 16#ff ->
    [{oem, [{type, Type}, {manufacturer_id, ManufaturerId}, {data, Rest}]}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_power_supply(<<OCapacity:16/little, PeakVA:16/little,
                      InrushCurrent:8, InrushInterval:8,
                      LowEndInputV1:16/little, HighEndInputV1:16/little,
                      LowEndInputV2:16/little, HighEndInputV2:16/little,
                      LowEndInputFrequency:8, HighEndInputFrequency:8,
                      ACDropOutTolerance:8, 0:3, FailSignal:1,
                      HotSwap:1, Autoswitch:1, PowerFactor:1,
                      PredictiveFailSupport:1, PeakW:16/little,
                      CombinedWattageV1:4, CombinedWattageV2:4,
                      TotalWattage:16/little,
                      PredictiveFailTachometerLowerThreshold:8>>) ->
    <<?EIPMI_RESERVED:4, OverallCapacity:12>> = <<OCapacity:16>>,
    <<PeakWattageSecs:4, PeakWattage:12>> = <<PeakW:16>>,
    [{overall_capacitly, {OverallCapacity, eipmi_sensor:get_unit(6)}},
     {peak_voltage, maybe_value({PeakVA, unit(9)}, unspecified)},
     {inrush_current, maybe_value({InrushCurrent, unit(5)}, unspecified)},
     {inrush_interval, maybe_value({InrushInterval, unit(21)}, unspecified)},
     {low_end_input_voltage_range_110v, {LowEndInputV1 / 100, unit(4)}},
     {high_end_input_voltage_range_110v, {HighEndInputV1 / 100, unit(4)}},
     {low_end_input_voltage_range_220v, {LowEndInputV2 / 100, unit(4)}},
     {high_end_input_voltage_range_220v, {HighEndInputV2 / 100, unit(4)}},
     {low_end_input_frequency_range, {LowEndInputFrequency, unit(19)}},
     {high_end_input_frequency_range, {HighEndInputFrequency, unit(19)}},
     {ac_dropout_tolerance, {ACDropOutTolerance, unit(21)}},
     {predictive_fail_signal,
      get_power_supply_predictive_fail_signal(FailSignal)},
     {hot_swap_supported, eipmi_util:get_bool(HotSwap)},
     {autoswitch_supported, eipmi_util:get_bool(Autoswitch)},
     {power_factor_correction_supported, eipmi_util:get_bool(PowerFactor)},
     {predictive_fail_pin_supported, eipmi_util:get_bool(PredictiveFailSupport)},
     get_predictive_fail_tachometer_lower_threshold(
       PredictiveFailTachometerLowerThreshold),
     {peak_wattage_tolerance, {PeakWattageSecs, unit(22)}},
     {peak_wattage, {PeakWattage, unit(6)}},
     get_combined_wattage(CombinedWattageV1, CombinedWattageV2, TotalWattage)].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_dc_output(<<Standby:1, ?EIPMI_RESERVED:3, OutputNumber:4,
                   NominalVoltage:16/signed-little,
                   MaximumNegativeVoltageDeviation:16/signed-little,
                   MaximumPositiveVoltageDeviation:16/signed-little,
                   RippleAndNoise:16/little,
                   MinimumCurrentDraw:16/little,
                   MaximumCurrentDraw:16/little>>) ->
    [{provides_standby_output, eipmi_util:get_bool(Standby)},
     {output, maybe_value({OutputNumber, number}, unknown)},
     {nominal_voltage, {NominalVoltage / 100, unit(4)}},
     {maximum_negative_voltage_deviation,
      {MaximumNegativeVoltageDeviation / 100, unit(4)}},
     {maximum_positive_voltage_deviation,
      {MaximumPositiveVoltageDeviation / 100, unit(4)}},
     {ripple_and_noise, {RippleAndNoise / 1000, unit(4)}},
     {minimum_current_draw, {MinimumCurrentDraw / 1000, unit(5)}},
     {maximum_current_draw, {MaximumCurrentDraw / 1000, unit(5)}}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_dc_load(<<?EIPMI_RESERVED:4, OutputNumber:4,
                 NominalVoltage:16/signed-little,
                 MinimumVoltage:16/signed-little,
                 MaximumVoltage:16/signed-little,
                 RippleAndNoise:16/little,
                 MinimumCurrentLoad:16/little,
                 MaximumCurrentLoad:16/little>>) ->
    [{output, maybe_value({OutputNumber, number}, unknown)},
     {nominal_voltage, {NominalVoltage / 100, unit(4)}},
     {minimum_voltage, {MinimumVoltage / 100, unit(4)}},
     {maximum_voltage, {MaximumVoltage / 100, unit(4)}},
     {ripple_and_noise, {RippleAndNoise / 1000, unit(4)}},
     {minimum_current_load, {MinimumCurrentLoad / 1000, unit(5)}},
     {maximum_current_load, {MaximumCurrentLoad / 1000, unit(5)}}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_management_access(<<16#01:8, URL/binary>>) ->
    [{system_management_url, eipmi_util:binary_to_string(URL)}];
decode_management_access(<<16#02:8, Name/binary>>) ->
    [{system_name, eipmi_util:binary_to_string(Name)}];
decode_management_access(<<16#03:8, Addr/binary>>) ->
    [{system_ping_address, eipmi_util:binary_to_string(Addr)}];
decode_management_access(<<16#04:8, URL/binary>>) ->
    [{component_management_url, eipmi_util:binary_to_string(URL)}];
decode_management_access(<<16#05:8, Name/binary>>) ->
    [{component_name, eipmi_util:binary_to_string(Name)}];
decode_management_access(<<16#06:8, Addr/binary>>) ->
    [{component_ping_address, eipmi_util:binary_to_string(Addr)}];
decode_management_access(<<16#07:8, Id/binary>>) ->
    [{system_unique_id, eipmi_util:binary_to_string(Id)}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_compatibility(<<ManufacturerID:24/little, EntityID:8,
                       CompatibilityBase:8, ?EIPMI_RESERVED:1,
                       CodeStart:7, CodeRanges/binary>>) ->
    eipmi_sensor:get_entity_id(EntityID)
        ++ [{manufacturer_id, ManufacturerID},
            {compatibility_base, CompatibilityBase},
            {compatible_codes, get_code_ranges(CodeRanges, CodeStart)}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_picmg_record(<<16#19:8, Rest/binary>>) ->
    [{amc_p2p_connectivity, decode_amc_p2p_connectivity_record(Rest)}];
decode_picmg_record(<<16#22:8, Rest/binary>>) ->
    [{mtca_carrier_information, decode_mtca_carrier_information_record(Rest)}];
decode_picmg_record(Data) ->
    [{oem, [{type, 16#c0}, {manufacturer_id, ?PICMG_MID}, {data, Data}]}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_amc_p2p_connectivity_record(
  <<?PICMG_FRU_VERSION:8, GUIDCount:8, Rest/binary>>) ->
    decode_amc_p2p_connectivity_record([], GUIDCount, Rest).
decode_amc_p2p_connectivity_record(Acc, 0, <<Rest/binary>>) ->
    decode_amc_p2p_connectivity_record(Acc, Rest);
decode_amc_p2p_connectivity_record(Acc, C, <<GUID:16/binary, Rest/binary>>) ->
    NewAcc = Acc ++ [{guid, eipmi_util:binary_to_string(GUID)}],
    decode_amc_p2p_connectivity_record(NewAcc, C - 1, Rest).
decode_amc_p2p_connectivity_record(Acc, <<D:1/binary, C:8, Rest/binary>>) ->
    {ChanDescs, NewRest} = get_amc_channel_descriptors(C * 3, Rest),
    LinkDescs = get_amc_link_descs(NewRest),
    Acc ++ get_device(D) ++ ChanDescs ++ LinkDescs.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_mtca_carrier_information_record(
  <<?PICMG_FRU_VERSION:8, C:8, O:1, _:7, Rest/binary>>) ->
    Slots = decode_mtca_carrier_information_record([], Rest),
    case C of 16#ff -> []; _ -> [{carrier_number, C}] end
        ++ get_mtca_orientation(O)
        ++ [{amc_slots, length(get_mtca_slots(amc, Slots))}]
        ++ [{mch_slots, length(get_mtca_slots(mch, Slots))}]
        ++ Slots.
decode_mtca_carrier_information_record(Acc, <<>>) ->
    Acc;
decode_mtca_carrier_information_record(
  Acc, <<SiN:8, SiT:8, SlN:8, TiN:8, Y:16/little, X:16/little, Rest/binary>>) ->
    decode_mtca_carrier_information_record(
      Acc ++ [{slot, eipmi_response:get_picmg_site_type(SiT) ++
                   [{site_number, SiN},
                    {slot_number, SlN},
                    {tier_number, TiN},
                    {x, {X, eipmi_sensor:get_unit(32)}},
                    {y, {Y, eipmi_sensor:get_unit(32)}}]}], Rest).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_code_ranges(Bytes, CodeStart) ->
    lists:sort(get_code_ranges(Bytes, CodeStart, 0, [CodeStart])).
get_code_ranges(<<>>, _CodeStart, _BitIndex, Acc) ->
    lists:reverse(Acc);
get_code_ranges(<<1:1, Rest/bitstring>>, CodeStart, BitIndex, Acc) ->
    NewCode = CodeStart + (((BitIndex div 8) * 8) + ((8 - (BitIndex rem 8)))),
    get_code_ranges(Rest, CodeStart, BitIndex + 1, [NewCode|Acc]);
get_code_ranges(<<0:1, Rest/bitstring>>, CodeStart, BitIndex, Acc) ->
    get_code_ranges(Rest, CodeStart, BitIndex + 1, Acc).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_predictive_fail_tachometer_lower_threshold(0) ->
    {predictive_fail_lower_treshold, none};
get_predictive_fail_tachometer_lower_threshold(Value) ->
    {predictive_fail_lower_treshold, {60 * Value, unit(18)}}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_combined_wattage(0, 0, 0) ->
    {combined_wattage, none};
get_combined_wattage(A, B, Wattage) ->
    {combined_wattage, {get_voltage(A), get_voltage(B), {Wattage, unit(6)}}}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_voltage(0) -> {12, unit(4)};
get_voltage(1) -> {-12, unit(4)};
get_voltage(2) -> {5, unit(4)};
get_voltage(3) -> {3.3, unit(4)}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_power_supply_predictive_fail_signal(0) ->
    one_pulse_per_rotation_or_signal_asserted;
get_power_supply_predictive_fail_signal(1) ->
    two_pulses_per_rotation_or_signal_deasserted.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_device(<<1:1, ?EIPMI_RESERVED:7>>) ->
    [{device_type, amc}];
get_device(<<0:1, ?EIPMI_RESERVED:3, Id:4>>) ->
    [{device_type, on_carrier_device}, {device_id, Id}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_amc_channel_descriptors(Count, Data) ->
    <<D:Count/binary, Rest/binary>> = Data,
    {get_amc_channel_descriptors_(D, []), Rest}.
get_amc_channel_descriptors_(<<>>, Acc) ->
    lists:reverse(Acc);
get_amc_channel_descriptors_(<<Desc:24/little, Rest/binary>>, Acc) ->
    NewAcc = [get_amc_channel_descriptor(<<Desc:24>>) | Acc],
    get_amc_channel_descriptors_(Rest, NewAcc).
get_amc_channel_descriptor(<<?EIPMI_RESERVED:4, L3:5, L2:5, L1:5, L0:5>>) ->
    {amc_channel_descriptor,
     case L0 of 16#1f -> []; _ -> [{lane0_port, L0}] end
     ++ case L1 of 16#1f -> []; _ -> [{lane1_port, L1}] end
     ++ case L2 of 16#1f -> []; _ -> [{lane2_port, L2}] end
     ++ case L3 of 16#1f -> []; _ -> [{lane3_port, L3}] end}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_amc_link_descs(Binary) ->
    get_amc_link_descs(Binary, []).
get_amc_link_descs(<<>>, Acc) ->
    lists:reverse(Acc);
get_amc_link_descs(<<Desc:40/little, Rest/binary>>, Acc) ->
    get_amc_link_descs(Rest, [get_amc_link_desc(<<Desc:40>>) | Acc]).
get_amc_link_desc(<<?EIPMI_RESERVED:8, G:8, LTExt:4, LT:8, Ls:4, Id:8>>) ->
    {amc_link_descriptor,
     [{channel_id, Id}, {group_id, G}]
     ++ get_amc_lanes(Ls) ++ get_link_type(LT, LTExt)}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_amc_lanes(Lanes) ->
    A = case Lanes band 2#1000 bsr 3 of 1 -> [3]; _ -> [] end,
    B = case Lanes band 2#100 bsr 2 of 1 -> [2]; _ -> [] end,
    C = case Lanes band 2#10 bsr 1 of 1 -> [1]; _ -> [] end,
    D = case Lanes band 2#1 of 1 -> [0]; _ -> [] end,
    [{lanes, A ++ B ++ C ++ D}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_link_type(16#02, Ext) -> [{link_type, {pci_express, Ext}}];
get_link_type(16#03, Ext) -> [{link_type, {pci_express_advanced_switching, Ext}}];
get_link_type(16#04, Ext) -> [{link_type, {pci_express_advanced_switching, Ext}}];
get_link_type(16#05, Ext) -> [{link_type, {ethernet, Ext}}];
get_link_type(16#06, Ext) -> [{link_type, {serial_rapid_io, Ext}}];
get_link_type(16#07, Ext) -> [{link_type, {storage, Ext}}];
get_link_type(T, Ext) when T >= 16#f0 andalso T =< 16#fe ->
    [{link_type, {ekeying, Ext}}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_mtca_orientation(0) ->
    [{slot_orientation, left_to_right}, {tier_orientation, bottom_to_top}];
get_mtca_orientation(1) ->
    [{slot_orientation, bottom_to_top}, {tier_orientation, left_to_right}].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_mtca_slots(Type, Slots) ->
    [S || S = {slot, Ps} <- Slots, proplists:get_value(site_type, Ps) =:= Type].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
maybe_value({0, _}, Alternative) -> Alternative;
maybe_value({16#ffff, _}, Alternative) -> Alternative;
maybe_value({16#ff, _}, Alternative) -> Alternative;
maybe_value(Value, _) -> Value.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
get_area(0, _NextOffsets, _FruData) ->
    <<>>;
get_area(Offset, [], FruData) ->
    SkipSize = Offset * 8,
    <<_:SkipSize/binary, Area/binary>> = FruData,
    Area;
get_area(Offset, [NextOffset | _], FruData) ->
    SkipSize = Offset * 8,
    Size = NextOffset * 8 - SkipSize,
    <<_:SkipSize/binary, Area:Size/binary, _/binary>> = FruData,
    Area.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_fields(Name, Lang, Data) ->
    decode_fields(Name, Lang, Data, []).
decode_fields(_Name, _Lang, <<?EOFIELDS:8, _/binary>>, Acc) ->
    lists:reverse(Acc);
decode_fields(Name, Lang, Data, Acc) ->
    {Field, Rest} = decode_field(Name, Lang, Data),
    decode_fields(Name, Lang, Rest, [Field | Acc]).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
decode_field(_Name, _Lang, <<_:2, 0:6, Rest/binary>>) ->
    {[], Rest};
decode_field(Name, _Lang, <<0:2, Len:6, Data:Len/binary, Rest/binary>>) ->
    {[{Name, Data}], Rest};
decode_field(Name, _Lang, <<1:2, Len:6, Data:Len/binary, Rest/binary>>) ->
    {[{Name, eipmi_util:from_bcd_plus(Data)}], Rest};
decode_field(Name, _Lang, <<2:2, Len:6, Data:Len/binary, Rest/binary>>) ->
    {[{Name, eipmi_util:from_packed_ascii(Data)}], Rest};
decode_field(Name, Lang, <<3:2, Len:6, Data:Len/binary, Rest/binary>>)
  when Lang =:= ?ENGLISH orelse Lang =:= ?OLD_ENGLISH ->
    {[{Name, eipmi_util:binary_to_string(Data)}], Rest};
decode_field(Name, _Lang, <<3:2, _Len:6, Data/utf16-little, Rest/binary>>) ->
    {[{Name, Data}], Rest};
%% This clause supports broken custom fields that deliver bullshit in their
%% length field. But note, at least the END-OF-FIELDS indicator must be present.
decode_field(Name, _Lang, <<_Broken:8, Complete/binary>>) ->
    {Data, Rest} = until_eofields(Complete),
    {[{Name, Data}], Rest}.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
until_eofields(Data) ->
    until_eofields(Data, <<>>).
until_eofields(Rest = <<?EOFIELDS:8, _/binary>>, Acc) ->
    {Acc, Rest};
until_eofields(<<Byte:8, Rest/binary>>, Acc) ->
    until_eofields(Rest, <<Acc/binary, Byte:8>>).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
non_zero(List) -> [Elem || Elem <- List, Elem > 0].

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
is_header_sane(<<Header:8/binary, _/binary>>) -> is_binary_sane(Header).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
is_binary_sane(Binary) -> sum(Binary, 0) =:= 0.

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
sum(<<>>, Sum)                    -> Sum rem 256;
sum(<<Byte:8, Rest/binary>>, Sum) -> sum(Rest, Sum + Byte).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
unit(Unit) -> eipmi_sensor:get_unit(Unit).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
to_list_chassis([]) -> "Chassis Info Area      : -";
to_list_chassis(Area) ->
    Type = proplists:get_value(type, Area, "-"),
    Part = proplists:get_value(part_number, Area, "-"),
    Serial = proplists:get_value(serial_number, Area, "-"),
    eipmi_util:join_nl(
      ["Chassis Info Area",
       "Chassis Type           : " ++ eipmi_util:format("~p", [Type]),
       "Chassis Part Number    : " ++ Part,
       "Chassis Serial Number  : " ++ Serial]).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
to_list_board([]) -> "Board Info Area        : -";
to_list_board(Area) ->
    Manufacturer = proplists:get_value(manufacturer, Area, "-"),
    Name = proplists:get_value(name, Area, "-"),
    Serial = proplists:get_value(serial_number, Area, "-"),
    Part = proplists:get_value(part_number, Area, "-"),
    File = proplists:get_value(fru_file_id, Area, "-"),
    eipmi_util:join_nl(
      ["Board Info Area",
       "Manufacturer           : " ++ Manufacturer,
       "Board Name             : " ++ Name,
       "Serial Number          : " ++ Serial,
       "Part Number            : " ++ Part,
       "FRU file ID            : " ++ File]).

%%------------------------------------------------------------------------------
%% @private
%%------------------------------------------------------------------------------
to_list_product([]) -> "Product Info Area      : -";
to_list_product(Area) ->
    Manufacturer = proplists:get_value(manufacturer, Area, "-"),
    Name = proplists:get_value(name, Area, "-"),
    Serial = proplists:get_value(serial_number, Area, "-"),
    Part = proplists:get_value(part_number, Area, "-"),
    File = proplists:get_value(fru_file_id, Area, "-"),
    Version = proplists:get_value(version, Area, "-"),
    Tag = proplists:get_value(asset_tag, Area, "-"),
    eipmi_util:join_nl(
      ["Product Info Area",
       "Manufacturer           : " ++ Manufacturer,
       "Product Name           : " ++ Name,
       "Product Number         : " ++ Part,
       "Part Version           : " ++ Version,
       "Product Serial Number  : " ++ Serial,
       "Asset Tag              : " ++ Tag,
       "FRU file ID            : " ++ File]).