Debian Codegraph @

level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h

raw
1 /*
2 * Copyright (C) 2020-2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #pragma once
9
10 #include "level_zero/sysman/source/shared/windows/sysman_kmd_sys_manager.h"
11 #include "level_zero/zes_api.h"
12
13 namespace L0 {
14 namespace Sysman {
15 namespace ult {
16
17 constexpr uint32_t mockKmdVersionMajor = 1;
18 constexpr uint32_t mockKmdVersionMinor = 0;
19 constexpr uint32_t mockKmdPatchNumber = 0;
20 constexpr uint32_t mockKmdMaxHandlesPerEvent = 20;
21
22 struct MockEventHandle {
23 HANDLE eventHandle;
24 bool inited = false;
25 };
26
27 uint64_t convertTStoMicroSec(uint64_t ts, uint32_t freq);
28 namespace KmdSysman = L0::Sysman::KmdSysman;
29 struct MockKmdSysManager : public L0::Sysman::KmdSysManager {
30 ze_bool_t allowSetCalls = false;
31 ze_bool_t fanSupported = false;
32 uint32_t mockPowerLimit1 = 2500;
33 NTSTATUS mockEscapeResult = STATUS_SUCCESS;
34 bool mockRequestSingle = false;
35 bool mockRequestMultiple = false;
36 bool requestMultipleSizeDiff = false;
37 ze_result_t mockRequestSingleResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
38 ze_result_t mockRequestMultipleResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
39
40 MockEventHandle handles[KmdSysman::Events::MaxEvents][mockKmdMaxHandlesPerEvent];
41
42 MOCKABLE_VIRTUAL void getInterfaceProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
43 pResponse->outDataSize = 0;
44 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
45 }
46
47 MOCKABLE_VIRTUAL void setInterfaceProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
48 pResponse->outDataSize = 0;
49 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
50 }
51
52 MOCKABLE_VIRTUAL void getPowerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
53 uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
54 pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
55
56 if (pRequest->inRequestId == KmdSysman::Requests::Power::CurrentPowerLimit1) {
57
58 if (pRequest->inDataSize != 0) {
59 pResponse->outDataSize = 0;
60 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
61 return;
62 }
63 uint32_t *pPl1 = reinterpret_cast<uint32_t *>(pBuffer);
64 *pPl1 = mockPowerLimit1;
65 pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
66 pResponse->outDataSize = sizeof(uint32_t);
67 } else {
68 pResponse->outDataSize = 0;
69 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
70 }
71 }
72
73 MOCKABLE_VIRTUAL void setPowerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
74 uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
75 pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
76
77 if (pRequest->inRequestId == KmdSysman::Requests::Power::CurrentPowerLimit1) {
78 uint32_t *pPl1 = reinterpret_cast<uint32_t *>(pBuffer);
79 mockPowerLimit1 = *pPl1;
80 pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
81 } else {
82 pResponse->outDataSize = 0;
83 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
84 }
85 }
86
87 MOCKABLE_VIRTUAL void getFrequencyProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
88 pResponse->outDataSize = 0;
89 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
90 }
91
92 MOCKABLE_VIRTUAL void setFrequencyProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
93 pResponse->outDataSize = 0;
94 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
95 }
96
97 MOCKABLE_VIRTUAL void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
98 pResponse->outDataSize = 0;
99 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
100 }
101
102 MOCKABLE_VIRTUAL void getPerformanceProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
103 pResponse->outDataSize = 0;
104 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
105 }
106
107 MOCKABLE_VIRTUAL void setActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
108 pResponse->outDataSize = 0;
109 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
110 }
111
112 MOCKABLE_VIRTUAL void getFanProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
113 pResponse->outDataSize = 0;
114 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
115 }
116
117 MOCKABLE_VIRTUAL void setFanProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
118 pResponse->outDataSize = 0;
119 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
120 }
121
122 MOCKABLE_VIRTUAL void getTemperatureProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
123 pResponse->outDataSize = 0;
124 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
125 }
126
127 MOCKABLE_VIRTUAL void setTemperatureProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
128 pResponse->outDataSize = 0;
129 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
130 }
131
132 MOCKABLE_VIRTUAL void setPerformanceProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
133 pResponse->outDataSize = 0;
134 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
135 }
136
137 MOCKABLE_VIRTUAL void getFpsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
138 pResponse->outDataSize = 0;
139 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
140 }
141
142 MOCKABLE_VIRTUAL void setFpsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
143 pResponse->outDataSize = 0;
144 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
145 }
146
147 MOCKABLE_VIRTUAL void getSchedulerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
148 pResponse->outDataSize = 0;
149 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
150 }
151
152 MOCKABLE_VIRTUAL void setSchedulerProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
153 pResponse->outDataSize = 0;
154 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
155 }
156
157 MOCKABLE_VIRTUAL void getMemoryProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
158 pResponse->outDataSize = 0;
159 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
160 }
161
162 MOCKABLE_VIRTUAL void setMemoryProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
163 pResponse->outDataSize = 0;
164 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
165 }
166
167 MOCKABLE_VIRTUAL void getPciProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
168 pResponse->outDataSize = 0;
169 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
170 }
171
172 MOCKABLE_VIRTUAL void setPciProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
173 pResponse->outDataSize = 0;
174 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
175 }
176
177 MOCKABLE_VIRTUAL void getGlobalOperationsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
178 pResponse->outDataSize = 0;
179 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
180 }
181
182 MOCKABLE_VIRTUAL void setGlobalOperationsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
183 pResponse->outDataSize = 0;
184 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
185 }
186
187 void retrieveCorrectVersion(KmdSysman::GfxSysmanMainHeaderOut *pHeaderOut) {
188 pHeaderOut->outNumElements = 1;
189 pHeaderOut->outTotalSize = 0;
190
191 KmdSysman::GfxSysmanReqHeaderOut *pResponse = reinterpret_cast<KmdSysman::GfxSysmanReqHeaderOut *>(pHeaderOut->outBuffer);
192 uint8_t *pBuffer = nullptr;
193
194 pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
195 pResponse->outDataSize = sizeof(KmdSysman::KmdSysmanVersion);
196 pBuffer = reinterpret_cast<uint8_t *>(pResponse);
197 pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
198 pHeaderOut->outTotalSize += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
199
200 KmdSysman::KmdSysmanVersion *pCurrentVersion = reinterpret_cast<KmdSysman::KmdSysmanVersion *>(pBuffer);
201 pCurrentVersion->majorVersion = mockKmdVersionMajor;
202 pCurrentVersion->minorVersion = mockKmdVersionMinor;
203 pCurrentVersion->patchNumber = mockKmdPatchNumber;
204
205 pHeaderOut->outTotalSize += sizeof(KmdSysman::KmdSysmanVersion);
206 }
207
208 bool validateInputBuffer(KmdSysman::GfxSysmanMainHeaderIn *pHeaderIn) {
209 uint8_t *pBufferPtr = pHeaderIn->inBuffer;
210
211 for (uint32_t i = 0; i < pHeaderIn->inNumElements; i++) {
212 KmdSysman::GfxSysmanReqHeaderIn *pRequest = reinterpret_cast<KmdSysman::GfxSysmanReqHeaderIn *>(pBufferPtr);
213 if (pRequest->inCommand == KmdSysman::Command::Get ||
214 pRequest->inCommand == KmdSysman::Command::Set ||
215 pRequest->inCommand == KmdSysman::Command::RegisterEvent) {
216 if (pRequest->inComponent >= KmdSysman::Component::InterfaceProperties && pRequest->inComponent < KmdSysman::Component::MaxComponents) {
217 pBufferPtr += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
218
219 if (pRequest->inCommand == KmdSysman::Command::Set ||
220 pRequest->inCommand == KmdSysman::Command::RegisterEvent) {
221 if (pRequest->inDataSize == 0) {
222 return false;
223 }
224 pBufferPtr += pRequest->inDataSize;
225 }
226 } else {
227 return false;
228 }
229 } else {
230 return false;
231 }
232 }
233
234 return true;
235 }
236
237 void registerEvent(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
238 if (!allowSetCalls) {
239 pResponse->outDataSize = 0;
240 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
241 return;
242 }
243
244 uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
245 pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
246
247 pResponse->outDataSize = 0;
248
249 switch (pRequest->inRequestId) {
250 case KmdSysman::Events::EnterD0:
251 case KmdSysman::Events::EnterD3:
252 case KmdSysman::Events::EnterTDR:
253 case KmdSysman::Events::ExitTDR:
254 case KmdSysman::Events::EnergyThresholdCrossed: {
255 bool found = false;
256 for (uint32_t i = 0; i < mockKmdMaxHandlesPerEvent; i++) {
257 if (!handles[pRequest->inRequestId][i].inited) {
258 handles[pRequest->inRequestId][i].inited = true;
259 memcpy_s(&handles[pRequest->inRequestId][i].eventHandle, sizeof(HANDLE), pBuffer, sizeof(HANDLE));
260 found = true;
261 break;
262 }
263 }
264 pResponse->outReturnCode = found ? KmdSysman::KmdSysmanSuccess : KmdSysman::KmdSysmanFail;
265 } break;
266 default:
267 pResponse->outDataSize = 0;
268 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
269 break;
270 }
271 }
272
273 void signalEvent(uint32_t idEvent) {
274
275 uint32_t arrayID = 0;
276 if (idEvent & ZES_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED) {
277 arrayID = KmdSysman::Events::EnergyThresholdCrossed;
278 }
279
280 if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_ENTER) {
281 arrayID = KmdSysman::Events::EnterD3;
282 }
283
284 if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT) {
285 arrayID = KmdSysman::Events::EnterD0;
286 }
287
288 if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_DETACH) {
289 arrayID = KmdSysman::Events::EnterTDR;
290 }
291
292 if (idEvent & ZES_EVENT_TYPE_FLAG_DEVICE_ATTACH) {
293 arrayID = KmdSysman::Events::ExitTDR;
294 }
295
296 for (uint32_t i = 0; i < mockKmdMaxHandlesPerEvent; i++) {
297 if (handles[arrayID][i].inited) {
298 SetEvent(handles[arrayID][i].eventHandle);
299 }
300 }
301 }
302
303 ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out) {
304 if (mockRequestSingle == false) {
305 return KmdSysManager::requestSingle(In, Out);
306 }
307 return mockRequestSingleResult;
308 }
309
310 ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut) {
311 if (mockRequestMultiple == false) {
312 return KmdSysManager::requestMultiple(vIn, vOut);
313 } else {
314 if (requestMultipleSizeDiff == true) {
315 KmdSysman::ResponseProperty temp;
316 vOut.push_back(temp);
317 }
318 return mockRequestMultipleResult;
319 }
320 return ZE_RESULT_SUCCESS;
321 }
322
323 void setProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
324 if (!allowSetCalls) {
325 pResponse->outDataSize = 0;
326 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
327 return;
328 }
329
330 switch (pRequest->inComponent) {
331 case KmdSysman::Component::InterfaceProperties: {
332 setInterfaceProperty(pRequest, pResponse);
333 } break;
334 case KmdSysman::Component::PowerComponent: {
335 setPowerProperty(pRequest, pResponse);
336 } break;
337 case KmdSysman::Component::FrequencyComponent: {
338 setFrequencyProperty(pRequest, pResponse);
339 } break;
340 case KmdSysman::Component::ActivityComponent: {
341 setActivityProperty(pRequest, pResponse);
342 } break;
343 case KmdSysman::Component::FanComponent: {
344 setFanProperty(pRequest, pResponse);
345 } break;
346 case KmdSysman::Component::TemperatureComponent: {
347 setTemperatureProperty(pRequest, pResponse);
348 } break;
349 case KmdSysman::Component::FpsComponent: {
350 setFpsProperty(pRequest, pResponse);
351 } break;
352 case KmdSysman::Component::SchedulerComponent: {
353 setSchedulerProperty(pRequest, pResponse);
354 } break;
355 case KmdSysman::Component::MemoryComponent: {
356 setMemoryProperty(pRequest, pResponse);
357 } break;
358 case KmdSysman::Component::PciComponent: {
359 setPciProperty(pRequest, pResponse);
360 } break;
361 case KmdSysman::Component::GlobalOperationsComponent: {
362 setGlobalOperationsProperty(pRequest, pResponse);
363 } break;
364 case KmdSysman::Component::PerformanceComponent: {
365 setPerformanceProperty(pRequest, pResponse);
366 } break;
367 default: {
368 pResponse->outDataSize = 0;
369 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
370 } break;
371 }
372 }
373
374 void getProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
375 switch (pRequest->inComponent) {
376 case KmdSysman::Component::InterfaceProperties: {
377 getInterfaceProperty(pRequest, pResponse);
378 } break;
379 case KmdSysman::Component::PowerComponent: {
380 getPowerProperty(pRequest, pResponse);
381 } break;
382 case KmdSysman::Component::FrequencyComponent: {
383 getFrequencyProperty(pRequest, pResponse);
384 } break;
385 case KmdSysman::Component::ActivityComponent: {
386 getActivityProperty(pRequest, pResponse);
387 } break;
388 case KmdSysman::Component::FanComponent: {
389 getFanProperty(pRequest, pResponse);
390 } break;
391 case KmdSysman::Component::TemperatureComponent: {
392 getTemperatureProperty(pRequest, pResponse);
393 } break;
394 case KmdSysman::Component::FpsComponent: {
395 getFpsProperty(pRequest, pResponse);
396 } break;
397 case KmdSysman::Component::SchedulerComponent: {
398 getSchedulerProperty(pRequest, pResponse);
399 } break;
400 case KmdSysman::Component::MemoryComponent: {
401 getMemoryProperty(pRequest, pResponse);
402 } break;
403 case KmdSysman::Component::PciComponent: {
404 getPciProperty(pRequest, pResponse);
405 } break;
406 case KmdSysman::Component::GlobalOperationsComponent: {
407 getGlobalOperationsProperty(pRequest, pResponse);
408 } break;
409 case KmdSysman::Component::PerformanceComponent: {
410 getPerformanceProperty(pRequest, pResponse);
411 } break;
412 default: {
413 pResponse->outDataSize = 0;
414 pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
415 } break;
416 }
417 }
418
419 NTSTATUS escape(uint32_t escapeOp, uint64_t pInPtr, uint32_t dataInSize, uint64_t pOutPtr, uint32_t dataOutSize) {
420 if (mockEscapeResult != STATUS_SUCCESS) {
421 return mockEscapeResult;
422 }
423 void *pDataIn = reinterpret_cast<void *>(pInPtr);
424 void *pDataOut = reinterpret_cast<void *>(pOutPtr);
425
426 if (pDataIn == nullptr || pDataOut == nullptr) {
427 return STATUS_UNSUCCESSFUL;
428 }
429
430 if (dataInSize != sizeof(KmdSysman::GfxSysmanMainHeaderIn) || dataOutSize != sizeof(KmdSysman::GfxSysmanMainHeaderOut)) {
431 return STATUS_UNSUCCESSFUL;
432 }
433
434 if (escapeOp != KmdSysman::PcEscapeOperation) {
435 return STATUS_UNSUCCESSFUL;
436 }
437
438 KmdSysman::GfxSysmanMainHeaderIn *pSysmanMainHeaderIn = reinterpret_cast<KmdSysman::GfxSysmanMainHeaderIn *>(pDataIn);
439 KmdSysman::GfxSysmanMainHeaderOut *pSysmanMainHeaderOut = reinterpret_cast<KmdSysman::GfxSysmanMainHeaderOut *>(pDataOut);
440
441 KmdSysman::KmdSysmanVersion versionSysman;
442 versionSysman.data = pSysmanMainHeaderIn->inVersion;
443
444 if (versionSysman.majorVersion != KmdSysman::KmdMajorVersion) {
445 if (versionSysman.majorVersion == 0) {
446 retrieveCorrectVersion(pSysmanMainHeaderOut);
447 return STATUS_SUCCESS;
448 }
449 return STATUS_UNSUCCESSFUL;
450 }
451
452 if (pSysmanMainHeaderIn->inTotalsize == 0) {
453 return STATUS_UNSUCCESSFUL;
454 }
455
456 if (pSysmanMainHeaderIn->inNumElements == 0) {
457 return STATUS_UNSUCCESSFUL;
458 }
459
460 if (!validateInputBuffer(pSysmanMainHeaderIn)) {
461 return STATUS_UNSUCCESSFUL;
462 }
463
464 uint8_t *pBufferIn = pSysmanMainHeaderIn->inBuffer;
465 uint8_t *pBufferOut = pSysmanMainHeaderOut->outBuffer;
466 uint32_t requestOffset = 0;
467 uint32_t responseOffset = 0;
468 pSysmanMainHeaderOut->outTotalSize = 0;
469
470 for (uint32_t i = 0; i < pSysmanMainHeaderIn->inNumElements; i++) {
471 KmdSysman::GfxSysmanReqHeaderIn *pRequest = reinterpret_cast<KmdSysman::GfxSysmanReqHeaderIn *>(pBufferIn);
472 KmdSysman::GfxSysmanReqHeaderOut *pResponse = reinterpret_cast<KmdSysman::GfxSysmanReqHeaderOut *>(pBufferOut);
473
474 switch (pRequest->inCommand) {
475 case KmdSysman::Command::Get: {
476 getProperty(pRequest, pResponse);
477 requestOffset = sizeof(KmdSysman::GfxSysmanReqHeaderIn);
478 responseOffset = sizeof(KmdSysman::GfxSysmanReqHeaderOut);
479 responseOffset += pResponse->outDataSize;
480 } break;
481 case KmdSysman::Command::Set: {
482 setProperty(pRequest, pResponse);
483 requestOffset = sizeof(KmdSysman::GfxSysmanReqHeaderIn);
484 requestOffset += pRequest->inDataSize;
485 responseOffset = sizeof(KmdSysman::GfxSysmanReqHeaderOut);
486 } break;
487 case KmdSysman::Command::RegisterEvent: {
488 registerEvent(pRequest, pResponse);
489 requestOffset = sizeof(KmdSysman::GfxSysmanReqHeaderIn);
490 requestOffset += pRequest->inDataSize;
491 responseOffset = sizeof(KmdSysman::GfxSysmanReqHeaderOut);
492 } break;
493 default: {
494 return STATUS_UNSUCCESSFUL;
495 } break;
496 }
497
498 pResponse->outRequestId = pRequest->inRequestId;
499 pResponse->outComponent = pRequest->inComponent;
500 pBufferIn += requestOffset;
501 pBufferOut += responseOffset;
502 pSysmanMainHeaderOut->outTotalSize += responseOffset;
503 }
504
505 pSysmanMainHeaderOut->outNumElements = pSysmanMainHeaderIn->inNumElements;
506 pSysmanMainHeaderOut->outStatus = KmdSysman::KmdSysmanSuccess;
507
508 return STATUS_SUCCESS;
509 }
510 };
511
512 } // namespace ult
513 } // namespace Sysman
514 } // namespace L0