1 #pragma once 2 3 #include <experimental/filesystem> 4 #include <string> 5 #include <vector> 6 7 namespace witherspoon 8 { 9 namespace pmbus 10 { 11 12 namespace fs = std::experimental::filesystem; 13 14 // The file name Linux uses to capture the STATUS_WORD from pmbus. 15 constexpr auto STATUS_WORD = "status0"; 16 17 // The file name Linux uses to capture the STATUS_INPUT from pmbus. 18 constexpr auto STATUS_INPUT = "status0_input"; 19 20 // Voltage out status. 21 // Overvoltage fault or warning, Undervoltage fault or warning, maximum or 22 // minimum warning, .... 23 // Uses Page substitution 24 constexpr auto STATUS_VOUT = "statusP_vout"; 25 26 namespace status_vout 27 { 28 // Mask of bits that are only warnings 29 constexpr auto WARNING_MASK = 0x6A; 30 } 31 32 // Current output status bits. 33 constexpr auto STATUS_IOUT = "status0_iout"; 34 35 // Manufacturing specific status bits 36 constexpr auto STATUS_MFR = "status0_mfr"; 37 38 // Reports on the status of any fans installed in position 1 and 2. 39 constexpr auto STATUS_FANS_1_2 = "status0_fans12"; 40 41 // Reports on temperature faults or warnings. Overtemperature fault, 42 // overtemperature warning, undertemperature warning, undertemperature fault. 43 constexpr auto STATUS_TEMPERATURE = "status0_temp"; 44 45 namespace status_word 46 { 47 constexpr auto VOUT_FAULT = 0x8000; 48 49 // The IBM CFF power supply driver does map this bit to power1_alarm in the 50 // hwmon space, but since the other bits that need to be checked do not have 51 // a similar mapping, the code will just read STATUS_WORD and use bit masking 52 // to see if the INPUT FAULT OR WARNING bit is on. 53 constexpr auto INPUT_FAULT_WARN = 0x2000; 54 55 // The bit mask representing the POWER_GOOD Negated bit of the STATUS_WORD. 56 constexpr auto POWER_GOOD_NEGATED = 0x0800; 57 58 // The bit mask representing the FAN FAULT or WARNING bit of the STATUS_WORD. 59 // Bit 2 of the high byte of STATUS_WORD. 60 constexpr auto FAN_FAULT = 0x0400; 61 62 // The bit mask representing the UNITI_IS_OFF bit of the STATUS_WORD. 63 constexpr auto UNIT_IS_OFF = 0x0040; 64 65 // Bit 5 of the STATUS_BYTE, or lower byte of STATUS_WORD is used to indicate 66 // an output overvoltage fault. 67 constexpr auto VOUT_OV_FAULT = 0x0020; 68 69 // The bit mask representing that an output overcurrent fault has occurred. 70 constexpr auto IOUT_OC_FAULT = 0x0010; 71 72 // The IBM CFF power supply driver does map this bit to in1_alarm, however, 73 // since a number of the other bits are not mapped that way for STATUS_WORD, 74 // this code will just read the entire STATUS_WORD and use bit masking to find 75 // out if that fault is on. 76 constexpr auto VIN_UV_FAULT = 0x0008; 77 78 // The bit mask representing the TEMPERATURE FAULT or WARNING bit of the 79 // STATUS_WORD. Bit 2 of the low byte (STATUS_BYTE). 80 constexpr auto TEMPERATURE_FAULT_WARN = 0x0004; 81 82 } 83 84 namespace status_temperature 85 { 86 // Overtemperature Fault 87 constexpr auto OT_FAULT = 0x80; 88 } 89 90 /** 91 * Where the access should be done 92 */ 93 enum class Type 94 { 95 Base, // base device directory 96 Hwmon, // hwmon directory 97 Debug, // pmbus debug directory 98 DeviceDebug, // device debug directory 99 HwmonDeviceDebug // hwmon device debug directory 100 }; 101 102 /** 103 * @class PMBus 104 * 105 * This class is an interface to communicating with PMBus devices 106 * by reading and writing sysfs files. 107 * 108 * Based on the Type parameter, the accesses can either be done 109 * in the base device directory (the one passed into the constructor), 110 * or in the hwmon directory for the device. 111 */ 112 class PMBus 113 { 114 public: 115 116 PMBus() = delete; 117 ~PMBus() = default; 118 PMBus(const PMBus&) = default; 119 PMBus& operator=(const PMBus&) = default; 120 PMBus(PMBus&&) = default; 121 PMBus& operator=(PMBus&&) = default; 122 123 /** 124 * Constructor 125 * 126 * @param[in] path - path to the sysfs directory 127 */ 128 PMBus(const std::string& path) : 129 basePath(path) 130 { 131 findHwmonDir(); 132 } 133 134 /** 135 * Constructor 136 * 137 * This version is required when DeviceDebug 138 * access will be used. 139 * 140 * @param[in] path - path to the sysfs directory 141 * @param[in] driverName - the device driver name 142 * @param[in] instance - chip instance number 143 */ 144 PMBus(const std::string& path, 145 const std::string& driverName, 146 size_t instance) : 147 basePath(path), 148 driverName(driverName), 149 instance(instance) 150 { 151 findHwmonDir(); 152 } 153 154 /** 155 * Reads a file in sysfs that represents a single bit, 156 * therefore doing a PMBus read. 157 * 158 * @param[in] name - path concatenated to 159 * basePath to read 160 * @param[in] type - Path type 161 * 162 * @return bool - false if result was 0, else true 163 */ 164 bool readBit(const std::string& name, Type type); 165 166 /** 167 * Reads a file in sysfs that represents a single bit, 168 * where the page number passed in is substituted 169 * into the name in place of the 'P' character in it. 170 * 171 * @param[in] name - path concatenated to 172 * basePath to read 173 * @param[in] page - page number 174 * @param[in] type - Path type 175 * 176 * @return bool - false if result was 0, else true 177 */ 178 bool readBitInPage(const std::string& name, 179 size_t page, 180 Type type); 181 /** 182 * Checks if the file for the given name and type exists. 183 * 184 * @param[in] name - path concatenated to basePath to read 185 * @param[in] type - Path type 186 * 187 * @return bool - True if file exists, false if it does not. 188 */ 189 bool exists(const std::string& name, Type type); 190 191 /** 192 * Read byte(s) from file in sysfs. 193 * 194 * @param[in] name - path concatenated to basePath to read 195 * @param[in] type - Path type 196 * 197 * @return uint64_t - Up to 8 bytes of data read from file. 198 */ 199 uint64_t read(const std::string& name, Type type); 200 201 /** 202 * Writes an integer value to the file, therefore doing 203 * a PMBus write. 204 * 205 * @param[in] name - path concatenated to 206 * basePath to write 207 * @param[in] value - the value to write 208 * @param[in] type - Path type 209 */ 210 void write(const std::string& name, int value, Type type); 211 212 /** 213 * Returns the sysfs base path of this device 214 */ 215 inline const auto& path() const 216 { 217 return basePath; 218 } 219 220 /** 221 * Replaces the 'P' in the string passed in with 222 * the page number passed in. 223 * 224 * For example: 225 * insertPageNum("inP_enable", 42) 226 * returns "in42_enable" 227 * 228 * @param[in] templateName - the name string, with a 'P' in it 229 * @param[in] page - the page number to insert where the P was 230 * 231 * @return string - the new string with the page number in it 232 */ 233 static std::string insertPageNum(const std::string& templateName, 234 size_t page); 235 236 /** 237 * Finds the path relative to basePath to the hwmon directory 238 * for the device and stores it in hwmonRelPath. 239 */ 240 void findHwmonDir(); 241 242 /** 243 * Returns the path to use for the passed in type. 244 * 245 * @param[in] type - Path type 246 * 247 * @return fs::path - the full path 248 */ 249 fs::path getPath(Type type); 250 251 private: 252 253 /** 254 * Returns the device name 255 * 256 * This is found in the 'name' file in basePath. 257 * 258 * @return string - the device name 259 */ 260 std::string getDeviceName(); 261 262 /** 263 * The sysfs device path 264 */ 265 fs::path basePath; 266 267 /** 268 * The directory name under the basePath hwmon directory 269 */ 270 fs::path hwmonDir; 271 272 /** 273 * The device driver name. Used for finding the device 274 * debug directory. Not required if that directory 275 * isn't used. 276 */ 277 std::string driverName; 278 279 /** 280 * The device instance number. 281 * 282 * Used in conjuction with the driver name for finding 283 * the debug directory. Not required if that directory 284 * isn't used. 285 */ 286 size_t instance = 0; 287 288 /** 289 * The pmbus debug path with status files 290 */ 291 const fs::path debugPath = "/sys/kernel/debug/"; 292 293 }; 294 295 } 296 } 297