Revert "Revert "Merge r38p1 from upstream into partner/android13-gs-pixel-5.10-tm-qpr2""

This reverts commit 34e635317dc2a91076ac341df3867ac3bdb31ef1.

Bug: 228779790
Change-Id: Ica7fbc34d4c725f36a302ae9723606dcf828c452

8 files changed, 180 insertions, 155 deletions

diff --git a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_codes_csf.h b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_codes_csf.h
index 2506ce1..9e4da9f 100644
--- a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_codes_csf.h
+++ b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_codes_csf.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -42,67 +42,67 @@ int dummy_array[] = {
 	/*
 	 * Generic CSF events
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(EVICT_CTX_SLOTS),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_EVICT_CTX_SLOTS_START),
 	/* info_val[0:7]   == fw version_minor
 	 * info_val[15:8]  == fw version_major
 	 * info_val[63:32] == fw version_hash
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(FIRMWARE_BOOT),
-	KBASE_KTRACE_CODE_MAKE_CODE(FIRMWARE_REBOOT),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TOCK),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_FIRMWARE_BOOT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_FIRMWARE_REBOOT),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TOCK_START),
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TOCK_END),
 	/* info_val == total number of runnable groups across all kctxs */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TICK),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TICK_START),
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TICK_END),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RESET),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RESET_START),
 	/* info_val = timeout in ms */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_WAIT_PROTM_QUIT),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_PROTM_WAIT_QUIT_START),
 	/* info_val = remaining ms timeout, or 0 if timedout */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_WAIT_PROTM_QUIT_DONE),
-	KBASE_KTRACE_CODE_MAKE_CODE(SYNC_UPDATE_EVENT),
-	KBASE_KTRACE_CODE_MAKE_CODE(SYNC_UPDATE_EVENT_NOTIFY_GPU),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_PROTM_WAIT_QUIT_END),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GROUP_SYNC_UPDATE_EVENT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_SYNC_UPDATE_NOTIFY_GPU_EVENT),
 
 	/* info_val = JOB_IRQ_STATUS */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT_START),
 	/* info_val = JOB_IRQ_STATUS */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT_END),
 	/* info_val = JOB_IRQ_STATUS */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_PROCESS),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_PROCESS_START),
 	/* info_val = GLB_REQ ^ GLB_ACQ */
-	KBASE_KTRACE_CODE_MAKE_CODE(GLB_REQ_ACQ),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT_GLB_REQ_ACK),
 	/* info_val[31:0] = num non idle offslot groups
 	 * info_val[32] = scheduler can suspend on idle
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_CAN_IDLE),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_ADVANCE_TICK),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NOADVANCE_TICK),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GPU_IDLE_EVENT_CAN_SUSPEND),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TICK_ADVANCE),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TICK_NOADVANCE),
 	/* kctx is added to the back of the list */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_INSERT_RUNNABLE),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_REMOVE_RUNNABLE),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RUNNABLE_KCTX_INSERT),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RUNNABLE_KCTX_REMOVE),
 	/* kctx is moved to the back of the list */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_ROTATE_RUNNABLE),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_HEAD_RUNNABLE),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RUNNABLE_KCTX_ROTATE),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RUNNABLE_KCTX_HEAD),
 
-	KBASE_KTRACE_CODE_MAKE_CODE(IDLE_WORKER_BEGIN),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GPU_IDLE_WORKER_START),
 	/* 4-bit encoding of boolean values (ease of reading as hex values)
 	 *
 	 * info_val[3:0] = was reset active/failed to be prevented
 	 * info_val[7:4] = whether scheduler was both idle and suspendable
 	 * info_val[11:8] = whether all groups were suspended
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(IDLE_WORKER_END),
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SYNC_UPDATE_WORKER_BEGIN),
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SYNC_UPDATE_WORKER_END),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GPU_IDLE_WORKER_END),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GROUP_SYNC_UPDATE_WORKER_START),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GROUP_SYNC_UPDATE_WORKER_END),
 
 	/* info_val = bitmask of slots that gave an ACK for STATUS_UPDATE */
