1/************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * Copyright 2014 Broadcom 5 * Copyright 2018 Alyssa Rosenzweig 6 * All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the 10 * "Software"), to deal in the Software without restriction, including 11 * without limitation the rights to use, copy, modify, merge, publish, 12 * distribute, sub license, and/or sell copies of the Software, and to 13 * permit persons to whom the Software is furnished to do so, subject to 14 * the following conditions: 15 * 16 * The above copyright notice and this permission notice (including the 17 * next paragraph) shall be included in all copies or substantial portions 18 * of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 27 * 28 **************************************************************************/ 29 30#include <xf86drm.h> 31#include <fcntl.h> 32#include "drm-uapi/drm_fourcc.h" 33 34#include "state_tracker/winsys_handle.h" 35#include "util/u_format.h" 36#include "util/u_memory.h" 37#include "util/u_surface.h" 38#include "util/u_transfer.h" 39#include "util/u_transfer_helper.h" 40 41#include "pan_context.h" 42#include "pan_screen.h" 43#include "pan_resource.h" 44#include "pan_swizzle.h" 45#include "pan_util.h" 46 47static struct pipe_resource * 48panfrost_resource_from_handle(struct pipe_screen *pscreen, 49 const struct pipe_resource *templat, 50 struct winsys_handle *whandle, 51 unsigned usage) 52{ 53 struct panfrost_screen *screen = pan_screen(pscreen); 54 struct panfrost_resource *rsc; 55 struct pipe_resource *prsc; 56 57 assert(whandle->type == WINSYS_HANDLE_TYPE_FD); 58 59 rsc = CALLOC_STRUCT(panfrost_resource); 60 if (!rsc) 61 return NULL; 62 63 prsc = &rsc->base; 64 65 *prsc = *templat; 66 67 pipe_reference_init(&prsc->reference, 1); 68 prsc->screen = pscreen; 69 70 rsc->bo = screen->driver->import_bo(screen, whandle); 71 rsc->bo->slices[0].stride = whandle->stride; 72 73 if (screen->ro) { 74 rsc->scanout = 75 renderonly_create_gpu_import_for_resource(prsc, screen->ro, NULL); 76 /* failure is expected in some cases.. */ 77 } 78 79 return prsc; 80} 81 82static boolean 83panfrost_resource_get_handle(struct pipe_screen *pscreen, 84 struct pipe_context *ctx, 85 struct pipe_resource *pt, 86 struct winsys_handle *handle, 87 unsigned usage) 88{ 89 struct panfrost_screen *screen = pan_screen(pscreen); 90 struct panfrost_resource *rsrc = (struct panfrost_resource *) pt; 91 struct renderonly_scanout *scanout = rsrc->scanout; 92 93 handle->modifier = DRM_FORMAT_MOD_INVALID; 94 95 if (handle->type == WINSYS_HANDLE_TYPE_SHARED) { 96 return FALSE; 97 } else if (handle->type == WINSYS_HANDLE_TYPE_KMS) { 98 if (renderonly_get_handle(scanout, handle)) 99 return TRUE; 100 101 handle->handle = rsrc->bo->gem_handle; 102 handle->stride = rsrc->bo->slices[0].stride; 103 return TRUE; 104 } else if (handle->type == WINSYS_HANDLE_TYPE_FD) { 105 if (scanout) { 106 struct drm_prime_handle args = { 107 .handle = scanout->handle, 108 .flags = DRM_CLOEXEC, 109 }; 110 111 int ret = drmIoctl(screen->ro->kms_fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &args); 112 if (ret == -1) 113 return FALSE; 114 115 handle->stride = scanout->stride; 116 handle->handle = args.fd; 117 118 return TRUE; 119 } else 120 return screen->driver->export_bo(screen, rsrc->bo->gem_handle, rsrc->bo->slices[0].stride, handle); 121 } 122 123 return FALSE; 124} 125 126static void 127panfrost_flush_resource(struct pipe_context *pctx, struct pipe_resource *prsc) 128{ 129 //DBG("TODO %s\n", __func__); 130} 131 132static void 133panfrost_blit(struct pipe_context *pipe, 134 const struct pipe_blit_info *info) 135{ 136 if (util_try_blit_via_copy_region(pipe, info)) 137 return; 138 139 /* TODO */ 140 DBG("Unhandled blit.\n"); 141 142 return; 143} 144 145static struct pipe_surface * 146panfrost_create_surface(struct pipe_context *pipe, 147 struct pipe_resource *pt, 148 const struct pipe_surface *surf_tmpl) 149{ 150 struct pipe_surface *ps = NULL; 151 152 ps = CALLOC_STRUCT(pipe_surface); 153 154 if (ps) { 155 pipe_reference_init(&ps->reference, 1); 156 pipe_resource_reference(&ps->texture, pt); 157 ps->context = pipe; 158 ps->format = surf_tmpl->format; 159 160 if (pt->target != PIPE_BUFFER) { 161 assert(surf_tmpl->u.tex.level <= pt->last_level); 162 ps->width = u_minify(pt->width0, surf_tmpl->u.tex.level); 163 ps->height = u_minify(pt->height0, surf_tmpl->u.tex.level); 164 ps->u.tex.level = surf_tmpl->u.tex.level; 165 ps->u.tex.first_layer = surf_tmpl->u.tex.first_layer; 166 ps->u.tex.last_layer = surf_tmpl->u.tex.last_layer; 167 } else { 168 /* setting width as number of elements should get us correct renderbuffer width */ 169 ps->width = surf_tmpl->u.buf.last_element - surf_tmpl->u.buf.first_element + 1; 170 ps->height = pt->height0; 171 ps->u.buf.first_element = surf_tmpl->u.buf.first_element; 172 ps->u.buf.last_element = surf_tmpl->u.buf.last_element; 173 assert(ps->u.buf.first_element <= ps->u.buf.last_element); 174 assert(ps->u.buf.last_element < ps->width); 175 } 176 } 177 178 return ps; 179} 180 181static void 182panfrost_surface_destroy(struct pipe_context *pipe, 183 struct pipe_surface *surf) 184{ 185 assert(surf->texture); 186 pipe_resource_reference(&surf->texture, NULL); 187 free(surf); 188} 189 190static void 191panfrost_setup_slices(const struct pipe_resource *tmpl, struct panfrost_bo *bo) 192{ 193 unsigned width = tmpl->width0; 194 unsigned height = tmpl->height0; 195 unsigned bytes_per_pixel = util_format_get_blocksize(tmpl->format); 196 197 unsigned offset = 0; 198 199 for (unsigned l = 0; l <= tmpl->last_level; ++l) { 200 struct panfrost_slice *slice = &bo->slices[l]; 201 202 unsigned effective_width = width; 203 unsigned effective_height = height; 204 205 /* Tiled operates blockwise; linear is packed */ 206 207 if (bo->layout == PAN_TILED) { 208 effective_width = ALIGN(effective_width, 16); 209 effective_height = ALIGN(effective_height, 16); 210 } 211 212 slice->offset = offset; 213 slice->stride = bytes_per_pixel * effective_width; 214 215 offset += slice->stride * effective_height; 216 217 width = u_minify(width, 1); 218 height = u_minify(height, 1); 219 } 220 221 assert(tmpl->array_size); 222 223 bo->cubemap_stride = ALIGN(offset, 64); 224 bo->size = ALIGN(bo->cubemap_stride * tmpl->array_size, 4096); 225} 226 227static struct panfrost_bo * 228panfrost_create_bo(struct panfrost_screen *screen, const struct pipe_resource *template) 229{ 230 struct panfrost_bo *bo = CALLOC_STRUCT(panfrost_bo); 231 pipe_reference_init(&bo->reference, 1); 232 233 /* Based on the usage, figure out what storing will be used. There are 234 * various tradeoffs: 235 * 236 * Linear: the basic format, bad for memory bandwidth, bad for cache 237 * use. Zero-copy, though. Renderable. 238 * 239 * Tiled: Not compressed, but cache-optimized. Expensive to write into 240 * (due to software tiling), but cheap to sample from. Ideal for most 241 * textures. 242 * 243 * AFBC: Compressed and renderable (so always desirable for non-scanout 244 * rendertargets). Cheap to sample from. The format is black box, so we 245 * can't read/write from software. 246 */ 247 248 /* Tiling textures is almost always faster, unless we only use it once */ 249 bool should_tile = (template->usage != PIPE_USAGE_STREAM) && (template->bind & PIPE_BIND_SAMPLER_VIEW); 250 251 /* For unclear reasons, depth/stencil is faster linear than AFBC, so 252 * make sure it's linear */ 253 254 if (template->bind & PIPE_BIND_DEPTH_STENCIL) 255 should_tile = false; 256 257 /* Set the layout appropriately */ 258 bo->layout = should_tile ? PAN_TILED : PAN_LINEAR; 259 260 panfrost_setup_slices(template, bo); 261 262 if (bo->layout == PAN_TILED || bo->layout == PAN_LINEAR) { 263 struct panfrost_memory mem; 264 265 screen->driver->allocate_slab(screen, &mem, bo->size / 4096, true, 0, 0, 0); 266 267 bo->cpu = mem.cpu; 268 bo->gpu = mem.gpu; 269 bo->gem_handle = mem.gem_handle; 270 } 271 272 return bo; 273} 274 275static struct pipe_resource * 276panfrost_resource_create(struct pipe_screen *screen, 277 const struct pipe_resource *template) 278{ 279 struct panfrost_resource *so = CALLOC_STRUCT(panfrost_resource); 280 struct panfrost_screen *pscreen = (struct panfrost_screen *) screen; 281 282 so->base = *template; 283 so->base.screen = screen; 284 285 pipe_reference_init(&so->base.reference, 1); 286 287 /* Make sure we're familiar */ 288 switch (template->target) { 289 case PIPE_BUFFER: 290 case PIPE_TEXTURE_1D: 291 case PIPE_TEXTURE_2D: 292 case PIPE_TEXTURE_3D: 293 case PIPE_TEXTURE_CUBE: 294 case PIPE_TEXTURE_RECT: 295 break; 296 default: 297 DBG("Unknown texture target %d\n", template->target); 298 assert(0); 299 } 300 301 util_range_init(&so->valid_buffer_range); 302 303 if (template->bind & PIPE_BIND_DISPLAY_TARGET || 304 template->bind & PIPE_BIND_SCANOUT || 305 template->bind & PIPE_BIND_SHARED) { 306 struct pipe_resource scanout_templat = *template; 307 struct renderonly_scanout *scanout; 308 struct winsys_handle handle; 309 310 scanout = renderonly_scanout_for_resource(&scanout_templat, 311 pscreen->ro, &handle); 312 if (!scanout) 313 return NULL; 314 315 assert(handle.type == WINSYS_HANDLE_TYPE_FD); 316 /* TODO: handle modifiers? */ 317 so = pan_resource(screen->resource_from_handle(screen, template, 318 &handle, 319 PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE)); 320 close(handle.handle); 321 if (!so) 322 return NULL; 323 324 so->scanout = scanout; 325 pscreen->display_target = so; 326 } else { 327 so->bo = panfrost_create_bo(pscreen, template); 328 } 329 330 return (struct pipe_resource *)so; 331} 332 333static void 334panfrost_destroy_bo(struct panfrost_screen *screen, struct panfrost_bo *pbo) 335{ 336 struct panfrost_bo *bo = (struct panfrost_bo *)pbo; 337 338 if ((bo->layout == PAN_LINEAR || bo->layout == PAN_TILED) && 339 !bo->imported) { 340 struct panfrost_memory mem = { 341 .cpu = bo->cpu, 342 .gpu = bo->gpu, 343 .size = bo->size, 344 .gem_handle = bo->gem_handle, 345 }; 346 347 screen->driver->free_slab(screen, &mem); 348 } 349 350 if (bo->layout == PAN_AFBC) { 351 /* TODO */ 352 DBG("--leaking afbc (%d bytes)--\n", bo->afbc_metadata_size); 353 } 354 355 if (bo->has_checksum) { 356 /* TODO */ 357 DBG("--leaking checksum (%zd bytes)--\n", bo->checksum_slab.size); 358 } 359 360 if (bo->imported) { 361 screen->driver->free_imported_bo(screen, bo); 362 } 363} 364 365void 366panfrost_bo_reference(struct panfrost_bo *bo) 367{ 368 pipe_reference(NULL, &bo->reference); 369} 370 371void 372panfrost_bo_unreference(struct pipe_screen *screen, struct panfrost_bo *bo) 373{ 374 /* When the reference count goes to zero, we need to cleanup */ 375 376 if (pipe_reference(&bo->reference, NULL)) { 377 panfrost_destroy_bo(pan_screen(screen), bo); 378 } 379} 380 381static void 382panfrost_resource_destroy(struct pipe_screen *screen, 383 struct pipe_resource *pt) 384{ 385 struct panfrost_screen *pscreen = pan_screen(screen); 386 struct panfrost_resource *rsrc = (struct panfrost_resource *) pt; 387 388 if (rsrc->scanout) 389 renderonly_scanout_destroy(rsrc->scanout, pscreen->ro); 390 391 if (rsrc->bo) 392 panfrost_bo_unreference(screen, rsrc->bo); 393 394 util_range_destroy(&rsrc->valid_buffer_range); 395 FREE(rsrc); 396} 397 398static void * 399panfrost_transfer_map(struct pipe_context *pctx, 400 struct pipe_resource *resource, 401 unsigned level, 402 unsigned usage, /* a combination of PIPE_TRANSFER_x */ 403 const struct pipe_box *box, 404 struct pipe_transfer **out_transfer) 405{ 406 int bytes_per_pixel = util_format_get_blocksize(resource->format); 407 struct panfrost_resource *rsrc = pan_resource(resource); 408 struct panfrost_bo *bo = rsrc->bo; 409 410 struct panfrost_gtransfer *transfer = CALLOC_STRUCT(panfrost_gtransfer); 411 transfer->base.level = level; 412 transfer->base.usage = usage; 413 transfer->base.box = *box; 414 415 pipe_resource_reference(&transfer->base.resource, resource); 416 417 *out_transfer = &transfer->base; 418 419 /* Check if we're bound for rendering and this is a read pixels. If so, 420 * we need to flush */ 421 422 struct panfrost_context *ctx = pan_context(pctx); 423 struct pipe_framebuffer_state *fb = &ctx->pipe_framebuffer; 424 425 bool is_bound = false; 426 427 for (unsigned c = 0; c < fb->nr_cbufs; ++c) { 428 is_bound |= fb->cbufs[c]->texture == resource; 429 } 430 431 if (is_bound && (usage & PIPE_TRANSFER_READ)) { 432 assert(level == 0); 433 panfrost_flush(pctx, NULL, PIPE_FLUSH_END_OF_FRAME); 434 } 435 436 /* TODO: Respect usage flags */ 437 438 if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { 439 /* TODO: reallocate */ 440 //printf("debug: Missed reallocate\n"); 441 } else if ((usage & PIPE_TRANSFER_WRITE) 442 && resource->target == PIPE_BUFFER 443 && !util_ranges_intersect(&rsrc->valid_buffer_range, box->x, box->x + box->width)) { 444 /* No flush for writes to uninitialized */ 445 } else if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { 446 if (usage & PIPE_TRANSFER_WRITE) { 447 /* STUB: flush reading */ 448 //printf("debug: missed reading flush %d\n", resource->target); 449 } else if (usage & PIPE_TRANSFER_READ) { 450 /* STUB: flush writing */ 451 //printf("debug: missed writing flush %d (%d-%d)\n", resource->target, box->x, box->x + box->width); 452 } else { 453 /* Why are you even mapping?! */ 454 } 455 } 456 457 if (bo->layout != PAN_LINEAR) { 458 /* Non-linear resources need to be indirectly mapped */ 459 460 if (usage & PIPE_TRANSFER_MAP_DIRECTLY) 461 return NULL; 462 463 transfer->base.stride = box->width * bytes_per_pixel; 464 transfer->base.layer_stride = transfer->base.stride * box->height; 465 466 /* TODO: Reads */ 467 transfer->map = malloc(transfer->base.layer_stride * box->depth); 468 469 return transfer->map; 470 } else { 471 transfer->base.stride = bo->slices[level].stride; 472 transfer->base.layer_stride = bo->cubemap_stride; 473 474 return bo->cpu 475 + bo->slices[level].offset 476 + transfer->base.box.z * bo->cubemap_stride 477 + transfer->base.box.y * bo->slices[level].stride 478 + transfer->base.box.x * bytes_per_pixel; 479 } 480} 481 482static void 483panfrost_tile_texture(struct panfrost_screen *screen, struct panfrost_resource *rsrc, struct panfrost_gtransfer *trans) 484{ 485 struct panfrost_bo *bo = (struct panfrost_bo *)rsrc->bo; 486 487 unsigned level = trans->base.level; 488 489 panfrost_texture_swizzle( 490 trans->base.box.x, 491 trans->base.box.y, 492 trans->base.box.width, 493 trans->base.box.height, 494 util_format_get_blocksize(rsrc->base.format), 495 u_minify(rsrc->base.width0, level), 496 trans->map, 497 bo->cpu 498 + bo->slices[level].offset 499 + bo->cubemap_stride * trans->base.box.z 500 ); 501} 502 503static void 504panfrost_transfer_unmap(struct pipe_context *pctx, 505 struct pipe_transfer *transfer) 506{ 507 struct panfrost_context *ctx = pan_context(pctx); 508 509 /* Gallium expects writeback here, so we tile */ 510 511 struct panfrost_gtransfer *trans = pan_transfer(transfer); 512 struct panfrost_resource *prsrc = (struct panfrost_resource *) transfer->resource; 513 514 if (trans->map) { 515 struct panfrost_bo *bo = prsrc->bo; 516 517 if (transfer->usage & PIPE_TRANSFER_WRITE) { 518 519 if (bo->layout == PAN_AFBC) { 520 DBG("Unimplemented: writes to AFBC\n"); 521 } else if (bo->layout == PAN_TILED) { 522 struct pipe_context *gallium = (struct pipe_context *) ctx; 523 struct panfrost_screen *screen = pan_screen(gallium->screen); 524 assert(transfer->box.depth == 1); 525 panfrost_tile_texture(screen, prsrc, trans); 526 } 527 } 528 529 free(trans->map); 530 } 531 532 533 util_range_add(&prsrc->valid_buffer_range, 534 transfer->box.x, 535 transfer->box.x + transfer->box.width); 536 537 /* Derefence the resource */ 538 pipe_resource_reference(&transfer->resource, NULL); 539 540 /* Transfer itself is CALLOCed at the moment */ 541 free(transfer); 542} 543 544static void 545panfrost_transfer_flush_region(struct pipe_context *pctx, 546 struct pipe_transfer *transfer, 547 const struct pipe_box *box) 548{ 549 struct panfrost_resource *rsc = pan_resource(transfer->resource); 550 551 if (transfer->resource->target == PIPE_BUFFER) { 552 util_range_add(&rsc->valid_buffer_range, 553 transfer->box.x + box->x, 554 transfer->box.x + box->x + box->width); 555 } 556} 557 558static struct pb_slab * 559panfrost_slab_alloc(void *priv, unsigned heap, unsigned entry_size, unsigned group_index) 560{ 561 struct panfrost_screen *screen = (struct panfrost_screen *) priv; 562 struct panfrost_memory *mem = CALLOC_STRUCT(panfrost_memory); 563 564 size_t slab_size = (1 << (MAX_SLAB_ENTRY_SIZE + 1)); 565 566 mem->slab.num_entries = slab_size / entry_size; 567 mem->slab.num_free = mem->slab.num_entries; 568 569 LIST_INITHEAD(&mem->slab.free); 570 for (unsigned i = 0; i < mem->slab.num_entries; ++i) { 571 /* Create a slab entry */ 572 struct panfrost_memory_entry *entry = CALLOC_STRUCT(panfrost_memory_entry); 573 entry->offset = entry_size * i; 574 575 entry->base.slab = &mem->slab; 576 entry->base.group_index = group_index; 577 578 LIST_ADDTAIL(&entry->base.head, &mem->slab.free); 579 } 580 581 /* Actually allocate the memory from kernel-space. Mapped, same_va, no 582 * special flags */ 583 584 screen->driver->allocate_slab(screen, mem, slab_size / 4096, true, 0, 0, 0); 585 586 return &mem->slab; 587} 588 589static bool 590panfrost_slab_can_reclaim(void *priv, struct pb_slab_entry *entry) 591{ 592 struct panfrost_memory_entry *p_entry = (struct panfrost_memory_entry *) entry; 593 return p_entry->freed; 594} 595 596static void 597panfrost_slab_free(void *priv, struct pb_slab *slab) 598{ 599 struct panfrost_memory *mem = (struct panfrost_memory *) slab; 600 struct panfrost_screen *screen = (struct panfrost_screen *) priv; 601 602 screen->driver->free_slab(screen, mem); 603} 604 605static void 606panfrost_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc) 607{ 608 //DBG("TODO %s\n", __func__); 609} 610 611static enum pipe_format 612panfrost_resource_get_internal_format(struct pipe_resource *prsrc) 613{ 614 return prsrc->format; 615} 616 617static void 618panfrost_resource_set_stencil(struct pipe_resource *prsrc, 619 struct pipe_resource *stencil) 620{ 621 pan_resource(prsrc)->separate_stencil = pan_resource(stencil); 622} 623 624static struct pipe_resource * 625panfrost_resource_get_stencil(struct pipe_resource *prsrc) 626{ 627 return &pan_resource(prsrc)->separate_stencil->base; 628} 629 630static const struct u_transfer_vtbl transfer_vtbl = { 631 .resource_create = panfrost_resource_create, 632 .resource_destroy = panfrost_resource_destroy, 633 .transfer_map = panfrost_transfer_map, 634 .transfer_unmap = panfrost_transfer_unmap, 635 .transfer_flush_region = panfrost_transfer_flush_region, 636 .get_internal_format = panfrost_resource_get_internal_format, 637 .set_stencil = panfrost_resource_set_stencil, 638 .get_stencil = panfrost_resource_get_stencil, 639}; 640 641void 642panfrost_resource_screen_init(struct panfrost_screen *pscreen) 643{ 644 //pscreen->base.resource_create_with_modifiers = 645 // panfrost_resource_create_with_modifiers; 646 pscreen->base.resource_create = u_transfer_helper_resource_create; 647 pscreen->base.resource_destroy = u_transfer_helper_resource_destroy; 648 pscreen->base.resource_from_handle = panfrost_resource_from_handle; 649 pscreen->base.resource_get_handle = panfrost_resource_get_handle; 650 pscreen->base.transfer_helper = u_transfer_helper_create(&transfer_vtbl, 651 true, false, 652 true, true); 653 654 pb_slabs_init(&pscreen->slabs, 655 MIN_SLAB_ENTRY_SIZE, 656 MAX_SLAB_ENTRY_SIZE, 657 658 3, /* Number of heaps */ 659 660 pscreen, 661 662 panfrost_slab_can_reclaim, 663 panfrost_slab_alloc, 664 panfrost_slab_free); 665} 666 667void 668panfrost_resource_context_init(struct pipe_context *pctx) 669{ 670 pctx->transfer_map = u_transfer_helper_transfer_map; 671 pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region; 672 pctx->transfer_unmap = u_transfer_helper_transfer_unmap; 673 pctx->buffer_subdata = u_default_buffer_subdata; 674 pctx->create_surface = panfrost_create_surface; 675 pctx->surface_destroy = panfrost_surface_destroy; 676 pctx->resource_copy_region = util_resource_copy_region; 677 pctx->blit = panfrost_blit; 678 pctx->flush_resource = panfrost_flush_resource; 679 pctx->invalidate_resource = panfrost_invalidate_resource; 680 pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region; 681 pctx->buffer_subdata = u_default_buffer_subdata; 682 pctx->texture_subdata = u_default_texture_subdata; 683} 684