/* 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.
|
*
|
*/
|
|
#ifndef _UAPI_KBASE_CSF_IOCTL_H_
|
#define _UAPI_KBASE_CSF_IOCTL_H_
|
|
#include <asm-generic/ioctl.h>
|
#include <linux/types.h>
|
|
/*
|
* 1.0:
|
* - CSF IOCTL header separated from JM
|
* 1.1:
|
* - Add a new priority level BASE_QUEUE_GROUP_PRIORITY_REALTIME
|
* - Add ioctl 54: This controls the priority setting.
|
* 1.2:
|
* - Add new CSF GPU_FEATURES register into the property structure
|
* returned by KBASE_IOCTL_GET_GPUPROPS
|
* 1.3:
|
* - Add __u32 group_uid member to
|
* &struct_kbase_ioctl_cs_queue_group_create.out
|
* 1.4:
|
* - Replace padding in kbase_ioctl_cs_get_glb_iface with
|
* instr_features member of same size
|
* 1.5:
|
* - Add ioctl 40: kbase_ioctl_cs_queue_register_ex, this is a new
|
* queue registration call with extended format for supporting CS
|
* trace configurations with CSF trace_command.
|
*/
|
|
#define BASE_UK_VERSION_MAJOR 1
|
#define BASE_UK_VERSION_MINOR 5
|
|
/**
|
* struct kbase_ioctl_version_check - Check version compatibility between
|
* kernel and userspace
|
*
|
* @major: Major version number
|
* @minor: Minor version number
|
*/
|
struct kbase_ioctl_version_check {
|
__u16 major;
|
__u16 minor;
|
};
|
|
#define KBASE_IOCTL_VERSION_CHECK_RESERVED \
|
_IOWR(KBASE_IOCTL_TYPE, 0, struct kbase_ioctl_version_check)
|
|
|
/**
|
* struct kbase_ioctl_cs_queue_register - Register a GPU command queue with the
|
* base back-end
|
*
|
* @buffer_gpu_addr: GPU address of the buffer backing the queue
|
* @buffer_size: Size of the buffer in bytes
|
* @priority: Priority of the queue within a group when run within a process
|
* @padding: Currently unused, must be zero
|
*
|
* @Note: There is an identical sub-section in kbase_ioctl_cs_queue_register_ex.
|
* Any change of this struct should also be mirrored to the latter.
|
*/
|
struct kbase_ioctl_cs_queue_register {
|
__u64 buffer_gpu_addr;
|
__u32 buffer_size;
|
__u8 priority;
|
__u8 padding[3];
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_REGISTER \
|
_IOW(KBASE_IOCTL_TYPE, 36, struct kbase_ioctl_cs_queue_register)
|
|
/**
|
* struct kbase_ioctl_cs_queue_kick - Kick the GPU command queue group scheduler
|
* to notify that a queue has been updated
|
*
|
* @buffer_gpu_addr: GPU address of the buffer backing the queue
|
*/
|
struct kbase_ioctl_cs_queue_kick {
|
__u64 buffer_gpu_addr;
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_KICK \
|
_IOW(KBASE_IOCTL_TYPE, 37, struct kbase_ioctl_cs_queue_kick)
|
|
/**
|
* union kbase_ioctl_cs_queue_bind - Bind a GPU command queue to a group
|
*
|
* @in: Input parameters
|
* @in.buffer_gpu_addr: GPU address of the buffer backing the queue
|
* @in.group_handle: Handle of the group to which the queue should be bound
|
* @in.csi_index: Index of the CSF interface the queue should be bound to
|
* @in.padding: Currently unused, must be zero
|
* @out: Output parameters
|
* @out.mmap_handle: Handle to be used for creating the mapping of CS
|
* input/output pages
|
*/
|
union kbase_ioctl_cs_queue_bind {
|
struct {
|
__u64 buffer_gpu_addr;
|
__u8 group_handle;
|
__u8 csi_index;
|
__u8 padding[6];
|
} in;
|
struct {
|
__u64 mmap_handle;
|
} out;
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_BIND \
|
_IOWR(KBASE_IOCTL_TYPE, 39, union kbase_ioctl_cs_queue_bind)
|
|
/**
|
* struct kbase_ioctl_cs_queue_register_ex - Register a GPU command queue with the
|
* base back-end in extended format,
|
* involving trace buffer configuration
|
*
|
* @buffer_gpu_addr: GPU address of the buffer backing the queue
|
* @buffer_size: Size of the buffer in bytes
|
* @priority: Priority of the queue within a group when run within a process
|
* @padding: Currently unused, must be zero
|
* @ex_offset_var_addr: GPU address of the trace buffer write offset variable
|
* @ex_buffer_base: Trace buffer GPU base address for the queue
|
* @ex_buffer_size: Size of the trace buffer in bytes
|
* @ex_event_size: Trace event write size, in log2 designation
|
* @ex_event_state: Trace event states configuration
|
* @ex_padding: Currently unused, must be zero
|
*
|
* @Note: There is an identical sub-section at the start of this struct to that
|
* of @ref kbase_ioctl_cs_queue_register. Any change of this sub-section
|
* must also be mirrored to the latter. Following the said sub-section,
|
* the remaining fields forms the extension, marked with ex_*.
|
*/
|
struct kbase_ioctl_cs_queue_register_ex {
|
__u64 buffer_gpu_addr;
|
__u32 buffer_size;
|
__u8 priority;
|
__u8 padding[3];
|
__u64 ex_offset_var_addr;
|
__u64 ex_buffer_base;
|
__u32 ex_buffer_size;
|
__u8 ex_event_size;
|
__u8 ex_event_state;
|
__u8 ex_padding[2];
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_REGISTER_EX \
|
_IOW(KBASE_IOCTL_TYPE, 40, struct kbase_ioctl_cs_queue_register_ex)
|
|
/**
|
* struct kbase_ioctl_cs_queue_terminate - Terminate a GPU command queue
|
*
|
* @buffer_gpu_addr: GPU address of the buffer backing the queue
|
*/
|
struct kbase_ioctl_cs_queue_terminate {
|
__u64 buffer_gpu_addr;
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_TERMINATE \
|
_IOW(KBASE_IOCTL_TYPE, 41, struct kbase_ioctl_cs_queue_terminate)
|
|
/**
|
* union kbase_ioctl_cs_queue_group_create - Create a GPU command queue group
|
* @in: Input parameters
|
* @in.tiler_mask: Mask of tiler endpoints the group is allowed to use.
|
* @in.fragment_mask: Mask of fragment endpoints the group is allowed to use.
|
* @in.compute_mask: Mask of compute endpoints the group is allowed to use.
|
* @in.cs_min: Minimum number of CSs required.
|
* @in.priority: Queue group's priority within a process.
|
* @in.tiler_max: Maximum number of tiler endpoints the group is allowed
|
* to use.
|
* @in.fragment_max: Maximum number of fragment endpoints the group is
|
* allowed to use.
|
* @in.compute_max: Maximum number of compute endpoints the group is allowed
|
* to use.
|
* @in.padding: Currently unused, must be zero
|
* @out: Output parameters
|
* @out.group_handle: Handle of a newly created queue group.
|
* @out.padding: Currently unused, must be zero
|
* @out.group_uid: UID of the queue group available to base.
|
*/
|
union kbase_ioctl_cs_queue_group_create {
|
struct {
|
__u64 tiler_mask;
|
__u64 fragment_mask;
|
__u64 compute_mask;
|
__u8 cs_min;
|
__u8 priority;
|
__u8 tiler_max;
|
__u8 fragment_max;
|
__u8 compute_max;
|
__u8 padding[3];
|
|
} in;
|
struct {
|
__u8 group_handle;
|
__u8 padding[3];
|
__u32 group_uid;
|
} out;
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_GROUP_CREATE \
|
_IOWR(KBASE_IOCTL_TYPE, 42, union kbase_ioctl_cs_queue_group_create)
|
|
/**
|
* struct kbase_ioctl_cs_queue_group_term - Terminate a GPU command queue group
|
*
|
* @group_handle: Handle of the queue group to be terminated
|
* @padding: Padding to round up to a multiple of 8 bytes, must be zero
|
*/
|
struct kbase_ioctl_cs_queue_group_term {
|
__u8 group_handle;
|
__u8 padding[7];
|
};
|
|
#define KBASE_IOCTL_CS_QUEUE_GROUP_TERMINATE \
|
_IOW(KBASE_IOCTL_TYPE, 43, struct kbase_ioctl_cs_queue_group_term)
|
|
#define KBASE_IOCTL_CS_EVENT_SIGNAL \
|
_IO(KBASE_IOCTL_TYPE, 44)
|
|
typedef __u8 base_kcpu_queue_id; /* We support up to 256 active KCPU queues */
|
|
/**
|
* struct kbase_ioctl_kcpu_queue_new - Create a KCPU command queue
|
*
|
* @id: ID of the new command queue returned by the kernel
|
* @padding: Padding to round up to a multiple of 8 bytes, must be zero
|
*/
|
struct kbase_ioctl_kcpu_queue_new {
|
base_kcpu_queue_id id;
|
__u8 padding[7];
|
};
|
|
#define KBASE_IOCTL_KCPU_QUEUE_CREATE \
|
_IOR(KBASE_IOCTL_TYPE, 45, struct kbase_ioctl_kcpu_queue_new)
|
|
/**
|
* struct kbase_ioctl_kcpu_queue_delete - Destroy a KCPU command queue
|
*
|
* @id: ID of the command queue to be destroyed
|
* @padding: Padding to round up to a multiple of 8 bytes, must be zero
|
*/
|
struct kbase_ioctl_kcpu_queue_delete {
|
base_kcpu_queue_id id;
|
__u8 padding[7];
|
};
|
|
#define KBASE_IOCTL_KCPU_QUEUE_DELETE \
|
_IOW(KBASE_IOCTL_TYPE, 46, struct kbase_ioctl_kcpu_queue_delete)
|
|
/**
|
* struct kbase_ioctl_kcpu_queue_enqueue - Enqueue commands into the KCPU queue
|
*
|
* @addr: Memory address of an array of struct base_kcpu_queue_command
|
* @nr_commands: Number of commands in the array
|
* @id: kcpu queue identifier, returned by KBASE_IOCTL_KCPU_QUEUE_CREATE ioctl
|
* @padding: Padding to round up to a multiple of 8 bytes, must be zero
|
*/
|
struct kbase_ioctl_kcpu_queue_enqueue {
|
__u64 addr;
|
__u32 nr_commands;
|
base_kcpu_queue_id id;
|
__u8 padding[3];
|
};
|
|
#define KBASE_IOCTL_KCPU_QUEUE_ENQUEUE \
|
_IOW(KBASE_IOCTL_TYPE, 47, struct kbase_ioctl_kcpu_queue_enqueue)
|
|
/**
|
* union kbase_ioctl_cs_tiler_heap_init - Initialize chunked tiler memory heap
|
* @in: Input parameters
|
* @in.chunk_size: Size of each chunk.
|
* @in.initial_chunks: Initial number of chunks that heap will be created with.
|
* @in.max_chunks: Maximum number of chunks that the heap is allowed to use.
|
* @in.target_in_flight: Number of render-passes that the driver should attempt to
|
* keep in flight for which allocation of new chunks is
|
* allowed.
|
* @in.group_id: Group ID to be used for physical allocations.
|
* @in.padding: Padding
|
* @out: Output parameters
|
* @out.gpu_heap_va: GPU VA (virtual address) of Heap context that was set up
|
* for the heap.
|
* @out.first_chunk_va: GPU VA of the first chunk allocated for the heap,
|
* actually points to the header of heap chunk and not to
|
* the low address of free memory in the chunk.
|
*/
|
union kbase_ioctl_cs_tiler_heap_init {
|
struct {
|
__u32 chunk_size;
|
__u32 initial_chunks;
|
__u32 max_chunks;
|
__u16 target_in_flight;
|
__u8 group_id;
|
__u8 padding;
|
} in;
|
struct {
|
__u64 gpu_heap_va;
|
__u64 first_chunk_va;
|
} out;
|
};
|
|
#define KBASE_IOCTL_CS_TILER_HEAP_INIT \
|
_IOWR(KBASE_IOCTL_TYPE, 48, union kbase_ioctl_cs_tiler_heap_init)
|
|
/**
|
* struct kbase_ioctl_cs_tiler_heap_term - Terminate a chunked tiler heap
|
* instance
|
*
|
* @gpu_heap_va: GPU VA of Heap context that was set up for the heap.
|
*/
|
struct kbase_ioctl_cs_tiler_heap_term {
|
__u64 gpu_heap_va;
|
};
|
|
#define KBASE_IOCTL_CS_TILER_HEAP_TERM \
|
_IOW(KBASE_IOCTL_TYPE, 49, struct kbase_ioctl_cs_tiler_heap_term)
|
|
/**
|
* union kbase_ioctl_cs_get_glb_iface - Request the global control block
|
* of CSF interface capabilities
|
*
|
* @in: Input parameters
|
* @in.max_group_num: The maximum number of groups to be read. Can be 0, in
|
* which case groups_ptr is unused.
|
* @in.max_total_stream _num: The maximum number of CSs to be read. Can be 0, in
|
* which case streams_ptr is unused.
|
* @in.groups_ptr: Pointer where to store all the group data (sequentially).
|
* @in.streams_ptr: Pointer where to store all the CS data (sequentially).
|
* @out: Output parameters
|
* @out.glb_version: Global interface version.
|
* @out.features: Bit mask of features (e.g. whether certain types of job
|
* can be suspended).
|
* @out.group_num: Number of CSGs supported.
|
* @out.prfcnt_size: Size of CSF performance counters, in bytes. Bits 31:16
|
* hold the size of firmware performance counter data
|
* and 15:0 hold the size of hardware performance counter
|
* data.
|
* @out.total_stream_num: Total number of CSs, summed across all groups.
|
* @out.instr_features: Instrumentation features. Bits 7:4 hold the maximum
|
* size of events. Bits 3:0 hold the offset update rate.
|
* (csf >= 1.1.0)
|
*
|
*/
|
union kbase_ioctl_cs_get_glb_iface {
|
struct {
|
__u32 max_group_num;
|
__u32 max_total_stream_num;
|
__u64 groups_ptr;
|
__u64 streams_ptr;
|
} in;
|
struct {
|
__u32 glb_version;
|
__u32 features;
|
__u32 group_num;
|
__u32 prfcnt_size;
|
__u32 total_stream_num;
|
__u32 instr_features;
|
} out;
|
};
|
|
#define KBASE_IOCTL_CS_GET_GLB_IFACE \
|
_IOWR(KBASE_IOCTL_TYPE, 51, union kbase_ioctl_cs_get_glb_iface)
|
|
struct kbase_ioctl_cs_cpu_queue_info {
|
__u64 buffer;
|
__u64 size;
|
};
|
|
#define KBASE_IOCTL_VERSION_CHECK \
|
_IOWR(KBASE_IOCTL_TYPE, 52, struct kbase_ioctl_version_check)
|
|
#define KBASE_IOCTL_CS_CPU_QUEUE_DUMP \
|
_IOW(KBASE_IOCTL_TYPE, 53, struct kbase_ioctl_cs_cpu_queue_info)
|
|
/***************
|
* test ioctls *
|
***************/
|
#if MALI_UNIT_TEST
|
/* These ioctls are purely for test purposes and are not used in the production
|
* driver, they therefore may change without notice
|
*/
|
|
/**
|
* struct kbase_ioctl_cs_event_memory_write - Write an event memory address
|
* @cpu_addr: Memory address to write
|
* @value: Value to write
|
* @padding: Currently unused, must be zero
|
*/
|
struct kbase_ioctl_cs_event_memory_write {
|
__u64 cpu_addr;
|
__u8 value;
|
__u8 padding[7];
|
};
|
|
/**
|
* union kbase_ioctl_cs_event_memory_read - Read an event memory address
|
* @in: Input parameters
|
* @in.cpu_addr: Memory address to read
|
* @out: Output parameters
|
* @out.value: Value read
|
* @out.padding: Currently unused, must be zero
|
*/
|
union kbase_ioctl_cs_event_memory_read {
|
struct {
|
__u64 cpu_addr;
|
} in;
|
struct {
|
__u8 value;
|
__u8 padding[7];
|
} out;
|
};
|
|
#endif /* MALI_UNIT_TEST */
|
|
#endif /* _UAPI_KBASE_CSF_IOCTL_H_ */
|
