2 * © Copyright 2019 Collabora, Ltd.
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:
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
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 FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28 #include "drm-uapi/panfrost_drm.h"
30 #include "util/u_memory.h"
31 #include "util/os_time.h"
33 #include "pan_screen.h"
34 #include "pan_resource.h"
35 #include "pan_context.h"
37 #include "pan_trace.h"
40 struct panfrost_driver base
;
45 panfrost_drm_allocate_slab(struct panfrost_screen
*screen
,
46 struct panfrost_memory
*mem
,
53 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
54 struct drm_panfrost_create_bo create_bo
= {
56 .flags
= 0, // TODO figure out proper flags..
58 struct drm_panfrost_mmap_bo mmap_bo
= {0,};
61 // TODO cache allocations
62 // TODO properly handle errors
63 // TODO take into account extra_flags
65 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_CREATE_BO
, &create_bo
);
67 fprintf(stderr
, "DRM_IOCTL_PANFROST_CREATE_BO failed: %d\n", ret
);
71 mem
->gpu
= create_bo
.offset
;
72 mem
->gem_handle
= create_bo
.handle
;
73 mem
->stack_bottom
= 0;
74 mem
->size
= create_bo
.size
;
76 // TODO map and unmap on demand?
77 mmap_bo
.handle
= create_bo
.handle
;
78 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_MMAP_BO
, &mmap_bo
);
80 fprintf(stderr
, "DRM_IOCTL_PANFROST_MMAP_BO failed: %d\n", ret
);
84 mem
->cpu
= mmap(NULL
, mem
->size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
,
85 drm
->fd
, mmap_bo
.offset
);
86 if (mem
->cpu
== MAP_FAILED
) {
87 fprintf(stderr
, "mmap failed: %p\n", mem
->cpu
);
91 /* Record the mmap if we're tracing */
92 if (!(extra_flags
& PAN_ALLOCATE_GROWABLE
))
93 pantrace_mmap(mem
->gpu
, mem
->cpu
, mem
->size
, NULL
);
97 panfrost_drm_free_slab(struct panfrost_screen
*screen
, struct panfrost_memory
*mem
)
99 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
100 struct drm_gem_close gem_close
= {
101 .handle
= mem
->gem_handle
,
105 if (munmap((void *) (uintptr_t) mem
->cpu
, mem
->size
)) {
112 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_GEM_CLOSE
, &gem_close
);
114 fprintf(stderr
, "DRM_IOCTL_GEM_CLOSE failed: %d\n", ret
);
118 mem
->gem_handle
= -1;
121 static struct panfrost_bo
*
122 panfrost_drm_import_bo(struct panfrost_screen
*screen
, struct winsys_handle
*whandle
)
124 struct panfrost_bo
*bo
= CALLOC_STRUCT(panfrost_bo
);
125 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
126 struct drm_panfrost_get_bo_offset get_bo_offset
= {0,};
127 struct drm_panfrost_mmap_bo mmap_bo
= {0,};
131 ret
= drmPrimeFDToHandle(drm
->fd
, whandle
->handle
, &gem_handle
);
134 get_bo_offset
.handle
= gem_handle
;
135 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_GET_BO_OFFSET
, &get_bo_offset
);
138 bo
->gem_handle
= gem_handle
;
139 bo
->gpu
= (mali_ptr
) get_bo_offset
.offset
;
141 // TODO map and unmap on demand?
142 mmap_bo
.handle
= gem_handle
;
143 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_MMAP_BO
, &mmap_bo
);
145 fprintf(stderr
, "DRM_IOCTL_PANFROST_MMAP_BO failed: %d\n", ret
);
149 bo
->size
= lseek(whandle
->handle
, 0, SEEK_END
);
150 assert(bo
->size
> 0);
151 bo
->cpu
= mmap(NULL
, bo
->size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
,
152 drm
->fd
, mmap_bo
.offset
);
153 if (bo
->cpu
== MAP_FAILED
) {
154 fprintf(stderr
, "mmap failed: %p\n", bo
->cpu
);
158 /* Record the mmap if we're tracing */
159 pantrace_mmap(bo
->gpu
, bo
->cpu
, bo
->size
, NULL
);
165 panfrost_drm_export_bo(struct panfrost_screen
*screen
, int gem_handle
, unsigned int stride
, struct winsys_handle
*whandle
)
167 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
168 struct drm_prime_handle args
= {
169 .handle
= gem_handle
,
170 .flags
= DRM_CLOEXEC
,
173 int ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PRIME_HANDLE_TO_FD
, &args
);
177 whandle
->handle
= args
.fd
;
178 whandle
->stride
= stride
;
184 panfrost_drm_free_imported_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
)
186 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
187 struct drm_gem_close gem_close
= {
188 .handle
= bo
->gem_handle
,
192 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_GEM_CLOSE
, &gem_close
);
194 fprintf(stderr
, "DRM_IOCTL_GEM_CLOSE failed: %d\n", ret
);
199 bo
->gpu
= (mali_ptr
)NULL
;
203 panfrost_drm_submit_job(struct panfrost_context
*ctx
, u64 job_desc
, int reqs
, struct pipe_surface
*surf
)
205 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
206 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
207 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
208 struct drm_panfrost_submit submit
= {0,};
211 submit
.in_syncs
= (u64
) (uintptr_t) &ctx
->out_sync
;
212 submit
.in_sync_count
= 1;
214 submit
.out_sync
= ctx
->out_sync
;
216 submit
.jc
= job_desc
;
217 submit
.requirements
= reqs
;
220 struct panfrost_resource
*res
= pan_resource(surf
->texture
);
221 assert(res
->bo
->gem_handle
> 0);
222 bo_handles
[submit
.bo_handle_count
++] = res
->bo
->gem_handle
;
224 if (res
->bo
->checksum_slab
.gem_handle
)
225 bo_handles
[submit
.bo_handle_count
++] = res
->bo
->checksum_slab
.gem_handle
;
228 /* TODO: Add here the transient pools */
229 bo_handles
[submit
.bo_handle_count
++] = ctx
->shaders
.gem_handle
;
230 bo_handles
[submit
.bo_handle_count
++] = ctx
->scratchpad
.gem_handle
;
231 bo_handles
[submit
.bo_handle_count
++] = ctx
->tiler_heap
.gem_handle
;
232 bo_handles
[submit
.bo_handle_count
++] = ctx
->varying_mem
.gem_handle
;
233 bo_handles
[submit
.bo_handle_count
++] = ctx
->misc_0
.gem_handle
;
234 submit
.bo_handles
= (u64
)bo_handles
;
236 /* Dump memory _before_ submitting so we're not corrupted with actual GPU results */
237 pantrace_dump_memory();
239 if (drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_SUBMIT
, &submit
)) {
240 fprintf(stderr
, "Error submitting: %m\n");
244 /* Trace the job if we're doing that and do a memory dump. We may
245 * want to adjust this logic once we're ready to trace FBOs */
246 pantrace_submit_job(submit
.jc
, submit
.requirements
, FALSE
);
252 panfrost_drm_submit_vs_fs_job(struct panfrost_context
*ctx
, bool has_draws
, bool is_scanout
)
254 struct pipe_surface
*surf
= ctx
->pipe_framebuffer
.cbufs
[0];
258 ret
= panfrost_drm_submit_job(ctx
, ctx
->set_value_job
, 0, NULL
);
262 ret
= panfrost_drm_submit_job(ctx
, panfrost_fragment_job(ctx
), PANFROST_JD_REQ_FS
, surf
);
267 static struct panfrost_fence
*
268 panfrost_fence_create(struct panfrost_context
*ctx
)
270 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
271 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
272 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
273 struct panfrost_fence
*f
= calloc(1, sizeof(*f
));
277 /* Snapshot the last Panfrost's rendering's out fence. We'd rather have
278 * another syncobj instead of a sync file, but this is all we get.
279 * (HandleToFD/FDToHandle just gives you another syncobj ID for the
282 drmSyncobjExportSyncFile(drm
->fd
, ctx
->out_sync
, &f
->fd
);
284 fprintf(stderr
, "export failed\n");
289 pipe_reference_init(&f
->reference
, 1);
295 panfrost_drm_force_flush_fragment(struct panfrost_context
*ctx
,
296 struct pipe_fence_handle
**fence
)
298 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
301 struct panfrost_fence
*f
= panfrost_fence_create(ctx
);
302 gallium
->screen
->fence_reference(gallium
->screen
, fence
, NULL
);
303 *fence
= (struct pipe_fence_handle
*)f
;
308 panfrost_drm_enable_counters(struct panfrost_screen
*screen
)
310 fprintf(stderr
, "unimplemented: %s\n", __func__
);
314 panfrost_drm_dump_counters(struct panfrost_screen
*screen
)
316 fprintf(stderr
, "unimplemented: %s\n", __func__
);
320 panfrost_drm_query_gpu_version(struct panfrost_screen
*screen
)
322 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
323 struct drm_panfrost_get_param get_param
= {0,};
326 get_param
.param
= DRM_PANFROST_PARAM_GPU_ID
;
327 ret
= drmIoctl(drm
->fd
, DRM_IOCTL_PANFROST_GET_PARAM
, &get_param
);
330 return get_param
.value
;
334 panfrost_drm_init_context(struct panfrost_context
*ctx
)
336 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
337 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
338 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
340 return drmSyncobjCreate(drm
->fd
, DRM_SYNCOBJ_CREATE_SIGNALED
,
345 panfrost_drm_fence_reference(struct pipe_screen
*screen
,
346 struct pipe_fence_handle
**ptr
,
347 struct pipe_fence_handle
*fence
)
349 struct panfrost_fence
**p
= (struct panfrost_fence
**)ptr
;
350 struct panfrost_fence
*f
= (struct panfrost_fence
*)fence
;
351 struct panfrost_fence
*old
= *p
;
353 if (pipe_reference(&(*p
)->reference
, &f
->reference
)) {
361 panfrost_drm_fence_finish(struct pipe_screen
*pscreen
,
362 struct pipe_context
*ctx
,
363 struct pipe_fence_handle
*fence
,
366 struct panfrost_screen
*screen
= pan_screen(pscreen
);
367 struct panfrost_drm
*drm
= (struct panfrost_drm
*)screen
->driver
;
368 struct panfrost_fence
*f
= (struct panfrost_fence
*)fence
;
372 ret
= drmSyncobjCreate(drm
->fd
, 0, &syncobj
);
374 fprintf(stderr
, "Failed to create syncobj to wait on: %m\n");
378 drmSyncobjImportSyncFile(drm
->fd
, syncobj
, f
->fd
);
380 fprintf(stderr
, "Failed to import fence to syncobj: %m\n");
384 uint64_t abs_timeout
= os_time_get_absolute_timeout(timeout
);
385 if (abs_timeout
== OS_TIMEOUT_INFINITE
)
386 abs_timeout
= INT64_MAX
;
388 ret
= drmSyncobjWait(drm
->fd
, &syncobj
, 1, abs_timeout
, 0, NULL
);
390 drmSyncobjDestroy(drm
->fd
, syncobj
);
395 struct panfrost_driver
*
396 panfrost_create_drm_driver(int fd
)
398 struct panfrost_drm
*driver
= CALLOC_STRUCT(panfrost_drm
);
402 driver
->base
.import_bo
= panfrost_drm_import_bo
;
403 driver
->base
.export_bo
= panfrost_drm_export_bo
;
404 driver
->base
.free_imported_bo
= panfrost_drm_free_imported_bo
;
405 driver
->base
.submit_vs_fs_job
= panfrost_drm_submit_vs_fs_job
;
406 driver
->base
.force_flush_fragment
= panfrost_drm_force_flush_fragment
;
407 driver
->base
.allocate_slab
= panfrost_drm_allocate_slab
;
408 driver
->base
.free_slab
= panfrost_drm_free_slab
;
409 driver
->base
.enable_counters
= panfrost_drm_enable_counters
;
410 driver
->base
.query_gpu_version
= panfrost_drm_query_gpu_version
;
411 driver
->base
.init_context
= panfrost_drm_init_context
;
412 driver
->base
.fence_reference
= panfrost_drm_fence_reference
;
413 driver
->base
.fence_finish
= panfrost_drm_fence_finish
;
414 driver
->base
.dump_counters
= panfrost_drm_dump_counters
;
416 return &driver
->base
;