aboutsummaryrefslogtreecommitdiffstats
path: root/meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch')
-rw-r--r--meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch2445
1 files changed, 2445 insertions, 0 deletions
diff --git a/meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch b/meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch
new file mode 100644
index 00000000..aa4f1724
--- /dev/null
+++ b/meta-v1000/recipes-kernel/linux/linux-yocto-4.14.71/1283-drm-amdkfd-Consolidate-and-clean-up-log-commands.patch
@@ -0,0 +1,2445 @@
+From a3e718dbed0d33c8114ef9022615d725c3c03f71 Mon Sep 17 00:00:00 2001
+From: Chaudhary Amit Kumar <chaudharyamit.kumar@amd.com>
+Date: Wed, 17 Oct 2018 19:33:42 +0530
+Subject: [PATCH 1283/4131] drm/amdkfd: Consolidate and clean up log commands
+
+Consolidate log commands so that dev_info(NULL, "Error...") uses the more
+accurate pr_err, remove the module name from the log (can be seen via
+dynamic debugging with +m), and the function name (can be seen via
+dynamic debugging with +f). We also don't need debug messages saying
+what function we're in. Those can be added by devs when needed
+
+Lastly, remove parentheses around %d, %i and 0x%llX.
+According to kernel.org:
+"Printing numbers in parentheses (%d) adds no value and should be
+avoided."
+
+Change-Id: Id74c1d43d413d5c18735e59e55b7a56c90701f03
+Signed-off-by: Kent Russell <kent.russell@amd.com>
+Signed-off-by: Chaudhary Amit Kumar <chaudharyamit.kumar@amd.com>
+---
+ drivers/gpu/drm/amd/amdkfd/kfd_chardev.c | 138 +++++++++------------
+ drivers/gpu/drm/amd/amdkfd/kfd_crat.c | 10 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c | 42 +++----
+ drivers/gpu/drm/amd/amdkfd/kfd_dbgmgr.c | 86 ++++---------
+ drivers/gpu/drm/amd/amdkfd/kfd_device.c | 46 +++----
+ .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c | 80 +++++-------
+ .../drm/amd/amdkfd/kfd_device_queue_manager_cik.c | 4 +-
+ .../drm/amd/amdkfd/kfd_device_queue_manager_v9.c | 2 +-
+ .../drm/amd/amdkfd/kfd_device_queue_manager_vi.c | 4 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c | 20 +--
+ drivers/gpu/drm/amd/amdkfd/kfd_events.c | 28 ++---
+ drivers/gpu/drm/amd/amdkfd/kfd_ipc.c | 6 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c | 20 +--
+ drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue_cik.c | 2 -
+ drivers/gpu/drm/amd/amdkfd/kfd_module.c | 4 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_cik.c | 12 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c | 10 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_vi.c | 10 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c | 27 ++--
+ drivers/gpu/drm/amd/amdkfd/kfd_peerdirect.c | 61 +++++----
+ drivers/gpu/drm/amd/amdkfd/kfd_process.c | 6 +-
+ .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 32 ++---
+ drivers/gpu/drm/amd/amdkfd/kfd_rdma.c | 11 +-
+ drivers/gpu/drm/amd/amdkfd/kfd_topology.c | 4 +-
+ 24 files changed, 273 insertions(+), 392 deletions(-)
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c
+index 8b35b70..91e977b 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_chardev.c
+@@ -161,12 +161,12 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
+ struct kfd_ioctl_create_queue_args *args)
+ {
+ if (args->queue_percentage > KFD_MAX_QUEUE_PERCENTAGE) {
+- pr_err("kfd: queue percentage must be between 0 to KFD_MAX_QUEUE_PERCENTAGE\n");
++ pr_err("Queue percentage must be between 0 to KFD_MAX_QUEUE_PERCENTAGE\n");
+ return -EINVAL;
+ }
+
+ if (args->queue_priority > KFD_MAX_QUEUE_PRIORITY) {
+- pr_err("kfd: queue priority must be between 0 to KFD_MAX_QUEUE_PRIORITY\n");
++ pr_err("Queue priority must be between 0 to KFD_MAX_QUEUE_PRIORITY\n");
+ return -EINVAL;
+ }
+
+@@ -174,26 +174,26 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
+ (!access_ok(VERIFY_WRITE,
+ (const void __user *) args->ring_base_address,
+ sizeof(uint64_t)))) {
+- pr_err("kfd: can't access ring base address\n");
++ pr_err("Can't access ring base address\n");
+ return -EFAULT;
+ }
+
+ if (!is_power_of_2(args->ring_size) && (args->ring_size != 0)) {
+- pr_err("kfd: ring size must be a power of 2 or 0\n");
++ pr_err("Ring size must be a power of 2 or 0\n");
+ return -EINVAL;
+ }
+
+ if (!access_ok(VERIFY_WRITE,
+ (const void __user *) args->read_pointer_address,
+ sizeof(uint32_t))) {
+- pr_err("kfd: can't access read pointer\n");
++ pr_err("Can't access read pointer\n");
+ return -EFAULT;
+ }
+
+ if (!access_ok(VERIFY_WRITE,
+ (const void __user *) args->write_pointer_address,
+ sizeof(uint32_t))) {
+- pr_err("kfd: can't access write pointer\n");
++ pr_err("Can't access write pointer\n");
+ return -EFAULT;
+ }
+
+@@ -201,7 +201,7 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
+ !access_ok(VERIFY_WRITE,
+ (const void __user *) args->eop_buffer_address,
+ sizeof(uint32_t))) {
+- pr_debug("kfd: can't access eop buffer");
++ pr_debug("Can't access eop buffer");
+ return -EFAULT;
+ }
+
+@@ -209,7 +209,7 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
+ !access_ok(VERIFY_WRITE,
+ (const void __user *) args->ctx_save_restore_address,
+ sizeof(uint32_t))) {
+- pr_debug("kfd: can't access ctx save restore buffer");
++ pr_debug("Can't access ctx save restore buffer");
+ return -EFAULT;
+ }
+
+@@ -239,27 +239,27 @@ static int set_queue_properties_from_user(struct queue_properties *q_properties,
+ else
+ q_properties->format = KFD_QUEUE_FORMAT_PM4;
+
+- pr_debug("Queue Percentage (%d, %d)\n",
++ pr_debug("Queue Percentage: %d, %d\n",
+ q_properties->queue_percent, args->queue_percentage);
+
+- pr_debug("Queue Priority (%d, %d)\n",
++ pr_debug("Queue Priority: %d, %d\n",
+ q_properties->priority, args->queue_priority);
+
+- pr_debug("Queue Address (0x%llX, 0x%llX)\n",
++ pr_debug("Queue Address: 0x%llX, 0x%llX\n",
+ q_properties->queue_address, args->ring_base_address);
+
+- pr_debug("Queue Size (0x%llX, %u)\n",
++ pr_debug("Queue Size: 0x%llX, %u\n",
+ q_properties->queue_size, args->ring_size);
+
+- pr_debug("Queue r/w Pointers (0x%llX, 0x%llX)\n",
+- (uint64_t) q_properties->read_ptr,
+- (uint64_t) q_properties->write_ptr);
++ pr_debug("Queue r/w Pointers: %p, %p\n",
++ q_properties->read_ptr,
++ q_properties->write_ptr);
+
+- pr_debug("Queue Format (%d)\n", q_properties->format);
++ pr_debug("Queue Format: %d\n", q_properties->format);
+
+- pr_debug("Queue EOP (0x%llX)\n", q_properties->eop_ring_buffer_address);
++ pr_debug("Queue EOP: 0x%llX\n", q_properties->eop_ring_buffer_address);
+
+- pr_debug("Queue CTX save arex (0x%llX)\n",
++ pr_debug("Queue CTX save area: 0x%llX\n",
+ q_properties->ctx_save_restore_area_address);
+
+ return 0;
+@@ -277,16 +277,16 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
+
+ memset(&q_properties, 0, sizeof(struct queue_properties));
+
+- pr_debug("kfd: creating queue ioctl\n");
++ pr_debug("Creating queue ioctl\n");
+
+ err = set_queue_properties_from_user(&q_properties, args);
+ if (err)
+ return err;
+
+- pr_debug("kfd: looking for gpu id 0x%x\n", args->gpu_id);
++ pr_debug("Looking for gpu id 0x%x\n", args->gpu_id);
+ dev = kfd_device_by_id(args->gpu_id);
+ if (dev == NULL) {
+- pr_debug("kfd: gpu id 0x%x was not found\n", args->gpu_id);
++ pr_debug("Could not find gpu id 0x%x\n", args->gpu_id);
+ return -EINVAL;
+ }
+
+@@ -298,7 +298,7 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
+ goto err_bind_process;
+ }
+
+- pr_debug("kfd: creating queue for PASID %d on GPU 0x%x\n",
++ pr_debug("Creating queue for PASID %d on gpu 0x%x\n",
+ p->pasid,
+ dev->id);
+
+@@ -323,15 +323,15 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
+
+ up_write(&p->lock);
+
+- pr_debug("kfd: queue id %d was created successfully\n", args->queue_id);
++ pr_debug("Queue id %d was created successfully\n", args->queue_id);
+
+- pr_debug("ring buffer address == 0x%016llX\n",
++ pr_debug("Ring buffer address == 0x%016llX\n",
+ args->ring_base_address);
+
+- pr_debug("read ptr address == 0x%016llX\n",
++ pr_debug("Read ptr address == 0x%016llX\n",
+ args->read_pointer_address);
+
+- pr_debug("write ptr address == 0x%016llX\n",
++ pr_debug("Write ptr address == 0x%016llX\n",
+ args->write_pointer_address);
+
+ return 0;
+@@ -348,7 +348,7 @@ static int kfd_ioctl_destroy_queue(struct file *filp, struct kfd_process *p,
+ int retval;
+ struct kfd_ioctl_destroy_queue_args *args = data;
+
+- pr_debug("kfd: destroying queue id %d for PASID %d\n",
++ pr_debug("Destroying queue id %d for pasid %d\n",
+ args->queue_id,
+ p->pasid);
+
+@@ -368,12 +368,12 @@ static int kfd_ioctl_update_queue(struct file *filp, struct kfd_process *p,
+ struct queue_properties properties;
+
+ if (args->queue_percentage > KFD_MAX_QUEUE_PERCENTAGE) {
+- pr_err("kfd: queue percentage must be between 0 to KFD_MAX_QUEUE_PERCENTAGE\n");
++ pr_err("Queue percentage must be between 0 to KFD_MAX_QUEUE_PERCENTAGE\n");
+ return -EINVAL;
+ }
+
+ if (args->queue_priority > KFD_MAX_QUEUE_PRIORITY) {
+- pr_err("kfd: queue priority must be between 0 to KFD_MAX_QUEUE_PRIORITY\n");
++ pr_err("Queue priority must be between 0 to KFD_MAX_QUEUE_PRIORITY\n");
+ return -EINVAL;
+ }
+
+@@ -381,12 +381,12 @@ static int kfd_ioctl_update_queue(struct file *filp, struct kfd_process *p,
+ (!access_ok(VERIFY_WRITE,
+ (const void __user *) args->ring_base_address,
+ sizeof(uint64_t)))) {
+- pr_err("kfd: can't access ring base address\n");
++ pr_err("Can't access ring base address\n");
+ return -EFAULT;
+ }
+
+ if (!is_power_of_2(args->ring_size) && (args->ring_size != 0)) {
+- pr_err("kfd: ring size must be a power of 2 or 0\n");
++ pr_err("Ring size must be a power of 2 or 0\n");
+ return -EINVAL;
+ }
+
+@@ -395,7 +395,7 @@ static int kfd_ioctl_update_queue(struct file *filp, struct kfd_process *p,
+ properties.queue_percent = args->queue_percentage;
+ properties.priority = args->queue_priority;
+
+- pr_debug("kfd: updating queue id %d for PASID %d\n",
++ pr_debug("Updating queue id %d for pasid %d\n",
+ args->queue_id, p->pasid);
+
+ down_write(&p->lock);
+@@ -418,14 +418,14 @@ static int kfd_ioctl_set_cu_mask(struct file *filp, struct kfd_process *p,
+ size_t cu_mask_size = sizeof(uint32_t) * (args->num_cu_mask / 32);
+
+ if ((args->num_cu_mask % 32) != 0) {
+- pr_debug("kfd: num_cu_mask (0x%x) must be a multiple of 32",
++ pr_debug("num_cu_mask 0x%x must be a multiple of 32",
+ args->num_cu_mask);
+ return -EINVAL;
+ }
+
+ properties.cu_mask_count = args->num_cu_mask;
+ if (properties.cu_mask_count == 0) {
+- pr_debug("kfd: CU Mask cannot be 0");
++ pr_debug("CU mask cannot be 0");
+ return -EINVAL;
+ }
+
+@@ -434,7 +434,7 @@ static int kfd_ioctl_set_cu_mask(struct file *filp, struct kfd_process *p,
+ * past max_num_cus bits and just use the first max_num_cus bits.
+ */
+ if (properties.cu_mask_count > max_num_cus) {
+- pr_debug("kfd: CU mask cannot be greater than 1024 bits");
++ pr_debug("CU mask cannot be greater than 1024 bits");
+ properties.cu_mask_count = max_num_cus;
+ cu_mask_size = sizeof(uint32_t) * (max_num_cus/32);
+ }
+@@ -445,7 +445,7 @@ static int kfd_ioctl_set_cu_mask(struct file *filp, struct kfd_process *p,
+
+ retval = copy_from_user(properties.cu_mask, cu_mask_ptr, cu_mask_size);
+ if (retval) {
+- pr_debug("kfd: Could not copy cu mask from userspace");
++ pr_debug("Could not copy CU mask from userspace");
+ kfree(properties.cu_mask);
+ return -EFAULT;
+ }
+@@ -553,12 +553,9 @@ kfd_ioctl_dbg_register(struct file *filep, struct kfd_process *p, void *data)
+ struct kfd_process_device *pdd;
+ bool create_ok = false;
+
+- pr_debug("kfd:dbg: %s\n", __func__);
+-
+ dev = kfd_device_by_id(args->gpu_id);
+ if (!dev) {
+- dev_info(NULL, "Error! kfd: In func %s >> getting device by id failed\n",
+- __func__);
++ pr_err("Getting device by id failed in %s\n", __func__);
+ return status;
+ }
+
+@@ -603,8 +600,7 @@ static int kfd_ioctl_dbg_unregister(struct file *filep,
+
+ dev = kfd_device_by_id(args->gpu_id);
+ if (!dev) {
+- dev_info(NULL, "Error! kfd: In func %s >> getting device by id failed\n",
+- __func__);
++ pr_err("Getting device by id failed in %s\n", __func__);
+ return status;
+ }
+
+@@ -649,9 +645,7 @@ kfd_ioctl_dbg_address_watch(struct file *filep,
+
+ dev = kfd_device_by_id(args->gpu_id);
+ if (!dev) {
+- dev_info(NULL,
+- "Error! kfd: In func %s >> get device by id failed\n",
+- __func__);
++ pr_err("Getting device by id failed in %s\n", __func__);
+ return -EFAULT;
+ }
+
+@@ -767,22 +761,17 @@ kfd_ioctl_dbg_wave_control(struct file *filep, struct kfd_process *p,
+ sizeof(wac_info.trapId);
+
+
+- dev_info(NULL, "kfd: In func %s - start\n", __func__);
+-
+ dev = kfd_device_by_id(args->gpu_id);
+ if (!dev) {
+- dev_info(NULL, "Error! kfd: In func %s >> getting device by id failed\n",
+- __func__);
++ pr_err("Getting device by id failed in %s\n", __func__);
+ return -EFAULT;
+ }
+
+ /* input size must match the computed "compact" size */
+
+ if (args->buf_size_in_bytes != computed_buff_size) {
+- dev_info(NULL,
+- "Error! kfd: In func %s >> size mismatch, computed : actual %u : %u\n",
+- __func__, args->buf_size_in_bytes,
+- computed_buff_size);
++ pr_err("Size mismatch, computed %u : actual %u\n",
++ args->buf_size_in_bytes, computed_buff_size);
+ return -EINVAL;
+ }
+
+@@ -798,9 +787,8 @@ kfd_ioctl_dbg_wave_control(struct file *filep, struct kfd_process *p,
+ if (copy_from_user(args_buff,
+ (void __user *) args->content_ptr,
+ args->buf_size_in_bytes - sizeof(*args))) {
+- dev_info(NULL,
+- "Error! kfd: In func %s >> copy_from_user failed\n",
+- __func__);
++ pr_err("copy_from_user failed\n");
++ status = -EFAULT;
+ goto out;
+ }
+
+@@ -825,16 +813,14 @@ kfd_ioctl_dbg_wave_control(struct file *filep, struct kfd_process *p,
+
+ mutex_lock(get_dbgmgr_mutex());
+
+- dev_info(NULL,
+- "kfd: In func %s >> calling dbg manager process %p, operand %u, mode %u, trapId %u, message %u\n",
+- __func__, wac_info.process, wac_info.operand,
+- wac_info.mode, wac_info.trapId,
+- wac_info.dbgWave_msg.DbgWaveMsg.WaveMsgInfoGen2.Value);
++ pr_info("Calling dbg manager process %p, operand %u, mode %u, trapId %u, message %u\n",
++ wac_info.process, wac_info.operand, wac_info.mode,
++ wac_info.trapId,
++ wac_info.dbgWave_msg.DbgWaveMsg.WaveMsgInfoGen2.Value);
+
+ status = kfd_dbgmgr_wave_control(dev->dbgmgr, &wac_info);
+
+- dev_info(NULL, "kfd: In func %s >> returned status of dbg manager is %ld\n",
+- __func__, status);
++ pr_info("Returned status of dbg manager is %ld\n", status);
+
+ mutex_unlock(get_dbgmgr_mutex());
+
+@@ -1044,12 +1030,12 @@ kfd_ioctl_create_event(struct file *filp, struct kfd_process *p, void *data)
+ int err = -EINVAL;
+ void *mem, *kern_addr = NULL;
+
+- pr_debug("amdkfd: Event page offset 0x%llx\n", args->event_page_offset);
++ pr_debug("Event page offset 0x%llx\n", args->event_page_offset);
+
+ if (args->event_page_offset) {
+ kfd = kfd_device_by_id(GET_GPU_ID(args->event_page_offset));
+ if (!kfd) {
+- pr_err("amdkfd: can't find kfd device\n");
++ pr_err("Getting device by id failed in %s\n", __func__);
+ return -EFAULT;
+ }
+ if (KFD_IS_DGPU(kfd->device_info->asic_family)) {
+@@ -1063,7 +1049,7 @@ kfd_ioctl_create_event(struct file *filp, struct kfd_process *p, void *data)
+ mem = kfd_process_device_translate_handle(pdd,
+ GET_IDR_HANDLE(args->event_page_offset));
+ if (!mem) {
+- pr_err("amdkfd: can't find BO offset is 0x%llx\n",
++ pr_err("Can't find BO, offset is 0x%llx\n",
+ args->event_page_offset);
+ up_write(&p->lock);
+ return -EFAULT;
+@@ -1178,7 +1164,7 @@ bool kfd_is_large_bar(struct kfd_dev *dev)
+ struct kfd_local_mem_info mem_info;
+
+ if (debug_largebar) {
+- pr_debug("amdkfd: simulate large-bar allocation on non large-bar machine\n");
++ pr_debug("Simulate large-bar allocation on non large-bar machine\n");
+ return true;
+ }
+
+@@ -1342,7 +1328,7 @@ static int kfd_ioctl_map_memory_to_gpu(struct file *filep,
+
+ if (args->device_ids_array_size > 0 &&
+ (args->device_ids_array_size < sizeof(uint32_t))) {
+- pr_err("amdkfd: err node IDs array size %u\n",
++ pr_err("Node IDs array size %u\n",
+ args->device_ids_array_size);
+ return -EFAULT;
+ }
+@@ -1383,7 +1369,7 @@ static int kfd_ioctl_map_memory_to_gpu(struct file *filep,
+ for (i = 0 ; i < num_dev; i++) {
+ peer = kfd_device_by_id(devices_arr[i]);
+ if (!peer) {
+- pr_err("amdkfd: didn't found kfd-dev for 0x%x\n",
++ pr_err("Getting device by id failed for 0x%x\n",
+ devices_arr[i]);
+ err = -EFAULT;
+ goto get_mem_obj_from_handle_failed;
+@@ -1397,12 +1383,12 @@ static int kfd_ioctl_map_memory_to_gpu(struct file *filep,
+ }
+ err = kfd_map_memory_to_gpu(mem, peer_pdd);
+ if (err != 0)
+- pr_err("amdkfd: failed to map\n");
++ pr_err("Failed to map\n");
+ }
+ } else {
+ err = kfd_map_memory_to_gpu(mem, pdd);
+ if (err != 0)
+- pr_err("amdkfd: failed to map\n");
++ pr_err("Failed to map\n");
+ }
+
+ if (args->device_ids_array_size > 0 && devices_arr)
+@@ -1450,7 +1436,7 @@ static int kfd_ioctl_unmap_memory_from_gpu(struct file *filep,
+
+ if (args->device_ids_array_size > 0 &&
+ (args->device_ids_array_size < sizeof(uint32_t))) {
+- pr_err("amdkfd: err node IDs array size %u\n",
++ pr_err("Node IDs array size %u\n",
+ args->device_ids_array_size);
+ return -EFAULT;
+ }
+@@ -1672,7 +1658,7 @@ static int kfd_ioctl_import_dmabuf(struct file *filep,
+ r = kfd_ipc_import_dmabuf(dev, p, args->gpu_id, args->dmabuf_fd,
+ args->va_addr, &args->handle, NULL);
+ if (r)
+- dev_err(kfd_device, "Failed to import dmabuf\n");
++ pr_err("Failed to import dmabuf\n");
+
+ return r;
+ }
+@@ -1691,7 +1677,7 @@ static int kfd_ioctl_ipc_export_handle(struct file *filep,
+
+ r = kfd_ipc_export_as_handle(dev, p, args->handle, args->share_handle);
+ if (r)
+- dev_err(kfd_device, "Failed to export IPC handle\n");
++ pr_err("Failed to export IPC handle\n");
+
+ return r;
+ }
+@@ -1712,7 +1698,7 @@ static int kfd_ioctl_ipc_import_handle(struct file *filep,
+ args->va_addr, &args->handle,
+ &args->mmap_offset);
+ if (r)
+- dev_err(kfd_device, "Failed to import IPC handle\n");
++ pr_err("Failed to import IPC handle\n");
+
+ return r;
+ }
+@@ -1832,7 +1818,7 @@ static int kfd_ioctl_cross_memory_copy(struct file *filep,
+ pr_err("Cross mem copy failed. Permission error\n");
+ err = -EPERM;
+ } else
+- pr_err("Cross mem copy failed. Invalid task (%d)\n",
++ pr_err("Cross mem copy failed. Invalid task %d\n",
+ err);
+ goto mm_access_fail;
+ }
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
+index 55c5e4e..26f6e72 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
+@@ -411,7 +411,7 @@ static int kfd_parse_subtype(struct crat_subtype_generic *sub_type_hdr,
+ ret = kfd_parse_subtype_iolink(iolink, device_list);
+ break;
+ default:
+- pr_warn("Unknown subtype (%d) in CRAT\n",
++ pr_warn("Unknown subtype %d in CRAT\n",
+ sub_type_hdr->type);
+ }
+
+@@ -471,7 +471,7 @@ int kfd_parse_crat_table(void *crat_image,
+ sub_type_hdr = (struct crat_subtype_generic *)(crat_table+1);
+ while ((char *)sub_type_hdr + sizeof(struct crat_subtype_generic) <
+ ((char *)crat_image) + image_len) {
+- pr_debug("kfd parsing crat sub type header %p enabled: %s type: 0x%x length %d\n",
++ pr_debug("Parsing CRAT subtype header %p enabled: %s type: 0x%x length %d\n",
+ sub_type_hdr,
+ (sub_type_hdr->flags &
+ CRAT_SUBTYPE_FLAGS_ENABLED)
+@@ -480,9 +480,9 @@ int kfd_parse_crat_table(void *crat_image,
+ sub_type_hdr->length);
+
+ if (sub_type_hdr->length == 0) {
+- pr_err("amdkfd: Parsing wrong CRAT's sub header last header type: %d last header len %d\n",
++ pr_err("Parsing wrong CRAT's subtype header last header type: %d last header len %d\n",
+ last_header_type, last_header_type);
+- pr_err("amdkfd: Current header type %d length %d\n",
++ pr_err("Current header type %d length %d\n",
+ sub_type_hdr->type, sub_type_hdr->length);
+ break;
+ }
+@@ -1008,7 +1008,7 @@ static int kfd_fill_gpu_memory_affinity(int *avail_size,
+
+ sub_type_hdr->proximity_domain = proximity_domain;
+
+- pr_debug("amdkfd: fill gpu memory affinity - type 0x%x size 0x%llx\n",
++ pr_debug("Fill gpu memory affinity - type 0x%x size 0x%llx\n",
+ type, size);
+
+ sub_type_hdr->length_low = lower_32_bits(size);
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c b/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c
+index 0fdc147..07c42d2 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c
+@@ -66,8 +66,7 @@ static int dbgdev_diq_submit_ib(struct kfd_dbgdev *dbgdev,
+
+ if ((kq == NULL) || (packet_buff == NULL) ||
+ (size_in_bytes == 0)) {
+- pr_debug("Error! kfd: In func %s >> Illegal packet parameters\n",
+- __func__);
++ pr_err("Illegal packet parameters\n");
+ return -EINVAL;
+ }
+ /* todo - enter proper locking to be multithreaded safe */
+@@ -83,8 +82,7 @@ static int dbgdev_diq_submit_ib(struct kfd_dbgdev *dbgdev,
+ pq_packets_size_in_bytes / sizeof(uint32_t),
+ &ib_packet_buff);
+ if (status != 0) {
+- pr_debug("Error! kfd: In func %s >> acquire_packet_buffer failed\n",
+- __func__);
++ pr_err("acquire_packet_buffer failed\n");
+ return status;
+ }
+
+@@ -128,8 +126,7 @@ static int dbgdev_diq_submit_ib(struct kfd_dbgdev *dbgdev,
+ &mem_obj);
+
+ if (status != 0) {
+- pr_debug("Error! kfd: In func %s >> failed to allocate GART memory\n",
+- __func__);
++ pr_err("Failed to allocate GART memory\n");
+ return status;
+ }
+
+@@ -197,8 +194,7 @@ static int dbgdev_register_diq(struct kfd_dbgdev *dbgdev)
+ struct process_queue_manager *pqm = dbgdev->pqm;
+
+ if (!pqm) {
+- pr_debug("Error! kfd: In func %s >> No PQM\n",
+- __func__);
++ pr_err("No PQM\n");
+ return -EFAULT;
+ }
+
+@@ -208,18 +204,16 @@ static int dbgdev_register_diq(struct kfd_dbgdev *dbgdev)
+ &properties, &qid);
+
+ if (status != 0) {
+- pr_debug("Error! kfd: In func %s >> Create Queue failed\n",
+- __func__);
++ pr_err("Create Queue failed\n");
+ return status;
+ }
+
+- pr_debug("kfd: DIQ Created with queue id: %d\n", qid);
++ pr_debug("DIQ Created with queue id: %d\n", qid);
+
+ kq = pqm_get_kernel_queue(dbgdev->pqm, qid);
+
+ if (kq == NULL) {
+- pr_debug("Error! kfd: In func %s >> Error getting Kernel Queue\n",
+- __func__);
++ pr_err("Error getting Kernel Queue\n");
+ return -ENOMEM;
+ }
+ dbgdev->kq = kq;
+@@ -242,7 +236,7 @@ static int dbgdev_unregister_diq(struct kfd_dbgdev *dbgdev)
+
+ if ((dbgdev == NULL) || (dbgdev->pqm == NULL) ||
+ (dbgdev->kq == NULL)) {
+- pr_debug("kfd Err:In func %s >> can't destroy diq\n", __func__);
++ pr_err("Can't destroy diq\n");
+ status = -EFAULT;
+ } else {
+ pqm_destroy_queue(dbgdev->pqm,
+@@ -295,7 +289,7 @@ static void dbgdev_address_watch_set_registers(
+ }
+
+ static int dbgdev_address_watch_nodiq(struct kfd_dbgdev *dbgdev,
+- struct dbg_address_watch_info *adw_info)
++ struct dbg_address_watch_info *adw_info)
+ {
+
+ union TCP_WATCH_ADDR_H_BITS addrHi;
+@@ -313,8 +307,7 @@ static int dbgdev_address_watch_nodiq(struct kfd_dbgdev *dbgdev,
+ pdd = kfd_get_process_device_data(dbgdev->dev,
+ adw_info->process);
+ if (!pdd) {
+- pr_debug("Error! kfd: In func %s >> no PDD available\n",
+- __func__);
++ pr_err("No PDD available\n");
+ return -EFAULT;
+ }
+
+@@ -371,7 +364,7 @@ static int dbgdev_address_watch_nodiq(struct kfd_dbgdev *dbgdev,
+ }
+
+ static int dbgdev_address_watch_diq(struct kfd_dbgdev *dbgdev,
+- struct dbg_address_watch_info *adw_info)
++ struct dbg_address_watch_info *adw_info)
+ {
+
+ int status = 0;
+@@ -519,8 +512,7 @@ static int dbgdev_address_watch_diq(struct kfd_dbgdev *dbgdev,
+ ib_size, true);
+
+ if (status != 0) {
+- pr_debug("Error! kfd: In func %s >> failed to submit DIQ packet\n",
+- __func__);
++ pr_err("Failed to submit DIQ packet\n");
+ return status;
+ }
+
+@@ -593,22 +585,22 @@ static int dbgdev_wave_control_set_registers(
+ case HSA_DBG_WAVEOP_HALT:
+ if (asic_family == CHIP_KAVERI) {
+ reg_sq_cmd.bits.cmd = SQ_IND_CMD_CMD_HALT;
+- pr_debug("kfd:dbgdev: halting KV\n");
++ pr_debug("Halting KV\n");
+ } else {
+ reg_sq_cmd.bits_sethalt.cmd = SQ_IND_CMD_NEW_SETHALT;
+ reg_sq_cmd.bits_sethalt.data = SQ_IND_CMD_DATA_HALT;
+- pr_debug("kfd:dbgdev: halting CZ\n");
++ pr_debug("Halting CZ\n");
+ }
+ break;
+
+ case HSA_DBG_WAVEOP_RESUME:
+ if (asic_family == CHIP_KAVERI) {
+ reg_sq_cmd.bits.cmd = SQ_IND_CMD_CMD_RESUME;
+- pr_debug("kfd:dbgdev: resuming KV\n");
++ pr_debug("Resuming KV\n");
+ } else {
+ reg_sq_cmd.bits_sethalt.cmd = SQ_IND_CMD_NEW_SETHALT;
+ reg_sq_cmd.bits_sethalt.data = SQ_IND_CMD_DATA_RESUME;
+- pr_debug("kfd:dbgdev: resuming CZ\n");
++ pr_debug("Resuming CZ\n");
+ }
+ break;
+
+@@ -870,7 +862,7 @@ int dbgdev_wave_reset_wavefronts(struct kfd_dev *dev, struct kfd_process *p)
+ }
+
+ if (vmid > last_vmid_to_scan) {
+- pr_err("amdkfd: didn't find vmid for pasid (%d)\n", p->pasid);
++ pr_err("Didn't find vmid for pasid %d\n", p->pasid);
+ return -EFAULT;
+ }
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_dbgmgr.c b/drivers/gpu/drm/amd/amdkfd/kfd_dbgmgr.c
+index 603cdc3..6a92a74 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_dbgmgr.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_dbgmgr.c
+@@ -69,8 +69,7 @@ bool kfd_dbgmgr_create(struct kfd_dbgmgr **ppmgr, struct kfd_dev *pdev)
+
+ new_buff = kfd_alloc_struct(new_buff);
+ if (!new_buff) {
+- dev_err(NULL, "Error! kfd: In func %s >> failed to allocate dbgmgr instance\n",
+- __func__);
++ pr_err("Failed to allocate dbgmgr instance\n");
+ return false;
+ }
+
+@@ -78,8 +77,7 @@ bool kfd_dbgmgr_create(struct kfd_dbgmgr **ppmgr, struct kfd_dev *pdev)
+ new_buff->dev = pdev;
+ new_buff->dbgdev = kfd_alloc_struct(new_buff->dbgdev);
+ if (!new_buff->dbgdev) {
+- dev_err(NULL, "Error! kfd: In func %s >> failed to allocate dbgdev\n",
+- __func__);
++ pr_err("Failed to allocate dbgdev\n");
+ kfree(new_buff);
+ return false;
+ }
+@@ -94,17 +92,11 @@ bool kfd_dbgmgr_create(struct kfd_dbgmgr **ppmgr, struct kfd_dev *pdev)
+ return true;
+ }
+
+-/*===========================================================================*/
+-
+-long
+-kfd_dbgmgr_register(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
++long kfd_dbgmgr_register(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
+ {
+- if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev)) {
+- dev_info(NULL, "Error! kfd: In func %s >> Illegal pointers\n",
+- __func__);
+- /* Invalid Pointer. */
++ if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev))
+ return -EINVAL;
+- }
++
+ if (pmgr->pasid != 0) {
+ /* HW debugger is already active. */
+ return -EBUSY;
+@@ -126,19 +118,13 @@ kfd_dbgmgr_register(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
+ return 0;
+ }
+
+-/* ========================================================================= */
+-
+-long
+-kfd_dbgmgr_unregister(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
++long kfd_dbgmgr_unregister(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
+ {
+
+ if ((pmgr == NULL) || (pmgr->dev == NULL) || (pmgr->dbgdev == NULL) ||
+- (p == NULL)) {
+- dev_info(NULL, "Error! kfd: In func %s >> Illegal pointers\n",
+- __func__);
+- /* Invalid Pointer */
++ (p == NULL))
+ return -EINVAL;
+- }
++
+ if (pmgr->pasid != p->pasid) {
+ /* Is the requests coming from the already registered
+ * process?
+@@ -157,21 +143,13 @@ kfd_dbgmgr_unregister(struct kfd_dbgmgr *pmgr, struct kfd_process *p)
+ return 0;
+ }
+
+-/* ========================================================================= */
+-
+-long
+-kfd_dbgmgr_wave_control(struct kfd_dbgmgr *pmgr,
++long kfd_dbgmgr_wave_control(struct kfd_dbgmgr *pmgr,
+ struct dbg_wave_control_info *wac_info)
+ {
+- dev_info(NULL, "kfd: In func %s\n", __func__);
+-
+- if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev) || (!wac_info)
+- || (wac_info->process == NULL)) {
+- /* Invalid Pointer */
+- dev_info(NULL, "Error! kfd: In func %s >> Illegal pointers\n",
+- __func__);
++ if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev) || (!wac_info) ||
++ (wac_info->process == NULL))
+ return -EINVAL;
+- }
++
+ /* Is the requests coming from the already registered
+ * process?
+ */
+@@ -186,21 +164,13 @@ kfd_dbgmgr_wave_control(struct kfd_dbgmgr *pmgr,
+ wac_info);
+ }
+
+-/* ========================================================================= */
+-
+-long
+-kfd_dbgmgr_address_watch(struct kfd_dbgmgr *pmgr,
++long kfd_dbgmgr_address_watch(struct kfd_dbgmgr *pmgr,
+ struct dbg_address_watch_info *adw_info)
+ {
+- dev_info(NULL, "kfd: In func %s\n", __func__);
+-
+- if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev) || (!adw_info)
+- || (adw_info->process == NULL)) {
+- /* Invalid Pointer */
+- dev_info(NULL, "Error! kfd: In func %s >> Illegal pointers\n",
+- __func__);
++ if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev) || (!adw_info) ||
++ (adw_info->process == NULL))
+ return -EINVAL;
+- }
++
+ /* Is the requests coming from the already registered
+ * process?
+ */
+@@ -216,29 +186,21 @@ kfd_dbgmgr_address_watch(struct kfd_dbgmgr *pmgr,
+ }
+
+
+-/* ========================================================================= */
+ /*
+ * Handle abnormal process termination
+ * if we are in the midst of a debug session, we should kill all pending waves
+ * of the debugged process and unregister the process from the Debugger.
+ */
+-long
+-kfd_dbgmgr_abnormal_termination(struct kfd_dbgmgr *pmgr,
++long kfd_dbgmgr_abnormal_termination(struct kfd_dbgmgr *pmgr,
+ struct kfd_process *process)
+ {
+ long status = 0;
+ struct dbg_wave_control_info wac_info;
+
+- dev_info(NULL, "kfd: In func %s\n", __func__);
+-
+- if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev)) {
+- /* Invalid Pointer */
+- dev_info(NULL, "Error! kfd: In func %s >> Illegal pointers\n",
+- __func__);
++ if ((!pmgr) || (!pmgr->dev) || (!pmgr->dbgdev))
+ return -EINVAL;
+- }
+- /* first, we kill all the wavefronts of this process */
+
++ /* first, we kill all the wavefronts of this process */
+ wac_info.process = process;
+ wac_info.mode = HSA_DBG_WAVEMODE_BROADCAST_PROCESS;
+ wac_info.operand = HSA_DBG_WAVEOP_KILL;
+@@ -252,8 +214,7 @@ kfd_dbgmgr_abnormal_termination(struct kfd_dbgmgr *pmgr,
+ &wac_info);
+
+ if (status != 0) {
+- dev_info(NULL, "Error! kfd: In func %s: wave control failed, status is: %ld\n",
+- __func__, status);
++ pr_err("wave control failed, status is: %ld\n", status);
+ return status;
+ }
+ if (pmgr->pasid == wac_info.process->pasid) {
+@@ -264,11 +225,8 @@ kfd_dbgmgr_abnormal_termination(struct kfd_dbgmgr *pmgr,
+ pmgr->pasid = 0;
+ }
+ if (status != 0)
+- dev_info(NULL,
+- "Error! kfd: In func %s: unregister failed, status is: %ld debugger can not be reused\n",
+- __func__, status);
++ pr_err("unregister failed, status is: %ld debugger can not be reused\n",
++ status);
+
+ return status;
+ }
+-
+-/* ///////////////////////////////////////////////////////////////////////// */
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device.c b/drivers/gpu/drm/amd/amdkfd/kfd_device.c
+index 0abccc4..b5ecfff 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_device.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device.c
+@@ -296,7 +296,7 @@ struct kfd_dev *kgd2kfd_probe(struct kgd_dev *kgd,
+ */
+ if (pci_enable_atomic_ops_to_root(pdev) < 0) {
+ dev_info(kfd_device,
+- "skipped device (%x:%x), PCI rejects atomics",
++ "skipped device %x:%x, PCI rejects atomics",
+ pdev->vendor, pdev->device);
+ return NULL;
+ }
+@@ -340,7 +340,7 @@ static bool device_iommu_pasid_init(struct kfd_dev *kfd)
+ }
+
+ if ((iommu_info.flags & required_iommu_flags) != required_iommu_flags) {
+- dev_err(kfd_device, "error required iommu flags ats(%i), pri(%i), pasid(%i)\n",
++ dev_err(kfd_device, "error required iommu flags ats %i, pri %i, pasid %i\n",
+ (iommu_info.flags & AMD_IOMMU_DEVICE_FLAG_ATS_SUP) != 0,
+ (iommu_info.flags & AMD_IOMMU_DEVICE_FLAG_PRI_SUP) != 0,
+ (iommu_info.flags & AMD_IOMMU_DEVICE_FLAG_PASID_SUP)
+@@ -421,7 +421,7 @@ static int kfd_cwsr_init(struct kfd_dev *kfd)
+ }
+
+ if (size > PAGE_SIZE) {
+- pr_err("amdkfd: wrong CWSR ISA size.\n");
++ pr_err("Wrong CWSR ISA size.\n");
+ return -EINVAL;
+ }
+ kfd->cwsr_size =
+@@ -429,7 +429,7 @@ static int kfd_cwsr_init(struct kfd_dev *kfd)
+ kfd->cwsr_pages = alloc_pages(GFP_KERNEL | __GFP_HIGHMEM,
+ get_order(kfd->cwsr_size));
+ if (!kfd->cwsr_pages) {
+- pr_err("amdkfd: error alloc CWSR isa memory.\n");
++ pr_err("Failed to allocate CWSR isa memory.\n");
+ return -ENOMEM;
+ }
+ /*Only first page used for cwsr ISA code */
+@@ -490,7 +490,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ if ((hws_max_conc_proc < 0)
+ || (hws_max_conc_proc > vmid_num_kfd)) {
+ dev_err(kfd_device,
+- "hws_max_conc_proc (%d) must be between 0 and %d, use %d instead\n",
++ "hws_max_conc_proc %d must be between 0 and %d, use %d instead\n",
+ hws_max_conc_proc, vmid_num_kfd, vmid_num_kfd);
+ kfd->max_proc_per_quantum = vmid_num_kfd;
+ } else
+@@ -518,13 +518,13 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ kfd->kgd, size, &kfd->gtt_mem,
+ &kfd->gtt_start_gpu_addr, &kfd->gtt_start_cpu_ptr)){
+ dev_err(kfd_device,
+- "Could not allocate %d bytes for device (%x:%x)\n",
++ "Could not allocate %d bytes for device %x:%x\n",
+ size, kfd->pdev->vendor, kfd->pdev->device);
+ goto out;
+ }
+
+ dev_info(kfd_device,
+- "Allocated %d bytes on gart for device(%x:%x)\n",
++ "Allocated %d bytes on gart for device %x:%x\n",
+ size, kfd->pdev->vendor, kfd->pdev->device);
+
+ /* Initialize GTT sa with 512 byte chunk size */
+@@ -538,14 +538,14 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+
+ if (kfd_topology_add_device(kfd) != 0) {
+ dev_err(kfd_device,
+- "Error adding device (%x:%x) to topology\n",
++ "Error adding device %x:%x to topology\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ goto kfd_topology_add_device_error;
+ }
+
+ if (kfd_interrupt_init(kfd)) {
+ dev_err(kfd_device,
+- "Error initializing interrupts for device (%x:%x)\n",
++ "Error initializing interrupts for device %x:%x\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ goto kfd_interrupt_error;
+ }
+@@ -553,7 +553,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ kfd->dqm = device_queue_manager_init(kfd);
+ if (!kfd->dqm) {
+ dev_err(kfd_device,
+- "Error initializing queue manager for device (%x:%x)\n",
++ "Error initializing queue manager for device %x:%x\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ goto device_queue_manager_error;
+ }
+@@ -562,7 +562,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ if (kfd->device_info->is_need_iommu_device) {
+ if (!device_iommu_pasid_init(kfd)) {
+ dev_err(kfd_device,
+- "Error initializing iommuv2 for device (%x:%x)\n",
++ "Error initializing iommuv2 for device %x:%x\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ goto device_iommu_pasid_error;
+ }
+@@ -586,10 +586,10 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ spin_lock_init(&kfd->tlb_invalidation_lock);
+
+ kfd->init_complete = true;
+- dev_info(kfd_device, "added device (%x:%x)\n", kfd->pdev->vendor,
++ dev_info(kfd_device, "added device %x:%x\n", kfd->pdev->vendor,
+ kfd->pdev->device);
+
+- pr_debug("kfd: Starting kfd with the following scheduling policy %d\n",
++ pr_debug("Starting kfd with the following scheduling policy %d\n",
+ kfd->dqm->sched_policy);
+
+ goto out;
+@@ -607,7 +607,7 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
+ kfd_gtt_sa_init_error:
+ kfd->kfd2kgd->free_gtt_mem(kfd->kgd, kfd->gtt_mem);
+ dev_err(kfd_device,
+- "device (%x:%x) NOT added due to errors\n",
++ "device %x:%x NOT added due to errors\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ out:
+ return kfd->init_complete;
+@@ -688,7 +688,7 @@ static int kfd_resume(struct kfd_dev *kfd)
+ err = kfd->dqm->ops.start(kfd->dqm);
+ if (err) {
+ dev_err(kfd_device,
+- "Error starting queue manager for device (%x:%x)\n",
++ "Error starting queue manager for device %x:%x\n",
+ kfd->pdev->vendor, kfd->pdev->device);
+ goto dqm_start_error;
+ }
+@@ -1020,7 +1020,7 @@ static int kfd_gtt_sa_init(struct kfd_dev *kfd, unsigned int buf_size,
+ if (!kfd->gtt_sa_bitmap)
+ return -ENOMEM;
+
+- pr_debug("kfd: gtt_sa_num_of_chunks = %d, gtt_sa_bitmap = %p\n",
++ pr_debug("gtt_sa_num_of_chunks = %d, gtt_sa_bitmap = %p\n",
+ kfd->gtt_sa_num_of_chunks, kfd->gtt_sa_bitmap);
+
+ mutex_init(&kfd->gtt_sa_lock);
+@@ -1066,7 +1066,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size,
+ if ((*mem_obj) == NULL)
+ return -ENOMEM;
+
+- pr_debug("kfd: allocated mem_obj = %p for size = %d\n", *mem_obj, size);
++ pr_debug("Allocated mem_obj = %p for size = %d\n", *mem_obj, size);
+
+ start_search = 0;
+
+@@ -1078,7 +1078,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size,
+ kfd->gtt_sa_num_of_chunks,
+ start_search);
+
+- pr_debug("kfd: found = %d\n", found);
++ pr_debug("Found = %d\n", found);
+
+ /* If there wasn't any free chunk, bail out */
+ if (found == kfd->gtt_sa_num_of_chunks)
+@@ -1096,12 +1096,12 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size,
+ found,
+ kfd->gtt_sa_chunk_size);
+
+- pr_debug("kfd: gpu_addr = %p, cpu_addr = %p\n",
++ pr_debug("gpu_addr = %p, cpu_addr = %p\n",
+ (uint64_t *) (*mem_obj)->gpu_addr, (*mem_obj)->cpu_ptr);
+
+ /* If we need only one chunk, mark it as allocated and get out */
+ if (size <= kfd->gtt_sa_chunk_size) {
+- pr_debug("kfd: single bit\n");
++ pr_debug("Single bit\n");
+ set_bit(found, kfd->gtt_sa_bitmap);
+ goto kfd_gtt_out;
+ }
+@@ -1136,7 +1136,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size,
+
+ } while (cur_size > 0);
+
+- pr_debug("kfd: range_start = %d, range_end = %d\n",
++ pr_debug("range_start = %d, range_end = %d\n",
+ (*mem_obj)->range_start, (*mem_obj)->range_end);
+
+ /* Mark the chunks as allocated */
+@@ -1150,7 +1150,7 @@ int kfd_gtt_sa_allocate(struct kfd_dev *kfd, unsigned int size,
+ return 0;
+
+ kfd_gtt_no_free_chunk:
+- pr_debug("kfd: allocation failed with mem_obj = %p\n", mem_obj);
++ pr_debug("Allocation failed with mem_obj = %p\n", mem_obj);
+ mutex_unlock(&kfd->gtt_sa_lock);
+ kfree(mem_obj);
+ return -ENOMEM;
+@@ -1166,7 +1166,7 @@ int kfd_gtt_sa_free(struct kfd_dev *kfd, struct kfd_mem_obj *mem_obj)
+ if (!mem_obj)
+ return 0;
+
+- pr_debug("kfd: free mem_obj = %p, range_start = %d, range_end = %d\n",
++ pr_debug("Free mem_obj = %p, range_start = %d, range_end = %d\n",
+ mem_obj, mem_obj->range_start, mem_obj->range_end);
+
+ mutex_lock(&kfd->gtt_sa_lock);
+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 99844c5..bae79d0 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c
+@@ -134,7 +134,7 @@ static int allocate_doorbell(struct qcm_process_device *qpd, struct queue *q)
+ found = find_first_zero_bit(qpd->doorbell_bitmap,
+ KFD_MAX_NUM_OF_QUEUES_PER_PROCESS);
+ if (found >= KFD_MAX_NUM_OF_QUEUES_PER_PROCESS) {
+- pr_debug("amdkfd: No doorbells available");
++ pr_debug("No doorbells available");
+ return -EBUSY;
+ }
+ set_bit(found, qpd->doorbell_bitmap);
+@@ -175,7 +175,7 @@ static int allocate_vmid(struct device_queue_manager *dqm,
+ dqm->vmid_bitmap &= ~(1 << bit);
+
+ allocated_vmid = bit + dqm->dev->vm_info.first_vmid_kfd;
+- pr_debug("kfd: vmid allocation %d\n", allocated_vmid);
++ pr_debug("vmid allocation %d\n", allocated_vmid);
+ qpd->vmid = allocated_vmid;
+ q->properties.vmid = allocated_vmid;
+
+@@ -218,7 +218,7 @@ static void deallocate_vmid(struct device_queue_manager *dqm,
+ /* On GFX v7, CP doesn't flush TC at dequeue */
+ if (q->device->device_info->asic_family == CHIP_HAWAII)
+ if (flush_texture_cache_nocpsch(q->device, qpd))
+- pr_err("kfd: Failed to flush TC\n");
++ pr_err("Failed to flush TC\n");
+
+ /* Release the vmid mapping */
+ set_pasid_vmid_mapping(dqm, 0, qpd->vmid);
+@@ -237,13 +237,12 @@ static int create_queue_nocpsch(struct device_queue_manager *dqm,
+
+ BUG_ON(!dqm || !q || !qpd || !allocated_vmid);
+
+- pr_debug("kfd: In func %s\n", __func__);
+ print_queue(q);
+
+ mutex_lock(&dqm->lock);
+
+ if (dqm->total_queue_count >= max_num_of_queues_per_device) {
+- pr_warn("amdkfd: Can't create new usermode queue because %d queues were already created\n",
++ pr_warn("Can't create new usermode queue because %d queues were already created\n",
+ dqm->total_queue_count);
+ mutex_unlock(&dqm->lock);
+ return -EPERM;
+@@ -329,8 +328,7 @@ static int allocate_hqd(struct device_queue_manager *dqm, struct queue *q)
+ if (!set)
+ return -EBUSY;
+
+- pr_debug("kfd: DQM %s hqd slot - pipe (%d) queue(%d)\n",
+- __func__, q->pipe, q->queue);
++ pr_debug("hqd slot - pipe %d, queue %d\n", q->pipe, q->queue);
+ /* horizontal hqd allocation */
+ dqm->next_pipe_to_allocate = (pipe + 1) % get_pipes_per_mec(dqm);
+
+@@ -369,9 +367,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
+ if (retval != 0)
+ goto out_deallocate_doorbell;
+
+- pr_debug("kfd: loading mqd to hqd on pipe (%d) queue (%d)\n",
+- q->pipe,
+- q->queue);
++ pr_debug("Loading mqd to hqd on pipe %d, queue %d\n",
++ q->pipe, q->queue);
+
+ dqm->dev->kfd2kgd->alloc_memory_of_scratch(
+ dqm->dev->kgd, qpd->sh_hidden_private_base, qpd->vmid);
+@@ -423,8 +420,8 @@ static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm,
+ dqm->sdma_queue_count--;
+ deallocate_sdma_queue(dqm, q->sdma_id);
+ } else {
+- pr_debug("q->properties.type is invalid (%d)\n",
+- q->properties.type);
++ pr_debug("q->properties.type %d is invalid\n",
++ q->properties.type);
+ retval = -EINVAL;
+ }
+ dqm->total_queue_count--;
+@@ -556,13 +553,13 @@ static struct mqd_manager *get_mqd_manager_nocpsch(
+
+ BUG_ON(!dqm || type >= KFD_MQD_TYPE_MAX);
+
+- pr_debug("kfd: In func %s mqd type %d\n", __func__, type);
++ pr_debug("mqd type %d\n", type);
+
+ mqd = dqm->mqds[type];
+ if (!mqd) {
+ mqd = mqd_manager_init(type, dqm->dev);
+ if (mqd == NULL)
+- pr_err("kfd: mqd manager is NULL");
++ pr_err("mqd manager is NULL");
+ dqm->mqds[type] = mqd;
+ }
+
+@@ -648,7 +645,7 @@ int process_restore_queues(struct device_queue_manager *dqm,
+
+ /* Update PD Base in QPD */
+ qpd->page_table_base = pd_base;
+- pr_debug("Updated PD address to 0x%08x in %s\n", pd_base, __func__);
++ pr_debug("Updated PD address to 0x%08x\n", pd_base);
+
+ if (dqm->sched_policy == KFD_SCHED_POLICY_NO_HWS &&
+ !list_empty(&qpd->queues_list)) {
+@@ -703,8 +700,6 @@ static int register_process(struct device_queue_manager *dqm,
+
+ BUG_ON(!dqm || !qpd);
+
+- pr_debug("In func %s\n", __func__);
+-
+ n = kzalloc(sizeof(struct device_process_node), GFP_KERNEL);
+ if (!n)
+ return -ENOMEM;
+@@ -720,7 +715,7 @@ static int register_process(struct device_queue_manager *dqm,
+
+ /* Update PD Base in QPD */
+ qpd->page_table_base = pd_base;
+- pr_debug("Updated PD address to 0x%08x in %s\n", pd_base, __func__);
++ pr_debug("Updated PD address to 0x%08x\n", pd_base);
+
+ retval = dqm->asic_ops.update_qpd(dqm, qpd);
+
+@@ -739,8 +734,6 @@ static int unregister_process(struct device_queue_manager *dqm,
+
+ BUG_ON(!dqm || !qpd);
+
+- pr_debug("In func %s\n", __func__);
+-
+ pr_debug("qpd->queues_list is %s\n",
+ list_empty(&qpd->queues_list) ? "empty" : "not empty");
+
+@@ -793,7 +786,6 @@ static int init_scheduler(struct device_queue_manager *dqm)
+
+ BUG_ON(!dqm);
+
+- pr_debug("kfd: In %s\n", __func__);
+
+ return retval;
+ }
+@@ -804,8 +796,7 @@ static int initialize_nocpsch(struct device_queue_manager *dqm)
+
+ BUG_ON(!dqm);
+
+- pr_debug("kfd: In func %s num of pipes: %d\n",
+- __func__, get_pipes_per_mec(dqm));
++ pr_debug("num of pipes: %d\n", get_pipes_per_mec(dqm));
+
+ dqm->allocated_queues = kcalloc(get_pipes_per_mec(dqm),
+ sizeof(unsigned int), GFP_KERNEL);
+@@ -899,9 +890,9 @@ static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
+ if (retval)
+ goto out_deallocate_sdma_queue;
+
+- pr_debug("kfd: sdma id is: %d\n", q->sdma_id);
+- pr_debug(" sdma queue id: %d\n", q->properties.sdma_queue_id);
+- pr_debug(" sdma engine id: %d\n", q->properties.sdma_engine_id);
++ pr_debug("SDMA id is: %d\n", q->sdma_id);
++ pr_debug("SDMA queue id: %d\n", q->properties.sdma_queue_id);
++ pr_debug("SDMA engine id: %d\n", q->properties.sdma_engine_id);
+
+ dqm->asic_ops.init_sdma_vm(dqm, q, qpd);
+ retval = mqd->init_mqd(mqd, &q->mqd, &q->mqd_mem_obj,
+@@ -936,8 +927,6 @@ static int set_sched_resources(struct device_queue_manager *dqm)
+
+ BUG_ON(!dqm);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ res.vmid_mask = dqm->dev->shared_resources.compute_vmid_bitmap;
+
+ res.queue_mask = 0;
+@@ -965,9 +954,9 @@ static int set_sched_resources(struct device_queue_manager *dqm)
+ res.gws_mask = res.oac_mask = res.gds_heap_base =
+ res.gds_heap_size = 0;
+
+- pr_debug("kfd: scheduling resources:\n"
+- " vmid mask: 0x%8X\n"
+- " queue mask: 0x%8llX\n",
++ pr_debug("Scheduling resources:\n"
++ "vmid mask: 0x%8X\n"
++ "queue mask: 0x%8llX\n",
+ res.vmid_mask, res.queue_mask);
+
+ return pm_send_set_resources(&dqm->packets, &res);
+@@ -979,8 +968,7 @@ static int initialize_cpsch(struct device_queue_manager *dqm)
+
+ BUG_ON(!dqm);
+
+- pr_debug("kfd: In func %s num of pipes: %d\n",
+- __func__, get_pipes_per_mec(dqm));
++ pr_debug("num of pipes: %d\n", get_pipes_per_mec(dqm));
+
+ mutex_init(&dqm->lock);
+ INIT_LIST_HEAD(&dqm->queues);
+@@ -1015,7 +1003,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
+ if (retval != 0)
+ goto fail_set_sched_resources;
+
+- pr_debug("kfd: allocating fence memory\n");
++ pr_debug("Allocating fence memory\n");
+
+ /* allocate fence memory on the gart */
+ retval = kfd_gtt_sa_allocate(dqm->dev, sizeof(*dqm->fence_addr),
+@@ -1063,11 +1051,9 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
+ {
+ BUG_ON(!dqm || !kq || !qpd);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ mutex_lock(&dqm->lock);
+ if (dqm->total_queue_count >= max_num_of_queues_per_device) {
+- pr_warn("amdkfd: Can't create new kernel queue because %d queues were already created\n",
++ pr_warn("Can't create new kernel queue because %d queues were already created\n",
+ dqm->total_queue_count);
+ mutex_unlock(&dqm->lock);
+ return -EPERM;
+@@ -1096,8 +1082,6 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
+ {
+ BUG_ON(!dqm || !kq);
+
+- pr_debug("kfd: In %s\n", __func__);
+-
+ mutex_lock(&dqm->lock);
+ /* here we actually preempt the DIQ */
+ list_del(&kq->list);
+@@ -1130,7 +1114,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
+ mutex_lock(&dqm->lock);
+
+ if (dqm->total_queue_count >= max_num_of_queues_per_device) {
+- pr_warn("amdkfd: Can't create new usermode queue because %d queues were already created\n",
++ pr_warn("Can't create new usermode queue because %d queues were already created\n",
+ dqm->total_queue_count);
+ retval = -EPERM;
+ goto out_unlock;
+@@ -1218,7 +1202,7 @@ int amdkfd_fence_wait_timeout(unsigned int *fence_addr,
+
+ while (*fence_addr != fence_value) {
+ if (time_after(jiffies, end_jiffies)) {
+- pr_err("kfd: qcm fence wait loop timeout expired\n");
++ pr_err("qcm fence wait loop timeout expired\n");
+ return -ETIME;
+ }
+ schedule();
+@@ -1274,7 +1258,7 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+ if (!dqm->active_runlist)
+ return retval;
+
+- pr_debug("kfd: Before destroying queues, sdma queue count is : %u\n",
++ pr_debug("Before destroying queues, sdma queue count is : %u\n",
+ dqm->sdma_queue_count);
+
+ if (dqm->sdma_queue_count > 0) {
+@@ -1294,7 +1278,7 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+ retval = amdkfd_fence_wait_timeout(dqm->fence_addr, KFD_FENCE_COMPLETED,
+ QUEUE_PREEMPT_DEFAULT_TIMEOUT_MS);
+ if (retval != 0) {
+- pr_err("kfd: unmapping queues failed.");
++ pr_err("Unmapping queues failed.");
+ return retval;
+ }
+
+@@ -1313,15 +1297,13 @@ static int execute_queues_cpsch(struct device_queue_manager *dqm,
+
+ BUG_ON(!dqm);
+
+- pr_debug("In function %s\n", __func__);
+-
+ filter = static_queues_included ?
+ KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+ KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
+
+ retval = unmap_queues_cpsch(dqm, filter, 0, false);
+ if (retval != 0) {
+- pr_err("kfd: the cp might be in an unrecoverable state due to an unsuccessful queues preemption");
++ pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
+ return retval;
+ }
+
+@@ -1415,8 +1397,6 @@ static bool set_cache_memory_policy(struct device_queue_manager *dqm,
+ {
+ bool retval = true;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ if (!dqm->asic_ops.set_cache_memory_policy)
+ return retval;
+
+@@ -1464,7 +1444,7 @@ static bool set_cache_memory_policy(struct device_queue_manager *dqm,
+ if ((dqm->sched_policy == KFD_SCHED_POLICY_NO_HWS) && (qpd->vmid != 0))
+ program_sh_mem_settings(dqm, qpd);
+
+- pr_debug("kfd: sh_mem_config: 0x%x, ape1_base: 0x%x, ape1_limit: 0x%x\n",
++ pr_debug("sh_mem_config: 0x%x, ape1_base: 0x%x, ape1_limit: 0x%x\n",
+ qpd->sh_mem_config, qpd->sh_mem_ape1_base,
+ qpd->sh_mem_ape1_limit);
+
+@@ -1596,7 +1576,7 @@ struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
+
+ BUG_ON(!dev);
+
+- pr_debug("kfd: loading device queue manager\n");
++ pr_debug("Loading device queue manager\n");
+
+ dqm = kzalloc(sizeof(struct device_queue_manager), GFP_KERNEL);
+ if (!dqm)
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
+index bf24368..f051e0d 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_cik.c
+@@ -144,7 +144,7 @@ static int update_qpd_cik(struct device_queue_manager *dqm,
+ qpd->sh_mem_config |= 1 << SH_MEM_CONFIG__PRIVATE_ATC__SHIFT;
+ }
+
+- pr_debug("kfd: is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
++ pr_debug("is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
+ qpd->pqm->process->is_32bit_user_mode, temp, qpd->sh_mem_bases);
+
+ return 0;
+@@ -176,7 +176,7 @@ static int update_qpd_cik_hawaii(struct device_queue_manager *dqm,
+ temp = get_sh_mem_bases_nybble_64(pdd);
+ qpd->sh_mem_bases = compute_sh_mem_bases_64bit(temp);
+
+- pr_debug("kfd: is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
++ pr_debug("is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
+ qpd->pqm->process->is_32bit_user_mode, temp, qpd->sh_mem_bases);
+
+ return 0;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_v9.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_v9.c
+index 786ea88..dde5882 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_v9.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_v9.c
+@@ -72,7 +72,7 @@ static int update_qpd_v9(struct device_queue_manager *dqm,
+
+ qpd->sh_mem_bases = compute_sh_mem_bases_64bit(pdd);
+
+- pr_debug("kfd: sh_mem_bases 0x%X\n", qpd->sh_mem_bases);
++ pr_debug("sh_mem_bases 0x%X\n", qpd->sh_mem_bases);
+
+ return 0;
+ }
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_vi.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_vi.c
+index 2f37b04..f6c6bea 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_vi.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager_vi.c
+@@ -194,7 +194,7 @@ static int update_qpd_vi(struct device_queue_manager *dqm,
+ SH_MEM_CONFIG__PRIVATE_ATC__SHIFT;
+ }
+
+- pr_debug("kfd: is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
++ pr_debug("is32bit process: %d sh_mem_bases nybble: 0x%X and register 0x%X\n",
+ qpd->pqm->process->is_32bit_user_mode, temp, qpd->sh_mem_bases);
+
+ return 0;
+@@ -230,7 +230,7 @@ static int update_qpd_vi_tonga(struct device_queue_manager *dqm,
+ temp = get_sh_mem_bases_nybble_64(pdd);
+ qpd->sh_mem_bases = compute_sh_mem_bases_64bit(temp);
+
+- pr_debug("kfd: sh_mem_bases nybble: 0x%X and register 0x%X\n",
++ pr_debug("sh_mem_bases nybble: 0x%X and register 0x%X\n",
+ temp, qpd->sh_mem_bases);
+
+ return 0;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c
+index 9a86b98..899fc4c 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_doorbell.c
+@@ -96,23 +96,23 @@ void kfd_doorbell_init(struct kfd_dev *kfd)
+
+ BUG_ON(!kfd->doorbell_kernel_ptr);
+
+- pr_debug("kfd: doorbell initialization:\n");
+- pr_debug("kfd: doorbell base == 0x%08lX\n",
++ pr_debug("Doorbell initialization:\n");
++ pr_debug("doorbell base == 0x%08lX\n",
+ (uintptr_t)kfd->doorbell_base);
+
+- pr_debug("kfd: doorbell_id_offset == 0x%08lX\n",
++ pr_debug("doorbell_id_offset == 0x%08lX\n",
+ kfd->doorbell_id_offset);
+
+- pr_debug("kfd: doorbell_process_limit == 0x%08lX\n",
++ pr_debug("doorbell_process_limit == 0x%08lX\n",
+ doorbell_process_limit);
+
+- pr_debug("kfd: doorbell_kernel_offset == 0x%08lX\n",
++ pr_debug("doorbell_kernel_offset == 0x%08lX\n",
+ (uintptr_t)kfd->doorbell_base);
+
+- pr_debug("kfd: doorbell aperture size == 0x%08lX\n",
++ pr_debug("doorbell aperture size == 0x%08lX\n",
+ kfd->shared_resources.doorbell_aperture_size);
+
+- pr_debug("kfd: doorbell kernel address == 0x%08lX\n",
++ pr_debug("doorbell kernel address == 0x%08lX\n",
+ (uintptr_t)kfd->doorbell_kernel_ptr);
+ }
+
+@@ -136,7 +136,7 @@ int kfd_doorbell_mmap(struct kfd_dev *dev, struct kfd_process *process,
+
+ vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+- pr_debug("kfd: mapping doorbell page in kfd_doorbell_mmap\n"
++ pr_debug("Mapping doorbell page in kfd_doorbell_mmap\n"
+ " target user address == 0x%08llX\n"
+ " physical address == 0x%08llX\n"
+ " vm_flags == 0x%04lX\n"
+@@ -181,7 +181,7 @@ void __iomem *kfd_get_kernel_doorbell(struct kfd_dev *kfd,
+ *doorbell_off = KERNEL_DOORBELL_PASID *
+ (kfd_doorbell_process_slice(kfd) / sizeof(u32)) + inx;
+
+- pr_debug("kfd: get kernel queue doorbell\n"
++ pr_debug("Get kernel queue doorbell\n"
+ " doorbell offset == 0x%08X\n"
+ " kernel address == 0x%08lX\n",
+ *doorbell_off, (uintptr_t)(kfd->doorbell_kernel_ptr + inx));
+@@ -206,7 +206,7 @@ void write_kernel_doorbell(void __iomem *db, u32 value)
+ {
+ if (db) {
+ writel(value, db);
+- pr_debug("writing %d to doorbell address 0x%p\n", value, db);
++ pr_debug("Writing %d to doorbell address 0x%p\n", value, db);
+ }
+ }
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_events.c b/drivers/gpu/drm/amd/amdkfd/kfd_events.c
+index 18198d8..ac9a463 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_events.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_events.c
+@@ -113,7 +113,7 @@ allocate_free_slot(struct kfd_process *process,
+ *out_page = page;
+ *out_slot_index = slot;
+
+- pr_debug("allocated event signal slot in page %p, slot %d\n",
++ pr_debug("Allocated event signal slot in page %p, slot %d\n",
+ page, slot);
+
+ return true;
+@@ -167,9 +167,9 @@ static bool allocate_signal_page(struct file *devkfd, struct kfd_process *p)
+ struct signal_page,
+ event_pages)->page_index + 1;
+
+- pr_debug("allocated new event signal page at %p, for process %p\n",
++ pr_debug("Allocated new event signal page at %p, for process %p\n",
+ page, p);
+- pr_debug("page index is %d\n", page->page_index);
++ pr_debug("Page index is %d\n", page->page_index);
+
+ list_add(&page->event_pages, &p->signal_event_pages);
+
+@@ -223,9 +223,9 @@ allocate_signal_page_dgpu(struct kfd_process *p,
+ struct signal_page,
+ event_pages)->page_index + 1;
+
+- pr_debug("allocated new event signal page at %p, for process %p\n",
++ pr_debug("Allocated new event signal page at %p, for process %p\n",
+ my_page, p);
+- pr_debug("page index is %d\n", my_page->page_index);
++ pr_debug("Page index is %d\n", my_page->page_index);
+
+ list_add(&my_page->event_pages, &p->signal_event_pages);
+
+@@ -274,7 +274,7 @@ allocate_debug_event_notification_slot(struct file *devkfd,
+ *out_page = page;
+ *out_slot_index = slot;
+
+- pr_debug("allocated debug event signal slot in page %p, slot %d\n",
++ pr_debug("Allocated debug event signal slot in page %p, slot %d\n",
+ page, slot);
+
+ return true;
+@@ -388,11 +388,11 @@ create_signal_event(struct file *devkfd, struct kfd_process *p,
+ {
+ if ((ev->type == KFD_EVENT_TYPE_SIGNAL) &&
+ (p->signal_event_count == KFD_SIGNAL_EVENT_LIMIT)) {
+- pr_warn("amdkfd: Signal event wasn't created because limit was reached\n");
++ pr_warn("Signal event wasn't created because limit was reached\n");
+ return -ENOMEM;
+ } else if ((ev->type == KFD_EVENT_TYPE_DEBUG) &&
+ (p->debug_event_count == KFD_DEBUG_EVENT_LIMIT)) {
+- pr_warn("amdkfd: Debug event wasn't created because limit was reached\n");
++ pr_warn("Debug event wasn't created because limit was reached\n");
+ return -ENOMEM;
+ }
+
+@@ -400,7 +400,7 @@ create_signal_event(struct file *devkfd, struct kfd_process *p,
+ if (!allocate_event_notification_slot(devkfd, p,
+ &ev->signal_page,
+ &ev->signal_slot_index)) {
+- pr_warn("amdkfd: Signal event wasn't created because out of kernel memory\n");
++ pr_warn("Signal event wasn't created because out of kernel memory\n");
+ return -ENOMEM;
+ }
+
+@@ -414,7 +414,7 @@ create_signal_event(struct file *devkfd, struct kfd_process *p,
+ if (!allocate_debug_event_notification_slot(devkfd, p,
+ &ev->signal_page,
+ &ev->signal_slot_index)) {
+- pr_warn("amdkfd: Debug event wasn't created because out of kernel memory\n");
++ pr_warn("Debug event wasn't created because out of kernel memory\n");
+ return -ENOMEM;
+ }
+
+@@ -427,7 +427,7 @@ create_signal_event(struct file *devkfd, struct kfd_process *p,
+ ev->event_id =
+ make_signal_event_id(ev->signal_page, ev->signal_slot_index);
+
+- pr_debug("signal event number %zu created with id %d, address %p\n",
++ pr_debug("Signal event number %zu created with id %d, address %p\n",
+ p->signal_event_count, ev->event_id,
+ ev->user_signal_address);
+
+@@ -977,7 +977,7 @@ int kfd_event_mmap(struct kfd_process *p, struct vm_area_struct *vma)
+ /* check required size is logical */
+ if (get_order(KFD_SIGNAL_EVENT_LIMIT * 8) !=
+ get_order(vma->vm_end - vma->vm_start)) {
+- pr_err("amdkfd: event page mmap requested illegal size\n");
++ pr_err("Event page mmap requested illegal size\n");
+ return -EINVAL;
+ }
+
+@@ -986,7 +986,7 @@ int kfd_event_mmap(struct kfd_process *p, struct vm_area_struct *vma)
+ page = lookup_signal_page_by_index(p, page_index);
+ if (!page) {
+ /* Probably KFD bug, but mmap is user-accessible. */
+- pr_debug("signal page could not be found for page_index %u\n",
++ pr_debug("Signal page could not be found for page_index %u\n",
+ page_index);
+ return -EINVAL;
+ }
+@@ -997,7 +997,7 @@ int kfd_event_mmap(struct kfd_process *p, struct vm_area_struct *vma)
+ vma->vm_flags |= VM_IO | VM_DONTCOPY | VM_DONTEXPAND | VM_NORESERVE
+ | VM_DONTDUMP | VM_PFNMAP;
+
+- pr_debug("mapping signal page\n");
++ pr_debug("Mapping signal page\n");
+ pr_debug(" start user address == 0x%08lx\n", vma->vm_start);
+ pr_debug(" end user address == 0x%08lx\n", vma->vm_end);
+ pr_debug(" pfn == 0x%016lX\n", pfn);
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_ipc.c b/drivers/gpu/drm/amd/amdkfd/kfd_ipc.c
+index e119ce7..9654d99 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_ipc.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_ipc.c
+@@ -212,7 +212,7 @@ int kfd_ipc_import_handle(struct kfd_dev *dev, struct kfd_process *p,
+ return -EINVAL;
+ ipc_obj_get(found);
+
+- pr_debug("ipc: found ipc_dma_buf: %p\n", found->data);
++ pr_debug("Found ipc_dma_buf: %p\n", found->data);
+
+ r = kfd_import_dmabuf_create_kfd_bo(dev, p, gpu_id, found->data,
+ va_addr, handle, mmap_offset,
+@@ -244,7 +244,7 @@ int kfd_ipc_export_as_handle(struct kfd_dev *dev, struct kfd_process *p,
+ up_write(&p->lock);
+
+ if (IS_ERR(pdd)) {
+- pr_err("failed to get pdd\n");
++ pr_err("Failed to get pdd\n");
+ return PTR_ERR(pdd);
+ }
+
+@@ -253,7 +253,7 @@ int kfd_ipc_export_as_handle(struct kfd_dev *dev, struct kfd_process *p,
+ up_write(&p->lock);
+
+ if (!kfd_bo) {
+- pr_err("failed to get bo");
++ pr_err("Failed to get bo");
+ return -EINVAL;
+ }
+ if (kfd_bo->kfd_ipc_obj) {
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c
+index 4a67e76..1a21c66 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue.c
+@@ -44,8 +44,8 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev,
+ BUG_ON(!kq || !dev);
+ BUG_ON(type != KFD_QUEUE_TYPE_DIQ && type != KFD_QUEUE_TYPE_HIQ);
+
+- pr_debug("amdkfd: In func %s initializing queue type %d size %d\n",
+- __func__, KFD_QUEUE_TYPE_HIQ, queue_size);
++ pr_debug("Initializing queue type %d size %d\n", KFD_QUEUE_TYPE_HIQ,
++ queue_size);
+
+ memset(&prop, 0, sizeof(prop));
+ memset(&nop, 0, sizeof(nop));
+@@ -73,13 +73,13 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev,
+ prop.doorbell_ptr = kfd_get_kernel_doorbell(dev, &prop.doorbell_off);
+
+ if (prop.doorbell_ptr == NULL) {
+- pr_err("amdkfd: error init doorbell");
++ pr_err("Failed to initialize doorbell");
+ goto err_get_kernel_doorbell;
+ }
+
+ retval = kfd_gtt_sa_allocate(dev, queue_size, &kq->pq);
+ if (retval != 0) {
+- pr_err("amdkfd: error init pq queues size (%d)\n", queue_size);
++ pr_err("Failed to init pq queues size %d\n", queue_size);
+ goto err_pq_allocate_vidmem;
+ }
+
+@@ -140,7 +140,7 @@ static bool initialize(struct kernel_queue *kq, struct kfd_dev *dev,
+
+ /* assign HIQ to HQD */
+ if (type == KFD_QUEUE_TYPE_HIQ) {
+- pr_debug("assigning hiq to hqd\n");
++ pr_debug("Assigning hiq to hqd\n");
+ kq->queue->pipe = KFD_CIK_HIQ_PIPE;
+ kq->queue->queue = KFD_CIK_HIQ_QUEUE;
+ kq->mqd->load_mqd(kq->mqd, kq->queue->mqd, kq->queue->pipe,
+@@ -227,8 +227,8 @@ static int acquire_packet_buffer(struct kernel_queue *kq,
+ queue_address = (unsigned int *)kq->pq_kernel_addr;
+ queue_size_dwords = kq->queue->properties.queue_size / sizeof(uint32_t);
+
+- pr_debug("amdkfd: In func %s\n rptr: %d\n wptr: %d\n queue_address 0x%p\n",
+- __func__, rptr, wptr, queue_address);
++ pr_debug("rptr: %d\n wptr: %d\n queue_address 0x%p\n", rptr, wptr,
++ queue_address);
+
+ available_size = (rptr + queue_size_dwords - 1 - wptr) %
+ queue_size_dwords;
+@@ -362,7 +362,7 @@ struct kernel_queue *kernel_queue_init(struct kfd_dev *dev,
+ }
+
+ if (!kq->ops.initialize(kq, dev, type, KFD_KERNEL_QUEUE_SIZE)) {
+- pr_err("amdkfd: failed to init kernel queue\n");
++ pr_err("Failed to init kernel queue\n");
+ kfree(kq);
+ return NULL;
+ }
+@@ -385,7 +385,7 @@ static __attribute__((unused)) void test_kq(struct kfd_dev *dev)
+
+ BUG_ON(!dev);
+
+- pr_err("amdkfd: starting kernel queue test\n");
++ pr_err("Starting kernel queue test\n");
+
+ kq = kernel_queue_init(dev, KFD_QUEUE_TYPE_HIQ);
+ BUG_ON(!kq);
+@@ -396,7 +396,7 @@ static __attribute__((unused)) void test_kq(struct kfd_dev *dev)
+ buffer[i] = kq->nop_packet;
+ kq->ops.submit_packet(kq);
+
+- pr_err("amdkfd: ending kernel queue test\n");
++ pr_err("Ending kernel queue test\n");
+ }
+
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue_cik.c b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue_cik.c
+index a06b0d4..2e4c6fb 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue_cik.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_kernel_queue_cik.c
+@@ -99,8 +99,6 @@ static int pm_map_process_scratch_cik(struct packet_manager *pm,
+
+ packet = (struct pm4_map_process_scratch_kv *)buffer;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ memset(buffer, 0, sizeof(struct pm4_map_process_scratch_kv));
+
+ packet->header.u32all = pm_build_pm4_header(IT_MAP_PROCESS,
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_module.c b/drivers/gpu/drm/amd/amdkfd/kfd_module.c
+index 2126ec5..71cea02 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_module.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_module.c
+@@ -120,7 +120,7 @@ static int __init kfd_module_init(void)
+ /* Verify module parameters */
+ if ((sched_policy < KFD_SCHED_POLICY_HWS) ||
+ (sched_policy > KFD_SCHED_POLICY_NO_HWS)) {
+- pr_err("kfd: sched_policy has invalid value\n");
++ pr_err("sched_policy has invalid value\n");
+ return -1;
+ }
+
+@@ -128,7 +128,7 @@ static int __init kfd_module_init(void)
+ if ((max_num_of_queues_per_device < 1) ||
+ (max_num_of_queues_per_device >
+ KFD_MAX_NUM_OF_QUEUES_PER_DEVICE)) {
+- pr_err("kfd: max_num_of_queues_per_device must be between 1 to KFD_MAX_NUM_OF_QUEUES_PER_DEVICE\n");
++ pr_err("max_num_of_queues_per_device must be between 1 to KFD_MAX_NUM_OF_QUEUES_PER_DEVICE\n");
+ return -1;
+ }
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_cik.c b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_cik.c
+index 4dff1ec..33367c3 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_cik.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_cik.c
+@@ -89,7 +89,7 @@ static void update_cu_mask(struct mqd_manager *mm, void *mqd,
+ m->compute_static_thread_mgmt_se2 = se_mask[2];
+ m->compute_static_thread_mgmt_se3 = se_mask[3];
+
+- pr_debug("kfd: update cu mask to %#x %#x %#x %#x\n",
++ pr_debug("Update cu mask to %#x %#x %#x %#x\n",
+ m->compute_static_thread_mgmt_se0,
+ m->compute_static_thread_mgmt_se1,
+ m->compute_static_thread_mgmt_se2,
+@@ -114,8 +114,6 @@ static int init_mqd(struct mqd_manager *mm, void **mqd,
+ struct cik_mqd *m;
+ int retval;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ retval = kfd_gtt_sa_allocate(mm->dev, sizeof(struct cik_mqd),
+ mqd_mem_obj);
+
+@@ -243,8 +241,6 @@ static int __update_mqd(struct mqd_manager *mm, void *mqd,
+
+ BUG_ON(!mm || !q || !mqd);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ m = get_mqd(mqd);
+ m->cp_hqd_pq_control = DEFAULT_RPTR_BLOCK_SIZE |
+ DEFAULT_MIN_AVAIL_SIZE;
+@@ -388,8 +384,6 @@ static int init_mqd_hiq(struct mqd_manager *mm, void **mqd,
+
+ BUG_ON(!mm || !q || !mqd || !mqd_mem_obj);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ retval = kfd_gtt_sa_allocate(mm->dev, sizeof(struct cik_mqd),
+ mqd_mem_obj);
+
+@@ -445,8 +439,6 @@ static int update_mqd_hiq(struct mqd_manager *mm, void *mqd,
+
+ BUG_ON(!mm || !q || !mqd);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ m = get_mqd(mqd);
+ m->cp_hqd_pq_control = DEFAULT_RPTR_BLOCK_SIZE |
+ DEFAULT_MIN_AVAIL_SIZE |
+@@ -510,8 +502,6 @@ struct mqd_manager *mqd_manager_init_cik(enum KFD_MQD_TYPE type,
+ BUG_ON(!dev);
+ BUG_ON(type >= KFD_MQD_TYPE_MAX);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ mqd = kzalloc(sizeof(struct mqd_manager), GFP_NOIO);
+ if (!mqd)
+ return NULL;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c
+index 0db4dbf..8e31af3 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_v9.c
+@@ -85,7 +85,7 @@ static void update_cu_mask(struct mqd_manager *mm, void *mqd,
+ m->compute_static_thread_mgmt_se2 = se_mask[2];
+ m->compute_static_thread_mgmt_se3 = se_mask[3];
+
+- pr_debug("kfd: update cu mask to %#x %#x %#x %#x\n",
++ pr_debug("update cu mask to %#x %#x %#x %#x\n",
+ m->compute_static_thread_mgmt_se0,
+ m->compute_static_thread_mgmt_se1,
+ m->compute_static_thread_mgmt_se2,
+@@ -194,14 +194,12 @@ static int update_mqd(struct mqd_manager *mm, void *mqd,
+ {
+ struct v9_mqd *m;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ m = get_mqd(mqd);
+
+ m->cp_hqd_pq_control = 5 << CP_HQD_PQ_CONTROL__RPTR_BLOCK_SIZE__SHIFT;
+ m->cp_hqd_pq_control |=
+ ffs(q->queue_size / sizeof(unsigned int)) - 1 - 1;
+- pr_debug("kfd: cp_hqd_pq_control 0x%x\n", m->cp_hqd_pq_control);
++ pr_debug("cp_hqd_pq_control 0x%x\n", m->cp_hqd_pq_control);
+
+ m->cp_hqd_pq_base_lo = lower_32_bits((uint64_t)q->queue_address >> 8);
+ m->cp_hqd_pq_base_hi = upper_32_bits((uint64_t)q->queue_address >> 8);
+@@ -214,7 +212,7 @@ static int update_mqd(struct mqd_manager *mm, void *mqd,
+ m->cp_hqd_pq_doorbell_control =
+ q->doorbell_off <<
+ CP_HQD_PQ_DOORBELL_CONTROL__DOORBELL_OFFSET__SHIFT;
+- pr_debug("kfd: cp_hqd_pq_doorbell_control 0x%x\n",
++ pr_debug("cp_hqd_pq_doorbell_control 0x%x\n",
+ m->cp_hqd_pq_doorbell_control);
+
+ m->cp_hqd_ib_control = 3 << CP_HQD_IB_CONTROL__MIN_IB_AVAIL_SIZE__SHIFT;
+@@ -455,8 +453,6 @@ struct mqd_manager *mqd_manager_init_v9(enum KFD_MQD_TYPE type,
+ if (WARN_ON(type >= KFD_MQD_TYPE_MAX))
+ return NULL;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ mqd = kzalloc(sizeof(struct mqd_manager), GFP_NOIO);
+ if (!mqd)
+ return NULL;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_vi.c b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_vi.c
+index ddca15f..eb7ce43 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_vi.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_mqd_manager_vi.c
+@@ -89,7 +89,7 @@ static void update_cu_mask(struct mqd_manager *mm, void *mqd,
+ m->compute_static_thread_mgmt_se2 = se_mask[2];
+ m->compute_static_thread_mgmt_se3 = se_mask[3];
+
+- pr_debug("kfd: update cu mask to %#x %#x %#x %#x\n",
++ pr_debug("Update cu mask to %#x %#x %#x %#x\n",
+ m->compute_static_thread_mgmt_se0,
+ m->compute_static_thread_mgmt_se1,
+ m->compute_static_thread_mgmt_se2,
+@@ -201,8 +201,6 @@ static int __update_mqd(struct mqd_manager *mm, void *mqd,
+
+ BUG_ON(!mm || !q || !mqd);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ m = get_mqd(mqd);
+
+ m->cp_hqd_pq_control = 5 << CP_HQD_PQ_CONTROL__RPTR_BLOCK_SIZE__SHIFT |
+@@ -210,7 +208,7 @@ static int __update_mqd(struct mqd_manager *mm, void *mqd,
+ mtype << CP_HQD_PQ_CONTROL__MTYPE__SHIFT;
+ m->cp_hqd_pq_control |=
+ ffs(q->queue_size / sizeof(unsigned int)) - 1 - 1;
+- pr_debug("kfd: cp_hqd_pq_control 0x%x\n", m->cp_hqd_pq_control);
++ pr_debug("cp_hqd_pq_control 0x%x\n", m->cp_hqd_pq_control);
+
+ m->cp_hqd_pq_base_lo = lower_32_bits((uint64_t)q->queue_address >> 8);
+ m->cp_hqd_pq_base_hi = upper_32_bits((uint64_t)q->queue_address >> 8);
+@@ -223,7 +221,7 @@ static int __update_mqd(struct mqd_manager *mm, void *mqd,
+ m->cp_hqd_pq_doorbell_control =
+ q->doorbell_off <<
+ CP_HQD_PQ_DOORBELL_CONTROL__DOORBELL_OFFSET__SHIFT;
+- pr_debug("kfd: cp_hqd_pq_doorbell_control 0x%x\n",
++ pr_debug("cp_hqd_pq_doorbell_control 0x%x\n",
+ m->cp_hqd_pq_doorbell_control);
+
+ m->cp_hqd_eop_control = atc_bit << CP_HQD_EOP_CONTROL__EOP_ATC__SHIFT |
+@@ -478,8 +476,6 @@ struct mqd_manager *mqd_manager_init_vi(enum KFD_MQD_TYPE type,
+ BUG_ON(!dev);
+ BUG_ON(type >= KFD_MQD_TYPE_MAX);
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ mqd = kzalloc(sizeof(struct mqd_manager), GFP_NOIO);
+ if (!mqd)
+ return NULL;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c
+index d4d521d..5c235bd 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c
+@@ -67,7 +67,7 @@ static void pm_calc_rlib_size(struct packet_manager *pm,
+ if ((process_count > max_proc_per_quantum) ||
+ compute_queue_count > get_queues_num(pm->dqm)) {
+ *over_subscription = true;
+- pr_debug("kfd: over subscribed runlist\n");
++ pr_debug("Over subscribed runlist\n");
+ }
+
+ map_queue_size = pm->pmf->get_map_queues_packet_size();
+@@ -82,7 +82,7 @@ static void pm_calc_rlib_size(struct packet_manager *pm,
+ if (*over_subscription)
+ *rlib_size += pm->pmf->get_runlist_packet_size();
+
+- pr_debug("kfd: runlist ib size %d\n", *rlib_size);
++ pr_debug("runlist ib size %d\n", *rlib_size);
+ }
+
+ static int pm_allocate_runlist_ib(struct packet_manager *pm,
+@@ -105,7 +105,7 @@ static int pm_allocate_runlist_ib(struct packet_manager *pm,
+ &pm->ib_buffer_obj);
+
+ if (retval != 0) {
+- pr_err("kfd: failed to allocate runlist IB\n");
++ pr_err("Failed to allocate runlist IB\n");
+ mutex_unlock(&pm->lock);
+ return retval;
+ }
+@@ -147,8 +147,7 @@ static int pm_create_runlist_ib(struct packet_manager *pm,
+ *rl_size_bytes = alloc_size_bytes;
+ pm->ib_size_bytes = alloc_size_bytes;
+
+- pr_debug("kfd: In func %s\n", __func__);
+- pr_debug("kfd: building runlist ib process count: %d queues count %d\n",
++ pr_debug("Building runlist ib process count: %d queues count %d\n",
+ pm->dqm->processes_count, pm->dqm->queue_count);
+
+ /* build the run list ib packet */
+@@ -156,7 +155,7 @@ static int pm_create_runlist_ib(struct packet_manager *pm,
+ qpd = cur->qpd;
+ /* build map process packet */
+ if (proccesses_mapped >= pm->dqm->processes_count) {
+- pr_debug("kfd: not enough space left in runlist IB\n");
++ pr_debug("Not enough space left in runlist IB\n");
+ pm_release_ib(pm);
+ return -ENOMEM;
+ }
+@@ -173,7 +172,7 @@ static int pm_create_runlist_ib(struct packet_manager *pm,
+ if (!kq->queue->properties.is_active)
+ continue;
+
+- pr_debug("kfd: static_queue, mapping kernel q %d, is debug status %d\n",
++ pr_debug("static_queue, mapping kernel q %d, is debug status %d\n",
+ kq->queue->queue, qpd->is_debug);
+
+ retval = pm->pmf->map_queues(pm,
+@@ -192,7 +191,7 @@ static int pm_create_runlist_ib(struct packet_manager *pm,
+ if (!q->properties.is_active)
+ continue;
+
+- pr_debug("kfd: static_queue, mapping user queue %d, is debug status %d\n",
++ pr_debug("static_queue, mapping user queue %d, is debug status %d\n",
+ q->queue, qpd->is_debug);
+
+ retval = pm->pmf->map_queues(pm,
+@@ -208,7 +207,7 @@ static int pm_create_runlist_ib(struct packet_manager *pm,
+ }
+ }
+
+- pr_debug("kfd: finished map process and queues to runlist\n");
++ pr_debug("Finished map process and queues to runlist\n");
+
+ if (is_over_subscription)
+ pm->pmf->runlist(pm, &rl_buffer[rl_wptr], *rl_gpu_addr,
+@@ -270,8 +269,6 @@ int pm_send_set_resources(struct packet_manager *pm,
+ {
+ uint32_t *buffer, size;
+
+- pr_debug("kfd: In func %s\n", __func__);
+-
+ size = pm->pmf->get_set_resources_packet_size();
+ mutex_lock(&pm->lock);
+ pm->priv_queue->ops.acquire_packet_buffer(pm->priv_queue,
+@@ -279,7 +276,7 @@ int pm_send_set_resources(struct packet_manager *pm,
+ (unsigned int **)&buffer);
+ if (buffer == NULL) {
+ mutex_unlock(&pm->lock);
+- pr_err("kfd: failed to allocate buffer on kernel queue\n");
++ pr_err("Failed to allocate buffer on kernel queue\n");
+ return -ENOMEM;
+ }
+
+@@ -306,7 +303,7 @@ int pm_send_runlist(struct packet_manager *pm, struct list_head *dqm_queues)
+ if (retval != 0)
+ goto fail_create_runlist_ib;
+
+- pr_debug("kfd: runlist IB address: 0x%llX\n", rl_gpu_ib_addr);
++ pr_debug("runlist IB address: 0x%llX\n", rl_gpu_ib_addr);
+
+ packet_size_dwords = pm->pmf->get_runlist_packet_size() /
+ sizeof(uint32_t);
+@@ -349,7 +346,7 @@ int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
+ size / sizeof(uint32_t), (unsigned int **)&buffer);
+ if (buffer == NULL) {
+ mutex_unlock(&pm->lock);
+- pr_err("kfd: failed to allocate buffer on kernel queue\n");
++ pr_err("Failed to allocate buffer on kernel queue\n");
+ return -ENOMEM;
+ }
+ pm->pmf->query_status(pm, buffer, fence_address, fence_value);
+@@ -372,7 +369,7 @@ int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
+ size / sizeof(uint32_t), (unsigned int **)&buffer);
+ if (buffer == NULL) {
+ mutex_unlock(&pm->lock);
+- pr_err("kfd: failed to allocate buffer on kernel queue\n");
++ pr_err("Failed to allocate buffer on kernel queue\n");
+ return -ENOMEM;
+ }
+ pm->pmf->unmap_queues(pm, buffer, type, filter, filter_param, reset,
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_peerdirect.c b/drivers/gpu/drm/amd/amdkfd/kfd_peerdirect.c
+index 937c0ac..fa22d47 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_peerdirect.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_peerdirect.c
+@@ -159,10 +159,10 @@ static void free_callback(void *client_priv)
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_priv;
+
+- pr_debug("free_callback: data 0x%p\n", mem_context);
++ pr_debug("data 0x%p\n", mem_context);
+
+ if (!mem_context) {
+- pr_warn("free_callback: Invalid client context\n");
++ pr_warn("Invalid client context\n");
+ return;
+ }
+
+@@ -189,19 +189,19 @@ static int amd_acquire(unsigned long addr, size_t size,
+ /* Get pointer to structure describing current process */
+ pid = get_task_pid(current, PIDTYPE_PID);
+
+- pr_debug("acquire: addr:0x%lx,size:0x%x, pid 0x%p\n",
++ pr_debug("addr:0x%lx,size:0x%x, pid 0x%p\n",
+ addr, (unsigned int)size, pid);
+
+ /* Check if address is handled by AMD GPU driver */
+ ret = rdma_interface->is_gpu_address(addr, pid);
+
+ if (!ret) {
+- pr_debug("acquire: Not GPU Address\n");
++ pr_debug("Not GPU Address\n");
+ /* This is not GPU address */
+ return 0;
+ }
+
+- pr_debug("acquire: GPU address\n");
++ pr_debug("GPU address\n");
+
+ /* Initialize context used for operation with given address */
+ mem_context = kzalloc(sizeof(struct amd_mem_context), GFP_KERNEL);
+@@ -218,7 +218,7 @@ static int amd_acquire(unsigned long addr, size_t size,
+ */
+ mem_context->pid = pid;
+
+- pr_debug("acquire: Client context %p\n", mem_context);
++ pr_debug("Client context %p\n", mem_context);
+
+ /* Return pointer to allocated context */
+ *client_context = mem_context;
+@@ -237,25 +237,25 @@ static int amd_get_pages(unsigned long addr, size_t size, int write, int force,
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("get_pages: addr:0x%lx,size:0x%x, core_context:%p\n",
++ pr_debug("addr:0x%lx,size:0x%x, core_context:%p\n",
+ addr, (unsigned int)size, core_context);
+
+ if (!mem_context) {
+- pr_warn("get_pages: Invalid client context");
++ pr_warn("Invalid client context");
+ return -EINVAL;
+ }
+
+- pr_debug("get_pages: pid :0x%p\n", mem_context->pid);
++ pr_debug("pid :0x%p\n", mem_context->pid);
+
+
+ if (addr != mem_context->va) {
+- pr_warn("get_pages: Context address (0x%llx) is not the same\n",
++ pr_warn("Context address (0x%llx) is not the same\n",
+ mem_context->va);
+ return -EINVAL;
+ }
+
+ if (size != mem_context->size) {
+- pr_warn("get_pages: Context size (0x%llx) is not the same\n",
++ pr_warn("Context size (0x%llx) is not the same\n",
+ mem_context->size);
+ return -EINVAL;
+ }
+@@ -304,16 +304,16 @@ static int amd_dma_map(struct sg_table *sg_head, void *client_context,
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("dma_map: Context 0x%p, sg_head 0x%p\n",
++ pr_debug("Context 0x%p, sg_head 0x%p\n",
+ client_context, sg_head);
+
+- pr_debug("dma_map: pid 0x%p, address 0x%llx, size:0x%llx\n",
++ pr_debug("pid 0x%p, address 0x%llx, size:0x%llx\n",
+ mem_context->pid,
+ mem_context->va,
+ mem_context->size);
+
+ if (!mem_context->p2p_info) {
+- pr_err("dma_map: No sg table were allocated\n");
++ pr_err("No sg table were allocated\n");
+ return -EINVAL;
+ }
+
+@@ -332,10 +332,10 @@ static int amd_dma_unmap(struct sg_table *sg_head, void *client_context,
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("dma_unmap: Context 0x%p, sg_table 0x%p\n",
++ pr_debug("Context 0x%p, sg_table 0x%p\n",
+ client_context, sg_head);
+
+- pr_debug("dma_unmap: pid 0x%p, address 0x%llx, size:0x%llx\n",
++ pr_debug("pid 0x%p, address 0x%llx, size:0x%llx\n",
+ mem_context->pid,
+ mem_context->va,
+ mem_context->size);
+@@ -349,18 +349,18 @@ static void amd_put_pages(struct sg_table *sg_head, void *client_context)
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("put_pages: sg_head %p client_context: 0x%p\n",
++ pr_debug("sg_head %p client_context: 0x%p\n",
+ sg_head, client_context);
+- pr_debug("put_pages: pid 0x%p, address 0x%llx, size:0x%llx\n",
++ pr_debug("pid 0x%p, address 0x%llx, size:0x%llx\n",
+ mem_context->pid,
+ mem_context->va,
+ mem_context->size);
+
+- pr_debug("put_pages: mem_context->p2p_info %p\n",
++ pr_debug("mem_context->p2p_info %p\n",
+ mem_context->p2p_info);
+
+ if (ACCESS_ONCE(mem_context->free_callback_called)) {
+- pr_debug("put_pages: free callback was called\n");
++ pr_debug("Free callback was called\n");
+ return;
+ }
+
+@@ -369,10 +369,10 @@ static void amd_put_pages(struct sg_table *sg_head, void *client_context)
+ mem_context->p2p_info = NULL;
+
+ if (ret)
+- pr_err("put_pages failure: %d (callback status %d)\n",
++ pr_err("Failure: %d (callback status %d)\n",
+ ret, mem_context->free_callback_called);
+ } else
+- pr_err("put_pages: Pointer to p2p info is null\n");
++ pr_err("Pointer to p2p info is null\n");
+ }
+ static unsigned long amd_get_page_size(void *client_context)
+ {
+@@ -381,8 +381,8 @@ static unsigned long amd_get_page_size(void *client_context)
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("get_page_size: context: %p\n", client_context);
+- pr_debug("get_page_size: pid 0x%p, address 0x%llx, size:0x%llx\n",
++ pr_debug("context: %p\n", client_context);
++ pr_debug("pid 0x%p, address 0x%llx, size:0x%llx\n",
+ mem_context->pid,
+ mem_context->va,
+ mem_context->size);
+@@ -410,8 +410,8 @@ static void amd_release(void *client_context)
+ struct amd_mem_context *mem_context =
+ (struct amd_mem_context *)client_context;
+
+- pr_debug("release: context: 0x%p\n", client_context);
+- pr_debug("release: pid 0x%p, address 0x%llx, size:0x%llx\n",
++ pr_debug("context: 0x%p\n", client_context);
++ pr_debug("pid 0x%p, address 0x%llx, size:0x%llx\n",
+ mem_context->pid,
+ mem_context->va,
+ mem_context->size);
+@@ -457,7 +457,7 @@ void kfd_init_peer_direct(void)
+
+ if (!pfn_ib_register_peer_memory_client ||
+ !pfn_ib_unregister_peer_memory_client) {
+- pr_debug("amdkfd: PeerDirect interface was not detected\n");
++ pr_debug("PeerDirect interface was not detected\n");
+ /* Do cleanup */
+ kfd_close_peer_direct();
+ return;
+@@ -466,8 +466,7 @@ void kfd_init_peer_direct(void)
+ result = amdkfd_query_rdma_interface(&rdma_interface);
+
+ if (result < 0) {
+- pr_err("amdkfd: Cannot get RDMA Interface (result = %d)\n",
+- result);
++ pr_err("Cannot get RDMA Interface (result = %d)\n", result);
+ return;
+ }
+
+@@ -478,13 +477,13 @@ void kfd_init_peer_direct(void)
+ &ib_invalidate_callback);
+
+ if (!ib_reg_handle) {
+- pr_err("amdkfd: Cannot register peer memory client\n");
++ pr_err("Cannot register peer memory client\n");
+ /* Do cleanup */
+ kfd_close_peer_direct();
+ return;
+ }
+
+- pr_info("amdkfd: PeerDirect support was initialized successfully\n");
++ pr_info("PeerDirect support was initialized successfully\n");
+ }
+
+ /**
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c
+index 025ee5d..e34b686 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c
+@@ -229,7 +229,7 @@ struct kfd_process *kfd_create_process(struct file *filep)
+ /* A prior open of /dev/kfd could have already created the process. */
+ process = find_process(thread, false);
+ if (process)
+- pr_debug("kfd: process already found\n");
++ pr_debug("Process already found\n");
+ else
+ process = create_process(thread, filep);
+
+@@ -741,7 +741,7 @@ struct kfd_process_device *kfd_bind_process_to_device(struct kfd_dev *dev,
+ return pdd;
+
+ if (pdd->bound == PDD_BOUND_SUSPENDED) {
+- pr_err("kfd: binding PDD_BOUND_SUSPENDED pdd is unexpected!\n");
++ pr_err("Binding PDD_BOUND_SUSPENDED pdd is unexpected!\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+@@ -780,7 +780,7 @@ int kfd_bind_processes_to_device(struct kfd_dev *dev)
+ err = amd_iommu_bind_pasid(dev->pdev, p->pasid,
+ p->lead_thread);
+ if (err < 0) {
+- pr_err("unexpected pasid %d binding failure\n",
++ pr_err("Unexpected pasid %d binding failure\n",
+ p->pasid);
+ up_write(&p->lock);
+ break;
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c
+index e4384ce..d2c9389 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c
+@@ -51,15 +51,13 @@ static int find_available_queue_slot(struct process_queue_manager *pqm,
+
+ BUG_ON(!pqm || !qid);
+
+- pr_debug("kfd: in %s\n", __func__);
+-
+ found = find_first_zero_bit(pqm->queue_slot_bitmap,
+ KFD_MAX_NUM_OF_QUEUES_PER_PROCESS);
+
+- pr_debug("kfd: the new slot id %lu\n", found);
++ pr_debug("The new slot id %lu\n", found);
+
+ if (found >= KFD_MAX_NUM_OF_QUEUES_PER_PROCESS) {
+- pr_info("amdkfd: Can not open more queues for process with pasid %d\n",
++ pr_info("Cannot open more queues for process with pasid %d\n",
+ pqm->process->pasid);
+ return -ENOMEM;
+ }
+@@ -87,7 +85,7 @@ void kfd_process_dequeue_from_device(struct kfd_process_device *pdd)
+ * wavefronts. Now we put the check there to be safe.
+ */
+ if (retval || pdd->reset_wavefronts) {
+- pr_warn("amdkfd: Resetting wave fronts on dev %p\n", dev);
++ pr_warn("Resetting wave fronts on dev %p\n", dev);
+ dbgdev_wave_reset_wavefronts(dev, p);
+ pdd->reset_wavefronts = false;
+ }
+@@ -122,8 +120,6 @@ void pqm_uninit(struct process_queue_manager *pqm)
+
+ BUG_ON(!pqm);
+
+- pr_debug("In func %s\n", __func__);
+-
+ list_for_each_entry_safe(pqn, next, &pqm->queues, process_queue_list) {
+ uninit_queue(pqn->q);
+ list_del(&pqn->process_queue_list);
+@@ -157,7 +153,7 @@ static int create_cp_queue(struct process_queue_manager *pqm,
+ (*q)->device = dev;
+ (*q)->process = pqm->process;
+
+- pr_debug("kfd: PQM After init queue");
++ pr_debug("PQM After init queue");
+
+ return retval;
+
+@@ -222,7 +218,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
+ switch (type) {
+ case KFD_QUEUE_TYPE_SDMA:
+ if (dev->dqm->sdma_queue_count >= CIK_SDMA_QUEUES) {
+- pr_err("kfd: over-subscription is not allowed for SDMA.\n");
++ pr_err("Over-subscription is not allowed for SDMA\n");
+ retval = -EPERM;
+ goto err_create_queue;
+ }
+@@ -244,7 +240,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
+ KFD_SCHED_POLICY_HWS_NO_OVERSUBSCRIPTION) &&
+ ((dev->dqm->processes_count >= dev->vm_info.vmid_num_kfd) ||
+ (dev->dqm->queue_count >= get_queues_num(dev->dqm)))) {
+- pr_err("kfd: over-subscription is not allowed in radeon_kfd.sched_policy == 1\n");
++ pr_err("Over-subscription is not allowed in radeon_kfd.sched_policy == 1\n");
+ retval = -EPERM;
+ goto err_create_queue;
+ }
+@@ -277,7 +273,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
+ }
+
+ if (retval != 0) {
+- pr_debug("Error dqm create queue\n");
++ pr_err("DQM create queue failed\n");
+ goto err_create_queue;
+ }
+
+@@ -290,12 +286,12 @@ int pqm_create_queue(struct process_queue_manager *pqm,
+ (q->properties.doorbell_off * sizeof(uint32_t)) &
+ (kfd_doorbell_process_slice(dev) - 1);
+
+- pr_debug("kfd: PQM After DQM create queue\n");
++ pr_debug("PQM After DQM create queue\n");
+
+ list_add(&pqn->process_queue_list, &pqm->queues);
+
+ if (q) {
+- pr_debug("kfd: PQM done creating queue\n");
++ pr_debug("PQM done creating queue\n");
+ print_queue_properties(&q->properties);
+ }
+
+@@ -325,11 +321,9 @@ int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid)
+ BUG_ON(!pqm);
+ retval = 0;
+
+- pr_debug("kfd: In Func %s\n", __func__);
+-
+ pqn = get_queue_by_qid(pqm, qid);
+ if (pqn == NULL) {
+- pr_err("kfd: queue id does not match any known queue\n");
++ pr_err("Queue id does not match any known queue\n");
+ return -EINVAL;
+ }
+
+@@ -386,8 +380,7 @@ int pqm_update_queue(struct process_queue_manager *pqm, unsigned int qid,
+
+ pqn = get_queue_by_qid(pqm, qid);
+ if (!pqn) {
+- pr_debug("amdkfd: No queue %d exists for update operation\n",
+- qid);
++ pr_debug("No queue %d exists for update operation\n", qid);
+ return -EFAULT;
+ }
+
+@@ -414,8 +407,7 @@ int pqm_set_cu_mask(struct process_queue_manager *pqm, unsigned int qid,
+
+ pqn = get_queue_by_qid(pqm, qid);
+ if (!pqn) {
+- pr_debug("amdkfd: No queue %d exists for update operation\n",
+- qid);
++ pr_debug("No queue %d exists for update operation\n", qid);
+ return -EFAULT;
+ }
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_rdma.c b/drivers/gpu/drm/amd/amdkfd/kfd_rdma.c
+index 2b3c300..bcf0bf2 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_rdma.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_rdma.c
+@@ -76,15 +76,14 @@ static int get_pages(uint64_t address, uint64_t length, struct pid *pid,
+
+ p = kfd_lookup_process_by_pid(pid);
+ if (!p) {
+- pr_err("could not find the process in %s.\n",
+- __func__);
++ pr_err("Could not find the process\n");
+ return -EINVAL;
+ }
+ down_read(&p->lock);
+
+ buf_obj = kfd_process_find_bo_from_interval(p, address, last);
+ if (!buf_obj) {
+- pr_err("can not find a kfd_bo for the range\n");
++ pr_err("Cannot find a kfd_bo for the range\n");
+ ret = -EINVAL;
+ goto out;
+ }
+@@ -195,8 +194,7 @@ static int put_pages(struct amd_p2p_info **p_p2p_data)
+
+ p = kfd_lookup_process_by_pid((*p_p2p_data)->pid);
+ if (!p) {
+- pr_err("could not find the process in %s\n",
+- __func__);
++ pr_err("Could not find the process\n");
+ return -EINVAL;
+ }
+
+@@ -227,8 +225,7 @@ static int is_gpu_address(uint64_t address, struct pid *pid)
+
+ p = kfd_lookup_process_by_pid(pid);
+ if (!p) {
+- pr_debug("could not find the process in %s.\n",
+- __func__);
++ pr_debug("Could not find the process\n");
+ return 0;
+ }
+
+diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
+index 3e21aef..da91ced 100644
+--- a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
++++ b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
+@@ -1239,7 +1239,7 @@ int kfd_topology_add_device(struct kfd_dev *gpu)
+
+ gpu_id = kfd_generate_gpu_id(gpu);
+
+- pr_debug("kfd: Adding new GPU (ID: 0x%x) to topology\n", gpu_id);
++ pr_debug("Adding new GPU (ID: 0x%x) to topology\n", gpu_id);
+
+ proximity_domain = atomic_inc_return(&
+ topology_crat_proximity_domain);
+@@ -1321,7 +1321,7 @@ int kfd_topology_add_device(struct kfd_dev *gpu)
+ case CHIP_FIJI:
+ case CHIP_POLARIS10:
+ case CHIP_POLARIS11:
+- pr_debug("amdkfd: adding doorbell packet type capability\n");
++ pr_debug("Adding doorbell packet type capability\n");
+ dev->node_props.capability |= ((HSA_CAP_DOORBELL_TYPE_1_0 <<
+ HSA_CAP_DOORBELL_TYPE_TOTALBITS_SHIFT) &
+ HSA_CAP_DOORBELL_TYPE_TOTALBITS_MASK);
+--
+2.7.4
+