-	KBASE_KTRACE_CODE_MAKE_CODE(SLOTS_STATUS_UPDATE_ACK),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_UPDATE_IDLE_SLOTS_ACK),
 
 	/* info_val[63:0] = GPU cycle counter, used mainly for benchmarking
 	 * purpose.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GPU_IDLE_HANDLING_START),
-	KBASE_KTRACE_CODE_MAKE_CODE(MCU_HALTED),
-	KBASE_KTRACE_CODE_MAKE_CODE(MCU_IN_SLEEP),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_GPU_IDLE_WORKER_HANDLING_START),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_FIRMWARE_MCU_HALTED),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSF_FIRMWARE_MCU_SLEEP),
 
 	/*
 	 * Group events
@@ -111,17 +111,17 @@ int dummy_array[] = {
 	 * info_val[19:16] == as_nr
 	 * info_val[63:32] == endpoint config (max number of endpoints allowed)
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_START),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_START_REQ),
 	/* info_val == CSG_REQ state issued */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STOP),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STOP_REQ),
 	/* info_val == CSG_ACK state */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STARTED),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_RUNNING),
 	/* info_val == CSG_ACK state */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STOPPED),
 	/* info_val == slot cleaned */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_CLEANED),
 	/* info_val = slot requesting STATUS_UPDATE */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STATUS_UPDATE),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_UPDATE_IDLE_SLOT_REQ),
 	/* info_val = scheduler's new csg_slots_idle_mask[0]
 	 * group->csg_nr indicates which bit was set
 	 */
@@ -133,13 +133,13 @@ int dummy_array[] = {
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_IDLE_CLEAR),
 	/* info_val == previous priority */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PRIO_UPDATE),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_PRIO_UPDATE),
 	/* info_val == CSG_REQ ^ CSG_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SYNC_UPDATE_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_SYNC_UPDATE),
 	/* info_val == CSG_REQ ^ CSG_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_IDLE_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_IDLE),
 	/* info_val == CSG_REQ ^ CSG_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PROGRESS_TIMER_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_PROGRESS_TIMER_EVENT),
 	/* info_val[31:0] == CSG_REQ ^ CSG_ACQ
 	 * info_val[63:32] == CSG_IRQ_REQ ^ CSG_IRQ_ACK
 	 */
@@ -152,34 +152,34 @@ int dummy_array[] = {
 	/* info_val[31:0] == new run state of the evicted group
 	 * info_val[63:32] == number of runnable groups
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_EVICT_SCHED),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_EVICT),
 
 	/* info_val == new num_runnable_grps
 	 * group is added to the back of the list for its priority level
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_INSERT_RUNNABLE),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_RUNNABLE_INSERT),
 	/* info_val == new num_runnable_grps
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_REMOVE_RUNNABLE),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_RUNNABLE_REMOVE),
 	/* info_val == num_runnable_grps
 	 * group is moved to the back of the list for its priority level
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_ROTATE_RUNNABLE),
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_HEAD_RUNNABLE),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_RUNNABLE_ROTATE),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_RUNNABLE_HEAD),
 	/* info_val == new num_idle_wait_grps
 	 * group is added to the back of the list
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_INSERT_IDLE_WAIT),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_IDLE_WAIT_INSERT),
 	/* info_val == new num_idle_wait_grps
 	 * group is added to the back of the list
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_REMOVE_IDLE_WAIT),
-	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_HEAD_IDLE_WAIT),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_IDLE_WAIT_REMOVE),
+	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_IDLE_WAIT_HEAD),
 
 	/* info_val == is scheduler running with protected mode tasks */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_CHECK_PROTM_ENTER),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_ENTER_PROTM),
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_EXIT_PROTM),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_PROTM_ENTER_CHECK),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_PROTM_ENTER),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_PROTM_EXIT),
 	/* info_val[31:0] == number of GPU address space slots in use
 	 * info_val[63:32] == number of runnable groups
 	 */
@@ -187,11 +187,11 @@ int dummy_array[] = {
 	/* info_val == new count of off-slot non-idle groups
 	 * no group indicates it was set rather than incremented
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_INC),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_GRP_INC),
 	/* info_val == new count of off-slot non-idle groups */
-	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_DEC),
+	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_GRP_DEC),
 
-	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_BEGIN),
+	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_START),
 	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_END),
 
 	/*
@@ -201,42 +201,42 @@ int dummy_array[] = {
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_START),
 	/* info_val == queue->enabled before stop */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_STOP),
