drivers/gpu/arm/t6xx/kbase/src/common/mali_kbase_mem.c

   1 /*
   2  *
   3  * (C) COPYRIGHT 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
  28 #include <linux/bug.h>
  29 #include <linux/compat.h>
  30
  31 #include <kbase/mali_kbase_config.h>
  32 #include <kbase/src/common/mali_kbase.h>
  33 #include <kbase/src/common/mali_midg_regmap.h>
  34 #include <kbase/src/common/mali_kbase_cache_policy.h>
  35 #include <kbase/src/common/mali_kbase_hw.h>
  36 #include <kbase/src/common/mali_kbase_gator.h>
  37
  38 /**
  39  * @brief Check the zone compatibility of two regions.
  40  */
  41 STATIC int kbase_region_tracker_match_zone(struct kbase_va_region *reg1, struct kbase_va_region *reg2)
  42 {
  43         return ((reg1->flags & KBASE_REG_ZONE_MASK) == (reg2->flags & KBASE_REG_ZONE_MASK));
  44 }
  45
  46 KBASE_EXPORT_TEST_API(kbase_region_tracker_match_zone)
  47
  48 /* This function inserts a region into the tree. */
  49 static void kbase_region_tracker_insert(struct kbase_context *kctx, struct kbase_va_region *new_reg)
  50 {
  51         u64 start_pfn = new_reg->start_pfn;
  52         struct rb_node **link = &(kctx->reg_rbtree.rb_node);
  53         struct rb_node *parent = NULL;
  54
  55         /* Find the right place in the tree using tree search */
  56         while (*link) {
  57                 struct kbase_va_region *old_reg;
  58
  59                 parent = *link;
  60                 old_reg = rb_entry(parent, struct kbase_va_region, rblink);
  61
  62                 /* RBTree requires no duplicate entries. */
  63                 KBASE_DEBUG_ASSERT(old_reg->start_pfn != start_pfn);
  64
  65                 if (old_reg->start_pfn > start_pfn)
  66                         link = &(*link)->rb_left;
  67                 else
  68                         link = &(*link)->rb_right;
  69         }
  70
  71         /* Put the new node there, and rebalance tree */
  72         rb_link_node(&(new_reg->rblink), parent, link);
  73         rb_insert_color(&(new_reg->rblink), &(kctx->reg_rbtree));
  74 }
  75
  76 /* Find allocated region enclosing range. */
  77 struct kbase_va_region *kbase_region_tracker_find_region_enclosing_range(kbase_context *kctx, u64 start_pfn, size_t nr_pages)
  78 {
  79         struct rb_node *rbnode;
  80         struct kbase_va_region *reg;
  81         u64 end_pfn = start_pfn + nr_pages;
  82
  83         rbnode = kctx->reg_rbtree.rb_node;
  84
  85         while (rbnode) {
  86                 u64 tmp_start_pfn, tmp_end_pfn;
  87                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
  88                 tmp_start_pfn = reg->start_pfn;
  89                 tmp_end_pfn = reg->start_pfn + kbase_reg_current_backed_size(reg);
  90
  91                 /* If start is lower than this, go left. */
  92                 if (start_pfn < tmp_start_pfn)
  93                         rbnode = rbnode->rb_left;
  94                 /* If end is higher than this, then go right. */
  95                 else if (end_pfn > tmp_end_pfn)
  96                         rbnode = rbnode->rb_right;
  97                 else    /* Enclosing */
  98                         return reg;
  99         }
 100
 101         return NULL;
 102 }
 103
 104 /* Find allocated region enclosing free range. */
 105 struct kbase_va_region *kbase_region_tracker_find_region_enclosing_range_free(kbase_context *kctx, u64 start_pfn, size_t nr_pages)
 106 {
 107         struct rb_node *rbnode;
 108         struct kbase_va_region *reg;
 109         u64 end_pfn = start_pfn + nr_pages;
 110
 111         rbnode = kctx->reg_rbtree.rb_node;
 112         while (rbnode) {
 113                 u64 tmp_start_pfn, tmp_end_pfn;
 114                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 115                 tmp_start_pfn = reg->start_pfn;
 116                 tmp_end_pfn = reg->start_pfn + reg->nr_pages;
 117
 118                 /* If start is lower than this, go left. */
 119                 if (start_pfn < tmp_start_pfn)
 120                         rbnode = rbnode->rb_left;
 121                 /* If end is higher than this, then go right. */
 122                 else if (end_pfn > tmp_end_pfn)
 123                         rbnode = rbnode->rb_right;
 124                 else    /* Enclosing */
 125                         return reg;
 126         }
 127
 128         return NULL;
 129 }
 130
 131 /* Find region enclosing given address. */
 132 kbase_va_region *kbase_region_tracker_find_region_enclosing_address(kbase_context *kctx, mali_addr64 gpu_addr)
 133 {
 134         struct rb_node *rbnode;
 135         struct kbase_va_region *reg;
 136         u64 gpu_pfn = gpu_addr >> PAGE_SHIFT;
 137
 138         KBASE_DEBUG_ASSERT(NULL != kctx);
 139
 140         rbnode = kctx->reg_rbtree.rb_node;
 141         while (rbnode) {
 142                 u64 tmp_start_pfn, tmp_end_pfn;
 143                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 144                 tmp_start_pfn = reg->start_pfn;
 145                 tmp_end_pfn = reg->start_pfn + reg->nr_pages;
 146
 147                 /* If start is lower than this, go left. */
 148                 if (gpu_pfn < tmp_start_pfn)
 149                         rbnode = rbnode->rb_left;
 150                 /* If end is higher than this, then go right. */
 151                 else if (gpu_pfn >= tmp_end_pfn)
 152                         rbnode = rbnode->rb_right;
 153                 else    /* Enclosing */
 154                         return reg;
 155         }
 156
 157         return NULL;
 158 }
 159
 160 KBASE_EXPORT_TEST_API(kbase_region_tracker_find_region_enclosing_address)
 161
 162 /* Find region with given base address */
 163 kbase_va_region *kbase_region_tracker_find_region_base_address(kbase_context *kctx, mali_addr64 gpu_addr)
 164 {
 165         u64 gpu_pfn = gpu_addr >> PAGE_SHIFT;
 166         struct rb_node *rbnode;
 167         struct kbase_va_region *reg;
 168
 169         KBASE_DEBUG_ASSERT(NULL != kctx);
 170
 171         rbnode = kctx->reg_rbtree.rb_node;
 172         while (rbnode) {
 173                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 174                 if (reg->start_pfn > gpu_pfn)
 175                         rbnode = rbnode->rb_left;
 176                 else if (reg->start_pfn < gpu_pfn)
 177                         rbnode = rbnode->rb_right;
 178                 else if (gpu_pfn == reg->start_pfn)
 179                         return reg;
 180                 else
 181                         rbnode = NULL;
 182         }
 183
 184         return NULL;
 185 }
 186
 187 KBASE_EXPORT_TEST_API(kbase_region_tracker_find_region_base_address)
 188
 189 /* Find region meeting given requirements */
 190 static struct kbase_va_region *kbase_region_tracker_find_region_meeting_reqs(kbase_context *kctx, struct kbase_va_region *reg_reqs, size_t nr_pages, size_t align)
 191 {
 192         struct rb_node *rbnode;
 193         struct kbase_va_region *reg;
 194
 195         /* Note that this search is a linear search, as we do not have a target
 196            address in mind, so does not benefit from the rbtree search */
 197         rbnode = rb_first(&(kctx->reg_rbtree));
 198         while (rbnode) {
 199                 reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 200                 if ((reg->nr_pages >= nr_pages) && (reg->flags & KBASE_REG_FREE) && kbase_region_tracker_match_zone(reg, reg_reqs)) {
 201
 202                         /* Check alignment */
 203                         u64 start_pfn = (reg->start_pfn + align - 1) & ~(align - 1);
 204                         if ((start_pfn >= reg->start_pfn) && (start_pfn <= (reg->start_pfn + reg->nr_pages - 1)) && ((start_pfn + nr_pages - 1) <= (reg->start_pfn + reg->nr_pages - 1)))
 205                                 return reg;
 206                 }
 207                 rbnode = rb_next(rbnode);
 208         }
 209
 210         return NULL;
 211 }
 212
 213 /**
 214  * @brief Remove a region object from the global list.
 215  *
 216  * The region reg is removed, possibly by merging with other free and
 217  * compatible adjacent regions.  It must be called with the context
 218  * region lock held. The associated memory is not released (see
 219  * kbase_free_alloced_region). Internal use only.
 220  */
 221 STATIC mali_error kbase_remove_va_region(kbase_context *kctx, struct kbase_va_region *reg)
 222 {
 223         struct rb_node *rbprev;
 224         struct kbase_va_region *prev = NULL;
 225         struct rb_node *rbnext;
 226         struct kbase_va_region *next = NULL;
 227
 228         int merged_front = 0;
 229         int merged_back = 0;
 230         mali_error err = MALI_ERROR_NONE;
 231
 232         /* Try to merge with the previous block first */
 233         rbprev = rb_prev(&(reg->rblink));
 234         if (rbprev) {
 235                 prev = rb_entry(rbprev, struct kbase_va_region, rblink);
 236                 if ((prev->flags & KBASE_REG_FREE) && kbase_region_tracker_match_zone(prev, reg)) {
 237                         /* We're compatible with the previous VMA, merge with it */
 238                         prev->nr_pages += reg->nr_pages;
 239                         rb_erase(&(reg->rblink), &kctx->reg_rbtree);
 240                         reg = prev;
 241                         merged_front = 1;
 242                 }
 243         }
 244
 245         /* Try to merge with the next block second */
 246         /* Note we do the lookup here as the tree may have been rebalanced. */
 247         rbnext = rb_next(&(reg->rblink));
 248         if (rbnext) {
 249                 /* We're compatible with the next VMA, merge with it */
 250                 next = rb_entry(rbnext, struct kbase_va_region, rblink);
 251                 if ((next->flags & KBASE_REG_FREE) && kbase_region_tracker_match_zone(next, reg)) {
 252                         next->start_pfn = reg->start_pfn;
 253                         next->nr_pages += reg->nr_pages;
 254                         rb_erase(&(reg->rblink), &kctx->reg_rbtree);
 255                         merged_back = 1;
 256                         if (merged_front) {
 257                                 /* We already merged with prev, free it */
 258                                 kbase_free_alloced_region(reg);
 259                         }
 260                 }
 261         }
 262
 263         /* If we failed to merge then we need to add a new block */
 264         if (!(merged_front || merged_back)) {
 265                 /*
 266                  * We didn't merge anything. Add a new free
 267                  * placeholder and remove the original one.
 268                  */
 269                 struct kbase_va_region *free_reg;
 270
 271                 free_reg = kbase_alloc_free_region(kctx, reg->start_pfn, reg->nr_pages, reg->flags & KBASE_REG_ZONE_MASK);
 272                 if (!free_reg) {
 273                         err = MALI_ERROR_OUT_OF_MEMORY;
 274                         goto out;
 275                 }
 276
 277                 rb_replace_node(&(reg->rblink), &(free_reg->rblink), &(kctx->reg_rbtree));
 278         }
 279
 280  out:
 281         return err;
 282 }
 283
 284 KBASE_EXPORT_TEST_API(kbase_remove_va_region)
 285
 286 /**
 287  * @brief Insert a VA region to the list, replacing the current at_reg.
 288  */
 289 static mali_error kbase_insert_va_region_nolock(kbase_context *kctx, struct kbase_va_region *new_reg, struct kbase_va_region *at_reg, u64 start_pfn, size_t nr_pages)
 290 {
 291         mali_error err = MALI_ERROR_NONE;
 292
 293         /* Must be a free region */
 294         KBASE_DEBUG_ASSERT((at_reg->flags & KBASE_REG_FREE) != 0);
 295         /* start_pfn should be contained within at_reg */
 296         KBASE_DEBUG_ASSERT((start_pfn >= at_reg->start_pfn) && (start_pfn < at_reg->start_pfn + at_reg->nr_pages));
 297         /* at least nr_pages from start_pfn should be contained within at_reg */
 298         KBASE_DEBUG_ASSERT(start_pfn + nr_pages <= at_reg->start_pfn + at_reg->nr_pages);
 299
 300         new_reg->start_pfn = start_pfn;
 301         new_reg->nr_pages = nr_pages;
 302
 303         /* Regions are a whole use, so swap and delete old one. */
 304         if (at_reg->start_pfn == start_pfn && at_reg->nr_pages == nr_pages) {
 305                 rb_replace_node(&(at_reg->rblink), &(new_reg->rblink), &(kctx->reg_rbtree));
 306                 kbase_free_alloced_region(at_reg);
 307         }
 308         /* New region replaces the start of the old one, so insert before. */
 309         else if (at_reg->start_pfn == start_pfn) {
 310                 at_reg->start_pfn += nr_pages;
 311                 KBASE_DEBUG_ASSERT(at_reg->nr_pages >= nr_pages);
 312                 at_reg->nr_pages -= nr_pages;
 313
 314                 kbase_region_tracker_insert(kctx, new_reg);
 315         }
 316         /* New region replaces the end of the old one, so insert after. */
 317         else if ((at_reg->start_pfn + at_reg->nr_pages) == (start_pfn + nr_pages)) {
 318                 at_reg->nr_pages -= nr_pages;
 319
 320                 kbase_region_tracker_insert(kctx, new_reg);
 321         }
 322         /* New region splits the old one, so insert and create new */
 323         else {
 324                 struct kbase_va_region *new_front_reg = kbase_alloc_free_region(kctx, at_reg->start_pfn, start_pfn - at_reg->start_pfn, at_reg->flags & KBASE_REG_ZONE_MASK);
 325                 if (new_front_reg) {
 326                         at_reg->nr_pages -= nr_pages + new_front_reg->nr_pages;
 327                         at_reg->start_pfn = start_pfn + nr_pages;
 328
 329                         kbase_region_tracker_insert(kctx, new_front_reg);
 330                         kbase_region_tracker_insert(kctx, new_reg);
 331                 } else {
 332                         err = MALI_ERROR_OUT_OF_MEMORY;
 333                 }
 334         }
 335
 336         return err;
 337 }
 338
 339 /**
 340  * @brief Add a VA region to the list.
 341  */
 342 mali_error kbase_add_va_region(kbase_context *kctx, struct kbase_va_region *reg, mali_addr64 addr, size_t nr_pages, size_t align)
 343 {
 344         struct kbase_va_region *tmp;
 345         u64 gpu_pfn = addr >> PAGE_SHIFT;
 346         mali_error err = MALI_ERROR_NONE;
 347
 348         KBASE_DEBUG_ASSERT(NULL != kctx);
 349         KBASE_DEBUG_ASSERT(NULL != reg);
 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                 KBASE_DEBUG_ASSERT(!(gpu_pfn & (align - 1)));
 361
 362                 tmp = kbase_region_tracker_find_region_enclosing_range_free(kctx, gpu_pfn, nr_pages);
 363                 if (!tmp) {
 364                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Enclosing region not found: 0x%08llx gpu_pfn, %zu nr_pages", gpu_pfn, nr_pages);
 365                         err = MALI_ERROR_OUT_OF_GPU_MEMORY;
 366                         goto exit;
 367                 }
 368
 369                 if ((!kbase_region_tracker_match_zone(tmp, reg)) || (!(tmp->flags & KBASE_REG_FREE))) {
 370                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Zone mismatch: %lu != %lu", tmp->flags & KBASE_REG_ZONE_MASK, reg->flags & KBASE_REG_ZONE_MASK);
 371                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "!(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);
 372                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "in function %s (%p, %p, 0x%llx, 0x%zx, 0x%zx)\n", __func__, kctx, reg, addr, nr_pages, align);
 373                         err = MALI_ERROR_OUT_OF_GPU_MEMORY;
 374                         goto exit;
 375                 }
 376
 377                 err = kbase_insert_va_region_nolock(kctx, reg, tmp, gpu_pfn, nr_pages);
 378                 if (err) {
 379                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Failed to insert va region");
 380                         err = MALI_ERROR_OUT_OF_GPU_MEMORY;
 381                         goto exit;
 382                 }
 383
 384                 goto exit;
 385         }
 386
 387         /* Path 2: Map any free address which meets the requirements.  */
 388         {
 389                 u64 start_pfn;
 390                 tmp = kbase_region_tracker_find_region_meeting_reqs(kctx, reg, nr_pages, align);
 391                 if (!tmp) {
 392                         err = MALI_ERROR_OUT_OF_GPU_MEMORY;
 393                         goto exit;
 394                 }
 395                 start_pfn = (tmp->start_pfn + align - 1) & ~(align - 1);
 396                 err = kbase_insert_va_region_nolock(kctx, reg, tmp, start_pfn, nr_pages);
 397         }
 398
 399  exit:
 400         return err;
 401 }
 402
 403 KBASE_EXPORT_TEST_API(kbase_add_va_region)
 404
 405 /**
 406  * @brief Initialize the internal region tracker data structure.
 407  */
 408 static void kbase_region_tracker_ds_init(kbase_context *kctx, struct kbase_va_region *same_va_reg, struct kbase_va_region *exec_reg, struct kbase_va_region *custom_va_reg)
 409 {
 410         kctx->reg_rbtree = RB_ROOT;
 411         kbase_region_tracker_insert(kctx, same_va_reg);
 412
 413         /* exec and custom_va_reg doesn't always exist */
 414         if (exec_reg && custom_va_reg) {
 415                 kbase_region_tracker_insert(kctx, exec_reg);
 416                 kbase_region_tracker_insert(kctx, custom_va_reg);
 417         }
 418 }
 419
 420 void kbase_region_tracker_term(kbase_context *kctx)
 421 {
 422         struct rb_node *rbnode;
 423         struct kbase_va_region *reg;
 424         do {
 425                 rbnode = rb_first(&(kctx->reg_rbtree));
 426                 if (rbnode) {
 427                         rb_erase(rbnode, &(kctx->reg_rbtree));
 428                         reg = rb_entry(rbnode, struct kbase_va_region, rblink);
 429                         kbase_free_alloced_region(reg);
 430                 }
 431         } while (rbnode);
 432 }
 433
 434 /**
 435  * Initialize the region tracker data structure.
 436  */
 437 mali_error kbase_region_tracker_init(kbase_context *kctx)
 438 {
 439         struct kbase_va_region *same_va_reg;
 440         struct kbase_va_region *exec_reg = NULL;
 441         struct kbase_va_region *custom_va_reg = NULL;
 442         size_t same_va_bits = sizeof(void*) * BITS_PER_BYTE;
 443         u64 custom_va_size = KBASE_REG_ZONE_CUSTOM_VA_SIZE;
 444         u64 gpu_va_limit = (1ULL << kctx->kbdev->gpu_props.mmu.va_bits) >> PAGE_SHIFT;
 445
 446 #ifdef CONFIG_64BIT
 447         if (is_compat_task())
 448                 same_va_bits = 32;
 449 #endif
 450
 451         if (kctx->kbdev->gpu_props.mmu.va_bits < same_va_bits)
 452                 return MALI_ERROR_FUNCTION_FAILED;
 453
 454         /* all have SAME_VA */
 455         same_va_reg = kbase_alloc_free_region(kctx, 1, (1ULL << (same_va_bits - PAGE_SHIFT)) - 2, KBASE_REG_ZONE_SAME_VA);
 456         if (!same_va_reg)
 457                 return MALI_ERROR_OUT_OF_MEMORY;
 458
 459 #ifdef CONFIG_64BIT
 460         /* only 32-bit clients have the other two zones */
 461         if (is_compat_task()) {
 462 #endif
 463                 if (gpu_va_limit <= KBASE_REG_ZONE_CUSTOM_VA_BASE) {
 464                         kbase_free_alloced_region(same_va_reg);
 465                         return MALI_ERROR_FUNCTION_FAILED;
 466                 }
 467                 /* If the current size of TMEM is out of range of the
 468                  * virtual address space addressable by the MMU then
 469                  * we should shrink it to fit
 470                  */
 471                 if( (KBASE_REG_ZONE_CUSTOM_VA_BASE + KBASE_REG_ZONE_CUSTOM_VA_SIZE) >= gpu_va_limit )
 472                         custom_va_size = gpu_va_limit - KBASE_REG_ZONE_CUSTOM_VA_BASE;
 473
 474                 exec_reg = kbase_alloc_free_region(kctx, KBASE_REG_ZONE_EXEC_BASE, KBASE_REG_ZONE_EXEC_SIZE, KBASE_REG_ZONE_EXEC);
 475                 if (!exec_reg) {
 476                         kbase_free_alloced_region(same_va_reg);
 477                         return MALI_ERROR_OUT_OF_MEMORY;
 478                 }
 479
 480                 custom_va_reg = kbase_alloc_free_region(kctx, KBASE_REG_ZONE_CUSTOM_VA_BASE, custom_va_size, KBASE_REG_ZONE_CUSTOM_VA);
 481                 if (!custom_va_reg) {
 482                         kbase_free_alloced_region(same_va_reg);
 483                         kbase_free_alloced_region(exec_reg);
 484                         return MALI_ERROR_OUT_OF_MEMORY;
 485                 }
 486 #ifdef CONFIG_64BIT
 487         }
 488 #endif
 489
 490         kbase_region_tracker_ds_init(kctx, same_va_reg, exec_reg, custom_va_reg);
 491
 492         return MALI_ERROR_NONE;
 493 }
 494
 495 mali_error kbase_mem_init(struct kbase_device *kbdev)
 496 {
 497         kbasep_mem_device *memdev;
 498         size_t max_shared_memory;
 499         KBASE_DEBUG_ASSERT(kbdev);
 500
 501         memdev = &kbdev->memdev;
 502
 503         max_shared_memory = (size_t)kbasep_get_config_value(kbdev, kbdev->config_attributes, KBASE_CONFIG_ATTR_MEMORY_OS_SHARED_MAX);
 504
 505         if (MALI_ERROR_NONE != kbase_mem_usage_init(&memdev->usage, max_shared_memory >> PAGE_SHIFT)) {
 506                 return MALI_ERROR_FUNCTION_FAILED;
 507         }
 508
 509         /* nothing to do, zero-inited when kbase_device was created */
 510         return MALI_ERROR_NONE;
 511 }
 512
 513 void kbase_mem_halt(kbase_device *kbdev)
 514 {
 515         CSTD_UNUSED(kbdev);
 516 }
 517
 518 void kbase_mem_term(kbase_device *kbdev)
 519 {
 520         kbasep_mem_device *memdev;
 521         KBASE_DEBUG_ASSERT(kbdev);
 522
 523         memdev = &kbdev->memdev;
 524
 525         kbase_mem_usage_term(&memdev->usage);
 526 }
 527
 528 KBASE_EXPORT_TEST_API(kbase_mem_term)
 529
 530 mali_error kbase_mem_usage_init(struct kbasep_mem_usage *usage, size_t max_pages)
 531 {
 532         KBASE_DEBUG_ASSERT(usage);
 533
 534         atomic_set(&usage->cur_pages, 0);
 535         /* query the max page count */
 536         usage->max_pages = max_pages;
 537
 538         return MALI_ERROR_NONE;
 539 }
 540
 541 void kbase_mem_usage_term(kbasep_mem_usage *usage)
 542 {
 543         KBASE_DEBUG_ASSERT(usage);
 544         /* No memory should be in use now */
 545         if (0 != atomic_read(&usage->cur_pages)) {
 546                 printk(KERN_ERR "Pages in use! %d\n", atomic_read(&usage->cur_pages));
 547         }
 548         /* So any new alloc requests will fail */
 549         usage->max_pages = 0;
 550         /* So we printk on double term */
 551         atomic_set(&usage->cur_pages, INT_MAX);
 552 }
 553
 554 mali_error kbase_mem_usage_request_pages(kbasep_mem_usage *usage, size_t nr_pages)
 555 {
 556         int cur_pages;
 557         int old_cur_pages;
 558
 559         KBASE_DEBUG_ASSERT(usage);
 560         KBASE_DEBUG_ASSERT(nr_pages);   /* 0 pages would be an error in the calling code */
 561
 562         /*
 563          * Fetch the initial cur_pages value
 564          * each loop iteration below fetches
 565          * it as part of the store attempt
 566          */
 567         cur_pages = atomic_read(&usage->cur_pages);
 568
 569         /* this check allows the simple if test in the loop below */
 570         if (usage->max_pages < nr_pages)
 571                 goto usage_cap_exceeded;
 572
 573         do {
 574                 int new_cur_pages;
 575                 /* enough pages to fullfill the request? */
 576                 if (usage->max_pages - nr_pages < cur_pages) {
 577  usage_cap_exceeded:
 578                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Memory usage cap has been reached:\n" "\t%lu pages currently used\n" "\t%lu pages usage cap\n" "\t%lu new pages requested\n" "\twould result in %lu pages over the cap\n", (unsigned long)cur_pages, (unsigned long)usage->max_pages, (unsigned long)nr_pages, (unsigned long)(cur_pages + nr_pages - usage->max_pages));
 579                         return MALI_ERROR_OUT_OF_MEMORY;
 580                 }
 581
 582                 /* try to atomically commit the new count */
 583                 old_cur_pages = cur_pages;
 584                 new_cur_pages = cur_pages + nr_pages;
 585                 cur_pages = atomic_cmpxchg(&usage->cur_pages, old_cur_pages,
 586                                             new_cur_pages);
 587                 /* cur_pages will be like old_cur_pages if there was no race */
 588         } while (cur_pages != old_cur_pages);
 589
 590 #ifdef CONFIG_MALI_GATOR_SUPPORT
 591         kbase_trace_mali_total_alloc_pages_change((long long int)cur_pages);
 592 #endif                          /* CONFIG_MALI_GATOR_SUPPORT */
 593
 594         return MALI_ERROR_NONE;
 595 }
 596
 597 KBASE_EXPORT_TEST_API(kbase_mem_usage_request_pages)
 598
 599 void kbase_mem_usage_release_pages(kbasep_mem_usage *usage, size_t nr_pages)
 600 {
 601         int new_val;
 602         KBASE_DEBUG_ASSERT(usage);
 603         KBASE_DEBUG_ASSERT(nr_pages <= atomic_read(&usage->cur_pages));
 604
 605         new_val = atomic_sub_return(nr_pages, &usage->cur_pages);
 606 #ifdef CONFIG_MALI_GATOR_SUPPORT
 607         kbase_trace_mali_total_alloc_pages_change((long long int)new_val);
 608 #endif                          /* CONFIG_MALI_GATOR_SUPPORT */
 609 }
 610
 611 KBASE_EXPORT_TEST_API(kbase_mem_usage_release_pages)
 612
 613 /**
 614  * @brief Wait for GPU write flush - only in use for BASE_HW_ISSUE_6367
 615  *
 616  * Wait 1000 GPU clock cycles. This delay is known to give the GPU time to flush its write buffer.
 617  * @note If GPU resets occur then the counters are reset to zero, the delay may not be as expected.
 618  */
 619 #ifndef CONFIG_MALI_NO_MALI
 620 void kbase_wait_write_flush(kbase_context *kctx)
 621 {
 622         u32 base_count = 0;
 623         /* A suspend won't happen here, because we're in a syscall from a userspace thread */
 624         kbase_pm_context_active(kctx->kbdev);
 625         kbase_pm_request_gpu_cycle_counter(kctx->kbdev);
 626         while (MALI_TRUE) {
 627                 u32 new_count;
 628                 new_count = kbase_reg_read(kctx->kbdev, GPU_CONTROL_REG(CYCLE_COUNT_LO), NULL);
 629                 /* First time around, just store the count. */
 630                 if (base_count == 0) {
 631                         base_count = new_count;
 632                         continue;
 633                 }
 634
 635                 /* No need to handle wrapping, unsigned maths works for this. */
 636                 if ((new_count - base_count) > 1000)
 637                         break;
 638         }
 639         kbase_pm_release_gpu_cycle_counter(kctx->kbdev);
 640         kbase_pm_context_idle(kctx->kbdev);
 641 }
 642 #endif                          /* CONFIG_MALI_NO_MALI */
 643
 644
 645
 646 /**
 647  * @brief Allocate a free region object.
 648  *
 649  * The allocated object is not part of any list yet, and is flagged as
 650  * KBASE_REG_FREE. No mapping is allocated yet.
 651  *
 652  * zone is KBASE_REG_ZONE_CUSTOM_VA, KBASE_REG_ZONE_SAME_VA, or KBASE_REG_ZONE_EXEC
 653  *
 654  */
 655 struct kbase_va_region *kbase_alloc_free_region(kbase_context *kctx, u64 start_pfn, size_t nr_pages, int zone)
 656 {
 657         struct kbase_va_region *new_reg;
 658
 659         KBASE_DEBUG_ASSERT(kctx != NULL);
 660
 661         /* zone argument should only contain zone related region flags */
 662         KBASE_DEBUG_ASSERT((zone & ~KBASE_REG_ZONE_MASK) == 0);
 663         KBASE_DEBUG_ASSERT(nr_pages > 0);
 664         KBASE_DEBUG_ASSERT(start_pfn + nr_pages <= (UINT64_MAX / PAGE_SIZE));   /* 64-bit address range is the max */
 665
 666         new_reg = kzalloc(sizeof(*new_reg), GFP_KERNEL);
 667
 668         if (!new_reg) {
 669                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "kzalloc failed");
 670                 return NULL;
 671         }
 672
 673         new_reg->alloc = NULL; /* no alloc bound yet */
 674         new_reg->kctx = kctx;
 675         new_reg->flags = zone | KBASE_REG_FREE;
 676
 677         new_reg->flags |= KBASE_REG_GROWABLE;
 678
 679         new_reg->start_pfn = start_pfn;
 680         new_reg->nr_pages = nr_pages;
 681
 682         return new_reg;
 683 }
 684
 685 KBASE_EXPORT_TEST_API(kbase_alloc_free_region)
 686
 687 /**
 688  * @brief Free a region object.
 689  *
 690  * The described region must be freed of any mapping.
 691  *
 692  * If the region is not flagged as KBASE_REG_FREE, the region's
 693  * alloc object will be released.
 694  * It is a bug if no alloc object exists for non-free regions.
 695  *
 696  */
 697 void kbase_free_alloced_region(struct kbase_va_region *reg)
 698 {
 699         KBASE_DEBUG_ASSERT(NULL != reg);
 700         if (!(reg->flags & KBASE_REG_FREE)) {
 701                 KBASE_DEBUG_ASSERT(reg->alloc);
 702                 kbase_mem_phy_alloc_put(reg->alloc);
 703                 KBASE_DEBUG_CODE(
 704                                         /* To detect use-after-free in debug builds */
 705                                         reg->flags |= KBASE_REG_FREE);
 706         }
 707         kfree(reg);
 708 }
 709
 710 KBASE_EXPORT_TEST_API(kbase_free_alloced_region)
 711
 712 void kbase_mmu_update(kbase_context *kctx)
 713 {
 714         /* Use GPU implementation-defined caching policy. */
 715         u32 memattr = ASn_MEMATTR_IMPL_DEF_CACHE_POLICY;
 716         u32 pgd_high;
 717
 718         KBASE_DEBUG_ASSERT(NULL != kctx);
 719         /* ASSERT that the context has a valid as_nr, which is only the case
 720          * when it's scheduled in.
 721          *
 722          * as_nr won't change because the caller has the runpool_irq lock */
 723         KBASE_DEBUG_ASSERT(kctx->as_nr != KBASEP_AS_NR_INVALID);
 724
 725         pgd_high = sizeof(kctx->pgd) > 4 ? (kctx->pgd >> 32) : 0;
 726
 727         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_TRANSTAB_LO), (kctx->pgd & ASn_TRANSTAB_ADDR_SPACE_MASK) | ASn_TRANSTAB_READ_INNER | ASn_TRANSTAB_ADRMODE_TABLE, kctx);
 728
 729         /* Need to use a conditional expression to avoid "right shift count >= width of type"
 730          * error when using an if statement - although the size_of condition is evaluated at compile
 731          * time the unused branch is not removed until after it is type-checked and the error
 732          * produced.
 733          */
 734         pgd_high = sizeof(kctx->pgd) > 4 ? (kctx->pgd >> 32) : 0;
 735
 736         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_TRANSTAB_HI), pgd_high, kctx);
 737
 738         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_MEMATTR_LO), memattr, kctx);
 739         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_MEMATTR_HI), memattr, kctx);
 740         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_COMMAND), ASn_COMMAND_UPDATE, kctx);
 741 }
 742
 743 KBASE_EXPORT_TEST_API(kbase_mmu_update)
 744
 745 void kbase_mmu_disable(kbase_context *kctx)
 746 {
 747         KBASE_DEBUG_ASSERT(NULL != kctx);
 748         /* ASSERT that the context has a valid as_nr, which is only the case
 749          * when it's scheduled in.
 750          *
 751          * as_nr won't change because the caller has the runpool_irq lock */
 752         KBASE_DEBUG_ASSERT(kctx->as_nr != KBASEP_AS_NR_INVALID);
 753
 754         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_TRANSTAB_LO), 0, kctx);
 755         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_TRANSTAB_HI), 0, kctx);
 756         kbase_reg_write(kctx->kbdev, MMU_AS_REG(kctx->as_nr, ASn_COMMAND), ASn_COMMAND_UPDATE, kctx);
 757 }
 758
 759 KBASE_EXPORT_TEST_API(kbase_mmu_disable)
 760
 761 mali_error kbase_gpu_mmap(kbase_context *kctx, struct kbase_va_region *reg, mali_addr64 addr, size_t nr_pages, size_t align)
 762 {
 763         mali_error err;
 764         KBASE_DEBUG_ASSERT(NULL != kctx);
 765         KBASE_DEBUG_ASSERT(NULL != reg);
 766
 767         err = kbase_add_va_region(kctx, reg, addr, nr_pages, align);
 768         if (MALI_ERROR_NONE != err)
 769                 return err;
 770
 771         err = kbase_mmu_insert_pages(kctx, reg->start_pfn, kbase_get_phy_pages(reg), kbase_reg_current_backed_size(reg) , reg->flags & ((1 << KBASE_REG_FLAGS_NR_BITS) - 1));
 772         if (MALI_ERROR_NONE != err)
 773                 kbase_remove_va_region(kctx, reg);
 774
 775         return err;
 776 }
 777
 778 KBASE_EXPORT_TEST_API(kbase_gpu_mmap)
 779
 780 mali_error kbase_gpu_munmap(kbase_context *kctx, struct kbase_va_region *reg)
 781 {
 782         mali_error err;
 783
 784         if (reg->start_pfn == 0)
 785                 return MALI_ERROR_NONE;
 786
 787         err = kbase_mmu_teardown_pages(kctx, reg->start_pfn, kbase_reg_current_backed_size(reg));
 788         if (MALI_ERROR_NONE != err)
 789                 return err;
 790
 791         err = kbase_remove_va_region(kctx, reg);
 792         return err;
 793 }
 794
 795 STATIC struct kbase_cpu_mapping *kbasep_find_enclosing_cpu_mapping_of_region(const struct kbase_va_region *reg, unsigned long uaddr, size_t size)
 796 {
 797         struct kbase_cpu_mapping *map;
 798         struct list_head *pos;
 799
 800         KBASE_DEBUG_ASSERT(NULL != reg);
 801         KBASE_DEBUG_ASSERT(reg->alloc);
 802
 803         if ((uintptr_t) uaddr + size < (uintptr_t) uaddr) /* overflow check */
 804                 return NULL;
 805
 806         list_for_each(pos, &reg->alloc->mappings) {
 807                 map = list_entry(pos, kbase_cpu_mapping, mappings_list);
 808                 if (map->vma->vm_start <= uaddr && map->vma->vm_end >= uaddr + size)
 809                         return map;
 810         }
 811
 812         return NULL;
 813 }
 814
 815 KBASE_EXPORT_TEST_API(kbasep_find_enclosing_cpu_mapping_of_region)
 816
 817 struct kbase_cpu_mapping *kbasep_find_enclosing_cpu_mapping(kbase_context *kctx, mali_addr64 gpu_addr, unsigned long uaddr, size_t size)
 818 {
 819         struct kbase_cpu_mapping *map = NULL;
 820         const struct kbase_va_region *reg;
 821
 822         KBASE_DEBUG_ASSERT(kctx != NULL);
 823
 824         kbase_gpu_vm_lock(kctx);
 825
 826         reg = kbase_region_tracker_find_region_enclosing_address(kctx, gpu_addr);
 827         if (NULL != reg)
 828                 map = kbasep_find_enclosing_cpu_mapping_of_region(reg, uaddr, size);
 829
 830         kbase_gpu_vm_unlock(kctx);
 831
 832         return map;
 833 }
 834
 835 KBASE_EXPORT_TEST_API(kbasep_find_enclosing_cpu_mapping)
 836
 837 static mali_error kbase_do_syncset(kbase_context *kctx, struct base_syncset *set, kbase_sync_kmem_fn sync_fn)
 838 {
 839         mali_error err = MALI_ERROR_NONE;
 840         struct basep_syncset *sset = &set->basep_sset;
 841         struct kbase_va_region *reg;
 842         struct kbase_cpu_mapping *map;
 843         unsigned long start;
 844         size_t size;
 845         phys_addr_t base_phy_addr = 0;
 846         phys_addr_t *pa;
 847         u64 page_off, page_count;
 848         u64 i;
 849         unsigned int offset_within_page;
 850         void *base_virt_addr = 0;
 851         size_t area_size = 0;
 852
 853         kbase_os_mem_map_lock(kctx);
 854
 855         kbase_gpu_vm_lock(kctx);
 856
 857         /* find the region where the virtual address is contained */
 858         reg = kbase_region_tracker_find_region_enclosing_address(kctx, sset->mem_handle);
 859         if (!reg) {
 860                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Can't find region at VA 0x%016llX", sset->mem_handle);
 861                 err = MALI_ERROR_FUNCTION_FAILED;
 862                 goto out_unlock;
 863         }
 864
 865         if (!(reg->flags & KBASE_REG_CPU_CACHED))
 866                 goto out_unlock;
 867
 868         start = (uintptr_t)sset->user_addr;
 869         size = (size_t)sset->size;
 870
 871         map = kbasep_find_enclosing_cpu_mapping_of_region(reg, start, size);
 872         if (!map) {
 873                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Can't find CPU mapping 0x%016lX for VA 0x%016llX", start, sset->mem_handle);
 874                 err = MALI_ERROR_FUNCTION_FAILED;
 875                 goto out_unlock;
 876         }
 877
 878         offset_within_page = start & (PAGE_SIZE - 1);
 879         page_off = map->page_off + ((start - map->vma->vm_start) >> PAGE_SHIFT);
 880         page_count = ((size + offset_within_page + (PAGE_SIZE - 1)) & PAGE_MASK) >> PAGE_SHIFT;
 881         pa = kbase_get_phy_pages(reg);
 882
 883         for (i = 0; i < page_count; i++) {
 884                 u32 offset = start & (PAGE_SIZE - 1);
 885                 phys_addr_t paddr = pa[page_off + i] + offset;
 886                 size_t sz = MIN(((size_t) PAGE_SIZE - offset), size);
 887
 888                 if (paddr == base_phy_addr + area_size && start == ((uintptr_t) base_virt_addr + area_size)) {
 889                         area_size += sz;
 890                 } else if (area_size > 0) {
 891                         sync_fn(base_phy_addr, base_virt_addr, area_size);
 892                         area_size = 0;
 893                 }
 894
 895                 if (area_size == 0) {
 896                         base_phy_addr = paddr;
 897                         base_virt_addr = (void *)(uintptr_t)start;
 898                         area_size = sz;
 899                 }
 900
 901                 start += sz;
 902                 size -= sz;
 903         }
 904
 905         if (area_size > 0)
 906                 sync_fn(base_phy_addr, base_virt_addr, area_size);
 907
 908         KBASE_DEBUG_ASSERT(size == 0);
 909
 910  out_unlock:
 911         kbase_gpu_vm_unlock(kctx);
 912         kbase_os_mem_map_unlock(kctx);
 913         return err;
 914 }
 915
 916 mali_error kbase_sync_now(kbase_context *kctx, struct base_syncset *syncset)
 917 {
 918         mali_error err = MALI_ERROR_FUNCTION_FAILED;
 919         struct basep_syncset *sset;
 920
 921         KBASE_DEBUG_ASSERT(NULL != kctx);
 922         KBASE_DEBUG_ASSERT(NULL != syncset);
 923
 924         sset = &syncset->basep_sset;
 925
 926         switch (sset->type) {
 927         case BASE_SYNCSET_OP_MSYNC:
 928                 err = kbase_do_syncset(kctx, syncset, kbase_sync_to_memory);
 929                 break;
 930
 931         case BASE_SYNCSET_OP_CSYNC:
 932                 err = kbase_do_syncset(kctx, syncset, kbase_sync_to_cpu);
 933                 break;
 934
 935         default:
 936                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Unknown msync op %d\n", sset->type);
 937                 break;
 938         }
 939
 940         return err;
 941 }
 942
 943 KBASE_EXPORT_TEST_API(kbase_sync_now)
 944
 945 /* vm lock must be held */
 946 mali_error kbase_mem_free_region(kbase_context *kctx, kbase_va_region *reg)
 947 {
 948         mali_error err;
 949         KBASE_DEBUG_ASSERT(NULL != kctx);
 950         KBASE_DEBUG_ASSERT(NULL != reg);
 951         BUG_ON(!mutex_is_locked(&kctx->reg_lock));
 952         err = kbase_gpu_munmap(kctx, reg);
 953         if (err) {
 954                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Could not unmap from the GPU...\n");
 955                 goto out;
 956         }
 957
 958         if (kbase_hw_has_issue(kctx->kbdev, BASE_HW_ISSUE_6367)) {
 959                 /* Wait for GPU to flush write buffer before freeing physical pages */
 960                 kbase_wait_write_flush(kctx);
 961         }
 962
 963         /* This will also free the physical pages */
 964         kbase_free_alloced_region(reg);
 965
 966  out:
 967         return err;
 968 }
 969
 970 KBASE_EXPORT_TEST_API(kbase_mem_free_region)
 971
 972 /**
 973  * @brief Free the region from the GPU and unregister it.
 974  *
 975  * This function implements the free operation on a memory segment.
 976  * It will loudly fail if called with outstanding mappings.
 977  */
 978 mali_error kbase_mem_free(kbase_context *kctx, mali_addr64 gpu_addr)
 979 {
 980         mali_error err = MALI_ERROR_NONE;
 981         struct kbase_va_region *reg;
 982
 983         KBASE_DEBUG_ASSERT(kctx != NULL);
 984
 985         if (0 == gpu_addr) {
 986                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "gpu_addr 0 is reserved for the ringbuffer and it's an error to try to free it using kbase_mem_free\n");
 987                 return MALI_ERROR_FUNCTION_FAILED;
 988         }
 989         kbase_gpu_vm_lock(kctx);
 990
 991         if (gpu_addr < PAGE_SIZE) {
 992                 /* an OS specific cookie, ask the OS specific code to validate it */
 993                 reg = kbase_lookup_cookie(kctx, gpu_addr);
 994                 if (!reg) {
 995                         err = MALI_ERROR_FUNCTION_FAILED;
 996                         goto out_unlock;
 997                 }
 998
 999                 /* ask to unlink the cookie as we'll free it */
1000                 kbase_unlink_cookie(kctx, gpu_addr, reg);
1001
1002                 kbase_free_alloced_region(reg);
1003         } else {
1004                 /* A real GPU va */
1005
1006                 /* Validate the region */
1007                 reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
1008                 if (!reg) {
1009                         KBASE_DEBUG_ASSERT_MSG(0, "Trying to free nonexistent region\n 0x%llX", gpu_addr);
1010                         err = MALI_ERROR_FUNCTION_FAILED;
1011                         goto out_unlock;
1012                 }
1013
1014                 err = kbase_mem_free_region(kctx, reg);
1015         }
1016
1017  out_unlock:
1018         kbase_gpu_vm_unlock(kctx);
1019         return err;
1020 }
1021
1022 KBASE_EXPORT_TEST_API(kbase_mem_free)
1023
1024 void kbase_update_region_flags(struct kbase_va_region *reg, unsigned long flags)
1025 {
1026         KBASE_DEBUG_ASSERT(NULL != reg);
1027         KBASE_DEBUG_ASSERT((flags & ~((1 << BASE_MEM_FLAGS_NR_BITS) - 1)) == 0);
1028
1029         reg->flags |= kbase_cache_enabled(flags, reg->nr_pages);
1030         /* all memory is now growable */
1031         reg->flags |= KBASE_REG_GROWABLE;
1032
1033         if (flags & BASE_MEM_GROW_ON_GPF)
1034                 reg->flags |= KBASE_REG_PF_GROW;
1035
1036         if (flags & BASE_MEM_PROT_CPU_WR)
1037                 reg->flags |= KBASE_REG_CPU_WR;
1038
1039         if (flags & BASE_MEM_PROT_CPU_RD)
1040                 reg->flags |= KBASE_REG_CPU_RD;
1041
1042         if (flags & BASE_MEM_PROT_GPU_WR)
1043                 reg->flags |= KBASE_REG_GPU_WR;
1044
1045         if (flags & BASE_MEM_PROT_GPU_RD)
1046                 reg->flags |= KBASE_REG_GPU_RD;
1047
1048         if (0 == (flags & BASE_MEM_PROT_GPU_EX))
1049                 reg->flags |= KBASE_REG_GPU_NX;
1050
1051         if (flags & BASE_MEM_COHERENT_LOCAL)
1052                 reg->flags |= KBASE_REG_SHARE_IN;
1053         else if (flags & BASE_MEM_COHERENT_SYSTEM)
1054                 reg->flags |= KBASE_REG_SHARE_BOTH;
1055
1056 }
1057 KBASE_EXPORT_TEST_API(kbase_update_region_flags)
1058
1059 int kbase_alloc_phy_pages_helper(struct kbase_mem_phy_alloc * alloc, size_t nr_pages_requested)
1060 {
1061         KBASE_DEBUG_ASSERT(alloc);
1062         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_NATIVE);
1063         KBASE_DEBUG_ASSERT(alloc->imported.kctx);
1064
1065         if (0 == nr_pages_requested)
1066                 goto done; /*nothing to do*/
1067
1068         if (MALI_ERROR_NONE != kbase_mem_usage_request_pages(&alloc->imported.kctx->usage, nr_pages_requested))
1069                 goto no_kctx_usage;
1070
1071         if (MALI_ERROR_NONE != kbase_mem_usage_request_pages(&alloc->imported.kctx->kbdev->memdev.usage, nr_pages_requested))
1072                 goto no_memdev_usage;
1073
1074         if (MALI_ERROR_NONE != kbase_mem_allocator_alloc(&alloc->imported.kctx->osalloc, nr_pages_requested, alloc->pages + alloc->nents))
1075                 goto no_alloc;
1076
1077         alloc->nents += nr_pages_requested;
1078
1079         kbase_process_page_usage_inc(alloc->imported.kctx, nr_pages_requested);
1080 done:
1081         return 0;
1082
1083 no_alloc:
1084         kbase_mem_usage_release_pages(&alloc->imported.kctx->kbdev->memdev.usage, nr_pages_requested);
1085 no_memdev_usage:
1086         kbase_mem_usage_release_pages(&alloc->imported.kctx->usage, nr_pages_requested);
1087 no_kctx_usage:
1088         return -ENOMEM;
1089 }
1090
1091 int kbase_free_phy_pages_helper(struct kbase_mem_phy_alloc * alloc, size_t nr_pages_to_free)
1092 {
1093         mali_bool syncback;
1094         phys_addr_t *start_free;
1095         KBASE_DEBUG_ASSERT(alloc);
1096         KBASE_DEBUG_ASSERT(alloc->type == KBASE_MEM_TYPE_NATIVE);
1097         KBASE_DEBUG_ASSERT(alloc->imported.kctx);
1098         KBASE_DEBUG_ASSERT(alloc->nents >= nr_pages_to_free);
1099
1100         /* early out if nothing to do */
1101         if (0 == nr_pages_to_free)
1102                 return 0;
1103
1104         start_free = alloc->pages + alloc->nents - nr_pages_to_free;
1105
1106         syncback = alloc->accessed_cached ? MALI_TRUE : MALI_FALSE;
1107
1108         kbase_mem_allocator_free(&alloc->imported.kctx->osalloc,
1109                                   nr_pages_to_free,
1110                                   start_free,
1111                                   syncback);
1112
1113         alloc->nents -= nr_pages_to_free;
1114         kbase_process_page_usage_dec(alloc->imported.kctx, nr_pages_to_free);
1115         kbase_mem_usage_release_pages(&alloc->imported.kctx->usage, nr_pages_to_free);
1116         kbase_mem_usage_release_pages(&alloc->imported.kctx->kbdev->memdev.usage, nr_pages_to_free);
1117
1118         return 0;
1119 }
1120
1121 void kbase_mem_kref_free(struct kref * kref)
1122 {
1123         struct kbase_mem_phy_alloc * alloc;
1124         alloc = container_of(kref, struct kbase_mem_phy_alloc, kref);
1125
1126         switch (alloc->type) {
1127                 case KBASE_MEM_TYPE_NATIVE:
1128                 {
1129                         KBASE_DEBUG_ASSERT(alloc->imported.kctx);
1130                         kbase_free_phy_pages_helper(alloc, alloc->nents);
1131                         break;
1132                 }
1133                 case KBASE_MEM_TYPE_RAW:
1134                         /* raw pages, external cleanup */
1135                         break;
1136  #ifdef CONFIG_UMP
1137                 case KBASE_MEM_TYPE_IMPORTED_UMP:
1138                         ump_dd_release(alloc->imported.ump_handle);
1139                         break;
1140 #endif
1141 #ifdef CONFIG_DMA_SHARED_BUFFER
1142                 case KBASE_MEM_TYPE_IMPORTED_UMM:
1143                         dma_buf_detach(alloc->imported.umm.dma_buf, alloc->imported.umm.dma_attachment);
1144                         dma_buf_put(alloc->imported.umm.dma_buf);
1145                         break;
1146 #endif
1147                 case KBASE_MEM_TYPE_TB:
1148                 {
1149                         void * tb;
1150                         tb = alloc->imported.kctx->jctx.tb;
1151                         kbase_device_trace_buffer_uninstall(alloc->imported.kctx);
1152                         vfree(tb);
1153                         break;
1154                 }
1155                 default:
1156                         WARN(1, "Unexecpted free of type %d\n", alloc->type);
1157                         break;
1158         }
1159         vfree(alloc);
1160 }
1161
1162 KBASE_EXPORT_TEST_API(kbase_mem_kref_free);
1163
1164 int kbase_alloc_phy_pages(struct kbase_va_region *reg, size_t vsize, size_t size)
1165 {
1166         KBASE_DEBUG_ASSERT(NULL != reg);
1167         KBASE_DEBUG_ASSERT(vsize > 0);
1168
1169         /* validate user provided arguments */
1170         if (size > vsize || vsize > reg->nr_pages)
1171                 goto out_term;
1172
1173         /* Prevent vsize*sizeof from wrapping around.
1174          * For instance, if vsize is 2**29+1, we'll allocate 1 byte and the alloc won't fail.
1175          */
1176         if ((size_t) vsize > ((size_t) -1 / sizeof(*reg->alloc->pages)))
1177                 goto out_term;
1178
1179         KBASE_DEBUG_ASSERT(0 != vsize);
1180
1181         if (MALI_ERROR_NONE != kbase_alloc_phy_pages_helper(reg->alloc, size))
1182                 goto out_term;
1183
1184         return 0;
1185
1186  out_term:
1187         return -1;
1188 }
1189
1190 KBASE_EXPORT_TEST_API(kbase_alloc_phy_pages)
1191
1192 mali_bool kbase_check_alloc_flags(unsigned long flags)
1193 {
1194         /* Only known flags should be set. */
1195         if (flags & ~((1 << BASE_MEM_FLAGS_NR_BITS) - 1))
1196                 return MALI_FALSE;
1197
1198         /* At least one flag should be set */
1199         if (flags == 0)
1200                 return MALI_FALSE;
1201
1202         /* Either the GPU or CPU must be reading from the allocated memory */
1203         if ((flags & (BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_GPU_RD)) == 0)
1204                 return MALI_FALSE;
1205
1206         /* Either the GPU or CPU must be writing to the allocated memory */
1207         if ((flags & (BASE_MEM_PROT_CPU_WR | BASE_MEM_PROT_GPU_WR)) == 0)
1208                 return MALI_FALSE;
1209
1210         /* GPU cannot be writing to GPU executable memory and cannot grow the memory on page fault. */
1211         if ((flags & BASE_MEM_PROT_GPU_EX) && (flags & (BASE_MEM_PROT_GPU_WR | BASE_MEM_GROW_ON_GPF)))
1212                 return MALI_FALSE;
1213
1214         /* GPU should have at least read or write access otherwise there is no
1215            reason for allocating. */
1216         if ((flags & (BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR)) == 0)
1217                 return MALI_FALSE;
1218
1219         return MALI_TRUE;
1220 }
1221
1222 /**
1223  * @brief Acquire the per-context region list lock
1224  */
1225 void kbase_gpu_vm_lock(kbase_context *kctx)
1226 {
1227         KBASE_DEBUG_ASSERT(kctx != NULL);
1228         mutex_lock(&kctx->reg_lock);
1229 }
1230
1231 KBASE_EXPORT_TEST_API(kbase_gpu_vm_lock)
1232
1233 /**
1234  * @brief Release the per-context region list lock
1235  */
1236 void kbase_gpu_vm_unlock(kbase_context *kctx)
1237 {
1238         KBASE_DEBUG_ASSERT(kctx != NULL);
1239         mutex_unlock(&kctx->reg_lock);
1240 }
1241
1242 KBASE_EXPORT_TEST_API(kbase_gpu_vm_unlock)