diff options
Diffstat (limited to 'meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/2825-drm-amdkfd-enable-CONFIG_HSA_AMD-and-rebased-some-ch.patch')
| -rw-r--r-- | meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/2825-drm-amdkfd-enable-CONFIG_HSA_AMD-and-rebased-some-ch.patch | 756 |
1 files changed, 756 insertions, 0 deletions
diff --git a/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/2825-drm-amdkfd-enable-CONFIG_HSA_AMD-and-rebased-some-ch.patch b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/2825-drm-amdkfd-enable-CONFIG_HSA_AMD-and-rebased-some-ch.patch new file mode 100644 index 00000000..fbb450b0 --- /dev/null +++ b/meta-amd-bsp/recipes-kernel/linux/linux-yocto-4.19.8/2825-drm-amdkfd-enable-CONFIG_HSA_AMD-and-rebased-some-ch.patch @@ -0,0 +1,756 @@ +From a08e41a45d528e77adbed0f751a1ea3d9d5b8aac Mon Sep 17 00:00:00 2001 +From: Chaudhary Amit Kumar <Chaudharyamit.Kumar@amd.com> +Date: Tue, 30 Jul 2019 18:16:41 +0530 +Subject: [PATCH 2825/2940] drm/amdkfd: enable CONFIG_HSA_AMD and rebased some + change in kfd + +--- + drivers/gpu/drm/amd/amdgpu/Kconfig | 1 + + drivers/gpu/drm/amd/amdgpu/Makefile | 11 +- + drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c | 23 ++++ + drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 9 +- + .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c | 2 + + .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 121 ++++-------------- + drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c | 85 ++++++------ + drivers/gpu/drm/amd/amdkfd/kfd_device.c | 8 ++ + .../drm/amd/amdkfd/kfd_device_queue_manager.c | 7 +- + drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c | 26 +++- + drivers/gpu/drm/amd/amdkfd/kfd_module.c | 2 + + drivers/gpu/drm/amd/amdkfd/kfd_process.c | 2 +- + kernel/fork.c | 1 + + security/device_cgroup.c | 1 + + 14 files changed, 146 insertions(+), 153 deletions(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/Kconfig b/drivers/gpu/drm/amd/amdgpu/Kconfig +index 3cdee30995a1..bdb7b74f3879 100644 +--- a/drivers/gpu/drm/amd/amdgpu/Kconfig ++++ b/drivers/gpu/drm/amd/amdgpu/Kconfig +@@ -43,3 +43,4 @@ config DRM_AMDGPU_GART_DEBUGFS + + source "drivers/gpu/drm/amd/acp/Kconfig" + source "drivers/gpu/drm/amd/display/Kconfig" ++source "drivers/gpu/drm/amd/amdkfd/Kconfig" +diff --git a/drivers/gpu/drm/amd/amdgpu/Makefile b/drivers/gpu/drm/amd/amdgpu/Makefile +index 8ea52c00fc8d..3c0a4675d36c 100644 +--- a/drivers/gpu/drm/amd/amdgpu/Makefile ++++ b/drivers/gpu/drm/amd/amdgpu/Makefile +@@ -35,7 +35,8 @@ ccflags-y := -I$(FULL_AMD_PATH)/include/asic_reg \ + -I$(FULL_AMD_DISPLAY_PATH) \ + -I$(FULL_AMD_DISPLAY_PATH)/include \ + -I$(FULL_AMD_DISPLAY_PATH)/dc \ +- -I$(FULL_AMD_DISPLAY_PATH)/amdgpu_dm ++ -I$(FULL_AMD_DISPLAY_PATH)/amdgpu_dm \ ++ -I$(FULL_AMD_PATH)/amdkfd + + amdgpu-y := amdgpu_drv.o + +@@ -150,7 +151,15 @@ amdgpu-y += \ + # add amdkfd interfaces + amdgpu-y += amdgpu_amdkfd.o + ++# linux-headers-4.15.0-20-generic/.config defined ++# CONFIG_HSA_AMD=m by default, ++# here we disable HSA just for rebase before enable kfd. ++# override CONFIG_HSA_AMD = ++ + ifneq ($(CONFIG_HSA_AMD),) ++AMDKFD_PATH := ../amdkfd ++include $(FULL_AMD_PATH)/amdkfd/Makefile ++amdgpu-y += $(AMDKFD_FILES) + amdgpu-y += \ + amdgpu_amdkfd_fence.o \ + amdgpu_amdkfd_gpuvm.o \ +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +index 1a699e47777d..ea1273734008 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +@@ -29,8 +29,10 @@ + #include <drm/drmP.h> + #include "amdgpu.h" + #include "amdgpu_gfx.h" ++#include "amdgpu_dma_buf.h" + #include <linux/module.h> + #include <linux/dma-buf.h> ++#include "amdgpu_xgmi.h" + + static unsigned int compute_vmid_bitmap = 0xFF00; + +@@ -566,6 +568,27 @@ uint64_t amdgpu_amdkfd_get_vram_usage(struct kgd_dev *kgd) + return amdgpu_vram_mgr_usage(&adev->mman.bdev.man[TTM_PL_VRAM]); + } + ++uint64_t amdgpu_amdkfd_get_hive_id(struct kgd_dev *kgd) ++{ ++ struct amdgpu_device *adev = (struct amdgpu_device *)kgd; ++ ++ return adev->gmc.xgmi.hive_id; ++} ++uint8_t amdgpu_amdkfd_get_xgmi_hops_count(struct kgd_dev *dst, struct kgd_dev *src) ++{ ++ struct amdgpu_device *peer_adev = (struct amdgpu_device *)src; ++ struct amdgpu_device *adev = (struct amdgpu_device *)dst; ++ int ret = amdgpu_xgmi_get_hops_count(adev, peer_adev); ++ ++ if (ret < 0) { ++ DRM_ERROR("amdgpu: failed to get xgmi hops count between node %d and %d. ret = %d\n", ++ adev->gmc.xgmi.physical_node_id, ++ peer_adev->gmc.xgmi.physical_node_id, ret); ++ ret = 0; ++ } ++ return (uint8_t)ret; ++} ++ + uint64_t amdgpu_amdkfd_get_mmio_remap_phys_addr(struct kgd_dev *kgd) + { + struct amdgpu_device *adev = (struct amdgpu_device *)kgd; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +index 5331d9c8c9f6..bdc550dcc2ca 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +@@ -177,9 +177,10 @@ int amdgpu_amdkfd_get_dmabuf_info(struct kgd_dev *kgd, int dma_buf_fd, + size_t buffer_size, uint32_t *metadata_size, + uint32_t *flags); + uint64_t amdgpu_amdkfd_get_vram_usage(struct kgd_dev *kgd); +- ++uint64_t amdgpu_amdkfd_get_hive_id(struct kgd_dev *kgd); + uint64_t amdgpu_amdkfd_get_mmio_remap_phys_addr(struct kgd_dev *kgd); + uint32_t amdgpu_amdkfd_get_num_gws(struct kgd_dev *kgd); ++uint8_t amdgpu_amdkfd_get_xgmi_hops_count(struct kgd_dev *dst, struct kgd_dev *src); + + #define read_user_wptr(mmptr, wptr, dst) \ + ({ \ +@@ -197,11 +198,11 @@ uint32_t amdgpu_amdkfd_get_num_gws(struct kgd_dev *kgd); + }) + + /* GPUVM API */ +-int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, void **vm, +- void **process_info, ++int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, unsigned int pasid, ++ void **vm, void **process_info, + struct dma_fence **ef); + int amdgpu_amdkfd_gpuvm_acquire_process_vm(struct kgd_dev *kgd, +- struct file *filp, ++ struct file *filp, unsigned int pasid, + void **vm, void **process_info, + struct dma_fence **ef); + void amdgpu_amdkfd_gpuvm_destroy_cb(struct amdgpu_device *adev, +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c +index 3107b9575929..24d2a623d9f0 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_fence.c +@@ -80,6 +80,7 @@ struct amdgpu_amdkfd_fence *amdgpu_amdkfd_fence_create(u64 context, + return fence; + } + ++#ifdef CONFIG_HSA_AMD + struct amdgpu_amdkfd_fence *to_amdgpu_amdkfd_fence(struct dma_fence *f) + { + struct amdgpu_amdkfd_fence *fence; +@@ -93,6 +94,7 @@ struct amdgpu_amdkfd_fence *to_amdgpu_amdkfd_fence(struct dma_fence *f) + + return NULL; + } ++#endif + + static const char *amdkfd_fence_get_driver_name(struct dma_fence *f) + { +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +index 97bd545045f2..2e7a32fc0dbe 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +@@ -31,6 +31,7 @@ + #include "amdgpu_object.h" + #include "amdgpu_vm.h" + #include "amdgpu_amdkfd.h" ++#include "amdgpu_dma_buf.h" + + /* Special VM and GART address alignment needed for VI pre-Fiji due to + * a HW bug. +@@ -204,39 +205,25 @@ void amdgpu_amdkfd_unreserve_memory_limit(struct amdgpu_bo *bo) + unreserve_mem_limit(adev, amdgpu_bo_size(bo), domain, sg); + } + +- +-/* amdgpu_amdkfd_remove_eviction_fence - Removes eviction fence(s) from BO's ++/* amdgpu_amdkfd_remove_eviction_fence - Removes eviction fence from BO's + * reservation object. + * + * @bo: [IN] Remove eviction fence(s) from this BO +- * @ef: [IN] If ef is specified, then this eviction fence is removed if it ++ * @ef: [IN] This eviction fence is removed if it + * is present in the shared list. +- * @ef_list: [OUT] Returns list of eviction fences. These fences are removed +- * from BO's reservation object shared list. +- * @ef_count: [OUT] Number of fences in ef_list. + * +- * NOTE: If called with ef_list, then amdgpu_amdkfd_add_eviction_fence must be +- * called to restore the eviction fences and to avoid memory leak. This is +- * useful for shared BOs. + * NOTE: Must be called with BO reserved i.e. bo->tbo.resv->lock held. + */ + static int amdgpu_amdkfd_remove_eviction_fence(struct amdgpu_bo *bo, +- struct amdgpu_amdkfd_fence *ef, +- struct amdgpu_amdkfd_fence ***ef_list, +- unsigned int *ef_count) ++ struct amdgpu_amdkfd_fence *ef) + { + struct reservation_object *resv = bo->tbo.resv; + struct reservation_object_list *old, *new; + unsigned int i, j, k; + +- if (!ef && !ef_list) ++ if (!ef) + return -EINVAL; + +- if (ef_list) { +- *ef_list = NULL; +- *ef_count = 0; +- } +- + old = reservation_object_get_list(resv); + if (!old) + return 0; +@@ -255,8 +242,7 @@ static int amdgpu_amdkfd_remove_eviction_fence(struct amdgpu_bo *bo, + f = rcu_dereference_protected(old->shared[i], + reservation_object_held(resv)); + +- if ((ef && f->context == ef->base.context) || +- (!ef && to_amdgpu_amdkfd_fence(f))) ++ if (f->context == ef->base.context) + RCU_INIT_POINTER(new->shared[--j], f); + else + RCU_INIT_POINTER(new->shared[k++], f); +@@ -264,21 +250,6 @@ static int amdgpu_amdkfd_remove_eviction_fence(struct amdgpu_bo *bo, + new->shared_max = old->shared_max; + new->shared_count = k; + +- if (!ef) { +- unsigned int count = old->shared_count - j; +- +- /* Alloc memory for count number of eviction fence pointers. +- * Fill the ef_list array and ef_count +- */ +- *ef_list = kcalloc(count, sizeof(**ef_list), GFP_KERNEL); +- *ef_count = count; +- +- if (!*ef_list) { +- kfree(new); +- return -ENOMEM; +- } +- } +- + /* Install the new fence list, seqcount provides the barriers */ + preempt_disable(); + write_seqcount_begin(&resv->seq); +@@ -292,10 +263,7 @@ static int amdgpu_amdkfd_remove_eviction_fence(struct amdgpu_bo *bo, + + f = rcu_dereference_protected(new->shared[i], + reservation_object_held(resv)); +- if (!ef) +- (*ef_list)[k++] = to_amdgpu_amdkfd_fence(f); +- else +- dma_fence_put(f); ++ dma_fence_put(f); + } + kfree_rcu(old, rcu); + +@@ -347,19 +315,8 @@ static int amdgpu_amdkfd_bo_validate(struct amdgpu_bo *bo, uint32_t domain, + ret = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx); + if (ret) + goto validate_fail; +- if (wait) { +- struct amdgpu_amdkfd_fence **ef_list; +- unsigned int ef_count; +- +- ret = amdgpu_amdkfd_remove_eviction_fence(bo, NULL, &ef_list, +- &ef_count); +- if (ret) +- goto validate_fail; +- +- ttm_bo_wait(&bo->tbo, false, false); +- amdgpu_amdkfd_add_eviction_fence(bo, ef_list, ef_count); +- } +- ++ if (wait) ++ amdgpu_bo_sync_wait(bo, AMDGPU_FENCE_OWNER_KFD, false); + validate_fail: + return ret; + } +@@ -448,7 +405,6 @@ static int add_bo_to_vm(struct amdgpu_device *adev, struct kgd_mem *mem, + { + int ret; + struct kfd_bo_va_list *bo_va_entry; +- struct amdgpu_bo *pd = vm->root.base.bo; + struct amdgpu_bo *bo = mem->bo; + uint64_t va = mem->va; + struct list_head *list_bo_va = &mem->bo_va_list; +@@ -487,28 +443,16 @@ static int add_bo_to_vm(struct amdgpu_device *adev, struct kgd_mem *mem, + if (p_bo_va_entry) + *p_bo_va_entry = bo_va_entry; + +- /* Allocate new page tables if needed and validate +- * them. Clearing of new page tables and validate need to wait +- * on move fences. We don't want that to trigger the eviction +- * fence, so remove it temporarily. +- */ +- amdgpu_amdkfd_remove_eviction_fence(pd, +- vm->process_info->eviction_fence, +- NULL, NULL); +- ++ /* Allocate validate page tables if needed */ + ret = vm_validate_pt_pd_bos(vm); + if (ret) { + pr_err("validate_pt_pd_bos() failed\n"); + goto err_alloc_pts; + } + +- /* Add the eviction fence back */ +- amdgpu_bo_fence(pd, &vm->process_info->eviction_fence->base, true); +- + return 0; + + err_alloc_pts: +- amdgpu_bo_fence(pd, &vm->process_info->eviction_fence->base, true); + amdgpu_vm_bo_rmv(adev, bo_va_entry->bo_va); + list_del(&bo_va_entry->bo_list); + err_vmadd: +@@ -818,24 +762,11 @@ static int unmap_bo_from_gpuvm(struct amdgpu_device *adev, + { + struct amdgpu_bo_va *bo_va = entry->bo_va; + struct amdgpu_vm *vm = bo_va->base.vm; +- struct amdgpu_bo *pd = vm->root.base.bo; + +- /* Remove eviction fence from PD (and thereby from PTs too as +- * they share the resv. object). Otherwise during PT update +- * job (see amdgpu_vm_bo_update_mapping), eviction fence would +- * get added to job->sync object and job execution would +- * trigger the eviction fence. +- */ +- amdgpu_amdkfd_remove_eviction_fence(pd, +- vm->process_info->eviction_fence, +- NULL, NULL); + amdgpu_vm_bo_unmap(adev, bo_va, entry->va); + + amdgpu_vm_clear_freed(adev, vm, &bo_va->last_pt_update); + +- /* Add the eviction fence back */ +- amdgpu_bo_fence(pd, &vm->process_info->eviction_fence->base, true); +- + amdgpu_sync_fence(NULL, sync, bo_va->last_pt_update, false); + + return 0; +@@ -1050,9 +981,8 @@ static int init_kfd_vm(struct amdgpu_vm *vm, void **process_info, + } + return ret; + } +- +-int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, void **vm, +- void **process_info, ++int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, unsigned int pasid, ++ void **vm, void **process_info, + struct dma_fence **ef) + { + struct amdgpu_device *adev = get_amdgpu_device(kgd); +@@ -1064,7 +994,7 @@ int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, void **vm, + return -ENOMEM; + + /* Initialize AMDGPU part of the VM */ +- ret = amdgpu_vm_init(adev, new_vm, AMDGPU_VM_CONTEXT_COMPUTE, 0); ++ ret = amdgpu_vm_init(adev, new_vm, AMDGPU_VM_CONTEXT_COMPUTE, pasid); + if (ret) { + pr_err("Failed init vm ret %d\n", ret); + goto amdgpu_vm_init_fail; +@@ -1087,7 +1017,7 @@ int amdgpu_amdkfd_gpuvm_create_process_vm(struct kgd_dev *kgd, void **vm, + } + + int amdgpu_amdkfd_gpuvm_acquire_process_vm(struct kgd_dev *kgd, +- struct file *filp, ++ struct file *filp, unsigned int pasid, + void **vm, void **process_info, + struct dma_fence **ef) + { +@@ -1116,6 +1046,7 @@ int amdgpu_amdkfd_gpuvm_acquire_process_vm(struct kgd_dev *kgd, + return 0; + } + ++#ifdef CONFIG_HSA_AMD + void amdgpu_amdkfd_gpuvm_destroy_cb(struct amdgpu_device *adev, + struct amdgpu_vm *vm) + { +@@ -1149,6 +1080,7 @@ void amdgpu_amdkfd_gpuvm_destroy_cb(struct amdgpu_device *adev, + kfree(process_info); + } + } ++#endif + + void amdgpu_amdkfd_gpuvm_destroy_process_vm(struct kgd_dev *kgd, void *vm) + { +@@ -1410,8 +1342,8 @@ int amdgpu_amdkfd_gpuvm_free_memory_of_gpu( + * attached + */ + amdgpu_amdkfd_remove_eviction_fence(mem->bo, +- process_info->eviction_fence, +- NULL, NULL); ++ process_info->eviction_fence); ++ + pr_debug("Release VA 0x%llx - 0x%llx\n", mem->va, + mem->va + bo_size * (1 + mem->aql_queue)); + +@@ -1638,8 +1570,7 @@ int amdgpu_amdkfd_gpuvm_unmap_memory_from_gpu( + if (mem->mapped_to_gpu_memory == 0 && + !amdgpu_ttm_tt_get_usermm(mem->bo->tbo.ttm) && !mem->bo->pin_count) + amdgpu_amdkfd_remove_eviction_fence(mem->bo, +- process_info->eviction_fence, +- NULL, NULL); ++ process_info->eviction_fence); + + unreserve_out: + unreserve_bo_and_vms(&ctx, false, false); +@@ -1700,7 +1631,7 @@ int amdgpu_amdkfd_gpuvm_map_gtt_bo_to_kernel(struct kgd_dev *kgd, + } + + amdgpu_amdkfd_remove_eviction_fence( +- bo, mem->process_info->eviction_fence, NULL, NULL); ++ bo, mem->process_info->eviction_fence); + list_del_init(&mem->validate_list.head); + + if (size) +@@ -1965,6 +1896,7 @@ int amdgpu_amdkfd_gpuvm_export_dmabuf(struct kgd_dev *kgd, void *vm, + return 0; + } + ++#ifdef CONFIG_HSA_AMD + /* Evict a userptr BO by stopping the queues if necessary + * + * Runs in MMU notifier, may be in RECLAIM_FS context. This means it +@@ -1996,6 +1928,7 @@ int amdgpu_amdkfd_evict_userptr(struct kgd_mem *mem, + + return r; + } ++#endif + + /* Update invalid userptr BOs + * +@@ -2142,16 +2075,6 @@ static int validate_invalid_user_pages(struct amdkfd_process_info *process_info) + + amdgpu_sync_create(&sync); + +- /* Avoid triggering eviction fences when unmapping invalid +- * userptr BOs (waits for all fences, doesn't use +- * FENCE_OWNER_VM) +- */ +- list_for_each_entry(peer_vm, &process_info->vm_list_head, +- vm_list_node) +- amdgpu_amdkfd_remove_eviction_fence(peer_vm->root.base.bo, +- process_info->eviction_fence, +- NULL, NULL); +- + ret = process_validate_vms(process_info); + if (ret) + goto unreserve_out; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +index 604571935072..d571d482948f 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +@@ -604,48 +604,6 @@ MODULE_PARM_DESC(mes, + "Enable Micro Engine Scheduler (0 = disabled (default), 1 = enabled)"); + module_param_named(mes, amdgpu_mes, int, 0444); + +-/** +- * DOC: pcie_p2p (bool) +- * Enable PCIe P2P (requires large-BAR). Default value: true (on) +- */ +-bool pcie_p2p = true; +-module_param(pcie_p2p, bool, 0444); +-MODULE_PARM_DESC(pcie_p2p, "Enable PCIe P2P (requires large-BAR). (N = off, Y = on(default))"); +- +-/** +- * DOC: dcfeaturemask (uint) +- * Override display features enabled. See enum DC_FEATURE_MASK in drivers/gpu/drm/amd/include/amd_shared.h. +- * The default is the current set of stable display features. +- */ +-MODULE_PARM_DESC(dcfeaturemask, "all stable DC features enabled (default))"); +-module_param_named(dcfeaturemask, amdgpu_dc_feature_mask, uint, 0444); +- +-/* +- * DOC: hws_gws_support(bool) +- * Whether HWS support gws barriers. Default value: false (not supported) +- * This will be replaced with a MEC firmware version check once firmware +- * is ready +- */ +-bool hws_gws_support; +-module_param(hws_gws_support, bool, 0444); +-MODULE_PARM_DESC(hws_gws_support, "MEC FW support gws barriers (false = not supported (Default), true = supported)"); +- +-/** +- * DOC: abmlevel (uint) +- * Override the default ABM (Adaptive Backlight Management) level used for DC +- * enabled hardware. Requires DMCU to be supported and loaded. +- * Valid levels are 0-4. A value of 0 indicates that ABM should be disabled by +- * default. Values 1-4 control the maximum allowable brightness reduction via +- * the ABM algorithm, with 1 being the least reduction and 4 being the most +- * reduction. +- * +- * Defaults to 0, or disabled. Userspace can still override this level later +- * after boot. +- */ +-uint amdgpu_dm_abm_level = 0; +-MODULE_PARM_DESC(abmlevel, "ABM level (0 = off (default), 1-4 = backlight reduction level) "); +-module_param_named(abmlevel, amdgpu_dm_abm_level, uint, 0444); +- + #ifdef CONFIG_HSA_AMD + /** + * DOC: sched_policy (int) +@@ -723,14 +681,14 @@ MODULE_PARM_DESC(ignore_crat, + + /** + * DOC: noretry (int) +- * This parameter sets sh_mem_config.retry_disable. Default value, 0, enables retry. +- * Setting 1 disables retry. ++ * This parameter sets sh_mem_config.retry_disable. Default value, 1, disable retry. ++ * Setting 0 enables retry. + * Retry is needed for recoverable page faults. + */ +-int noretry; ++int noretry = 1; + module_param(noretry, int, 0644); + MODULE_PARM_DESC(noretry, +- "Set sh_mem_config.retry_disable on Vega10 (0 = retry enabled (default), 1 = retry disabled)"); ++ "Set sh_mem_config.retry_disable on Vega10 (1 = retry disabled (default), 0 = retry enabled)"); + + /** + * DOC: halt_if_hws_hang (int) +@@ -776,6 +734,38 @@ module_param(queue_preemption_timeout_ms, int, 0644); + MODULE_PARM_DESC(queue_preemption_timeout_ms, "queue preemption timeout in ms (1 = Minimum, 9000 = default)"); + #endif + ++/** ++ * DOC: pcie_p2p (bool) ++ * Enable PCIe P2P (requires large-BAR). Default value: true (on) ++ */ ++bool pcie_p2p = true; ++module_param(pcie_p2p, bool, 0444); ++MODULE_PARM_DESC(pcie_p2p, "Enable PCIe P2P (requires large-BAR). (N = off, Y = on(default))"); ++ ++/** ++ * DOC: dcfeaturemask (uint) ++ * Override display features enabled. See enum DC_FEATURE_MASK in drivers/gpu/drm/amd/include/amd_shared.h. ++ * The default is the current set of stable display features. ++ */ ++MODULE_PARM_DESC(dcfeaturemask, "all stable DC features enabled (default))"); ++module_param_named(dcfeaturemask, amdgpu_dc_feature_mask, uint, 0444); ++ ++/** ++ * DOC: abmlevel (uint) ++ * Override the default ABM (Adaptive Backlight Management) level used for DC ++ * enabled hardware. Requires DMCU to be supported and loaded. ++ * Valid levels are 0-4. A value of 0 indicates that ABM should be disabled by ++ * default. Values 1-4 control the maximum allowable brightness reduction via ++ * the ABM algorithm, with 1 being the least reduction and 4 being the most ++ * reduction. ++ * ++ * Defaults to 0, or disabled. Userspace can still override this level later ++ * after boot. ++ */ ++uint amdgpu_dm_abm_level = 0; ++MODULE_PARM_DESC(abmlevel, "ABM level (0 = off (default), 1-4 = backlight reduction level) "); ++module_param_named(abmlevel, amdgpu_dm_abm_level, uint, 0444); ++ + static const struct pci_device_id pciidlist[] = { + #ifdef CONFIG_DRM_AMDGPU_SI + {0x1002, 0x6780, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI}, +@@ -1482,6 +1472,9 @@ static int __init amdgpu_init(void) + #endif + kms_driver.num_ioctls = amdgpu_max_kms_ioctl; + amdgpu_register_atpx_handler(); ++ ++ /* Ignore KFD init failures. Normal when CONFIG_HSA_AMD is not set. */ ++ amdgpu_amdkfd_init(); + /* let modprobe override vga console setting */ + return pci_register_driver(&amdgpu_kms_pci_driver); + +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device.c b/drivers/gpu/drm/amd/amdkfd/kfd_device.c +index bbab3c740dbe..da6826343180 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_device.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device.c +@@ -483,6 +483,7 @@ static const struct kfd_device_info *lookup_device_info(unsigned short did) + return NULL; + } + ++#ifdef CONFIG_HSA_AMD + struct kfd_dev *kgd2kfd_probe(struct kgd_dev *kgd, + struct pci_dev *pdev, const struct kfd2kgd_calls *f2g) + { +@@ -528,6 +529,7 @@ struct kfd_dev *kgd2kfd_probe(struct kgd_dev *kgd, + + return kfd; + } ++#endif + + static void kfd_cwsr_init(struct kfd_dev *kfd) + { +@@ -550,6 +552,7 @@ static void kfd_cwsr_init(struct kfd_dev *kfd) + } + } + ++#ifdef CONFIG_HSA_AMD + bool kgd2kfd_device_init(struct kfd_dev *kfd, + struct drm_device *ddev, + const struct kgd2kfd_shared_resources *gpu_resources) +@@ -742,12 +745,14 @@ int kgd2kfd_post_reset(struct kfd_dev *kfd) + + return 0; + } ++#endif + + bool kfd_is_locked(void) + { + return (atomic_read(&kfd_locked) > 0); + } + ++#ifdef CONFIG_HSA_AMD + void kgd2kfd_suspend(struct kfd_dev *kfd) + { + if (!kfd->init_complete) +@@ -780,6 +785,7 @@ int kgd2kfd_resume(struct kfd_dev *kfd) + + return ret; + } ++#endif + + static int kfd_resume(struct kfd_dev *kfd) + { +@@ -808,6 +814,7 @@ static int kfd_resume(struct kfd_dev *kfd) + return err; + } + ++#ifdef CONFIG_HSA_AMD + /* This is called directly from KGD at ISR. */ + void kgd2kfd_interrupt(struct kfd_dev *kfd, const void *ih_ring_entry) + { +@@ -834,6 +841,7 @@ void kgd2kfd_interrupt(struct kfd_dev *kfd, const void *ih_ring_entry) + + spin_unlock_irqrestore(&kfd->interrupt_lock, flags); + } ++#endif + + int kgd2kfd_quiesce_mm(struct mm_struct *mm) + { +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +index a0344d7165b4..07caeda8eed4 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +@@ -1222,7 +1222,9 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q, + + if (q->properties.type == KFD_QUEUE_TYPE_SDMA || + q->properties.type == KFD_QUEUE_TYPE_SDMA_XGMI) { ++ dqm_lock(dqm); + retval = allocate_sdma_queue(dqm, q); ++ dqm_unlock(dqm); + if (retval) + goto out; + } +@@ -1282,8 +1284,11 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q, + deallocate_doorbell(qpd, q); + out_deallocate_sdma_queue: + if (q->properties.type == KFD_QUEUE_TYPE_SDMA || +- q->properties.type == KFD_QUEUE_TYPE_SDMA_XGMI) ++ q->properties.type == KFD_QUEUE_TYPE_SDMA_XGMI) { ++ dqm_lock(dqm); + deallocate_sdma_queue(dqm, q); ++ dqm_unlock(dqm); ++ } + out: + return retval; + } +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c +index 278bc22edf49..9f5024bce095 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c +@@ -126,10 +126,34 @@ void kfd_doorbell_fini(struct kfd_dev *kfd) + iounmap(kfd->doorbell_kernel_ptr); + } + ++static void kfd_doorbell_open(struct vm_area_struct *vma) ++{ ++ /* Don't track the parent's PDD in a child process. We do set ++ * VM_DONTCOPY, but that can be overridden from user mode. ++ */ ++ vma->vm_private_data = NULL; ++} ++ ++static void kfd_doorbell_close(struct vm_area_struct *vma) ++{ ++ struct kfd_process_device *pdd = vma->vm_private_data; ++ ++ if (!pdd) ++ return; ++ ++ mutex_lock(&pdd->qpd.doorbell_lock); ++ pdd->qpd.doorbell_vma = NULL; ++ /* Remember if the process was evicted without doorbells ++ * mapped to user mode. ++ */ ++ if (pdd->qpd.doorbell_mapped == 0) ++ pdd->qpd.doorbell_mapped = -1; ++ mutex_unlock(&pdd->qpd.doorbell_lock); ++} ++ + static int kfd_doorbell_vm_fault(struct vm_fault *vmf) + { + struct kfd_process_device *pdd = vmf->vma->vm_private_data; +- pr_debug("Process %d doorbell vm page fault\n", process->pasid); + if (!pdd) + return VM_FAULT_SIGBUS; + +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_module.c b/drivers/gpu/drm/amd/amdkfd/kfd_module.c +index 9c6dfb856797..d0a05024d38c 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_module.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_module.c +@@ -95,7 +95,9 @@ int kgd2kfd_init() + return kfd_init(); + } + ++#ifdef CONFIG_HSA_AMD + void kgd2kfd_exit(void) + { + kfd_exit(); + } ++#endif +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c +index edaad275b869..bcdc1f915bc8 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c +@@ -864,7 +864,7 @@ int kfd_process_device_init_vm(struct kfd_process_device *pdd, + + if (drm_file) + ret = amdgpu_amdkfd_gpuvm_acquire_process_vm( +- dev->kgd, drm_file, ++ dev->kgd, drm_file, p->pasid, + &pdd->vm, &p->kgd_process_info, &p->ef); + else + ret = amdgpu_amdkfd_gpuvm_create_process_vm(dev->kgd, p->pasid, +diff --git a/kernel/fork.c b/kernel/fork.c +index f0b58479534f..a455cca4fc10 100644 +--- a/kernel/fork.c ++++ b/kernel/fork.c +@@ -1157,6 +1157,7 @@ struct mm_struct *mm_access(struct task_struct *task, unsigned int mode) + + return mm; + } ++EXPORT_SYMBOL_GPL(mm_access); + + static void complete_vfork_done(struct task_struct *tsk) + { +diff --git a/security/device_cgroup.c b/security/device_cgroup.c +index cd97929fac66..e3a9ad5db5a0 100644 +--- a/security/device_cgroup.c ++++ b/security/device_cgroup.c +@@ -824,3 +824,4 @@ int __devcgroup_check_permission(short type, u32 major, u32 minor, + + return 0; + } ++EXPORT_SYMBOL(__devcgroup_check_permission); +-- +2.17.1 + |