dvalin/kernel/drivers/gpu/arm/midgard/debug/backend/mali_kbase_debug_ktrace_codes_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.
  *
  */

 /*
  * ***** IMPORTANT: THIS IS NOT A NORMAL HEADER FILE         *****
  * *****            DO NOT INCLUDE DIRECTLY                  *****
  * *****            THE LACK OF HEADER GUARDS IS INTENTIONAL *****
  */

 /*
  * The purpose of this header file is just to contain a list of trace code
  * identifiers
  *
  * When updating this file, also remember to update
  * mali_kbase_debug_linux_ktrace_csf.h
  *
  * IMPORTANT: THIS FILE MUST NOT BE USED FOR ANY OTHER PURPOSE OTHER THAN THAT
  * DESCRIBED IN mali_kbase_debug_ktrace_codes.h
  */

 #if 0 /* Dummy section to avoid breaking formatting */
 int dummy_array[] = {
 #endif
 	/*
 	 * Generic CSF events
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(EVICT_CTX_SLOTS),
 	/* 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(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_END),
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RESET),
 	/* info_val = timeout in ms */
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_WAIT_PROTM_QUIT),
 	/* 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),

 	/* info_val = JOB_IRQ_STATUS */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT),
 	/* 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),
 	/* info_val = GLB_REQ ^ GLB_ACQ */
 	KBASE_KTRACE_CODE_MAKE_CODE(GLB_REQ_ACQ),
 	/* 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),
 	/* 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),
 	/* 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(IDLE_WORKER_BEGIN),
 	/* 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),

 	/* info_val = bitmask of slots that gave an ACK for STATUS_UPDATE */
 	KBASE_KTRACE_CODE_MAKE_CODE(SLOTS_STATUS_UPDATE_ACK),

 	/*
 	 * Group events
 	 */
 	/* info_val[2:0] == CSG_REQ state issued
 	 * 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),
 	/* info_val == CSG_REQ state issued */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STOP),
 	/* info_val == CSG_ACK state */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STARTED),
 	/* 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),
 	/* info_val = scheduler's new csg_slots_idle_mask[0]
 	 * group->csg_nr indicates which bit was set
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_IDLE_SET),
 	/* info_val = scheduler's new csg_slots_idle_mask[0]
 	 * group->csg_nr indicates which bit was cleared
 	 *
 	 * in case of no group, multiple bits may have been updated
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_IDLE_CLEAR),
 	/* info_val == previous priority */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PRIO_UPDATE),
 	/* info_val == CSG_REQ ^ CSG_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SYNC_UPDATE_INTERRUPT),
 	/* info_val == CSG_REQ ^ CSG_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_IDLE_INTERRUPT),
 	/* info_val == CSG_REQ ^ CSG_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PROGRESS_TIMER_INTERRUPT),
 	/* info_val[31:0] == CSG_REQ ^ CSG_ACQ
 	 * info_val[63:32] == CSG_IRQ_REQ ^ CSG_IRQ_ACK
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_PROCESS_END),
 	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SYNC_UPDATE_DONE),
 	/* info_val == run state of the group */
 	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_DESCHEDULE),
 	/* info_val == run state of the group */
 	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SCHEDULE),
 	/* 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),

 	/* 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),
 	/* info_val == new num_runnable_grps
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_REMOVE_RUNNABLE),
 	/* 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),
 	/* 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),
 	/* 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),

 	/* 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),
 	/* info_val[31:0] == number of GPU address space slots in use
 	 * info_val[63:32] == number of runnable groups
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TOP_GRP),
 	/* 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),
 	/* info_val == new count of off-slot non-idle groups */
 	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_DEC),

 	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_BEGIN),
 	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_END),

 	/*
 	 * Group + Queue events
 	 */
 	/* info_val == queue->enabled */
 	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),
 	/* 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),
 	/* info_val == CS_REQ ^ CS_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_FAULT_INTERRUPT),
 	/* info_val == CS_REQ ^ CS_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_TILER_OOM_INTERRUPT),
 	/* info_val == CS_REQ ^ CS_ACK */
 	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_PEND_INTERRUPT),
 	/* 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),
 	/* info_val == bool for result of the evaluation */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_EVALUATED),
 	/* info_val == contents of CS_STATUS_WAIT */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_STATUS_WAIT),
 	/* info_val == current sync value pointed to by queue->sync_ptr */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_CURRENT_VAL),
 	/* info_val == current value of CS_STATUS_WAIT_SYNC_VALUE */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_TEST_VAL),
 	/* info_val == current value of CS_STATUS_BLOCKED_REASON */
 	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_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),
 	/* 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),

 	/*
 	 * KCPU queue events
 	 */
 	/* KTrace info_val == KCPU queue fence context
 	 * KCPU extra_info_val == N/A.
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_NEW),
 	/* 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),
 	/* 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),
 	/* 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),
 	/* 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),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_SIGNAL),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_START),
 	/* KTrace info_val == Fence context
 	 * KCPU extra_info_val == Fence seqno.
 	 */
 	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_END),

 #if 0 /* Dummy section to avoid breaking formatting */
 };
 #endif

 /* ***** THE LACK OF HEADER GUARDS IS INTENTIONAL ***** */
	/* 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.
	*
	*/

	/*
	* *** IMPORTANT: THIS IS NOT A NORMAL HEADER FILE ***
	* *** DO NOT INCLUDE DIRECTLY ***
	* *** THE LACK OF HEADER GUARDS IS INTENTIONAL ***
	*/

	/*
	* The purpose of this header file is just to contain a list of trace code
	* identifiers
	*
	* When updating this file, also remember to update
	* mali_kbase_debug_linux_ktrace_csf.h
	*
	* IMPORTANT: THIS FILE MUST NOT BE USED FOR ANY OTHER PURPOSE OTHER THAN THAT
	* DESCRIBED IN mali_kbase_debug_ktrace_codes.h
	*/

	#if 0 /* Dummy section to avoid breaking formatting */
	int dummy_array[] = {
	#endif
	/*
	* Generic CSF events
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(EVICT_CTX_SLOTS),
	/* 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(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_END),
	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_RESET),
	/* info_val = timeout in ms */
	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_WAIT_PROTM_QUIT),
	/* 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),

	/* info_val = JOB_IRQ_STATUS */
	KBASE_KTRACE_CODE_MAKE_CODE(CSF_INTERRUPT),
	/* 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),
	/* info_val = GLB_REQ ^ GLB_ACQ */
	KBASE_KTRACE_CODE_MAKE_CODE(GLB_REQ_ACQ),
	/* 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),
	/* 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),
	/* 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(IDLE_WORKER_BEGIN),
	/* 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),

	/* info_val = bitmask of slots that gave an ACK for STATUS_UPDATE */
	KBASE_KTRACE_CODE_MAKE_CODE(SLOTS_STATUS_UPDATE_ACK),

	/*
	* Group events
	*/
	/* info_val[2:0] == CSG_REQ state issued
	* 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),
	/* info_val == CSG_REQ state issued */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STOP),
	/* info_val == CSG_ACK state */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_STARTED),
	/* 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),
	/* info_val = scheduler's new csg_slots_idle_mask[0]
	* group->csg_nr indicates which bit was set
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_IDLE_SET),
	/* info_val = scheduler's new csg_slots_idle_mask[0]
	* group->csg_nr indicates which bit was cleared
	*
	* in case of no group, multiple bits may have been updated
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SLOT_IDLE_CLEAR),
	/* info_val == previous priority */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PRIO_UPDATE),
	/* info_val == CSG_REQ ^ CSG_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_SYNC_UPDATE_INTERRUPT),
	/* info_val == CSG_REQ ^ CSG_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_IDLE_INTERRUPT),
	/* info_val == CSG_REQ ^ CSG_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_PROGRESS_TIMER_INTERRUPT),
	/* info_val[31:0] == CSG_REQ ^ CSG_ACQ
	* info_val[63:32] == CSG_IRQ_REQ ^ CSG_IRQ_ACK
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(CSG_INTERRUPT_PROCESS_END),
	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SYNC_UPDATE_DONE),
	/* info_val == run state of the group */
	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_DESCHEDULE),
	/* info_val == run state of the group */
	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_SCHEDULE),
	/* 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),

	/* 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),
	/* info_val == new num_runnable_grps
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(GROUP_REMOVE_RUNNABLE),
	/* 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),
	/* 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),
	/* 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),

	/* 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),
	/* info_val[31:0] == number of GPU address space slots in use
	* info_val[63:32] == number of runnable groups
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_TOP_GRP),
	/* 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),
	/* info_val == new count of off-slot non-idle groups */
	KBASE_KTRACE_CODE_MAKE_CODE(SCHEDULER_NONIDLE_OFFSLOT_DEC),

	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_BEGIN),
	KBASE_KTRACE_CODE_MAKE_CODE(PROTM_EVENT_WORKER_END),

	/*
	* Group + Queue events
	*/
	/* info_val == queue->enabled */
	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),
	/* 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),
	/* info_val == CS_REQ ^ CS_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSI_FAULT_INTERRUPT),
	/* info_val == CS_REQ ^ CS_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSI_TILER_OOM_INTERRUPT),
	/* info_val == CS_REQ ^ CS_ACK */
	KBASE_KTRACE_CODE_MAKE_CODE(CSI_PROTM_PEND_INTERRUPT),
	/* 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),
	/* info_val == bool for result of the evaluation */
	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_UPDATE_EVALUATED),
	/* info_val == contents of CS_STATUS_WAIT */
	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_STATUS_WAIT),
	/* info_val == current sync value pointed to by queue->sync_ptr */
	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_CURRENT_VAL),
	/* info_val == current value of CS_STATUS_WAIT_SYNC_VALUE */
	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_TEST_VAL),
	/* info_val == current value of CS_STATUS_BLOCKED_REASON */
	KBASE_KTRACE_CODE_MAKE_CODE(QUEUE_SYNC_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),
	/* 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),

	/*
	* KCPU queue events
	*/
	/* KTrace info_val == KCPU queue fence context
	* KCPU extra_info_val == N/A.
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(KCPU_QUEUE_NEW),
	/* 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),
	/* 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),
	/* 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),
	/* 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),
	/* KTrace info_val == Fence context
	* KCPU extra_info_val == Fence seqno.
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_SIGNAL),
	/* KTrace info_val == Fence context
	* KCPU extra_info_val == Fence seqno.
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_START),
	/* KTrace info_val == Fence context
	* KCPU extra_info_val == Fence seqno.
	*/
	KBASE_KTRACE_CODE_MAKE_CODE(FENCE_WAIT_END),

	#if 0 /* Dummy section to avoid breaking formatting */
	};
	#endif

	/* *** THE LACK OF HEADER GUARDS IS INTENTIONAL *** */