xref: /openbmc/google-ipmi-sys/handler_impl.hpp (revision 8c0094e4eb82029af1d111d2736111cbdda59b63)
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