drivers/gpu/arm/midgard/mali_kbase_mem.c

   1 /*
   2  *
   3  * (C) COPYRIGHT 2010-2016 ARM Limited. All rights reserved.
   4  *
   5  * This program is free software and is provided to you under the terms of the
   6  * GNU General Public License version 2 as published by the Free Software
   7  * Foundation, and any use by you of this program is subject to the terms
   8  * of such GNU licence.
   9  *
  10  * A copy of the licence is included with the program, and can also be obtained
  11  * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  12  * Boston, MA  02110-1301, USA.
  13  *
  14  */
  15
  16
  17
  18
  19
  20 /**
  21  * @file mali_kbase_mem.c
  22  * Base kernel memory APIs
  23  */
  24 #ifdef CONFIG_DMA_SHARED_BUFFER
  25 #include <linux/dma-buf.h>
  26 #endif                          /* CONFIG_DMA_SHARED_BUFFER */
  27 #ifdef CONFIG_UMP
  28 #include <linux/ump.h>
  29 #endif                          /* CONFIG_UMP */
  30 #include <linux/kernel.h>
  31 #include <linux/bug.h>
  32 #include <linux/compat.h>
  33 #include <linux/version.h>
  34
  35 #include <mali_kbase_config.h>
  36 #include <mali_kbase.h>
  37 #include <mali_midg_regmap.h>
  38 #include <mali_kbase_cache_policy.h>
  39 #include <mali_kbase_hw.h>
  40 #include <mali_kbase_hwaccess_time.h>
  41 #include <mali_kbase_tlstream.h>
  42
  43 /**
  44  * @brief Check the zone compatibility of two regions.
  45  */
  46 static int kbase_region_tracker_match_zone(struct kbase_va_region *reg1,
  47                 struct kbase_va_region *reg2)
  48 {
  49         return ((reg1->flags & KBASE_REG_ZONE_MASK) ==
  50                 (reg2->flags & KBASE_REG_ZONE_MASK));
  51 }
  52
  53 KBASE_EXPORT_TEST_API(kbase_region_tracker_match_zone);
  54
  55 /* This function inserts a region into the tree. */
  56 static void kbase_region_tracker_insert(struct kbase_context *kctx, struct kbase_va_region *new_reg)
  57 {
  58         u64 start_pfn = new_reg->start_pfn;
  59         struct rb_node **link = &(kctx->reg_rbtree.rb_node);
  60         struct rb_node *parent = NULL;
  61
  62         /* Find the right place in the tree using tree search */
  63         while (*link) {
  64                 struct kbase_va_region *old_reg;
  65
  66                 parent = *link;
  67                 old_reg = rb_entry(parent, struct kbase_va_region, rblink);
  68
  69                 /* RBTree requires no duplicate entries. */
  70                 KBASE_DEBUG_ASSERT(old_reg->start_pfn != start_pfn);
  71
  72                 if (old_reg->start_pfn > start_pfn)
  73                         link = &(*link)->rb_left;
  74                 else
  75                         link = &(*link)->rb_right;
  76         }
  77
  78         /* Put the new node there, and rebalance tree */
  79         rb_link_node(&(new_reg->rblink), parent, link);
  80         rb_insert_color(&(new_reg->rblink), &(kctx->reg_rbtree));
  81 }
  82
  83 /* Find allocated region enclosing free range. */
  84 static struct kbase_va_region *kbase_region_tracker_find_region_enclosing_range_free(
  85                 struct kbase_context *kctx, u64 start_pfn, size_t nr_pages)
  86 {
  87         struct rb_node *rbnode;
  88         struct kbase_va_region *reg;
  89
  90         u64 end_pfn = start_pfn + nr_pages;
  91
  92         rbnode = kctx->reg_rbtree.rb_node;
  93         while (rbnode) {
  94                 u64 tmp_start_pfn, tmp_end_pfn;
  95
  96                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
  97                 tmp_start_pfn = reg->start_pfn;
  98                 tmp_end_pfn = reg->start_pfn + reg->nr_pages;
  99
 100                 /* If start is lower than this, go left. */
 101                 if (start_pfn < tmp_start_pfn)
 102                         rbnode = rbnode->rb_left;
 103                 /* If end is higher than this, then go right. */
 104                 else if (end_pfn > tmp_end_pfn)
 105                         rbnode = rbnode->rb_right;
 106                 else    /* Enclosing */
 107                         return reg;
 108         }
 109
 110         return NULL;
 111 }
 112
 113 /* Find region enclosing given address. */
 114 struct kbase_va_region *kbase_region_tracker_find_region_enclosing_address(struct kbase_context *kctx, u64 gpu_addr)
 115 {
 116         struct rb_node *rbnode;
 117         struct kbase_va_region *reg;
 118         u64 gpu_pfn = gpu_addr >> PAGE_SHIFT;
 119
 120         KBASE_DEBUG_ASSERT(NULL != kctx);
 121
 122         lockdep_assert_held(&kctx->reg_lock);
 123
 124         rbnode = kctx->reg_rbtree.rb_node;
 125         while (rbnode) {
 126                 u64 tmp_start_pfn, tmp_end_pfn;
 127
 128                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 129                 tmp_start_pfn = reg->start_pfn;
 130                 tmp_end_pfn = reg->start_pfn + reg->nr_pages;
 131
 132                 /* If start is lower than this, go left. */
 133                 if (gpu_pfn < tmp_start_pfn)
 134                         rbnode = rbnode->rb_left;
 135                 /* If end is higher than this, then go right. */
 136                 else if (gpu_pfn >= tmp_end_pfn)
 137                         rbnode = rbnode->rb_right;
 138                 else    /* Enclosing */
 139                         return reg;
 140         }
 141
 142         return NULL;
 143 }
 144
 145 KBASE_EXPORT_TEST_API(kbase_region_tracker_find_region_enclosing_address);
 146
 147 /* Find region with given base address */
 148 struct kbase_va_region *kbase_region_tracker_find_region_base_address(struct kbase_context *kctx, u64 gpu_addr)
 149 {
 150         u64 gpu_pfn = gpu_addr >> PAGE_SHIFT;
 151         struct rb_node *rbnode;
 152         struct kbase_va_region *reg;
 153
 154         KBASE_DEBUG_ASSERT(NULL != kctx);
 155
 156         lockdep_assert_held(&kctx->reg_lock);
 157
 158         rbnode = kctx->reg_rbtree.rb_node;
 159         while (rbnode) {
 160                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 161                 if (reg->start_pfn > gpu_pfn)
 162                         rbnode = rbnode->rb_left;
 163                 else if (reg->start_pfn < gpu_pfn)
 164                         rbnode = rbnode->rb_right;
 165                 else
 166                         return reg;
 167
 168         }
 169
 170         return NULL;
 171 }
 172
 173 KBASE_EXPORT_TEST_API(kbase_region_tracker_find_region_base_address);
 174
 175 /* Find region meeting given requirements */
 176 static struct kbase_va_region *kbase_region_tracker_find_region_meeting_reqs(struct kbase_context *kctx, struct kbase_va_region *reg_reqs, size_t nr_pages, size_t align)
 177 {
 178         struct rb_node *rbnode;
 179         struct kbase_va_region *reg;
 180
 181         /* Note that this search is a linear search, as we do not have a target
 182            address in mind, so does not benefit from the rbtree search */
 183         rbnode = rb_first(&(kctx->reg_rbtree));
 184         while (rbnode) {
 185                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 186                 if ((reg->nr_pages >= nr_pages) &&
 187                                 (reg->flags & KBASE_REG_FREE) &&
 188                                 kbase_region_tracker_match_zone(reg, reg_reqs)) {
 189                         /* Check alignment */
 190                         u64 start_pfn = (reg->start_pfn + align - 1) & ~(align - 1);
 191
 192                         if ((start_pfn >= reg->start_pfn) &&
 193                                         (start_pfn <= (reg->start_pfn + reg->nr_pages - 1)) &&
 194                                         ((start_pfn + nr_pages - 1) <= (reg->start_pfn + reg->nr_pages - 1)))
 195                                 return reg;
 196                 }
 197                 rbnode = rb_next(rbnode);
 198         }
 199
 200         return NULL;
 201 }
 202
 203 /**
 204  * @brief Remove a region object from the global list.
 205  *
 206  * The region reg is removed, possibly by merging with other free and
 207  * compatible adjacent regions.  It must be called with the context
 208  * region lock held. The associated memory is not released (see
 209  * kbase_free_alloced_region). Internal use only.
 210  */
 211 static int kbase_remove_va_region(struct kbase_context *kctx, struct kbase_va_region *reg)
 212 {
 213         struct rb_node *rbprev;
 214         struct kbase_va_region *prev = NULL;
 215         struct rb_node *rbnext;
 216         struct kbase_va_region *next = NULL;
 217
 218         int merged_front = 0;
 219         int merged_back = 0;
 220         int err = 0;
 221
 222         /* Try to merge with the previous block first */
 223         rbprev = rb_prev(&(reg->rblink));
 224         if (rbprev) {
 225                 prev = rb_entry(rbprev, struct kbase_va_region, rblink);
 226                 if ((prev->flags & KBASE_REG_FREE) && kbase_region_tracker_match_zone(prev, reg)) {
 227                         /* We're compatible with the previous VMA, merge with it */
 228                         prev->nr_pages += reg->nr_pages;
 229                         rb_erase(&(reg->rblink), &kctx->reg_rbtree);
 230                         reg = prev;
 231                         merged_front = 1;
 232                 }
 233         }
 234
 235         /* Try to merge with the next block second */
 236         /* Note we do the lookup here as the tree may have been rebalanced. */
 237         rbnext = rb_next(&(reg->rblink));
 238         if (rbnext) {
 239                 /* We're compatible with the next VMA, merge with it */
 240                 next = rb_entry(rbnext, struct kbase_va_region, rblink);
 241                 if ((next->flags & KBASE_REG_FREE) && kbase_region_tracker_match_zone(next, reg)) {
 242                         next->start_pfn = reg->start_pfn;
 243                         next->nr_pages += reg->nr_pages;
 244                         rb_erase(&(reg->rblink), &kctx->reg_rbtree);
 245                         merged_back = 1;
 246                         if (merged_front) {
 247                                 /* We already merged with prev, free it */
 248                                 kbase_free_alloced_region(reg);
 249                         }
 250                 }
 251         }
 252
 253         /* If we failed to merge then we need to add a new block */
 254         if (!(merged_front || merged_back)) {
 255                 /*
 256                  * We didn't merge anything. Add a new free
 257                  * placeholder and remove the original one.
 258                  */
 259                 struct kbase_va_region *free_reg;
 260
 261                 free_reg = kbase_alloc_free_region(kctx, reg->start_pfn, reg->nr_pages, reg->flags & KBASE_REG_ZONE_MASK);
 262                 if (!free_reg) {
 263                         err = -ENOMEM;
 264                         goto out;
 265                 }
 266
 267                 rb_replace_node(&(reg->rblink), &(free_reg->rblink), &(kctx->reg_rbtree));
 268         }
 269
 270  out:
 271         return err;
 272 }
 273
 274 KBASE_EXPORT_TEST_API(kbase_remove_va_region);
 275
 276 /**
 277  * @brief Insert a VA region to the list, replacing the current at_reg.
 278  */
 279 static int kbase_insert_va_region_nolock(struct kbase_context *kctx, struct kbase_va_region *new_reg, struct kbase_va_region *at_reg, u64 start_pfn, size_t nr_pages)
 280 {
 281         int err = 0;
 282
 283         /* Must be a free region */
 284         KBASE_DEBUG_ASSERT((at_reg->flags & KBASE_REG_FREE) != 0);
 285         /* start_pfn should be contained within at_reg */
 286         KBASE_DEBUG_ASSERT((start_pfn >= at_reg->start_pfn) && (start_pfn < at_reg->start_pfn + at_reg->nr_pages));
 287         /* at least nr_pages from start_pfn should be contained within at_reg */
 288         KBASE_DEBUG_ASSERT(start_pfn + nr_pages <= at_reg->start_pfn + at_reg->nr_pages);
 289
 290         new_reg->start_pfn = start_pfn;
 291         new_reg->nr_pages = nr_pages;
 292
 293         /* Regions are a whole use, so swap and delete old one. */
 294         if (at_reg->start_pfn == start_pfn && at_reg->nr_pages == nr_pages) {
 295                 rb_replace_node(&(at_reg->rblink), &(new_reg->rblink), &(kctx->reg_rbtree));
 296                 kbase_free_alloced_region(at_reg);
 297         }
 298         /* New region replaces the start of the old one, so insert before. */
 299         else if (at_reg->start_pfn == start_pfn) {
 300                 at_reg->start_pfn += nr_pages;
 301                 KBASE_DEBUG_ASSERT(at_reg->nr_pages >= nr_pages);
 302                 at_reg->nr_pages -= nr_pages;
 303
 304                 kbase_region_tracker_insert(kctx, new_reg);
 305         }
 306         /* New region replaces the end of the old one, so insert after. */
 307         else if ((at_reg->start_pfn + at_reg->nr_pages) == (start_pfn + nr_pages)) {
 308                 at_reg->nr_pages -= nr_pages;
 309
 310                 kbase_region_tracker_insert(kctx, new_reg);
 311         }
 312         /* New region splits the old one, so insert and create new */
 313         else {
 314                 struct kbase_va_region *new_front_reg;
 315
 316                 new_front_reg = kbase_alloc_free_region(kctx,
 317                                 at_reg->start_pfn,
 318                                 start_pfn - at_reg->start_pfn,
 319                                 at_reg->flags & KBASE_REG_ZONE_MASK);
 320
 321                 if (new_front_reg) {
 322                         at_reg->nr_pages -= nr_pages + new_front_reg->nr_pages;
 323                         at_reg->start_pfn = start_pfn + nr_pages;
 324
 325                         kbase_region_tracker_insert(kctx, new_front_reg);
 326                         kbase_region_tracker_insert(kctx, new_reg);
 327                 } else {
 328                         err = -ENOMEM;
 329                 }
 330         }
 331
 332         return err;
 333 }
 334
 335 /**
 336  * @brief Add a VA region to the list.
 337  */
 338 int kbase_add_va_region(struct kbase_context *kctx,
 339                 struct kbase_va_region *reg, u64 addr,
 340                 size_t nr_pages, size_t align)
 341 {
 342         struct kbase_va_region *tmp;
 343         u64 gpu_pfn = addr >> PAGE_SHIFT;
 344         int err = 0;
 345
 346         KBASE_DEBUG_ASSERT(NULL != kctx);
 347         KBASE_DEBUG_ASSERT(NULL != reg);
 348
 349         lockdep_assert_held(&kctx->reg_lock);
 350
 351         if (!align)
 352                 align = 1;
 353
 354         /* must be a power of 2 */
 355         KBASE_DEBUG_ASSERT((align & (align - 1)) == 0);
 356         KBASE_DEBUG_ASSERT(nr_pages > 0);
 357
 358         /* Path 1: Map a specific address. Find the enclosing region, which *must* be free. */
 359         if (gpu_pfn) {
 360                 struct device *dev = kctx->kbdev->dev;
 361
 362                 KBASE_DEBUG_ASSERT(!(gpu_pfn & (align - 1)));
 363
 364                 tmp = kbase_region_tracker_find_region_enclosing_range_free(kctx, gpu_pfn, nr_pages);
 365                 if (!tmp) {
 366                         dev_warn(dev, "Enclosing region not found: 0x%08llx gpu_pfn, %zu nr_pages", gpu_pfn, nr_pages);
 367                         err = -ENOMEM;
 368                         goto exit;
 369                 }
 370
 371                 if ((!kbase_region_tracker_match_zone(tmp, reg)) ||
 372                                 (!(tmp->flags & KBASE_REG_FREE))) {
 373                         dev_warn(dev, "Zone mismatch: %lu != %lu", tmp->flags & KBASE_REG_ZONE_MASK, reg->flags & KBASE_REG_ZONE_MASK);
 374                         dev_warn(dev, "!(tmp->flags & KBASE_REG_FREE): tmp->start_pfn=0x%llx tmp->flags=0x%lx tmp->nr_pages=0x%zx gpu_pfn=0x%llx nr_pages=0x%zx\n", tmp->start_pfn, tmp->flags, tmp->nr_pages, gpu_pfn, nr_pages);
 375                         dev_warn(dev, "in function %s (%p, %p, 0x%llx, 0x%zx, 0x%zx)\n", __func__, kctx, reg, addr, nr_pages, align);
 376                         err = -ENOMEM;
 377                         goto exit;
 378                 }
 379
 380                 err = kbase_insert_va_region_nolock(kctx, reg, tmp, gpu_pfn, nr_pages);
 381                 if (err) {
 382                         dev_warn(dev, "Failed to insert va region");
 383                         err = -ENOMEM;
 384                         goto exit;
 385                 }
 386
 387                 goto exit;
 388         }
 389
 390         /* Path 2: Map any free address which meets the requirements.  */
 391         {
 392                 u64 start_pfn;
 393
 394                 /*
 395                  * Depending on the zone the allocation request is for
 396                  * we might need to retry it.
 397                  */
 398                 do {
 399                         tmp = kbase_region_tracker_find_region_meeting_reqs(
 400                                         kctx, reg, nr_pages, align);
 401                         if (tmp) {
 402                                 start_pfn = (tmp->start_pfn + align - 1) &
 403                                                 ~(align - 1);
 404                                 err = kbase_insert_va_region_nolock(kctx, reg,
 405                                                 tmp, start_pfn, nr_pages);
 406                                 break;
 407                         }
 408
 409                         /*
 410                          * If the allocation is not from the same zone as JIT
 411                          * then don't retry, we're out of VA and there is
 412                          * nothing which can be done about it.
 413                          */
 414                         if ((reg->flags & KBASE_REG_ZONE_MASK) !=
 415                                         KBASE_REG_ZONE_CUSTOM_VA)
 416                                 break;
 417                 } while (kbase_jit_evict(kctx));
 418
 419                 if (!tmp)
 420                         err = -ENOMEM;
 421         }
 422
 423  exit:
 424         return err;
 425 }
 426
 427 KBASE_EXPORT_TEST_API(kbase_add_va_region);
 428
 429 /**
 430  * @brief Initialize the internal region tracker data structure.
 431  */
 432 static void kbase_region_tracker_ds_init(struct kbase_context *kctx,
 433                 struct kbase_va_region *same_va_reg,
 434                 struct kbase_va_region *exec_reg,
 435                 struct kbase_va_region *custom_va_reg)
 436 {
 437         kctx->reg_rbtree = RB_ROOT;
 438         kbase_region_tracker_insert(kctx, same_va_reg);
 439
 440         /* exec and custom_va_reg doesn't always exist */
 441         if (exec_reg && custom_va_reg) {
 442                 kbase_region_tracker_insert(kctx, exec_reg);
 443                 kbase_region_tracker_insert(kctx, custom_va_reg);
 444         }
 445 }
 446
 447 void kbase_region_tracker_term(struct kbase_context *kctx)
 448 {
 449         struct rb_node *rbnode;
 450         struct kbase_va_region *reg;
 451
 452         do {
 453                 rbnode = rb_first(&(kctx->reg_rbtree));
 454                 if (rbnode) {
 455                         rb_erase(rbnode, &(kctx->reg_rbtree));
 456                         reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 457                         kbase_free_alloced_region(reg);
 458                 }
 459         } while (rbnode);
 460 }
 461
 462 /**
 463  * Initialize the region tracker data structure.
 464  */
 465 int kbase_region_tracker_init(struct kbase_context *kctx)
 466 {
 467         struct kbase_va_region *same_va_reg;
 468         struct kbase_va_region *exec_reg = NULL;
 469         struct kbase_va_region *custom_va_reg = NULL;
 470         size_t same_va_bits = sizeof(void *) * BITS_PER_BYTE;
 471         u64 custom_va_size = KBASE_REG_ZONE_CUSTOM_VA_SIZE;
 472         u64 gpu_va_limit = (1ULL << kctx->kbdev->gpu_props.mmu.va_bits) >> PAGE_SHIFT;
 473         u64 same_va_pages;
 474         int err;
 475
 476         /* Take the lock as kbase_free_alloced_region requires it */
 477         kbase_gpu_vm_lock(kctx);
 478
 479 #if defined(CONFIG_ARM64)
 480         same_va_bits = VA_BITS;
 481 #elif defined(CONFIG_X86_64)
 482         same_va_bits = 47;
 483 #elif defined(CONFIG_64BIT)
 484 #error Unsupported 64-bit architecture
 485 #endif
 486
 487 #ifdef CONFIG_64BIT
 488         if (kctx->is_compat)
 489                 same_va_bits = 32;
 490         else if (kbase_hw_has_feature(kctx->kbdev, BASE_HW_FEATURE_33BIT_VA))
 491                 same_va_bits = 33;
 492 #endif
 493
 494         if (kctx->kbdev->gpu_props.mmu.va_bits < same_va_bits) {
 495                 err = -EINVAL;
 496                 goto fail_unlock;
 497         }
 498
 499         same_va_pages = (1ULL << (same_va_bits - PAGE_SHIFT)) - 1;
 500         /* all have SAME_VA */
 501         same_va_reg = kbase_alloc_free_region(kctx, 1,
 502                         same_va_pages,
 503                         KBASE_REG_ZONE_SAME_VA);
 504
 505         if (!same_va_reg) {
 506                 err = -ENOMEM;
 507                 goto fail_unlock;
 508         }
 509
 510 #ifdef CONFIG_64BIT
 511         /* 32-bit clients have exec and custom VA zones */
 512         if (kctx->is_compat) {
 513 #endif
 514                 if (gpu_va_limit <= KBASE_REG_ZONE_CUSTOM_VA_BASE) {
 515                         err = -EINVAL;
 516                         goto fail_free_same_va;
 517                 }
 518                 /* If the current size of TMEM is out of range of the
 519                  * virtual address space addressable by the MMU then
 520                  * we should shrink it to fit
 521                  */
 522                 if ((KBASE_REG_ZONE_CUSTOM_VA_BASE + KBASE_REG_ZONE_CUSTOM_VA_SIZE) >= gpu_va_limit)
 523                         custom_va_size = gpu_va_limit - KBASE_REG_ZONE_CUSTOM_VA_BASE;
 524
 525                 exec_reg = kbase_alloc_free_region(kctx,
 526                                 KBASE_REG_ZONE_EXEC_BASE,
 527                                 KBASE_REG_ZONE_EXEC_SIZE,
 528                                 KBASE_REG_ZONE_EXEC);
 529
 530                 if (!exec_reg) {
 531                         err = -ENOMEM;
 532                         goto fail_free_same_va;
 533                 }
 534
 535                 custom_va_reg = kbase_alloc_free_region(kctx,
 536                                 KBASE_REG_ZONE_CUSTOM_VA_BASE,
 537                                 custom_va_size, KBASE_REG_ZONE_CUSTOM_VA);
 538
 539                 if (!custom_va_reg) {
 540                         err = -ENOMEM;
 541                         goto fail_free_exec;
 542                 }
 543 #ifdef CONFIG_64BIT
 544         }
 545 #endif
 546
 547         kbase_region_tracker_ds_init(kctx, same_va_reg, exec_reg, custom_va_reg);
 548
 549         kctx->same_va_end = same_va_pages + 1;
 550
 551         kbase_gpu_vm_unlock(kctx);
 552         return 0;
 553
 554 fail_free_exec:
 555         kbase_free_alloced_region(exec_reg);
 556 fail_free_same_va:
 557         kbase_free_alloced_region(same_va_reg);
 558 fail_unlock:
 559         kbase_gpu_vm_unlock(kctx);
 560         return err;
 561 }
 562
 563 int kbase_region_tracker_init_jit(struct kbase_context *kctx, u64 jit_va_pages)
 564 {
 565 #ifdef CONFIG_64BIT
 566         struct kbase_va_region *same_va;
 567         struct kbase_va_region *custom_va_reg;
 568         u64 same_va_bits;
 569         u64 total_va_size;
 570         int err;
 571
 572         /*
 573          * Nothing to do for 32-bit clients, JIT uses the existing
 574          * custom VA zone.
 575          */
 576         if (kctx->is_compat)
 577                 return 0;
 578
 579 #if defined(CONFIG_ARM64)
 580         same_va_bits = VA_BITS;
 581 #elif defined(CONFIG_X86_64)
 582         same_va_bits = 47;
 583 #elif defined(CONFIG_64BIT)
 584 #error Unsupported 64-bit architecture
 585 #endif
 586
 587         if (kbase_hw_has_feature(kctx->kbdev, BASE_HW_FEATURE_33BIT_VA))
 588                 same_va_bits = 33;
 589
 590         total_va_size = (1ULL << (same_va_bits - PAGE_SHIFT)) - 1;
 591
 592         kbase_gpu_vm_lock(kctx);
 593
 594         /*
 595          * Modify the same VA free region after creation. Be careful to ensure
 596          * that allocations haven't been made as they could cause an overlap
 597          * to happen with existing same VA allocations and the custom VA zone.
 598          */
 599         same_va = kbase_region_tracker_find_region_base_address(kctx,
 600                         PAGE_SIZE);
 601         if (!same_va) {
 602                 err = -ENOMEM;
 603                 goto fail_unlock;
 604         }
 605
 606         /* The region flag or region size has changed since creation so bail. */
 607         if ((!(same_va->flags & KBASE_REG_FREE)) ||
 608                         (same_va->nr_pages != total_va_size)) {
 609                 err = -ENOMEM;
 610                 goto fail_unlock;
 611         }
 612
 613         if (same_va->nr_pages < jit_va_pages ||
 614                         kctx->same_va_end < jit_va_pages) {
 615                 err = -ENOMEM;
 616                 goto fail_unlock;
 617         }
 618
 619         /* It's safe to adjust the same VA zone now */
 620         same_va->nr_pages -= jit_va_pages;
 621         kctx->same_va_end -= jit_va_pages;
 622
 623         /*
 624          * Create a custom VA zone at the end of the VA for allocations which
 625          * JIT can use so it doesn't have to allocate VA from the kernel.
 626          */
 627         custom_va_reg = kbase_alloc_free_region(kctx,
 628                                 kctx->same_va_end,
 629                                 jit_va_pages,
 630                                 KBASE_REG_ZONE_CUSTOM_VA);
 631         if (!custom_va_reg) {
 632                 /*
 633                  * The context will be destroyed if we fail here so no point
 634                  * reverting the change we made to same_va.
 635                  */
 636                 err = -ENOMEM;
 637                 goto fail_unlock;
 638         }
 639
 640         kbase_region_tracker_insert(kctx, custom_va_reg);
 641
 642         kbase_gpu_vm_unlock(kctx);
 643         return 0;
 644
 645 fail_unlock:
 646         kbase_gpu_vm_unlock(kctx);
 647         return err;
 648 #else
 649         return 0;
 650 #endif
 651 }
 652
 653 int kbase_mem_init(struct kbase_device *kbdev)
 654 {
 655         struct kbasep_mem_device *memdev;
 656
 657         KBASE_DEBUG_ASSERT(kbdev);
 658
 659         memdev = &kbdev->memdev;
 660         kbdev->mem_pool_max_size_default = KBASE_MEM_POOL_MAX_SIZE_KCTX;
 661
 662         /* Initialize memory usage */
 663         atomic_set(&memdev->used_pages, 0);
 664
 665         return kbase_mem_pool_init(&kbdev->mem_pool,
 666                         KBASE_MEM_POOL_MAX_SIZE_KBDEV, kbdev, NULL);
 667 }
 668
 669 void kbase_mem_halt(struct kbase_device *kbdev)
 670 {
 671         CSTD_UNUSED(kbdev);
 672 }
 673
 674 void kbase_mem_term(struct kbase_device *kbdev)
 675 {
 676         struct kbasep_mem_device *memdev;
 677         int pages;
 678
 679         KBASE_DEBUG_ASSERT(kbdev);
 680
 681         memdev = &kbdev->memdev;
 682
 683         pages = atomic_read(&memdev->used_pages);
 684         if (pages != 0)
 685                 dev_warn(kbdev->dev, "%s: %d pages in use!\n", __func__, pages);
 686
 687         kbase_mem_pool_term(&kbdev->mem_pool);
 688 }
 689
 690 KBASE_EXPORT_TEST_API(kbase_mem_term);
 691
 692
 693
 694
 695 /**
 696  * @brief Allocate a free region object.
 697  *
 698  * The allocated object is not part of any list yet, and is flagged as
 699  * KBASE_REG_FREE. No mapping is allocated yet.
 700  *
 701  * zone is KBASE_REG_ZONE_CUSTOM_VA, KBASE_REG_ZONE_SAME_VA, or KBASE_REG_ZONE_EXEC
 702  *
 703  */
 704 struct kbase_va_region *kbase_alloc_free_region(struct kbase_context *kctx, u64 start_pfn, size_t nr_pages, int zone)
 705 {
 706         struct kbase_va_region *new_reg;
 707
 708         KBASE_DEBUG_ASSERT(kctx != NULL);
 709
 710         /* zone argument should only contain zone related region flags */
 711         KBASE_DEBUG_ASSERT((zone & ~KBASE_REG_ZONE_MASK) == 0);
 712         KBASE_DEBUG_ASSERT(nr_pages > 0);
 713         /* 64-bit address range is the max */
 714         KBASE_DEBUG_ASSERT(start_pfn + nr_pages <= (U64_MAX / PAGE_SIZE));
 715
 716         new_reg = kzalloc(sizeof(*new_reg), GFP_KERNEL);
 717
 718         if (!new_reg)
 719                 return NULL;
 720
 721         new_reg->cpu_alloc = NULL; /* no alloc bound yet */
 722         new_reg->gpu_alloc = NULL; /* no alloc bound yet */
 723         new_reg->kctx = kctx;
 724         new_reg->flags = zone | KBASE_REG_FREE;
 725
 726         new_reg->flags |= KBASE_REG_GROWABLE;
 727
 728         new_reg->start_pfn = start_pfn;
 729         new_reg->nr_pages = nr_pages;
 730
 731         return new_reg;
 732 }
 733
 734 KBASE_EXPORT_TEST_API(kbase_alloc_free_region);
 735
 736 /**
 737  * @brief Free a region object.
 738  *
 739  * The described region must be freed of any mapping.
 740  *
 741  * If the region is not flagged as KBASE_REG_FREE, the region's
 742  * alloc object will be released.
 743  * It is a bug if no alloc object exists for non-free regions.
 744  *
 745  */
 746 void kbase_free_alloced_region(struct kbase_va_region *reg)
 747 {
 748         if (!(reg->flags & KBASE_REG_FREE)) {
 749                 /*
 750                  * The physical allocation should have been removed from the
 751                  * eviction list before this function is called. However, in the
 752                  * case of abnormal process termination or the app leaking the
 753                  * memory kbase_mem_free_region is not called so it can still be
 754                  * on the list at termination time of the region tracker.
 755                  */
 756                 if (!list_empty(&reg->gpu_alloc->evict_node)) {
 757                         /*
 758                          * Unlink the physical allocation before unmaking it
 759                          * evictable so that the allocation isn't grown back to
 760                          * its last backed size as we're going to unmap it
 761                          * anyway.
 762                          */
 763                         reg->cpu_alloc->reg = NULL;
 764                         if (reg->cpu_alloc != reg->gpu_alloc)
 765                                 reg->gpu_alloc->reg = NULL;
 766
 767                         /*
 768                          * If a region has been made evictable then we must
 769                          * unmake it before trying to free it.
 770                          * If the memory hasn't been reclaimed it will be
 771                          * unmapped and freed below, if it has been reclaimed
 772                          * then the operations below are no-ops.
 773                          */
 774                         if (reg->flags & KBASE_REG_DONT_NEED) {
 775                                 KBASE_DEBUG_ASSERT(reg->cpu_alloc->type ==
 776                                                    KBASE_MEM_TYPE_NATIVE);
 777                                 kbase_mem_evictable_unmake(reg->gpu_alloc);
 778                         }
 779                 }
 780
 781                 /*
 782                  * Remove the region from the sticky resource metadata
 783                  * list should it be there.
 784                  */
 785                 kbase_sticky_resource_release(reg->kctx, NULL,
 786                                 reg->start_pfn << PAGE_SHIFT);
 787
 788                 kbase_mem_phy_alloc_put(reg->cpu_alloc);
 789                 kbase_mem_phy_alloc_put(reg->gpu_alloc);
 790                 /* To detect use-after-free in debug builds */
 791                 KBASE_DEBUG_CODE(reg->flags |= KBASE_REG_FREE);
 792         }
 793         kfree(reg);
 794 }
 795
 796 KBASE_EXPORT_TEST_API(kbase_free_alloced_region);
 797
 798 int kbase_gpu_mmap(struct kbase_context *kctx, struct kbase_va_region *reg, u64 addr, size_t nr_pages, size_t align)
 799 {
 800         int err;
 801         size_t i = 0;
 802         unsigned long attr;
 803         unsigned long mask = ~KBASE_REG_MEMATTR_MASK;
 804
 805         if ((kctx->kbdev->system_coherency == COHERENCY_ACE) &&
 806                 (reg->flags & KBASE_REG_SHARE_BOTH))
 807                 attr = KBASE_REG_MEMATTR_INDEX(AS_MEMATTR_INDEX_OUTER_WA);
 808         else
 809                 attr = KBASE_REG_MEMATTR_INDEX(AS_MEMATTR_INDEX_WRITE_ALLOC);
 810
 811         KBASE_DEBUG_ASSERT(NULL != kctx);
 812         KBASE_DEBUG_ASSERT(NULL != reg);
 813
 814         err = kbase_add_va_region(kctx, reg, addr, nr_pages, align);
 815         if (err)
 816                 return err;
 817
 818         if (reg->gpu_alloc->type == KBASE_MEM_TYPE_ALIAS) {
 819                 u64 stride;
 820                 struct kbase_mem_phy_alloc *alloc;
 821
 822                 alloc = reg->gpu_alloc;
 823                 stride = alloc->imported.alias.stride;
 824                 KBASE_DEBUG_ASSERT(alloc->imported.alias.aliased);
 825                 for (i = 0; i < alloc->imported.alias.nents; i++) {
 826                         if (alloc->imported.alias.aliased[i].alloc) {
 827                                 err = kbase_mmu_insert_pages(kctx,
 828                                                 reg->start_pfn + (i * stride),
 829                                                 alloc->imported.alias.aliased[i].alloc->pages + alloc->imported.alias.aliased[i].offset,
 830                                                 alloc->imported.alias.aliased[i].length,
 831                                                 reg->flags);
 832                                 if (err)
 833                                         goto bad_insert;
 834
 835                                 kbase_mem_phy_alloc_gpu_mapped(alloc->imported.alias.aliased[i].alloc);
 836                         } else {
 837                                 err = kbase_mmu_insert_single_page(kctx,
 838                                         reg->start_pfn + i * stride,
 839                                         page_to_phys(kctx->aliasing_sink_page),
 840                                         alloc->imported.alias.aliased[i].length,
 841                                         (reg->flags & mask) | attr);
 842
 843                                 if (err)
 844                                         goto bad_insert;
 845                         }
 846                 }
 847         } else {
 848                 err = kbase_mmu_insert_pages(kctx, reg->start_pfn,
 849                                 kbase_get_gpu_phy_pages(reg),
 850                                 kbase_reg_current_backed_size(reg),
 851                                 reg->flags);
 852                 if (err)
 853                         goto bad_insert;
 854                 kbase_mem_phy_alloc_gpu_mapped(reg->gpu_alloc);
 855         }
 856
 857         return err;
 858
 859 bad_insert:
 860         if (reg->gpu_alloc->type == KBASE_MEM_TYPE_ALIAS) {
 861                 u64 stride;
 862
 863                 stride = reg->gpu_alloc->imported.alias.stride;
 864                 KBASE_DEBUG_ASSERT(reg->gpu_alloc->imported.alias.aliased);
 865                 while (i--)
 866                         if (reg->gpu_alloc->imported.alias.aliased[i].alloc) {
 867                                 kbase_mmu_teardown_pages(kctx, reg->start_pfn + (i * stride), reg->gpu_alloc->imported.alias.aliased[i].length);
 868                                 kbase_mem_phy_alloc_gpu_unmapped(reg->gpu_alloc->imported.alias.aliased[i].alloc);
 869                         }
 870         }
 871
 872         kbase_remove_va_region(kctx, reg);
 873
 874         return err;
 875 }
 876
 877 KBASE_EXPORT_TEST_API(kbase_gpu_mmap);
 878
 879 int kbase_gpu_munmap(struct kbase_context *kctx, struct kbase_va_region *reg)
 880 {
 881         int err;
 882
 883         if (reg->start_pfn == 0)
 884                 return 0;
 885
 886         if (reg->gpu_alloc && reg->gpu_alloc->type == KBASE_MEM_TYPE_ALIAS) {
 887                 size_t i;
 888
 889                 err = kbase_mmu_teardown_pages(kctx, reg->start_pfn, reg->nr_pages);
 890                 KBASE_DEBUG_ASSERT(reg->gpu_alloc->imported.alias.aliased);
 891                 for (i = 0; i < reg->gpu_alloc->imported.alias.nents; i++)
 892                         if (reg->gpu_alloc->imported.alias.aliased[i].alloc)
 893                                 kbase_mem_phy_alloc_gpu_unmapped(reg->gpu_alloc->imported.alias.aliased[i].alloc);
 894         } else {
 895                 err = kbase_mmu_teardown_pages(kctx, reg->start_pfn, kbase_reg_current_backed_size(reg));
 896                 kbase_mem_phy_alloc_gpu_unmapped(reg->gpu_alloc);
 897         }
 898
 899         if (err)
 900                 return err;
 901
 902         err = kbase_remove_va_region(kctx, reg);
 903         return err;
 904 }
 905
 906 static struct kbase_cpu_mapping *kbasep_find_enclosing_cpu_mapping_of_region(const struct kbase_va_region *reg, unsigned long uaddr, size_t size)
 907 {
 908         struct kbase_cpu_mapping *map;
 909         struct list_head *pos;
 910
 911         KBASE_DEBUG_ASSERT(NULL != reg);
 912         KBASE_DEBUG_ASSERT(reg->cpu_alloc);
 913
 914         if ((uintptr_t) uaddr + size < (uintptr_t) uaddr) /* overflow check */
 915                 return NULL;
 916
 917         list_for_each(pos, &reg->cpu_alloc->mappings) {
 918                 map = list_entry(pos, struct kbase_cpu_mapping, mappings_list);
 919                 if (map->vm_start <= uaddr && map->vm_end >= uaddr + size)
 920                         return map;
 921         }
 922
 923         return NULL;
 924 }
 925
 926 KBASE_EXPORT_TEST_API(kbasep_find_enclosing_cpu_mapping_of_region);
 927
 928 int kbasep_find_enclosing_cpu_mapping_offset(
 929         struct kbase_context *kctx, u64 gpu_addr,
 930         unsigned long uaddr, size_t size, u64 * offset)
 931 {
 932         struct kbase_cpu_mapping *map = NULL;
 933         const struct kbase_va_region *reg;
 934         int err = -EINVAL;
 935
 936         KBASE_DEBUG_ASSERT(kctx != NULL);
 937
 938         kbase_gpu_vm_lock(kctx);
 939
 940         reg = kbase_region_tracker_find_region_enclosing_address(kctx, gpu_addr);
 941         if (reg && !(reg->flags & KBASE_REG_FREE)) {
 942                 map = kbasep_find_enclosing_cpu_mapping_of_region(reg, uaddr,
 943                                 size);
 944                 if (map) {
 945                         *offset = (uaddr - PTR_TO_U64(map->vm_start)) +
 946                                                  (map->page_off << PAGE_SHIFT);
 947                         err = 0;
 948                 }
 949         }
 950
 951         kbase_gpu_vm_unlock(kctx);
 952
 953         return err;
 954 }
 955
 956 KBASE_EXPORT_TEST_API(kbasep_find_enclosing_cpu_mapping_offset);
 957
 958 void kbase_sync_single(struct kbase_context *kctx,
 959                 phys_addr_t cpu_pa, phys_addr_t gpu_pa,
 960                 off_t offset, size_t size, enum kbase_sync_type sync_fn)
 961 {
 962         struct page *cpu_page;
 963
 964         cpu_page = pfn_to_page(PFN_DOWN(cpu_pa));
 965
 966         if (likely(cpu_pa == gpu_pa)) {
 967                 dma_addr_t dma_addr;
 968
 969                 BUG_ON(!cpu_page);
 970                 BUG_ON(offset + size > PAGE_SIZE);
 971
 972                 dma_addr = kbase_dma_addr(cpu_page) + offset;
 973                 if (sync_fn == KBASE_SYNC_TO_CPU)
 974                         dma_sync_single_for_cpu(kctx->kbdev->dev, dma_addr,
 975                                         size, DMA_BIDIRECTIONAL);
 976                 else if (sync_fn == KBASE_SYNC_TO_DEVICE)
 977                         dma_sync_single_for_device(kctx->kbdev->dev, dma_addr,
 978                                         size, DMA_BIDIRECTIONAL);
 979         } else {
 980                 void *src = NULL;
 981                 void *dst = NULL;
 982                 struct page *gpu_page;
 983
 984                 if (WARN(!gpu_pa, "No GPU PA found for infinite cache op"))
 985                         return;
 986
 987                 gpu_page = pfn_to_page(PFN_DOWN(gpu_pa));
 988
 989                 if (sync_fn == KBASE_SYNC_TO_DEVICE) {
 990                         src = ((unsigned char *)kmap(cpu_page)) + offset;
 991                         dst = ((unsigned char *)kmap(gpu_page)) + offset;
 992                 } else if (sync_fn == KBASE_SYNC_TO_CPU) {
 993                         dma_sync_single_for_cpu(kctx->kbdev->dev,
 994                                         kbase_dma_addr(gpu_page) + offset,
 995                                         size, DMA_BIDIRECTIONAL);
 996                         src = ((unsigned char *)kmap(gpu_page)) + offset;
 997                         dst = ((unsigned char *)kmap(cpu_page)) + offset;
 998                 }
 999                 memcpy(dst, src, size);
1000                 kunmap(gpu_page);
1001                 kunmap(cpu_page);
1002                 if (sync_fn == KBASE_SYNC_TO_DEVICE)
1003                         dma_sync_single_for_device(kctx->kbdev->dev,
1004                                         kbase_dma_addr(gpu_page) + offset,
1005                                         size, DMA_BIDIRECTIONAL);
1006         }
1007 }
1008
1009 static int kbase_do_syncset(struct kbase_context *kctx,
1010                 struct base_syncset *set, enum kbase_sync_type sync_fn)
1011 {
1012         int err = 0;
1013         struct basep_syncset *sset = &set->basep_sset;
1014         struct kbase_va_region *reg;
1015         struct kbase_cpu_mapping *map;
1016         unsigned long start;
1017         size_t size;
1018         phys_addr_t *cpu_pa;
1019         phys_addr_t *gpu_pa;
1020         u64 page_off, page_count;
1021         u64 i;
1022         off_t offset;
1023
1024         kbase_os_mem_map_lock(kctx);
1025         kbase_gpu_vm_lock(kctx);
1026
1027         /* find the region where the virtual address is contained */
1028         reg = kbase_region_tracker_find_region_enclosing_address(kctx,
1029                         sset->mem_handle.basep.handle);
1030         if (!reg) {
1031                 dev_warn(kctx->kbdev->dev, "Can't find region at VA 0x%016llX",
1032                                 sset->mem_handle.basep.handle);
1033                 err = -EINVAL;
1034                 goto out_unlock;
1035         }
1036
1037         if (!(reg->flags & KBASE_REG_CPU_CACHED))
1038                 goto out_unlock;
1039
1040         start = (uintptr_t)sset->user_addr;
1041         size = (size_t)sset->size;
1042
1043         map = kbasep_find_enclosing_cpu_mapping_of_region(reg, start, size);
1044         if (!map) {
1045                 dev_warn(kctx->kbdev->dev, "Can't find CPU mapping 0x%016lX for VA 0x%016llX",
1046                                 start, sset->mem_handle.basep.handle);
1047                 err = -EINVAL;
1048                 goto out_unlock;
1049         }
1050
1051         offset = start & (PAGE_SIZE - 1);
1052         page_off = map->page_off + ((start - map->vm_start) >> PAGE_SHIFT);
1053         page_count = (size + offset + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1054         cpu_pa = kbase_get_cpu_phy_pages(reg);
1055         gpu_pa = kbase_get_gpu_phy_pages(reg);
1056
1057         /* Sync first page */
1058         if (cpu_pa[page_off]) {
1059                 size_t sz = MIN(((size_t) PAGE_SIZE - offset), size);
1060
1061                 kbase_sync_single(kctx, cpu_pa[page_off], gpu_pa[page_off],
1062                                 offset, sz, sync_fn);
1063         }
1064
1065         /* Sync middle pages (if any) */
1066         for (i = 1; page_count > 2 && i < page_count - 1; i++) {
1067                 /* we grow upwards, so bail on first non-present page */
1068                 if (!cpu_pa[page_off + i])
1069                         break;
1070
1071                 kbase_sync_single(kctx, cpu_pa[page_off + i],
1072                                 gpu_pa[page_off + i], 0, PAGE_SIZE, sync_fn);
1073         }
1074
1075         /* Sync last page (if any) */
1076         if (page_count > 1 && cpu_pa[page_off + page_count - 1]) {
1077                 size_t sz = ((start + size - 1) & ~PAGE_MASK) + 1;
1078
1079                 kbase_sync_single(kctx, cpu_pa[page_off + page_count - 1],
1080                                 gpu_pa[page_off + page_count - 1], 0, sz,
1081                                 sync_fn);
1082         }
1083
1084 out_unlock:
1085         kbase_gpu_vm_unlock(kctx);
1086         kbase_os_mem_map_unlock(kctx);
1087         return err;
1088 }
1089
1090 int kbase_sync_now(struct kbase_context *kctx, struct base_syncset *syncset)
1091 {
1092         int err = -EINVAL;
1093         struct basep_syncset *sset;
1094
1095         KBASE_DEBUG_ASSERT(NULL != kctx);
1096         KBASE_DEBUG_ASSERT(NULL != syncset);
1097
1098         sset = &syncset->basep_sset;
1099
1100         switch (sset->type) {
1101         case BASE_SYNCSET_OP_MSYNC:
1102                 err = kbase_do_syncset(kctx, syncset, KBASE_SYNC_TO_DEVICE);
1103                 break;
1104
1105         case BASE_SYNCSET_OP_CSYNC:
1106                 err = kbase_do_syncset(kctx, syncset, KBASE_SYNC_TO_CPU);
1107                 break;
1108
1109         default:
1110                 dev_warn(kctx->kbdev->dev, "Unknown msync op %d\n", sset->type);
1111                 break;
1112         }
1113
1114         return err;
1115 }
1116
1117 KBASE_EXPORT_TEST_API(kbase_sync_now);
1118
1119 /* vm lock must be held */
1120 int kbase_mem_free_region(struct kbase_context *kctx, struct kbase_va_region *reg)
1121 {
1122         int err;
1123
1124         KBASE_DEBUG_ASSERT(NULL != kctx);
1125         KBASE_DEBUG_ASSERT(NULL != reg);
1126         lockdep_assert_held(&kctx->reg_lock);
1127
1128         /*
1129          * Unlink the physical allocation before unmaking it evictable so
1130          * that the allocation isn't grown back to its last backed size
1131          * as we're going to unmap it anyway.
1132          */
1133         reg->cpu_alloc->reg = NULL;
1134         if (reg->cpu_alloc != reg->gpu_alloc)
1135                 reg->gpu_alloc->reg = NULL;
1136
1137         /*
1138          * If a region has been made evictable then we must unmake it
1139          * before trying to free it.
1140          * If the memory hasn't been reclaimed it will be unmapped and freed
1141          * below, if it has been reclaimed then the operations below are no-ops.
1142          */
1143         if (reg->flags & KBASE_REG_DONT_NEED) {
1144                 KBASE_DEBUG_ASSERT(reg->cpu_alloc->type ==
1145                                    KBASE_MEM_TYPE_NATIVE);
1146                 kbase_mem_evictable_unmake(reg->gpu_alloc);
1147         }
1148
1149         err = kbase_gpu_munmap(kctx, reg);
1150         if (err) {
1151                 dev_warn(reg->kctx->kbdev->dev, "Could not unmap from the GPU...\n");
1152                 goto out;
1153         }
1154
1155         /* This will also free the physical pages */
1156         kbase_free_alloced_region(reg);
1157
1158  out:
1159         return err;
1160 }
1161
1162 KBASE_EXPORT_TEST_API(kbase_mem_free_region);
1163
1164 /**
1165  * @brief Free the region from the GPU and unregister it.
1166  *
1167  * This function implements the free operation on a memory segment.
1168  * It will loudly fail if called with outstanding mappings.
1169  */
1170 int kbase_mem_free(struct kbase_context *kctx, u64 gpu_addr)
1171 {
1172         int err = 0;
1173         struct kbase_va_region *reg;
1174
1175         KBASE_DEBUG_ASSERT(kctx != NULL);
1176
1177         if (0 == gpu_addr) {
1178                 dev_warn(kctx->kbdev->dev, "gpu_addr 0 is reserved for the ringbuffer and it's an error to try to free it using kbase_mem_free\n");
1179                 return -EINVAL;
1180         }
1181         kbase_gpu_vm_lock(kctx);
1182
1183         if (gpu_addr >= BASE_MEM_COOKIE_BASE &&
1184             gpu_addr < BASE_MEM_FIRST_FREE_ADDRESS) {
1185                 int cookie = PFN_DOWN(gpu_addr - BASE_MEM_COOKIE_BASE);
1186
1187                 reg = kctx->pending_regions[cookie];
1188                 if (!reg) {
1189                         err = -EINVAL;
1190                         goto out_unlock;
1191                 }
1192
1193                 /* ask to unlink the cookie as we'll free it */
1194
1195                 kctx->pending_regions[cookie] = NULL;
1196                 kctx->cookies |= (1UL << cookie);
1197
1198                 kbase_free_alloced_region(reg);
1199         } else {
1200                 /* A real GPU va */
1201                 /* Validate the region */
1202                 reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
1203                 if (!reg || (reg->flags & KBASE_REG_FREE)) {
1204                         dev_warn(kctx->kbdev->dev, "kbase_mem_free called with nonexistent gpu_addr 0x%llX",
1205                                         gpu_addr);
1206                         err = -EINVAL;
1207                         goto out_unlock;
1208                 }
1209
1210                 if ((reg->flags & KBASE_REG_ZONE_MASK) == KBASE_REG_ZONE_SAME_VA) {
1211                         /* SAME_VA must be freed through munmap */
1212                         dev_warn(kctx->kbdev->dev, "%s called on SAME_VA memory 0x%llX", __func__,
1213                                         gpu_addr);
1214                         err = -EINVAL;
1215                         goto out_unlock;
1216                 }
1217                 err = kbase_mem_free_region(kctx, reg);
1218         }
1219
1220  out_unlock:
1221         kbase_gpu_vm_unlock(kctx);
1222         return err;
1223 }
1224
1225 KBASE_EXPORT_TEST_API(kbase_mem_free);
1226
1227 void kbase_update_region_flags(struct kbase_context *kctx,
1228                 struct kbase_va_region *reg, unsigned long flags)
1229 {
1230         KBASE_DEBUG_ASSERT(NULL != reg);
1231         KBASE_DEBUG_ASSERT((flags & ~((1ul << BASE_MEM_FLAGS_NR_BITS) - 1)) == 0);
1232
1233         reg->flags |= kbase_cache_enabled(flags, reg->nr_pages);
1234         /* all memory is now growable */
1235         reg->flags |= KBASE_REG_GROWABLE;
1236
1237         if (flags & BASE_MEM_GROW_ON_GPF)
1238                 reg->flags |= KBASE_REG_PF_GROW;
1239
1240         if (flags & BASE_MEM_PROT_CPU_WR)
1241                 reg->flags |= KBASE_REG_CPU_WR;
1242
1243         if (flags & BASE_MEM_PROT_CPU_RD)
1244                 reg->flags |= KBASE_REG_CPU_RD;
1245
1246         if (flags & BASE_MEM_PROT_GPU_WR)
1247                 reg->flags |= KBASE_REG_GPU_WR;
1248
1249         if (flags & BASE_MEM_PROT_GPU_RD)
1250                 reg->flags |= KBASE_REG_GPU_RD;
1251
1252         if (0 == (flags & BASE_MEM_PROT_GPU_EX))
1253                 reg->flags |= KBASE_REG_GPU_NX;
1254
1255         if (flags & BASE_MEM_COHERENT_SYSTEM ||
1256                         flags & BASE_MEM_COHERENT_SYSTEM_REQUIRED)
1257                 reg->flags |= KBASE_REG_SHARE_BOTH;
1258         else if (flags & BASE_MEM_COHERENT_LOCAL)
1259                 reg->flags |= KBASE_REG_SHARE_IN;
1260
1261         /* Set up default MEMATTR usage */
1262         if (kctx->kbdev->system_coherency == COHERENCY_ACE &&
1263                 (reg->flags & KBASE_REG_SHARE_BOTH)) {
1264                 reg->flags |=
1265                         KBASE_REG_MEMATTR_INDEX(AS_MEMATTR_INDEX_DEFAULT_ACE);
1266         } else {
1267                 reg->flags |=
1268                         KBASE_REG_MEMATTR_INDEX(AS_MEMATTR_INDEX_DEFAULT);
1269         }
1270 }
1271 KBASE_EXPORT_TEST_API(kbase_update_region_flags);
1272
1273 int kbase_alloc_phy_pages_helper(
1274         struct kbase_mem_phy_alloc *alloc,
1275         size_t nr_pages_requested)
1276 {
1277         int new_page_count __maybe_unused;
1278         size_t old_page_count = alloc->nents;
1279
1280         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_NATIVE);
1281         KBASE_DEBUG_ASSERT(alloc->imported.kctx);
1282
1283         if (nr_pages_requested == 0)
1284                 goto done; /*nothing to do*/
1285
1286         new_page_count = kbase_atomic_add_pages(
1287                         nr_pages_requested, &alloc->imported.kctx->used_pages);
1288         kbase_atomic_add_pages(nr_pages_requested, &alloc->imported.kctx->kbdev->memdev.used_pages);
1289
1290         /* Increase mm counters before we allocate pages so that this
1291          * allocation is visible to the OOM killer */
1292         kbase_process_page_usage_inc(alloc->imported.kctx, nr_pages_requested);
1293
1294         if (kbase_mem_pool_alloc_pages(&alloc->imported.kctx->mem_pool,
1295                         nr_pages_requested, alloc->pages + old_page_count) != 0)
1296                 goto no_alloc;
1297
1298         /*
1299          * Request a zone cache update, this scans only the new pages an
1300          * appends their information to the zone cache. if the update
1301          * fails then clear the cache so we fall-back to doing things
1302          * page by page.
1303          */
1304         if (kbase_zone_cache_update(alloc, old_page_count) != 0)
1305                 kbase_zone_cache_clear(alloc);
1306
1307         kbase_tlstream_aux_pagesalloc(
1308                         (u32)alloc->imported.kctx->id,
1309                         (u64)new_page_count);
1310
1311         alloc->nents += nr_pages_requested;
1312 done:
1313         return 0;
1314
1315 no_alloc:
1316         kbase_process_page_usage_dec(alloc->imported.kctx, nr_pages_requested);
1317         kbase_atomic_sub_pages(nr_pages_requested, &alloc->imported.kctx->used_pages);
1318         kbase_atomic_sub_pages(nr_pages_requested, &alloc->imported.kctx->kbdev->memdev.used_pages);
1319
1320         return -ENOMEM;
1321 }
1322
1323 int kbase_free_phy_pages_helper(
1324         struct kbase_mem_phy_alloc *alloc,
1325         size_t nr_pages_to_free)
1326 {
1327         struct kbase_context *kctx = alloc->imported.kctx;
1328         bool syncback;
1329         bool reclaimed = (alloc->evicted != 0);
1330         phys_addr_t *start_free;
1331         int new_page_count __maybe_unused;
1332
1333         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_NATIVE);
1334         KBASE_DEBUG_ASSERT(alloc->imported.kctx);
1335         KBASE_DEBUG_ASSERT(alloc->nents >= nr_pages_to_free);
1336
1337         /* early out if nothing to do */
1338         if (0 == nr_pages_to_free)
1339                 return 0;
1340
1341         start_free = alloc->pages + alloc->nents - nr_pages_to_free;
1342
1343         syncback = alloc->properties & KBASE_MEM_PHY_ALLOC_ACCESSED_CACHED;
1344
1345         /*
1346          * Clear the zone cache, we don't expect JIT allocations to be
1347          * shrunk in parts so there is no point trying to optimize for that
1348          * by scanning for the changes caused by freeing this memory and
1349          * updating the existing cache entries.
1350          */
1351         kbase_zone_cache_clear(alloc);
1352
1353         kbase_mem_pool_free_pages(&kctx->mem_pool,
1354                                   nr_pages_to_free,
1355                                   start_free,
1356                                   syncback,
1357                                   reclaimed);
1358
1359         alloc->nents -= nr_pages_to_free;
1360
1361         /*
1362          * If the allocation was not evicted (i.e. evicted == 0) then
1363          * the page accounting needs to be done.
1364          */
1365         if (!reclaimed) {
1366                 kbase_process_page_usage_dec(kctx, nr_pages_to_free);
1367                 new_page_count = kbase_atomic_sub_pages(nr_pages_to_free,
1368                                                         &kctx->used_pages);
1369                 kbase_atomic_sub_pages(nr_pages_to_free,
1370                                        &kctx->kbdev->memdev.used_pages);
1371
1372                 kbase_tlstream_aux_pagesalloc(
1373                                 (u32)kctx->id,
1374                                 (u64)new_page_count);
1375         }
1376
1377         return 0;
1378 }
1379
1380 void kbase_mem_kref_free(struct kref *kref)
1381 {
1382         struct kbase_mem_phy_alloc *alloc;
1383
1384         alloc = container_of(kref, struct kbase_mem_phy_alloc, kref);
1385
1386         switch (alloc->type) {
1387         case KBASE_MEM_TYPE_NATIVE: {
1388                 WARN_ON(!alloc->imported.kctx);
1389                 /*
1390                  * The physical allocation must have been removed from the
1391                  * eviction list before trying to free it.
1392                  */
1393                 WARN_ON(!list_empty(&alloc->evict_node));
1394                 kbase_free_phy_pages_helper(alloc, alloc->nents);
1395                 break;
1396         }
1397         case KBASE_MEM_TYPE_ALIAS: {
1398                 /* just call put on the underlying phy allocs */
1399                 size_t i;
1400                 struct kbase_aliased *aliased;
1401
1402                 aliased = alloc->imported.alias.aliased;
1403                 if (aliased) {
1404                         for (i = 0; i < alloc->imported.alias.nents; i++)
1405                                 if (aliased[i].alloc)
1406                                         kbase_mem_phy_alloc_put(aliased[i].alloc);
1407                         vfree(aliased);
1408                 }
1409                 break;
1410         }
1411         case KBASE_MEM_TYPE_RAW:
1412                 /* raw pages, external cleanup */
1413                 break;
1414  #ifdef CONFIG_UMP
1415         case KBASE_MEM_TYPE_IMPORTED_UMP:
1416                 ump_dd_release(alloc->imported.ump_handle);
1417                 break;
1418 #endif
1419 #ifdef CONFIG_DMA_SHARED_BUFFER
1420         case KBASE_MEM_TYPE_IMPORTED_UMM:
1421                 dma_buf_detach(alloc->imported.umm.dma_buf,
1422                                alloc->imported.umm.dma_attachment);
1423                 dma_buf_put(alloc->imported.umm.dma_buf);
1424                 break;
1425 #endif
1426         case KBASE_MEM_TYPE_IMPORTED_USER_BUF:
1427                 if (alloc->imported.user_buf.mm)
1428                         mmdrop(alloc->imported.user_buf.mm);
1429                 kfree(alloc->imported.user_buf.pages);
1430                 break;
1431         case KBASE_MEM_TYPE_TB:{
1432                 void *tb;
1433
1434                 tb = alloc->imported.kctx->jctx.tb;
1435                 kbase_device_trace_buffer_uninstall(alloc->imported.kctx);
1436                 vfree(tb);
1437                 break;
1438         }
1439         default:
1440                 WARN(1, "Unexecpted free of type %d\n", alloc->type);
1441                 break;
1442         }
1443
1444         /* Free based on allocation type */
1445         if (alloc->properties & KBASE_MEM_PHY_ALLOC_LARGE)
1446                 vfree(alloc);
1447         else
1448                 kfree(alloc);
1449 }
1450
1451 KBASE_EXPORT_TEST_API(kbase_mem_kref_free);
1452
1453 int kbase_alloc_phy_pages(struct kbase_va_region *reg, size_t vsize, size_t size)
1454 {
1455         KBASE_DEBUG_ASSERT(NULL != reg);
1456         KBASE_DEBUG_ASSERT(vsize > 0);
1457
1458         /* validate user provided arguments */
1459         if (size > vsize || vsize > reg->nr_pages)
1460                 goto out_term;
1461
1462         /* Prevent vsize*sizeof from wrapping around.
1463          * For instance, if vsize is 2**29+1, we'll allocate 1 byte and the alloc won't fail.
1464          */
1465         if ((size_t) vsize > ((size_t) -1 / sizeof(*reg->cpu_alloc->pages)))
1466                 goto out_term;
1467
1468         KBASE_DEBUG_ASSERT(0 != vsize);
1469
1470         if (kbase_alloc_phy_pages_helper(reg->cpu_alloc, size) != 0)
1471                 goto out_term;
1472
1473         reg->cpu_alloc->reg = reg;
1474         if (reg->cpu_alloc != reg->gpu_alloc) {
1475                 if (kbase_alloc_phy_pages_helper(reg->gpu_alloc, size) != 0)
1476                         goto out_rollback;
1477                 reg->gpu_alloc->reg = reg;
1478         }
1479
1480         return 0;
1481
1482 out_rollback:
1483         kbase_free_phy_pages_helper(reg->cpu_alloc, size);
1484 out_term:
1485         return -1;
1486 }
1487
1488 KBASE_EXPORT_TEST_API(kbase_alloc_phy_pages);
1489
1490 bool kbase_check_alloc_flags(unsigned long flags)
1491 {
1492         /* Only known input flags should be set. */
1493         if (flags & ~BASE_MEM_FLAGS_INPUT_MASK)
1494                 return false;
1495
1496         /* At least one flag should be set */
1497         if (flags == 0)
1498                 return false;
1499
1500         /* Either the GPU or CPU must be reading from the allocated memory */
1501         if ((flags & (BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_GPU_RD)) == 0)
1502                 return false;
1503
1504         /* Either the GPU or CPU must be writing to the allocated memory */
1505         if ((flags & (BASE_MEM_PROT_CPU_WR | BASE_MEM_PROT_GPU_WR)) == 0)
1506                 return false;
1507
1508         /* GPU cannot be writing to GPU executable memory and cannot grow the memory on page fault. */
1509         if ((flags & BASE_MEM_PROT_GPU_EX) && (flags & (BASE_MEM_PROT_GPU_WR | BASE_MEM_GROW_ON_GPF)))
1510                 return false;
1511
1512         /* GPU should have at least read or write access otherwise there is no
1513            reason for allocating. */
1514         if ((flags & (BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR)) == 0)
1515                 return false;
1516
1517         /* BASE_MEM_IMPORT_SHARED is only valid for imported memory */
1518         if ((flags & BASE_MEM_IMPORT_SHARED) == BASE_MEM_IMPORT_SHARED)
1519                 return false;
1520
1521         return true;
1522 }
1523
1524 bool kbase_check_import_flags(unsigned long flags)
1525 {
1526         /* Only known input flags should be set. */
1527         if (flags & ~BASE_MEM_FLAGS_INPUT_MASK)
1528                 return false;
1529
1530         /* At least one flag should be set */
1531         if (flags == 0)
1532                 return false;
1533
1534         /* Imported memory cannot be GPU executable */
1535         if (flags & BASE_MEM_PROT_GPU_EX)
1536                 return false;
1537
1538         /* Imported memory cannot grow on page fault */
1539         if (flags & BASE_MEM_GROW_ON_GPF)
1540                 return false;
1541
1542         /* GPU should have at least read or write access otherwise there is no
1543            reason for importing. */
1544         if ((flags & (BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR)) == 0)
1545                 return false;
1546
1547         /* Secure memory cannot be read by the CPU */
1548         if ((flags & BASE_MEM_SECURE) && (flags & BASE_MEM_PROT_CPU_RD))
1549                 return false;
1550
1551         return true;
1552 }
1553
1554 /**
1555  * @brief Acquire the per-context region list lock
1556  */
1557 void kbase_gpu_vm_lock(struct kbase_context *kctx)
1558 {
1559         KBASE_DEBUG_ASSERT(kctx != NULL);
1560         mutex_lock(&kctx->reg_lock);
1561 }
1562
1563 KBASE_EXPORT_TEST_API(kbase_gpu_vm_lock);
1564
1565 /**
1566  * @brief Release the per-context region list lock
1567  */
1568 void kbase_gpu_vm_unlock(struct kbase_context *kctx)
1569 {
1570         KBASE_DEBUG_ASSERT(kctx != NULL);
1571         mutex_unlock(&kctx->reg_lock);
1572 }
1573
1574 KBASE_EXPORT_TEST_API(kbase_gpu_vm_unlock);
1575
1576 #ifdef CONFIG_DEBUG_FS
1577 struct kbase_jit_debugfs_data {
1578         int (*func)(struct kbase_jit_debugfs_data *);
1579         struct mutex lock;
1580         struct kbase_context *kctx;
1581         u64 active_value;
1582         u64 pool_value;
1583         u64 destroy_value;
1584         char buffer[50];
1585 };
1586
1587 static int kbase_jit_debugfs_common_open(struct inode *inode,
1588                 struct file *file, int (*func)(struct kbase_jit_debugfs_data *))
1589 {
1590         struct kbase_jit_debugfs_data *data;
1591
1592         data = kzalloc(sizeof(*data), GFP_KERNEL);
1593         if (!data)
1594                 return -ENOMEM;
1595
1596         data->func = func;
1597         mutex_init(&data->lock);
1598         data->kctx = (struct kbase_context *) inode->i_private;
1599
1600         file->private_data = data;
1601
1602         return nonseekable_open(inode, file);
1603 }
1604
1605 static ssize_t kbase_jit_debugfs_common_read(struct file *file,
1606                 char __user *buf, size_t len, loff_t *ppos)
1607 {
1608         struct kbase_jit_debugfs_data *data;
1609         size_t size;
1610         int ret;
1611
1612         data = (struct kbase_jit_debugfs_data *) file->private_data;
1613         mutex_lock(&data->lock);
1614
1615         if (*ppos) {
1616                 size = strnlen(data->buffer, sizeof(data->buffer));
1617         } else {
1618                 if (!data->func) {
1619                         ret = -EACCES;
1620                         goto out_unlock;
1621                 }
1622
1623                 if (data->func(data)) {
1624                         ret = -EACCES;
1625                         goto out_unlock;
1626                 }
1627
1628                 size = scnprintf(data->buffer, sizeof(data->buffer),
1629                                 "%llu,%llu,%llu", data->active_value,
1630                                 data->pool_value, data->destroy_value);
1631         }
1632
1633         ret = simple_read_from_buffer(buf, len, ppos, data->buffer, size);
1634
1635 out_unlock:
1636         mutex_unlock(&data->lock);
1637         return ret;
1638 }
1639
1640 static int kbase_jit_debugfs_common_release(struct inode *inode,
1641                 struct file *file)
1642 {
1643         kfree(file->private_data);
1644         return 0;
1645 }
1646
1647 #define KBASE_JIT_DEBUGFS_DECLARE(__fops, __func) \
1648 static int __fops ## _open(struct inode *inode, struct file *file) \
1649 { \
1650         return kbase_jit_debugfs_common_open(inode, file, __func); \
1651 } \
1652 static const struct file_operations __fops = { \
1653         .owner = THIS_MODULE, \
1654         .open = __fops ## _open, \
1655         .release = kbase_jit_debugfs_common_release, \
1656         .read = kbase_jit_debugfs_common_read, \
1657         .write = NULL, \
1658         .llseek = generic_file_llseek, \
1659 }
1660
1661 static int kbase_jit_debugfs_count_get(struct kbase_jit_debugfs_data *data)
1662 {
1663         struct kbase_context *kctx = data->kctx;
1664         struct list_head *tmp;
1665
1666         mutex_lock(&kctx->jit_lock);
1667         list_for_each(tmp, &kctx->jit_active_head) {
1668                 data->active_value++;
1669         }
1670
1671         list_for_each(tmp, &kctx->jit_pool_head) {
1672                 data->pool_value++;
1673         }
1674
1675         list_for_each(tmp, &kctx->jit_destroy_head) {
1676                 data->destroy_value++;
1677         }
1678         mutex_unlock(&kctx->jit_lock);
1679
1680         return 0;
1681 }
1682 KBASE_JIT_DEBUGFS_DECLARE(kbase_jit_debugfs_count_fops,
1683                 kbase_jit_debugfs_count_get);
1684
1685 static int kbase_jit_debugfs_vm_get(struct kbase_jit_debugfs_data *data)
1686 {
1687         struct kbase_context *kctx = data->kctx;
1688         struct kbase_va_region *reg;
1689
1690         mutex_lock(&kctx->jit_lock);
1691         list_for_each_entry(reg, &kctx->jit_active_head, jit_node) {
1692                 data->active_value += reg->nr_pages;
1693         }
1694
1695         list_for_each_entry(reg, &kctx->jit_pool_head, jit_node) {
1696                 data->pool_value += reg->nr_pages;
1697         }
1698
1699         list_for_each_entry(reg, &kctx->jit_destroy_head, jit_node) {
1700                 data->destroy_value += reg->nr_pages;
1701         }
1702         mutex_unlock(&kctx->jit_lock);
1703
1704         return 0;
1705 }
1706 KBASE_JIT_DEBUGFS_DECLARE(kbase_jit_debugfs_vm_fops,
1707                 kbase_jit_debugfs_vm_get);
1708
1709 static int kbase_jit_debugfs_phys_get(struct kbase_jit_debugfs_data *data)
1710 {
1711         struct kbase_context *kctx = data->kctx;
1712         struct kbase_va_region *reg;
1713
1714         mutex_lock(&kctx->jit_lock);
1715         list_for_each_entry(reg, &kctx->jit_active_head, jit_node) {
1716                 data->active_value += reg->gpu_alloc->nents;
1717         }
1718
1719         list_for_each_entry(reg, &kctx->jit_pool_head, jit_node) {
1720                 data->pool_value += reg->gpu_alloc->nents;
1721         }
1722
1723         list_for_each_entry(reg, &kctx->jit_destroy_head, jit_node) {
1724                 data->destroy_value += reg->gpu_alloc->nents;
1725         }
1726         mutex_unlock(&kctx->jit_lock);
1727
1728         return 0;
1729 }
1730 KBASE_JIT_DEBUGFS_DECLARE(kbase_jit_debugfs_phys_fops,
1731                 kbase_jit_debugfs_phys_get);
1732
1733 void kbase_jit_debugfs_add(struct kbase_context *kctx)
1734 {
1735         /* Debugfs entry for getting the number of JIT allocations. */
1736         debugfs_create_file("mem_jit_count", S_IRUGO, kctx->kctx_dentry,
1737                         kctx, &kbase_jit_debugfs_count_fops);
1738
1739         /*
1740          * Debugfs entry for getting the total number of virtual pages
1741          * used by JIT allocations.
1742          */
1743         debugfs_create_file("mem_jit_vm", S_IRUGO, kctx->kctx_dentry,
1744                         kctx, &kbase_jit_debugfs_vm_fops);
1745
1746         /*
1747          * Debugfs entry for getting the number of physical pages used
1748          * by JIT allocations.
1749          */
1750         debugfs_create_file("mem_jit_phys", S_IRUGO, kctx->kctx_dentry,
1751                         kctx, &kbase_jit_debugfs_phys_fops);
1752 }
1753 #endif /* CONFIG_DEBUG_FS */
1754
1755 /**
1756  * kbase_jit_destroy_worker - Deferred worker which frees JIT allocations
1757  * @work: Work item
1758  *
1759  * This function does the work of freeing JIT allocations whose physical
1760  * backing has been released.
1761  */
1762 static void kbase_jit_destroy_worker(struct work_struct *work)
1763 {
1764         struct kbase_context *kctx;
1765         struct kbase_va_region *reg;
1766
1767         kctx = container_of(work, struct kbase_context, jit_work);
1768         do {
1769                 mutex_lock(&kctx->jit_lock);
1770                 if (list_empty(&kctx->jit_destroy_head))
1771                         reg = NULL;
1772                 else
1773                         reg = list_first_entry(&kctx->jit_destroy_head,
1774                                 struct kbase_va_region, jit_node);
1775
1776                 if (reg) {
1777                         list_del(&reg->jit_node);
1778                         mutex_unlock(&kctx->jit_lock);
1779
1780                         kbase_gpu_vm_lock(kctx);
1781                         kbase_mem_free_region(kctx, reg);
1782                         kbase_gpu_vm_unlock(kctx);
1783                 } else
1784                         mutex_unlock(&kctx->jit_lock);
1785         } while (reg);
1786 }
1787
1788 int kbase_jit_init(struct kbase_context *kctx)
1789 {
1790         INIT_LIST_HEAD(&kctx->jit_active_head);
1791         INIT_LIST_HEAD(&kctx->jit_pool_head);
1792         INIT_LIST_HEAD(&kctx->jit_destroy_head);
1793         mutex_init(&kctx->jit_lock);
1794         INIT_WORK(&kctx->jit_work, kbase_jit_destroy_worker);
1795
1796         return 0;
1797 }
1798
1799 struct kbase_va_region *kbase_jit_allocate(struct kbase_context *kctx,
1800                 struct base_jit_alloc_info *info)
1801 {
1802         struct kbase_va_region *reg = NULL;
1803         struct kbase_va_region *walker;
1804         struct kbase_va_region *temp;
1805         size_t current_diff = SIZE_MAX;
1806
1807         int ret;
1808
1809         mutex_lock(&kctx->jit_lock);
1810         /*
1811          * Scan the pool for an existing allocation which meets our
1812          * requirements and remove it.
1813          */
1814         list_for_each_entry_safe(walker, temp, &kctx->jit_pool_head, jit_node) {
1815
1816                 if (walker->nr_pages >= info->va_pages) {
1817                         size_t min_size, max_size, diff;
1818
1819                         /*
1820                          * The JIT allocations VA requirements have been
1821                          * meet, it's suitable but other allocations
1822                          * might be a better fit.
1823                          */
1824                         min_size = min_t(size_t, walker->gpu_alloc->nents,
1825                                         info->commit_pages);
1826                         max_size = max_t(size_t, walker->gpu_alloc->nents,
1827                                         info->commit_pages);
1828                         diff = max_size - min_size;
1829
1830                         if (current_diff > diff) {
1831                                 current_diff = diff;
1832                                 reg = walker;
1833                         }
1834
1835                         /* The allocation is an exact match, stop looking */
1836                         if (current_diff == 0)
1837                                 break;
1838                 }
1839         }
1840
1841         if (reg) {
1842                 /*
1843                  * Remove the found region from the pool and add it to the
1844                  * active list.
1845                  */
1846                 list_del_init(&reg->jit_node);
1847                 list_add(&reg->jit_node, &kctx->jit_active_head);
1848
1849                 /* Release the jit lock before modifying the allocation */
1850                 mutex_unlock(&kctx->jit_lock);
1851
1852                 kbase_gpu_vm_lock(kctx);
1853
1854                 /* Make the physical backing no longer reclaimable */
1855                 if (!kbase_mem_evictable_unmake(reg->gpu_alloc))
1856                         goto update_failed;
1857
1858                 /* Grow the backing if required */
1859                 if (reg->gpu_alloc->nents < info->commit_pages) {
1860                         size_t delta;
1861                         size_t old_size = reg->gpu_alloc->nents;
1862
1863                         /* Allocate some more pages */
1864                         delta = info->commit_pages - reg->gpu_alloc->nents;
1865                         if (kbase_alloc_phy_pages_helper(reg->gpu_alloc, delta)
1866                                         != 0)
1867                                 goto update_failed;
1868
1869                         if (reg->cpu_alloc != reg->gpu_alloc) {
1870                                 if (kbase_alloc_phy_pages_helper(
1871                                                 reg->cpu_alloc, delta) != 0) {
1872                                         kbase_free_phy_pages_helper(
1873                                                         reg->gpu_alloc, delta);
1874                                         goto update_failed;
1875                                 }
1876                         }
1877
1878                         ret = kbase_mem_grow_gpu_mapping(kctx, reg,
1879                                         info->commit_pages, old_size);
1880                         /*
1881                          * The grow failed so put the allocation back in the
1882                          * pool and return failure.
1883                          */
1884                         if (ret)
1885                                 goto update_failed;
1886                 }
1887                 kbase_gpu_vm_unlock(kctx);
1888         } else {
1889                 /* No suitable JIT allocation was found so create a new one */
1890                 u64 flags = BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_GPU_RD |
1891                                 BASE_MEM_PROT_GPU_WR | BASE_MEM_GROW_ON_GPF |
1892                                 BASE_MEM_COHERENT_LOCAL;
1893                 u64 gpu_addr;
1894                 u16 alignment;
1895
1896                 mutex_unlock(&kctx->jit_lock);
1897
1898                 reg = kbase_mem_alloc(kctx, info->va_pages, info->commit_pages,
1899                                 info->extent, &flags, &gpu_addr, &alignment);
1900                 if (!reg)
1901                         goto out_unlocked;
1902
1903                 mutex_lock(&kctx->jit_lock);
1904                 list_add(&reg->jit_node, &kctx->jit_active_head);
1905                 mutex_unlock(&kctx->jit_lock);
1906         }
1907
1908         return reg;
1909
1910 update_failed:
1911         /*
1912          * An update to an allocation from the pool failed, chances
1913          * are slim a new allocation would fair any better so return
1914          * the allocation to the pool and return the function with failure.
1915          */
1916         kbase_gpu_vm_unlock(kctx);
1917         mutex_lock(&kctx->jit_lock);
1918         list_del_init(&reg->jit_node);
1919         list_add(&reg->jit_node, &kctx->jit_pool_head);
1920         mutex_unlock(&kctx->jit_lock);
1921 out_unlocked:
1922         return NULL;
1923 }
1924
1925 void kbase_jit_free(struct kbase_context *kctx, struct kbase_va_region *reg)
1926 {
1927         /* The physical backing of memory in the pool is always reclaimable */
1928         down_read(&kctx->process_mm->mmap_sem);
1929         kbase_gpu_vm_lock(kctx);
1930         kbase_mem_evictable_make(reg->gpu_alloc);
1931         kbase_gpu_vm_unlock(kctx);
1932         up_read(&kctx->process_mm->mmap_sem);
1933
1934         mutex_lock(&kctx->jit_lock);
1935         list_del_init(&reg->jit_node);
1936         list_add(&reg->jit_node, &kctx->jit_pool_head);
1937         mutex_unlock(&kctx->jit_lock);
1938 }
1939
1940 void kbase_jit_backing_lost(struct kbase_va_region *reg)
1941 {
1942         struct kbase_context *kctx = reg->kctx;
1943
1944         /*
1945          * JIT allocations will always be on a list, if the region
1946          * is not on a list then it's not a JIT allocation.
1947          */
1948         if (list_empty(&reg->jit_node))
1949                 return;
1950
1951         /*
1952          * Freeing the allocation requires locks we might not be able
1953          * to take now, so move the allocation to the free list and kick
1954          * the worker which will do the freeing.
1955          */
1956         mutex_lock(&kctx->jit_lock);
1957         list_del_init(&reg->jit_node);
1958         list_add(&reg->jit_node, &kctx->jit_destroy_head);
1959         mutex_unlock(&kctx->jit_lock);
1960
1961         schedule_work(&kctx->jit_work);
1962 }
1963
1964 bool kbase_jit_evict(struct kbase_context *kctx)
1965 {
1966         struct kbase_va_region *reg = NULL;
1967
1968         lockdep_assert_held(&kctx->reg_lock);
1969
1970         /* Free the oldest allocation from the pool */
1971         mutex_lock(&kctx->jit_lock);
1972         if (!list_empty(&kctx->jit_pool_head)) {
1973                 reg = list_entry(kctx->jit_pool_head.prev,
1974                                 struct kbase_va_region, jit_node);
1975                 list_del(&reg->jit_node);
1976         }
1977         mutex_unlock(&kctx->jit_lock);
1978
1979         if (reg)
1980                 kbase_mem_free_region(kctx, reg);
1981
1982         return (reg != NULL);
1983 }
1984
1985 void kbase_jit_term(struct kbase_context *kctx)
1986 {
1987         struct kbase_va_region *walker;
1988
1989         /* Free all allocations for this context */
1990
1991         /*
1992          * Flush the freeing of allocations whose backing has been freed
1993          * (i.e. everything in jit_destroy_head).
1994          */
1995         cancel_work_sync(&kctx->jit_work);
1996
1997         kbase_gpu_vm_lock(kctx);
1998         /* Free all allocations from the pool */
1999         while (!list_empty(&kctx->jit_pool_head)) {
2000                 walker = list_first_entry(&kctx->jit_pool_head,
2001                                 struct kbase_va_region, jit_node);
2002                 list_del(&walker->jit_node);
2003                 kbase_mem_free_region(kctx, walker);
2004         }
2005
2006         /* Free all allocations from active list */
2007         while (!list_empty(&kctx->jit_active_head)) {
2008                 walker = list_first_entry(&kctx->jit_active_head,
2009                                 struct kbase_va_region, jit_node);
2010                 list_del(&walker->jit_node);
2011                 kbase_mem_free_region(kctx, walker);
2012         }
2013         kbase_gpu_vm_unlock(kctx);
2014 }
2015
2016 static int kbase_jd_user_buf_map(struct kbase_context *kctx,
2017                 struct kbase_va_region *reg)
2018 {
2019         long pinned_pages;
2020         struct kbase_mem_phy_alloc *alloc;
2021         struct page **pages;
2022         phys_addr_t *pa;
2023         long i;
2024         int err = -ENOMEM;
2025         unsigned long address;
2026         struct mm_struct *mm;
2027         struct device *dev;
2028         unsigned long offset;
2029         unsigned long local_size;
2030
2031         alloc = reg->gpu_alloc;
2032         pa = kbase_get_gpu_phy_pages(reg);
2033         address = alloc->imported.user_buf.address;
2034         mm = alloc->imported.user_buf.mm;
2035
2036         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_IMPORTED_USER_BUF);
2037
2038         pages = alloc->imported.user_buf.pages;
2039
2040 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0)
2041         pinned_pages = get_user_pages(NULL, mm,
2042                         address,
2043                         alloc->imported.user_buf.nr_pages,
2044                         reg->flags & KBASE_REG_GPU_WR,
2045                         0, pages, NULL);
2046 #else
2047         pinned_pages = get_user_pages_remote(NULL, mm,
2048                         address,
2049                         alloc->imported.user_buf.nr_pages,
2050                         reg->flags & KBASE_REG_GPU_WR,
2051                         0, pages, NULL);
2052 #endif
2053
2054         if (pinned_pages <= 0)
2055                 return pinned_pages;
2056
2057         if (pinned_pages != alloc->imported.user_buf.nr_pages) {
2058                 for (i = 0; i < pinned_pages; i++)
2059                         put_page(pages[i]);
2060                 return -ENOMEM;
2061         }
2062
2063         dev = kctx->kbdev->dev;
2064         offset = address & ~PAGE_MASK;
2065         local_size = alloc->imported.user_buf.size;
2066
2067         for (i = 0; i < pinned_pages; i++) {
2068                 dma_addr_t dma_addr;
2069                 unsigned long min;
2070
2071                 min = MIN(PAGE_SIZE - offset, local_size);
2072                 dma_addr = dma_map_page(dev, pages[i],
2073                                 offset, min,
2074                                 DMA_BIDIRECTIONAL);
2075                 if (dma_mapping_error(dev, dma_addr))
2076                         goto unwind;
2077
2078                 alloc->imported.user_buf.dma_addrs[i] = dma_addr;
2079                 pa[i] = page_to_phys(pages[i]);
2080
2081                 local_size -= min;
2082                 offset = 0;
2083         }
2084
2085         alloc->nents = pinned_pages;
2086
2087         err = kbase_mmu_insert_pages(kctx, reg->start_pfn, pa,
2088                         kbase_reg_current_backed_size(reg),
2089                         reg->flags);
2090         if (err == 0)
2091                 return 0;
2092
2093         alloc->nents = 0;
2094         /* fall down */
2095 unwind:
2096         while (i--) {
2097                 dma_unmap_page(kctx->kbdev->dev,
2098                                 alloc->imported.user_buf.dma_addrs[i],
2099                                 PAGE_SIZE, DMA_BIDIRECTIONAL);
2100                 put_page(pages[i]);
2101                 pages[i] = NULL;
2102         }
2103
2104         return err;
2105 }
2106
2107 static void kbase_jd_user_buf_unmap(struct kbase_context *kctx,
2108                 struct kbase_mem_phy_alloc *alloc, bool writeable)
2109 {
2110         long i;
2111         struct page **pages;
2112         unsigned long size = alloc->imported.user_buf.size;
2113
2114         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_IMPORTED_USER_BUF);
2115         pages = alloc->imported.user_buf.pages;
2116         for (i = 0; i < alloc->imported.user_buf.nr_pages; i++) {
2117                 unsigned long local_size;
2118                 dma_addr_t dma_addr = alloc->imported.user_buf.dma_addrs[i];
2119
2120                 local_size = MIN(size, PAGE_SIZE - (dma_addr & ~PAGE_MASK));
2121                 dma_unmap_page(kctx->kbdev->dev, dma_addr, local_size,
2122                                 DMA_BIDIRECTIONAL);
2123                 if (writeable)
2124                         set_page_dirty_lock(pages[i]);
2125                 put_page(pages[i]);
2126                 pages[i] = NULL;
2127
2128                 size -= local_size;
2129         }
2130         alloc->nents = 0;
2131 }
2132
2133
2134 /* to replace sg_dma_len. */
2135 #define MALI_SG_DMA_LEN(sg)        ((sg)->length)
2136
2137 #ifdef CONFIG_DMA_SHARED_BUFFER
2138 static int kbase_jd_umm_map(struct kbase_context *kctx,
2139                 struct kbase_va_region *reg)
2140 {
2141         struct sg_table *sgt;
2142         struct scatterlist *s;
2143         int i;
2144         phys_addr_t *pa;
2145         int err;
2146         size_t count = 0;
2147         struct kbase_mem_phy_alloc *alloc;
2148
2149         alloc = reg->gpu_alloc;
2150
2151         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_IMPORTED_UMM);
2152         KBASE_DEBUG_ASSERT(NULL == alloc->imported.umm.sgt);
2153         sgt = dma_buf_map_attachment(alloc->imported.umm.dma_attachment,
2154                         DMA_BIDIRECTIONAL);
2155
2156         if (IS_ERR_OR_NULL(sgt))
2157                 return -EINVAL;
2158
2159         /* save for later */
2160         alloc->imported.umm.sgt = sgt;
2161
2162         pa = kbase_get_gpu_phy_pages(reg);
2163         KBASE_DEBUG_ASSERT(pa);
2164
2165         for_each_sg(sgt->sgl, s, sgt->nents, i) {
2166                 int j;
2167                 size_t pages = PFN_UP(MALI_SG_DMA_LEN(s));
2168
2169                 WARN_ONCE(MALI_SG_DMA_LEN(s) & (PAGE_SIZE-1),
2170                 "MALI_SG_DMA_LEN(s)=%u is not a multiple of PAGE_SIZE\n",
2171                 MALI_SG_DMA_LEN(s));
2172
2173                 WARN_ONCE(sg_dma_address(s) & (PAGE_SIZE-1),
2174                 "sg_dma_address(s)=%llx is not aligned to PAGE_SIZE\n",
2175                 (unsigned long long) sg_dma_address(s));
2176
2177                 for (j = 0; (j < pages) && (count < reg->nr_pages); j++,
2178                                 count++)
2179                         *pa++ = sg_dma_address(s) + (j << PAGE_SHIFT);
2180                 WARN_ONCE(j < pages,
2181                 "sg list from dma_buf_map_attachment > dma_buf->size=%zu\n",
2182                 alloc->imported.umm.dma_buf->size);
2183         }
2184
2185         if (WARN_ONCE(count < reg->nr_pages,
2186                         "sg list from dma_buf_map_attachment < dma_buf->size=%zu\n",
2187                         alloc->imported.umm.dma_buf->size)) {
2188                 err = -EINVAL;
2189                 goto out;
2190         }
2191
2192         /* Update nents as we now have pages to map */
2193         alloc->nents = count;
2194
2195         err = kbase_mmu_insert_pages(kctx, reg->start_pfn,
2196                         kbase_get_gpu_phy_pages(reg),
2197                         kbase_reg_current_backed_size(reg),
2198                         reg->flags | KBASE_REG_GPU_WR | KBASE_REG_GPU_RD);
2199
2200 out:
2201         if (err) {
2202                 dma_buf_unmap_attachment(alloc->imported.umm.dma_attachment,
2203                                 alloc->imported.umm.sgt, DMA_BIDIRECTIONAL);
2204                 alloc->imported.umm.sgt = NULL;
2205         }
2206
2207         return err;
2208 }
2209
2210 static void kbase_jd_umm_unmap(struct kbase_context *kctx,
2211                 struct kbase_mem_phy_alloc *alloc)
2212 {
2213         KBASE_DEBUG_ASSERT(kctx);
2214         KBASE_DEBUG_ASSERT(alloc);
2215         KBASE_DEBUG_ASSERT(alloc->imported.umm.dma_attachment);
2216         KBASE_DEBUG_ASSERT(alloc->imported.umm.sgt);
2217         dma_buf_unmap_attachment(alloc->imported.umm.dma_attachment,
2218             alloc->imported.umm.sgt, DMA_BIDIRECTIONAL);
2219         alloc->imported.umm.sgt = NULL;
2220         alloc->nents = 0;
2221 }
2222 #endif                          /* CONFIG_DMA_SHARED_BUFFER */
2223
2224 #if (defined(CONFIG_KDS) && defined(CONFIG_UMP)) \
2225                 || defined(CONFIG_DMA_SHARED_BUFFER_USES_KDS)
2226 static void add_kds_resource(struct kds_resource *kds_res,
2227                 struct kds_resource **kds_resources, u32 *kds_res_count,
2228                 unsigned long *kds_access_bitmap, bool exclusive)
2229 {
2230         u32 i;
2231
2232         for (i = 0; i < *kds_res_count; i++) {
2233                 /* Duplicate resource, ignore */
2234                 if (kds_resources[i] == kds_res)
2235                         return;
2236         }
2237
2238         kds_resources[*kds_res_count] = kds_res;
2239         if (exclusive)
2240                 set_bit(*kds_res_count, kds_access_bitmap);
2241         (*kds_res_count)++;
2242 }
2243 #endif
2244
2245 struct kbase_mem_phy_alloc *kbase_map_external_resource(
2246                 struct kbase_context *kctx, struct kbase_va_region *reg,
2247                 struct mm_struct *locked_mm
2248 #ifdef CONFIG_KDS
2249                 , u32 *kds_res_count, struct kds_resource **kds_resources,
2250                 unsigned long *kds_access_bitmap, bool exclusive
2251 #endif
2252                 )
2253 {
2254         int err;
2255
2256         /* decide what needs to happen for this resource */
2257         switch (reg->gpu_alloc->type) {
2258         case KBASE_MEM_TYPE_IMPORTED_USER_BUF: {
2259                 if (reg->gpu_alloc->imported.user_buf.mm != locked_mm)
2260                         goto exit;
2261
2262                 reg->gpu_alloc->imported.user_buf.current_mapping_usage_count++;
2263                 if (1 == reg->gpu_alloc->imported.user_buf.current_mapping_usage_count) {
2264                         err = kbase_jd_user_buf_map(kctx, reg);
2265                         if (err) {
2266                                 reg->gpu_alloc->imported.user_buf.current_mapping_usage_count--;
2267                                 goto exit;
2268                         }
2269                 }
2270         }
2271         break;
2272         case KBASE_MEM_TYPE_IMPORTED_UMP: {
2273 #if defined(CONFIG_KDS) && defined(CONFIG_UMP)
2274                 if (kds_res_count) {
2275                         struct kds_resource *kds_res;
2276
2277                         kds_res = ump_dd_kds_resource_get(
2278                                         reg->gpu_alloc->imported.ump_handle);
2279                         if (kds_res)
2280                                 add_kds_resource(kds_res, kds_resources,
2281                                                 kds_res_count,
2282                                                 kds_access_bitmap, exclusive);
2283                 }
2284 #endif                          /*defined(CONFIG_KDS) && defined(CONFIG_UMP) */
2285                 break;
2286         }
2287 #ifdef CONFIG_DMA_SHARED_BUFFER
2288         case KBASE_MEM_TYPE_IMPORTED_UMM: {
2289 #ifdef CONFIG_DMA_SHARED_BUFFER_USES_KDS
2290                 if (kds_res_count) {
2291                         struct kds_resource *kds_res;
2292
2293                         kds_res = get_dma_buf_kds_resource(
2294                                         reg->gpu_alloc->imported.umm.dma_buf);
2295                         if (kds_res)
2296                                 add_kds_resource(kds_res, kds_resources,
2297                                                 kds_res_count,
2298                                                 kds_access_bitmap, exclusive);
2299                 }
2300 #endif
2301                 reg->gpu_alloc->imported.umm.current_mapping_usage_count++;
2302                 if (1 == reg->gpu_alloc->imported.umm.current_mapping_usage_count) {
2303                         err = kbase_jd_umm_map(kctx, reg);
2304                         if (err) {
2305                                 reg->gpu_alloc->imported.umm.current_mapping_usage_count--;
2306                                 goto exit;
2307                         }
2308                 }
2309                 break;
2310         }
2311 #endif
2312         default:
2313                 goto exit;
2314         }
2315
2316         return kbase_mem_phy_alloc_get(reg->gpu_alloc);
2317 exit:
2318         return NULL;
2319 }
2320
2321 void kbase_unmap_external_resource(struct kbase_context *kctx,
2322                 struct kbase_va_region *reg, struct kbase_mem_phy_alloc *alloc)
2323 {
2324         switch (alloc->type) {
2325 #ifdef CONFIG_DMA_SHARED_BUFFER
2326         case KBASE_MEM_TYPE_IMPORTED_UMM: {
2327                 alloc->imported.umm.current_mapping_usage_count--;
2328
2329                 if (0 == alloc->imported.umm.current_mapping_usage_count) {
2330                         if (reg && reg->gpu_alloc == alloc)
2331                                 kbase_mmu_teardown_pages(
2332                                                 kctx,
2333                                                 reg->start_pfn,
2334                                                 kbase_reg_current_backed_size(reg));
2335
2336                         kbase_jd_umm_unmap(kctx, alloc);
2337                 }
2338         }
2339         break;
2340 #endif /* CONFIG_DMA_SHARED_BUFFER */
2341         case KBASE_MEM_TYPE_IMPORTED_USER_BUF: {
2342                 alloc->imported.user_buf.current_mapping_usage_count--;
2343
2344                 if (0 == alloc->imported.user_buf.current_mapping_usage_count) {
2345                         bool writeable = true;
2346
2347                         if (reg && reg->gpu_alloc == alloc)
2348                                 kbase_mmu_teardown_pages(
2349                                                 kctx,
2350                                                 reg->start_pfn,
2351                                                 kbase_reg_current_backed_size(reg));
2352
2353                         if (reg && ((reg->flags & KBASE_REG_GPU_WR) == 0))
2354                                 writeable = false;
2355
2356                         kbase_jd_user_buf_unmap(kctx, alloc, writeable);
2357                 }
2358         }
2359         break;
2360         default:
2361         break;
2362         }
2363         kbase_mem_phy_alloc_put(alloc);
2364 }
2365
2366 struct kbase_ctx_ext_res_meta *kbase_sticky_resource_acquire(
2367                 struct kbase_context *kctx, u64 gpu_addr)
2368 {
2369         struct kbase_ctx_ext_res_meta *meta = NULL;
2370         struct kbase_ctx_ext_res_meta *walker;
2371
2372         lockdep_assert_held(&kctx->reg_lock);
2373
2374         /*
2375          * Walk the per context external resource metadata list for the
2376          * metadata which matches the region which is being acquired.
2377          */
2378         list_for_each_entry(walker, &kctx->ext_res_meta_head, ext_res_node) {
2379                 if (walker->gpu_addr == gpu_addr) {
2380                         meta = walker;
2381                         break;
2382                 }
2383         }
2384
2385         /* No metadata exists so create one. */
2386         if (!meta) {
2387                 struct kbase_va_region *reg;
2388
2389                 /* Find the region */
2390                 reg = kbase_region_tracker_find_region_enclosing_address(
2391                                 kctx, gpu_addr);
2392                 if (NULL == reg || (reg->flags & KBASE_REG_FREE))
2393                         goto failed;
2394
2395                 /* Allocate the metadata object */
2396                 meta = kzalloc(sizeof(*meta), GFP_KERNEL);
2397                 if (!meta)
2398                         goto failed;
2399
2400                 /*
2401                  * Fill in the metadata object and acquire a reference
2402                  * for the physical resource.
2403                  */
2404                 meta->alloc = kbase_map_external_resource(kctx, reg, NULL
2405 #ifdef CONFIG_KDS
2406                                 , NULL, NULL,
2407                                 NULL, false
2408 #endif
2409                                 );
2410
2411                 if (!meta->alloc)
2412                         goto fail_map;
2413
2414                 meta->gpu_addr = reg->start_pfn << PAGE_SHIFT;
2415
2416                 list_add(&meta->ext_res_node, &kctx->ext_res_meta_head);
2417         }
2418
2419         return meta;
2420
2421 fail_map:
2422         kfree(meta);
2423 failed:
2424         return NULL;
2425 }
2426
2427 bool kbase_sticky_resource_release(struct kbase_context *kctx,
2428                 struct kbase_ctx_ext_res_meta *meta, u64 gpu_addr)
2429 {
2430         struct kbase_ctx_ext_res_meta *walker;
2431         struct kbase_va_region *reg;
2432
2433         lockdep_assert_held(&kctx->reg_lock);
2434
2435         /* Search of the metadata if one isn't provided. */
2436         if (!meta) {
2437                 /*
2438                  * Walk the per context external resource metadata list for the
2439                  * metadata which matches the region which is being released.
2440                  */
2441                 list_for_each_entry(walker, &kctx->ext_res_meta_head,
2442                                 ext_res_node) {
2443                         if (walker->gpu_addr == gpu_addr) {
2444                                 meta = walker;
2445                                 break;
2446                         }
2447                 }
2448         }
2449
2450         /* No metadata so just return. */
2451         if (!meta)
2452                 return false;
2453
2454         /* Drop the physical memory reference and free the metadata. */
2455         reg = kbase_region_tracker_find_region_enclosing_address(
2456                         kctx,
2457                         meta->gpu_addr);
2458
2459         kbase_unmap_external_resource(kctx, reg, meta->alloc);
2460         list_del(&meta->ext_res_node);
2461         kfree(meta);
2462
2463         return true;
2464 }
2465
2466 int kbase_sticky_resource_init(struct kbase_context *kctx)
2467 {
2468         INIT_LIST_HEAD(&kctx->ext_res_meta_head);
2469
2470         return 0;
2471 }
2472
2473 void kbase_sticky_resource_term(struct kbase_context *kctx)
2474 {
2475         struct kbase_ctx_ext_res_meta *walker;
2476
2477         lockdep_assert_held(&kctx->reg_lock);
2478
2479         /*
2480          * Free any sticky resources which haven't been unmapped.
2481          *
2482          * Note:
2483          * We don't care about refcounts at this point as no future
2484          * references to the meta data will be made.
2485          * Region termination would find these if we didn't free them
2486          * here, but it's more efficient if we do the clean up here.
2487          */
2488         while (!list_empty(&kctx->ext_res_meta_head)) {
2489                 walker = list_first_entry(&kctx->ext_res_meta_head,
2490                                 struct kbase_ctx_ext_res_meta, ext_res_node);
2491
2492                 kbase_sticky_resource_release(kctx, walker, 0);
2493         }
2494 }