/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * * (C) COPYRIGHT 2014-2023 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. * */ /* * HW access job manager common APIs */ #ifndef _KBASE_HWACCESS_JM_H_ #define _KBASE_HWACCESS_JM_H_ /** * kbase_backend_run_atom() - Run an atom on the GPU * @kbdev: Device pointer * @katom: Atom to run * * Caller must hold the HW access lock */ void kbase_backend_run_atom(struct kbase_device *kbdev, struct kbase_jd_atom *katom); /** * kbase_backend_slot_update - Update state based on slot ringbuffers * * @kbdev: Device pointer * * Inspect the jobs in the slot ringbuffers and update state. * * This will cause jobs to be submitted to hardware if they are unblocked */ void kbase_backend_slot_update(struct kbase_device *kbdev); /** * kbase_backend_find_and_release_free_address_space() - Release a free AS * @kbdev: Device pointer * @kctx: Context pointer * * This function can evict an idle context from the runpool, freeing up the * address space it was using. * * The address space is marked as in use. The caller must either assign a * context using kbase_gpu_use_ctx(), or release it using * kbase_ctx_sched_release() * * Return: Number of free address space, or KBASEP_AS_NR_INVALID if none * available */ int kbase_backend_find_and_release_free_address_space(struct kbase_device *kbdev, struct kbase_context *kctx); /** * kbase_backend_use_ctx() - Activate a currently unscheduled context, using the * provided address space. * @kbdev: Device pointer * @kctx: Context pointer. May be NULL * @as_nr: Free address space to use * * kbase_gpu_next_job() will pull atoms from the active context. * * Return: true if successful, false if ASID not assigned. */ bool kbase_backend_use_ctx(struct kbase_device *kbdev, struct kbase_context *kctx, int as_nr); /** * kbase_backend_use_ctx_sched() - Activate a context. * @kbdev: Device pointer * @kctx: Context pointer * @js: Job slot to activate context on * * kbase_gpu_next_job() will pull atoms from the active context. * * The context must already be scheduled and assigned to an address space. If * the context is not scheduled, then kbase_gpu_use_ctx() should be used * instead. * * Caller must hold hwaccess_lock * * Return: true if context is now active, false otherwise (ie if context does * not have an address space assigned) */ bool kbase_backend_use_ctx_sched(struct kbase_device *kbdev, struct kbase_context *kctx, unsigned int js); /** * kbase_backend_release_ctx_irq - Release a context from the GPU. This will * de-assign the assigned address space. * @kbdev: Device pointer * @kctx: Context pointer * * Caller must hold kbase_device->mmu_hw_mutex and hwaccess_lock */ void kbase_backend_release_ctx_irq(struct kbase_device *kbdev, struct kbase_context *kctx); /** * kbase_backend_release_ctx_noirq - Release a context from the GPU. This will * de-assign the assigned address space. * @kbdev: Device pointer * @kctx: Context pointer * * Caller must hold kbase_device->mmu_hw_mutex * * This function must perform any operations that could not be performed in IRQ * context by kbase_backend_release_ctx_irq(). */ void kbase_backend_release_ctx_noirq(struct kbase_device *kbdev, struct kbase_context *kctx); /** * kbase_backend_cache_clean - Perform a cache clean if the given atom requires * one * @kbdev: Device pointer * @katom: Pointer to the failed atom * * On some GPUs, the GPU cache must be cleaned following a failed atom. This * function performs a clean if it is required by @katom. */ void kbase_backend_cache_clean(struct kbase_device *kbdev, struct kbase_jd_atom *katom); /** * kbase_backend_complete_wq() - Perform backend-specific actions required on * completing an atom. * @kbdev: Device pointer * @katom: Pointer to the atom to complete * * This function should only be called from kbase_jd_done_worker() or * js_return_worker(). * * Return: true if atom has completed, false if atom should be re-submitted */ void kbase_backend_complete_wq(struct kbase_device *kbdev, struct kbase_jd_atom *katom); #if !MALI_USE_CSF /** * kbase_backend_complete_wq_post_sched - Perform backend-specific actions * required on completing an atom, after * any scheduling has taken place. * @kbdev: Device pointer * @core_req: Core requirements of atom * * This function should only be called from kbase_jd_done_worker() or * js_return_worker(). */ void kbase_backend_complete_wq_post_sched(struct kbase_device *kbdev, base_jd_core_req core_req); #endif /* !MALI_USE_CSF */ /** * kbase_backend_reset() - The GPU is being reset. Cancel all jobs on the GPU * and remove any others from the ringbuffers. * @kbdev: Device pointer * @end_timestamp: Timestamp of reset */ void kbase_backend_reset(struct kbase_device *kbdev, ktime_t *end_timestamp); /** * kbase_backend_inspect_tail - Return the atom currently at the tail of slot * @js * @kbdev: Device pointer * @js: Job slot to inspect * * Return: Atom currently at the head of slot @js, or NULL */ struct kbase_jd_atom *kbase_backend_inspect_tail(struct kbase_device *kbdev, unsigned int js); /** * kbase_backend_nr_atoms_on_slot() - Return the number of atoms currently on a * slot. * @kbdev: Device pointer * @js: Job slot to inspect * * Return: Number of atoms currently on slot */ int kbase_backend_nr_atoms_on_slot(struct kbase_device *kbdev, unsigned int js); /** * kbase_backend_nr_atoms_submitted() - Return the number of atoms on a slot * that are currently on the GPU. * @kbdev: Device pointer * @js: Job slot to inspect * * Return: Number of atoms currently on slot @js that are currently on the GPU. */ u32 kbase_backend_nr_atoms_submitted(struct kbase_device *kbdev, unsigned int js); /** * kbase_backend_ctx_count_changed() - Number of contexts ready to submit jobs * has changed. * @kbdev: Device pointer * * Perform any required backend-specific actions (eg starting/stopping * scheduling timers). */ void kbase_backend_ctx_count_changed(struct kbase_device *kbdev); /** * kbase_backend_timeouts_changed() - Job Scheduler timeouts have changed. * @kbdev: Device pointer * * Perform any required backend-specific actions (eg updating timeouts of * currently running atoms). */ void kbase_backend_timeouts_changed(struct kbase_device *kbdev); /** * kbase_backend_slot_free() - Return the number of jobs that can be currently * submitted to slot @js. * @kbdev: Device pointer * @js: Job slot to inspect * * Return: Number of jobs that can be submitted. */ int kbase_backend_slot_free(struct kbase_device *kbdev, unsigned int js); /** * kbase_job_check_leave_disjoint - potentially leave disjoint state * @kbdev: kbase device * @target_katom: atom which is finishing * * Work out whether to leave disjoint state when finishing an atom that was * originated by kbase_job_check_enter_disjoint(). */ void kbase_job_check_leave_disjoint(struct kbase_device *kbdev, struct kbase_jd_atom *target_katom); /** * kbase_backend_jm_kill_running_jobs_from_kctx - Kill all jobs that are * currently running on GPU from a context * @kctx: Context pointer * * This is used in response to a page fault to remove all jobs from the faulting * context from the hardware. * * Caller must hold hwaccess_lock. */ void kbase_backend_jm_kill_running_jobs_from_kctx(struct kbase_context *kctx); /** * kbase_jm_wait_for_zero_jobs - Wait for context to have zero jobs running, and * to be descheduled. * @kctx: Context pointer * * This should be called following kbase_js_zap_context(), to ensure the context * can be safely destroyed. */ void kbase_jm_wait_for_zero_jobs(struct kbase_context *kctx); /** * kbase_backend_get_current_flush_id - Return the current flush ID * * @kbdev: Device pointer * * Return: the current flush ID to be recorded for each job chain */ u32 kbase_backend_get_current_flush_id(struct kbase_device *kbdev); /** * kbase_job_slot_hardstop - Hard-stop the specified job slot * @kctx: The kbase context that contains the job(s) that should * be hard-stopped * @js: The job slot to hard-stop * @target_katom: The job that should be hard-stopped (or NULL for all * jobs from the context) * Context: * The job slot lock must be held when calling this function. */ void kbase_job_slot_hardstop(struct kbase_context *kctx, unsigned int js, struct kbase_jd_atom *target_katom); /** * kbase_gpu_atoms_submitted_any() - Inspect whether there are any atoms * currently on the GPU * @kbdev: Device pointer * * Return: true if there are any atoms on the GPU, false otherwise */ bool kbase_gpu_atoms_submitted_any(struct kbase_device *kbdev); /** * kbase_backend_slot_kctx_purge_locked - Perform a purge on the slot_rb tracked * kctx * * @kbdev: Device pointer * @kctx: The kbase context that needs to be purged from slot_rb[] * * For JM GPUs, the L1 read only caches may need a start_flush invalidation, * potentially on all slots (even if the kctx was only using a single slot), * following a context termination or address-space ID recycle. This function * performs a clean-up purge on the given kctx which if it has been tracked by * slot_rb[] objects. * * Caller must hold kbase_device->hwaccess_lock. */ void kbase_backend_slot_kctx_purge_locked(struct kbase_device *kbdev, struct kbase_context *kctx); #endif /* _KBASE_HWACCESS_JM_H_ */