-	KBASE_KTRACE_CODE_MAKE_CODE(CSI_STOP_REQUESTED),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_STOP_REQ),
 	/* info_val == CS_REQ ^ CS_ACK that were not processed due to the group
 	 * being suspended
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSI_IGNORED_INTERRUPTS_GROUP_SUSPEND),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_INTERRUPT_GROUP_SUSPENDS_IGNORED),
 	/* info_val == CS_REQ ^ CS_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSI_FAULT_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_INTERRUPT_FAULT),
 	/* info_val == CS_REQ ^ CS_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSI_TILER_OOM_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_INTERRUPT_TILER_OOM),
 	/* info_val == CS_REQ ^ CS_ACK */
-	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_PEND_INTERRUPT),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_INTERRUPT_PROTM_PEND),
 	/* info_val == CS_ACK_PROTM_PEND ^ CS_REQ_PROTM_PEND */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_ACK),
 	/* info_val == group->run_State (for group the queue is bound to) */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_START),
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_STOP),
 	/* info_val == contents of CS_STATUS_WAIT_SYNC_POINTER */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_EVAL_START),
 	/* info_val == bool for result of the evaluation */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_EVALUATED),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_EVAL_END),
 	/* info_val == contents of CS_STATUS_WAIT */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_STATUS_WAIT),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_WAIT_STATUS),
 	/* info_val == current sync value pointed to by queue->sync_ptr */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_CURRENT_VAL),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_CUR_VAL),
 	/* info_val == current value of CS_STATUS_WAIT_SYNC_VALUE */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_TEST_VAL),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_TEST_VAL),
 	/* info_val == current value of CS_STATUS_BLOCKED_REASON */
-	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_BLOCKED_REASON),
+	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_BLOCKED_REASON),
 	/* info_val = group's new protm_pending_bitmap[0]
 	 * queue->csi_index indicates which bit was set
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_PENDING_SET),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_PEND_SET),
 	/* info_val = group's new protm_pending_bitmap[0]
 	 * queue->csi_index indicates which bit was cleared
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_PENDING_CLEAR),
+	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_PEND_CLEAR),
 
 	/*
 	 * KCPU queue events
@@ -244,42 +244,42 @@ int dummy_array[] = {
 	/* KTrace info_val == KCPU queue fence context
 	 * KCPU extra_info_val == N/A.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_NEW),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_CREATE),
 	/* KTrace info_val == Number of pending commands in KCPU queue when
 	 * it is destroyed.
 	 * KCPU extra_info_val == Number of CQS wait operations present in
 	 * the KCPU queue when it is destroyed.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_DESTROY),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_DELETE),
 	/* KTrace info_val == CQS event memory address
 	 * KCPU extra_info_val == Upper 32 bits of event memory, i.e. contents
 	 * of error field.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(CQS_SET),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_CQS_SET),
 	/* KTrace info_val == Number of CQS objects to be waited upon
 	 * KCPU extra_info_val == N/A.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(CQS_WAIT_START),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_CQS_WAIT_START),
 	/* KTrace info_val == CQS event memory address
 	 * KCPU extra_info_val == 1 if CQS was signaled with an error and queue
 	 * inherited the error, otherwise 0.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(CQS_WAIT_END),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_CQS_WAIT_END),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_SIGNAL),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_FENCE_SIGNAL),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_START),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_FENCE_WAIT_START),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
-	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_END),
+	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_FENCE_WAIT_END),
 
 #if 0 /* Dummy section to avoid breaking formatting */
 };
 #endif
 
