2 * © Copyright 2019 Collabora, Ltd.
3 * Copyright 2019 Alyssa Rosenzweig
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 #include "drm-uapi/panfrost_drm.h"
31 #include "util/u_memory.h"
32 #include "util/os_time.h"
33 #include "os/os_mman.h"
35 #include "pan_screen.h"
36 #include "pan_resource.h"
37 #include "pan_context.h"
39 #include "pandecode/decode.h"
42 panfrost_drm_mmap_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
)
44 struct drm_panfrost_mmap_bo mmap_bo
= { .handle
= bo
->gem_handle
};
50 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PANFROST_MMAP_BO
, &mmap_bo
);
52 fprintf(stderr
, "DRM_IOCTL_PANFROST_MMAP_BO failed: %m\n");
56 bo
->cpu
= os_mmap(NULL
, bo
->size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
,
57 screen
->fd
, mmap_bo
.offset
);
58 if (bo
->cpu
== MAP_FAILED
) {
59 fprintf(stderr
, "mmap failed: %p %m\n", bo
->cpu
);
63 /* Record the mmap if we're tracing */
64 if (pan_debug
& PAN_DBG_TRACE
)
65 pandecode_inject_mmap(bo
->gpu
, bo
->cpu
, bo
->size
, NULL
);
69 panfrost_drm_munmap_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
)
74 if (os_munmap((void *) (uintptr_t)bo
->cpu
, bo
->size
)) {
83 panfrost_drm_create_bo(struct panfrost_screen
*screen
, size_t size
,
86 struct panfrost_bo
*bo
;
88 /* Kernel will fail (confusingly) with EPERM otherwise */
91 /* To maximize BO cache usage, don't allocate tiny BOs */
92 size
= MAX2(size
, 4096);
94 /* GROWABLE BOs cannot be mmapped */
95 if (flags
& PAN_ALLOCATE_GROWABLE
)
96 assert(flags
& PAN_ALLOCATE_INVISIBLE
);
98 unsigned translated_flags
= 0;
100 if (screen
->kernel_version
->version_major
> 1 ||
101 screen
->kernel_version
->version_minor
>= 1) {
102 if (flags
& PAN_ALLOCATE_GROWABLE
)
103 translated_flags
|= PANFROST_BO_HEAP
;
104 if (!(flags
& PAN_ALLOCATE_EXECUTE
))
105 translated_flags
|= PANFROST_BO_NOEXEC
;
108 struct drm_panfrost_create_bo create_bo
= {
110 .flags
= translated_flags
,
113 /* Before creating a BO, we first want to check the cache */
115 bo
= panfrost_bo_cache_fetch(screen
, size
, flags
);
118 /* Otherwise, the cache misses and we need to allocate a BO fresh from
123 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PANFROST_CREATE_BO
, &create_bo
);
125 fprintf(stderr
, "DRM_IOCTL_PANFROST_CREATE_BO failed: %m\n");
129 /* We have a BO allocated from the kernel; fill in the userspace
132 bo
= rzalloc(screen
, struct panfrost_bo
);
133 bo
->size
= create_bo
.size
;
134 bo
->gpu
= create_bo
.offset
;
135 bo
->gem_handle
= create_bo
.handle
;
139 /* Only mmap now if we know we need to. For CPU-invisible buffers, we
140 * never map since we don't care about their contents; they're purely
141 * for GPU-internal use. But we do trace them anyway. */
143 if (!(flags
& (PAN_ALLOCATE_INVISIBLE
| PAN_ALLOCATE_DELAY_MMAP
)))
144 panfrost_drm_mmap_bo(screen
, bo
);
145 else if (flags
& PAN_ALLOCATE_INVISIBLE
) {
146 if (pan_debug
& PAN_DBG_TRACE
)
147 pandecode_inject_mmap(bo
->gpu
, NULL
, bo
->size
, NULL
);
150 pipe_reference_init(&bo
->reference
, 1);
155 panfrost_drm_release_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
, bool cacheable
)
160 struct drm_gem_close gem_close
= { .handle
= bo
->gem_handle
};
163 /* Rather than freeing the BO now, we'll cache the BO for later
164 * allocations if we're allowed to */
166 panfrost_drm_munmap_bo(screen
, bo
);
169 bool cached
= panfrost_bo_cache_put(screen
, bo
);
175 /* Otherwise, if the BO wasn't cached, we'll legitimately free the BO */
177 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_GEM_CLOSE
, &gem_close
);
179 fprintf(stderr
, "DRM_IOCTL_GEM_CLOSE failed: %m\n");
187 panfrost_drm_allocate_slab(struct panfrost_screen
*screen
,
188 struct panfrost_memory
*mem
,
195 // TODO cache allocations
196 // TODO properly handle errors
197 // TODO take into account extra_flags
198 mem
->bo
= panfrost_drm_create_bo(screen
, pages
* 4096, extra_flags
);
199 mem
->stack_bottom
= 0;
203 panfrost_drm_free_slab(struct panfrost_screen
*screen
, struct panfrost_memory
*mem
)
205 panfrost_bo_unreference(&screen
->base
, mem
->bo
);
210 panfrost_drm_import_bo(struct panfrost_screen
*screen
, int fd
)
212 struct panfrost_bo
*bo
= rzalloc(screen
, struct panfrost_bo
);
213 struct drm_panfrost_get_bo_offset get_bo_offset
= {0,};
217 ret
= drmPrimeFDToHandle(screen
->fd
, fd
, &gem_handle
);
220 get_bo_offset
.handle
= gem_handle
;
221 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PANFROST_GET_BO_OFFSET
, &get_bo_offset
);
224 bo
->gem_handle
= gem_handle
;
225 bo
->gpu
= (mali_ptr
) get_bo_offset
.offset
;
226 bo
->size
= lseek(fd
, 0, SEEK_END
);
227 assert(bo
->size
> 0);
228 pipe_reference_init(&bo
->reference
, 1);
230 // TODO map and unmap on demand?
231 panfrost_drm_mmap_bo(screen
, bo
);
236 panfrost_drm_export_bo(struct panfrost_screen
*screen
, const struct panfrost_bo
*bo
)
238 struct drm_prime_handle args
= {
239 .handle
= bo
->gem_handle
,
240 .flags
= DRM_CLOEXEC
,
243 int ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PRIME_HANDLE_TO_FD
, &args
);
251 panfrost_drm_submit_batch(struct panfrost_batch
*batch
, u64 first_job_desc
,
254 struct panfrost_context
*ctx
= batch
->ctx
;
255 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
256 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
257 struct drm_panfrost_submit submit
= {0,};
258 int *bo_handles
, ret
;
260 submit
.in_syncs
= (u64
) (uintptr_t) &ctx
->out_sync
;
261 submit
.in_sync_count
= 1;
263 submit
.out_sync
= ctx
->out_sync
;
265 submit
.jc
= first_job_desc
;
266 submit
.requirements
= reqs
;
268 bo_handles
= calloc(batch
->bos
->entries
, sizeof(*bo_handles
));
271 set_foreach(batch
->bos
, entry
) {
272 struct panfrost_bo
*bo
= (struct panfrost_bo
*)entry
->key
;
273 assert(bo
->gem_handle
> 0);
274 bo_handles
[submit
.bo_handle_count
++] = bo
->gem_handle
;
277 submit
.bo_handles
= (u64
) (uintptr_t) bo_handles
;
278 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PANFROST_SUBMIT
, &submit
);
281 fprintf(stderr
, "Error submitting: %m\n");
285 /* Trace the job if we're doing that */
286 if (pan_debug
& PAN_DBG_TRACE
) {
287 /* Wait so we can get errors reported back */
288 drmSyncobjWait(screen
->fd
, &ctx
->out_sync
, 1, INT64_MAX
, 0, NULL
);
289 pandecode_jc(submit
.jc
, FALSE
);
296 panfrost_drm_submit_vs_fs_batch(struct panfrost_batch
*batch
, bool has_draws
)
298 struct panfrost_context
*ctx
= batch
->ctx
;
301 panfrost_batch_add_bo(batch
, ctx
->scratchpad
.bo
);
302 panfrost_batch_add_bo(batch
, ctx
->tiler_heap
.bo
);
303 panfrost_batch_add_bo(batch
, batch
->polygon_list
);
305 if (batch
->first_job
.gpu
) {
306 ret
= panfrost_drm_submit_batch(batch
, batch
->first_job
.gpu
, 0);
310 if (batch
->first_tiler
.gpu
|| batch
->clear
) {
311 ret
= panfrost_drm_submit_batch(batch
,
312 panfrost_fragment_job(ctx
, has_draws
),
320 static struct panfrost_fence
*
321 panfrost_fence_create(struct panfrost_context
*ctx
)
323 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
324 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
325 struct panfrost_fence
*f
= calloc(1, sizeof(*f
));
329 /* Snapshot the last Panfrost's rendering's out fence. We'd rather have
330 * another syncobj instead of a sync file, but this is all we get.
331 * (HandleToFD/FDToHandle just gives you another syncobj ID for the
334 drmSyncobjExportSyncFile(screen
->fd
, ctx
->out_sync
, &f
->fd
);
336 fprintf(stderr
, "export failed: %m\n");
341 pipe_reference_init(&f
->reference
, 1);
347 panfrost_drm_force_flush_fragment(struct panfrost_context
*ctx
,
348 struct pipe_fence_handle
**fence
)
350 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
351 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
353 if (!ctx
->last_fragment_flushed
) {
354 drmSyncobjWait(screen
->fd
, &ctx
->out_sync
, 1, INT64_MAX
, 0, NULL
);
355 ctx
->last_fragment_flushed
= true;
357 /* The job finished up, so we're safe to clean it up now */
358 panfrost_free_batch(ctx
->last_batch
);
362 struct panfrost_fence
*f
= panfrost_fence_create(ctx
);
363 gallium
->screen
->fence_reference(gallium
->screen
, fence
, NULL
);
364 *fence
= (struct pipe_fence_handle
*)f
;
369 panfrost_drm_query_gpu_version(struct panfrost_screen
*screen
)
371 struct drm_panfrost_get_param get_param
= {0,};
374 get_param
.param
= DRM_PANFROST_PARAM_GPU_PROD_ID
;
375 ret
= drmIoctl(screen
->fd
, DRM_IOCTL_PANFROST_GET_PARAM
, &get_param
);
378 return get_param
.value
;
382 panfrost_drm_init_context(struct panfrost_context
*ctx
)
384 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
385 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
387 return drmSyncobjCreate(screen
->fd
, DRM_SYNCOBJ_CREATE_SIGNALED
,
392 panfrost_drm_fence_reference(struct pipe_screen
*screen
,
393 struct pipe_fence_handle
**ptr
,
394 struct pipe_fence_handle
*fence
)
396 struct panfrost_fence
**p
= (struct panfrost_fence
**)ptr
;
397 struct panfrost_fence
*f
= (struct panfrost_fence
*)fence
;
398 struct panfrost_fence
*old
= *p
;
400 if (pipe_reference(&(*p
)->reference
, &f
->reference
)) {
408 panfrost_drm_fence_finish(struct pipe_screen
*pscreen
,
409 struct pipe_context
*ctx
,
410 struct pipe_fence_handle
*fence
,
413 struct panfrost_screen
*screen
= pan_screen(pscreen
);
414 struct panfrost_fence
*f
= (struct panfrost_fence
*)fence
;
418 ret
= drmSyncobjCreate(screen
->fd
, 0, &syncobj
);
420 fprintf(stderr
, "Failed to create syncobj to wait on: %m\n");
424 ret
= drmSyncobjImportSyncFile(screen
->fd
, syncobj
, f
->fd
);
426 fprintf(stderr
, "Failed to import fence to syncobj: %m\n");
430 uint64_t abs_timeout
= os_time_get_absolute_timeout(timeout
);
431 if (abs_timeout
== OS_TIMEOUT_INFINITE
)
432 abs_timeout
= INT64_MAX
;
434 ret
= drmSyncobjWait(screen
->fd
, &syncobj
, 1, abs_timeout
, 0, NULL
);
436 drmSyncobjDestroy(screen
->fd
, syncobj
);