drivers/gpu/arm/t6xx/kbase/src/linux/mali_kbase_mem_linux.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_linux.c
  22  * Base kernel memory APIs, Linux implementation.
  23  */
  24
  25 #include <linux/compat.h>
  26 #include <linux/kernel.h>
  27 #include <linux/bug.h>
  28 #include <linux/mm.h>
  29 #include <linux/fs.h>
  30 #include <linux/version.h>
  31 #include <linux/dma-mapping.h>
  32 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
  33         #include <linux/dma-attrs.h>
  34 #endif
  35 #ifdef CONFIG_DMA_SHARED_BUFFER
  36 #include <linux/dma-buf.h>
  37 #endif                          /* defined(CONFIG_DMA_SHARED_BUFFER) */
  38
  39 #include <kbase/src/common/mali_kbase.h>
  40 #include <kbase/src/linux/mali_kbase_mem_linux.h>
  41
  42 static int kbase_tracking_page_setup(struct kbase_context *kctx, struct vm_area_struct *vma);
  43
  44 struct kbase_va_region *kbase_mem_alloc(kbase_context *kctx, u64 va_pages, u64 commit_pages, u64 extent, u64 *flags, u64 *gpu_va, u16 *va_alignment)
  45 {
  46         int zone;
  47         int gpu_pc_bits;
  48         int cpu_va_bits;
  49         struct kbase_va_region *reg;
  50         KBASE_DEBUG_ASSERT(kctx);
  51         KBASE_DEBUG_ASSERT(flags);
  52         KBASE_DEBUG_ASSERT(gpu_va);
  53         KBASE_DEBUG_ASSERT(va_alignment);
  54
  55         *va_alignment = 0; /* no alignment by default */
  56         *gpu_va = 0; /* return 0 on failure */
  57
  58         gpu_pc_bits = kctx->kbdev->gpu_props.props.core_props.log2_program_counter_size;
  59         cpu_va_bits = BITS_PER_LONG;
  60
  61         if (0 == va_pages) {
  62                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM,
  63                                 "kbase_mem_alloc called with 0 va_pages!");
  64                 goto zero_size;
  65         }
  66
  67 #if defined(CONFIG_64BIT)
  68         if (is_compat_task())
  69                 cpu_va_bits = 32;
  70         else
  71                 /* force SAME_VA if a 64-bit client */
  72                 *flags |= BASE_MEM_SAME_VA;
  73 #endif
  74
  75         if (!kbase_check_alloc_flags(*flags)) {
  76                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM,
  77                                 "kbase_mem_alloc called with bad flags (%llx)",
  78                                 (unsigned long long)*flags);
  79                 goto bad_flags;
  80         }
  81
  82         /* Limit GPU executable allocs to GPU PC size */
  83         if ((*flags & BASE_MEM_PROT_GPU_EX) &&
  84             (va_pages > (1ULL << gpu_pc_bits >> PAGE_SHIFT)))
  85                 goto bad_ex_size;
  86
  87         /* find out which VA zone to use */
  88         if (*flags & BASE_MEM_SAME_VA)
  89                 zone = KBASE_REG_ZONE_SAME_VA;
  90         else if (*flags & BASE_MEM_PROT_GPU_EX)
  91                 zone = KBASE_REG_ZONE_EXEC;
  92         else
  93                 zone = KBASE_REG_ZONE_CUSTOM_VA;
  94
  95         reg = kbase_alloc_free_region(kctx, 0, va_pages, zone);
  96         if (!reg) {
  97                 KBASE_DEBUG_PRINT_ERROR(KBASE_MEM,
  98                                          "Failed to allocate free region");
  99                 goto no_region;
 100         }
 101
 102         if (MALI_ERROR_NONE != kbase_reg_prepare_native(reg, kctx)) {
 103                 KBASE_DEBUG_PRINT_ERROR(KBASE_MEM, "Failed to prepare region");
 104                 goto prepare_failed;
 105         }
 106
 107         kbase_update_region_flags(reg, *flags);
 108
 109         if (*flags & BASE_MEM_GROW_ON_GPF)
 110                 reg->extent = extent;
 111         else
 112                 reg->extent = 0;
 113
 114         if (kbase_alloc_phy_pages(reg, va_pages, commit_pages)) {
 115                 KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Failed to allocate %lld pages (va_pages=%lld)",
 116                                        (unsigned long long)commit_pages, (unsigned long long)va_pages);
 117                 goto no_mem;
 118         }
 119
 120         kbase_gpu_vm_lock(kctx);
 121
 122         /* mmap needed to setup VA? */
 123         if (*flags & BASE_MEM_SAME_VA) {
 124                 /* Bind to a cookie */
 125                 if (!kctx->osctx.cookies) {
 126                         KBASE_DEBUG_PRINT_ERROR(KBASE_MEM, "No cookies available for allocation!");
 127                         goto no_cookie;
 128                 }
 129                 /* return a cookie */
 130                 *gpu_va = __ffs(kctx->osctx.cookies);
 131                 kctx->osctx.cookies &= ~(1UL << *gpu_va);
 132                 reg->flags &= ~KBASE_REG_COOKIE_MASK;
 133                 reg->flags |= KBASE_REG_COOKIE(*gpu_va);
 134                 list_add(&reg->link, &kctx->osctx.reg_pending);
 135
 136                 /* See if we must align memory due to GPU PC bits vs CPU VA */
 137                 if ((*flags & BASE_MEM_PROT_GPU_EX) &&
 138                     (cpu_va_bits > gpu_pc_bits)) {
 139                         *va_alignment = gpu_pc_bits;
 140                         reg->flags |= KBASE_REG_ALIGNED;
 141                 }
 142         } else /* we control the VA */ {
 143                 if (MALI_ERROR_NONE != kbase_gpu_mmap(kctx, reg, 0, va_pages, 1)) {
 144                         KBASE_DEBUG_PRINT_WARN(KBASE_MEM, "Failed to map memory on GPU");
 145                         goto no_mmap;
 146                 }
 147                 /* return real GPU VA */
 148                 *gpu_va = reg->start_pfn << PAGE_SHIFT;
 149         }
 150
 151         kbase_gpu_vm_unlock(kctx);
 152         return reg;
 153
 154 no_mmap:
 155 no_cookie:
 156         kbase_gpu_vm_unlock(kctx);
 157 no_mem:
 158         kbase_mem_phy_alloc_put(reg->alloc);
 159 prepare_failed:
 160         kfree(reg);
 161 no_region:
 162 bad_ex_size:
 163 bad_flags:
 164 zero_size:
 165         return NULL;
 166 }
 167
 168 mali_error kbase_mem_query(kbase_context *kctx, mali_addr64 gpu_addr, int query, u64 * const out)
 169 {
 170         kbase_va_region *reg;
 171         mali_error ret = MALI_ERROR_FUNCTION_FAILED;
 172
 173         KBASE_DEBUG_ASSERT(kctx);
 174         KBASE_DEBUG_ASSERT(out);
 175
 176         kbase_gpu_vm_lock(kctx);
 177
 178         /* Validate the region */
 179         reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
 180         if (!reg || (reg->flags & KBASE_REG_FREE) )
 181                 goto out_unlock;
 182
 183         switch (query) {
 184                 case KBASE_MEM_QUERY_COMMIT_SIZE:
 185                         *out = reg->alloc->nents;
 186                         break;
 187                 case KBASE_MEM_QUERY_VA_SIZE:
 188                         *out = reg->nr_pages;
 189                         break;
 190                 case KBASE_MEM_QUERY_FLAGS:
 191                 {
 192                         *out = 0;
 193                         if( KBASE_REG_GPU_WR & reg->flags )
 194                                 *out |= BASE_MEM_PROT_GPU_WR;
 195                         if( KBASE_REG_GPU_RD & reg->flags )
 196                                 *out |= BASE_MEM_PROT_GPU_RD;
 197                         if( !(KBASE_REG_GPU_NX & reg->flags) )
 198                                 *out |= BASE_MEM_PROT_GPU_EX;
 199                         if( KBASE_REG_SHARE_BOTH & reg->flags )
 200                                 *out |= BASE_MEM_COHERENT_SYSTEM;
 201                         if ( KBASE_REG_SHARE_IN & reg->flags )
 202                                 *out |= BASE_MEM_COHERENT_LOCAL;
 203                         break;
 204                 }
 205                 default:
 206                         *out = 0;
 207                         goto out_unlock;
 208         }
 209
 210         ret = MALI_ERROR_NONE;
 211
 212 out_unlock:
 213         kbase_gpu_vm_unlock(kctx);
 214         return ret;
 215 }
 216
 217 mali_error kbase_mem_flags_change(kbase_context *kctx, mali_addr64 gpu_addr, unsigned int flags, unsigned int mask)
 218 {
 219         kbase_va_region *reg;
 220         mali_error ret = MALI_ERROR_FUNCTION_FAILED;
 221         unsigned int real_flags = 0;
 222         unsigned int prev_flags = 0;
 223
 224         KBASE_DEBUG_ASSERT(kctx);
 225
 226         if (!gpu_addr)
 227                 return MALI_ERROR_FUNCTION_FAILED;
 228
 229         /* nuke other bits */
 230         flags &= mask;
 231
 232         /* check for only supported flags */
 233         if (flags & ~(BASE_MEM_COHERENT_SYSTEM | BASE_MEM_COHERENT_LOCAL))
 234                 goto out;
 235
 236         /* mask covers bits we don't support? */
 237         if (mask & ~(BASE_MEM_COHERENT_SYSTEM | BASE_MEM_COHERENT_LOCAL))
 238                 goto out;
 239
 240         /* convert flags */
 241         if( BASE_MEM_COHERENT_SYSTEM & flags )
 242                 real_flags |= KBASE_REG_SHARE_BOTH;
 243         else if ( BASE_MEM_COHERENT_LOCAL & flags )
 244                 real_flags |= KBASE_REG_SHARE_IN;
 245
 246         /* now we can lock down the context, and find the region */
 247         kbase_gpu_vm_lock(kctx);
 248
 249         /* Validate the region */
 250         reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
 251         if (!reg || (reg->flags & KBASE_REG_FREE) )
 252                 goto out_unlock;
 253
 254         /* limit to imported memory */
 255         if ( (reg->alloc->type != KBASE_MEM_TYPE_IMPORTED_UMP) &&
 256              (reg->alloc->type != KBASE_MEM_TYPE_IMPORTED_UMM))
 257                 goto out_unlock;
 258
 259         /* no change? */
 260         if (real_flags == (reg->flags & (KBASE_REG_SHARE_IN | KBASE_REG_SHARE_BOTH)))
 261         {
 262                 ret = MALI_ERROR_NONE;
 263                 goto out_unlock;
 264         }
 265
 266         /* save for roll back */
 267         prev_flags = reg->flags;
 268         reg->flags &= ~(KBASE_REG_SHARE_IN | KBASE_REG_SHARE_BOTH);
 269         reg->flags |= real_flags;
 270
 271         /* Currently supporting only imported memory */
 272         switch(reg->alloc->type)
 273         {
 274 #ifdef CONFIG_UMP
 275                 case KBASE_MEM_TYPE_IMPORTED_UMP:
 276                         ret = kbase_mmu_update_pages(kctx, reg->start_pfn, kbase_get_phy_pages(reg), reg->alloc->nents, reg->flags);
 277                         break;
 278 #endif
 279 #ifdef CONFIG_DMA_SHARED_BUFFER
 280                 case KBASE_MEM_TYPE_IMPORTED_UMM:
 281                         /* Future use will use the new flags, existing mapping will NOT be updated
 282                          * as memory should not be in use by the GPU when updating the flags.
 283                          */
 284                         ret = MALI_ERROR_NONE;
 285                         WARN_ON(reg->alloc->imported.umm.current_mapping_usage_count);
 286                         break;
 287 #endif
 288                 default:
 289                         break;
 290         }
 291
 292         /* roll back on error, i.e. not UMP */
 293         if (ret != MALI_ERROR_NONE)
 294                 reg->flags = prev_flags;
 295
 296 out_unlock:
 297         kbase_gpu_vm_unlock(kctx);
 298 out:
 299         return ret;
 300 }
 301
 302 #ifdef CONFIG_UMP
 303 static struct kbase_va_region *kbase_mem_from_ump(kbase_context *kctx, ump_secure_id id, u64 *va_pages, u64 *flags)
 304 {
 305         struct kbase_va_region *reg;
 306         ump_dd_handle umph;
 307         u64 block_count;
 308         const ump_dd_physical_block_64 *block_array;
 309         u64 i, j;
 310         int page = 0;
 311         ump_alloc_flags ump_flags;
 312         ump_alloc_flags cpu_flags;
 313         ump_alloc_flags gpu_flags;
 314
 315         KBASE_DEBUG_ASSERT(kctx);
 316         KBASE_DEBUG_ASSERT(va_pages);
 317         KBASE_DEBUG_ASSERT(flags);
 318
 319         umph = ump_dd_from_secure_id(id);
 320         if (UMP_DD_INVALID_MEMORY_HANDLE == umph)
 321                 goto bad_id;
 322
 323         ump_flags = ump_dd_allocation_flags_get(umph);
 324         cpu_flags = (ump_flags >> UMP_DEVICE_CPU_SHIFT) & UMP_DEVICE_MASK;
 325         gpu_flags = (ump_flags >> kctx->kbdev->memdev.ump_device_id) & UMP_DEVICE_MASK;
 326
 327         *va_pages = ump_dd_size_get_64(umph);
 328         *va_pages >>= PAGE_SHIFT;
 329
 330         if (!*va_pages)
 331                 goto bad_size;
 332
 333         if (*flags & BASE_MEM_SAME_VA)
 334                 reg = kbase_alloc_free_region(kctx, 0, *va_pages, KBASE_REG_ZONE_SAME_VA);
 335         else
 336                 reg = kbase_alloc_free_region(kctx, 0, *va_pages, KBASE_REG_ZONE_CUSTOM_VA);
 337
 338         if (!reg)
 339                 goto no_region;
 340
 341         /* we've got pages to map now, and support SAME_VA */
 342         *flags |= KBASE_MEM_IMPORT_HAVE_PAGES;
 343
 344         reg->alloc = kbase_alloc_create(*va_pages, KBASE_MEM_TYPE_IMPORTED_UMP);
 345         if (IS_ERR_OR_NULL(reg->alloc))
 346                 goto no_alloc_obj;
 347
 348         reg->alloc->imported.ump_handle = umph;
 349
 350         reg->flags &= ~KBASE_REG_FREE;
 351         reg->flags |= KBASE_REG_GPU_NX; /* UMP is always No eXecute */
 352         reg->flags &= ~KBASE_REG_GROWABLE;      /* UMP cannot be grown */
 353
 354         if ((cpu_flags & (UMP_HINT_DEVICE_RD | UMP_HINT_DEVICE_WR)) == (UMP_HINT_DEVICE_RD | UMP_HINT_DEVICE_WR))
 355                 reg->flags |= KBASE_REG_CPU_CACHED;
 356
 357         if (cpu_flags & UMP_PROT_DEVICE_WR)
 358                 reg->flags |= KBASE_REG_CPU_WR;
 359
 360         if (cpu_flags & UMP_PROT_DEVICE_RD)
 361                 reg->flags |= KBASE_REG_CPU_RD;
 362
 363         if ((gpu_flags & (UMP_HINT_DEVICE_RD | UMP_HINT_DEVICE_WR)) == (UMP_HINT_DEVICE_RD | UMP_HINT_DEVICE_WR))
 364                 reg->flags |= KBASE_REG_GPU_CACHED;
 365
 366         if (gpu_flags & UMP_PROT_DEVICE_WR)
 367                 reg->flags |= KBASE_REG_GPU_WR;
 368
 369         if (gpu_flags & UMP_PROT_DEVICE_RD)
 370                 reg->flags |= KBASE_REG_GPU_RD;
 371
 372         /* ump phys block query */
 373         ump_dd_phys_blocks_get_64(umph, &block_count, &block_array);
 374
 375         for (i = 0; i < block_count; i++) {
 376                 for (j = 0; j < (block_array[i].size >> PAGE_SHIFT); j++) {
 377                         reg->alloc->pages[page] = block_array[i].addr + (j << PAGE_SHIFT);
 378                         page++;
 379                 }
 380         }
 381         reg->alloc->nents = *va_pages;
 382         reg->extent = 0;
 383
 384         return reg;
 385
 386 no_alloc_obj:
 387         kfree(reg);
 388 no_region:
 389 bad_size:
 390         ump_dd_release(umph);
 391 bad_id:
 392         return NULL;
 393
 394 }
 395 #endif                          /* CONFIG_UMP */
 396
 397 #ifdef CONFIG_DMA_SHARED_BUFFER
 398 static struct kbase_va_region *kbase_mem_from_umm(kbase_context *kctx, int fd, u64 *va_pages, u64 *flags)
 399 {
 400         struct kbase_va_region *reg;
 401         struct dma_buf *dma_buf;
 402         struct dma_buf_attachment *dma_attachment;
 403
 404         dma_buf = dma_buf_get(fd);
 405         if (IS_ERR_OR_NULL(dma_buf))
 406                 goto no_buf;
 407
 408         dma_attachment = dma_buf_attach(dma_buf, kctx->kbdev->osdev.dev);
 409         if (!dma_attachment)
 410                 goto no_attachment;
 411
 412         *va_pages = PAGE_ALIGN(dma_buf->size) >> PAGE_SHIFT;
 413         if (!*va_pages)
 414                 goto bad_size;
 415
 416         /* ignore SAME_VA */
 417         *flags &= ~BASE_MEM_SAME_VA;
 418
 419 #ifdef CONFIG_64BIT
 420         if (!is_compat_task()) {
 421                 /* 64-bit tasks must MMAP anyway, but not expose this address to clients */
 422                 *flags |= KBASE_MEM_IMPORT_MMAP;
 423                 reg = kbase_alloc_free_region(kctx, 0, *va_pages, KBASE_REG_ZONE_SAME_VA);
 424         } else {
 425 #else
 426         if (1) {
 427 #endif
 428                 reg = kbase_alloc_free_region(kctx, 0, *va_pages, KBASE_REG_ZONE_CUSTOM_VA);
 429         }
 430
 431         if (!reg)
 432                 goto no_region;
 433
 434         reg->alloc = kbase_alloc_create(*va_pages, KBASE_MEM_TYPE_IMPORTED_UMM);
 435         if (IS_ERR_OR_NULL(reg->alloc))
 436                 goto no_alloc_obj;
 437
 438         reg->alloc->nents = *va_pages;
 439
 440         reg->flags &= ~KBASE_REG_FREE;
 441         reg->flags |= KBASE_REG_GPU_NX; /* UMM is always No eXecute */
 442         reg->flags &= ~KBASE_REG_GROWABLE;      /* UMM cannot be grown */
 443         reg->flags |= KBASE_REG_GPU_CACHED;
 444
 445         /* no read or write permission given on import, only on run do we give the right permissions */
 446
 447         reg->alloc->type = BASE_TMEM_IMPORT_TYPE_UMM;
 448         reg->alloc->imported.umm.sgt = NULL;
 449         reg->alloc->imported.umm.dma_buf = dma_buf;
 450         reg->alloc->imported.umm.dma_attachment = dma_attachment;
 451         reg->alloc->imported.umm.current_mapping_usage_count = 0;
 452         reg->extent = 0;
 453
 454         return reg;
 455
 456 no_alloc_obj:
 457         kfree(reg);
 458 no_region:
 459 bad_size:
 460         dma_buf_detach(dma_buf, dma_attachment);
 461 no_attachment:
 462         dma_buf_put(dma_buf);
 463 no_buf:
 464         return NULL;
 465 }
 466 #endif  /* CONFIG_DMA_SHARED_BUFFER */
 467
 468 int kbase_mem_import(kbase_context *kctx, base_mem_import_type type, int handle, mali_addr64 * gpu_va, u64 * va_pages, u64 * flags)
 469 {
 470         kbase_va_region * reg;
 471
 472         KBASE_DEBUG_ASSERT(kctx);
 473         KBASE_DEBUG_ASSERT(gpu_va);
 474         KBASE_DEBUG_ASSERT(va_pages);
 475         KBASE_DEBUG_ASSERT(flags);
 476
 477 #ifdef CONFIG_64BIT
 478         if (!is_compat_task())
 479                 *flags |= BASE_MEM_SAME_VA;
 480 #endif
 481
 482         switch (type) {
 483 #ifdef CONFIG_UMP
 484         case BASE_MEM_IMPORT_TYPE_UMP:
 485                 reg = kbase_mem_from_ump(kctx, (ump_secure_id)handle, va_pages, flags);
 486                 break;
 487 #endif /* CONFIG_UMP */
 488 #ifdef CONFIG_DMA_SHARED_BUFFER
 489         case BASE_MEM_IMPORT_TYPE_UMM:
 490                 reg = kbase_mem_from_umm(kctx, handle, va_pages, flags);
 491                 break;
 492 #endif /* CONFIG_DMA_SHARED_BUFFER */
 493         default:
 494                 reg = NULL;
 495                 break;
 496         }
 497
 498         if (!reg)
 499                 goto no_reg;
 500
 501         kbase_gpu_vm_lock(kctx);
 502
 503         /* mmap needed to setup VA? */
 504         if (*flags & (BASE_MEM_SAME_VA | KBASE_MEM_IMPORT_MMAP)) {
 505                 /* Bind to a cookie */
 506                 if (!kctx->osctx.cookies)
 507                         goto no_cookie;
 508                 /* return a cookie */
 509                 *gpu_va = __ffs(kctx->osctx.cookies);
 510                 kctx->osctx.cookies &= ~(1UL << *gpu_va);
 511                 reg->flags &= ~KBASE_REG_COOKIE_MASK;
 512                 reg->flags |= KBASE_REG_COOKIE(*gpu_va);
 513                 list_add(&reg->link, &kctx->osctx.reg_pending);
 514         } else if (*flags & KBASE_MEM_IMPORT_HAVE_PAGES)  {
 515                 /* we control the VA, mmap now to the GPU */
 516                 if (MALI_ERROR_NONE != kbase_gpu_mmap(kctx, reg, 0, *va_pages, 1))
 517                         goto no_gpu_va;
 518                 /* return real GPU VA */
 519                 *gpu_va = reg->start_pfn << PAGE_SHIFT;
 520         } else {
 521                 /* we control the VA, but nothing to mmap yet */
 522                 if (MALI_ERROR_NONE != kbase_add_va_region(kctx, reg, 0, *va_pages, 1))
 523                         goto no_gpu_va;
 524                 /* return real GPU VA */
 525                 *gpu_va = reg->start_pfn << PAGE_SHIFT;
 526         }
 527
 528         kbase_gpu_vm_unlock(kctx);
 529
 530         return 0;
 531
 532 no_gpu_va:
 533 no_cookie:
 534         kbase_gpu_vm_unlock(kctx);
 535         kbase_mem_phy_alloc_put(reg->alloc);
 536         kfree(reg);
 537 no_reg:
 538         *gpu_va = 0;
 539         *va_pages = 0;
 540         *flags = 0;
 541         return -ENOMEM;
 542 }
 543
 544
 545 int kbase_mem_commit(kbase_context * kctx, mali_addr64 gpu_addr, u64 new_pages, base_backing_threshold_status * failure_reason)
 546 {
 547         u64 old_pages;
 548         u64 delta;
 549         int res = -EINVAL;
 550         kbase_va_region *reg;
 551         phys_addr_t *phy_pages;
 552
 553         KBASE_DEBUG_ASSERT(kctx);
 554         KBASE_DEBUG_ASSERT(failure_reason);
 555         KBASE_DEBUG_ASSERT(gpu_addr != 0);
 556
 557         kbase_gpu_vm_lock(kctx);
 558
 559         /* Validate the region */
 560         reg = kbase_region_tracker_find_region_base_address(kctx, gpu_addr);
 561         if (!reg || (reg->flags & KBASE_REG_FREE)) {
 562                 *failure_reason = BASE_BACKING_THRESHOLD_ERROR_INVALID_ARGUMENTS;
 563                 goto out_unlock;
 564         }
 565
 566         KBASE_DEBUG_ASSERT(reg->alloc);
 567
 568         if (reg->alloc->type != KBASE_MEM_TYPE_NATIVE) {
 569                 *failure_reason = BASE_BACKING_THRESHOLD_ERROR_NOT_GROWABLE;
 570                 goto out_unlock;
 571         }
 572
 573         if (0 == (reg->flags & KBASE_REG_GROWABLE)) {
 574                 *failure_reason = BASE_BACKING_THRESHOLD_ERROR_NOT_GROWABLE;
 575                 goto out_unlock;
 576         }
 577
 578         if (new_pages > reg->nr_pages) {
 579                 /* Would overflow the VA region */
 580                 *failure_reason = BASE_BACKING_THRESHOLD_ERROR_INVALID_ARGUMENTS;
 581                 goto out_unlock;
 582         }
 583
 584         if (new_pages == reg->alloc->nents) {
 585                 /* no change */
 586                 res = 0;
 587                 goto out_unlock;
 588         }
 589
 590         phy_pages = kbase_get_phy_pages(reg);
 591         old_pages = kbase_reg_current_backed_size(reg);
 592
 593         if (new_pages > old_pages) {
 594                 /* growing */
 595                 mali_error err;
 596                 delta = new_pages - old_pages;
 597                 /* Allocate some more pages */
 598                 if (MALI_ERROR_NONE != kbase_alloc_phy_pages_helper(reg->alloc, delta)) {
 599                         *failure_reason = BASE_BACKING_THRESHOLD_ERROR_OOM;
 600                         goto out_unlock;
 601                 }
 602                 err = kbase_mmu_insert_pages(kctx, reg->start_pfn + old_pages, phy_pages + old_pages, delta, reg->flags);
 603                 if (MALI_ERROR_NONE != err) {
 604                         kbase_free_phy_pages_helper(reg->alloc, delta);
 605                         *failure_reason = BASE_BACKING_THRESHOLD_ERROR_OOM;
 606                         goto out_unlock;
 607                 }
 608         } else {
 609                 /* shrinking */
 610                 struct kbase_cpu_mapping * mapping;
 611                 mali_error err;
 612
 613                 /* first, unmap from any mappings affected */
 614                 list_for_each_entry(mapping, &reg->alloc->mappings, mappings_list) {
 615                         struct vm_area_struct * vma = mapping->vma;
 616                         unsigned long mapping_size = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 617
 618                         /* is this mapping affected ?*/
 619                         if ((mapping->page_off + mapping_size) > new_pages) {
 620                                 unsigned long first_bad = 0;
 621                                 int zap_res;
 622
 623                                 if (new_pages > mapping->page_off)
 624                                         first_bad = new_pages - mapping->page_off;
 625
 626                                 zap_res = zap_vma_ptes(vma, vma->vm_start + (first_bad << PAGE_SHIFT), (mapping_size - first_bad) << PAGE_SHIFT);
 627                                 WARN(zap_res, "Failed to zap vma %p (0x%lx - 0x%lx), tried %ld pages from 0x%lx\n", vma, vma->vm_start, vma->vm_end, (mapping_size - first_bad), vma->vm_start + (first_bad << PAGE_SHIFT));
 628                         }
 629                 }
 630
 631                 /* Free some pages */
 632                 delta = old_pages - new_pages;
 633                 err = kbase_mmu_teardown_pages(kctx, reg->start_pfn + new_pages, delta);
 634                 if (MALI_ERROR_NONE != err) {
 635                         *failure_reason = BASE_BACKING_THRESHOLD_ERROR_OOM;
 636                         goto out_unlock;
 637                 }
 638
 639                 if (kbase_hw_has_issue(kctx->kbdev, BASE_HW_ISSUE_6367)) {
 640                         /* Wait for GPU to flush write buffer before freeing physical pages */
 641                         kbase_wait_write_flush(kctx);
 642                 }
 643
 644                 kbase_free_phy_pages_helper(reg->alloc, delta);
 645         }
 646
 647         res = 0;
 648
 649 out_unlock:
 650         kbase_gpu_vm_unlock(kctx);
 651
 652         return res;
 653
 654 }
 655
 656 STATIC void kbase_cpu_vm_open(struct vm_area_struct *vma)
 657 {
 658         struct kbase_cpu_mapping *map = vma->vm_private_data;
 659         KBASE_DEBUG_ASSERT(map);
 660         KBASE_DEBUG_ASSERT(map->count > 0);
 661         /* non-atomic as we're under Linux' mm lock */
 662         map->count++;
 663 }
 664
 665 STATIC void kbase_cpu_vm_close(struct vm_area_struct *vma)
 666 {
 667         struct kbase_cpu_mapping *map = vma->vm_private_data;
 668         KBASE_DEBUG_ASSERT(map);
 669         KBASE_DEBUG_ASSERT(map->count > 0);
 670
 671         /* non-atomic as we're under Linux' mm lock */
 672         if (--map->count)
 673                 return;
 674
 675         KBASE_DEBUG_ASSERT(map->vma == vma);
 676         KBASE_DEBUG_ASSERT(map->kctx);
 677         KBASE_DEBUG_ASSERT(map->alloc);
 678
 679         kbase_gpu_vm_lock(map->kctx);
 680
 681         if (map->region) {
 682                 KBASE_DEBUG_ASSERT((map->region->flags & KBASE_REG_ZONE_MASK) == KBASE_REG_ZONE_SAME_VA);
 683                 kbase_mem_free_region(map->kctx, map->region);
 684         }
 685
 686         list_del(&map->mappings_list);
 687
 688         kbase_gpu_vm_unlock(map->kctx);
 689
 690         kbase_mem_phy_alloc_put(map->alloc);
 691         kfree(map);
 692 }
 693
 694 KBASE_EXPORT_TEST_API(kbase_cpu_vm_close)
 695
 696
 697 STATIC int kbase_cpu_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 698 {
 699         struct kbase_cpu_mapping *map = vma->vm_private_data;
 700         pgoff_t rel_pgoff;
 701         size_t i;
 702
 703         KBASE_DEBUG_ASSERT(map);
 704         KBASE_DEBUG_ASSERT(map->vma == vma);
 705         KBASE_DEBUG_ASSERT(map->count > 0);
 706         KBASE_DEBUG_ASSERT(map->kctx);
 707         KBASE_DEBUG_ASSERT(map->alloc);
 708
 709         /* we don't use vmf->pgoff as it's affected by our mmap with offset being a GPU VA or a cookie */
 710         rel_pgoff = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT;
 711
 712         kbase_gpu_vm_lock(map->kctx);
 713         if (map->page_off + rel_pgoff >= map->alloc->nents)
 714                 goto locked_bad_fault;
 715
 716         /* insert all valid pages from the fault location */
 717         for (i = rel_pgoff; i < MIN((vma->vm_end - vma->vm_start) >> PAGE_SHIFT, map->alloc->nents - map->page_off); i++)
 718                 if (vm_insert_pfn(vma, vma->vm_start + (i << PAGE_SHIFT), PFN_DOWN(map->alloc->pages[map->page_off + i])))
 719                         goto locked_bad_fault;
 720
 721         kbase_gpu_vm_unlock(map->kctx);
 722         /* we resolved it, nothing for VM to do */
 723         return VM_FAULT_NOPAGE;
 724
 725 locked_bad_fault:
 726         kbase_gpu_vm_unlock(map->kctx);
 727         send_sig(SIGSEGV, current, 1);
 728         return VM_FAULT_NOPAGE;
 729 }
 730
 731 static const struct vm_operations_struct kbase_vm_ops = {
 732         .open  = kbase_cpu_vm_open,
 733         .close = kbase_cpu_vm_close,
 734         .fault = kbase_cpu_vm_fault
 735 };
 736
 737 static int kbase_cpu_mmap(struct kbase_va_region *reg, struct vm_area_struct *vma, void *kaddr, size_t nr_pages, int free_on_close)
 738 {
 739         struct kbase_cpu_mapping *map;
 740         u64 start_off = vma->vm_pgoff - reg->start_pfn;
 741         phys_addr_t *page_array;
 742         int err = 0;
 743         int i;
 744
 745         map = kzalloc(sizeof(*map), GFP_KERNEL);
 746
 747         if (!map) {
 748                 WARN_ON(1);
 749                 err = -ENOMEM;
 750                 goto out;
 751         }
 752
 753         /*
 754          * VM_DONTCOPY - don't make this mapping available in fork'ed processes
 755          * VM_DONTEXPAND - disable mremap on this region
 756          * VM_IO - disables paging
 757          * VM_DONTDUMP - Don't include in core dumps (3.7 only)
 758          * VM_MIXEDMAP - Support mixing struct page*s and raw pfns.
 759          *               This is needed to support using the dedicated and
 760          *               the OS based memory backends together.
 761          */
 762         /*
 763          * This will need updating to propagate coherency flags
 764          * See MIDBASE-1057
 765          */
 766
 767 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
 768         vma->vm_flags |= VM_DONTCOPY | VM_DONTDUMP | VM_DONTEXPAND | VM_IO;
 769 #else
 770         vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_RESERVED | VM_IO;
 771 #endif
 772         vma->vm_ops = &kbase_vm_ops;
 773         vma->vm_private_data = map;
 774
 775         page_array = kbase_get_phy_pages(reg);
 776
 777         if (!(reg->flags & KBASE_REG_CPU_CACHED)) {
 778                 /* We can't map vmalloc'd memory uncached.
 779                  * Other memory will have been returned from
 780                  * kbase_mem_allocator_alloc which would be
 781                  * suitable for mapping uncached.
 782                  */
 783                 BUG_ON(kaddr);
 784                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 785         }
 786
 787         if (!kaddr) {
 788                 vma->vm_flags |= VM_PFNMAP;
 789                 for (i = 0; i < nr_pages; i++) {
 790                         err = vm_insert_pfn(vma, vma->vm_start + (i << PAGE_SHIFT), page_array[i + start_off] >> PAGE_SHIFT);
 791                         if (WARN_ON(err))
 792                                 break;
 793                 }
 794         } else {
 795                 /* MIXEDMAP so we can vfree the kaddr early and not track it after map time */
 796                 vma->vm_flags |= VM_MIXEDMAP;
 797                 /* vmalloc remaping is easy... */
 798                 err = remap_vmalloc_range(vma, kaddr, 0);
 799                 WARN_ON(err);
 800         }
 801
 802         if (err) {
 803                 kfree(map);
 804                 goto out;
 805         }
 806
 807
 808         map->page_off = start_off;
 809         map->region = free_on_close ? reg : NULL;
 810         map->kctx = reg->kctx;
 811         map->vma = vma;
 812         map->alloc = kbase_mem_phy_alloc_get(reg->alloc);
 813         map->count = 1; /* start with one ref */
 814
 815         if (reg->flags & KBASE_REG_CPU_CACHED)
 816                 map->alloc->accessed_cached = 1;
 817
 818         list_add(&map->mappings_list, &map->alloc->mappings);
 819
 820  out:
 821         return err;
 822 }
 823
 824 static int kbase_trace_buffer_mmap(kbase_context *kctx, struct vm_area_struct *vma, struct kbase_va_region **const reg, void **const kaddr)
 825 {
 826         struct kbase_va_region *new_reg;
 827         u32 nr_pages;
 828         size_t size;
 829         int err = 0;
 830         u32 *tb;
 831         int owns_tb = 1;
 832
 833         pr_debug("in %s\n", __func__);
 834         size = (vma->vm_end - vma->vm_start);
 835         nr_pages = size >> PAGE_SHIFT;
 836
 837         if (!kctx->jctx.tb) {
 838                 KBASE_DEBUG_ASSERT(0 != size);
 839                 tb = vmalloc_user(size);
 840
 841                 if (NULL == tb) {
 842                         err = -ENOMEM;
 843                         goto out;
 844                 }
 845
 846                 kbase_device_trace_buffer_install(kctx, tb, size);
 847         } else {
 848                 err = -EINVAL;
 849                 goto out;
 850         }
 851
 852         *kaddr = kctx->jctx.tb;
 853
 854         new_reg = kbase_alloc_free_region(kctx, 0, nr_pages, KBASE_REG_ZONE_SAME_VA);
 855         if (!new_reg) {
 856                 err = -ENOMEM;
 857                 WARN_ON(1);
 858                 goto out_no_region;
 859         }
 860
 861         new_reg->alloc = kbase_alloc_create(0, KBASE_MEM_TYPE_TB);
 862         if (IS_ERR_OR_NULL(new_reg->alloc)) {
 863                 err = -ENOMEM;
 864                 new_reg->alloc = NULL;
 865                 WARN_ON(1);
 866                 goto out_no_alloc;
 867         }
 868
 869         new_reg->alloc->imported.kctx = kctx;
 870         new_reg->flags &= ~KBASE_REG_FREE;
 871         new_reg->flags |= KBASE_REG_CPU_CACHED;
 872
 873         /* alloc now owns the tb */
 874         owns_tb = 0;
 875
 876         if (MALI_ERROR_NONE != kbase_add_va_region(kctx, new_reg, vma->vm_start, nr_pages, 1)) {
 877                 err = -ENOMEM;
 878                 WARN_ON(1);
 879                 goto out_no_va_region;
 880         }
 881
 882         *reg = new_reg;
 883
 884         /* map read only, noexec */
 885         vma->vm_flags &= ~(VM_WRITE | VM_EXEC);
 886         /* the rest of the flags is added by the cpu_mmap handler */
 887
 888         pr_debug("%s done\n", __func__);
 889         return 0;
 890
 891 out_no_va_region:
 892 out_no_alloc:
 893         kbase_free_alloced_region(new_reg);
 894 out_no_region:
 895         if (owns_tb) {
 896                 kbase_device_trace_buffer_uninstall(kctx);
 897                 vfree(tb);
 898         }
 899 out:
 900         return err;
 901
 902 }
 903
 904 static int kbase_mmu_dump_mmap(kbase_context *kctx, struct vm_area_struct *vma, struct kbase_va_region **const reg, void **const kmap_addr)
 905 {
 906         struct kbase_va_region *new_reg;
 907         void *kaddr;
 908         u32 nr_pages;
 909         size_t size;
 910         int err = 0;
 911
 912         pr_debug("in kbase_mmu_dump_mmap\n");
 913         size = (vma->vm_end - vma->vm_start);
 914         nr_pages = size >> PAGE_SHIFT;
 915
 916         kaddr = kbase_mmu_dump(kctx, nr_pages);
 917
 918         if (!kaddr) {
 919                 err = -ENOMEM;
 920                 goto out;
 921         }
 922
 923         new_reg = kbase_alloc_free_region(kctx, 0, nr_pages, KBASE_REG_ZONE_SAME_VA);
 924         if (!new_reg) {
 925                 err = -ENOMEM;
 926                 WARN_ON(1);
 927                 goto out;
 928         }
 929
 930         new_reg->alloc = kbase_alloc_create(0, KBASE_MEM_TYPE_RAW);
 931         if (IS_ERR_OR_NULL(new_reg->alloc)) {
 932                 err = -ENOMEM;
 933                 new_reg->alloc = NULL;
 934                 WARN_ON(1);
 935                 goto out_no_alloc;
 936         }
 937
 938         new_reg->flags &= ~KBASE_REG_FREE;
 939         new_reg->flags |= KBASE_REG_CPU_CACHED;
 940         if (MALI_ERROR_NONE != kbase_add_va_region(kctx, new_reg, vma->vm_start, nr_pages, 1)) {
 941                 err = -ENOMEM;
 942                 WARN_ON(1);
 943                 goto out_va_region;
 944         }
 945
 946         *kmap_addr = kaddr;
 947         *reg = new_reg;
 948
 949         pr_debug("kbase_mmu_dump_mmap done\n");
 950         return 0;
 951
 952 out_no_alloc:
 953 out_va_region:
 954         kbase_free_alloced_region(new_reg);
 955 out:
 956         return err;
 957 }
 958
 959 /* must be called with the gpu vm lock held */
 960
 961 struct kbase_va_region *kbase_lookup_cookie(kbase_context *kctx, mali_addr64 cookie)
 962 {
 963         struct kbase_va_region *reg;
 964         struct list_head *pos;
 965         mali_addr64 test_cookie;
 966
 967         KBASE_DEBUG_ASSERT(kctx != NULL);
 968         BUG_ON(!mutex_is_locked(&kctx->reg_lock));
 969
 970         test_cookie = KBASE_REG_COOKIE(cookie);
 971
 972         list_for_each(pos, &kctx->osctx.reg_pending) {
 973                 reg = list_entry(pos, struct kbase_va_region, link);
 974                 if ((reg->flags & KBASE_REG_COOKIE_MASK) == test_cookie)
 975                         return reg;
 976         }
 977
 978         return NULL;            /* not found */
 979 }
 980
 981 KBASE_EXPORT_TEST_API(kbase_lookup_cookie)
 982
 983 void kbase_unlink_cookie(kbase_context *kctx, mali_addr64 cookie, struct kbase_va_region *reg)
 984 {
 985         KBASE_DEBUG_ASSERT(kctx != NULL);
 986         KBASE_DEBUG_ASSERT(reg != NULL);
 987         KBASE_DEBUG_ASSERT(MALI_TRUE == kbasep_list_member_of(&kctx->osctx.reg_pending, &reg->link));
 988         KBASE_DEBUG_ASSERT(KBASE_REG_COOKIE(cookie) == (reg->flags & KBASE_REG_COOKIE_MASK));
 989         KBASE_DEBUG_ASSERT((kctx->osctx.cookies & (1UL << cookie)) == 0);
 990
 991         list_del(&reg->link);
 992         kctx->osctx.cookies |= (1UL << cookie); /* mark as resolved */
 993 }
 994
 995 KBASE_EXPORT_TEST_API(kbase_unlink_cookie)
 996
 997 void kbase_os_mem_map_lock(kbase_context *kctx)
 998 {
 999         struct mm_struct *mm = current->mm;
1000         (void)kctx;
1001         down_read(&mm->mmap_sem);
1002 }
1003
1004 void kbase_os_mem_map_unlock(kbase_context *kctx)
1005 {
1006         struct mm_struct *mm = current->mm;
1007         (void)kctx;
1008         up_read(&mm->mmap_sem);
1009 }
1010
1011 int kbase_mmap(struct file *file, struct vm_area_struct *vma)
1012 {
1013         kbase_context *kctx = file->private_data;
1014         struct kbase_va_region *reg;
1015         void *kaddr = NULL;
1016         size_t nr_pages;
1017         int err = 0;
1018         int free_on_close = 0;
1019
1020         pr_debug("kbase_mmap\n");
1021         nr_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
1022
1023         if (0 == nr_pages) {
1024                 err = -EINVAL;
1025                 goto out;
1026         }
1027
1028         if (!(vma->vm_flags & VM_SHARED)) {
1029                 err = -EINVAL;
1030                 goto out;
1031         }
1032
1033         kbase_gpu_vm_lock(kctx);
1034
1035         if (vma->vm_pgoff == KBASE_REG_COOKIE_MTP)
1036         {
1037                 /* The non-mapped tracking helper page */
1038                 err = kbase_tracking_page_setup(kctx, vma);
1039                 goto out_unlock;
1040         }
1041
1042         /* if not the MTP, verify that the MTP has been mapped */
1043         rcu_read_lock();
1044         /* catches both when the special page isn't present or when we've forked */
1045         if (rcu_dereference(kctx->process_mm) != current->mm)
1046         {
1047                 err = -EINVAL;
1048                 rcu_read_unlock();
1049                 goto out_unlock;
1050         }
1051         rcu_read_unlock();
1052
1053         if (vma->vm_pgoff == KBASE_REG_COOKIE_RB) {
1054                 /* Ring buffer doesn't exist any more */
1055                 err = -EINVAL;
1056                 goto out_unlock;
1057         } else if (vma->vm_pgoff == KBASE_REG_COOKIE_TB) {
1058                 err = kbase_trace_buffer_mmap(kctx, vma, &reg, &kaddr);
1059                 if (0 != err) {
1060                         goto out_unlock;
1061                 }
1062                 pr_debug("kbase_trace_buffer_mmap ok\n");
1063
1064                 /* free the region on munmap */
1065                 free_on_close = 1;
1066
1067                 goto map;
1068         } else if (vma->vm_pgoff == KBASE_REG_COOKIE_MMU_DUMP) {
1069                 /* MMU dump */
1070                 err = kbase_mmu_dump_mmap(kctx, vma, &reg, &kaddr);
1071                 if (0 != err) {
1072                         goto out_unlock;
1073                 }
1074
1075                 /* free the region on munmap */
1076                 free_on_close = 1;
1077
1078                 goto map;
1079         }
1080
1081         /* first 4096 pages (16MB) is reserved for cookie resolution */
1082         if (vma->vm_pgoff < PAGE_SIZE) {
1083                 /* SAME_VA stuff, fetch the right region */
1084                 int gpu_pc_bits;
1085                 gpu_pc_bits = kctx->kbdev->gpu_props.props.core_props.log2_program_counter_size;
1086                 reg = kbase_lookup_cookie(kctx, vma->vm_pgoff);
1087                 if (NULL != reg) {
1088                         size_t aligned_offset = 0;
1089
1090                         if (reg->flags & KBASE_REG_ALIGNED) {
1091                                 /* nr_pages must be able to hold alignment pages
1092                                  * plus actual pages */
1093                                 if (nr_pages != ((1UL << gpu_pc_bits >>
1094                                                         PAGE_SHIFT) +
1095                                                         reg->nr_pages)) {
1096                                         /* incorrect mmap size */
1097                                         /* leave the cookie for a potential
1098                                          * later mapping, or to be reclaimed
1099                                          * later when the context is freed */
1100                                         err = -ENOMEM;
1101                                         goto out_unlock;
1102                                 }
1103
1104                                 aligned_offset = (vma->vm_start +
1105                                                   (1UL << gpu_pc_bits) - 1) &
1106                                                   ~((1UL << gpu_pc_bits) - 1);
1107                                 aligned_offset -= vma->vm_start;
1108                         } else if (reg->nr_pages != nr_pages) {
1109                                 /* incorrect mmap size */
1110                                 /* leave the cookie for a potential later
1111                                  * mapping, or to be reclaimed later when the
1112                                  * context is freed */
1113                                 err = -ENOMEM;
1114                                 goto out_unlock;
1115                         }
1116
1117                         if ((vma->vm_flags & VM_READ && !(reg->flags & KBASE_REG_CPU_RD)) ||
1118                             (vma->vm_flags & VM_WRITE && !(reg->flags & KBASE_REG_CPU_WR))) {
1119                                 /* VM flags inconsistent with region flags */
1120                                 err = -EPERM;
1121                                 printk(KERN_ERR "%s:%d inconsistent VM flags\n", __FILE__, __LINE__);
1122                                 goto out_unlock;
1123                         }
1124
1125                         /* adjust down nr_pages to what we have physically */
1126                         nr_pages = reg->alloc->nents;
1127
1128                         kbase_unlink_cookie(kctx, vma->vm_pgoff, reg);
1129
1130                         if (MALI_ERROR_NONE != kbase_gpu_mmap(kctx, reg, vma->vm_start + aligned_offset, reg->nr_pages, 1)) {
1131                                 printk(KERN_ERR "%s:%d\n", __FILE__, __LINE__);
1132                                 /* Unable to map in GPU space. Recover from kbase_unlink_cookie */
1133                                 list_add(&reg->link, &kctx->osctx.reg_pending);
1134                                 kctx->osctx.cookies &= ~(1UL << vma->vm_pgoff);
1135                                 WARN_ON(1);
1136                                 err = -ENOMEM;
1137                                 goto out_unlock;
1138                         }
1139
1140                         /* clear off the cookie bits */
1141                         reg->flags &= ~(KBASE_REG_COOKIE_MASK);
1142
1143                         /*
1144                          * Overwrite the offset with the
1145                          * region start_pfn, so we effectively
1146                          * map from offset 0 in the region.
1147                          */
1148                         vma->vm_pgoff = reg->start_pfn;
1149
1150                         /* free the region on munmap */
1151                         free_on_close = 1;
1152                         goto map;
1153                 }
1154
1155                 err = -ENOMEM;
1156                 goto out_unlock;
1157         } else {
1158                 int zone;
1159
1160                 /* CUSTOM_VA case or EXEC case */
1161                 if (vma->vm_pgoff < KBASE_REG_ZONE_EXEC_BASE)
1162                         zone = KBASE_REG_ZONE_SAME_VA;
1163                 else if (vma->vm_pgoff < KBASE_REG_ZONE_CUSTOM_VA_BASE)
1164                         zone = KBASE_REG_ZONE_EXEC;
1165                 else
1166                         zone = KBASE_REG_ZONE_CUSTOM_VA;
1167
1168                 reg = kbase_region_tracker_find_region_enclosing_address(kctx, (u64)vma->vm_pgoff << PAGE_SHIFT);
1169
1170                 if (reg && (reg->flags & (KBASE_REG_ZONE_MASK | KBASE_REG_FREE)) == zone) {
1171                         /* will this mapping overflow the size of the region? */
1172                         if (nr_pages > (reg->nr_pages - (vma->vm_pgoff - reg->start_pfn)))
1173                                 goto overflow;
1174
1175 #ifdef CONFIG_DMA_SHARED_BUFFER
1176                         if (reg->alloc->type == KBASE_MEM_TYPE_IMPORTED_UMM)
1177                                 goto dma_map;
1178 #endif                          /* CONFIG_DMA_SHARED_BUFFER */
1179
1180                         /* limit what we map to the amount currently backed */
1181                         if (reg->alloc->nents < (vma->vm_pgoff - reg->start_pfn + nr_pages)) {
1182                                 if ((vma->vm_pgoff - reg->start_pfn) >= reg->alloc->nents)
1183                                         nr_pages = 0;
1184                                 else
1185                                         nr_pages = reg->alloc->nents - (vma->vm_pgoff - reg->start_pfn);
1186                         }
1187
1188                         goto map;
1189                 }
1190
1191 overflow:
1192                 err = -ENOMEM;
1193                 goto out_unlock;
1194         }
1195 map:
1196         err = kbase_cpu_mmap(reg, vma, kaddr, nr_pages, free_on_close);
1197
1198         if (vma->vm_pgoff == KBASE_REG_COOKIE_MMU_DUMP) {
1199                 /* MMU dump - userspace should now have a reference on
1200                  * the pages, so we can now free the kernel mapping */
1201                 vfree(kaddr);
1202         }
1203         goto out_unlock;
1204
1205 #ifdef CONFIG_DMA_SHARED_BUFFER
1206 dma_map:
1207         err = dma_buf_mmap(reg->alloc->imported.umm.dma_buf, vma, vma->vm_pgoff - reg->start_pfn);
1208 #endif                          /* CONFIG_DMA_SHARED_BUFFER */
1209 out_unlock:
1210         kbase_gpu_vm_unlock(kctx);
1211 out:
1212         if (err)
1213                 pr_err("mmap failed %d\n", err);
1214
1215         return err;
1216 }
1217
1218 KBASE_EXPORT_TEST_API(kbase_mmap)
1219
1220 mali_error kbase_create_os_context(kbase_os_context * const osctx)
1221 {
1222         KBASE_DEBUG_ASSERT(osctx != NULL);
1223
1224         INIT_LIST_HEAD(&osctx->reg_pending);
1225         osctx->cookies = ~KBASE_REG_RESERVED_COOKIES;
1226         osctx->tgid = current->tgid;
1227         osctx->pid = current->pid;
1228         init_waitqueue_head(&osctx->event_queue);
1229
1230         return MALI_ERROR_NONE;
1231 }
1232
1233 KBASE_EXPORT_TEST_API(kbase_create_os_context)
1234
1235 static void kbase_reg_pending_dtor(struct kbase_va_region *reg)
1236 {
1237         pr_info("Freeing pending unmapped region\n");
1238         kbase_mem_phy_alloc_put(reg->alloc);
1239         kfree(reg);
1240 }
1241
1242 void kbase_destroy_os_context(kbase_os_context *osctx)
1243 {
1244         struct kbase_va_region *reg;
1245
1246         KBASE_DEBUG_ASSERT(osctx != NULL);
1247
1248         while (!list_empty(&osctx->reg_pending)) {
1249                 reg = list_entry(osctx->reg_pending.next, struct kbase_va_region, link);
1250                 list_del(osctx->reg_pending.next);
1251                 kbase_reg_pending_dtor(reg);
1252         }
1253 }
1254
1255 KBASE_EXPORT_TEST_API(kbase_destroy_os_context)
1256
1257 void kbasep_os_process_page_usage_update( kbase_context *kctx, int pages )
1258 {
1259         struct mm_struct *mm;
1260
1261         rcu_read_lock();
1262         mm = rcu_dereference(kctx->process_mm);
1263         if (mm)
1264         {
1265                 atomic_add(pages, &kctx->nonmapped_pages);
1266 #ifdef SPLIT_RSS_COUNTING
1267                 add_mm_counter(mm, MM_FILEPAGES, pages);
1268 #else
1269                 spin_lock(&mm->page_table_lock);
1270                 add_mm_counter(mm, MM_FILEPAGES, pages);
1271                 spin_unlock(&mm->page_table_lock);
1272 #endif
1273         }
1274         rcu_read_unlock();
1275 }
1276
1277 static void kbasep_os_process_page_usage_drain(kbase_context * kctx)
1278 {
1279         int pages;
1280         struct mm_struct * mm;
1281
1282         spin_lock(&kctx->mm_update_lock);
1283         mm = rcu_dereference_protected(kctx->process_mm, lockdep_is_held(&kctx->mm_update_lock));
1284         if (!mm)
1285         {
1286                 spin_unlock(&kctx->mm_update_lock);
1287                 return;
1288         }
1289
1290         rcu_assign_pointer(kctx->process_mm, NULL);
1291         spin_unlock(&kctx->mm_update_lock);
1292         synchronize_rcu();
1293
1294         pages = atomic_xchg(&kctx->nonmapped_pages, 0);
1295 #ifdef SPLIT_RSS_COUNTING
1296         add_mm_counter(mm, MM_FILEPAGES, -pages);
1297 #else
1298         spin_lock(&mm->page_table_lock);
1299         add_mm_counter(mm, MM_FILEPAGES, -pages);
1300         spin_unlock(&mm->page_table_lock);
1301 #endif
1302 }
1303
1304 static void kbase_special_vm_close(struct vm_area_struct *vma)
1305 {
1306         kbase_context * kctx;
1307         kctx = vma->vm_private_data;
1308         kbasep_os_process_page_usage_drain(kctx);
1309 }
1310
1311 static const struct vm_operations_struct kbase_vm_special_ops = {
1312         .close = kbase_special_vm_close,
1313 };
1314
1315 static int kbase_tracking_page_setup(struct kbase_context * kctx, struct vm_area_struct * vma)
1316 {
1317         /* check that this is the only tracking page */
1318         spin_lock(&kctx->mm_update_lock);
1319         if (rcu_dereference_protected(kctx->process_mm, lockdep_is_held(&kctx->mm_update_lock)))
1320         {
1321                 spin_unlock(&kctx->mm_update_lock);
1322                 return -EFAULT;
1323         }
1324
1325         rcu_assign_pointer(kctx->process_mm, current->mm);
1326
1327         spin_unlock(&kctx->mm_update_lock);
1328
1329         /* no real access */
1330         vma->vm_flags &= ~(VM_READ | VM_WRITE | VM_EXEC);
1331 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
1332         vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_DONTDUMP | VM_IO;
1333 #else
1334         vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_RESERVED | VM_IO;
1335 #endif
1336         vma->vm_ops = &kbase_vm_special_ops;
1337         vma->vm_private_data = kctx;
1338
1339         return 0;
1340 }
1341 void *kbase_va_alloc(kbase_context *kctx, u32 size, kbase_hwc_dma_mapping *handle)
1342 {
1343         int i;
1344         int res;
1345         void *va;
1346         dma_addr_t  dma_pa;
1347         struct kbase_va_region *reg;
1348         phys_addr_t *page_array;
1349 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
1350         DEFINE_DMA_ATTRS(attrs);
1351 #endif
1352
1353         u32 pages = ((size - 1) >> PAGE_SHIFT) + 1;
1354         u32 flags = BASE_MEM_PROT_CPU_RD | BASE_MEM_PROT_CPU_WR |
1355                     BASE_MEM_PROT_GPU_RD | BASE_MEM_PROT_GPU_WR;
1356
1357         KBASE_DEBUG_ASSERT(kctx != NULL);
1358         KBASE_DEBUG_ASSERT(0 != size);
1359         KBASE_DEBUG_ASSERT(0 != pages);
1360
1361         if (size == 0)
1362                 goto err;
1363
1364 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
1365         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
1366         va = dma_alloc_attrs(kctx->kbdev->osdev.dev, size, &dma_pa, GFP_KERNEL, &attrs);
1367 #else
1368         va = dma_alloc_writecombine(kctx->kbdev->osdev.dev, size, &dma_pa, GFP_KERNEL);
1369 #endif
1370         if (!va)
1371                 goto err;
1372
1373         memset(va, 0x0, size);
1374
1375         /* Store the state so we can free it later. */
1376         handle->cpu_va = va;
1377         handle->dma_pa = dma_pa;
1378         handle->size   = size;
1379
1380
1381         reg = kbase_alloc_free_region(kctx, 0, pages, KBASE_REG_ZONE_SAME_VA);
1382         if (!reg)
1383                 goto no_reg;
1384
1385         reg->flags &= ~KBASE_REG_FREE;
1386         kbase_update_region_flags(reg, flags);
1387
1388         reg->alloc = kbase_alloc_create(pages, KBASE_MEM_TYPE_RAW);
1389         if (IS_ERR_OR_NULL(reg->alloc))
1390                 goto no_alloc;
1391
1392         page_array = kbase_get_phy_pages(reg);
1393
1394         for (i = 0; i < pages; i++) {
1395                 page_array[i] = dma_pa + (i << PAGE_SHIFT);
1396         }
1397
1398         reg->alloc->nents = pages;
1399
1400         kbase_gpu_vm_lock(kctx);
1401         res = kbase_gpu_mmap(kctx, reg, (uintptr_t) va, pages, 1);
1402         kbase_gpu_vm_unlock(kctx);
1403         if (res)
1404                 goto no_mmap;
1405
1406         return va;
1407
1408 no_mmap:
1409         kbase_mem_phy_alloc_put(reg->alloc);
1410 no_alloc:
1411         kfree(reg);
1412 no_reg:
1413 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
1414         dma_free_attrs(kctx->kbdev->osdev.dev, size, va, dma_pa, &attrs);
1415 #else
1416         dma_free_writecombine(kctx->kbdev->osdev.dev, size, va, dma_pa);
1417 #endif
1418 err:
1419         return NULL;
1420 }
1421 KBASE_EXPORT_SYMBOL(kbase_va_alloc);
1422
1423 void kbase_va_free(kbase_context *kctx, kbase_hwc_dma_mapping *handle)
1424 {
1425         struct kbase_va_region *reg;
1426         mali_error err;
1427 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
1428         DEFINE_DMA_ATTRS(attrs);
1429 #endif
1430
1431         KBASE_DEBUG_ASSERT(kctx != NULL);
1432         KBASE_DEBUG_ASSERT(handle->cpu_va != NULL);
1433
1434         kbase_gpu_vm_lock(kctx);
1435         reg = kbase_region_tracker_find_region_base_address(kctx, (uintptr_t)handle->cpu_va);
1436         KBASE_DEBUG_ASSERT(reg);
1437         err = kbase_gpu_munmap(kctx, reg);
1438         kbase_gpu_vm_unlock(kctx);
1439         KBASE_DEBUG_ASSERT(err == MALI_ERROR_NONE);
1440
1441         kbase_mem_phy_alloc_put(reg->alloc);
1442         kfree(reg);
1443
1444 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0))
1445         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
1446         dma_free_attrs(kctx->kbdev->osdev.dev, handle->size,
1447                         handle->cpu_va, handle->dma_pa, &attrs);
1448 #else
1449         dma_free_writecombine(kctx->kbdev->osdev.dev, handle->size,
1450                                 handle->cpu_va, handle->dma_pa);
1451 #endif
1452 }
1453 KBASE_EXPORT_SYMBOL(kbase_va_free);
1454