From f70575805708cabdedea7498aaa3f710fde4d920 Mon Sep 17 00:00:00 2001
From: hc <hc@nodka.com>
Date: Wed, 31 Jan 2024 03:29:01 +0000
Subject: [PATCH] add lvds1024*800
---
kernel/drivers/gpu/arm/bifrost/device/mali_kbase_device.c | 141 +++++++++++++++++++++++++++++++++++++---------
1 files changed, 113 insertions(+), 28 deletions(-)
diff --git a/kernel/drivers/gpu/arm/bifrost/device/mali_kbase_device.c b/kernel/drivers/gpu/arm/bifrost/device/mali_kbase_device.c
index 08961d5..b2b0cfd 100644
--- a/kernel/drivers/gpu/arm/bifrost/device/mali_kbase_device.c
+++ b/kernel/drivers/gpu/arm/bifrost/device/mali_kbase_device.c
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
/*
*
- * (C) COPYRIGHT 2010-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2010-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
@@ -35,35 +35,36 @@
#include <mali_kbase.h>
#include <mali_kbase_defs.h>
#include <mali_kbase_hwaccess_instr.h>
+#include <mali_kbase_hwaccess_time.h>
#include <mali_kbase_hw.h>
#include <mali_kbase_config_defaults.h>
#include <linux/priority_control_manager.h>
#include <tl/mali_kbase_timeline.h>
+#include "mali_kbase_kinstr_prfcnt.h"
#include "mali_kbase_vinstr.h"
-#include "mali_kbase_hwcnt_context.h"
-#include "mali_kbase_hwcnt_virtualizer.h"
+#include "hwcnt/mali_kbase_hwcnt_context.h"
+#include "hwcnt/mali_kbase_hwcnt_virtualizer.h"
#include "mali_kbase_device.h"
#include "mali_kbase_device_internal.h"
#include "backend/gpu/mali_kbase_pm_internal.h"
#include "backend/gpu/mali_kbase_irq_internal.h"
#include "mali_kbase_regs_history_debugfs.h"
+#include "mali_kbase_pbha.h"
#ifdef CONFIG_MALI_ARBITER_SUPPORT
#include "arbiter/mali_kbase_arbiter_pm.h"
#endif /* CONFIG_MALI_ARBITER_SUPPORT */
-/* NOTE: Magic - 0x45435254 (TRCE in ASCII).
- * Supports tracing feature provided in the base module.
- * Please keep it in sync with the value of base module.
- */
-#define TRACE_BUFFER_HEADER_SPECIAL 0x45435254
+#if defined(CONFIG_DEBUG_FS) && !IS_ENABLED(CONFIG_MALI_BIFROST_NO_MALI)
/* Number of register accesses for the buffer that we allocate during
* initialization time. The buffer size can be changed later via debugfs.
*/
#define KBASEP_DEFAULT_REGISTER_HISTORY_SIZE ((u16)512)
+
+#endif /* defined(CONFIG_DEBUG_FS) && !IS_ENABLED(CONFIG_MALI_BIFROST_NO_MALI) */
static DEFINE_MUTEX(kbase_dev_list_lock);
static LIST_HEAD(kbase_dev_list);
@@ -161,11 +162,14 @@
/**
* mali_oom_notifier_handler - Mali driver out-of-memory handler
*
- * @nb - notifier block - used to retrieve kbdev pointer
- * @action - action (unused)
- * @data - data pointer (unused)
+ * @nb: notifier block - used to retrieve kbdev pointer
+ * @action: action (unused)
+ * @data: data pointer (unused)
+ *
* This function simply lists memory usage by the Mali driver, per GPU device,
* for diagnostic purposes.
+ *
+ * Return: NOTIFY_OK on success, NOTIFY_BAD otherwise.
*/
static int mali_oom_notifier_handler(struct notifier_block *nb,
unsigned long action, void *data)
@@ -187,19 +191,25 @@
mutex_lock(&kbdev->kctx_list_lock);
- list_for_each_entry (kctx, &kbdev->kctx_list, kctx_list_link) {
+ list_for_each_entry(kctx, &kbdev->kctx_list, kctx_list_link) {
struct pid *pid_struct;
struct task_struct *task;
+ struct pid *tgid_struct;
+ struct task_struct *tgid_task;
+
unsigned long task_alloc_total =
KBASE_PAGES_TO_KIB(atomic_read(&(kctx->used_pages)));
rcu_read_lock();
pid_struct = find_get_pid(kctx->pid);
task = pid_task(pid_struct, PIDTYPE_PID);
+ tgid_struct = find_get_pid(kctx->tgid);
+ tgid_task = pid_task(tgid_struct, PIDTYPE_PID);
dev_err(kbdev->dev,
- "OOM notifier: tsk %s tgid (%u) pid (%u) %lu kB\n",
- task ? task->comm : "[null task]", kctx->tgid,
+ "OOM notifier: tsk %s:%s tgid (%u) pid (%u) %lu kB\n",
+ tgid_task ? tgid_task->comm : "[null task]",
+ task ? task->comm : "[null comm]", kctx->tgid,
kctx->pid, task_alloc_total);
put_pid(pid_struct);
@@ -273,13 +283,20 @@
if (err)
goto dma_set_mask_failed;
+
+ /* There is no limit for Mali, so set to max. */
+ if (kbdev->dev->dma_parms)
+ err = dma_set_max_seg_size(kbdev->dev, UINT_MAX);
+ if (err)
+ goto dma_set_mask_failed;
+
kbdev->nr_hw_address_spaces = kbdev->gpu_props.num_address_spaces;
err = kbase_device_all_as_init(kbdev);
if (err)
goto dma_set_mask_failed;
- err = kbase_ktrace_init(kbdev);
+ err = kbase_pbha_read_dtb(kbdev);
if (err)
goto term_as;
@@ -291,10 +308,15 @@
kbdev->pm.dvfs_period = DEFAULT_PM_DVFS_PERIOD;
- kbdev->reset_timeout_ms = DEFAULT_RESET_TIMEOUT_MS;
+#if MALI_USE_CSF
+ kbdev->reset_timeout_ms = kbase_get_timeout_ms(kbdev, CSF_CSG_SUSPEND_TIMEOUT);
+#else
+ kbdev->reset_timeout_ms = JM_DEFAULT_RESET_TIMEOUT_MS;
+#endif /* MALI_USE_CSF */
kbdev->mmu_mode = kbase_mmu_mode_get_aarch64();
-
+ kbdev->mmu_as_inactive_wait_time_ms =
+ kbase_get_timeout_ms(kbdev, MMU_AS_INACTIVE_WAIT_TIMEOUT);
mutex_init(&kbdev->kctx_list_lock);
INIT_LIST_HEAD(&kbdev->kctx_list);
@@ -307,6 +329,16 @@
"Unable to register OOM notifier for Mali - but will continue\n");
kbdev->oom_notifier_block.notifier_call = NULL;
}
+
+#if !MALI_USE_CSF
+ spin_lock_init(&kbdev->quick_reset_lock);
+ kbdev->quick_reset_enabled = true;
+ kbdev->num_of_atoms_hw_completed = 0;
+#endif
+
+#if MALI_USE_CSF && IS_ENABLED(CONFIG_SYNC_FILE)
+ atomic_set(&kbdev->live_fence_metadata, 0);
+#endif
return 0;
term_as:
@@ -325,14 +357,44 @@
#if KBASE_KTRACE_ENABLE
kbase_debug_assert_register_hook(NULL, NULL);
#endif
-
- kbase_ktrace_term(kbdev);
-
kbase_device_all_as_term(kbdev);
+
if (kbdev->oom_notifier_block.notifier_call)
unregister_oom_notifier(&kbdev->oom_notifier_block);
+
+#if MALI_USE_CSF && IS_ENABLED(CONFIG_SYNC_FILE)
+ if (atomic_read(&kbdev->live_fence_metadata) > 0)
+ dev_warn(kbdev->dev, "Terminating Kbase device with live fence metadata!");
+#endif
}
+
+#if !MALI_USE_CSF
+void kbase_enable_quick_reset(struct kbase_device *kbdev)
+{
+ spin_lock(&kbdev->quick_reset_lock);
+
+ kbdev->quick_reset_enabled = true;
+ kbdev->num_of_atoms_hw_completed = 0;
+
+ spin_unlock(&kbdev->quick_reset_lock);
+}
+
+void kbase_disable_quick_reset(struct kbase_device *kbdev)
+{
+ spin_lock(&kbdev->quick_reset_lock);
+
+ kbdev->quick_reset_enabled = false;
+ kbdev->num_of_atoms_hw_completed = 0;
+
+ spin_unlock(&kbdev->quick_reset_lock);
+}
+
+bool kbase_is_quick_reset_enabled(struct kbase_device *kbdev)
+{
+ return kbdev->quick_reset_enabled;
+}
+#endif
void kbase_device_free(struct kbase_device *kbdev)
{
@@ -395,7 +457,17 @@
kbase_vinstr_term(kbdev->vinstr_ctx);
}
-#if defined(CONFIG_DEBUG_FS) && !IS_ENABLED(CONFIG_MALI_BIFROST_NO_MALI)
+int kbase_device_kinstr_prfcnt_init(struct kbase_device *kbdev)
+{
+ return kbase_kinstr_prfcnt_init(kbdev->hwcnt_gpu_virt,
+ &kbdev->kinstr_prfcnt_ctx);
+}
+
+void kbase_device_kinstr_prfcnt_term(struct kbase_device *kbdev)
+{
+ kbase_kinstr_prfcnt_term(kbdev->kinstr_prfcnt_ctx);
+}
+
int kbase_device_io_history_init(struct kbase_device *kbdev)
{
return kbase_io_history_init(&kbdev->io_history,
@@ -406,7 +478,6 @@
{
kbase_io_history_term(&kbdev->io_history);
}
-#endif
int kbase_device_misc_register(struct kbase_device *kbdev)
{
@@ -455,27 +526,38 @@
{
int err;
- err = kbasep_platform_device_init(kbdev);
+ err = kbase_ktrace_init(kbdev);
if (err)
return err;
+
+
+ err = kbasep_platform_device_init(kbdev);
+ if (err)
+ goto ktrace_term;
err = kbase_pm_runtime_init(kbdev);
if (err)
goto fail_runtime_pm;
+ /* This spinlock is initialized before doing the first access to GPU
+ * registers and installing interrupt handlers.
+ */
+ spin_lock_init(&kbdev->hwaccess_lock);
+
/* Ensure we can access the GPU registers */
kbase_pm_register_access_enable(kbdev);
- /* Find out GPU properties based on the GPU feature registers */
+ /*
+ * Find out GPU properties based on the GPU feature registers.
+ * Note that this does not populate the few properties that depend on
+ * hw_features being initialized. Those are set by kbase_gpuprops_set_features
+ * soon after this in the init process.
+ */
kbase_gpuprops_set(kbdev);
/* We're done accessing the GPU registers for now. */
kbase_pm_register_access_disable(kbdev);
- /* This spinlock has to be initialized before installing interrupt
- * handlers that require to hold it to process interrupts.
- */
- spin_lock_init(&kbdev->hwaccess_lock);
#ifdef CONFIG_MALI_ARBITER_SUPPORT
if (kbdev->arb.arb_if)
err = kbase_arbiter_pm_install_interrupts(kbdev);
@@ -493,6 +575,8 @@
kbase_pm_runtime_term(kbdev);
fail_runtime_pm:
kbasep_platform_device_term(kbdev);
+ktrace_term:
+ kbase_ktrace_term(kbdev);
return err;
}
@@ -509,6 +593,7 @@
#endif /* CONFIG_MALI_ARBITER_SUPPORT */
kbase_pm_runtime_term(kbdev);
kbasep_platform_device_term(kbdev);
+ kbase_ktrace_term(kbdev);
}
int kbase_device_late_init(struct kbase_device *kbdev)
--
Gitblit v1.6.2