diff options
author | Konsta Holtta <kholtta@nvidia.com> | 2017-03-14 07:47:04 -0400 |
---|---|---|
committer | mobile promotions <svcmobile_promotions@nvidia.com> | 2017-03-21 18:01:47 -0400 |
commit | 8f3875393e7a6bd0fc03afdb1fa99b7e33b71576 (patch) | |
tree | 7ee7b2da741fae7d06eeb367db2b14d8f78f0f55 | |
parent | 79658ac5cb22cc68a2d24d964379a606086c8b39 (diff) |
gpu: nvgpu: abstract away dma alloc attrs
Don't use enum dma_attr in the gk20a_gmmu_alloc_attr* functions, but
define nvgpu-internal flags for no kernel mapping, force contiguous, and
read only modes. Store the flags in the allocated struct mem_desc and
only use gk20a_gmmu_free, remove gk20a_gmmu_free_attr. This helps in OS
abstraction. Rename the notion of attr to flags.
Add implicit NVGPU_DMA_NO_KERNEL_MAPPING to all vidmem buffers
allocated via gk20a_gmmu_alloc_vid for consistency.
Fix a bug in gk20a_gmmu_alloc_map_attr that dropped the attr
parameter accidentally.
Bug 1853519
Change-Id: I1ff67dff9fc425457ae445ce4976a780eb4dcc9f
Signed-off-by: Konsta Holtta <kholtta@nvidia.com>
Reviewed-on: http://git-master/r/1321101
Reviewed-by: svccoveritychecker <svccoveritychecker@nvidia.com>
Reviewed-by: Alex Waterman <alexw@nvidia.com>
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>
-rw-r--r-- | drivers/gpu/nvgpu/common/semaphore.c | 2 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/gr_gk20a.c | 28 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/ltc_common.c | 4 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/mm_gk20a.c | 151 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/mm_gk20a.h | 39 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/platform_gk20a.h | 2 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gk20a/pmu_gk20a.c | 2 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gm20b/acr_gm20b.c | 4 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/gp106/acr_gp106.c | 8 | ||||
-rw-r--r-- | drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c | 4 |
10 files changed, 131 insertions, 113 deletions
diff --git a/drivers/gpu/nvgpu/common/semaphore.c b/drivers/gpu/nvgpu/common/semaphore.c index e4099bd1..ff86ada9 100644 --- a/drivers/gpu/nvgpu/common/semaphore.c +++ b/drivers/gpu/nvgpu/common/semaphore.c | |||
@@ -49,7 +49,7 @@ static int __nvgpu_semaphore_sea_grow(struct nvgpu_semaphore_sea *sea) | |||
49 | 49 | ||
50 | __lock_sema_sea(sea); | 50 | __lock_sema_sea(sea); |
51 | 51 | ||
52 | ret = gk20a_gmmu_alloc_attr_sys(gk20a, DMA_ATTR_NO_KERNEL_MAPPING, | 52 | ret = gk20a_gmmu_alloc_flags_sys(gk20a, NVGPU_DMA_NO_KERNEL_MAPPING, |
53 | PAGE_SIZE * SEMAPHORE_POOL_COUNT, | 53 | PAGE_SIZE * SEMAPHORE_POOL_COUNT, |
54 | &sea->sea_mem); | 54 | &sea->sea_mem); |
55 | if (ret) | 55 | if (ret) |
diff --git a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c index 2451786b..5a76822f 100644 --- a/drivers/gpu/nvgpu/gk20a/gr_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/gr_gk20a.c | |||
@@ -1936,8 +1936,8 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g, | |||
1936 | if (enable_hwpm_ctxsw) { | 1936 | if (enable_hwpm_ctxsw) { |
1937 | /* Allocate buffer if necessary */ | 1937 | /* Allocate buffer if necessary */ |
1938 | if (pm_ctx->mem.gpu_va == 0) { | 1938 | if (pm_ctx->mem.gpu_va == 0) { |
1939 | ret = gk20a_gmmu_alloc_attr_sys(g, | 1939 | ret = gk20a_gmmu_alloc_flags_sys(g, |
1940 | DMA_ATTR_NO_KERNEL_MAPPING, | 1940 | NVGPU_DMA_NO_KERNEL_MAPPING, |
1941 | g->gr.ctx_vars.pm_ctxsw_image_size, | 1941 | g->gr.ctx_vars.pm_ctxsw_image_size, |
1942 | &pm_ctx->mem); | 1942 | &pm_ctx->mem); |
1943 | if (ret) { | 1943 | if (ret) { |
@@ -1956,8 +1956,7 @@ int gr_gk20a_update_hwpm_ctxsw_mode(struct gk20a *g, | |||
1956 | if (!pm_ctx->mem.gpu_va) { | 1956 | if (!pm_ctx->mem.gpu_va) { |
1957 | gk20a_err(dev_from_gk20a(g), | 1957 | gk20a_err(dev_from_gk20a(g), |
1958 | "failed to map pm ctxt buffer"); | 1958 | "failed to map pm ctxt buffer"); |
1959 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, | 1959 | gk20a_gmmu_free(g, &pm_ctx->mem); |
1960 | &pm_ctx->mem); | ||
1961 | c->g->ops.fifo.enable_channel(c); | 1960 | c->g->ops.fifo.enable_channel(c); |
1962 | return -ENOMEM; | 1961 | return -ENOMEM; |
1963 | } | 1962 | } |
@@ -2017,7 +2016,7 @@ clean_up_mem: | |||
2017 | cleanup_pm_buf: | 2016 | cleanup_pm_buf: |
2018 | gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, pm_ctx->mem.size, | 2017 | gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, pm_ctx->mem.size, |
2019 | gk20a_mem_flag_none); | 2018 | gk20a_mem_flag_none); |
2020 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &pm_ctx->mem); | 2019 | gk20a_gmmu_free(g, &pm_ctx->mem); |
2021 | memset(&pm_ctx->mem, 0, sizeof(struct mem_desc)); | 2020 | memset(&pm_ctx->mem, 0, sizeof(struct mem_desc)); |
2022 | 2021 | ||
2023 | gk20a_enable_channel_tsg(g, c); | 2022 | gk20a_enable_channel_tsg(g, c); |
@@ -2699,7 +2698,7 @@ static void gk20a_gr_destroy_ctx_buffer(struct gk20a *g, | |||
2699 | { | 2698 | { |
2700 | if (!desc) | 2699 | if (!desc) |
2701 | return; | 2700 | return; |
2702 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &desc->mem); | 2701 | gk20a_gmmu_free(g, &desc->mem); |
2703 | desc->destroy = NULL; | 2702 | desc->destroy = NULL; |
2704 | } | 2703 | } |
2705 | 2704 | ||
@@ -2709,7 +2708,7 @@ static int gk20a_gr_alloc_ctx_buffer(struct gk20a *g, | |||
2709 | { | 2708 | { |
2710 | int err = 0; | 2709 | int err = 0; |
2711 | 2710 | ||
2712 | err = gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING, | 2711 | err = gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_NO_KERNEL_MAPPING, |
2713 | size, &desc->mem); | 2712 | size, &desc->mem); |
2714 | if (err) | 2713 | if (err) |
2715 | return err; | 2714 | return err; |
@@ -2952,7 +2951,7 @@ int gr_gk20a_alloc_gr_ctx(struct gk20a *g, | |||
2952 | if (!gr_ctx) | 2951 | if (!gr_ctx) |
2953 | return -ENOMEM; | 2952 | return -ENOMEM; |
2954 | 2953 | ||
2955 | err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, | 2954 | err = gk20a_gmmu_alloc_flags(g, NVGPU_DMA_NO_KERNEL_MAPPING, |
2956 | gr->ctx_vars.buffer_total_size, | 2955 | gr->ctx_vars.buffer_total_size, |
2957 | &gr_ctx->mem); | 2956 | &gr_ctx->mem); |
2958 | if (err) | 2957 | if (err) |
@@ -2972,7 +2971,7 @@ int gr_gk20a_alloc_gr_ctx(struct gk20a *g, | |||
2972 | return 0; | 2971 | return 0; |
2973 | 2972 | ||
2974 | err_free_mem: | 2973 | err_free_mem: |
2975 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &gr_ctx->mem); | 2974 | gk20a_gmmu_free(g, &gr_ctx->mem); |
2976 | err_free_ctx: | 2975 | err_free_ctx: |
2977 | kfree(gr_ctx); | 2976 | kfree(gr_ctx); |
2978 | gr_ctx = NULL; | 2977 | gr_ctx = NULL; |
@@ -3021,7 +3020,7 @@ void gr_gk20a_free_gr_ctx(struct gk20a *g, | |||
3021 | 3020 | ||
3022 | gk20a_gmmu_unmap(vm, gr_ctx->mem.gpu_va, | 3021 | gk20a_gmmu_unmap(vm, gr_ctx->mem.gpu_va, |
3023 | gr_ctx->mem.size, gk20a_mem_flag_none); | 3022 | gr_ctx->mem.size, gk20a_mem_flag_none); |
3024 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &gr_ctx->mem); | 3023 | gk20a_gmmu_free(g, &gr_ctx->mem); |
3025 | kfree(gr_ctx); | 3024 | kfree(gr_ctx); |
3026 | } | 3025 | } |
3027 | 3026 | ||
@@ -3050,7 +3049,7 @@ static int gr_gk20a_alloc_channel_patch_ctx(struct gk20a *g, | |||
3050 | 3049 | ||
3051 | gk20a_dbg_fn(""); | 3050 | gk20a_dbg_fn(""); |
3052 | 3051 | ||
3053 | err = gk20a_gmmu_alloc_map_attr_sys(ch_vm, DMA_ATTR_NO_KERNEL_MAPPING, | 3052 | err = gk20a_gmmu_alloc_map_flags_sys(ch_vm, NVGPU_DMA_NO_KERNEL_MAPPING, |
3054 | 128 * sizeof(u32), &patch_ctx->mem); | 3053 | 128 * sizeof(u32), &patch_ctx->mem); |
3055 | if (err) | 3054 | if (err) |
3056 | return err; | 3055 | return err; |
@@ -3070,7 +3069,7 @@ static void gr_gk20a_free_channel_patch_ctx(struct channel_gk20a *c) | |||
3070 | gk20a_gmmu_unmap(c->vm, patch_ctx->mem.gpu_va, | 3069 | gk20a_gmmu_unmap(c->vm, patch_ctx->mem.gpu_va, |
3071 | patch_ctx->mem.size, gk20a_mem_flag_none); | 3070 | patch_ctx->mem.size, gk20a_mem_flag_none); |
3072 | 3071 | ||
3073 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &patch_ctx->mem); | 3072 | gk20a_gmmu_free(g, &patch_ctx->mem); |
3074 | patch_ctx->data_count = 0; | 3073 | patch_ctx->data_count = 0; |
3075 | } | 3074 | } |
3076 | 3075 | ||
@@ -3085,7 +3084,7 @@ static void gr_gk20a_free_channel_pm_ctx(struct channel_gk20a *c) | |||
3085 | gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, | 3084 | gk20a_gmmu_unmap(c->vm, pm_ctx->mem.gpu_va, |
3086 | pm_ctx->mem.size, gk20a_mem_flag_none); | 3085 | pm_ctx->mem.size, gk20a_mem_flag_none); |
3087 | 3086 | ||
3088 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, &pm_ctx->mem); | 3087 | gk20a_gmmu_free(g, &pm_ctx->mem); |
3089 | } | 3088 | } |
3090 | } | 3089 | } |
3091 | 3090 | ||
@@ -3365,8 +3364,7 @@ static void gk20a_remove_gr_support(struct gr_gk20a *gr) | |||
3365 | gk20a_gmmu_free(g, &gr->mmu_wr_mem); | 3364 | gk20a_gmmu_free(g, &gr->mmu_wr_mem); |
3366 | gk20a_gmmu_free(g, &gr->mmu_rd_mem); | 3365 | gk20a_gmmu_free(g, &gr->mmu_rd_mem); |
3367 | 3366 | ||
3368 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, | 3367 | gk20a_gmmu_free(g, &gr->compbit_store.mem); |
3369 | &gr->compbit_store.mem); | ||
3370 | 3368 | ||
3371 | memset(&gr->compbit_store, 0, sizeof(struct compbit_store_desc)); | 3369 | memset(&gr->compbit_store, 0, sizeof(struct compbit_store_desc)); |
3372 | 3370 | ||
diff --git a/drivers/gpu/nvgpu/gk20a/ltc_common.c b/drivers/gpu/nvgpu/gk20a/ltc_common.c index 13819872..7c4db84e 100644 --- a/drivers/gpu/nvgpu/gk20a/ltc_common.c +++ b/drivers/gpu/nvgpu/gk20a/ltc_common.c | |||
@@ -68,7 +68,7 @@ static int gk20a_ltc_alloc_phys_cbc(struct gk20a *g, | |||
68 | { | 68 | { |
69 | struct gr_gk20a *gr = &g->gr; | 69 | struct gr_gk20a *gr = &g->gr; |
70 | 70 | ||
71 | return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_FORCE_CONTIGUOUS, | 71 | return gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_FORCE_CONTIGUOUS, |
72 | compbit_backing_size, | 72 | compbit_backing_size, |
73 | &gr->compbit_store.mem); | 73 | &gr->compbit_store.mem); |
74 | } | 74 | } |
@@ -78,7 +78,7 @@ static int gk20a_ltc_alloc_virt_cbc(struct gk20a *g, | |||
78 | { | 78 | { |
79 | struct gr_gk20a *gr = &g->gr; | 79 | struct gr_gk20a *gr = &g->gr; |
80 | 80 | ||
81 | return gk20a_gmmu_alloc_attr_sys(g, DMA_ATTR_NO_KERNEL_MAPPING, | 81 | return gk20a_gmmu_alloc_flags_sys(g, NVGPU_DMA_NO_KERNEL_MAPPING, |
82 | compbit_backing_size, | 82 | compbit_backing_size, |
83 | &gr->compbit_store.mem); | 83 | &gr->compbit_store.mem); |
84 | } | 84 | } |
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c index 32d1f32f..b9678fbb 100644 --- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.c | |||
@@ -25,6 +25,8 @@ | |||
25 | #include <soc/tegra/chip-id.h> | 25 | #include <soc/tegra/chip-id.h> |
26 | #include <linux/vmalloc.h> | 26 | #include <linux/vmalloc.h> |
27 | #include <linux/dma-buf.h> | 27 | #include <linux/dma-buf.h> |
28 | #include <linux/dma-mapping.h> | ||
29 | #include <linux/dma-attrs.h> | ||
28 | #include <linux/lcm.h> | 30 | #include <linux/lcm.h> |
29 | #include <linux/fdtable.h> | 31 | #include <linux/fdtable.h> |
30 | #include <uapi/linux/nvgpu.h> | 32 | #include <uapi/linux/nvgpu.h> |
@@ -1253,7 +1255,7 @@ static int alloc_gmmu_pages(struct vm_gk20a *vm, u32 order, | |||
1253 | if (IS_ENABLED(CONFIG_ARM64)) | 1255 | if (IS_ENABLED(CONFIG_ARM64)) |
1254 | err = gk20a_gmmu_alloc(g, len, &entry->mem); | 1256 | err = gk20a_gmmu_alloc(g, len, &entry->mem); |
1255 | else | 1257 | else |
1256 | err = gk20a_gmmu_alloc_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, | 1258 | err = gk20a_gmmu_alloc_flags(g, NVGPU_DMA_NO_KERNEL_MAPPING, |
1257 | len, &entry->mem); | 1259 | len, &entry->mem); |
1258 | 1260 | ||
1259 | 1261 | ||
@@ -1284,15 +1286,7 @@ void free_gmmu_pages(struct vm_gk20a *vm, | |||
1284 | return; | 1286 | return; |
1285 | } | 1287 | } |
1286 | 1288 | ||
1287 | /* | 1289 | gk20a_gmmu_free(g, &entry->mem); |
1288 | * On arm32 we're limited by vmalloc space, so we do not map pages by | ||
1289 | * default. | ||
1290 | */ | ||
1291 | if (IS_ENABLED(CONFIG_ARM64)) | ||
1292 | gk20a_gmmu_free(g, &entry->mem); | ||
1293 | else | ||
1294 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, | ||
1295 | &entry->mem); | ||
1296 | } | 1290 | } |
1297 | 1291 | ||
1298 | int map_gmmu_pages(struct gk20a *g, struct gk20a_mm_entry *entry) | 1292 | int map_gmmu_pages(struct gk20a *g, struct gk20a_mm_entry *entry) |
@@ -2910,14 +2904,14 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm, | |||
2910 | 2904 | ||
2911 | int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem) | 2905 | int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem) |
2912 | { | 2906 | { |
2913 | return gk20a_gmmu_alloc_attr(g, 0, size, mem); | 2907 | return gk20a_gmmu_alloc_flags(g, 0, size, mem); |
2914 | } | 2908 | } |
2915 | 2909 | ||
2916 | int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size, | 2910 | int gk20a_gmmu_alloc_flags(struct gk20a *g, unsigned long flags, size_t size, |
2917 | struct mem_desc *mem) | 2911 | struct mem_desc *mem) |
2918 | { | 2912 | { |
2919 | if (g->mm.vidmem_is_vidmem) { | 2913 | if (g->mm.vidmem_is_vidmem) { |
2920 | int err = gk20a_gmmu_alloc_attr_vid(g, attr, size, mem); | 2914 | int err = gk20a_gmmu_alloc_flags_vid(g, flags, size, mem); |
2921 | 2915 | ||
2922 | if (!err) | 2916 | if (!err) |
2923 | return 0; | 2917 | return 0; |
@@ -2927,15 +2921,26 @@ int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size, | |||
2927 | */ | 2921 | */ |
2928 | } | 2922 | } |
2929 | 2923 | ||
2930 | return gk20a_gmmu_alloc_attr_sys(g, attr, size, mem); | 2924 | return gk20a_gmmu_alloc_flags_sys(g, flags, size, mem); |
2931 | } | 2925 | } |
2932 | 2926 | ||
2933 | int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem) | 2927 | int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem) |
2934 | { | 2928 | { |
2935 | return gk20a_gmmu_alloc_attr_sys(g, 0, size, mem); | 2929 | return gk20a_gmmu_alloc_flags_sys(g, 0, size, mem); |
2936 | } | 2930 | } |
2937 | 2931 | ||
2938 | int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, | 2932 | static void gk20a_dma_flags_to_attrs(struct dma_attrs *attrs, |
2933 | unsigned long flags) | ||
2934 | { | ||
2935 | if (flags & NVGPU_DMA_NO_KERNEL_MAPPING) | ||
2936 | dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs); | ||
2937 | if (flags & NVGPU_DMA_FORCE_CONTIGUOUS) | ||
2938 | dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs); | ||
2939 | if (flags & NVGPU_DMA_READ_ONLY) | ||
2940 | dma_set_attr(DMA_ATTR_READ_ONLY, attrs); | ||
2941 | } | ||
2942 | |||
2943 | int gk20a_gmmu_alloc_flags_sys(struct gk20a *g, unsigned long flags, | ||
2939 | size_t size, struct mem_desc *mem) | 2944 | size_t size, struct mem_desc *mem) |
2940 | { | 2945 | { |
2941 | struct device *d = dev_from_gk20a(g); | 2946 | struct device *d = dev_from_gk20a(g); |
@@ -2944,17 +2949,19 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, | |||
2944 | 2949 | ||
2945 | gk20a_dbg_fn(""); | 2950 | gk20a_dbg_fn(""); |
2946 | 2951 | ||
2947 | if (attr) { | 2952 | if (flags) { |
2948 | DEFINE_DMA_ATTRS(attrs); | 2953 | DEFINE_DMA_ATTRS(dma_attrs); |
2949 | dma_set_attr(attr, &attrs); | 2954 | |
2950 | if (attr == DMA_ATTR_NO_KERNEL_MAPPING) { | 2955 | gk20a_dma_flags_to_attrs(&dma_attrs, flags); |
2956 | |||
2957 | if (flags & NVGPU_DMA_NO_KERNEL_MAPPING) { | ||
2951 | mem->pages = dma_alloc_attrs(d, | 2958 | mem->pages = dma_alloc_attrs(d, |
2952 | size, &iova, GFP_KERNEL, &attrs); | 2959 | size, &iova, GFP_KERNEL, &dma_attrs); |
2953 | if (!mem->pages) | 2960 | if (!mem->pages) |
2954 | return -ENOMEM; | 2961 | return -ENOMEM; |
2955 | } else { | 2962 | } else { |
2956 | mem->cpu_va = dma_alloc_attrs(d, | 2963 | mem->cpu_va = dma_alloc_attrs(d, |
2957 | size, &iova, GFP_KERNEL, &attrs); | 2964 | size, &iova, GFP_KERNEL, &dma_attrs); |
2958 | if (!mem->cpu_va) | 2965 | if (!mem->cpu_va) |
2959 | return -ENOMEM; | 2966 | return -ENOMEM; |
2960 | } | 2967 | } |
@@ -2964,7 +2971,7 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, | |||
2964 | return -ENOMEM; | 2971 | return -ENOMEM; |
2965 | } | 2972 | } |
2966 | 2973 | ||
2967 | if (attr == DMA_ATTR_NO_KERNEL_MAPPING) | 2974 | if (flags & NVGPU_DMA_NO_KERNEL_MAPPING) |
2968 | err = gk20a_get_sgtable_from_pages(d, &mem->sgt, mem->pages, | 2975 | err = gk20a_get_sgtable_from_pages(d, &mem->sgt, mem->pages, |
2969 | iova, size); | 2976 | iova, size); |
2970 | else { | 2977 | else { |
@@ -2976,6 +2983,7 @@ int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, | |||
2976 | 2983 | ||
2977 | mem->size = size; | 2984 | mem->size = size; |
2978 | mem->aperture = APERTURE_SYSMEM; | 2985 | mem->aperture = APERTURE_SYSMEM; |
2986 | mem->flags = flags; | ||
2979 | 2987 | ||
2980 | gk20a_dbg_fn("done"); | 2988 | gk20a_dbg_fn("done"); |
2981 | 2989 | ||
@@ -2988,31 +2996,28 @@ fail_free: | |||
2988 | return err; | 2996 | return err; |
2989 | } | 2997 | } |
2990 | 2998 | ||
2991 | static void gk20a_gmmu_free_attr_sys(struct gk20a *g, enum dma_attr attr, | 2999 | static void gk20a_gmmu_free_sys(struct gk20a *g, struct mem_desc *mem) |
2992 | struct mem_desc *mem) | ||
2993 | { | 3000 | { |
2994 | struct device *d = dev_from_gk20a(g); | 3001 | struct device *d = dev_from_gk20a(g); |
2995 | 3002 | ||
2996 | if (mem->cpu_va || mem->pages) { | 3003 | if (mem->cpu_va || mem->pages) { |
2997 | if (attr) { | 3004 | if (mem->flags) { |
2998 | DEFINE_DMA_ATTRS(attrs); | 3005 | DEFINE_DMA_ATTRS(dma_attrs); |
2999 | dma_set_attr(attr, &attrs); | 3006 | |
3000 | if (attr == DMA_ATTR_NO_KERNEL_MAPPING) { | 3007 | gk20a_dma_flags_to_attrs(&dma_attrs, mem->flags); |
3001 | if (mem->pages) | 3008 | |
3002 | dma_free_attrs(d, mem->size, mem->pages, | 3009 | if (mem->flags & NVGPU_DMA_NO_KERNEL_MAPPING) { |
3003 | sg_dma_address(mem->sgt->sgl), | 3010 | dma_free_attrs(d, mem->size, mem->pages, |
3004 | &attrs); | 3011 | sg_dma_address(mem->sgt->sgl), |
3012 | &dma_attrs); | ||
3005 | } else { | 3013 | } else { |
3006 | if (mem->cpu_va) | 3014 | dma_free_attrs(d, mem->size, mem->cpu_va, |
3007 | dma_free_attrs(d, mem->size, | 3015 | sg_dma_address(mem->sgt->sgl), |
3008 | mem->cpu_va, | 3016 | &dma_attrs); |
3009 | sg_dma_address(mem->sgt->sgl), | ||
3010 | &attrs); | ||
3011 | } | 3017 | } |
3012 | } else { | 3018 | } else { |
3013 | if (mem->cpu_va) | 3019 | dma_free_coherent(d, mem->size, mem->cpu_va, |
3014 | dma_free_coherent(d, mem->size, mem->cpu_va, | 3020 | sg_dma_address(mem->sgt->sgl)); |
3015 | sg_dma_address(mem->sgt->sgl)); | ||
3016 | } | 3021 | } |
3017 | mem->cpu_va = NULL; | 3022 | mem->cpu_va = NULL; |
3018 | mem->pages = NULL; | 3023 | mem->pages = NULL; |
@@ -3089,13 +3094,14 @@ static int gk20a_gmmu_clear_vidmem_mem(struct gk20a *g, struct mem_desc *mem) | |||
3089 | 3094 | ||
3090 | int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem) | 3095 | int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem) |
3091 | { | 3096 | { |
3092 | return gk20a_gmmu_alloc_attr_vid(g, 0, size, mem); | 3097 | return gk20a_gmmu_alloc_flags_vid(g, |
3098 | NVGPU_DMA_NO_KERNEL_MAPPING, size, mem); | ||
3093 | } | 3099 | } |
3094 | 3100 | ||
3095 | int gk20a_gmmu_alloc_attr_vid(struct gk20a *g, enum dma_attr attr, | 3101 | int gk20a_gmmu_alloc_flags_vid(struct gk20a *g, unsigned long flags, |
3096 | size_t size, struct mem_desc *mem) | 3102 | size_t size, struct mem_desc *mem) |
3097 | { | 3103 | { |
3098 | return gk20a_gmmu_alloc_attr_vid_at(g, attr, size, mem, 0); | 3104 | return gk20a_gmmu_alloc_flags_vid_at(g, flags, size, mem, 0); |
3099 | } | 3105 | } |
3100 | 3106 | ||
3101 | #if defined(CONFIG_GK20A_VIDMEM) | 3107 | #if defined(CONFIG_GK20A_VIDMEM) |
@@ -3113,7 +3119,7 @@ static u64 __gk20a_gmmu_alloc(struct nvgpu_allocator *allocator, dma_addr_t at, | |||
3113 | } | 3119 | } |
3114 | #endif | 3120 | #endif |
3115 | 3121 | ||
3116 | int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr, | 3122 | int gk20a_gmmu_alloc_flags_vid_at(struct gk20a *g, unsigned long flags, |
3117 | size_t size, struct mem_desc *mem, dma_addr_t at) | 3123 | size_t size, struct mem_desc *mem, dma_addr_t at) |
3118 | { | 3124 | { |
3119 | #if defined(CONFIG_GK20A_VIDMEM) | 3125 | #if defined(CONFIG_GK20A_VIDMEM) |
@@ -3129,9 +3135,11 @@ int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr, | |||
3129 | if (!nvgpu_alloc_initialized(&g->mm.vidmem.allocator)) | 3135 | if (!nvgpu_alloc_initialized(&g->mm.vidmem.allocator)) |
3130 | return -ENOSYS; | 3136 | return -ENOSYS; |
3131 | 3137 | ||
3132 | /* we don't support dma attributes here, except that kernel mappings | 3138 | /* |
3133 | * are not done anyway */ | 3139 | * Our own allocator doesn't have any flags yet, and we can't |
3134 | WARN_ON(attr != 0 && attr != DMA_ATTR_NO_KERNEL_MAPPING); | 3140 | * kernel-map these, so require explicit flags. |
3141 | */ | ||
3142 | WARN_ON(flags != NVGPU_DMA_NO_KERNEL_MAPPING); | ||
3135 | 3143 | ||
3136 | nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex); | 3144 | nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex); |
3137 | before_pending = atomic64_read(&g->mm.vidmem.bytes_pending); | 3145 | before_pending = atomic64_read(&g->mm.vidmem.bytes_pending); |
@@ -3186,12 +3194,14 @@ fail_physfree: | |||
3186 | #endif | 3194 | #endif |
3187 | } | 3195 | } |
3188 | 3196 | ||
3189 | static void gk20a_gmmu_free_attr_vid(struct gk20a *g, enum dma_attr attr, | 3197 | static void gk20a_gmmu_free_vid(struct gk20a *g, struct mem_desc *mem) |
3190 | struct mem_desc *mem) | ||
3191 | { | 3198 | { |
3192 | #if defined(CONFIG_GK20A_VIDMEM) | 3199 | #if defined(CONFIG_GK20A_VIDMEM) |
3193 | bool was_empty; | 3200 | bool was_empty; |
3194 | 3201 | ||
3202 | /* Sanity check - only this supported when allocating. */ | ||
3203 | WARN_ON(mem->flags != NVGPU_DMA_NO_KERNEL_MAPPING); | ||
3204 | |||
3195 | if (mem->user_mem) { | 3205 | if (mem->user_mem) { |
3196 | nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex); | 3206 | nvgpu_mutex_acquire(&g->mm.vidmem.clear_list_mutex); |
3197 | was_empty = list_empty(&g->mm.vidmem.clear_list_head); | 3207 | was_empty = list_empty(&g->mm.vidmem.clear_list_head); |
@@ -3216,24 +3226,18 @@ static void gk20a_gmmu_free_attr_vid(struct gk20a *g, enum dma_attr attr, | |||
3216 | #endif | 3226 | #endif |
3217 | } | 3227 | } |
3218 | 3228 | ||
3219 | void gk20a_gmmu_free_attr(struct gk20a *g, enum dma_attr attr, | 3229 | void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem) |
3220 | struct mem_desc *mem) | ||
3221 | { | 3230 | { |
3222 | switch (mem->aperture) { | 3231 | switch (mem->aperture) { |
3223 | case APERTURE_SYSMEM: | 3232 | case APERTURE_SYSMEM: |
3224 | return gk20a_gmmu_free_attr_sys(g, attr, mem); | 3233 | return gk20a_gmmu_free_sys(g, mem); |
3225 | case APERTURE_VIDMEM: | 3234 | case APERTURE_VIDMEM: |
3226 | return gk20a_gmmu_free_attr_vid(g, attr, mem); | 3235 | return gk20a_gmmu_free_vid(g, mem); |
3227 | default: | 3236 | default: |
3228 | break; /* like free() on "null" memory */ | 3237 | break; /* like free() on "null" memory */ |
3229 | } | 3238 | } |
3230 | } | 3239 | } |
3231 | 3240 | ||
3232 | void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem) | ||
3233 | { | ||
3234 | return gk20a_gmmu_free_attr(g, 0, mem); | ||
3235 | } | ||
3236 | |||
3237 | /* | 3241 | /* |
3238 | * If mem is in VIDMEM, return base address in vidmem | 3242 | * If mem is in VIDMEM, return base address in vidmem |
3239 | * else return IOVA address for SYSMEM | 3243 | * else return IOVA address for SYSMEM |
@@ -3322,14 +3326,14 @@ u32 gk20a_aperture_mask(struct gk20a *g, struct mem_desc *mem, | |||
3322 | int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size, | 3326 | int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size, |
3323 | struct mem_desc *mem) | 3327 | struct mem_desc *mem) |
3324 | { | 3328 | { |
3325 | return gk20a_gmmu_alloc_map_attr(vm, 0, size, mem); | 3329 | return gk20a_gmmu_alloc_map_flags(vm, 0, size, mem); |
3326 | } | 3330 | } |
3327 | 3331 | ||
3328 | int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm, | 3332 | int gk20a_gmmu_alloc_map_flags(struct vm_gk20a *vm, unsigned long flags, |
3329 | enum dma_attr attr, size_t size, struct mem_desc *mem) | 3333 | size_t size, struct mem_desc *mem) |
3330 | { | 3334 | { |
3331 | if (vm->mm->vidmem_is_vidmem) { | 3335 | if (vm->mm->vidmem_is_vidmem) { |
3332 | int err = gk20a_gmmu_alloc_map_attr_vid(vm, 0, size, mem); | 3336 | int err = gk20a_gmmu_alloc_map_flags_vid(vm, flags, size, mem); |
3333 | 3337 | ||
3334 | if (!err) | 3338 | if (!err) |
3335 | return 0; | 3339 | return 0; |
@@ -3339,19 +3343,19 @@ int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm, | |||
3339 | */ | 3343 | */ |
3340 | } | 3344 | } |
3341 | 3345 | ||
3342 | return gk20a_gmmu_alloc_map_attr_sys(vm, 0, size, mem); | 3346 | return gk20a_gmmu_alloc_map_flags_sys(vm, flags, size, mem); |
3343 | } | 3347 | } |
3344 | 3348 | ||
3345 | int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size, | 3349 | int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size, |
3346 | struct mem_desc *mem) | 3350 | struct mem_desc *mem) |
3347 | { | 3351 | { |
3348 | return gk20a_gmmu_alloc_map_attr_sys(vm, 0, size, mem); | 3352 | return gk20a_gmmu_alloc_map_flags_sys(vm, 0, size, mem); |
3349 | } | 3353 | } |
3350 | 3354 | ||
3351 | int gk20a_gmmu_alloc_map_attr_sys(struct vm_gk20a *vm, | 3355 | int gk20a_gmmu_alloc_map_flags_sys(struct vm_gk20a *vm, unsigned long flags, |
3352 | enum dma_attr attr, size_t size, struct mem_desc *mem) | 3356 | size_t size, struct mem_desc *mem) |
3353 | { | 3357 | { |
3354 | int err = gk20a_gmmu_alloc_attr_sys(vm->mm->g, attr, size, mem); | 3358 | int err = gk20a_gmmu_alloc_flags_sys(vm->mm->g, flags, size, mem); |
3355 | 3359 | ||
3356 | if (err) | 3360 | if (err) |
3357 | return err; | 3361 | return err; |
@@ -3371,15 +3375,16 @@ fail_free: | |||
3371 | return err; | 3375 | return err; |
3372 | } | 3376 | } |
3373 | 3377 | ||
3374 | int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size, struct mem_desc *mem) | 3378 | int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size, |
3379 | struct mem_desc *mem) | ||
3375 | { | 3380 | { |
3376 | return gk20a_gmmu_alloc_map_attr_vid(vm, 0, size, mem); | 3381 | return gk20a_gmmu_alloc_map_flags_vid(vm, 0, size, mem); |
3377 | } | 3382 | } |
3378 | 3383 | ||
3379 | int gk20a_gmmu_alloc_map_attr_vid(struct vm_gk20a *vm, | 3384 | int gk20a_gmmu_alloc_map_flags_vid(struct vm_gk20a *vm, unsigned long flags, |
3380 | enum dma_attr attr, size_t size, struct mem_desc *mem) | 3385 | size_t size, struct mem_desc *mem) |
3381 | { | 3386 | { |
3382 | int err = gk20a_gmmu_alloc_attr_vid(vm->mm->g, attr, size, mem); | 3387 | int err = gk20a_gmmu_alloc_flags_vid(vm->mm->g, flags, size, mem); |
3383 | 3388 | ||
3384 | if (err) | 3389 | if (err) |
3385 | return err; | 3390 | return err; |
diff --git a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h index 0d3547e1..52e5d4db 100644 --- a/drivers/gpu/nvgpu/gk20a/mm_gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/mm_gk20a.h | |||
@@ -19,7 +19,6 @@ | |||
19 | #define MM_GK20A_H | 19 | #define MM_GK20A_H |
20 | 20 | ||
21 | #include <linux/scatterlist.h> | 21 | #include <linux/scatterlist.h> |
22 | #include <linux/dma-attrs.h> | ||
23 | #include <linux/iommu.h> | 22 | #include <linux/iommu.h> |
24 | #include <soc/tegra/chip-id.h> | 23 | #include <soc/tegra/chip-id.h> |
25 | #include <linux/vmalloc.h> | 24 | #include <linux/vmalloc.h> |
@@ -80,6 +79,7 @@ struct mem_desc { | |||
80 | struct nvgpu_allocator *allocator; /* vidmem only */ | 79 | struct nvgpu_allocator *allocator; /* vidmem only */ |
81 | struct list_head clear_list_entry; /* vidmem only */ | 80 | struct list_head clear_list_entry; /* vidmem only */ |
82 | bool skip_wmb; | 81 | bool skip_wmb; |
82 | unsigned long flags; | ||
83 | }; | 83 | }; |
84 | 84 | ||
85 | struct mem_desc_sub { | 85 | struct mem_desc_sub { |
@@ -545,40 +545,55 @@ u64 gk20a_gmmu_fixed_map(struct vm_gk20a *vm, | |||
545 | bool priv, | 545 | bool priv, |
546 | enum gk20a_aperture aperture); | 546 | enum gk20a_aperture aperture); |
547 | 547 | ||
548 | /* Flags for the below gk20a_gmmu_{alloc,alloc_map}_flags* */ | ||
549 | |||
550 | /* | ||
551 | * Don't create a virtual kernel mapping for the buffer but only allocate it; | ||
552 | * this may save some resources. The buffer can be mapped later explicitly. | ||
553 | */ | ||
554 | #define NVGPU_DMA_NO_KERNEL_MAPPING (1 << 0) | ||
555 | /* | ||
556 | * Don't allow building the buffer from individual pages but require a | ||
557 | * physically contiguous block. | ||
558 | */ | ||
559 | #define NVGPU_DMA_FORCE_CONTIGUOUS (1 << 1) | ||
560 | /* | ||
561 | * Make the mapping read-only. | ||
562 | */ | ||
563 | #define NVGPU_DMA_READ_ONLY (1 << 2) | ||
564 | |||
548 | int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size, | 565 | int gk20a_gmmu_alloc_map(struct vm_gk20a *vm, size_t size, |
549 | struct mem_desc *mem); | 566 | struct mem_desc *mem); |
550 | int gk20a_gmmu_alloc_map_attr(struct vm_gk20a *vm, enum dma_attr attr, | 567 | int gk20a_gmmu_alloc_map_flags(struct vm_gk20a *vm, unsigned long flags, |
551 | size_t size, struct mem_desc *mem); | 568 | size_t size, struct mem_desc *mem); |
552 | 569 | ||
553 | int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size, | 570 | int gk20a_gmmu_alloc_map_sys(struct vm_gk20a *vm, size_t size, |
554 | struct mem_desc *mem); | 571 | struct mem_desc *mem); |
555 | int gk20a_gmmu_alloc_map_attr_sys(struct vm_gk20a *vm, enum dma_attr attr, | 572 | int gk20a_gmmu_alloc_map_flags_sys(struct vm_gk20a *vm, unsigned long flags, |
556 | size_t size, struct mem_desc *mem); | 573 | size_t size, struct mem_desc *mem); |
557 | 574 | ||
558 | int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size, | 575 | int gk20a_gmmu_alloc_map_vid(struct vm_gk20a *vm, size_t size, |
559 | struct mem_desc *mem); | 576 | struct mem_desc *mem); |
560 | int gk20a_gmmu_alloc_map_attr_vid(struct vm_gk20a *vm, enum dma_attr attr, | 577 | int gk20a_gmmu_alloc_map_flags_vid(struct vm_gk20a *vm, unsigned long flags, |
561 | size_t size, struct mem_desc *mem); | 578 | size_t size, struct mem_desc *mem); |
562 | 579 | ||
563 | void gk20a_gmmu_unmap_free(struct vm_gk20a *vm, struct mem_desc *mem); | 580 | void gk20a_gmmu_unmap_free(struct vm_gk20a *vm, struct mem_desc *mem); |
564 | 581 | ||
565 | int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem); | 582 | int gk20a_gmmu_alloc(struct gk20a *g, size_t size, struct mem_desc *mem); |
566 | int gk20a_gmmu_alloc_attr(struct gk20a *g, enum dma_attr attr, size_t size, | 583 | int gk20a_gmmu_alloc_flags(struct gk20a *g, unsigned long flags, size_t size, |
567 | struct mem_desc *mem); | 584 | struct mem_desc *mem); |
568 | 585 | ||
569 | int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem); | 586 | int gk20a_gmmu_alloc_sys(struct gk20a *g, size_t size, struct mem_desc *mem); |
570 | int gk20a_gmmu_alloc_attr_sys(struct gk20a *g, enum dma_attr attr, size_t size, | 587 | int gk20a_gmmu_alloc_flags_sys(struct gk20a *g, unsigned long flags, |
571 | struct mem_desc *mem); | 588 | size_t size, struct mem_desc *mem); |
572 | 589 | ||
573 | int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem); | 590 | int gk20a_gmmu_alloc_vid(struct gk20a *g, size_t size, struct mem_desc *mem); |
574 | int gk20a_gmmu_alloc_attr_vid(struct gk20a *g, enum dma_attr attr, size_t size, | 591 | int gk20a_gmmu_alloc_flags_vid(struct gk20a *g, unsigned long flags, |
575 | struct mem_desc *mem); | 592 | size_t size, struct mem_desc *mem); |
576 | int gk20a_gmmu_alloc_attr_vid_at(struct gk20a *g, enum dma_attr attr, | 593 | int gk20a_gmmu_alloc_flags_vid_at(struct gk20a *g, unsigned long flags, |
577 | size_t size, struct mem_desc *mem, dma_addr_t at); | 594 | size_t size, struct mem_desc *mem, dma_addr_t at); |
578 | 595 | ||
579 | void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem); | 596 | void gk20a_gmmu_free(struct gk20a *g, struct mem_desc *mem); |
580 | void gk20a_gmmu_free_attr(struct gk20a *g, enum dma_attr attr, | ||
581 | struct mem_desc *mem); | ||
582 | 597 | ||
583 | static inline phys_addr_t gk20a_mem_phys(struct mem_desc *mem) | 598 | static inline phys_addr_t gk20a_mem_phys(struct mem_desc *mem) |
584 | { | 599 | { |
diff --git a/drivers/gpu/nvgpu/gk20a/platform_gk20a.h b/drivers/gpu/nvgpu/gk20a/platform_gk20a.h index b23d0091..99ea1bb7 100644 --- a/drivers/gpu/nvgpu/gk20a/platform_gk20a.h +++ b/drivers/gpu/nvgpu/gk20a/platform_gk20a.h | |||
@@ -17,7 +17,6 @@ | |||
17 | #define _GK20A_PLATFORM_H_ | 17 | #define _GK20A_PLATFORM_H_ |
18 | 18 | ||
19 | #include <linux/device.h> | 19 | #include <linux/device.h> |
20 | #include <linux/dma-attrs.h> | ||
21 | #include <linux/version.h> | 20 | #include <linux/version.h> |
22 | 21 | ||
23 | #include <nvgpu/lock.h> | 22 | #include <nvgpu/lock.h> |
@@ -33,7 +32,6 @@ struct secure_page_buffer { | |||
33 | void (*destroy)(struct device *, struct secure_page_buffer *); | 32 | void (*destroy)(struct device *, struct secure_page_buffer *); |
34 | size_t size; | 33 | size_t size; |
35 | u64 iova; | 34 | u64 iova; |
36 | struct dma_attrs attrs; | ||
37 | }; | 35 | }; |
38 | 36 | ||
39 | struct gk20a_platform { | 37 | struct gk20a_platform { |
diff --git a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c index c7e68f44..ee995d44 100644 --- a/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c +++ b/drivers/gpu/nvgpu/gk20a/pmu_gk20a.c | |||
@@ -4746,7 +4746,7 @@ int gk20a_pmu_sysmem_surface_alloc(struct gk20a *g, struct mem_desc *mem, | |||
4746 | 4746 | ||
4747 | void gk20a_pmu_surface_free(struct gk20a *g, struct mem_desc *mem) | 4747 | void gk20a_pmu_surface_free(struct gk20a *g, struct mem_desc *mem) |
4748 | { | 4748 | { |
4749 | gk20a_gmmu_free_attr(g, DMA_ATTR_NO_KERNEL_MAPPING, mem); | 4749 | gk20a_gmmu_free(g, mem); |
4750 | memset(mem, 0, sizeof(struct mem_desc)); | 4750 | memset(mem, 0, sizeof(struct mem_desc)); |
4751 | } | 4751 | } |
4752 | 4752 | ||
diff --git a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c index bcad4437..e613e65f 100644 --- a/drivers/gpu/nvgpu/gm20b/acr_gm20b.c +++ b/drivers/gpu/nvgpu/gm20b/acr_gm20b.c | |||
@@ -1411,8 +1411,8 @@ int pmu_exec_gen_bl(struct gk20a *g, void *desc, u8 b_wait_for_halt) | |||
1411 | /*TODO in code verify that enable PMU is done, | 1411 | /*TODO in code verify that enable PMU is done, |
1412 | scrubbing etc is done*/ | 1412 | scrubbing etc is done*/ |
1413 | /*TODO in code verify that gmmu vm init is done*/ | 1413 | /*TODO in code verify that gmmu vm init is done*/ |
1414 | err = gk20a_gmmu_alloc_attr_sys(g, | 1414 | err = gk20a_gmmu_alloc_flags_sys(g, |
1415 | DMA_ATTR_READ_ONLY, bl_sz, &acr->hsbl_ucode); | 1415 | NVGPU_DMA_READ_ONLY, bl_sz, &acr->hsbl_ucode); |
1416 | if (err) { | 1416 | if (err) { |
1417 | gk20a_err(d, "failed to allocate memory\n"); | 1417 | gk20a_err(d, "failed to allocate memory\n"); |
1418 | goto err_done; | 1418 | goto err_done; |
diff --git a/drivers/gpu/nvgpu/gp106/acr_gp106.c b/drivers/gpu/nvgpu/gp106/acr_gp106.c index f5228136..afb9ebe2 100644 --- a/drivers/gpu/nvgpu/gp106/acr_gp106.c +++ b/drivers/gpu/nvgpu/gp106/acr_gp106.c | |||
@@ -109,12 +109,14 @@ static int gp106_alloc_blob_space(struct gk20a *g, | |||
109 | * Even though this mem_desc wouldn't be used, the wpr region needs to | 109 | * Even though this mem_desc wouldn't be used, the wpr region needs to |
110 | * be reserved in the allocator. | 110 | * be reserved in the allocator. |
111 | */ | 111 | */ |
112 | err = gk20a_gmmu_alloc_attr_vid_at(g, 0, wpr_inf.size, | 112 | err = gk20a_gmmu_alloc_flags_vid_at(g, |
113 | &g->acr.wpr_dummy, wpr_inf.wpr_base); | 113 | NVGPU_DMA_NO_KERNEL_MAPPING, wpr_inf.size, |
114 | &g->acr.wpr_dummy, wpr_inf.wpr_base); | ||
114 | if (err) | 115 | if (err) |
115 | return err; | 116 | return err; |
116 | 117 | ||
117 | return gk20a_gmmu_alloc_attr_vid_at(g, 0, wpr_inf.size, mem, | 118 | return gk20a_gmmu_alloc_flags_vid_at(g, |
119 | NVGPU_DMA_NO_KERNEL_MAPPING, wpr_inf.size, mem, | ||
118 | wpr_inf.nonwpr_base); | 120 | wpr_inf.nonwpr_base); |
119 | } | 121 | } |
120 | 122 | ||
diff --git a/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c b/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c index 1b40702a..d612fcd2 100644 --- a/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c +++ b/drivers/gpu/nvgpu/tegra/linux/platform_gk20a_tegra.c | |||
@@ -95,9 +95,10 @@ static inline void __maybe_unused pmc_write(u32 val, unsigned long reg) | |||
95 | static void gk20a_tegra_secure_page_destroy(struct device *dev, | 95 | static void gk20a_tegra_secure_page_destroy(struct device *dev, |
96 | struct secure_page_buffer *secure_buffer) | 96 | struct secure_page_buffer *secure_buffer) |
97 | { | 97 | { |
98 | DEFINE_DMA_ATTRS(attrs); | ||
98 | dma_free_attrs(&tegra_vpr_dev, secure_buffer->size, | 99 | dma_free_attrs(&tegra_vpr_dev, secure_buffer->size, |
99 | (void *)(uintptr_t)secure_buffer->iova, | 100 | (void *)(uintptr_t)secure_buffer->iova, |
100 | secure_buffer->iova, &secure_buffer->attrs); | 101 | secure_buffer->iova, &attrs); |
101 | } | 102 | } |
102 | 103 | ||
103 | int gk20a_tegra_secure_page_alloc(struct device *dev) | 104 | int gk20a_tegra_secure_page_alloc(struct device *dev) |
@@ -118,7 +119,6 @@ int gk20a_tegra_secure_page_alloc(struct device *dev) | |||
118 | 119 | ||
119 | secure_buffer->size = size; | 120 | secure_buffer->size = size; |
120 | secure_buffer->iova = iova; | 121 | secure_buffer->iova = iova; |
121 | secure_buffer->attrs = attrs; | ||
122 | secure_buffer->destroy = gk20a_tegra_secure_page_destroy; | 122 | secure_buffer->destroy = gk20a_tegra_secure_page_destroy; |
123 | 123 | ||
124 | return 0; | 124 | return 0; |