1 /** 2 * Copyright © 2020 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 #include "chassis.hpp" 19 #include "id_map.hpp" 20 #include "rule.hpp" 21 #include "services.hpp" 22 23 #include <memory> 24 #include <utility> 25 #include <vector> 26 27 namespace phosphor::power::regulators 28 { 29 30 /** 31 * @class System 32 * 33 * The computer system being controlled and monitored by the BMC. 34 * 35 * The system contains one or more chassis. Chassis are large enclosures that 36 * can be independently powered off and on by the BMC. 37 */ 38 class System 39 { 40 public: 41 // Specify which compiler-generated methods we want 42 System() = delete; 43 System(const System&) = delete; 44 System(System&&) = delete; 45 System& operator=(const System&) = delete; 46 System& operator=(System&&) = delete; 47 ~System() = default; 48 49 /** 50 * Constructor. 51 * 52 * @param rules rules used to monitor and control regulators in the system 53 * @param chassis chassis in the system 54 */ System(std::vector<std::unique_ptr<Rule>> rules,std::vector<std::unique_ptr<Chassis>> chassis)55 explicit System(std::vector<std::unique_ptr<Rule>> rules, 56 std::vector<std::unique_ptr<Chassis>> chassis) : 57 rules{std::move(rules)}, chassis{std::move(chassis)} 58 { 59 buildIDMap(); 60 } 61 62 /** 63 * Clear any cached data about hardware devices. 64 */ 65 void clearCache(); 66 67 /** 68 * Clears all error history. 69 * 70 * All data on previously logged errors will be deleted. If errors occur 71 * again in the future they will be logged again. 72 * 73 * This method is normally called when the system is being powered on. 74 */ 75 void clearErrorHistory(); 76 77 /** 78 * Close the regulator devices in the system. 79 * 80 * @param services system services like error logging and the journal 81 */ 82 void closeDevices(Services& services); 83 84 /** 85 * Configure the regulator devices in the system. 86 * 87 * This method should be called during the boot before regulators are 88 * enabled. 89 * 90 * @param services system services like error logging and the journal 91 */ 92 void configure(Services& services); 93 94 /** 95 * Detect redundant phase faults in regulator devices in the system. 96 * 97 * This method should be called repeatedly based on a timer. 98 * 99 * @param services system services like error logging and the journal 100 */ 101 void detectPhaseFaults(Services& services); 102 103 /** 104 * Returns the chassis in the system. 105 * 106 * @return chassis 107 */ getChassis() const108 const std::vector<std::unique_ptr<Chassis>>& getChassis() const 109 { 110 return chassis; 111 } 112 113 /** 114 * Returns the IDMap for the system. 115 * 116 * The IDMap provides a mapping from string IDs to the associated Device, 117 * Rail, and Rule objects. 118 * 119 * @return IDMap 120 */ getIDMap() const121 const IDMap& getIDMap() const 122 { 123 return idMap; 124 } 125 126 /** 127 * Returns the rules used to monitor and control regulators in the system. 128 * 129 * @return rules 130 */ getRules() const131 const std::vector<std::unique_ptr<Rule>>& getRules() const 132 { 133 return rules; 134 } 135 136 /** 137 * Monitors the sensors for the voltage rails produced by this system, if 138 * any. 139 * 140 * This method should be called repeatedly based on a timer. 141 * 142 * @param services system services like error logging and the journal 143 */ 144 void monitorSensors(Services& services); 145 146 private: 147 /** 148 * Builds the IDMap for the system. 149 * 150 * Adds the Device, Rail, and Rule objects in the system to the map. 151 */ 152 void buildIDMap(); 153 154 /** 155 * Rules used to monitor and control regulators in the system. 156 */ 157 std::vector<std::unique_ptr<Rule>> rules{}; 158 159 /** 160 * Chassis in the system. 161 */ 162 std::vector<std::unique_ptr<Chassis>> chassis{}; 163 164 /** 165 * Mapping from string IDs to the associated Device, Rail, and Rule objects. 166 */ 167 IDMap idMap{}; 168 }; 169 170 } // namespace phosphor::power::regulators 171