-/* ***** THE LACK OF HEADER GUARDS IS INTENTIONAL ***** */
+	/* ***** THE LACK OF HEADER GUARDS IS INTENTIONAL ***** */
diff --git a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_csf.c b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_csf.c
index 824ca4b..cff6f89 100644
--- a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_csf.c
+++ b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_csf.c
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -98,6 +98,9 @@ void kbasep_ktrace_add_csf(struct kbase_device *kbdev,
 	struct kbase_ktrace_msg *trace_msg;
 	struct kbase_context *kctx = NULL;
 
+	if (unlikely(!kbasep_ktrace_initialized(&kbdev->ktrace)))
+		return;
+
 	spin_lock_irqsave(&kbdev->ktrace.lock, irqflags);
 
 	/* Reserve and update indices */
@@ -165,6 +168,9 @@ void kbasep_ktrace_add_csf_kcpu(struct kbase_device *kbdev,
 	struct kbase_ktrace_msg *trace_msg;
 	struct kbase_context *kctx = queue->kctx;
 
+	if (unlikely(!kbasep_ktrace_initialized(&kbdev->ktrace)))
+		return;
+
 	spin_lock_irqsave(&kbdev->ktrace.lock, irqflags);
 
 	/* Reserve and update indices */
diff --git a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_defs_csf.h b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_defs_csf.h
index 7f32cd2..1896e10 100644
--- a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_defs_csf.h
+++ b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_defs_csf.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -47,7 +47,7 @@
  * 1.3:
  * Add a lot of extra new traces. Tweak some existing scheduler related traces
  * to contain extra information information/happen at slightly different times.
- * SCHEDULER_EXIT_PROTM now has group information
+ * SCHEDULER_PROTM_EXIT now has group information
  */
 #define KBASE_KTRACE_VERSION_MAJOR 1
 #define KBASE_KTRACE_VERSION_MINOR 3
diff --git a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_jm.c b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_jm.c
index 05d1677..6597a15 100644
--- a/mali_kbase/debug/backend/mali_kbase_debug_ktrace_jm.c
+++ b/mali_kbase/debug/backend/mali_kbase_debug_ktrace_jm.c
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -80,6 +80,9 @@ void kbasep_ktrace_add_jm(struct kbase_device *kbdev,
 	unsigned long irqflags;
 	struct kbase_ktrace_msg *trace_msg;
 
+	if (unlikely(!kbasep_ktrace_initialized(&kbdev->ktrace)))
+		return;
+
 	spin_lock_irqsave(&kbdev->ktrace.lock, irqflags);
 
 	/* Reserve and update indices */
diff --git a/mali_kbase/debug/backend/mali_kbase_debug_linux_ktrace_csf.h b/mali_kbase/debug/backend/mali_kbase_debug_linux_ktrace_csf.h
index 9ee7f81..86e81e5 100644
--- a/mali_kbase/debug/backend/mali_kbase_debug_linux_ktrace_csf.h
+++ b/mali_kbase/debug/backend/mali_kbase_debug_linux_ktrace_csf.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -30,37 +30,36 @@
 /*
  * Generic CSF events - using the common DEFINE_MALI_ADD_EVENT
  */
-DEFINE_MALI_ADD_EVENT(EVICT_CTX_SLOTS);
-DEFINE_MALI_ADD_EVENT(FIRMWARE_BOOT);
-DEFINE_MALI_ADD_EVENT(FIRMWARE_REBOOT);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_TOCK);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_EVICT_CTX_SLOTS_START);
+DEFINE_MALI_ADD_EVENT(CSF_FIRMWARE_BOOT);
+DEFINE_MALI_ADD_EVENT(CSF_FIRMWARE_REBOOT);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_TOCK_START);
 DEFINE_MALI_ADD_EVENT(SCHEDULER_TOCK_END);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK_START);
 DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK_END);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_RESET);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_WAIT_PROTM_QUIT);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_WAIT_PROTM_QUIT_DONE);
-DEFINE_MALI_ADD_EVENT(SYNC_UPDATE_EVENT);
-DEFINE_MALI_ADD_EVENT(SYNC_UPDATE_EVENT_NOTIFY_GPU);
-DEFINE_MALI_ADD_EVENT(CSF_INTERRUPT);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_RESET_START);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_PROTM_WAIT_QUIT_START);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_PROTM_WAIT_QUIT_END);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GROUP_SYNC_UPDATE_EVENT);
+DEFINE_MALI_ADD_EVENT(CSF_SYNC_UPDATE_NOTIFY_GPU_EVENT);
+DEFINE_MALI_ADD_EVENT(CSF_INTERRUPT_START);
 DEFINE_MALI_ADD_EVENT(CSF_INTERRUPT_END);
