1 /**
2  * Copyright © 2019 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 "configuration.hpp"
19 #include "sensor_monitoring.hpp"
20 #include "services.hpp"
21 
22 #include <memory>
23 #include <string>
24 #include <utility>
25 
26 namespace phosphor::power::regulators
27 {
28 
29 // Forward declarations to avoid circular dependencies
30 class Chassis;
31 class Device;
32 class System;
33 
34 /**
35  * @class Rail
36  *
37  * A voltage rail produced by a voltage regulator.
38  *
39  * Voltage regulators produce one or more rails.  Each rail typically provides a
40  * different output voltage level, such as 1.1V.
41  */
42 class Rail
43 {
44   public:
45     // Specify which compiler-generated methods we want
46     Rail() = delete;
47     Rail(const Rail&) = delete;
48     Rail(Rail&&) = delete;
49     Rail& operator=(const Rail&) = delete;
50     Rail& operator=(Rail&&) = delete;
51     ~Rail() = default;
52 
53     /**
54      * Constructor.
55      *
56      * @param id unique rail ID
57      * @param configuration configuration changes to apply to this rail, if any
58      * @param sensorMonitoring sensor monitoring for this rail, if any
59      */
Rail(const std::string & id,std::unique_ptr<Configuration> configuration=nullptr,std::unique_ptr<SensorMonitoring> sensorMonitoring=nullptr)60     explicit Rail(
61         const std::string& id,
62         std::unique_ptr<Configuration> configuration = nullptr,
63         std::unique_ptr<SensorMonitoring> sensorMonitoring = nullptr) :
64         id{id}, configuration{std::move(configuration)},
65         sensorMonitoring{std::move(sensorMonitoring)}
66     {}
67 
68     /**
69      * Clears all error history.
70      *
71      * All data on previously logged errors will be deleted.  If errors occur
72      * again in the future they will be logged again.
73      *
74      * This method is normally called when the system is being powered on.
75      */
76     void clearErrorHistory();
77 
78     /**
79      * Configure this rail.
80      *
81      * Applies the configuration changes that are defined for this rail, if any.
82      *
83      * This method should be called during the boot before regulators are
84      * enabled.
85      *
86      * @param services system services like error logging and the journal
87      * @param system system that contains the chassis
88      * @param chassis chassis that contains the device
89      * @param device device that contains this rail
90      */
91     void configure(Services& services, System& system, Chassis& chassis,
92                    Device& device);
93 
94     /**
95      * Returns the configuration changes to apply to this rail, if any.
96      *
97      * @return Pointer to Configuration object.  Will equal nullptr if no
98      *         configuration changes are defined for this rail.
99      */
getConfiguration() const100     const std::unique_ptr<Configuration>& getConfiguration() const
101     {
102         return configuration;
103     }
104 
105     /**
106      * Returns the unique ID of this rail.
107      *
108      * @return rail ID
109      */
getID() const110     const std::string& getID() const
111     {
112         return id;
113     }
114 
115     /**
116      * Monitor the sensors for this rail.
117      *
118      * Sensor monitoring is optional.  If sensor monitoring is defined for this
119      * rail, the sensor values are read.
120      *
121      * This method should be called repeatedly based on a timer.
122      *
123      * @param services system services like error logging and the journal
124      * @param system system that contains the chassis
125      * @param chassis chassis that contains the device
126      * @param device device that contains this rail
127      */
128     void monitorSensors(Services& services, System& system, Chassis& chassis,
129                         Device& device);
130 
131     /**
132      * Returns the sensor monitoring for this rail, if any.
133      *
134      * @return Pointer to SensorMonitoring object.  Will equal nullptr if no
135      *         sensor monitoring is defined for this rail.
136      */
getSensorMonitoring() const137     const std::unique_ptr<SensorMonitoring>& getSensorMonitoring() const
138     {
139         return sensorMonitoring;
140     }
141 
142   private:
143     /**
144      * Unique ID of this rail.
145      */
146     const std::string id{};
147 
148     /**
149      * Configuration changes to apply to this rail, if any.  Set to nullptr if
150      * no configuration changes are defined for this rail.
151      */
152     std::unique_ptr<Configuration> configuration{};
153 
154     /**
155      * Sensor monitoring for this rail, if any.  Set to nullptr if no sensor
156      * monitoring is defined for this rail.
157      */
158     std::unique_ptr<SensorMonitoring> sensorMonitoring{};
159 };
160 
161 } // namespace phosphor::power::regulators
162