2 * Copyright (C) 2008 VMware, Inc.
3 * Copyright (C) 2014 Broadcom
4 * Copyright (C) 2018-2019 Alyssa Rosenzweig
5 * Copyright (C) 2019 Collabora, Ltd.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * Authors (Collabora):
27 * Tomeu Vizoso <tomeu.vizoso@collabora.com>
28 * Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
34 #include "drm-uapi/drm_fourcc.h"
36 #include "state_tracker/winsys_handle.h"
37 #include "util/u_format.h"
38 #include "util/u_memory.h"
39 #include "util/u_surface.h"
40 #include "util/u_transfer.h"
41 #include "util/u_transfer_helper.h"
42 #include "util/u_gen_mipmap.h"
44 #include "pan_context.h"
45 #include "pan_screen.h"
46 #include "pan_resource.h"
48 #include "pan_tiling.h"
50 static struct pipe_resource
*
51 panfrost_resource_from_handle(struct pipe_screen
*pscreen
,
52 const struct pipe_resource
*templat
,
53 struct winsys_handle
*whandle
,
56 struct panfrost_screen
*screen
= pan_screen(pscreen
);
57 struct panfrost_resource
*rsc
;
58 struct pipe_resource
*prsc
;
60 assert(whandle
->type
== WINSYS_HANDLE_TYPE_FD
);
62 rsc
= rzalloc(pscreen
, struct panfrost_resource
);
70 pipe_reference_init(&prsc
->reference
, 1);
71 prsc
->screen
= pscreen
;
73 rsc
->bo
= panfrost_drm_import_bo(screen
, whandle
);
74 rsc
->slices
[0].stride
= whandle
->stride
;
75 rsc
->slices
[0].initialized
= true;
79 renderonly_create_gpu_import_for_resource(prsc
, screen
->ro
, NULL
);
80 /* failure is expected in some cases.. */
87 panfrost_resource_get_handle(struct pipe_screen
*pscreen
,
88 struct pipe_context
*ctx
,
89 struct pipe_resource
*pt
,
90 struct winsys_handle
*handle
,
93 struct panfrost_screen
*screen
= pan_screen(pscreen
);
94 struct panfrost_resource
*rsrc
= (struct panfrost_resource
*) pt
;
95 struct renderonly_scanout
*scanout
= rsrc
->scanout
;
97 handle
->modifier
= DRM_FORMAT_MOD_INVALID
;
99 if (handle
->type
== WINSYS_HANDLE_TYPE_SHARED
) {
101 } else if (handle
->type
== WINSYS_HANDLE_TYPE_KMS
) {
102 if (renderonly_get_handle(scanout
, handle
))
105 handle
->handle
= rsrc
->bo
->gem_handle
;
106 handle
->stride
= rsrc
->slices
[0].stride
;
108 } else if (handle
->type
== WINSYS_HANDLE_TYPE_FD
) {
110 struct drm_prime_handle args
= {
111 .handle
= scanout
->handle
,
112 .flags
= DRM_CLOEXEC
,
115 int ret
= drmIoctl(screen
->ro
->kms_fd
, DRM_IOCTL_PRIME_HANDLE_TO_FD
, &args
);
119 handle
->stride
= scanout
->stride
;
120 handle
->handle
= args
.fd
;
124 return panfrost_drm_export_bo(screen
, rsrc
->bo
->gem_handle
,
125 rsrc
->slices
[0].stride
,
133 panfrost_flush_resource(struct pipe_context
*pctx
, struct pipe_resource
*prsc
)
135 //DBG("TODO %s\n", __func__);
138 static struct pipe_surface
*
139 panfrost_create_surface(struct pipe_context
*pipe
,
140 struct pipe_resource
*pt
,
141 const struct pipe_surface
*surf_tmpl
)
143 struct pipe_surface
*ps
= NULL
;
145 ps
= rzalloc(pipe
, struct pipe_surface
);
148 pipe_reference_init(&ps
->reference
, 1);
149 pipe_resource_reference(&ps
->texture
, pt
);
151 ps
->format
= surf_tmpl
->format
;
153 if (pt
->target
!= PIPE_BUFFER
) {
154 assert(surf_tmpl
->u
.tex
.level
<= pt
->last_level
);
155 ps
->width
= u_minify(pt
->width0
, surf_tmpl
->u
.tex
.level
);
156 ps
->height
= u_minify(pt
->height0
, surf_tmpl
->u
.tex
.level
);
157 ps
->u
.tex
.level
= surf_tmpl
->u
.tex
.level
;
158 ps
->u
.tex
.first_layer
= surf_tmpl
->u
.tex
.first_layer
;
159 ps
->u
.tex
.last_layer
= surf_tmpl
->u
.tex
.last_layer
;
161 /* setting width as number of elements should get us correct renderbuffer width */
162 ps
->width
= surf_tmpl
->u
.buf
.last_element
- surf_tmpl
->u
.buf
.first_element
+ 1;
163 ps
->height
= pt
->height0
;
164 ps
->u
.buf
.first_element
= surf_tmpl
->u
.buf
.first_element
;
165 ps
->u
.buf
.last_element
= surf_tmpl
->u
.buf
.last_element
;
166 assert(ps
->u
.buf
.first_element
<= ps
->u
.buf
.last_element
);
167 assert(ps
->u
.buf
.last_element
< ps
->width
);
175 panfrost_surface_destroy(struct pipe_context
*pipe
,
176 struct pipe_surface
*surf
)
178 assert(surf
->texture
);
179 pipe_resource_reference(&surf
->texture
, NULL
);
183 static struct pipe_resource
*
184 panfrost_create_scanout_res(struct pipe_screen
*screen
,
185 const struct pipe_resource
*template)
187 struct panfrost_screen
*pscreen
= pan_screen(screen
);
188 struct pipe_resource scanout_templat
= *template;
189 struct renderonly_scanout
*scanout
;
190 struct winsys_handle handle
;
191 struct pipe_resource
*res
;
193 scanout
= renderonly_scanout_for_resource(&scanout_templat
,
194 pscreen
->ro
, &handle
);
198 assert(handle
.type
== WINSYS_HANDLE_TYPE_FD
);
199 /* TODO: handle modifiers? */
200 res
= screen
->resource_from_handle(screen
, template, &handle
,
201 PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE
);
202 close(handle
.handle
);
206 struct panfrost_resource
*pres
= pan_resource(res
);
208 pres
->scanout
= scanout
;
209 pscreen
->display_target
= pres
;
214 /* Computes sizes for checksumming, which is 8 bytes per 16x16 tile */
216 #define CHECKSUM_TILE_WIDTH 16
217 #define CHECKSUM_TILE_HEIGHT 16
218 #define CHECKSUM_BYTES_PER_TILE 8
221 panfrost_compute_checksum_sizes(
222 struct panfrost_slice
*slice
,
226 unsigned aligned_width
= ALIGN(width
, CHECKSUM_TILE_WIDTH
);
227 unsigned aligned_height
= ALIGN(height
, CHECKSUM_TILE_HEIGHT
);
229 unsigned tile_count_x
= aligned_width
/ CHECKSUM_TILE_WIDTH
;
230 unsigned tile_count_y
= aligned_height
/ CHECKSUM_TILE_HEIGHT
;
232 slice
->checksum_stride
= tile_count_x
* CHECKSUM_BYTES_PER_TILE
;
234 return slice
->checksum_stride
* tile_count_y
;
237 /* Setup the mip tree given a particular layout, possibly with checksumming */
240 panfrost_setup_slices(struct panfrost_resource
*pres
, size_t *bo_size
)
242 struct pipe_resource
*res
= &pres
->base
;
243 unsigned width
= res
->width0
;
244 unsigned height
= res
->height0
;
245 unsigned depth
= res
->depth0
;
246 unsigned bytes_per_pixel
= util_format_get_blocksize(res
->format
);
250 /* Tiled operates blockwise; linear is packed. Also, anything
251 * we render to has to be tile-aligned. Maybe not strictly
252 * necessary, but we're not *that* pressed for memory and it
253 * makes code a lot simpler */
255 bool renderable
= res
->bind
&
256 (PIPE_BIND_RENDER_TARGET
| PIPE_BIND_DEPTH_STENCIL
);
257 bool afbc
= pres
->layout
== PAN_AFBC
;
258 bool tiled
= pres
->layout
== PAN_TILED
;
259 bool should_align
= renderable
|| tiled
;
261 /* We don't know how to specify a 2D stride for 3D textures */
263 bool can_align_stride
=
264 res
->target
!= PIPE_TEXTURE_3D
;
266 should_align
&= can_align_stride
;
269 unsigned size_2d
= 0;
271 for (unsigned l
= 0; l
<= res
->last_level
; ++l
) {
272 struct panfrost_slice
*slice
= &pres
->slices
[l
];
274 unsigned effective_width
= width
;
275 unsigned effective_height
= height
;
276 unsigned effective_depth
= depth
;
279 effective_width
= ALIGN(effective_width
, 16);
280 effective_height
= ALIGN(effective_height
, 16);
282 /* We don't need to align depth */
285 slice
->offset
= offset
;
287 /* Compute the would-be stride */
288 unsigned stride
= bytes_per_pixel
* effective_width
;
290 /* ..but cache-line align it for performance */
291 if (can_align_stride
&& pres
->layout
== PAN_LINEAR
)
292 stride
= ALIGN(stride
, 64);
294 slice
->stride
= stride
;
296 unsigned slice_one_size
= slice
->stride
* effective_height
;
297 unsigned slice_full_size
= slice_one_size
* effective_depth
;
299 /* Report 2D size for 3D texturing */
302 size_2d
= slice_one_size
;
304 /* Compute AFBC sizes if necessary */
307 panfrost_afbc_header_size(width
, height
);
309 offset
+= slice
->header_size
;
312 offset
+= slice_full_size
;
314 /* Add a checksum region if necessary */
315 if (pres
->checksummed
) {
316 slice
->checksum_offset
= offset
;
318 unsigned size
= panfrost_compute_checksum_sizes(
319 slice
, width
, height
);
324 width
= u_minify(width
, 1);
325 height
= u_minify(height
, 1);
326 depth
= u_minify(depth
, 1);
329 assert(res
->array_size
);
331 if (res
->target
!= PIPE_TEXTURE_3D
) {
332 /* Arrays and cubemaps have the entire miptree duplicated */
334 pres
->cubemap_stride
= ALIGN(offset
, 64);
335 *bo_size
= ALIGN(pres
->cubemap_stride
* res
->array_size
, 4096);
337 /* 3D strides across the 2D layers */
338 assert(res
->array_size
== 1);
340 pres
->cubemap_stride
= size_2d
;
341 *bo_size
= ALIGN(offset
, 4096);
346 panfrost_resource_create_bo(struct panfrost_screen
*screen
, struct panfrost_resource
*pres
)
348 struct pipe_resource
*res
= &pres
->base
;
350 /* Based on the usage, figure out what storing will be used. There are
353 * Linear: the basic format, bad for memory bandwidth, bad for cache
354 * use. Zero-copy, though. Renderable.
356 * Tiled: Not compressed, but cache-optimized. Expensive to write into
357 * (due to software tiling), but cheap to sample from. Ideal for most
360 * AFBC: Compressed and renderable (so always desirable for non-scanout
361 * rendertargets). Cheap to sample from. The format is black box, so we
362 * can't read/write from software.
365 /* Tiling textures is almost always faster, unless we only use it once */
367 bool is_texture
= (res
->bind
& PIPE_BIND_SAMPLER_VIEW
);
368 bool is_2d
= res
->depth0
== 1 && res
->array_size
== 1;
369 bool is_streaming
= (res
->usage
!= PIPE_USAGE_STREAM
);
371 bool should_tile
= is_streaming
&& is_texture
&& is_2d
;
373 /* Depth/stencil can't be tiled, only linear or AFBC */
374 should_tile
&= !(res
->bind
& PIPE_BIND_DEPTH_STENCIL
);
376 /* FBOs we would like to checksum, if at all possible */
377 bool can_checksum
= !(res
->bind
& (PIPE_BIND_SCANOUT
| PIPE_BIND_SHARED
));
378 bool should_checksum
= res
->bind
& PIPE_BIND_RENDER_TARGET
;
380 pres
->checksummed
= can_checksum
&& should_checksum
;
382 /* Set the layout appropriately */
383 pres
->layout
= should_tile
? PAN_TILED
: PAN_LINEAR
;
387 panfrost_setup_slices(pres
, &bo_size
);
389 struct panfrost_memory mem
;
390 struct panfrost_bo
*bo
= rzalloc(screen
, struct panfrost_bo
);
392 pipe_reference_init(&bo
->reference
, 1);
393 panfrost_drm_allocate_slab(screen
, &mem
, bo_size
/ 4096, true, 0, 0, 0);
397 bo
->gem_handle
= mem
.gem_handle
;
402 static struct pipe_resource
*
403 panfrost_resource_create(struct pipe_screen
*screen
,
404 const struct pipe_resource
*template)
406 /* Make sure we're familiar */
407 switch (template->target
) {
409 case PIPE_TEXTURE_1D
:
410 case PIPE_TEXTURE_2D
:
411 case PIPE_TEXTURE_3D
:
412 case PIPE_TEXTURE_CUBE
:
413 case PIPE_TEXTURE_RECT
:
414 case PIPE_TEXTURE_2D_ARRAY
:
417 DBG("Unknown texture target %d\n", template->target
);
422 (PIPE_BIND_DISPLAY_TARGET
| PIPE_BIND_SCANOUT
| PIPE_BIND_SHARED
))
423 return panfrost_create_scanout_res(screen
, template);
425 struct panfrost_resource
*so
= rzalloc(screen
, struct panfrost_resource
);
426 struct panfrost_screen
*pscreen
= (struct panfrost_screen
*) screen
;
428 so
->base
= *template;
429 so
->base
.screen
= screen
;
431 pipe_reference_init(&so
->base
.reference
, 1);
433 util_range_init(&so
->valid_buffer_range
);
435 panfrost_resource_create_bo(pscreen
, so
);
436 return (struct pipe_resource
*)so
;
440 panfrost_destroy_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
)
442 struct panfrost_memory mem
= {
446 .gem_handle
= bo
->gem_handle
,
449 panfrost_drm_free_slab(screen
, &mem
);
454 panfrost_bo_reference(struct panfrost_bo
*bo
)
456 pipe_reference(NULL
, &bo
->reference
);
460 panfrost_bo_unreference(struct pipe_screen
*screen
, struct panfrost_bo
*bo
)
462 /* When the reference count goes to zero, we need to cleanup */
464 if (pipe_reference(&bo
->reference
, NULL
)) {
465 panfrost_destroy_bo(pan_screen(screen
), bo
);
470 panfrost_resource_destroy(struct pipe_screen
*screen
,
471 struct pipe_resource
*pt
)
473 struct panfrost_screen
*pscreen
= pan_screen(screen
);
474 struct panfrost_resource
*rsrc
= (struct panfrost_resource
*) pt
;
477 renderonly_scanout_destroy(rsrc
->scanout
, pscreen
->ro
);
480 panfrost_bo_unreference(screen
, rsrc
->bo
);
482 util_range_destroy(&rsrc
->valid_buffer_range
);
487 panfrost_transfer_map(struct pipe_context
*pctx
,
488 struct pipe_resource
*resource
,
490 unsigned usage
, /* a combination of PIPE_TRANSFER_x */
491 const struct pipe_box
*box
,
492 struct pipe_transfer
**out_transfer
)
494 int bytes_per_pixel
= util_format_get_blocksize(resource
->format
);
495 struct panfrost_resource
*rsrc
= pan_resource(resource
);
496 struct panfrost_bo
*bo
= rsrc
->bo
;
498 struct panfrost_gtransfer
*transfer
= rzalloc(pctx
, struct panfrost_gtransfer
);
499 transfer
->base
.level
= level
;
500 transfer
->base
.usage
= usage
;
501 transfer
->base
.box
= *box
;
503 pipe_resource_reference(&transfer
->base
.resource
, resource
);
505 *out_transfer
= &transfer
->base
;
507 /* Check if we're bound for rendering and this is a read pixels. If so,
508 * we need to flush */
510 struct panfrost_context
*ctx
= pan_context(pctx
);
511 struct pipe_framebuffer_state
*fb
= &ctx
->pipe_framebuffer
;
513 bool is_bound
= false;
515 for (unsigned c
= 0; c
< fb
->nr_cbufs
; ++c
) {
516 is_bound
|= fb
->cbufs
[c
]->texture
== resource
;
519 if (is_bound
&& (usage
& PIPE_TRANSFER_READ
)) {
521 panfrost_flush(pctx
, NULL
, PIPE_FLUSH_END_OF_FRAME
);
524 /* TODO: Respect usage flags */
526 if (usage
& PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE
) {
527 /* TODO: reallocate */
528 //printf("debug: Missed reallocate\n");
529 } else if ((usage
& PIPE_TRANSFER_WRITE
)
530 && resource
->target
== PIPE_BUFFER
531 && !util_ranges_intersect(&rsrc
->valid_buffer_range
, box
->x
, box
->x
+ box
->width
)) {
532 /* No flush for writes to uninitialized */
533 } else if (!(usage
& PIPE_TRANSFER_UNSYNCHRONIZED
)) {
534 if (usage
& PIPE_TRANSFER_WRITE
) {
535 /* STUB: flush reading */
536 //printf("debug: missed reading flush %d\n", resource->target);
537 } else if (usage
& PIPE_TRANSFER_READ
) {
538 /* STUB: flush writing */
539 //printf("debug: missed writing flush %d (%d-%d)\n", resource->target, box->x, box->x + box->width);
541 /* Why are you even mapping?! */
545 if (rsrc
->layout
!= PAN_LINEAR
) {
546 /* Non-linear resources need to be indirectly mapped */
548 if (usage
& PIPE_TRANSFER_MAP_DIRECTLY
)
551 transfer
->base
.stride
= box
->width
* bytes_per_pixel
;
552 transfer
->base
.layer_stride
= transfer
->base
.stride
* box
->height
;
553 transfer
->map
= rzalloc_size(transfer
, transfer
->base
.layer_stride
* box
->depth
);
554 assert(box
->depth
== 1);
556 if ((usage
& PIPE_TRANSFER_READ
) && rsrc
->slices
[level
].initialized
) {
557 if (rsrc
->layout
== PAN_AFBC
) {
558 DBG("Unimplemented: reads from AFBC");
559 } else if (rsrc
->layout
== PAN_TILED
) {
560 panfrost_load_tiled_image(
562 bo
->cpu
+ rsrc
->slices
[level
].offset
,
564 transfer
->base
.stride
,
565 rsrc
->slices
[level
].stride
,
566 util_format_get_blocksize(resource
->format
));
570 return transfer
->map
;
572 transfer
->base
.stride
= rsrc
->slices
[level
].stride
;
573 transfer
->base
.layer_stride
= rsrc
->cubemap_stride
;
575 /* By mapping direct-write, we're implicitly already
576 * initialized (maybe), so be conservative */
578 if ((usage
& PIPE_TRANSFER_WRITE
) && (usage
& PIPE_TRANSFER_MAP_DIRECTLY
))
579 rsrc
->slices
[level
].initialized
= true;
582 + rsrc
->slices
[level
].offset
583 + transfer
->base
.box
.z
* rsrc
->cubemap_stride
584 + transfer
->base
.box
.y
* rsrc
->slices
[level
].stride
585 + transfer
->base
.box
.x
* bytes_per_pixel
;
590 panfrost_transfer_unmap(struct pipe_context
*pctx
,
591 struct pipe_transfer
*transfer
)
593 /* Gallium expects writeback here, so we tile */
595 struct panfrost_gtransfer
*trans
= pan_transfer(transfer
);
596 struct panfrost_resource
*prsrc
= (struct panfrost_resource
*) transfer
->resource
;
599 struct panfrost_bo
*bo
= prsrc
->bo
;
601 if (transfer
->usage
& PIPE_TRANSFER_WRITE
) {
602 unsigned level
= transfer
->level
;
603 prsrc
->slices
[level
].initialized
= true;
605 if (prsrc
->layout
== PAN_AFBC
) {
606 DBG("Unimplemented: writes to AFBC\n");
607 } else if (prsrc
->layout
== PAN_TILED
) {
608 assert(transfer
->box
.depth
== 1);
610 panfrost_store_tiled_image(
611 bo
->cpu
+ prsrc
->slices
[level
].offset
,
614 prsrc
->slices
[level
].stride
,
616 util_format_get_blocksize(prsrc
->base
.format
));
622 util_range_add(&prsrc
->valid_buffer_range
,
624 transfer
->box
.x
+ transfer
->box
.width
);
626 /* Derefence the resource */
627 pipe_resource_reference(&transfer
->resource
, NULL
);
629 /* Transfer itself is RALLOCed at the moment */
630 ralloc_free(transfer
);
634 panfrost_transfer_flush_region(struct pipe_context
*pctx
,
635 struct pipe_transfer
*transfer
,
636 const struct pipe_box
*box
)
638 struct panfrost_resource
*rsc
= pan_resource(transfer
->resource
);
640 if (transfer
->resource
->target
== PIPE_BUFFER
) {
641 util_range_add(&rsc
->valid_buffer_range
,
642 transfer
->box
.x
+ box
->x
,
643 transfer
->box
.x
+ box
->x
+ box
->width
);
647 static struct pb_slab
*
648 panfrost_slab_alloc(void *priv
, unsigned heap
, unsigned entry_size
, unsigned group_index
)
650 struct panfrost_screen
*screen
= (struct panfrost_screen
*) priv
;
651 struct panfrost_memory
*mem
= rzalloc(screen
, struct panfrost_memory
);
653 size_t slab_size
= (1 << (MAX_SLAB_ENTRY_SIZE
+ 1));
655 mem
->slab
.num_entries
= slab_size
/ entry_size
;
656 mem
->slab
.num_free
= mem
->slab
.num_entries
;
658 LIST_INITHEAD(&mem
->slab
.free
);
659 for (unsigned i
= 0; i
< mem
->slab
.num_entries
; ++i
) {
660 /* Create a slab entry */
661 struct panfrost_memory_entry
*entry
= rzalloc(mem
, struct panfrost_memory_entry
);
662 entry
->offset
= entry_size
* i
;
664 entry
->base
.slab
= &mem
->slab
;
665 entry
->base
.group_index
= group_index
;
667 LIST_ADDTAIL(&entry
->base
.head
, &mem
->slab
.free
);
670 /* Actually allocate the memory from kernel-space. Mapped, same_va, no
673 panfrost_drm_allocate_slab(screen
, mem
, slab_size
/ 4096, true, 0, 0, 0);
679 panfrost_slab_can_reclaim(void *priv
, struct pb_slab_entry
*entry
)
681 struct panfrost_memory_entry
*p_entry
= (struct panfrost_memory_entry
*) entry
;
682 return p_entry
->freed
;
686 panfrost_slab_free(void *priv
, struct pb_slab
*slab
)
688 struct panfrost_memory
*mem
= (struct panfrost_memory
*) slab
;
689 struct panfrost_screen
*screen
= (struct panfrost_screen
*) priv
;
691 panfrost_drm_free_slab(screen
, mem
);
696 panfrost_invalidate_resource(struct pipe_context
*pctx
, struct pipe_resource
*prsc
)
698 //DBG("TODO %s\n", __func__);
701 static enum pipe_format
702 panfrost_resource_get_internal_format(struct pipe_resource
*prsrc
)
704 return prsrc
->format
;
708 panfrost_generate_mipmap(
709 struct pipe_context
*pctx
,
710 struct pipe_resource
*prsrc
,
711 enum pipe_format format
,
714 unsigned first_layer
,
717 struct panfrost_context
*ctx
= pan_context(pctx
);
718 struct panfrost_resource
*rsrc
= pan_resource(prsrc
);
720 /* Generating a mipmap invalidates the written levels, so make that
721 * explicit so we don't try to wallpaper them back and end up with
722 * u_blitter recursion */
725 for (unsigned l
= base_level
+ 1; l
<= last_level
; ++l
)
726 rsrc
->slices
[l
].initialized
= false;
728 /* Beyond that, we just delegate the hard stuff. We're careful to
729 * include flushes on both ends to make sure the data is really valid.
730 * We could be doing a lot better perf-wise, especially once we have
731 * reorder-type optimizations in place. But for now prioritize
734 struct panfrost_job
*job
= panfrost_get_job_for_fbo(ctx
);
735 bool has_draws
= job
->last_job
.gpu
;
738 panfrost_flush(pctx
, NULL
, PIPE_FLUSH_END_OF_FRAME
);
740 /* We've flushed the original buffer if needed, now trigger a blit */
742 bool blit_res
= util_gen_mipmap(
744 base_level
, last_level
,
745 first_layer
, last_layer
,
746 PIPE_TEX_FILTER_LINEAR
);
748 /* If the blit was successful, flush once more. If it wasn't, well, let
749 * the state tracker deal with it. */
752 panfrost_flush(pctx
, NULL
, PIPE_FLUSH_END_OF_FRAME
);
757 /* Computes the address to a texture at a particular slice */
760 panfrost_get_texture_address(
761 struct panfrost_resource
*rsrc
,
762 unsigned level
, unsigned face
)
764 unsigned level_offset
= rsrc
->slices
[level
].offset
;
765 unsigned face_offset
= face
* rsrc
->cubemap_stride
;
767 return rsrc
->bo
->gpu
+ level_offset
+ face_offset
;
771 panfrost_resource_set_stencil(struct pipe_resource
*prsrc
,
772 struct pipe_resource
*stencil
)
774 pan_resource(prsrc
)->separate_stencil
= pan_resource(stencil
);
777 static struct pipe_resource
*
778 panfrost_resource_get_stencil(struct pipe_resource
*prsrc
)
780 return &pan_resource(prsrc
)->separate_stencil
->base
;
783 static const struct u_transfer_vtbl transfer_vtbl
= {
784 .resource_create
= panfrost_resource_create
,
785 .resource_destroy
= panfrost_resource_destroy
,
786 .transfer_map
= panfrost_transfer_map
,
787 .transfer_unmap
= panfrost_transfer_unmap
,
788 .transfer_flush_region
= panfrost_transfer_flush_region
,
789 .get_internal_format
= panfrost_resource_get_internal_format
,
790 .set_stencil
= panfrost_resource_set_stencil
,
791 .get_stencil
= panfrost_resource_get_stencil
,
795 panfrost_resource_screen_init(struct panfrost_screen
*pscreen
)
797 //pscreen->base.resource_create_with_modifiers =
798 // panfrost_resource_create_with_modifiers;
799 pscreen
->base
.resource_create
= u_transfer_helper_resource_create
;
800 pscreen
->base
.resource_destroy
= u_transfer_helper_resource_destroy
;
801 pscreen
->base
.resource_from_handle
= panfrost_resource_from_handle
;
802 pscreen
->base
.resource_get_handle
= panfrost_resource_get_handle
;
803 pscreen
->base
.transfer_helper
= u_transfer_helper_create(&transfer_vtbl
,
807 pb_slabs_init(&pscreen
->slabs
,
811 3, /* Number of heaps */
815 panfrost_slab_can_reclaim
,
821 panfrost_resource_screen_deinit(struct panfrost_screen
*pscreen
)
823 pb_slabs_deinit(&pscreen
->slabs
);
827 panfrost_resource_context_init(struct pipe_context
*pctx
)
829 pctx
->transfer_map
= u_transfer_helper_transfer_map
;
830 pctx
->transfer_flush_region
= u_transfer_helper_transfer_flush_region
;
831 pctx
->transfer_unmap
= u_transfer_helper_transfer_unmap
;
832 pctx
->buffer_subdata
= u_default_buffer_subdata
;
833 pctx
->create_surface
= panfrost_create_surface
;
834 pctx
->surface_destroy
= panfrost_surface_destroy
;
835 pctx
->resource_copy_region
= util_resource_copy_region
;
836 pctx
->blit
= panfrost_blit
;
837 pctx
->generate_mipmap
= panfrost_generate_mipmap
;
838 pctx
->flush_resource
= panfrost_flush_resource
;
839 pctx
->invalidate_resource
= panfrost_invalidate_resource
;
840 pctx
->transfer_flush_region
= u_transfer_helper_transfer_flush_region
;
841 pctx
->buffer_subdata
= u_default_buffer_subdata
;
842 pctx
->texture_subdata
= u_default_texture_subdata
;