-DEFINE_MALI_ADD_EVENT(CSG_INTERRUPT_PROCESS);
-DEFINE_MALI_ADD_EVENT(GLB_REQ_ACQ);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_CAN_IDLE);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_ADVANCE_TICK);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_NOADVANCE_TICK);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_INSERT_RUNNABLE);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_REMOVE_RUNNABLE);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_ROTATE_RUNNABLE);
-DEFINE_MALI_ADD_EVENT(SCHEDULER_HEAD_RUNNABLE);
-DEFINE_MALI_ADD_EVENT(IDLE_WORKER_BEGIN);
-DEFINE_MALI_ADD_EVENT(IDLE_WORKER_END);
-DEFINE_MALI_ADD_EVENT(GROUP_SYNC_UPDATE_WORKER_BEGIN);
-DEFINE_MALI_ADD_EVENT(GROUP_SYNC_UPDATE_WORKER_END);
-DEFINE_MALI_ADD_EVENT(SLOTS_STATUS_UPDATE_ACK);
-DEFINE_MALI_ADD_EVENT(GPU_IDLE_HANDLING_START);
-DEFINE_MALI_ADD_EVENT(MCU_HALTED);
-DEFINE_MALI_ADD_EVENT(MCU_IN_SLEEP);
+DEFINE_MALI_ADD_EVENT(CSF_INTERRUPT_GLB_REQ_ACK);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GPU_IDLE_EVENT_CAN_SUSPEND);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK_ADVANCE);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK_NOADVANCE);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_RUNNABLE_KCTX_INSERT);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_RUNNABLE_KCTX_REMOVE);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_RUNNABLE_KCTX_ROTATE);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_RUNNABLE_KCTX_HEAD);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GPU_IDLE_WORKER_START);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GPU_IDLE_WORKER_END);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GROUP_SYNC_UPDATE_WORKER_START);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GROUP_SYNC_UPDATE_WORKER_END);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_UPDATE_IDLE_SLOTS_ACK);
+DEFINE_MALI_ADD_EVENT(SCHEDULER_GPU_IDLE_WORKER_HANDLING_START);
+DEFINE_MALI_ADD_EVENT(CSF_FIRMWARE_MCU_HALTED);
+DEFINE_MALI_ADD_EVENT(CSF_FIRMWARE_MCU_SLEEP);
 
 DECLARE_EVENT_CLASS(mali_csf_grp_q_template,
 	TP_PROTO(struct kbase_device *kbdev, struct kbase_queue_group *group,
@@ -130,37 +129,38 @@ DECLARE_EVENT_CLASS(mali_csf_grp_q_template,
 		__entry->kctx_tgid, __entry->kctx_id, __entry->group_handle, \
 		__entry->csg_nr, __entry->slot_prio, __entry->info_val))
 
-DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_START);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STOP);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STARTED);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_START_REQ);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STOP_REQ);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_RUNNING);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STOPPED);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_CLEANED);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STATUS_UPDATE);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_UPDATE_IDLE_SLOT_REQ);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_IDLE_SET);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_IDLE_CLEAR);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_PRIO_UPDATE);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_SYNC_UPDATE_INTERRUPT);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_IDLE_INTERRUPT);
-DEFINE_MALI_CSF_GRP_EVENT(CSG_PROGRESS_TIMER_INTERRUPT);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_PRIO_UPDATE);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_INTERRUPT_SYNC_UPDATE);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_INTERRUPT_IDLE);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_INTERRUPT_PROGRESS_TIMER_EVENT);
+DEFINE_MALI_CSF_GRP_EVENT(CSG_INTERRUPT_PROCESS_START);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_INTERRUPT_PROCESS_END);
 DEFINE_MALI_CSF_GRP_EVENT(GROUP_SYNC_UPDATE_DONE);
 DEFINE_MALI_CSF_GRP_EVENT(GROUP_DESCHEDULE);
 DEFINE_MALI_CSF_GRP_EVENT(GROUP_SCHEDULE);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_EVICT_SCHED);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_INSERT_RUNNABLE);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_REMOVE_RUNNABLE);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_ROTATE_RUNNABLE);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_HEAD_RUNNABLE);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_INSERT_IDLE_WAIT);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_REMOVE_IDLE_WAIT);
