1 /* 2 // Copyright (c) 2018 Intel 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 #include <ipmid/api.h> 18 19 #include <string> 20 21 namespace ipmi 22 { 23 24 static constexpr uint8_t maxIpmiChannels = 16; 25 static constexpr uint8_t currentChNum = 0xE; 26 static constexpr uint8_t invalidChannel = 0xff; 27 28 /** 29 * @enum IPMI return codes specific to channel (refer spec se 22.22 response 30 * data) 31 */ 32 enum ipmi_channel_return_codes 33 { 34 IPMI_CC_ACTION_NOT_SUPPORTED_FOR_CHANNEL = 0x82, 35 IPMI_CC_ACCESS_MODE_NOT_SUPPORTED_FOR_CHANEL = 0x83 36 }; 37 38 /** 39 * @enum Channel Protocol Type (refer spec sec 6.4) 40 */ 41 enum class EChannelProtocolType : uint8_t 42 { 43 na = 0x00, 44 ipmbV10 = 0x01, 45 icmbV11 = 0x02, 46 reserved = 0x03, 47 ipmiSmbus = 0x04, 48 kcs = 0x05, 49 smic = 0x06, 50 bt10 = 0x07, 51 bt15 = 0x08, 52 tMode = 0x09, 53 oem = 0x1C, 54 }; 55 56 /** 57 * @enum Channel Medium Type (refer spec sec 6.5) 58 */ 59 enum class EChannelMediumType : uint8_t 60 { 61 reserved = 0x00, 62 ipmb = 0x01, 63 icmbV10 = 0x02, 64 icmbV09 = 0x03, 65 lan8032 = 0x04, 66 serial = 0x05, 67 otherLan = 0x06, 68 pciSmbus = 0x07, 69 smbusV11 = 0x08, 70 smbusV20 = 0x09, 71 usbV1x = 0x0A, 72 usbV2x = 0x0B, 73 systemInterface = 0x0C, 74 oem = 0x60, 75 unknown = 0x82, 76 }; 77 78 /** 79 * @enum Channel Session Type (refer spec sec 22.24 - 80 * response data byte 5) 81 */ 82 enum class EChannelSessSupported : uint8_t 83 { 84 none = 0, 85 single = 1, 86 multi = 2, 87 any = 3, 88 }; 89 90 /** 91 * @enum Channel Access Mode (refer spec sec 6.6) 92 */ 93 enum class EChannelAccessMode : uint8_t 94 { 95 disabled = 0, 96 preboot = 1, 97 alwaysAvail = 2, 98 shared = 3, 99 }; 100 101 /** 102 * @enum Authentication Types (refer spec sec 13.6 - IPMI 103 * Session Header) 104 */ 105 enum class EAuthType : uint8_t 106 { 107 none = (1 << 0x0), 108 md2 = (1 << 0x1), 109 md5 = (1 << 0x2), 110 reserved = (1 << 0x3), 111 straightPasswd = (1 << 0x4), 112 oem = (1 << 0x5), 113 }; 114 115 // TODO: Remove duplicate 'PayloadType' definition from netipmid's message.hpp 116 // to phosphor-ipmi-host/include 117 /** 118 * @enum Payload Types (refer spec sec 13.27.3) 119 */ 120 enum class PayloadType : uint8_t 121 { 122 IPMI = 0x00, 123 SOL = 0x01, 124 OPEN_SESSION_REQUEST = 0x10, 125 OPEN_SESSION_RESPONSE = 0x11, 126 RAKP1 = 0x12, 127 RAKP2 = 0x13, 128 RAKP3 = 0x14, 129 RAKP4 = 0x15, 130 INVALID = 0xFF, 131 }; 132 133 /** 134 * @enum Access mode for channel access set/get (refer spec 135 * sec 22.22 - request byte 2[7:6]) 136 */ 137 typedef enum 138 { 139 doNotSet = 0x00, 140 nvData = 0x01, 141 activeData = 0x02, 142 reserved = 0x03, 143 } EChannelActionType; 144 145 /** 146 * @enum Access set flag to determine changes that has to be updated 147 * in channel access data configuration. 148 */ 149 enum AccessSetFlag 150 { 151 setAccessMode = (1 << 0), 152 setUserAuthEnabled = (1 << 1), 153 setMsgAuthEnabled = (1 << 2), 154 setAlertingEnabled = (1 << 3), 155 setPrivLimit = (1 << 4), 156 }; 157 158 /** @struct ChannelAccess 159 * 160 * Structure to store channel access related information, defined in IPMI 161 * specification and used in Get / Set channel access (refer spec sec 22.22 162 * & 22.23) 163 */ 164 struct ChannelAccess 165 { 166 uint8_t accessMode; 167 bool userAuthDisabled; 168 bool perMsgAuthDisabled; 169 bool alertingDisabled; 170 uint8_t privLimit; 171 }; 172 173 /** @struct ChannelInfo 174 * 175 * Structure to store data about channel information, which identifies each 176 * channel type and information as defined in IPMI specification. (refer spec 177 * sec 22.22 & 22.23) 178 */ 179 struct ChannelInfo 180 { 181 uint8_t mediumType; 182 uint8_t protocolType; 183 uint8_t sessionSupported; 184 bool isIpmi; // Is session IPMI 185 // This is used in Get LAN Configuration parameter. 186 // This holds the supported AuthTypes for a given channel. 187 uint8_t authTypeSupported; 188 }; 189 190 /** @brief determines valid channel 191 * 192 * @param[in] chNum- channel number 193 * 194 * @return true if valid, false otherwise 195 */ 196 bool isValidChannel(const uint8_t chNum); 197 198 /** @brief determines whether channel device exist 199 * 200 * @param[in] chNum - channel number 201 * 202 * @return true if valid, false otherwise 203 */ 204 bool doesDeviceExist(const uint8_t chNum); 205 206 /** @brief determines whether privilege limit is valid 207 * 208 * @param[in] privLimit - Privilege limit 209 * 210 * @return true if valid, false otherwise 211 */ 212 bool isValidPrivLimit(const uint8_t privLimit); 213 214 /** @brief determines whether access mode is valid 215 * 216 * @param[in] accessMode - Access mode 217 * 218 * @return true if valid, false otherwise 219 */ 220 bool isValidAccessMode(const uint8_t accessMode); 221 222 /** @brief determines valid authentication type based on channel number 223 * 224 * @param[in] chNum - channel number 225 * @param[in] authType - authentication type 226 * 227 * @return true if valid, false otherwise 228 */ 229 bool isValidAuthType(const uint8_t chNum, const EAuthType& authType); 230 231 /** @brief determines supported session type of a channel 232 * 233 * @param[in] chNum - channel number 234 * 235 * @return EChannelSessSupported - supported session type 236 */ 237 EChannelSessSupported getChannelSessionSupport(const uint8_t chNum); 238 239 /** @brief determines number of active sessions on a channel 240 * 241 * @param[in] chNum - channel number 242 * 243 * @return numer of active sessions 244 */ 245 int getChannelActiveSessions(const uint8_t chNum); 246 247 /** @brief determines maximum transfer size for a channel 248 * 249 * @param[in] chNum - channel number 250 * 251 * @return maximum bytes that can be transferred on this channel 252 */ 253 size_t getChannelMaxTransferSize(uint8_t chNum); 254 255 /** @brief initializes channel management 256 * 257 * @return IPMI_CC_OK for success, others for failure. 258 */ 259 ipmi_ret_t ipmiChannelInit(); 260 261 /** @brief provides channel info details 262 * 263 * @param[in] chNum - channel number 264 * @param[out] chInfo - channel info details 265 * 266 * @return IPMI_CC_OK for success, others for failure. 267 */ 268 ipmi_ret_t getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo); 269 270 /** @brief provides channel access data 271 * 272 * @param[in] chNum - channel number 273 * @param[out] chAccessData -channel access data 274 * 275 * @return IPMI_CC_OK for success, others for failure. 276 */ 277 ipmi_ret_t getChannelAccessData(const uint8_t chNum, 278 ChannelAccess& chAccessData); 279 280 /** @brief provides function to convert current channel number (0xE) 281 * 282 * @param[in] chNum - channel number as requested in commands. 283 * @param[in] devChannel - channel number as provided by device (not 0xE) 284 * 285 * @return same channel number or proper channel number for current channel 286 * number (0xE). 287 */ 288 static inline uint8_t convertCurrentChannelNum(const uint8_t chNum, 289 const uint8_t devChannel) 290 { 291 if (chNum == currentChNum) 292 { 293 return devChannel; 294 } 295 return chNum; 296 } 297 298 /** @brief to set channel access data 299 * 300 * @param[in] chNum - channel number 301 * @param[in] chAccessData - channel access data 302 * @param[in] setFlag - flag to indicate updatable fields 303 * 304 * @return IPMI_CC_OK for success, others for failure. 305 */ 306 ipmi_ret_t setChannelAccessData(const uint8_t chNum, 307 const ChannelAccess& chAccessData, 308 const uint8_t setFlag); 309 310 /** @brief to get channel access data persistent data 311 * 312 * @param[in] chNum - channel number 313 * @param[out] chAccessData - channel access data 314 * 315 * @return IPMI_CC_OK for success, others for failure. 316 */ 317 ipmi_ret_t getChannelAccessPersistData(const uint8_t chNum, 318 ChannelAccess& chAccessData); 319 320 /** @brief to set channel access data persistent data 321 * 322 * @param[in] chNum - channel number 323 * @param[in] chAccessData - channel access data 324 * @param[in] setFlag - flag to indicate updatable fields 325 * 326 * @return IPMI_CC_OK for success, others for failure. 327 */ 328 ipmi_ret_t setChannelAccessPersistData(const uint8_t chNum, 329 const ChannelAccess& chAccessData, 330 const uint8_t setFlag); 331 332 /** @brief provides supported authentication type for the channel 333 * 334 * @param[in] chNum - channel number 335 * @param[out] authTypeSupported - supported authentication type 336 * 337 * @return IPMI_CC_OK for success, others for failure. 338 */ 339 ipmi_ret_t getChannelAuthTypeSupported(const uint8_t chNum, 340 uint8_t& authTypeSupported); 341 342 /** @brief provides enabled authentication type for the channel 343 * 344 * @param[in] chNum - channel number 345 * @param[in] priv - privilege 346 * @param[out] authType - enabled authentication type 347 * 348 * @return IPMI_CC_OK for success, others for failure. 349 */ 350 ipmi_ret_t getChannelEnabledAuthType(const uint8_t chNum, const uint8_t priv, 351 EAuthType& authType); 352 353 /** @brief Retrieves the LAN channel name from the IPMI channel number 354 * 355 * @param[in] chNum - IPMI channel number 356 * 357 * @return the LAN channel name (i.e. eth0) 358 */ 359 std::string getChannelName(const uint8_t chNum); 360 361 /** @brief Retrieves the LAN channel number from the IPMI channel name 362 * 363 * @param[in] chName - IPMI channel name (i.e. eth0) 364 * 365 * @return the LAN channel number 366 */ 367 uint8_t getChannelByName(const std::string& chName); 368 369 /** @brief determines whether payload type is valid 370 * 371 * @param[in] payload type - Payload Type 372 * 373 * @return true if valid, false otherwise 374 */ 375 bool isValidPayloadType(const PayloadType payloadType); 376 377 } // namespace ipmi 378