From 1543e317f1da31b75942316931e8f491a8920811 Mon Sep 17 00:00:00 2001
From: hc <hc@nodka.com>
Date: Thu, 04 Jan 2024 10:08:02 +0000
Subject: [PATCH] disable FB
---
kernel/drivers/gpu/arm/bifrost/device/backend/mali_kbase_device_csf.c | 157 ++++++++++++++++++++++++++++++++++++----------------
1 files changed, 109 insertions(+), 48 deletions(-)
diff --git a/kernel/drivers/gpu/arm/bifrost/device/backend/mali_kbase_device_csf.c b/kernel/drivers/gpu/arm/bifrost/device/backend/mali_kbase_device_csf.c
index f97ee35..f7054f5 100644
--- a/kernel/drivers/gpu/arm/bifrost/device/backend/mali_kbase_device_csf.c
+++ b/kernel/drivers/gpu/arm/bifrost/device/backend/mali_kbase_device_csf.c
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
/*
*
- * (C) COPYRIGHT 2019-2021 ARM Limited. All rights reserved.
+ * (C) COPYRIGHT 2019-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
@@ -23,12 +23,13 @@
#include <device/mali_kbase_device.h>
#include <mali_kbase_hwaccess_backend.h>
-#include <mali_kbase_hwcnt_backend_csf_if_fw.h>
+#include <hwcnt/backend/mali_kbase_hwcnt_backend_csf_if_fw.h>
+#include <hwcnt/mali_kbase_hwcnt_watchdog_if_timer.h>
#include <mali_kbase_ctx_sched.h>
#include <mali_kbase_reset_gpu.h>
#include <csf/mali_kbase_csf.h>
#include <csf/ipa_control/mali_kbase_csf_ipa_control.h>
-
+#include <backend/gpu/mali_kbase_model_linux.h>
#include <mali_kbase.h>
#include <backend/gpu/mali_kbase_irq_internal.h>
@@ -36,8 +37,10 @@
#include <backend/gpu/mali_kbase_js_internal.h>
#include <backend/gpu/mali_kbase_clk_rate_trace_mgr.h>
#include <csf/mali_kbase_csf_csg_debugfs.h>
-#include <mali_kbase_hwcnt_virtualizer.h>
+#include <hwcnt/mali_kbase_hwcnt_virtualizer.h>
+#include <mali_kbase_kinstr_prfcnt.h>
#include <mali_kbase_vinstr.h>
+#include <tl/mali_kbase_timeline.h>
/**
* kbase_device_firmware_hwcnt_term - Terminate CSF firmware and HWC
@@ -51,10 +54,11 @@
static void kbase_device_firmware_hwcnt_term(struct kbase_device *kbdev)
{
if (kbdev->csf.firmware_inited) {
+ kbase_kinstr_prfcnt_term(kbdev->kinstr_prfcnt_ctx);
kbase_vinstr_term(kbdev->vinstr_ctx);
kbase_hwcnt_virtualizer_term(kbdev->hwcnt_gpu_virt);
kbase_hwcnt_backend_csf_metadata_term(&kbdev->hwcnt_gpu_iface);
- kbase_csf_firmware_term(kbdev);
+ kbase_csf_firmware_unload_term(kbdev);
}
}
@@ -85,13 +89,13 @@
goto fail_timer;
#ifdef CONFIG_MALI_BIFROST_DEBUG
-#ifndef CONFIG_MALI_BIFROST_NO_MALI
+#if IS_ENABLED(CONFIG_MALI_REAL_HW)
if (kbasep_common_test_interrupt_handlers(kbdev) != 0) {
dev_err(kbdev->dev, "Interrupt assignment check failed.\n");
err = -EINVAL;
goto fail_interrupt_test;
}
-#endif /* !CONFIG_MALI_BIFROST_NO_MALI */
+#endif /* IS_ENABLED(CONFIG_MALI_REAL_HW) */
#endif /* CONFIG_MALI_BIFROST_DEBUG */
kbase_ipa_control_init(kbdev);
@@ -119,6 +123,10 @@
if (err)
goto fail_update_l2_features;
+ err = kbase_backend_time_init(kbdev);
+ if (err)
+ goto fail_update_l2_features;
+
init_waitqueue_head(&kbdev->hwaccess.backend.reset_wait);
kbase_pm_context_idle(kbdev);
@@ -135,9 +143,9 @@
kbase_ipa_control_term(kbdev);
#ifdef CONFIG_MALI_BIFROST_DEBUG
-#ifndef CONFIG_MALI_BIFROST_NO_MALI
+#if IS_ENABLED(CONFIG_MALI_REAL_HW)
fail_interrupt_test:
-#endif /* !CONFIG_MALI_BIFROST_NO_MALI */
+#endif /* IS_ENABLED(CONFIG_MALI_REAL_HW) */
#endif /* CONFIG_MALI_BIFROST_DEBUG */
kbase_backend_timer_term(kbdev);
@@ -185,18 +193,56 @@
}
/**
- * kbase_csf_early_init - Early termination for firmware & scheduler.
+ * kbase_csf_early_term() - Early termination for firmware & scheduler.
* @kbdev: Device pointer
*/
static void kbase_csf_early_term(struct kbase_device *kbdev)
{
kbase_csf_scheduler_early_term(kbdev);
+ kbase_csf_firmware_early_term(kbdev);
+}
+
+/**
+ * kbase_csf_late_init - late initialization for firmware.
+ * @kbdev: Device pointer
+ *
+ * Return: 0 on success, error code otherwise.
+ */
+static int kbase_csf_late_init(struct kbase_device *kbdev)
+{
+ int err = kbase_csf_firmware_late_init(kbdev);
+
+ return err;
+}
+
+/**
+ * kbase_device_hwcnt_watchdog_if_init - Create hardware counter watchdog
+ * interface.
+ * @kbdev: Device pointer
+ *
+ * Return: 0 if successful or a negative error code on failure.
+ */
+static int kbase_device_hwcnt_watchdog_if_init(struct kbase_device *kbdev)
+{
+ return kbase_hwcnt_watchdog_if_timer_create(
+ &kbdev->hwcnt_watchdog_timer);
+}
+
+/**
+ * kbase_device_hwcnt_watchdog_if_term - Terminate hardware counter watchdog
+ * interface.
+ * @kbdev: Device pointer
+ */
+static void kbase_device_hwcnt_watchdog_if_term(struct kbase_device *kbdev)
+{
+ kbase_hwcnt_watchdog_if_timer_destroy(&kbdev->hwcnt_watchdog_timer);
}
/**
* kbase_device_hwcnt_backend_csf_if_init - Create hardware counter backend
* firmware interface.
* @kbdev: Device pointer
+ * Return: 0 if successful or a negative error code on failure.
*/
static int kbase_device_hwcnt_backend_csf_if_init(struct kbase_device *kbdev)
{
@@ -217,14 +263,15 @@
/**
* kbase_device_hwcnt_backend_csf_init - Create hardware counter backend.
* @kbdev: Device pointer
+ *
+ * Return: 0 if successful or a negative error code on failure.
*/
-
static int kbase_device_hwcnt_backend_csf_init(struct kbase_device *kbdev)
{
return kbase_hwcnt_backend_csf_create(
&kbdev->hwcnt_backend_csf_if_fw,
KBASE_HWCNT_BACKEND_CSF_RING_BUFFER_COUNT,
- &kbdev->hwcnt_gpu_iface);
+ &kbdev->hwcnt_watchdog_timer, &kbdev->hwcnt_gpu_iface);
}
/**
@@ -237,51 +284,52 @@
}
static const struct kbase_device_init dev_init[] = {
+#if !IS_ENABLED(CONFIG_MALI_REAL_HW)
+ { kbase_gpu_device_create, kbase_gpu_device_destroy,
+ "Dummy model initialization failed" },
+#else /* !IS_ENABLED(CONFIG_MALI_REAL_HW) */
{ assign_irqs, NULL, "IRQ search failed" },
+#endif /* !IS_ENABLED(CONFIG_MALI_REAL_HW) */
+#if !IS_ENABLED(CONFIG_MALI_BIFROST_NO_MALI)
{ registers_map, registers_unmap, "Register map failed" },
- { power_control_init, power_control_term,
- "Power control initialization failed" },
+#endif /* !IS_ENABLED(CONFIG_MALI_BIFROST_NO_MALI) */
+ { power_control_init, power_control_term, "Power control initialization failed" },
{ kbase_device_io_history_init, kbase_device_io_history_term,
"Register access history initialization failed" },
- { kbase_device_early_init, kbase_device_early_term,
- "Early device initialization failed" },
- { kbase_device_populate_max_freq, NULL,
- "Populating max frequency failed" },
+ { kbase_device_early_init, kbase_device_early_term, "Early device initialization failed" },
+ { kbase_device_populate_max_freq, NULL, "Populating max frequency failed" },
+ { kbase_pm_lowest_gpu_freq_init, NULL, "Lowest freq initialization failed" },
{ kbase_device_misc_init, kbase_device_misc_term,
"Miscellaneous device initialization failed" },
{ kbase_device_pcm_dev_init, kbase_device_pcm_dev_term,
"Priority control manager initialization failed" },
- { kbase_ctx_sched_init, kbase_ctx_sched_term,
- "Context scheduler initialization failed" },
- { kbase_mem_init, kbase_mem_term,
- "Memory subsystem initialization failed" },
+ { kbase_ctx_sched_init, kbase_ctx_sched_term, "Context scheduler initialization failed" },
+ { kbase_mem_init, kbase_mem_term, "Memory subsystem initialization failed" },
{ kbase_csf_protected_memory_init, kbase_csf_protected_memory_term,
"Protected memory allocator initialization failed" },
{ kbase_device_coherency_init, NULL, "Device coherency init failed" },
{ kbase_protected_mode_init, kbase_protected_mode_term,
"Protected mode subsystem initialization failed" },
- { kbase_device_list_init, kbase_device_list_term,
- "Device list setup failed" },
+ { kbase_device_list_init, kbase_device_list_term, "Device list setup failed" },
{ kbase_device_timeline_init, kbase_device_timeline_term,
"Timeline stream initialization failed" },
{ kbase_clk_rate_trace_manager_init, kbase_clk_rate_trace_manager_term,
"Clock rate trace manager initialization failed" },
- { kbase_device_hwcnt_backend_csf_if_init,
- kbase_device_hwcnt_backend_csf_if_term,
+ { kbase_device_hwcnt_watchdog_if_init, kbase_device_hwcnt_watchdog_if_term,
+ "GPU hwcnt backend watchdog interface creation failed" },
+ { kbase_device_hwcnt_backend_csf_if_init, kbase_device_hwcnt_backend_csf_if_term,
"GPU hwcnt backend CSF interface creation failed" },
- { kbase_device_hwcnt_backend_csf_init,
- kbase_device_hwcnt_backend_csf_term,
+ { kbase_device_hwcnt_backend_csf_init, kbase_device_hwcnt_backend_csf_term,
"GPU hwcnt backend creation failed" },
{ kbase_device_hwcnt_context_init, kbase_device_hwcnt_context_term,
"GPU hwcnt context initialization failed" },
- { kbase_backend_late_init, kbase_backend_late_term,
- "Late backend initialization failed" },
- { kbase_csf_early_init, kbase_csf_early_term,
- "Early CSF initialization failed" },
+ { kbase_csf_early_init, kbase_csf_early_term, "Early CSF initialization failed" },
+ { kbase_backend_late_init, kbase_backend_late_term, "Late backend initialization failed" },
+ { kbase_csf_late_init, NULL, "Late CSF initialization failed" },
{ NULL, kbase_device_firmware_hwcnt_term, NULL },
-#ifdef MALI_KBASE_BUILD
- { kbase_device_debugfs_init, kbase_device_debugfs_term,
- "DebugFS initialization failed" },
+ { kbase_debug_csf_fault_init, kbase_debug_csf_fault_term,
+ "CSF fault debug initialization failed" },
+ { kbase_device_debugfs_init, kbase_device_debugfs_term, "DebugFS initialization failed" },
/* Sysfs init needs to happen before registering the device with
* misc_register(), otherwise it causes a race condition between
* registering the device and a uevent event being generated for
@@ -299,9 +347,11 @@
"Misc device registration failed" },
{ kbase_gpuprops_populate_user_buffer, kbase_gpuprops_free_user_buffer,
"GPU property population failed" },
- { kbase_device_late_init, kbase_device_late_term,
- "Late device initialization failed" },
-#endif
+ { kbase_device_late_init, kbase_device_late_term, "Late device initialization failed" },
+#if IS_ENABLED(CONFIG_MALI_CORESIGHT)
+ { kbase_debug_coresight_csf_init, kbase_debug_coresight_csf_term,
+ "Coresight initialization failed" },
+#endif /* IS_ENABLED(CONFIG_MALI_CORESIGHT) */
};
static void kbase_device_term_partial(struct kbase_device *kbdev,
@@ -315,7 +365,6 @@
void kbase_device_term(struct kbase_device *kbdev)
{
- kbdev->csf.mali_file_inode = NULL;
kbase_device_term_partial(kbdev, ARRAY_SIZE(dev_init));
kbase_mem_halt(kbdev);
}
@@ -354,7 +403,7 @@
* Hardware counter components depending on firmware are initialized after CSF
* firmware is loaded.
*
- * @return 0 on success. An error code on failure.
+ * Return: 0 on success. An error code on failure.
*/
static int kbase_device_hwcnt_csf_deferred_init(struct kbase_device *kbdev)
{
@@ -390,7 +439,18 @@
goto vinstr_fail;
}
+ ret = kbase_kinstr_prfcnt_init(kbdev->hwcnt_gpu_virt,
+ &kbdev->kinstr_prfcnt_ctx);
+ if (ret) {
+ dev_err(kbdev->dev,
+ "Performance counter instrumentation initialization failed");
+ goto kinstr_prfcnt_fail;
+ }
+
return ret;
+
+kinstr_prfcnt_fail:
+ kbase_vinstr_term(kbdev->vinstr_ctx);
vinstr_fail:
kbase_hwcnt_virtualizer_term(kbdev->hwcnt_gpu_virt);
@@ -410,7 +470,7 @@
* To meet Android GKI vendor guideline, firmware load is deferred at
* the time when @ref kbase_open is called for the first time.
*
- * @return 0 on success. An error code on failure.
+ * Return: 0 on success. An error code on failure.
*/
static int kbase_csf_firmware_deferred_init(struct kbase_device *kbdev)
{
@@ -418,9 +478,7 @@
lockdep_assert_held(&kbdev->fw_load_lock);
- kbase_pm_context_active(kbdev);
-
- err = kbase_csf_firmware_init(kbdev);
+ err = kbase_csf_firmware_load_init(kbdev);
if (!err) {
unsigned long flags;
@@ -432,8 +490,6 @@
dev_err(kbdev->dev, "Firmware initialization failed");
}
- kbase_pm_context_idle(kbdev);
-
return err;
}
@@ -444,21 +500,26 @@
mutex_lock(&kbdev->fw_load_lock);
if (!kbdev->csf.firmware_inited) {
+ kbase_pm_context_active(kbdev);
+
ret = kbase_csf_firmware_deferred_init(kbdev);
if (ret)
goto out;
ret = kbase_device_hwcnt_csf_deferred_init(kbdev);
if (ret) {
- kbase_csf_firmware_term(kbdev);
+ kbase_csf_firmware_unload_term(kbdev);
goto out;
}
kbase_csf_debugfs_init(kbdev);
+ kbase_timeline_io_debugfs_init(kbdev);
+out:
+ kbase_pm_context_idle(kbdev);
}
-out:
mutex_unlock(&kbdev->fw_load_lock);
return ret;
}
+KBASE_EXPORT_TEST_API(kbase_device_firmware_init_once);
--
Gitblit v1.6.2