-DEFINE_MALI_CSF_GRP_EVENT(GROUP_HEAD_IDLE_WAIT);
-DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_CHECK_PROTM_ENTER);
-DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_ENTER_PROTM);
-DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_EXIT_PROTM);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_EVICT);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_RUNNABLE_INSERT);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_RUNNABLE_REMOVE);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_RUNNABLE_ROTATE);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_RUNNABLE_HEAD);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_IDLE_WAIT_INSERT);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_IDLE_WAIT_REMOVE);
+DEFINE_MALI_CSF_GRP_EVENT(GROUP_IDLE_WAIT_HEAD);
+DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_PROTM_ENTER_CHECK);
+DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_PROTM_ENTER);
+DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_PROTM_EXIT);
 DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_TOP_GRP);
-DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_NONIDLE_OFFSLOT_INC);
-DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_NONIDLE_OFFSLOT_DEC);
-DEFINE_MALI_CSF_GRP_EVENT(PROTM_EVENT_WORKER_BEGIN);
+DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_NONIDLE_OFFSLOT_GRP_INC);
+DEFINE_MALI_CSF_GRP_EVENT(SCHEDULER_NONIDLE_OFFSLOT_GRP_DEC);
+DEFINE_MALI_CSF_GRP_EVENT(PROTM_EVENT_WORKER_START);
 DEFINE_MALI_CSF_GRP_EVENT(PROTM_EVENT_WORKER_END);
 
 #undef DEFINE_MALI_CSF_GRP_EVENT
@@ -176,22 +176,22 @@ DEFINE_MALI_CSF_GRP_EVENT(PROTM_EVENT_WORKER_END);
 
 DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_START);
 DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_STOP);
-DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_STOP_REQUESTED);
-DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_IGNORED_INTERRUPTS_GROUP_SUSPEND);
-DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_FAULT_INTERRUPT);
-DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_TILER_OOM_INTERRUPT);
-DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_PROTM_PEND_INTERRUPT);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_STOP_REQ);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_INTERRUPT_GROUP_SUSPENDS_IGNORED);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_INTERRUPT_FAULT);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_INTERRUPT_TILER_OOM);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_INTERRUPT_PROTM_PEND);
 DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_PROTM_ACK);
 DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_START);
 DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_STOP);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_EVALUATED);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_STATUS_WAIT);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_CURRENT_VAL);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_TEST_VAL);
-DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_BLOCKED_REASON);
-DEFINE_MALI_CSF_GRP_Q_EVENT(PROTM_PENDING_SET);
-DEFINE_MALI_CSF_GRP_Q_EVENT(PROTM_PENDING_CLEAR);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_EVAL_START);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_EVAL_END);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_WAIT_STATUS);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_CUR_VAL);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_TEST_VAL);
+DEFINE_MALI_CSF_GRP_Q_EVENT(QUEUE_SYNC_UPDATE_BLOCKED_REASON);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_PROTM_PEND_SET);
+DEFINE_MALI_CSF_GRP_Q_EVENT(CSI_PROTM_PEND_CLEAR);
 
 #undef DEFINE_MALI_CSF_GRP_Q_EVENT
 
@@ -230,14 +230,14 @@ DECLARE_EVENT_CLASS(mali_csf_kcpu_queue_template,
 		 u64 info_val1, u64 info_val2), \
 	TP_ARGS(queue, info_val1, info_val2))
 
-DEFINE_MALI_CSF_KCPU_EVENT(KCPU_QUEUE_NEW);
-DEFINE_MALI_CSF_KCPU_EVENT(KCPU_QUEUE_DESTROY);
-DEFINE_MALI_CSF_KCPU_EVENT(CQS_SET);
-DEFINE_MALI_CSF_KCPU_EVENT(CQS_WAIT_START);
-DEFINE_MALI_CSF_KCPU_EVENT(CQS_WAIT_END);
-DEFINE_MALI_CSF_KCPU_EVENT(FENCE_SIGNAL);
-DEFINE_MALI_CSF_KCPU_EVENT(FENCE_WAIT_START);
-DEFINE_MALI_CSF_KCPU_EVENT(FENCE_WAIT_END);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_QUEUE_CREATE);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_QUEUE_DELETE);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_CQS_SET);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_CQS_WAIT_START);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_CQS_WAIT_END);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_FENCE_SIGNAL);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_FENCE_WAIT_START);
+DEFINE_MALI_CSF_KCPU_EVENT(KCPU_FENCE_WAIT_END);
 
 #undef DEFINE_MALI_CSF_KCPU_EVENT
 
