1 // Copyright 2023 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //      http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #pragma once
16 
17 #include "bifurcation.hpp"
18 #include "file_system_wrapper_impl.hpp"
19 #include "handler.hpp"
20 
21 #include <nlohmann/json.hpp>
22 #include <sdbusplus/bus.hpp>
23 
24 #include <cstdint>
25 #include <map>
26 #include <memory>
27 #include <string>
28 #include <string_view>
29 #include <tuple>
30 #include <vector>
31 
32 namespace google
33 {
34 namespace ipmi
35 {
36 
37 constexpr char defaultConfigFile[] =
38     "/usr/share/ipmi-entity-association/entity_association_map.json";
39 
40 class Handler : public HandlerInterface
41 {
42   public:
Handler(const std::string & entityConfigPath=defaultConfigFile)43     explicit Handler(const std::string& entityConfigPath = defaultConfigFile) :
44         fsPtr(std::make_unique<FileSystemWrapper>()),
45         _configFile(entityConfigPath),
46         bifurcationHelper(BifurcationStatic::createBifurcation()) {};
Handler(std::reference_wrapper<BifurcationInterface> bifurcationHelper,const std::string & entityConfigPath=defaultConfigFile)47     Handler(std::reference_wrapper<BifurcationInterface> bifurcationHelper,
48             const std::string& entityConfigPath = defaultConfigFile) :
49         fsPtr(std::make_unique<FileSystemWrapper>()),
50         _configFile(entityConfigPath), bifurcationHelper(bifurcationHelper) {};
51     ~Handler() = default;
52 
53     uint8_t getBmcMode() override;
54     std::tuple<std::uint8_t, std::string>
55         getEthDetails(std::string intf) const override;
56     std::int64_t getRxPackets(const std::string& name) const override;
57     VersionTuple getCpldVersion(unsigned int id) const override;
58     void psuResetDelay(std::uint32_t delay) const override;
59     void psuResetOnShutdown() const override;
60     std::string getEntityName(std::uint8_t id, std::uint8_t instance) override;
61     uint32_t getFlashSize() override;
62     std::string getMachineName() override;
63     void buildI2cPcieMapping() override;
64     size_t getI2cPcieMappingSize() const override;
65     void hostPowerOffDelay(std::uint32_t delay) const override;
66     std::tuple<std::uint32_t, std::string>
67         getI2cEntry(unsigned int entry) const override;
68     std::vector<uint8_t> pcieBifurcation(uint8_t) override;
69 
70     uint32_t accelOobDeviceCount() const override;
71     std::string accelOobDeviceName(size_t index) const override;
72     uint64_t accelOobRead(std::string_view name, uint64_t address,
73                           uint8_t num_bytes) const override;
74     void accelOobWrite(std::string_view name, uint64_t address,
75                        uint8_t num_bytes, uint64_t data) const override;
76     void linuxBootDone() const override;
77     void accelSetVrSettings(::ipmi::Context::ptr ctx, uint8_t chip_id,
78                             uint8_t settings_id, uint16_t value) const override;
79     uint16_t accelGetVrSettings(::ipmi::Context::ptr ctx, uint8_t chip_id,
80                                 uint8_t settings_id) const override;
81     std::string getBMInstanceProperty(uint8_t propertyType) const override;
82 
83   protected:
84     // Exposed for dependency injection
85     virtual sdbusplus::bus_t getDbus() const;
86     virtual const std::unique_ptr<FileSystemInterface>& getFs() const;
87 
88   private:
89     std::unique_ptr<FileSystemInterface> fsPtr;
90 
91     std::string _configFile;
92 
93     bool _entityConfigParsed = false;
94 
95     const std::map<uint8_t, std::string> _entityIdToName{
96         {0x03, "cpu"},
97         {0x04, "storage_device"},
98         {0x06, "system_management_module"},
99         {0x07, "system_board"},
100         {0x08, "memory_module"},
101         {0x0B, "add_in_card"},
102         {0x0E, "power_system_board"},
103         {0x10, "system_internal_expansion_board"},
104         {0x11, "other_system_board"},
105         {0x17, "system_chassis"},
106         {0x1D, "fan"},
107         {0x1E, "cooling_unit"},
108         {0x20, "memory_device"}};
109 
110     const std::unordered_map<uint8_t, std::string> _vrSettingsMap{
111         {0, "idle_mode_"}, {1, "power_brake_"}, {2, "loadline_"}};
112 
113     const std::unordered_map<uint8_t, std::string> bmInstanceTypeStringMap = {
114         {0x00, "asset-tag"}, {0x01, "board-serial-number"},
115         {0x02, "family"},    {0x03, "product-name"},
116         {0x04, "sku"},       {0x05, "system-serial-number"},
117         {0x06, "uuid"}};
118 
119     nlohmann::json _entityConfig{};
120 
121     std::vector<std::tuple<uint32_t, std::string>> _pcie_i2c_map;
122 
123     std::reference_wrapper<BifurcationInterface> bifurcationHelper;
124 };
125 
126 /**
127  * Given a type, entity instance, and a configuration, return the name.
128  *
129  * @param[in] type - the entity type
130  * @param[in] instance - the entity instance
131  * @param[in] config - the json object holding the entity mapping
132  * @return the name of the entity from the map
133  */
134 std::string readNameFromConfig(const std::string& type, uint8_t instance,
135                                const nlohmann::json& config);
136 
137 } // namespace ipmi
138 } // namespace google
139