Debian Codegraph @

media_softlet/linux/common/os/i915_production/mos_bufmgr_prelim.cpp

raw
1 /*
2 * Copyright © 2022 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Xiaogang Li <[email protected]>
25 *
26 */
27
28 /**
29 * @file mos_bufmgr_prelim.cpp
30 *
31 * The implementation for Prelim version functions.
32 */
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 #include <fcntl.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <assert.h>
44 #include <pthread.h>
45 #include <sys/ioctl.h>
46 #include <sys/stat.h>
47 #include <sys/types.h>
48 #include <stdbool.h>
49 #include <stdint.h>
50 #include <limits.h>
51 #include "errno.h"
52
53 #include "errno.h"
54 #ifndef ETIME
55 #define ETIME ETIMEDOUT
56 #endif
57 #include "libdrm_macros.h"
58 #include "libdrm_lists.h"
59
60 #include "xf86drm.h"
61 #include "xf86drm.h"
62 #include "xf86atomic.h"
63 #include "i915_drm.h"
64 #include "mos_bufmgr.h"
65 #include "mos_bufmgr_priv.h"
66 #include "mos_resource_defs.h"
67 #include "mos_util_debug.h"
68 #include "mos_vma.h"
69 #include "intel_hwconfig_types.h"
70 #include "mos_bufmgr_prelim.h"
71
72 #define memclear(s) memset(&s, 0, sizeof(s))
73
74 #define GOTO_FINI_IF_NOT_0(expr) \
75 if (expr) \
76 { \
77 goto fini; \
78 }
79
80 #define GOTO_FINI_IF_MALLOC_FAIL(expr) \
81 { \
82 void *ptr = (expr); \
83 if (!ptr) \
84 { \
85 assert(ptr); \
86 ret = -ENOMEM; \
87 goto fini; \
88 } \
89 }
90
91 bool BufmgrPrelim::m_prelimEnabled = false;
92
93 BufmgrPrelim *BufmgrPrelim::CreatePrelim(int fd)
94 {
95 if (fd < 0) {
96 return nullptr;
97 }
98
99 struct drm_i915_query_item item{};
100 BufmgrPrelim *prelim = nullptr;
101
102 memclear(item);
103 item.query_id = PRELIM_DRM_I915_QUERY_MEMORY_REGIONS;
104
105 struct drm_i915_query q;
106
107 memclear(q);
108 q.num_items = 1;
109 q.items_ptr = (uintptr_t)&item;
110
111 if (0 == drmIoctl(fd, DRM_IOCTL_I915_QUERY, &q) && item.length > 0) {
112 prelim = new BufmgrPrelim(fd);
113 if (nullptr != prelim) {
114 m_prelimEnabled = true;
115 }
116 }
117
118 return prelim;
119 }
120
121 bool BufmgrPrelim::IsPrelimSupported()
122 {
123 return m_prelimEnabled;
124 }
125
126 void BufmgrPrelim::DestroyPrelim(BufmgrPrelim *prelim)
127 {
128 if (nullptr != prelim) {
129 delete prelim;
130 }
131 }
132
133 BufmgrPrelim::BufmgrPrelim(int fd)
134 :m_fd(fd)
135 {
136 }
137
138 BufmgrPrelim::~BufmgrPrelim()
139 {
140 m_fd = -1;
141 }
142
143 int BufmgrPrelim::Init(struct mos_bufmgr &bufmgr, bool hasLmem)
144 {
145 uint32_t nengine = 8;
146 struct i915_engine_class_instance uengines[nengine];
147 memset(uengines, 0, sizeof(uengines));
148
149 m_tileId = GetTileId();
150
151 bufmgr.get_reserved = &m_tileId;
152 int ret = QueryEngines(hasLmem, I915_ENGINE_CLASS_VIDEO, PRELIM_I915_VIDEO_CLASS_CAPABILITY_VDENC, &nengine, uengines);
153 if(ret == 0)
154 {
155 if(nengine > 0)
156 {
157 bufmgr.has_full_vd = true;
158 }
159 else
160 {
161 bufmgr.has_full_vd = false;
162 }
163 }
164
165 return ret;
166 }
167
168 void BufmgrPrelim::WaDisableSingleTimeline(bool hasLmem, uint32_t &flags)
169 {
170 /*
171 Since KMD has potential issue when submit cmd buffer to multi-tile GPU with context of single timeline;
172 So add a WA here to remove this flag if not first tile in use on XeHP because context with single timeline can only work on first tile
173 */
174 if(hasLmem && m_tileId != 0)
175 {
176 flags &= ~(I915_CONTEXT_CREATE_FLAGS_SINGLE_TIMELINE);
177 }
178 }
179
180 int BufmgrPrelim::QueryItems(int fd, struct drm_i915_query_item *items, uint32_t numItems)
181 {
182 struct drm_i915_query q;
183
184 memclear(q);
185 q.num_items = numItems;
186 q.items_ptr = (uintptr_t)items;
187
188 return drmIoctl(fd, DRM_IOCTL_I915_QUERY, &q);
189 }
190
191 struct prelim_drm_i915_query_memory_regions *BufmgrPrelim::QueryMemRegions()
192 {
193 int ret = 0;
194 struct drm_i915_query_item item{};
195 struct prelim_drm_i915_query_memory_regions *queryInfo = nullptr;
196
197 memclear(item);
198 item.query_id = PRELIM_DRM_I915_QUERY_MEMORY_REGIONS;
199 ret = QueryItems(m_fd, &item, 1);
200 if (ret != 0 || item.length <= 0)
201 return nullptr;
202
203 queryInfo = (struct prelim_drm_i915_query_memory_regions *)calloc(1, item.length);
204
205 item.data_ptr = (uintptr_t)queryInfo;
206 ret = QueryItems(m_fd, &item, 1);
207 if (ret != 0) {
208 free(queryInfo);
209 return nullptr;
210 }
211
212 return queryInfo;
213 }
214
215 uint8_t BufmgrPrelim::GetLmemRegionCount()
216 {
217 struct prelim_drm_i915_query_memory_regions *queryInfo;
218 uint8_t numRegions = 0;
219 uint8_t lmemRegions = 0;
220
221 queryInfo = QueryMemRegions();
222
223 if(nullptr != queryInfo)
224 {
225 numRegions = queryInfo->num_regions;
226
227 for (int i = 0; i < numRegions; i++) {
228 if (queryInfo->regions[i].region.memory_class == PRELIM_I915_MEMORY_CLASS_DEVICE)
229 {
230 lmemRegions += 1;
231 }
232 }
233 free(queryInfo);
234 }
235
236 return lmemRegions;
237 }
238
239 uint32_t BufmgrPrelim::GetTileId()
240 {
241 uint8_t lmemRegions = 0;
242 uint32_t tileId = 0;
243 lmemRegions = GetLmemRegionCount();
244
245 if (lmemRegions > 0)
246 {
247 // generate an instance index by random
248 struct timespec currentTime;
249 clock_gettime(CLOCK_MONOTONIC, &currentTime);
250 srand(currentTime.tv_nsec);
251 uint8_t instance = rand() % lmemRegions;
252 tileId = instance;
253
254 // get tile setting from environment variable
255 char *tileInstance = getenv("INTEL_TILE_INSTANCE");
256 if (tileInstance != nullptr)
257 {
258 errno = 0;
259 long int instance = strtol(tileInstance, nullptr, TYPE_DECIMAL);
260 /* Check for various possible errors */
261 if ((errno == ERANGE && (instance == LONG_MAX || instance == LONG_MIN)) ||
262 (errno != 0 && instance == 0))
263 {
264 fprintf(stderr, "Invalid INTEL_TILE_INSTANCE setting.(%d)\n", errno);
265 }
266 else
267 {
268 // valid instance value should be 0, 1, ..., lmemRegions-1
269 if (instance >= 0 && instance < lmemRegions)
270 {
271 tileId = instance;
272 }
273 else
274 {
275 fprintf(stderr, "Invalid tile instance provided by user, will use default tile.\n");
276 }
277 }
278 }
279 }
280
281 return tileId;
282 }
283
284 void BufmgrPrelim::InitVmaHeap(mos_vma_heap *heap)
285 {
286 assert(nullptr != heap);
287 mos_vma_heap_init(heap, MEMZONE_PRIME_START, MEMZONE_PRIME_SIZE);
288 }
289
290 void BufmgrPrelim::UninitVmaHeap(mos_vma_heap *heap)
291 {
292 assert(nullptr != heap);
293 mos_vma_heap_finish(heap);
294 }
295
296 enum mos_memory_zone
297 BufmgrPrelim::GetMemzoneForAddress(uint64_t address)
298 {
299 if (address >= MEMZONE_PRIME_START) {
300 return MEMZONE_PRIME;
301 } else if (address >= MEMZONE_DEVICE_START) {
302 return MEMZONE_DEVICE;
303 } else {
304 return MEMZONE_SYS;
305 }
306 }
307
308 int BufmgrPrelim::CreateGem(uint64_t inSize,
309 uint32_t &outHandle,
310 uint64_t &outSize,
311 uint32_t &outRegion)
312 {
313 int ret = 0;
314
315 struct prelim_drm_i915_gem_memory_class_instance mem_regions;
316 uint32_t num_regions = 1;
317 memclear(mem_regions);
318 mem_regions.memory_class = PRELIM_I915_MEMORY_CLASS_DEVICE;
319 mem_regions.memory_instance = m_tileId;
320
321 struct prelim_drm_i915_gem_object_param region_param;
322 memclear(region_param);
323 region_param.size = num_regions;
324 region_param.data = (uintptr_t)(&mem_regions);
325 region_param.param = PRELIM_I915_OBJECT_PARAM | PRELIM_I915_PARAM_MEMORY_REGIONS;
326
327 struct prelim_drm_i915_gem_create_ext_setparam setparam_region;
328 memclear(setparam_region);
329 setparam_region.base.name = PRELIM_I915_GEM_CREATE_EXT_SETPARAM;
330 setparam_region.param = region_param;
331
332 struct prelim_drm_i915_gem_create_ext create;
333 memclear(create);
334 create.size = inSize;
335 create.extensions = (uintptr_t)(&setparam_region);
336
337 ret = drmIoctl(m_fd,
338 PRELIM_DRM_IOCTL_I915_GEM_CREATE_EXT,
339 &create);
340 outHandle = create.handle;
341 outSize = create.size;
342 outRegion = PRELIM_I915_MEMORY_CLASS_DEVICE;
343
344 return ret;
345 }
346
347 int BufmgrPrelim::CheckMemRegion(int memRegion, int mem_type)
348 {
349 if (memRegion == PRELIM_I915_MEMORY_CLASS_SYSTEM &&
350 (mem_type == MOS_MEMPOOL_VIDEOMEMORY || mem_type == MOS_MEMPOOL_DEVICEMEMORY))
351 return -EINVAL;
352
353 if (memRegion == PRELIM_I915_MEMORY_CLASS_DEVICE &&
354 (mem_type == MOS_MEMPOOL_SYSTEMMEMORY))
355 return -EINVAL;
356
357 return 0;
358 }
359
360 void BufmgrPrelim::SetMmapOffset(int memRegion, struct drm_i915_gem_mmap_offset &mmap_arg)
361 {
362 if(memRegion == PRELIM_I915_MEMORY_CLASS_SYSTEM)
363 {
364 mmap_arg.flags = I915_MMAP_OFFSET_WB;
365 }
366 else
367 {
368 mmap_arg.flags = I915_MMAP_OFFSET_WC;
369 }
370 }
371
372 int BufmgrPrelim::QueryEnginesCount(unsigned int *nengine)
373 {
374 assert(m_fd >= 0);
375 assert(nullptr != nengine);
376
377 struct drm_i915_query query;
378 struct drm_i915_query_item queryItem;
379 struct prelim_drm_i915_query_engine_info *engines = nullptr;
380 int ret, len;
381
382 memclear(queryItem);
383 queryItem.query_id = PRELIM_DRM_I915_QUERY_ENGINE_INFO;
384 queryItem.length = 0;
385
386 ret = QueryItems(m_fd, &queryItem, 1);
387 if (ret || queryItem.length <= 0)
388 {
389 *nengine = 0;
390 return ret;
391 }
392
393 len = queryItem.length;
394 engines = (prelim_drm_i915_query_engine_info *)malloc(len);
395 if (engines == nullptr)
396 {
397 *nengine = 0;
398 return ret;
399 }
400
401 memset(engines, 0, len);
402 memclear(queryItem);
403 queryItem.query_id = PRELIM_DRM_I915_QUERY_ENGINE_INFO;
404 queryItem.length = len;
405 queryItem.data_ptr = (uintptr_t)engines;
406 ret = QueryItems(m_fd, &queryItem, 1);
407
408 *nengine = ret ? 0 : engines->num_engines;
409
410 if (engines)
411 {
412 free(engines);
413 }
414 return ret;
415 }
416
417 bool BufmgrPrelim::IsEngineSatisfyCaps(
418 struct prelim_drm_i915_engine_info *engine,
419 uint64_t caps)
420 {
421 if (!(engine->flags & PRELIM_I915_ENGINE_INFO_HAS_KNOWN_CAPABILITIES) ||
422 !(engine->known_capabilities & PRELIM_I915_VIDEO_CLASS_CAPABILITY_VDENC))
423 caps &= ~PRELIM_I915_VIDEO_CLASS_CAPABILITY_VDENC;
424
425 return (caps & engine->capabilities) == caps;
426 }
427
428 int BufmgrPrelim::QueryEnginesInternal(uint16_t engine_class,
429 uint64_t caps,
430 unsigned int *nengine,
431 struct i915_engine_class_instance *ci,
432 std::map<uint16_t, uint16_t> &logicalMap)
433 {
434 if(nengine == nullptr || ci == nullptr)
435 {
436 return -EINVAL;
437 }
438
439 assert(m_fd >= 0);
440
441 struct drm_i915_query query;
442 struct drm_i915_query_item item;
443 struct prelim_drm_i915_query_engine_info *engines = nullptr;
444 int ret, len;
445
446 memclear(item);
447 item.query_id = PRELIM_DRM_I915_QUERY_ENGINE_INFO;
448 item.length = 0;
449
450 GOTO_FINI_IF_NOT_0(ret = QueryItems(m_fd, &item, 1));
451 len = item.length;
452 if (len <= 0)
453 {
454 goto fini;
455 }
456
457 engines = (prelim_drm_i915_query_engine_info *)malloc(len);
458 GOTO_FINI_IF_MALLOC_FAIL(engines);
459
460 memset(engines,0,len);
461 memclear(item);
462 item.query_id = PRELIM_DRM_I915_QUERY_ENGINE_INFO;
463 item.length = len;
464 item.data_ptr = (uintptr_t)engines;
465 GOTO_FINI_IF_NOT_0(ret = QueryItems(m_fd, &item, 1));
466
467 int i, num;
468 for (i = 0, num = 0; i < engines->num_engines; i++)
469 {
470 struct prelim_drm_i915_engine_info *engine = (struct prelim_drm_i915_engine_info *)&engines->engines[i];
471 if (engine_class == engine->engine.engine_class && IsEngineSatisfyCaps(engine, caps))
472 {
473 ci->engine_class = engine_class;
474 ci->engine_instance = engine->engine.engine_instance;
475
476 /** Need to sort ci to logical order instead of uabi order
477 |physica | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | assume 4 fused off
478 -----------------------------------------
479 |uabi | 0 | 1 | 2 | 3 | | 4 | 5 | 6 |
480 -----------------------------------------
481 |logical | 0 | 3 | 1 | 4 | | 5 | 2 | 6 |
482 */
483 logicalMap[engine->engine.engine_instance] = engine->logical_instance;
484 ci++;
485 num++;
486 }
487 if (num > *nengine)
488 {
489 fprintf(stderr,"%s: Number of engine instances out of range, %d,%d\n",
490 __FUNCTION__, num, *nengine);
491 goto fini;
492 }
493 }
494 *nengine = num;
495
496 fini:
497 if (engines)
498 free(engines);
499 return ret;
500 }
501
502 int BufmgrPrelim::QueryEngines(bool hasLmem,
503 uint16_t engineClass,
504 uint64_t caps,
505 unsigned int *nengine,
506 struct i915_engine_class_instance *ci)
507 {
508 if((nengine == nullptr) || (ci == nullptr))
509 {
510 return -EINVAL;
511 }
512
513 uint32_t tileId = m_tileId;
514 struct i915_engine_class_instance *ciTemp = nullptr;
515 struct prelim_drm_i915_query_distance_info *distances = nullptr;
516 std::map<uint16_t, uint16_t> logicalMap;
517 logicalMap.clear();
518 unsigned int engineNum;
519
520 ciTemp = (struct i915_engine_class_instance *)malloc((*nengine) * sizeof(struct i915_engine_class_instance));
521 if (!ciTemp)
522 {
523 assert(ciTemp);
524 return -ENOMEM;
525 }
526
527 memset(ciTemp, 0, (*nengine) * sizeof(struct i915_engine_class_instance));
528
529 int ret = QueryEnginesInternal(engineClass,
530 caps,
531 nengine,
532 ciTemp,
533 logicalMap);
534 GOTO_FINI_IF_NOT_0(ret);
535
536 distances = (struct prelim_drm_i915_query_distance_info *)malloc((*nengine) * sizeof(struct prelim_drm_i915_query_distance_info));
537 GOTO_FINI_IF_MALLOC_FAIL(distances);
538
539 memset(distances, 0, (*nengine) * sizeof(struct prelim_drm_i915_query_distance_info));
540 for (int i = 0; i < *nengine; i++)
541 {
542 distances[i].engine = ciTemp[i];
543 distances[i].region.memory_class = hasLmem ? PRELIM_I915_MEMORY_CLASS_DEVICE : PRELIM_I915_MEMORY_CLASS_SYSTEM;
544 distances[i].region.memory_instance = tileId;
545 }
546 GOTO_FINI_IF_NOT_0(ret = QueryEnginesDistance(*nengine, distances));
547
548 //select the engine with 0 distance
549 int i, j;
550 for(i = 0, j = 0; i < *nengine; i++)
551 {
552 if(0 == distances[i].distance)
553 {
554 ci[j] = distances[i].engine;
555 j++;
556 }
557 #if (_DEBUG || _RELEASE_INTERNAL)
558 else if (0 > distances[i].distance)
559 {
560 MOS_OS_NORMALMESSAGE("Engine = {engine_class = %hu, engine_instance = %hu}; Distance (error code) == %d",
561 distances[i].engine.engine_class, distances[i].engine.engine_instance, distances[i].distance);
562 }
563 #endif
564 }
565 *nengine = j;
566
567 engineNum = *nengine;
568 if (engineClass == I915_ENGINE_CLASS_VIDEO && engineNum > 2)
569 {
570 std::map<uint16_t, uint16_t> reorderMap; //<logical id, uabi id>
571
572 for (i = 0; i < engineNum; i++)
573 {
574 uint16_t index = logicalMap[(ci + i)->engine_instance];
575 reorderMap[index] = (ci + i)->engine_instance;
576 }
577
578 i = 0;
579 for (auto iter = reorderMap.begin(); iter != reorderMap.end(); iter++)
580 {
581 (ci + i)->engine_instance = iter->second;
582 i++;
583 }
584 }
585
586 fini:
587 if(ciTemp)
588 {
589 free(ciTemp);
590 }
591 if(distances)
592 {
593 free(distances);
594 }
595
596 return ret;
597 }
598
599 int BufmgrPrelim::SetContextParamParallel(struct mos_linux_context *ctx,
600 struct i915_engine_class_instance *ci,
601 unsigned int count)
602 {
603 if((ctx == nullptr) || (ci == nullptr) || (count <= 0))
604 {
605 return -EINVAL;
606 }
607
608 int ret = 0;
609 uint32_t size = 0;
610 int n;
611 struct i915_context_engines_parallel_submit* parallel_submit = nullptr;
612 struct i915_context_param_engines* set_engines = nullptr;
613
614 size = sizeof(struct i915_context_engines_parallel_submit) + count * sizeof(*ci);
615 parallel_submit = (struct i915_context_engines_parallel_submit*)malloc(size);
616 GOTO_FINI_IF_MALLOC_FAIL(parallel_submit);
617
618 memset(parallel_submit, 0, size);
619 parallel_submit->base.name = PRELIM_I915_CONTEXT_ENGINES_EXT_PARALLEL2_SUBMIT;
620 parallel_submit->engine_index = 0;
621 parallel_submit->width = count;
622 parallel_submit->num_siblings = 1;
623 for(int i = 0; i < count; i++)
624 {
625 parallel_submit->engines[i] = ci[i];
626 }
627
628 /* I915_DEFINE_CONTEXT_PARAM_ENGINES */
629 size = sizeof(struct i915_context_param_engines) + sizeof(struct i915_engine_class_instance);
630 set_engines = (struct i915_context_param_engines*) malloc(size);
631 GOTO_FINI_IF_MALLOC_FAIL(set_engines);
632
633 set_engines->extensions = (uintptr_t)(parallel_submit);
634 set_engines->engines[0].engine_class = I915_ENGINE_CLASS_INVALID;
635 set_engines->engines[0].engine_instance = I915_ENGINE_CLASS_INVALID_NONE;
636
637 ret = mos_set_context_param(ctx,
638 size,
639 I915_CONTEXT_PARAM_ENGINES,
640 (uintptr_t)set_engines);
641 fini:
642 if (set_engines)
643 free(set_engines);
644 if (parallel_submit)
645 free(parallel_submit);
646 return ret;
647 }
648
649 int BufmgrPrelim::QueryDeviceBlob(int fd, MEDIA_SYSTEM_INFO* gfxInfo)
650 {
651 uint32_t *hwInfo;
652 uint32_t ulength= 0;
653 int ret, i;
654 struct drm_i915_query_item item;
655
656 hwInfo = nullptr;
657
658 memclear(item);
659 item.length = 0;
660 item.query_id = PRELIM_DRM_I915_QUERY_HWCONFIG_TABLE;
661 ret = QueryItems(fd, &item, 1);
662 if (ret != 0 || item.length <= 0)
663 {
664 return (ret != 0) ? ret : -1;
665 }
666
667 hwInfo = (uint32_t*) malloc(item.length);
668 if (hwInfo != nullptr)
669 memset(hwInfo, 0, item.length);
670 else
671 return -ENOMEM;
672 item.data_ptr = (uintptr_t) hwInfo;
673 ret = QueryItems(fd, &item, 1);
674 if (ret != 0 || item.length <= 0)
675 {
676 return (ret != 0) ? ret : -1;
677 }
678 ulength = item.length / sizeof(uint32_t);
679 i = 0;
680 assert(gfxInfo);
681 while (i < ulength) {
682 /* Attribute ID starts with 1 */
683 assert(hwInfo[i] > 0);
684
685 switch (hwInfo[i])
686 {
687 case INTEL_HWCONFIG_MAX_SLICES_SUPPORTED:
688 {
689 assert(hwInfo[i+1] == 1);
690 gfxInfo->SliceCount = hwInfo[i+2];
691 gfxInfo->MaxSlicesSupported = hwInfo[i+2];
692 }
693
694 case INTEL_HWCONFIG_MAX_DUAL_SUBSLICES_SUPPORTED:
695 {
696 assert(hwInfo[i+1] == 1);
697 gfxInfo->SubSliceCount = hwInfo[i+2];
698 gfxInfo->MaxSubSlicesSupported = hwInfo[i+2];
699 }
700
701 case INTEL_HWCONFIG_MAX_NUM_EU_PER_DSS:
702 {
703 assert(hwInfo[i+1] == 1);
704 gfxInfo->MaxEuPerSubSlice = hwInfo[i+2];
705 }
706
707 case INTEL_HWCONFIG_NUM_THREADS_PER_EU:
708 {
709 assert(hwInfo[i+1] == 1);
710 gfxInfo->NumThreadsPerEu = hwInfo[i+2];
711 }
712
713 case INTEL_HWCONFIG_MAX_VECS:
714 {
715 assert(hwInfo[i+1] == 1);
716 gfxInfo->MaxVECS = hwInfo[i+2];
717 }
718
719 default:
720 break;
721 }
722
723 /* Advance to next key */
724 i += hwInfo[i + 1]; // value size
725 i += 2;// KL size
726 }
727
728 if (hwInfo != nullptr)
729 free(hwInfo);
730
731 return ret;
732 }
733
734 bool BufmgrPrelim::IsQueryEnginesDistanceSupported(struct prelim_drm_i915_query_distance_info *distances)
735 {
736 assert(nullptr != distances);
737 assert(m_fd >= 0);
738
739 struct drm_i915_query_item item;
740 memclear(item);
741 item.query_id = PRELIM_DRM_I915_QUERY_DISTANCE_INFO;
742 item.data_ptr = (uintptr_t)&distances[0];
743 item.length = 0; // When set to zero, this is filled with the size of the data
744
745 if (QueryItems(m_fd, &item, 1))
746 {
747 return false;
748 }
749 return item.length > 0;
750 }
751
752 int BufmgrPrelim::QueryEnginesDistance(unsigned int nengine,
753 struct prelim_drm_i915_query_distance_info *distances)
754 {
755 assert(nullptr != distances);
756 assert(m_fd >= 0);
757
758 int ret = 0;
759 struct drm_i915_query_item *item = nullptr;
760
761 item = (struct drm_i915_query_item *)malloc(nengine * sizeof(struct drm_i915_query_item));
762 GOTO_FINI_IF_MALLOC_FAIL(item);
763
764 GOTO_FINI_IF_NOT_0(!IsQueryEnginesDistanceSupported(distances));
765
766 // Match memory, regions and distances to correct engines
767 memset(item, 0, nengine * sizeof(struct drm_i915_query_item));
768 for (int i = 0; i < nengine; i++)
769 {
770 item[i].query_id = PRELIM_DRM_I915_QUERY_DISTANCE_INFO;
771 item[i].data_ptr = (uintptr_t)&distances[i];
772 item[i].length = sizeof(struct prelim_drm_i915_query_distance_info);
773 }
774
775 GOTO_FINI_IF_NOT_0(ret = QueryItems(m_fd, item, nengine));
776 for (int i = 0; i < nengine; i++)
777 {
778 if (item[i].length < 0) // The kernel sets this value to a negative value to signal an error
779 {
780 distances[i].distance = item[i].length; // Propagate the error up the call stack
781 }
782 }
783
784 fini:
785 if (item)
786 free(item);
787 return ret;
788 }
789
790 int BufmgrPrelim::GetMemoryInfo(bool hasLmem, char *info, uint32_t length)
791 {
792 if (hasLmem) {
793 struct prelim_drm_i915_query_memory_regions *queryInfo = nullptr;
794 queryInfo = QueryMemRegions();
795
796 if (nullptr != queryInfo) {
797 int offset = 0;
798 for (int i = 0; i < queryInfo->num_regions; i++) {
799 uint32_t memory_instance = queryInfo->regions[i].region.memory_instance;
800 uint64_t probed_size = queryInfo->regions[i].probed_size;
801
802 if (queryInfo->regions[i].region.memory_class == PRELIM_I915_MEMORY_CLASS_SYSTEM) {
803 offset += sprintf_s(info + offset, length - offset, "system(0x%x): 0x%lx ", memory_instance, probed_size);
804 }
805 else if (queryInfo->regions[i].region.memory_class == PRELIM_I915_MEMORY_CLASS_DEVICE) {
806 if (queryInfo->regions[i].region.memory_instance == m_tileId) {
807 offset += sprintf_s(info + offset, length - offset, "| *local%d: 0x%lx ", memory_instance, probed_size);
808 }
809 else {
810 offset += sprintf_s(info + offset, length - offset, " | local%d: 0x%lx ", memory_instance, probed_size);
811 }
812 }
813 }
814 free(queryInfo);
815 queryInfo = nullptr;
816 }
817 }
818
819 return 0;
820 }