diff --git a/mali_kbase/debug/mali_kbase_debug_ktrace.c b/mali_kbase/debug/mali_kbase_debug_ktrace.c
index 9bf8610..f521b47 100644
--- a/mali_kbase/debug/mali_kbase_debug_ktrace.c
+++ b/mali_kbase/debug/mali_kbase_debug_ktrace.c
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -27,13 +27,13 @@ int kbase_ktrace_init(struct kbase_device *kbdev)
 #if KBASE_KTRACE_TARGET_RBUF
 	struct kbase_ktrace_msg *rbuf;
 
+	spin_lock_init(&kbdev->ktrace.lock);
 	rbuf = kmalloc_array(KBASE_KTRACE_SIZE, sizeof(*rbuf), GFP_KERNEL);
 
 	if (!rbuf)
 		return -EINVAL;
 
 	kbdev->ktrace.rbuf = rbuf;
-	spin_lock_init(&kbdev->ktrace.lock);
 #endif /* KBASE_KTRACE_TARGET_RBUF */
 	return 0;
 }
@@ -42,6 +42,7 @@ void kbase_ktrace_term(struct kbase_device *kbdev)
 {
 #if KBASE_KTRACE_TARGET_RBUF
 	kfree(kbdev->ktrace.rbuf);
+	kbdev->ktrace.rbuf = NULL;
 #endif /* KBASE_KTRACE_TARGET_RBUF */
 }
 
@@ -183,6 +184,9 @@ void kbasep_ktrace_add(struct kbase_device *kbdev, enum kbase_ktrace_code code,
 	unsigned long irqflags;
 	struct kbase_ktrace_msg *trace_msg;
 
+	if (unlikely(!kbasep_ktrace_initialized(&kbdev->ktrace)))
+		return;
+
 	WARN_ON((flags & ~KBASE_KTRACE_FLAG_COMMON_ALL));
 
 	spin_lock_irqsave(&kbdev->ktrace.lock, irqflags);
diff --git a/mali_kbase/debug/mali_kbase_debug_ktrace.h b/mali_kbase/debug/mali_kbase_debug_ktrace.h
index f1e6d3d..31a15a0 100644
--- a/mali_kbase/debug/mali_kbase_debug_ktrace.h
+++ b/mali_kbase/debug/mali_kbase_debug_ktrace.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -82,6 +82,18 @@ void kbase_ktrace_debugfs_init(struct kbase_device *kbdev);
  */
 #if KBASE_KTRACE_TARGET_RBUF
 /**
+ * kbasep_ktrace_initialized - Check whether kbase ktrace is initialized
+ *
+ * @ktrace: ktrace of kbase device.
+ *
+ * Return: true if ktrace has been initialized.
+ */
+static inline bool kbasep_ktrace_initialized(struct kbase_ktrace *ktrace)
+{
+	return ktrace->rbuf != NULL;
+}
+
+/**
  * kbasep_ktrace_add - internal function to add trace to the ringbuffer.
  * @kbdev:    kbase device
  * @code:     ktrace code
diff --git a/mali_kbase/debug/mali_kbase_debug_ktrace_defs.h b/mali_kbase/debug/mali_kbase_debug_ktrace_defs.h
index 4694b78..8d9e11e 100644
--- a/mali_kbase/debug/mali_kbase_debug_ktrace_defs.h
+++ b/mali_kbase/debug/mali_kbase_debug_ktrace_defs.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
- * (C) COPYRIGHT 2020-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
  *
  * This program is free software and is provided to you under the terms of the
  * GNU General Public License version 2 as published by the Free Software
@@ -138,8 +138,8 @@ enum kbase_ktrace_code {
 };
 
 /**
- * struct kbase_ktrace - object representing a trace message added to trace
- *                      buffer trace_rbuf in &kbase_device
+ * struct kbase_ktrace_msg - object representing a trace message added to trace
+ *                           buffer trace_rbuf in &kbase_device
  * @timestamp: CPU timestamp at which the trace message was added.
  * @thread_id: id of the thread in the context of which trace message was
  *             added.