blob: 6dc9fe2d5e27d80f00b2323cd4d575a89011e9df [file] [log] [blame]
AppaRao Puli071f3f22018-05-24 16:45:30 +05301/*
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
William A. Kennington III194375f2018-12-14 02:14:33 -080017#include <ipmid/api.h>
AppaRao Puli071f3f22018-05-24 16:45:30 +053018
19#include <string>
20
21namespace ipmi
22{
23
24static constexpr uint8_t maxIpmiChannels = 16;
Richard Marian Thomaiyara39208e2018-12-08 17:27:11 +053025static constexpr uint8_t currentChNum = 0xE;
Vernon Mauery735ee952019-02-15 13:38:52 -080026static constexpr uint8_t invalidChannel = 0xff;
AppaRao Puli071f3f22018-05-24 16:45:30 +053027
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053028/**
29 * @enum IPMI return codes specific to channel (refer spec se 22.22 response
30 * data)
31 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053032enum 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
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053038/**
39 * @enum Channel Protocol Type (refer spec sec 6.4)
40 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053041enum 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
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053056/**
57 * @enum Channel Medium Type (refer spec sec 6.5)
58 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053059enum 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
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053078/**
79 * @enum Channel Session Type (refer spec sec 22.24 -
80 * response data byte 5)
81 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053082enum class EChannelSessSupported : uint8_t
83{
84 none = 0,
85 single = 1,
86 multi = 2,
87 any = 3,
88};
89
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053090/**
91 * @enum Channel Access Mode (refer spec sec 6.6)
92 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053093enum class EChannelAccessMode : uint8_t
94{
95 disabled = 0,
96 preboot = 1,
97 alwaysAvail = 2,
98 shared = 3,
99};
100
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +0530101/**
102 * @enum Authentication Types (refer spec sec 13.6 - IPMI
103 * Session Header)
104 */
AppaRao Puli071f3f22018-05-24 16:45:30 +0530105enum 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
Saravanan Palanisamyb5a0f162019-03-04 18:34:44 +0530115// 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 */
120enum 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
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +0530133/**
134 * @enum Access mode for channel access set/get (refer spec
135 * sec 22.22 - request byte 2[7:6])
136 */
AppaRao Puli071f3f22018-05-24 16:45:30 +0530137typedef enum
138{
139 doNotSet = 0x00,
140 nvData = 0x01,
141 activeData = 0x02,
142 reserved = 0x03,
143} EChannelActionType;
144
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +0530145/**
146 * @enum Access set flag to determine changes that has to be updated
147 * in channel access data configuration.
148 */
AppaRao Puli071f3f22018-05-24 16:45:30 +0530149enum AccessSetFlag
150{
151 setAccessMode = (1 << 0),
152 setUserAuthEnabled = (1 << 1),
153 setMsgAuthEnabled = (1 << 2),
154 setAlertingEnabled = (1 << 3),
155 setPrivLimit = (1 << 4),
156};
157
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +0530158/** @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 */
AppaRao Puli071f3f22018-05-24 16:45:30 +0530164struct ChannelAccess
165{
166 uint8_t accessMode;
167 bool userAuthDisabled;
168 bool perMsgAuthDisabled;
169 bool alertingDisabled;
170 uint8_t privLimit;
171};
172
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +0530173/** @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 */
AppaRao Puli071f3f22018-05-24 16:45:30 +0530179struct 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 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530196bool isValidChannel(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530197
198/** @brief determines whether channel device exist
199 *
200 * @param[in] chNum - channel number
201 *
202 * @return true if valid, false otherwise
203 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530204bool doesDeviceExist(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530205
206/** @brief determines whether privilege limit is valid
207 *
208 * @param[in] privLimit - Privilege limit
209 *
210 * @return true if valid, false otherwise
211 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530212bool isValidPrivLimit(const uint8_t privLimit);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530213
214/** @brief determines whether access mode is valid
215 *
216 * @param[in] accessMode - Access mode
217 *
218 * @return true if valid, false otherwise
219 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530220bool isValidAccessMode(const uint8_t accessMode);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530221
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 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530229bool isValidAuthType(const uint8_t chNum, const EAuthType& authType);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530230
231/** @brief determines supported session type of a channel
232 *
233 * @param[in] chNum - channel number
234 *
235 * @return EChannelSessSupported - supported session type
236 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530237EChannelSessSupported getChannelSessionSupport(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530238
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 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530245int getChannelActiveSessions(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530246
Vernon Mauery58317122018-11-28 11:02:43 -0800247/** @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 */
253size_t getChannelMaxTransferSize(uint8_t chNum);
254
AppaRao Puli071f3f22018-05-24 16:45:30 +0530255/** @brief initializes channel management
256 *
257 * @return IPMI_CC_OK for success, others for failure.
258 */
259ipmi_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 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530268ipmi_ret_t getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530269
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 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530277ipmi_ret_t getChannelAccessData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530278 ChannelAccess& chAccessData);
279
Richard Marian Thomaiyara39208e2018-12-08 17:27:11 +0530280/** @brief provides function to convert current channel number (0xE)
281 *
282 * @param[in] chNum - channel number as requested in commands.
Vernon Mauery5ed39592019-05-14 09:16:53 -0700283 * @param[in] devChannel - channel number as provided by device (not 0xE)
Richard Marian Thomaiyar30b01122019-04-03 15:46:03 +0530284 *
285 * @return same channel number or proper channel number for current channel
286 * number (0xE).
287 */
Vernon Mauery5ed39592019-05-14 09:16:53 -0700288static inline uint8_t convertCurrentChannelNum(const uint8_t chNum,
289 const uint8_t devChannel)
Richard Marian Thomaiyar30b01122019-04-03 15:46:03 +0530290{
291 if (chNum == currentChNum)
292 {
Vernon Mauery5ed39592019-05-14 09:16:53 -0700293 return devChannel;
Richard Marian Thomaiyar30b01122019-04-03 15:46:03 +0530294 }
295 return chNum;
296}
297
298/** @brief provides function to convert current channel number (0xE)
299 *
300 * @param[in] chNum - channel number as requested in commands.
Richard Marian Thomaiyara39208e2018-12-08 17:27:11 +0530301 *
302 * @return same channel number or proper channel number for current channel
303 * number (0xE).
304 */
305uint8_t convertCurrentChannelNum(const uint8_t chNum);
306
AppaRao Puli071f3f22018-05-24 16:45:30 +0530307/** @brief to set channel access data
308 *
309 * @param[in] chNum - channel number
310 * @param[in] chAccessData - channel access data
311 * @param[in] setFlag - flag to indicate updatable fields
312 *
313 * @return IPMI_CC_OK for success, others for failure.
314 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530315ipmi_ret_t setChannelAccessData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530316 const ChannelAccess& chAccessData,
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530317 const uint8_t setFlag);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530318
319/** @brief to get channel access data persistent data
320 *
321 * @param[in] chNum - channel number
322 * @param[out] chAccessData - channel access data
323 *
324 * @return IPMI_CC_OK for success, others for failure.
325 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530326ipmi_ret_t getChannelAccessPersistData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530327 ChannelAccess& chAccessData);
328
329/** @brief to set channel access data persistent data
330 *
331 * @param[in] chNum - channel number
332 * @param[in] chAccessData - channel access data
333 * @param[in] setFlag - flag to indicate updatable fields
334 *
335 * @return IPMI_CC_OK for success, others for failure.
336 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530337ipmi_ret_t setChannelAccessPersistData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530338 const ChannelAccess& chAccessData,
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530339 const uint8_t setFlag);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530340
341/** @brief provides supported authentication type for the channel
342 *
343 * @param[in] chNum - channel number
344 * @param[out] authTypeSupported - supported authentication type
345 *
346 * @return IPMI_CC_OK for success, others for failure.
347 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530348ipmi_ret_t getChannelAuthTypeSupported(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530349 uint8_t& authTypeSupported);
350
351/** @brief provides enabled authentication type for the channel
352 *
353 * @param[in] chNum - channel number
354 * @param[in] priv - privilege
355 * @param[out] authType - enabled authentication type
356 *
357 * @return IPMI_CC_OK for success, others for failure.
358 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530359ipmi_ret_t getChannelEnabledAuthType(const uint8_t chNum, const uint8_t priv,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530360 EAuthType& authType);
361
Johnathan Mantey74a21022018-12-13 13:17:56 -0800362/** @brief Retrieves the LAN channel name from the IPMI channel number
363 *
364 * @param[in] chNum - IPMI channel number
365 *
366 * @return the LAN channel name (i.e. eth0)
367 */
Richard Marian Thomaiyar55768e32019-03-02 22:54:37 +0530368std::string getChannelName(const uint8_t chNum);
Johnathan Mantey74a21022018-12-13 13:17:56 -0800369
Vernon Mauery735ee952019-02-15 13:38:52 -0800370/** @brief Retrieves the LAN channel number from the IPMI channel name
371 *
372 * @param[in] chName - IPMI channel name (i.e. eth0)
373 *
374 * @return the LAN channel number
375 */
376uint8_t getChannelByName(const std::string& chName);
377
AppaRao Puli071f3f22018-05-24 16:45:30 +0530378} // namespace ipmi