| /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ |
| /* |
| * |
| * (C) COPYRIGHT 2018-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. |
| * |
| */ |
| |
| /* Definitions (types, defines, etcs) common to the CSF. |
| * They are placed here to allow the hierarchy of header files to work. |
| */ |
| |
| #ifndef _KBASE_CSF_DEFS_H_ |
| #define _KBASE_CSF_DEFS_H_ |
| |
| #include <linux/types.h> |
| #include <linux/wait.h> |
| |
| #include "mali_kbase_csf_firmware.h" |
| |
| /* Maximum number of KCPU command queues to be created per GPU address space. |
| */ |
| #define KBASEP_MAX_KCPU_QUEUES ((size_t)256) |
| |
| /* Maximum number of GPU command queue groups to be created per GPU address |
| * space. |
| */ |
| #define MAX_QUEUE_GROUP_NUM (256) |
| |
| /* Maximum number of GPU tiler heaps to allow to be created per GPU address |
| * space. |
| */ |
| #define MAX_TILER_HEAPS (128) |
| |
| #define CSF_FIRMWARE_ENTRY_READ (1ul << 0) |
| #define CSF_FIRMWARE_ENTRY_WRITE (1ul << 1) |
| #define CSF_FIRMWARE_ENTRY_EXECUTE (1ul << 2) |
| #define CSF_FIRMWARE_ENTRY_CACHE_MODE (3ul << 3) |
| #define CSF_FIRMWARE_ENTRY_PROTECTED (1ul << 5) |
| #define CSF_FIRMWARE_ENTRY_SHARED (1ul << 30) |
| #define CSF_FIRMWARE_ENTRY_ZERO (1ul << 31) |
| |
| /** |
| * enum kbase_csf_bind_state - bind state of the queue |
| * |
| * @KBASE_CSF_QUEUE_UNBOUND: Set when the queue is registered or when the link |
| * between queue and the group to which it was bound or being bound is removed. |
| * @KBASE_CSF_QUEUE_BIND_IN_PROGRESS: Set when the first part of bind operation |
| * has completed i.e. CS_QUEUE_BIND ioctl. |
| * @KBASE_CSF_QUEUE_BOUND: Set when the bind operation has completed i.e. IO |
| * pages have been mapped in the process address space. |
| */ |
| enum kbase_csf_queue_bind_state { |
| KBASE_CSF_QUEUE_UNBOUND, |
| KBASE_CSF_QUEUE_BIND_IN_PROGRESS, |
| KBASE_CSF_QUEUE_BOUND, |
| }; |
| |
| /** |
| * enum kbase_csf_reset_gpu_state - state of the gpu reset |
| * |
| * @KBASE_CSF_RESET_GPU_NOT_PENDING: Set when the GPU reset isn't pending |
| * |
| * @KBASE_CSF_RESET_GPU_PREPARED: Set when kbase_prepare_to_reset_gpu() has |
| * been called. This is just for debugging checks to encourage callers to call |
| * kbase_prepare_to_reset_gpu() before kbase_reset_gpu(). |
| * |
| * @KBASE_CSF_RESET_GPU_COMMITTED: Set when the GPU reset process has been |
| * committed and so will definitely happen, but the procedure to reset the GPU |
| * has not yet begun. Other threads must finish accessing the HW before we |
| * reach %KBASE_CSF_RESET_GPU_HAPPENING. |
| * |
| * @KBASE_CSF_RESET_GPU_HAPPENING: Set when the GPU reset process is occurring |
| * (silent or otherwise), and is actively accessing the HW. Any changes to the |
| * HW in other threads might get lost, overridden, or corrupted. |
| * |
| * @KBASE_CSF_RESET_GPU_COMMITTED_SILENT: Set when the GPU reset process has |
| * been committed but has not started happening. This is used when resetting |
| * the GPU as part of normal behavior (e.g. when exiting protected mode). |
| * Other threads must finish accessing the HW before we reach |
| * %KBASE_CSF_RESET_GPU_HAPPENING. |
| * |
| * @KBASE_CSF_RESET_GPU_FAILED: Set when an error is encountered during the |
| * GPU reset process. No more work could then be executed on GPU, unloading |
| * the Driver module is the only option. |
| */ |
| enum kbase_csf_reset_gpu_state { |
| KBASE_CSF_RESET_GPU_NOT_PENDING, |
| KBASE_CSF_RESET_GPU_PREPARED, |
| KBASE_CSF_RESET_GPU_COMMITTED, |
| KBASE_CSF_RESET_GPU_HAPPENING, |
| KBASE_CSF_RESET_GPU_COMMITTED_SILENT, |
| KBASE_CSF_RESET_GPU_FAILED, |
| }; |
| |
| /** |
| * enum kbase_csf_group_state - state of the GPU command queue group |
| * |
| * @KBASE_CSF_GROUP_INACTIVE: Group is inactive and won't be |
| * considered by scheduler for running on |
| * CSG slot. |
| * @KBASE_CSF_GROUP_RUNNABLE: Group is in the list of runnable groups |
| * and is subjected to time-slice based |
| * scheduling. A start request would be |
| * sent (or already has been sent) if the |
| * group is assigned the CS |
| * group slot for the fist time. |
| * @KBASE_CSF_GROUP_IDLE: Group is currently on a CSG slot |
| * but all the CSs bound to the group have |
| * become either idle or waiting on sync |
| * object. |
| * Group could be evicted from the slot on |
| * the next tick if there are no spare |
| * slots left after scheduling non-idle |
| * queue groups. If the group is kept on |
| * slot then it would be moved to the |
| * RUNNABLE state, also if one of the |
| * queues bound to the group is kicked it |
| * would be moved to the RUNNABLE state. |
| * If the group is evicted from the slot it |
| * would be moved to either |
| * KBASE_CSF_GROUP_SUSPENDED_ON_IDLE or |
| * KBASE_CSF_GROUP_SUSPENDED_ON_WAIT_SYNC |
| * state. |
| * @KBASE_CSF_GROUP_SUSPENDED: Group was evicted from the CSG slot |
| * and is not running but is still in the |
| * list of runnable groups and subjected |
| * to time-slice based scheduling. A resume |
| * request would be sent when a CSG slot is |
| * re-assigned to the group and once the |
| * resume is complete group would be moved |
| * back to the RUNNABLE state. |
| * @KBASE_CSF_GROUP_SUSPENDED_ON_IDLE: Same as KBASE_CSF_GROUP_SUSPENDED except |
| * that queue group also became idle before |
| * the suspension. This state helps |
| * Scheduler avoid scheduling the idle |
| * groups over the non-idle groups in the |
| * subsequent ticks. If one of the queues |
| * bound to the group is kicked it would be |
| * moved to the SUSPENDED state. |
| * @KBASE_CSF_GROUP_SUSPENDED_ON_WAIT_SYNC: Same as GROUP_SUSPENDED_ON_IDLE |
| * except that at least one CS |
| * bound to this group was |
| * waiting for synchronization object |
| * before the suspension. |
| * @KBASE_CSF_GROUP_FAULT_EVICTED: Group is evicted from the scheduler due |
| * to a fault condition, pending to be |
| * terminated. |
| * @KBASE_CSF_GROUP_TERMINATED: Group is no longer schedulable and is |
| * pending to be deleted by Client, all the |
| * queues bound to it have been unbound. |
| */ |
| enum kbase_csf_group_state { |
| KBASE_CSF_GROUP_INACTIVE, |
| KBASE_CSF_GROUP_RUNNABLE, |
| KBASE_CSF_GROUP_IDLE, |
| KBASE_CSF_GROUP_SUSPENDED, |
| KBASE_CSF_GROUP_SUSPENDED_ON_IDLE, |
| KBASE_CSF_GROUP_SUSPENDED_ON_WAIT_SYNC, |
| KBASE_CSF_GROUP_FAULT_EVICTED, |
| KBASE_CSF_GROUP_TERMINATED, |
| }; |
| |
| /** |
| * enum kbase_csf_csg_slot_state - state of the command queue group slots under |
| * the scheduler control. |
| * |
| * @CSG_SLOT_READY: The slot is clean and ready to be programmed with a |
| * queue group. |
| * @CSG_SLOT_READY2RUN: The slot has been programmed with a queue group, i.e. a |
| * start or resume request has been sent to the firmware. |
| * @CSG_SLOT_RUNNING: The queue group is running on the slot, acknowledgment |
| * of a start or resume request has been obtained from the |
| * firmware. |
| * @CSG_SLOT_DOWN2STOP: The suspend or terminate request for the queue group on |
| * the slot has been sent to the firmware. |
| * @CSG_SLOT_STOPPED: The queue group is removed from the slot, acknowledgment |
| * of suspend or terminate request has been obtained from |
| * the firmware. |
| * @CSG_SLOT_READY2RUN_TIMEDOUT: The start or resume request sent on the slot |
| * for the queue group timed out. |
| * @CSG_SLOT_DOWN2STOP_TIMEDOUT: The suspend or terminate request for queue |
| * group on the slot timed out. |
| */ |
| enum kbase_csf_csg_slot_state { |
| CSG_SLOT_READY, |
| CSG_SLOT_READY2RUN, |
| CSG_SLOT_RUNNING, |
| CSG_SLOT_DOWN2STOP, |
| CSG_SLOT_STOPPED, |
| CSG_SLOT_READY2RUN_TIMEDOUT, |
| CSG_SLOT_DOWN2STOP_TIMEDOUT, |
| }; |
| |
| /** |
| * enum kbase_csf_scheduler_state - state of the scheduler operational phases. |
| * |
| * @SCHED_BUSY: The scheduler is busy performing on tick schedule |
| * operations, the state of CSG slots |
| * can't be changed. |
| * @SCHED_INACTIVE: The scheduler is inactive, it is allowed to modify the |
| * state of CSG slots by in-cycle |
| * priority scheduling. |
| * @SCHED_SUSPENDED: The scheduler is in low-power mode with scheduling |
| * operations suspended and is not holding the power |
| * management reference. This can happen if the GPU |
| * becomes idle for a duration exceeding a threshold, |
| * or due to a system triggered suspend action. |
| */ |
| enum kbase_csf_scheduler_state { |
| SCHED_BUSY, |
| SCHED_INACTIVE, |
| SCHED_SUSPENDED, |
| }; |
| |
| /** |
| * enum kbase_queue_group_priority - Kbase internal relative priority list. |
| * |
| * @KBASE_QUEUE_GROUP_PRIORITY_REALTIME: The realtime queue group priority. |
| * @KBASE_QUEUE_GROUP_PRIORITY_HIGH: The high queue group priority. |
| * @KBASE_QUEUE_GROUP_PRIORITY_MEDIUM: The medium queue group priority. |
| * @KBASE_QUEUE_GROUP_PRIORITY_LOW: The low queue group priority. |
| * @KBASE_QUEUE_GROUP_PRIORITY_COUNT: The number of priority levels. |
| */ |
| enum kbase_queue_group_priority { |
| KBASE_QUEUE_GROUP_PRIORITY_REALTIME = 0, |
| KBASE_QUEUE_GROUP_PRIORITY_HIGH, |
| KBASE_QUEUE_GROUP_PRIORITY_MEDIUM, |
| KBASE_QUEUE_GROUP_PRIORITY_LOW, |
| KBASE_QUEUE_GROUP_PRIORITY_COUNT |
| }; |
| |
| |
| /** |
| * struct kbase_csf_notification - Event or error generated as part of command |
| * queue execution |
| * |
| * @data: Event or error data returned to userspace |
| * @link: Link to the linked list, &struct_kbase_csf_context.error_list. |
| */ |
| struct kbase_csf_notification { |
| struct base_csf_notification data; |
| struct list_head link; |
| }; |
| |
| /** |
| * struct kbase_queue - Object representing a GPU command queue. |
| * |
| * @kctx: Pointer to the base context with which this GPU command queue |
| * is associated. |
| * @reg: Pointer to the region allocated from the shared |
| * interface segment for mapping the User mode |
| * input/output pages in MCU firmware address space. |
| * @phys: Pointer to the physical pages allocated for the |
| * pair or User mode input/output page |
| * @user_io_addr: Pointer to the permanent kernel mapping of User mode |
| * input/output pages. The pages can be accessed through |
| * the mapping without any cache maintenance. |
| * @handle: Handle returned with bind ioctl for creating a |
| * contiguous User mode mapping of input/output pages & |
| * the hardware doorbell page. |
| * @doorbell_nr: Index of the hardware doorbell page assigned to the |
| * queue. |
| * @db_file_offset: File offset value that is assigned to userspace mapping |
| * created on bind to access the doorbell page. |
| * It is in page units. |
| * @link: Link to the linked list of GPU command queues created per |
| * GPU address space. |
| * @refcount: Reference count, stands for the number of times the queue |
| * has been referenced. The reference is taken when it is |
| * created, when it is bound to the group and also when the |
| * @oom_event_work work item is queued |
| * for it. |
| * @group: Pointer to the group to which this queue is bound. |
| * @queue_reg: Pointer to the VA region allocated for CS buffer. |
| * @oom_event_work: Work item corresponding to the out of memory event for |
| * chunked tiler heap being used for this queue. |
| * @base_addr: Base address of the CS buffer. |
| * @size: Size of the CS buffer. |
| * @priority: Priority of this queue within the group. |
| * @bind_state: Bind state of the queue as enum @kbase_csf_queue_bind_state |
| * @csi_index: The ID of the assigned CS hardware interface. |
| * @enabled: Indicating whether the CS is running, or not. |
| * @status_wait: Value of CS_STATUS_WAIT register of the CS will |
| * be kept when the CS gets blocked by sync wait. |
| * CS_STATUS_WAIT provides information on conditions queue is |
| * blocking on. This is set when the group, to which queue is |
| * bound, is suspended after getting blocked, i.e. in |
| * KBASE_CSF_GROUP_SUSPENDED_ON_WAIT_SYNC state. |
| * @sync_ptr: Value of CS_STATUS_WAIT_SYNC_POINTER register of the CS |
| * will be kept when the CS gets blocked by |
| * sync wait. CS_STATUS_WAIT_SYNC_POINTER contains the address |
| * of synchronization object being waited on. |
| * Valid only when @status_wait is set. |
| * @sync_value: Value of CS_STATUS_WAIT_SYNC_VALUE register of the CS |
| * will be kept when the CS gets blocked by |
| * sync wait. CS_STATUS_WAIT_SYNC_VALUE contains the value |
| * tested against the synchronization object. |
| * Valid only when @status_wait is set. |
| * @sb_status: Value indicates which of the scoreboard entries in the queue |
| * are non-zero |
| * @blocked_reason: Value shows if the queue is blocked, and if so, |
| * the reason why it is blocked |
| * @trace_buffer_base: CS trace buffer base address. |
| * @trace_offset_ptr: Pointer to the CS trace buffer offset variable. |
| * @trace_buffer_size: CS trace buffer size for the queue. |
| * @trace_cfg: CS trace configuration parameters. |
| * @error: GPU command queue fatal information to pass to user space. |
| * @fatal_event_work: Work item to handle the CS fatal event reported for this |
| * queue. |
| * @cs_fatal_info: Records additional information about the CS fatal event. |
| * @cs_fatal: Records information about the CS fatal event. |
| */ |
| struct kbase_queue { |
| struct kbase_context *kctx; |
| struct kbase_va_region *reg; |
| struct tagged_addr phys[2]; |
| char *user_io_addr; |
| u64 handle; |
| int doorbell_nr; |
| unsigned long db_file_offset; |
| struct list_head link; |
| atomic_t refcount; |
| struct kbase_queue_group *group; |
| struct kbase_va_region *queue_reg; |
| struct work_struct oom_event_work; |
| u64 base_addr; |
| u32 size; |
| u8 priority; |
| s8 csi_index; |
| enum kbase_csf_queue_bind_state bind_state; |
| bool enabled; |
| u32 status_wait; |
| u64 sync_ptr; |
| u32 sync_value; |
| u32 sb_status; |
| u32 blocked_reason; |
| u64 trace_buffer_base; |
| u64 trace_offset_ptr; |
| u32 trace_buffer_size; |
| u32 trace_cfg; |
| struct kbase_csf_notification error; |
| struct work_struct fatal_event_work; |
| u64 cs_fatal_info; |
| u32 cs_fatal; |
| }; |
| |
| /** |
| * struct kbase_normal_suspend_buffer - Object representing a normal |
| * suspend buffer for queue group. |
| * @reg: Memory region allocated for the normal-mode suspend buffer. |
| * @phy: Array of physical memory pages allocated for the normal- |
| * mode suspend buffer. |
| */ |
| struct kbase_normal_suspend_buffer { |
| struct kbase_va_region *reg; |
| struct tagged_addr *phy; |
| }; |
| |
| /** |
| * struct kbase_protected_suspend_buffer - Object representing a protected |
| * suspend buffer for queue group. |
| * @reg: Memory region allocated for the protected-mode suspend buffer. |
| * @pma: Array of pointer to protected mode allocations containing |
| * information about memory pages allocated for protected mode |
| * suspend buffer. |
| */ |
| struct kbase_protected_suspend_buffer { |
| struct kbase_va_region *reg; |
| struct protected_memory_allocation **pma; |
| }; |
| |
| /** |
| * struct kbase_queue_group - Object representing a GPU command queue group. |
| * |
| * @kctx: Pointer to the kbase context with which this queue group |
| * is associated. |
| * @normal_suspend_buf: Object representing the normal suspend buffer. |
| * Normal-mode suspend buffer that is used for |
| * group context switch. |
| * @protected_suspend_buf: Object representing the protected suspend |
| * buffer. Protected-mode suspend buffer that is |
| * used for group context switch. |
| * @handle: Handle which identifies this queue group. |
| * @csg_nr: Number/index of the CSG to which this queue group is |
| * mapped; KBASEP_CSG_NR_INVALID indicates that the queue |
| * group is not scheduled. |
| * @priority: Priority of the queue group, 0 being the highest, |
| * BASE_QUEUE_GROUP_PRIORITY_COUNT - 1 being the lowest. |
| * @tiler_max: Maximum number of tiler endpoints the group is allowed |
| * to use. |
| * @fragment_max: Maximum number of fragment endpoints the group is |
| * allowed to use. |
| * @compute_max: Maximum number of compute endpoints the group is |
| * allowed to use. |
| * @tiler_mask: Mask of tiler endpoints the group is allowed to use. |
| * @fragment_mask: Mask of fragment endpoints the group is allowed to use. |
| * @compute_mask: Mask of compute endpoints the group is allowed to use. |
| * @group_uid: 32-bit wide unsigned identifier for the group, unique |
| * across all kbase devices and contexts. |
| * @link: Link to this queue group in the 'runnable_groups' list of |
| * the corresponding kctx. |
| * @link_to_schedule: Link to this queue group in the list of prepared groups |
| * to be scheduled, if the group is runnable/suspended. |
| * If the group is idle or waiting for CQS, it would be a |
| * link to the list of idle/blocked groups list. |
| * @run_state: Current state of the queue group. |
| * @prepared_seq_num: Indicates the position of queue group in the list of |
| * prepared groups to be scheduled. |
| * @scan_seq_num: Scan out sequence number before adjusting for dynamic |
| * idle conditions. It is used for setting a group's |
| * onslot priority. It could differ from prepared_seq_number |
| * when there are idle groups. |
| * @faulted: Indicates that a GPU fault occurred for the queue group. |
| * This flag persists until the fault has been queued to be |
| * reported to userspace. |
| * @bound_queues: Array of registered queues bound to this queue group. |
| * @doorbell_nr: Index of the hardware doorbell page assigned to the |
| * group. |
| * @protm_event_work: Work item corresponding to the protected mode entry |
| * event for this queue. |
| * @protm_pending_bitmap: Bit array to keep a track of CSs that |
| * have pending protected mode entry requests. |
| * @error_fatal: An error of type BASE_GPU_QUEUE_GROUP_ERROR_FATAL to be |
| * returned to userspace if such an error has occurred. |
| * @error_timeout: An error of type BASE_GPU_QUEUE_GROUP_ERROR_TIMEOUT |
| * to be returned to userspace if such an error has occurred. |
| * @error_tiler_oom: An error of type BASE_GPU_QUEUE_GROUP_ERROR_TILER_HEAP_OOM |
| * to be returned to userspace if such an error has occurred. |
| * @timer_event_work: Work item to handle the progress timeout fatal event |
| * for the group. |
| */ |
| struct kbase_queue_group { |
| struct kbase_context *kctx; |
| struct kbase_normal_suspend_buffer normal_suspend_buf; |
| struct kbase_protected_suspend_buffer protected_suspend_buf; |
| u8 handle; |
| s8 csg_nr; |
| u8 priority; |
| |
| u8 tiler_max; |
| u8 fragment_max; |
| u8 compute_max; |
| |
| u64 tiler_mask; |
| u64 fragment_mask; |
| u64 compute_mask; |
| |
| u32 group_uid; |
| |
| struct list_head link; |
| struct list_head link_to_schedule; |
| enum kbase_csf_group_state run_state; |
| u32 prepared_seq_num; |
| u32 scan_seq_num; |
| bool faulted; |
| |
| struct kbase_queue *bound_queues[MAX_SUPPORTED_STREAMS_PER_GROUP]; |
| |
| int doorbell_nr; |
| struct work_struct protm_event_work; |
| DECLARE_BITMAP(protm_pending_bitmap, MAX_SUPPORTED_STREAMS_PER_GROUP); |
| |
| struct kbase_csf_notification error_fatal; |
| struct kbase_csf_notification error_timeout; |
| struct kbase_csf_notification error_tiler_oom; |
| |
| struct work_struct timer_event_work; |
| }; |
| |
| /** |
| * struct kbase_csf_kcpu_queue_context - Object representing the kernel CPU |
| * queues for a GPU address space. |
| * |
| * @lock: Lock preventing concurrent access to @array and the @in_use bitmap. |
| * @array: Array of pointers to kernel CPU command queues. |
| * @in_use: Bitmap which indicates which kernel CPU command queues are in use. |
| * @wq: Dedicated workqueue for processing kernel CPU command queues. |
| * @num_cmds: The number of commands that have been enqueued across |
| * all the KCPU command queues. This could be used as a |
| * timestamp to determine the command's enqueueing time. |
| * @jit_cmds_head: A list of the just-in-time memory commands, both |
| * allocate & free, in submission order, protected |
| * by kbase_csf_kcpu_queue_context.lock. |
| * @jit_blocked_queues: A list of KCPU command queues blocked by a pending |
| * just-in-time memory allocation command which will be |
| * reattempted after the impending free of other active |
| * allocations. |
| */ |
| struct kbase_csf_kcpu_queue_context { |
| struct mutex lock; |
| struct kbase_kcpu_command_queue *array[KBASEP_MAX_KCPU_QUEUES]; |
| DECLARE_BITMAP(in_use, KBASEP_MAX_KCPU_QUEUES); |
| struct workqueue_struct *wq; |
| u64 num_cmds; |
| |
| struct list_head jit_cmds_head; |
| struct list_head jit_blocked_queues; |
| }; |
| |
| /** |
| * struct kbase_csf_cpu_queue_context - Object representing the cpu queue |
| * information. |
| * |
| * @buffer: Buffer containing CPU queue information provided by Userspace. |
| * @buffer_size: The size of @buffer. |
| * @dump_req_status: Indicates the current status for CPU queues dump request. |
| * @dump_cmp: Dumping cpu queue completion event. |
| */ |
| struct kbase_csf_cpu_queue_context { |
| char *buffer; |
| size_t buffer_size; |
| atomic_t dump_req_status; |
| struct completion dump_cmp; |
| }; |
| |
| /** |
| * struct kbase_csf_heap_context_allocator - Allocator of heap contexts |
| * |
| * Heap context structures are allocated by the kernel for use by the firmware. |
| * The current implementation subdivides a single GPU memory region for use as |
| * a sparse array. |
| * |
| * @kctx: Pointer to the kbase context with which this allocator is |
| * associated. |
| * @region: Pointer to a GPU memory region from which heap context structures |
| * are allocated. NULL if no heap contexts have been allocated. |
| * @gpu_va: GPU virtual address of the start of the region from which heap |
| * context structures are allocated. 0 if no heap contexts have been |
| * allocated. |
| * @lock: Lock preventing concurrent access to the @in_use bitmap. |
| * @in_use: Bitmap that indicates which heap context structures are currently |
| * allocated (in @region). |
| */ |
| struct kbase_csf_heap_context_allocator { |
| struct kbase_context *kctx; |
| struct kbase_va_region *region; |
| u64 gpu_va; |
| struct mutex lock; |
| DECLARE_BITMAP(in_use, MAX_TILER_HEAPS); |
| }; |
| |
| /** |
| * struct kbase_csf_tiler_heap_context - Object representing the tiler heaps |
| * context for a GPU address space. |
| * |
| * This contains all of the CSF state relating to chunked tiler heaps for one |
| * @kbase_context. It is not the same as a heap context structure allocated by |
| * the kernel for use by the firmware. |
| * |
| * @lock: Lock preventing concurrent access to the tiler heaps. |
| * @list: List of tiler heaps. |
| * @ctx_alloc: Allocator for heap context structures. |
| * @nr_of_heaps: Total number of tiler heaps that were added during the |
| * life time of the context. |
| */ |
| struct kbase_csf_tiler_heap_context { |
| struct mutex lock; |
| struct list_head list; |
| struct kbase_csf_heap_context_allocator ctx_alloc; |
| u64 nr_of_heaps; |
| }; |
| |
| /** |
| * struct kbase_csf_scheduler_context - Object representing the scheduler's |
| * context for a GPU address space. |
| * |
| * @runnable_groups: Lists of runnable GPU command queue groups in the kctx, |
| * one per queue group relative-priority level. |
| * @num_runnable_grps: Total number of runnable groups across all priority |
| * levels in @runnable_groups. |
| * @idle_wait_groups: A list of GPU command queue groups in which all enabled |
| * GPU command queues are idle and at least one of them |
| * is blocked on a sync wait operation. |
| * @num_idle_wait_grps: Length of the @idle_wait_groups list. |
| * @sync_update_wq: Dedicated workqueue to process work items corresponding |
| * to the sync_update events by sync_set/sync_add |
| * instruction execution on CSs bound to groups |
| * of @idle_wait_groups list. |
| * @sync_update_work: work item to process the sync_update events by |
| * sync_set / sync_add instruction execution on command |
| * streams bound to groups of @idle_wait_groups list. |
| * @ngrp_to_schedule: Number of groups added for the context to the |
| * 'groups_to_schedule' list of scheduler instance. |
| */ |
| struct kbase_csf_scheduler_context { |
| struct list_head runnable_groups[KBASE_QUEUE_GROUP_PRIORITY_COUNT]; |
| u32 num_runnable_grps; |
| struct list_head idle_wait_groups; |
| u32 num_idle_wait_grps; |
| struct workqueue_struct *sync_update_wq; |
| struct work_struct sync_update_work; |
| u32 ngrp_to_schedule; |
| }; |
| |
| /** |
| * struct kbase_csf_context - Object representing CSF for a GPU address space. |
| * |
| * @event_pages_head: A list of pages allocated for the event memory used by |
| * the synchronization objects. A separate list would help |
| * in the fast lookup, since the list is expected to be short |
| * as one page would provide the memory for up to 1K |
| * synchronization objects. |
| * KBASE_PERMANENTLY_MAPPED_MEM_LIMIT_PAGES is the upper |
| * bound on the size of event memory. |
| * @cookies: Bitmask containing of KBASE_CSF_NUM_USER_IO_PAGES_HANDLE |
| * bits, used for creating the User mode CPU mapping in a |
| * deferred manner of a pair of User mode input/output pages |
| * & a hardware doorbell page. |
| * The pages are allocated when a GPU command queue is |
| * bound to a CSG in kbase_csf_queue_bind. |
| * This helps returning unique handles to Userspace from |
| * kbase_csf_queue_bind and later retrieving the pointer to |
| * queue in the mmap handler. |
| * @user_pages_info: Array containing pointers to queue |
| * structures, used in conjunction with cookies bitmask for |
| * providing a mechansim to create a CPU mapping of |
| * input/output pages & hardware doorbell page. |
| * @lock: Serializes accesses to all members, except for ones that |
| * have their own locks. |
| * @queue_groups: Array of registered GPU command queue groups. |
| * @queue_list: Linked list of GPU command queues not yet deregistered. |
| * Note that queues can persist after deregistration if the |
| * userspace mapping created for them on bind operation |
| * hasn't been removed. |
| * @kcpu_queues: Kernel CPU command queues. |
| * @event_lock: Lock protecting access to @event_callback_list and |
| * @error_list. |
| * @event_callback_list: List of callbacks which are registered to serve CSF |
| * events. |
| * @tiler_heaps: Chunked tiler memory heaps. |
| * @wq: Dedicated workqueue to process work items corresponding |
| * to the OoM events raised for chunked tiler heaps being |
| * used by GPU command queues, and progress timeout events. |
| * @link: Link to this csf context in the 'runnable_kctxs' list of |
| * the scheduler instance |
| * @user_reg_vma: Pointer to the vma corresponding to the virtual mapping |
| * of the USER register page. Currently used only for sanity |
| * checking. |
| * @sched: Object representing the scheduler's context |
| * @error_list: List for CS fatal errors in this context. |
| * Link of fatal error is |
| * &struct_kbase_csf_notification.link. |
| * @event_lock needs to be held to access this list. |
| * @cpu_queue: CPU queue information. Only be available when DEBUG_FS |
| * is enabled. |
| */ |
| struct kbase_csf_context { |
| struct list_head event_pages_head; |
| DECLARE_BITMAP(cookies, KBASE_CSF_NUM_USER_IO_PAGES_HANDLE); |
| struct kbase_queue *user_pages_info[ |
| KBASE_CSF_NUM_USER_IO_PAGES_HANDLE]; |
| struct mutex lock; |
| struct kbase_queue_group *queue_groups[MAX_QUEUE_GROUP_NUM]; |
| struct list_head queue_list; |
| struct kbase_csf_kcpu_queue_context kcpu_queues; |
| spinlock_t event_lock; |
| struct list_head event_callback_list; |
| struct kbase_csf_tiler_heap_context tiler_heaps; |
| struct workqueue_struct *wq; |
| struct list_head link; |
| struct vm_area_struct *user_reg_vma; |
| struct kbase_csf_scheduler_context sched; |
| struct list_head error_list; |
| #if IS_ENABLED(CONFIG_DEBUG_FS) |
| struct kbase_csf_cpu_queue_context cpu_queue; |
| #endif |
| }; |
| |
| /** |
| * struct kbase_csf_reset_gpu - Object containing the members required for |
| * GPU reset handling. |
| * @workq: Workqueue to execute the GPU reset work item @work. |
| * @work: Work item for performing the GPU reset. |
| * @wait: Wait queue used to wait for the GPU reset completion. |
| * @sem: RW Semaphore to ensure no other thread attempts to use the |
| * GPU whilst a reset is in process. Unlike traditional |
| * semaphores and wait queues, this allows Linux's lockdep |
| * mechanism to check for deadlocks involving reset waits. |
| * @state: Tracks if the GPU reset is in progress or not. |
| * The state is represented by enum @kbase_csf_reset_gpu_state. |
| */ |
| struct kbase_csf_reset_gpu { |
| struct workqueue_struct *workq; |
| struct work_struct work; |
| wait_queue_head_t wait; |
| struct rw_semaphore sem; |
| atomic_t state; |
| }; |
| |
| /** |
| * struct kbase_csf_csg_slot - Object containing members for tracking the state |
| * of CSG slots. |
| * @resident_group: pointer to the queue group that is resident on the CSG slot. |
| * @state: state of the slot as per enum @kbase_csf_csg_slot_state. |
| * @trigger_jiffies: value of jiffies when change in slot state is recorded. |
| * @priority: dynamic priority assigned to CSG slot. |
| */ |
| struct kbase_csf_csg_slot { |
| struct kbase_queue_group *resident_group; |
| atomic_t state; |
| unsigned long trigger_jiffies; |
| u8 priority; |
| }; |
| |
| /** |
| * struct kbase_csf_scheduler - Object representing the scheduler used for |
| * CSF for an instance of GPU platform device. |
| * @lock: Lock to serialize the scheduler operations and |
| * access to the data members. |
| * @interrupt_lock: Lock to protect members accessed by interrupt |
| * handler. |
| * @state: The operational phase the scheduler is in. Primarily |
| * used for indicating what in-cycle schedule actions |
| * are allowed. |
| * @doorbell_inuse_bitmap: Bitmap of hardware doorbell pages keeping track of |
| * which pages are currently available for assignment |
| * to clients. |
| * @csg_inuse_bitmap: Bitmap to keep a track of CSG slots |
| * that are currently in use. |
| * @csg_slots: The array for tracking the state of CS |
| * group slots. |
| * @runnable_kctxs: List of Kbase contexts that have runnable command |
| * queue groups. |
| * @groups_to_schedule: List of runnable queue groups prepared on every |
| * scheduler tick. The dynamic priority of the CSG |
| * slot assigned to a group will depend upon the |
| * position of group in the list. |
| * @ngrp_to_schedule: Number of groups in the @groups_to_schedule list, |
| * incremented when a group is added to the list, used |
| * to record the position of group in the list. |
| * @num_active_address_spaces: Number of GPU address space slots that would get |
| * used to program the groups in @groups_to_schedule |
| * list on all the available CSG |
| * slots. |
| * @num_csg_slots_for_tick: Number of CSG slots that can be |
| * active in the given tick/tock. This depends on the |
| * value of @num_active_address_spaces. |
| * @remaining_tick_slots: Tracking the number of remaining available slots |
| * for @num_csg_slots_for_tick during the scheduling |
| * operation in a tick/tock. |
| * @idle_groups_to_schedule: List of runnable queue groups, in which all GPU |
| * command queues became idle or are waiting for |
| * synchronization object, prepared on every |
| * scheduler tick. The groups in this list are |
| * appended to the tail of @groups_to_schedule list |
| * after the scan out so that the idle groups aren't |
| * preferred for scheduling over the non-idle ones. |
| * @csg_scan_count_for_tick: CSG scanout count for assign the scan_seq_num for |
| * each scanned out group during scheduling operation |
| * in a tick/tock. |
| * @total_runnable_grps: Total number of runnable groups across all KCTXs. |
| * @csgs_events_enable_mask: Use for temporary masking off asynchronous events |
| * from firmware (such as OoM events) before a group |
| * is suspended. |
| * @csg_slots_idle_mask: Bit array for storing the mask of CS |
| * group slots for which idle notification was |
| * received. |
| * @csg_slots_prio_update: Bit array for tracking slots that have an on-slot |
| * priority update operation. |
| * @last_schedule: Time in jiffies recorded when the last "tick" or |
| * "tock" schedule operation concluded. Used for |
| * evaluating the exclusion window for in-cycle |
| * schedule operation. |
| * @timer_enabled: Whether the CSF scheduler wakes itself up for |
| * periodic scheduling tasks. If this value is 0 |
| * then it will only perform scheduling under the |
| * influence of external factors e.g., IRQs, IOCTLs. |
| * @wq: Dedicated workqueue to execute the @tick_work. |
| * @tick_timer: High-resolution timer employed to schedule tick |
| * workqueue items (kernel-provided delayed_work |
| * items do not use hrtimer and for some reason do |
| * not provide sufficiently reliable periodicity). |
| * @tick_work: Work item that performs the "schedule on tick" |
| * operation to implement timeslice-based scheduling. |
| * @tock_work: Work item that would perform the schedule on tock |
| * operation to implement the asynchronous scheduling. |
| * @ping_work: Work item that would ping the firmware at regular |
| * intervals, only if there is a single active CSG |
| * slot, to check if firmware is alive and would |
| * initiate a reset if the ping request isn't |
| * acknowledged. |
| * @top_ctx: Pointer to the Kbase context corresponding to the |
| * @top_grp. |
| * @top_grp: Pointer to queue group inside @groups_to_schedule |
| * list that was assigned the highest slot priority. |
| * @tock_pending_request: A "tock" request is pending: a group that is not |
| * currently on the GPU demands to be scheduled. |
| * @active_protm_grp: Indicates if firmware has been permitted to let GPU |
| * enter protected mode with the given group. On exit |
| * from protected mode the pointer is reset to NULL. |
| * @gpu_idle_fw_timer_enabled: Whether the CSF scheduler has activiated the |
| * firmware idle hysteresis timer for preparing a |
| * GPU suspend on idle. |
| * @gpu_idle_work: Work item for facilitating the scheduler to bring |
| * the GPU to a low-power mode on becoming idle. |
| * @non_idle_offslot_grps: Count of off-slot non-idle groups. Reset during |
| * the scheduler active phase in a tick. It then |
| * tracks the count of non-idle groups across all the |
| * other phases. |
| * @non_idle_scanout_grps: Count on the non-idle groups in the scan-out |
| * list at the scheduling prepare stage. |
| * @pm_active_count: Count indicating if the scheduler is owning a power |
| * management reference count. Reference is taken when |
| * the count becomes 1 and is dropped when the count |
| * becomes 0. It is used to enable the power up of MCU |
| * after GPU and L2 cache have been powered up. So when |
| * this count is zero, MCU will not be powered up. |
| * @csg_scheduling_period_ms: Duration of Scheduling tick in milliseconds. |
| * @tick_timer_active: Indicates whether the @tick_timer is effectively |
| * active or not, as the callback function of |
| * @tick_timer will enqueue @tick_work only if this |
| * flag is true. This is mainly useful for the case |
| * when scheduling tick needs to be advanced from |
| * interrupt context, without actually deactivating |
| * the @tick_timer first and then enqueing @tick_work. |
| */ |
| struct kbase_csf_scheduler { |
| struct mutex lock; |
| spinlock_t interrupt_lock; |
| enum kbase_csf_scheduler_state state; |
| DECLARE_BITMAP(doorbell_inuse_bitmap, CSF_NUM_DOORBELL); |
| DECLARE_BITMAP(csg_inuse_bitmap, MAX_SUPPORTED_CSGS); |
| struct kbase_csf_csg_slot *csg_slots; |
| struct list_head runnable_kctxs; |
| struct list_head groups_to_schedule; |
| u32 ngrp_to_schedule; |
| u32 num_active_address_spaces; |
| u32 num_csg_slots_for_tick; |
| u32 remaining_tick_slots; |
| struct list_head idle_groups_to_schedule; |
| u32 csg_scan_count_for_tick; |
| u32 total_runnable_grps; |
| DECLARE_BITMAP(csgs_events_enable_mask, MAX_SUPPORTED_CSGS); |
| DECLARE_BITMAP(csg_slots_idle_mask, MAX_SUPPORTED_CSGS); |
| DECLARE_BITMAP(csg_slots_prio_update, MAX_SUPPORTED_CSGS); |
| unsigned long last_schedule; |
| bool timer_enabled; |
| struct workqueue_struct *wq; |
| struct hrtimer tick_timer; |
| struct work_struct tick_work; |
| struct delayed_work tock_work; |
| struct delayed_work ping_work; |
| struct kbase_context *top_ctx; |
| struct kbase_queue_group *top_grp; |
| bool tock_pending_request; |
| struct kbase_queue_group *active_protm_grp; |
| bool gpu_idle_fw_timer_enabled; |
| struct work_struct gpu_idle_work; |
| atomic_t non_idle_offslot_grps; |
| u32 non_idle_scanout_grps; |
| u32 pm_active_count; |
| unsigned int csg_scheduling_period_ms; |
| bool tick_timer_active; |
| }; |
| |
| /** |
| * Number of GPU cycles per unit of the global progress timeout. |
| */ |
| #define GLB_PROGRESS_TIMER_TIMEOUT_SCALE ((u64)1024) |
| |
| /** |
| * Maximum value of the global progress timeout. |
| */ |
| #define GLB_PROGRESS_TIMER_TIMEOUT_MAX \ |
| ((GLB_PROGRESS_TIMER_TIMEOUT_MASK >> \ |
| GLB_PROGRESS_TIMER_TIMEOUT_SHIFT) * \ |
| GLB_PROGRESS_TIMER_TIMEOUT_SCALE) |
| |
| /** |
| * Default GLB_PWROFF_TIMER_TIMEOUT value in unit of micro-seconds. |
| */ |
| #define DEFAULT_GLB_PWROFF_TIMEOUT_US (800) |
| |
| /** |
| * In typical operations, the management of the shader core power transitions |
| * is delegated to the MCU/firmware. However, if the host driver is configured |
| * to take direct control, one needs to disable the MCU firmware GLB_PWROFF |
| * timer. |
| */ |
| #define DISABLE_GLB_PWROFF_TIMER (0) |
| |
| /* Index of the GPU_ACTIVE counter within the CSHW counter block */ |
| #define GPU_ACTIVE_CNT_IDX (4) |
| |
| /** |
| * Maximum number of sessions that can be managed by the IPA Control component. |
| */ |
| #if MALI_UNIT_TEST |
| #define KBASE_IPA_CONTROL_MAX_SESSIONS ((size_t)8) |
| #else |
| #define KBASE_IPA_CONTROL_MAX_SESSIONS ((size_t)2) |
| #endif |
| |
| /** |
| * enum kbase_ipa_core_type - Type of counter block for performance counters |
| * |
| * @KBASE_IPA_CORE_TYPE_CSHW: CS Hardware counters. |
| * @KBASE_IPA_CORE_TYPE_MEMSYS: Memory System counters. |
| * @KBASE_IPA_CORE_TYPE_TILER: Tiler counters. |
| * @KBASE_IPA_CORE_TYPE_SHADER: Shader Core counters. |
| * @KBASE_IPA_CORE_TYPE_NUM: Number of core types. |
| */ |
| enum kbase_ipa_core_type { |
| KBASE_IPA_CORE_TYPE_CSHW = 0, |
| KBASE_IPA_CORE_TYPE_MEMSYS, |
| KBASE_IPA_CORE_TYPE_TILER, |
| KBASE_IPA_CORE_TYPE_SHADER, |
| KBASE_IPA_CORE_TYPE_NUM |
| }; |
| |
| /** |
| * Number of configurable counters per type of block on the IPA Control |
| * interface. |
| */ |
| #define KBASE_IPA_CONTROL_NUM_BLOCK_COUNTERS ((size_t)8) |
| |
| /** |
| * Total number of configurable counters existing on the IPA Control interface. |
| */ |
| #define KBASE_IPA_CONTROL_MAX_COUNTERS \ |
| ((size_t)KBASE_IPA_CORE_TYPE_NUM * KBASE_IPA_CONTROL_NUM_BLOCK_COUNTERS) |
| |
| /** |
| * struct kbase_ipa_control_prfcnt - Session for a single performance counter |
| * |
| * @latest_raw_value: Latest raw value read from the counter. |
| * @scaling_factor: Factor raw value shall be multiplied by. |
| * @accumulated_diff: Partial sum of scaled and normalized values from |
| * previous samples. This represent all the values |
| * that were read before the latest raw value. |
| * @type: Type of counter block for performance counter. |
| * @select_idx: Index of the performance counter as configured on |
| * the IPA Control interface. |
| * @gpu_norm: Indicating whether values shall be normalized by |
| * GPU frequency. If true, returned values represent |
| * an interval of time expressed in seconds (when the |
| * scaling factor is set to 1). |
| */ |
| struct kbase_ipa_control_prfcnt { |
| u64 latest_raw_value; |
| u64 scaling_factor; |
| u64 accumulated_diff; |
| enum kbase_ipa_core_type type; |
| u8 select_idx; |
| bool gpu_norm; |
| }; |
| |
| /** |
| * struct kbase_ipa_control_session - Session for an IPA Control client |
| * |
| * @prfcnts: Sessions for individual performance counters. |
| * @num_prfcnts: Number of performance counters. |
| * @active: Indicates whether this slot is in use or not |
| * @last_query_time: Time of last query, in ns |
| * @protm_time: Amount of time (in ns) that GPU has been in protected |
| */ |
| struct kbase_ipa_control_session { |
| struct kbase_ipa_control_prfcnt prfcnts[KBASE_IPA_CONTROL_MAX_COUNTERS]; |
| size_t num_prfcnts; |
| bool active; |
| u64 last_query_time; |
| u64 protm_time; |
| }; |
| |
| /** |
| * struct kbase_ipa_control_prfcnt_config - Performance counter configuration |
| * |
| * @idx: Index of the performance counter inside the block, as specified |
| * in the GPU architecture. |
| * @refcount: Number of client sessions bound to this counter. |
| * |
| * This structure represents one configurable performance counter of |
| * the IPA Control interface. The entry may be mapped to a specific counter |
| * by one or more client sessions. The counter is considered to be unused |
| * if it isn't part of any client session. |
| */ |
| struct kbase_ipa_control_prfcnt_config { |
| u8 idx; |
| u8 refcount; |
| }; |
| |
| /** |
| * struct kbase_ipa_control_prfcnt_block - Block of performance counters |
| * |
| * @select: Current performance counter configuration. |
| * @num_available_counters: Number of counters that are not already configured. |
| * |
| */ |
| struct kbase_ipa_control_prfcnt_block { |
| struct kbase_ipa_control_prfcnt_config |
| select[KBASE_IPA_CONTROL_NUM_BLOCK_COUNTERS]; |
| size_t num_available_counters; |
| }; |
| |
| /** |
| * struct kbase_ipa_control - Manager of the IPA Control interface. |
| * |
| * @blocks: Current configuration of performance counters |
| * for the IPA Control interface. |
| * @sessions: State of client sessions, storing information |
| * like performance counters the client subscribed to |
| * and latest value read from each counter. |
| * @lock: Spinlock to serialize access by concurrent clients. |
| * @rtm_listener_data: Private data for allocating a GPU frequency change |
| * listener. |
| * @num_active_sessions: Number of sessions opened by clients. |
| * @cur_gpu_rate: Current GPU top-level operating frequency, in Hz. |
| * @rtm_listener_data: Private data for allocating a GPU frequency change |
| * listener. |
| * @protm_start: Time (in ns) at which the GPU entered protected mode |
| */ |
| struct kbase_ipa_control { |
| struct kbase_ipa_control_prfcnt_block blocks[KBASE_IPA_CORE_TYPE_NUM]; |
| struct kbase_ipa_control_session |
| sessions[KBASE_IPA_CONTROL_MAX_SESSIONS]; |
| spinlock_t lock; |
| void *rtm_listener_data; |
| size_t num_active_sessions; |
| u32 cur_gpu_rate; |
| u64 protm_start; |
| }; |
| |
| /** |
| * struct kbase_csf_firmware_interface - Interface in the MCU firmware |
| * |
| * @node: Interface objects are on the kbase_device:csf.firmware_interfaces |
| * list using this list_head to link them |
| * @phys: Array of the physical (tagged) addresses making up this interface |
| * @name: NULL-terminated string naming the interface |
| * @num_pages: Number of entries in @phys and @pma (and length of the interface) |
| * @virtual: Starting GPU virtual address this interface is mapped at |
| * @flags: bitmask of CSF_FIRMWARE_ENTRY_* conveying the interface attributes |
| * @data_start: Offset into firmware image at which the interface data starts |
| * @data_end: Offset into firmware image at which the interface data ends |
| * @kernel_map: A kernel mapping of the memory or NULL if not required to be |
| * mapped in the kernel |
| * @pma: Array of pointers to protected memory allocations. |
| */ |
| struct kbase_csf_firmware_interface { |
| struct list_head node; |
| struct tagged_addr *phys; |
| char *name; |
| u32 num_pages; |
| u32 virtual; |
| u32 flags; |
| u32 data_start; |
| u32 data_end; |
| void *kernel_map; |
| struct protected_memory_allocation **pma; |
| }; |
| |
| /* |
| * struct kbase_csf_hwcnt - Object containing members for handling the dump of |
| * HW counters. |
| * |
| * @request_pending: Flag set when HWC requested and used for HWC sample |
| * done interrupt. |
| * @enable_pending: Flag set when HWC enable status change and used for |
| * enable done interrupt. |
| */ |
| struct kbase_csf_hwcnt { |
| bool request_pending; |
| bool enable_pending; |
| }; |
| |
| /** |
| * struct kbase_csf_device - Object representing CSF for an instance of GPU |
| * platform device. |
| * |
| * @mcu_mmu: MMU page tables for the MCU firmware |
| * @firmware_interfaces: List of interfaces defined in the firmware image |
| * @firmware_config: List of configuration options within the firmware |
| * image |
| * @firmware_timeline_metadata: List of timeline meta-data within the firmware |
| * image |
| * @fw_cfg_kobj: Pointer to the kobject corresponding to the sysf |
| * directory that contains a sub-directory for each |
| * of the configuration option present in the |
| * firmware image. |
| * @firmware_trace_buffers: List of trace buffers described in the firmware |
| * image. |
| * @shared_interface: Pointer to the interface object containing info for |
| * the memory area shared between firmware & host. |
| * @shared_reg_rbtree: RB tree of the memory regions allocated from the |
| * shared interface segment in MCU firmware address |
| * space. |
| * @db_filp: Pointer to a dummy file, that alongwith |
| * @db_file_offsets, facilitates the use of unqiue |
| * file offset for the userspace mapping created |
| * for Hw Doorbell pages. The userspace mapping |
| * is made to point to this file inside the mmap |
| * handler. |
| * @db_file_offsets: Counter that is incremented every time a GPU |
| * command queue is bound to provide a unique file |
| * offset range for @db_filp file, so that pte of |
| * Doorbell page can be zapped through the kernel |
| * function unmap_mapping_range(). It is incremented |
| * in page units. |
| * @dummy_db_page: Address of the dummy page that is mapped in place |
| * of the real Hw doorbell page for the active GPU |
| * command queues after they are stopped or after the |
| * GPU is powered down. |
| * @dummy_user_reg_page: Address of the dummy page that is mapped in place |
| * of the real User register page just before the GPU |
| * is powered down. The User register page is mapped |
| * in the address space of every process, that created |
| * a Base context, to enable the access to LATEST_FLUSH |
| * register from userspace. |
| * @mali_file_inode: Pointer to the inode corresponding to mali device |
| * file. This is needed in order to switch to the |
| * @dummy_user_reg_page on GPU power down. |
| * All instances of the mali device file will point to |
| * the same inode. |
| * @reg_lock: Lock to serialize the MCU firmware related actions |
| * that affect all contexts such as allocation of |
| * regions from shared interface area, assignment of |
| * of hardware doorbell pages, assignment of CSGs, |
| * sending global requests. |
| * @event_wait: Wait queue to wait for receiving csf events, i.e. |
| * the interrupt from CSF firmware, or scheduler state |
| * changes. |
| * @interrupt_received: Flag set when the interrupt is received from CSF fw |
| * @global_iface: The result of parsing the global interface |
| * structure set up by the firmware, including the |
| * CSGs, CSs, and their properties |
| * @scheduler: The CS scheduler instance. |
| * @reset: Contain members required for GPU reset handling. |
| * @progress_timeout: Maximum number of GPU clock cycles without forward |
| * progress to allow, for all tasks running on |
| * hardware endpoints (e.g. shader cores), before |
| * terminating a GPU command queue group. |
| * Must not exceed @GLB_PROGRESS_TIMER_TIMEOUT_MAX. |
| * @pma_dev: Pointer to protected memory allocator device. |
| * @firmware_inited: Flag for indicating that the cold-boot stage of |
| * the MCU has completed. |
| * @firmware_reloaded: Flag for indicating a firmware reload operation |
| * in GPU reset has completed. |
| * @firmware_reload_needed: Flag for indicating that the firmware needs to be |
| * reloaded as part of the GPU reset action. |
| * @firmware_hctl_core_pwr: Flag for indicating that the host diver is in |
| * charge of the shader core's power transitions, and |
| * the mcu_core_pwroff timeout feature is disabled |
| * (i.e. configured 0 in the register field). If |
| * false, the control is delegated to the MCU. |
| * @firmware_reload_work: Work item for facilitating the procedural actions |
| * on reloading the firmware. |
| * @glb_init_request_pending: Flag to indicate that Global requests have been |
| * sent to the FW after MCU was re-enabled and their |
| * acknowledgement is pending. |
| * @fw_error_work: Work item for handling the firmware internal error |
| * fatal event. |
| * @ipa_control: IPA Control component manager. |
| * @mcu_core_pwroff_dur_us: Sysfs attribute for the glb_pwroff timeout input |
| * in unit of micro-seconds. The firmware does not use |
| * it directly. |
| * @mcu_core_pwroff_dur_count: The counterpart of the glb_pwroff timeout input |
| * in interface required format, ready to be used |
| * directly in the firmware. |
| * @mcu_core_pwroff_reg_shadow: The actual value that has been programed into |
| * the glb_pwoff register. This is separated from |
| * the @p mcu_core_pwroff_dur_count as an update |
| * to the latter is asynchronous. |
| * @gpu_idle_hysteresis_ms: Sysfs attribute for the idle hysteresis time |
| * window in unit of ms. The firmware does not use it |
| * directly. |
| * @gpu_idle_dur_count: The counterpart of the hysteresis time window in |
| * interface required format, ready to be used |
| * directly in the firmware. |
| * @fw_timeout_ms: Timeout value (in milliseconds) used when waiting |
| * for any request sent to the firmware. |
| * @hwcnt: Contain members required for handling the dump of |
| * HW counters. |
| */ |
| struct kbase_csf_device { |
| struct kbase_mmu_table mcu_mmu; |
| struct list_head firmware_interfaces; |
| struct list_head firmware_config; |
| struct list_head firmware_timeline_metadata; |
| struct kobject *fw_cfg_kobj; |
| struct kbase_csf_trace_buffers firmware_trace_buffers; |
| void *shared_interface; |
| struct rb_root shared_reg_rbtree; |
| struct file *db_filp; |
| u32 db_file_offsets; |
| struct tagged_addr dummy_db_page; |
| struct tagged_addr dummy_user_reg_page; |
| struct inode *mali_file_inode; |
| struct mutex reg_lock; |
| wait_queue_head_t event_wait; |
| bool interrupt_received; |
| struct kbase_csf_global_iface global_iface; |
| struct kbase_csf_scheduler scheduler; |
| struct kbase_csf_reset_gpu reset; |
| atomic64_t progress_timeout; |
| struct protected_memory_allocator_device *pma_dev; |
| bool firmware_inited; |
| bool firmware_reloaded; |
| bool firmware_reload_needed; |
| bool firmware_hctl_core_pwr; |
| struct work_struct firmware_reload_work; |
| bool glb_init_request_pending; |
| struct work_struct fw_error_work; |
| struct kbase_ipa_control ipa_control; |
| u32 mcu_core_pwroff_dur_us; |
| u32 mcu_core_pwroff_dur_count; |
| u32 mcu_core_pwroff_reg_shadow; |
| u32 gpu_idle_hysteresis_ms; |
| u32 gpu_idle_dur_count; |
| unsigned int fw_timeout_ms; |
| struct kbase_csf_hwcnt hwcnt; |
| }; |
| |
| /** |
| * struct kbase_as - Object representing an address space of GPU. |
| * @number: Index at which this address space structure is present |
| * in an array of address space structures embedded inside |
| * the &struct kbase_device. |
| * @pf_wq: Workqueue for processing work items related to |
| * Page fault, Bus fault and GPU fault handling. |
| * @work_pagefault: Work item for the Page fault handling. |
| * @work_busfault: Work item for the Bus fault handling. |
| * @work_gpufault: Work item for the GPU fault handling. |
| * @pf_data: Data relating to Page fault. |
| * @bf_data: Data relating to Bus fault. |
| * @gf_data: Data relating to GPU fault. |
| * @current_setup: Stores the MMU configuration for this address space. |
| */ |
| struct kbase_as { |
| int number; |
| struct workqueue_struct *pf_wq; |
| struct work_struct work_pagefault; |
| struct work_struct work_busfault; |
| struct work_struct work_gpufault; |
| struct kbase_fault pf_data; |
| struct kbase_fault bf_data; |
| struct kbase_fault gf_data; |
| struct kbase_mmu_setup current_setup; |
| }; |
| |
| #endif /* _KBASE_CSF_DEFS_H_ */ |
