bifrost/r32p1/kernel/drivers/gpu/arm/midgard/debug/backend/mali_kbase_debug_linux_ktrace_csf.h - manifest_repos/mali-driver - Git at Google

 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
 /*
  *
  * (C) COPYRIGHT 2020-2021 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
  * Foundation, and any use by you of this program is subject to the terms
  * of such GNU license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, you can access it online at
  * http://www.gnu.org/licenses/gpl-2.0.html.
  *
  */

 /*
  * NOTE: This must **only** be included through mali_linux_trace.h,
  * otherwise it will fail to setup tracepoints correctly
  */

 #if !defined(_KBASE_DEBUG_LINUX_KTRACE_CSF_H_) || defined(TRACE_HEADER_MULTI_READ)
 #define _KBASE_DEBUG_LINUX_KTRACE_CSF_H_

 /*
  * 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_TOCK_END);
 DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK);
 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(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);

 DECLARE_EVENT_CLASS(mali_csf_grp_q_template,
 	TP_PROTO(struct kbase_device *kbdev, struct kbase_queue_group *group,
 			struct kbase_queue *queue, u64 info_val),
 	TP_ARGS(kbdev, group, queue, info_val),
 	TP_STRUCT__entry(
 		__field(u64, info_val)
 		__field(pid_t, kctx_tgid)
 		__field(u32, kctx_id)
 		__field(u8, group_handle)
 		__field(s8, csg_nr)
 		__field(u8, slot_prio)
 		__field(s8, csi_index)
 	),
 	TP_fast_assign(
 		{
 			struct kbase_context *kctx = NULL;

 			__entry->info_val = info_val;
 			/* Note: if required in future, we could record some
 			 * flags in __entry about whether the group/queue parts
 			 * are valid, and add that to the trace message e.g.
 			 * by using __print_flags()/__print_symbolic()
 			 */
 			if (queue) {
 				/* Note: kctx overridden by group->kctx later if group is valid */
 				kctx = queue->kctx;
 				__entry->csi_index = queue->csi_index;
 			} else {
 				__entry->csi_index = -1;
 			}

 			if (group) {
 				kctx = group->kctx;
 				__entry->group_handle = group->handle;
 				__entry->csg_nr = group->csg_nr;
 				if (group->csg_nr >= 0)
 					__entry->slot_prio = kbdev->csf.scheduler.csg_slots[group->csg_nr].priority;
 				else
 					__entry->slot_prio = 0u;
 			} else {
 				__entry->group_handle = 0u;
 				__entry->csg_nr = -1;
 				__entry->slot_prio = 0u;
 			}
 			__entry->kctx_id = (kctx) ? kctx->id : 0u;
 			__entry->kctx_tgid = (kctx) ? kctx->tgid : 0;
 		}

 	),
 	TP_printk("kctx=%d_%u group=%u slot=%d prio=%u csi=%d info=0x%llx",
 			__entry->kctx_tgid, __entry->kctx_id,
 			__entry->group_handle, __entry->csg_nr,
 			__entry->slot_prio, __entry->csi_index,
 			__entry->info_val)
 );

 /*
  * Group events
  */
 #define DEFINE_MALI_CSF_GRP_EVENT(name) \
 	DEFINE_EVENT_PRINT(mali_csf_grp_q_template, mali_##name, \
 	TP_PROTO(struct kbase_device *kbdev, struct kbase_queue_group *group, \
 			struct kbase_queue *queue, u64 info_val), \
 	TP_ARGS(kbdev, group, queue, info_val), \
 	TP_printk("kctx=%d_%u group=%u slot=%d prio=%u info=0x%llx", \
 		__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_STOPPED);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_CLEANED);
 DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STATUS_UPDATE);
 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_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(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(PROTM_EVENT_WORKER_END);

 #undef DEFINE_MALI_CSF_GRP_EVENT

 /*
  * Group + Queue events
  */
 #define DEFINE_MALI_CSF_GRP_Q_EVENT(name)  \
 	DEFINE_EVENT(mali_csf_grp_q_template, mali_##name, \
 	TP_PROTO(struct kbase_device *kbdev, struct kbase_queue_group *group, \
 			struct kbase_queue *queue, u64 info_val), \
 	TP_ARGS(kbdev, group, queue, info_val))

 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_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);

 #undef DEFINE_MALI_CSF_GRP_Q_EVENT

 /*
  * KCPU queue events
  */
 DECLARE_EVENT_CLASS(mali_csf_kcpu_queue_template,
 	TP_PROTO(struct kbase_kcpu_command_queue *queue,
 		 u64 info_val1, u64 info_val2),
 	TP_ARGS(queue, info_val1, info_val2),
 	TP_STRUCT__entry(
 		__field(u64, info_val1)
 		__field(u64, info_val2)
 		__field(pid_t, kctx_tgid)
 		__field(u32, kctx_id)
 		__field(u8, id)
 	),
 	TP_fast_assign(
 		{
 			__entry->info_val1 = info_val1;
 			__entry->info_val2 = info_val2;
 			__entry->kctx_id = queue->kctx->id;
 			__entry->kctx_tgid = queue->kctx->tgid;
 			__entry->id = queue->id;
 		}

 	),
 	TP_printk("kctx=%d_%u id=%u info_val1=0x%llx info_val2=0x%llx",
 			__entry->kctx_tgid, __entry->kctx_id, __entry->id,
 			__entry->info_val1, __entry->info_val2)
 );

 #define DEFINE_MALI_CSF_KCPU_EVENT(name)  \
 	DEFINE_EVENT(mali_csf_kcpu_queue_template, mali_##name, \
 	TP_PROTO(struct kbase_kcpu_command_queue *queue, \
 		 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);

 #undef DEFINE_MALI_CSF_KCPU_EVENT

 #endif /* !defined(_KBASE_DEBUG_LINUX_KTRACE_CSF_H_) || defined(TRACE_HEADER_MULTI_READ) */
	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
	/*
	*
	* (C) COPYRIGHT 2020-2021 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
	* Foundation, and any use by you of this program is subject to the terms
	* of such GNU license.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, you can access it online at
	* http://www.gnu.org/licenses/gpl-2.0.html.
	*
	*/

	/*
	* NOTE: This must only be included through mali_linux_trace.h,
	* otherwise it will fail to setup tracepoints correctly
	*/

	#if !defined(_KBASE_DEBUG_LINUX_KTRACE_CSF_H_) \|\| defined(TRACE_HEADER_MULTI_READ)
	#define _KBASE_DEBUG_LINUX_KTRACE_CSF_H_

	/*
	* 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_TOCK_END);
	DEFINE_MALI_ADD_EVENT(SCHEDULER_TICK);
	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(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);

	DECLARE_EVENT_CLASS(mali_csf_grp_q_template,
	TP_PROTO(struct kbase_device kbdev, struct kbase_queue_group group,
	struct kbase_queue *queue, u64 info_val),
	TP_ARGS(kbdev, group, queue, info_val),
	TP_STRUCT__entry(
	__field(u64, info_val)
	__field(pid_t, kctx_tgid)
	__field(u32, kctx_id)
	__field(u8, group_handle)
	__field(s8, csg_nr)
	__field(u8, slot_prio)
	__field(s8, csi_index)
	),
	TP_fast_assign(
	{
	struct kbase_context *kctx = NULL;

	__entry->info_val = info_val;
	/* Note: if required in future, we could record some
	* flags in __entry about whether the group/queue parts
	* are valid, and add that to the trace message e.g.
	* by using __print_flags()/__print_symbolic()
	*/
	if (queue) {
	/* Note: kctx overridden by group->kctx later if group is valid */
	kctx = queue->kctx;
	__entry->csi_index = queue->csi_index;
	} else {
	__entry->csi_index = -1;
	}

	if (group) {
	kctx = group->kctx;
	__entry->group_handle = group->handle;
	__entry->csg_nr = group->csg_nr;
	if (group->csg_nr >= 0)
	__entry->slot_prio = kbdev->csf.scheduler.csg_slots[group->csg_nr].priority;
	else
	__entry->slot_prio = 0u;
	} else {
	__entry->group_handle = 0u;
	__entry->csg_nr = -1;
	__entry->slot_prio = 0u;
	}
	__entry->kctx_id = (kctx) ? kctx->id : 0u;
	__entry->kctx_tgid = (kctx) ? kctx->tgid : 0;
	}

	),
	TP_printk("kctx=%d_%u group=%u slot=%d prio=%u csi=%d info=0x%llx",
	__entry->kctx_tgid, __entry->kctx_id,
	__entry->group_handle, __entry->csg_nr,
	__entry->slot_prio, __entry->csi_index,
	__entry->info_val)
	);

	/*
	* Group events
	*/
	#define DEFINE_MALI_CSF_GRP_EVENT(name) \
	DEFINE_EVENT_PRINT(mali_csf_grp_q_template, mali_##name, \
	TP_PROTO(struct kbase_device kbdev, struct kbase_queue_group group, \
	struct kbase_queue *queue, u64 info_val), \
	TP_ARGS(kbdev, group, queue, info_val), \
	TP_printk("kctx=%d_%u group=%u slot=%d prio=%u info=0x%llx", \
	__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_STOPPED);
	DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_CLEANED);
	DEFINE_MALI_CSF_GRP_EVENT(CSG_SLOT_STATUS_UPDATE);
	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_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(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(PROTM_EVENT_WORKER_END);

	#undef DEFINE_MALI_CSF_GRP_EVENT

	/*
	* Group + Queue events
	*/
	#define DEFINE_MALI_CSF_GRP_Q_EVENT(name) \
	DEFINE_EVENT(mali_csf_grp_q_template, mali_##name, \
	TP_PROTO(struct kbase_device kbdev, struct kbase_queue_group group, \
	struct kbase_queue *queue, u64 info_val), \
	TP_ARGS(kbdev, group, queue, info_val))

	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_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);

	#undef DEFINE_MALI_CSF_GRP_Q_EVENT

	/*
	* KCPU queue events
	*/
	DECLARE_EVENT_CLASS(mali_csf_kcpu_queue_template,
	TP_PROTO(struct kbase_kcpu_command_queue *queue,
	u64 info_val1, u64 info_val2),
	TP_ARGS(queue, info_val1, info_val2),
	TP_STRUCT__entry(
	__field(u64, info_val1)
	__field(u64, info_val2)
	__field(pid_t, kctx_tgid)
	__field(u32, kctx_id)
	__field(u8, id)
	),
	TP_fast_assign(
	{
	__entry->info_val1 = info_val1;
	__entry->info_val2 = info_val2;
	__entry->kctx_id = queue->kctx->id;
	__entry->kctx_tgid = queue->kctx->tgid;
	__entry->id = queue->id;
	}

	),
	TP_printk("kctx=%d_%u id=%u info_val1=0x%llx info_val2=0x%llx",
	__entry->kctx_tgid, __entry->kctx_id, __entry->id,
	__entry->info_val1, __entry->info_val2)
	);

	#define DEFINE_MALI_CSF_KCPU_EVENT(name) \
	DEFINE_EVENT(mali_csf_kcpu_queue_template, mali_##name, \
	TP_PROTO(struct kbase_kcpu_command_queue *queue, \
	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);

	#undef DEFINE_MALI_CSF_KCPU_EVENT

	#endif /* !defined(_KBASE_DEBUG_LINUX_KTRACE_CSF_H_) \|\| defined(TRACE_HEADER_MULTI_READ) */