2 * Copyright (C) 2008 VMware, Inc.
3 * Copyright (C) 2014 Broadcom
4 * Copyright (C) 2018-2019 Alyssa Rosenzweig
5 * Copyright (C) 2019 Collabora
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"
43 #include "pan_context.h"
44 #include "pan_screen.h"
45 #include "pan_resource.h"
46 #include "pan_swizzle.h"
49 static struct pipe_resource
*
50 panfrost_resource_from_handle(struct pipe_screen
*pscreen
,
51 const struct pipe_resource
*templat
,
52 struct winsys_handle
*whandle
,
55 struct panfrost_screen
*screen
= pan_screen(pscreen
);
56 struct panfrost_resource
*rsc
;
57 struct pipe_resource
*prsc
;
59 assert(whandle
->type
== WINSYS_HANDLE_TYPE_FD
);
61 rsc
= rzalloc(pscreen
, struct panfrost_resource
);
69 pipe_reference_init(&prsc
->reference
, 1);
70 prsc
->screen
= pscreen
;
72 rsc
->bo
= screen
->driver
->import_bo(screen
, whandle
);
73 rsc
->bo
->slices
[0].stride
= whandle
->stride
;
77 renderonly_create_gpu_import_for_resource(prsc
, screen
->ro
, NULL
);
78 /* failure is expected in some cases.. */
85 panfrost_resource_get_handle(struct pipe_screen
*pscreen
,
86 struct pipe_context
*ctx
,
87 struct pipe_resource
*pt
,
88 struct winsys_handle
*handle
,
91 struct panfrost_screen
*screen
= pan_screen(pscreen
);
92 struct panfrost_resource
*rsrc
= (struct panfrost_resource
*) pt
;
93 struct renderonly_scanout
*scanout
= rsrc
->scanout
;
95 handle
->modifier
= DRM_FORMAT_MOD_INVALID
;
97 if (handle
->type
== WINSYS_HANDLE_TYPE_SHARED
) {
99 } else if (handle
->type
== WINSYS_HANDLE_TYPE_KMS
) {
100 if (renderonly_get_handle(scanout
, handle
))
103 handle
->handle
= rsrc
->bo
->gem_handle
;
104 handle
->stride
= rsrc
->bo
->slices
[0].stride
;
106 } else if (handle
->type
== WINSYS_HANDLE_TYPE_FD
) {
108 struct drm_prime_handle args
= {
109 .handle
= scanout
->handle
,
110 .flags
= DRM_CLOEXEC
,
113 int ret
= drmIoctl(screen
->ro
->kms_fd
, DRM_IOCTL_PRIME_HANDLE_TO_FD
, &args
);
117 handle
->stride
= scanout
->stride
;
118 handle
->handle
= args
.fd
;
122 return screen
->driver
->export_bo(screen
, rsrc
->bo
->gem_handle
, rsrc
->bo
->slices
[0].stride
, handle
);
129 panfrost_flush_resource(struct pipe_context
*pctx
, struct pipe_resource
*prsc
)
131 //DBG("TODO %s\n", __func__);
134 static struct pipe_surface
*
135 panfrost_create_surface(struct pipe_context
*pipe
,
136 struct pipe_resource
*pt
,
137 const struct pipe_surface
*surf_tmpl
)
139 struct pipe_surface
*ps
= NULL
;
141 ps
= rzalloc(pipe
, struct pipe_surface
);
144 pipe_reference_init(&ps
->reference
, 1);
145 pipe_resource_reference(&ps
->texture
, pt
);
147 ps
->format
= surf_tmpl
->format
;
149 if (pt
->target
!= PIPE_BUFFER
) {
150 assert(surf_tmpl
->u
.tex
.level
<= pt
->last_level
);
151 ps
->width
= u_minify(pt
->width0
, surf_tmpl
->u
.tex
.level
);
152 ps
->height
= u_minify(pt
->height0
, surf_tmpl
->u
.tex
.level
);
153 ps
->u
.tex
.level
= surf_tmpl
->u
.tex
.level
;
154 ps
->u
.tex
.first_layer
= surf_tmpl
->u
.tex
.first_layer
;
155 ps
->u
.tex
.last_layer
= surf_tmpl
->u
.tex
.last_layer
;
157 /* setting width as number of elements should get us correct renderbuffer width */
158 ps
->width
= surf_tmpl
->u
.buf
.last_element
- surf_tmpl
->u
.buf
.first_element
+ 1;
159 ps
->height
= pt
->height0
;
160 ps
->u
.buf
.first_element
= surf_tmpl
->u
.buf
.first_element
;
161 ps
->u
.buf
.last_element
= surf_tmpl
->u
.buf
.last_element
;
162 assert(ps
->u
.buf
.first_element
<= ps
->u
.buf
.last_element
);
163 assert(ps
->u
.buf
.last_element
< ps
->width
);
171 panfrost_surface_destroy(struct pipe_context
*pipe
,
172 struct pipe_surface
*surf
)
174 assert(surf
->texture
);
175 pipe_resource_reference(&surf
->texture
, NULL
);
180 panfrost_setup_slices(const struct pipe_resource
*tmpl
, struct panfrost_bo
*bo
)
182 unsigned width
= tmpl
->width0
;
183 unsigned height
= tmpl
->height0
;
184 unsigned depth
= tmpl
->depth0
;
185 unsigned bytes_per_pixel
= util_format_get_blocksize(tmpl
->format
);
189 /* Tiled operates blockwise; linear is packed. Also, anything
190 * we render to has to be tile-aligned. Maybe not strictly
191 * necessary, but we're not *that* pressed for memory and it
192 * makes code a lot simpler */
194 bool renderable
= tmpl
->bind
&
195 (PIPE_BIND_RENDER_TARGET
| PIPE_BIND_DEPTH_STENCIL
);
196 bool tiled
= bo
->layout
== PAN_TILED
;
197 bool should_align
= renderable
|| tiled
;
199 /* We don't know how to specify a 2D stride for 3D textures */
201 bool should_align_stride
=
202 tmpl
->target
!= PIPE_TEXTURE_3D
;
204 should_align
&= should_align_stride
;
207 unsigned size_2d
= 0;
209 for (unsigned l
= 0; l
<= tmpl
->last_level
; ++l
) {
210 struct panfrost_slice
*slice
= &bo
->slices
[l
];
212 unsigned effective_width
= width
;
213 unsigned effective_height
= height
;
214 unsigned effective_depth
= depth
;
217 effective_width
= ALIGN(effective_width
, 16);
218 effective_height
= ALIGN(effective_height
, 16);
220 /* We don't need to align depth */
223 slice
->offset
= offset
;
225 /* Compute the would-be stride */
226 unsigned stride
= bytes_per_pixel
* effective_width
;
228 /* ..but cache-line align it for performance */
229 if (should_align_stride
)
230 stride
= ALIGN(stride
, 64);
232 slice
->stride
= stride
;
234 unsigned slice_one_size
= slice
->stride
* effective_height
;
235 unsigned slice_full_size
= slice_one_size
* effective_depth
;
237 /* Report 2D size for 3D texturing */
240 size_2d
= slice_one_size
;
242 offset
+= slice_full_size
;
244 width
= u_minify(width
, 1);
245 height
= u_minify(height
, 1);
246 depth
= u_minify(depth
, 1);
249 assert(tmpl
->array_size
);
251 if (tmpl
->target
!= PIPE_TEXTURE_3D
) {
252 /* Arrays and cubemaps have the entire miptree duplicated */
254 bo
->cubemap_stride
= ALIGN(offset
, 64);
255 bo
->size
= ALIGN(bo
->cubemap_stride
* tmpl
->array_size
, 4096);
257 /* 3D strides across the 2D layers */
258 assert(tmpl
->array_size
== 1);
260 bo
->cubemap_stride
= size_2d
;
261 bo
->size
= ALIGN(offset
, 4096);
265 static struct panfrost_bo
*
266 panfrost_create_bo(struct panfrost_screen
*screen
, const struct pipe_resource
*template)
268 struct panfrost_bo
*bo
= rzalloc(screen
, struct panfrost_bo
);
269 pipe_reference_init(&bo
->reference
, 1);
271 /* Based on the usage, figure out what storing will be used. There are
274 * Linear: the basic format, bad for memory bandwidth, bad for cache
275 * use. Zero-copy, though. Renderable.
277 * Tiled: Not compressed, but cache-optimized. Expensive to write into
278 * (due to software tiling), but cheap to sample from. Ideal for most
281 * AFBC: Compressed and renderable (so always desirable for non-scanout
282 * rendertargets). Cheap to sample from. The format is black box, so we
283 * can't read/write from software.
286 /* Tiling textures is almost always faster, unless we only use it once */
288 bool is_texture
= (template->bind
& PIPE_BIND_SAMPLER_VIEW
);
289 bool is_2d
= template->depth0
== 1 && template->array_size
== 1;
290 bool is_streaming
= (template->usage
!= PIPE_USAGE_STREAM
);
292 bool should_tile
= is_streaming
&& is_texture
&& is_2d
;
294 /* Set the layout appropriately */
295 bo
->layout
= should_tile
? PAN_TILED
: PAN_LINEAR
;
297 panfrost_setup_slices(template, bo
);
299 if (bo
->layout
== PAN_TILED
|| bo
->layout
== PAN_LINEAR
) {
300 struct panfrost_memory mem
;
302 screen
->driver
->allocate_slab(screen
, &mem
, bo
->size
/ 4096, true, 0, 0, 0);
306 bo
->gem_handle
= mem
.gem_handle
;
312 static struct pipe_resource
*
313 panfrost_resource_create(struct pipe_screen
*screen
,
314 const struct pipe_resource
*template)
316 struct panfrost_resource
*so
= rzalloc(screen
, struct panfrost_resource
);
317 struct panfrost_screen
*pscreen
= (struct panfrost_screen
*) screen
;
319 so
->base
= *template;
320 so
->base
.screen
= screen
;
322 pipe_reference_init(&so
->base
.reference
, 1);
324 /* Make sure we're familiar */
325 switch (template->target
) {
327 case PIPE_TEXTURE_1D
:
328 case PIPE_TEXTURE_2D
:
329 case PIPE_TEXTURE_3D
:
330 case PIPE_TEXTURE_CUBE
:
331 case PIPE_TEXTURE_RECT
:
332 case PIPE_TEXTURE_2D_ARRAY
:
335 DBG("Unknown texture target %d\n", template->target
);
339 util_range_init(&so
->valid_buffer_range
);
341 if (template->bind
& PIPE_BIND_DISPLAY_TARGET
||
342 template->bind
& PIPE_BIND_SCANOUT
||
343 template->bind
& PIPE_BIND_SHARED
) {
344 struct pipe_resource scanout_templat
= *template;
345 struct renderonly_scanout
*scanout
;
346 struct winsys_handle handle
;
348 scanout
= renderonly_scanout_for_resource(&scanout_templat
,
349 pscreen
->ro
, &handle
);
353 assert(handle
.type
== WINSYS_HANDLE_TYPE_FD
);
354 /* TODO: handle modifiers? */
355 so
= pan_resource(screen
->resource_from_handle(screen
, template,
357 PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE
));
358 close(handle
.handle
);
362 so
->scanout
= scanout
;
363 pscreen
->display_target
= so
;
365 so
->bo
= panfrost_create_bo(pscreen
, template);
368 return (struct pipe_resource
*)so
;
372 panfrost_destroy_bo(struct panfrost_screen
*screen
, struct panfrost_bo
*bo
)
374 if ((bo
->layout
== PAN_LINEAR
|| bo
->layout
== PAN_TILED
) &&
376 struct panfrost_memory mem
= {
380 .gem_handle
= bo
->gem_handle
,
383 screen
->driver
->free_slab(screen
, &mem
);
386 if (bo
->layout
== PAN_AFBC
) {
388 DBG("--leaking afbc (%d bytes)--\n", bo
->afbc_metadata_size
);
391 if (bo
->has_checksum
) {
392 struct panfrost_memory mem
= {
393 .cpu
= bo
->checksum_slab
.cpu
,
394 .gpu
= bo
->checksum_slab
.gpu
,
395 .size
= bo
->checksum_slab
.size
,
396 .gem_handle
= bo
->checksum_slab
.gem_handle
,
399 screen
->driver
->free_slab(screen
, &mem
);
403 screen
->driver
->free_imported_bo(screen
, bo
);
410 panfrost_bo_reference(struct panfrost_bo
*bo
)
412 pipe_reference(NULL
, &bo
->reference
);
416 panfrost_bo_unreference(struct pipe_screen
*screen
, struct panfrost_bo
*bo
)
418 /* When the reference count goes to zero, we need to cleanup */
420 if (pipe_reference(&bo
->reference
, NULL
)) {
421 panfrost_destroy_bo(pan_screen(screen
), bo
);
426 panfrost_resource_destroy(struct pipe_screen
*screen
,
427 struct pipe_resource
*pt
)
429 struct panfrost_screen
*pscreen
= pan_screen(screen
);
430 struct panfrost_resource
*rsrc
= (struct panfrost_resource
*) pt
;
433 renderonly_scanout_destroy(rsrc
->scanout
, pscreen
->ro
);
436 panfrost_bo_unreference(screen
, rsrc
->bo
);
438 util_range_destroy(&rsrc
->valid_buffer_range
);
443 panfrost_transfer_map(struct pipe_context
*pctx
,
444 struct pipe_resource
*resource
,
446 unsigned usage
, /* a combination of PIPE_TRANSFER_x */
447 const struct pipe_box
*box
,
448 struct pipe_transfer
**out_transfer
)
450 int bytes_per_pixel
= util_format_get_blocksize(resource
->format
);
451 struct panfrost_resource
*rsrc
= pan_resource(resource
);
452 struct panfrost_bo
*bo
= rsrc
->bo
;
454 struct panfrost_gtransfer
*transfer
= rzalloc(pctx
, struct panfrost_gtransfer
);
455 transfer
->base
.level
= level
;
456 transfer
->base
.usage
= usage
;
457 transfer
->base
.box
= *box
;
459 pipe_resource_reference(&transfer
->base
.resource
, resource
);
461 *out_transfer
= &transfer
->base
;
463 /* Check if we're bound for rendering and this is a read pixels. If so,
464 * we need to flush */
466 struct panfrost_context
*ctx
= pan_context(pctx
);
467 struct pipe_framebuffer_state
*fb
= &ctx
->pipe_framebuffer
;
469 bool is_bound
= false;
471 for (unsigned c
= 0; c
< fb
->nr_cbufs
; ++c
) {
472 is_bound
|= fb
->cbufs
[c
]->texture
== resource
;
475 if (is_bound
&& (usage
& PIPE_TRANSFER_READ
)) {
477 panfrost_flush(pctx
, NULL
, PIPE_FLUSH_END_OF_FRAME
);
480 /* TODO: Respect usage flags */
482 if (usage
& PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE
) {
483 /* TODO: reallocate */
484 //printf("debug: Missed reallocate\n");
485 } else if ((usage
& PIPE_TRANSFER_WRITE
)
486 && resource
->target
== PIPE_BUFFER
487 && !util_ranges_intersect(&rsrc
->valid_buffer_range
, box
->x
, box
->x
+ box
->width
)) {
488 /* No flush for writes to uninitialized */
489 } else if (!(usage
& PIPE_TRANSFER_UNSYNCHRONIZED
)) {
490 if (usage
& PIPE_TRANSFER_WRITE
) {
491 /* STUB: flush reading */
492 //printf("debug: missed reading flush %d\n", resource->target);
493 } else if (usage
& PIPE_TRANSFER_READ
) {
494 /* STUB: flush writing */
495 //printf("debug: missed writing flush %d (%d-%d)\n", resource->target, box->x, box->x + box->width);
497 /* Why are you even mapping?! */
501 if (bo
->layout
!= PAN_LINEAR
) {
502 /* Non-linear resources need to be indirectly mapped */
504 if (usage
& PIPE_TRANSFER_MAP_DIRECTLY
)
507 transfer
->base
.stride
= box
->width
* bytes_per_pixel
;
508 transfer
->base
.layer_stride
= transfer
->base
.stride
* box
->height
;
511 transfer
->map
= rzalloc_size(transfer
, transfer
->base
.layer_stride
* box
->depth
);
513 return transfer
->map
;
515 transfer
->base
.stride
= bo
->slices
[level
].stride
;
516 transfer
->base
.layer_stride
= bo
->cubemap_stride
;
519 + bo
->slices
[level
].offset
520 + transfer
->base
.box
.z
* bo
->cubemap_stride
521 + transfer
->base
.box
.y
* bo
->slices
[level
].stride
522 + transfer
->base
.box
.x
* bytes_per_pixel
;
527 panfrost_tile_texture(struct panfrost_screen
*screen
, struct panfrost_resource
*rsrc
, struct panfrost_gtransfer
*trans
)
529 struct panfrost_bo
*bo
= (struct panfrost_bo
*)rsrc
->bo
;
531 unsigned level
= trans
->base
.level
;
533 panfrost_texture_swizzle(
536 trans
->base
.box
.width
,
537 trans
->base
.box
.height
,
538 util_format_get_blocksize(rsrc
->base
.format
),
539 u_minify(rsrc
->base
.width0
, level
),
542 + bo
->slices
[level
].offset
543 + bo
->cubemap_stride
* trans
->base
.box
.z
548 panfrost_transfer_unmap(struct pipe_context
*pctx
,
549 struct pipe_transfer
*transfer
)
551 struct panfrost_context
*ctx
= pan_context(pctx
);
553 /* Gallium expects writeback here, so we tile */
555 struct panfrost_gtransfer
*trans
= pan_transfer(transfer
);
556 struct panfrost_resource
*prsrc
= (struct panfrost_resource
*) transfer
->resource
;
559 struct panfrost_bo
*bo
= prsrc
->bo
;
561 if (transfer
->usage
& PIPE_TRANSFER_WRITE
) {
563 if (bo
->layout
== PAN_AFBC
) {
564 DBG("Unimplemented: writes to AFBC\n");
565 } else if (bo
->layout
== PAN_TILED
) {
566 struct pipe_context
*gallium
= (struct pipe_context
*) ctx
;
567 struct panfrost_screen
*screen
= pan_screen(gallium
->screen
);
568 assert(transfer
->box
.depth
== 1);
569 panfrost_tile_texture(screen
, prsrc
, trans
);
575 util_range_add(&prsrc
->valid_buffer_range
,
577 transfer
->box
.x
+ transfer
->box
.width
);
579 /* Derefence the resource */
580 pipe_resource_reference(&transfer
->resource
, NULL
);
582 /* Transfer itself is RALLOCed at the moment */
583 ralloc_free(transfer
);
587 panfrost_transfer_flush_region(struct pipe_context
*pctx
,
588 struct pipe_transfer
*transfer
,
589 const struct pipe_box
*box
)
591 struct panfrost_resource
*rsc
= pan_resource(transfer
->resource
);
593 if (transfer
->resource
->target
== PIPE_BUFFER
) {
594 util_range_add(&rsc
->valid_buffer_range
,
595 transfer
->box
.x
+ box
->x
,
596 transfer
->box
.x
+ box
->x
+ box
->width
);
600 static struct pb_slab
*
601 panfrost_slab_alloc(void *priv
, unsigned heap
, unsigned entry_size
, unsigned group_index
)
603 struct panfrost_screen
*screen
= (struct panfrost_screen
*) priv
;
604 struct panfrost_memory
*mem
= rzalloc(screen
, struct panfrost_memory
);
606 size_t slab_size
= (1 << (MAX_SLAB_ENTRY_SIZE
+ 1));
608 mem
->slab
.num_entries
= slab_size
/ entry_size
;
609 mem
->slab
.num_free
= mem
->slab
.num_entries
;
611 LIST_INITHEAD(&mem
->slab
.free
);
612 for (unsigned i
= 0; i
< mem
->slab
.num_entries
; ++i
) {
613 /* Create a slab entry */
614 struct panfrost_memory_entry
*entry
= rzalloc(mem
, struct panfrost_memory_entry
);
615 entry
->offset
= entry_size
* i
;
617 entry
->base
.slab
= &mem
->slab
;
618 entry
->base
.group_index
= group_index
;
620 LIST_ADDTAIL(&entry
->base
.head
, &mem
->slab
.free
);
623 /* Actually allocate the memory from kernel-space. Mapped, same_va, no
626 screen
->driver
->allocate_slab(screen
, mem
, slab_size
/ 4096, true, 0, 0, 0);
632 panfrost_slab_can_reclaim(void *priv
, struct pb_slab_entry
*entry
)
634 struct panfrost_memory_entry
*p_entry
= (struct panfrost_memory_entry
*) entry
;
635 return p_entry
->freed
;
639 panfrost_slab_free(void *priv
, struct pb_slab
*slab
)
641 struct panfrost_memory
*mem
= (struct panfrost_memory
*) slab
;
642 struct panfrost_screen
*screen
= (struct panfrost_screen
*) priv
;
644 screen
->driver
->free_slab(screen
, mem
);
649 panfrost_invalidate_resource(struct pipe_context
*pctx
, struct pipe_resource
*prsc
)
651 //DBG("TODO %s\n", __func__);
654 static enum pipe_format
655 panfrost_resource_get_internal_format(struct pipe_resource
*prsrc
)
657 return prsrc
->format
;
661 panfrost_resource_set_stencil(struct pipe_resource
*prsrc
,
662 struct pipe_resource
*stencil
)
664 pan_resource(prsrc
)->separate_stencil
= pan_resource(stencil
);
667 static struct pipe_resource
*
668 panfrost_resource_get_stencil(struct pipe_resource
*prsrc
)
670 return &pan_resource(prsrc
)->separate_stencil
->base
;
673 static const struct u_transfer_vtbl transfer_vtbl
= {
674 .resource_create
= panfrost_resource_create
,
675 .resource_destroy
= panfrost_resource_destroy
,
676 .transfer_map
= panfrost_transfer_map
,
677 .transfer_unmap
= panfrost_transfer_unmap
,
678 .transfer_flush_region
= panfrost_transfer_flush_region
,
679 .get_internal_format
= panfrost_resource_get_internal_format
,
680 .set_stencil
= panfrost_resource_set_stencil
,
681 .get_stencil
= panfrost_resource_get_stencil
,
685 panfrost_resource_screen_init(struct panfrost_screen
*pscreen
)
687 //pscreen->base.resource_create_with_modifiers =
688 // panfrost_resource_create_with_modifiers;
689 pscreen
->base
.resource_create
= u_transfer_helper_resource_create
;
690 pscreen
->base
.resource_destroy
= u_transfer_helper_resource_destroy
;
691 pscreen
->base
.resource_from_handle
= panfrost_resource_from_handle
;
692 pscreen
->base
.resource_get_handle
= panfrost_resource_get_handle
;
693 pscreen
->base
.transfer_helper
= u_transfer_helper_create(&transfer_vtbl
,
697 pb_slabs_init(&pscreen
->slabs
,
701 3, /* Number of heaps */
705 panfrost_slab_can_reclaim
,
711 panfrost_resource_screen_deinit(struct panfrost_screen
*pscreen
)
713 pb_slabs_deinit(&pscreen
->slabs
);
717 panfrost_resource_context_init(struct pipe_context
*pctx
)
719 pctx
->transfer_map
= u_transfer_helper_transfer_map
;
720 pctx
->transfer_flush_region
= u_transfer_helper_transfer_flush_region
;
721 pctx
->transfer_unmap
= u_transfer_helper_transfer_unmap
;
722 pctx
->buffer_subdata
= u_default_buffer_subdata
;
723 pctx
->create_surface
= panfrost_create_surface
;
724 pctx
->surface_destroy
= panfrost_surface_destroy
;
725 pctx
->resource_copy_region
= util_resource_copy_region
;
726 pctx
->blit
= panfrost_blit
;
727 pctx
->flush_resource
= panfrost_flush_resource
;
728 pctx
->invalidate_resource
= panfrost_invalidate_resource
;
729 pctx
->transfer_flush_region
= u_transfer_helper_transfer_flush_region
;
730 pctx
->buffer_subdata
= u_default_buffer_subdata
;
731 pctx
->texture_subdata
= u_default_texture_subdata
;