1 /*
2  * Copyright (C) 2020-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #pragma once
9 #include "level_zero/core/test/unit_tests/mock.h"
10 #include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h"
11 
12 #include "sysman/power/power_imp.h"
13 
14 namespace L0 {
15 namespace ult {
16 
17 class PowerKmdSysManager : public Mock<MockKmdSysManager> {};
18 
19 template <>
20 struct Mock<PowerKmdSysManager> : public PowerKmdSysManager {
21 
22     uint32_t mockPowerLimit1Enabled = 1;
23     uint32_t mockPowerLimit2Enabled = 1;
24     int32_t mockPowerLimit1 = 25000;
25     int32_t mockPowerLimit2 = 41000;
26     int32_t mockTauPowerLimit1 = 20800;
27     uint32_t mockTpdDefault = 34000;
28     uint32_t mockMinPowerLimit = 1000;
29     uint32_t mockMaxPowerLimit = 80000;
30     int32_t mockAcPowerPeak = 0;
31     int32_t mockDcPowerPeak = 0;
32     uint32_t mockEnergyThreshold = 0;
33     uint32_t mockEnergyCounter = 3231121;
34     uint32_t mockTimeStamp = 1123412412;
35     uint32_t mockEnergyUnit = 14;
36 
37     uint32_t mockFrequencyTimeStamp = 38400000;
38 
39     void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
40         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
41         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
42 
43         switch (pRequest->inRequestId) {
44         case KmdSysman::Requests::Activity::TimestampFrequency: {
45             uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
46             *pValueFrequency = mockFrequencyTimeStamp;
47             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
48             pResponse->outDataSize = sizeof(uint32_t);
49         } break;
50         default: {
51             pResponse->outDataSize = 0;
52             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
53         } break;
54         }
55     }
56 
57     void getPowerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
58         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
59         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
60 
61         switch (pRequest->inRequestId) {
62         case KmdSysman::Requests::Power::EnergyThresholdSupported: {
63             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
64             *pValue = static_cast<uint32_t>(this->allowSetCalls);
65             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
66             pResponse->outDataSize = sizeof(uint32_t);
67         } break;
68         case KmdSysman::Requests::Power::TdpDefault: {
69             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
70             *pValue = mockTpdDefault;
71             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
72             pResponse->outDataSize = sizeof(uint32_t);
73         } break;
74         case KmdSysman::Requests::Power::MinPowerLimitDefault: {
75             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
76             *pValue = mockMinPowerLimit;
77             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
78             pResponse->outDataSize = sizeof(uint32_t);
79         } break;
80         case KmdSysman::Requests::Power::MaxPowerLimitDefault: {
81             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
82             *pValue = mockMaxPowerLimit;
83             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
84             pResponse->outDataSize = sizeof(uint32_t);
85         } break;
86         case KmdSysman::Requests::Power::PowerLimit1Enabled: {
87             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
88             *pValue = mockPowerLimit1Enabled;
89             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
90             pResponse->outDataSize = sizeof(uint32_t);
91         } break;
92         case KmdSysman::Requests::Power::PowerLimit2Enabled: {
93             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
94             *pValue = mockPowerLimit2Enabled;
95             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
96             pResponse->outDataSize = sizeof(uint32_t);
97         } break;
98         case KmdSysman::Requests::Power::CurrentPowerLimit1: {
99             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
100             *pValue = mockPowerLimit1;
101             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
102             pResponse->outDataSize = sizeof(int32_t);
103         } break;
104         case KmdSysman::Requests::Power::CurrentPowerLimit1Tau: {
105             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
106             *pValue = mockTauPowerLimit1;
107             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
108             pResponse->outDataSize = sizeof(int32_t);
109         } break;
110         case KmdSysman::Requests::Power::CurrentPowerLimit2: {
111             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
112             *pValue = mockPowerLimit2;
113             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
114             pResponse->outDataSize = sizeof(int32_t);
115         } break;
116         case KmdSysman::Requests::Power::CurrentPowerLimit4Ac: {
117             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
118             *pValue = mockAcPowerPeak;
119             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
120             pResponse->outDataSize = sizeof(int32_t);
121         } break;
122         case KmdSysman::Requests::Power::CurrentPowerLimit4Dc: {
123             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
124             *pValue = mockDcPowerPeak;
125             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
126             pResponse->outDataSize = sizeof(uint32_t);
127         } break;
128         case KmdSysman::Requests::Power::CurrentEnergyThreshold: {
129             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
130             *pValue = mockEnergyThreshold;
131             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
132             pResponse->outDataSize = sizeof(uint32_t);
133         } break;
134         case KmdSysman::Requests::Power::CurrentEnergyCounter: {
135             uint32_t *pValueCounter = reinterpret_cast<uint32_t *>(pBuffer);
136             uint64_t *pValueTS = reinterpret_cast<uint64_t *>(pBuffer + sizeof(uint32_t));
137             *pValueCounter = mockEnergyCounter;
138             *pValueTS = mockTimeStamp;
139             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
140             pResponse->outDataSize = sizeof(uint32_t) + sizeof(uint64_t);
141         } break;
142         case KmdSysman::Requests::Power::EnergyCounterUnits: {
143             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
144             *pValue = mockEnergyUnit;
145             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
146             pResponse->outDataSize = sizeof(uint32_t);
147         } break;
148         default: {
149             pResponse->outDataSize = 0;
150             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
151         } break;
152         }
153     }
154 
155     void setPowerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
156         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
157         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
158 
159         switch (pRequest->inRequestId) {
160         case KmdSysman::Requests::Power::CurrentPowerLimit1: {
161             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
162             mockPowerLimit1 = *pValue;
163             pResponse->outDataSize = 0;
164             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
165         } break;
166         case KmdSysman::Requests::Power::CurrentPowerLimit1Tau: {
167             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
168             mockTauPowerLimit1 = *pValue;
169             pResponse->outDataSize = 0;
170             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
171         } break;
172         case KmdSysman::Requests::Power::CurrentPowerLimit2: {
173             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
174             mockPowerLimit2 = *pValue;
175             pResponse->outDataSize = 0;
176             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
177         } break;
178         case KmdSysman::Requests::Power::CurrentPowerLimit4Ac: {
179             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
180             mockAcPowerPeak = *pValue;
181             pResponse->outDataSize = 0;
182             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
183         } break;
184         case KmdSysman::Requests::Power::CurrentPowerLimit4Dc: {
185             int32_t *pValue = reinterpret_cast<int32_t *>(pBuffer);
186             mockDcPowerPeak = *pValue;
187             pResponse->outDataSize = 0;
188             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
189         } break;
190         case KmdSysman::Requests::Power::CurrentEnergyThreshold: {
191             uint32_t *pValue = reinterpret_cast<uint32_t *>(pBuffer);
192             mockEnergyThreshold = *pValue;
193             pResponse->outDataSize = 0;
194             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
195         } break;
196         default: {
197             pResponse->outDataSize = 0;
198             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
199         } break;
200         }
201     }
202 
203     Mock() = default;
204     ~Mock() = default;
205 };
206 
207 } // namespace ult
208 } // namespace L0
209