* [PATCH v5 1/2] Bluetooth: btintel_pcie: Move debug INI parsing to debug file
2026-11-04 12:25 [PATCH v5 0/2] Bluetooth: btintel_pcie: debug INI rework and fatal error injection Sai Teja Aluvala
@ 2026-11-04 12:25 ` Sai Teja Aluvala
2026-11-04 16:43 ` Bluetooth: btintel_pcie: debug INI rework and fatal error injection bluez.test.bot
2026-11-04 12:25 ` [PATCH v5 2/2] Bluetooth: btintel_pcie: Add fatal error injection test mode Sai Teja Aluvala
2026-11-04 16:30 ` [PATCH v5 0/2] Bluetooth: btintel_pcie: debug INI rework and fatal error injection patchwork-bot+bluetooth
2 siblings, 1 reply; 5+ messages in thread
From: Sai Teja Aluvala @ 2026-11-04 12:25 UTC (permalink / raw)
To: linux-bluetooth; +Cc: kiran.k, chethan.tumkur.narayan, Sai Teja Aluvala
Move the debug INI parser from btintel_pcie.c to btintel_pcie_debug.c
so that all debug INI handling lives in one file. Split it into
btintel_pcie_read_debug_ini() and btintel_pcie_ini_next() for reuse,
export btintel_pcie_load_dbg_path_from_ini(), and update the module
description. An INI file that cannot be read, including an allocation
failure, is now logged as unavailable. DBG_PATH, ENABLE_INI and
LOG_MASK behave as before.
Signed-off-by: Sai Teja Aluvala <aluvala.sai.teja@intel.com>
---
drivers/bluetooth/btintel_pcie.c | 122 ---------------------
drivers/bluetooth/btintel_pcie_debug.c | 142 ++++++++++++++++++++++++-
drivers/bluetooth/btintel_pcie_debug.h | 8 +-
3 files changed, 146 insertions(+), 126 deletions(-)
diff --git a/drivers/bluetooth/btintel_pcie.c b/drivers/bluetooth/btintel_pcie.c
index 7d84c8106cf1..8b991ad2a107 100644
--- a/drivers/bluetooth/btintel_pcie.c
+++ b/drivers/bluetooth/btintel_pcie.c
@@ -274,128 +274,6 @@ static inline bool btintel_pcie_dbg_to_wifi(struct btintel_pcie_data *data)
return data->dbg_path_cache != BTINTEL_PCIE_DRAM;
}
-/* Name of the optional INI file used to override the default dbg_path
- * (data->dbg_path_cache), yoyo ini settings and runtime log_mask.
- */
-#define BTINTEL_PCIE_DBG_INI_FILE "ibt_bt_dbg_cfg.ini"
-
-/* Loads optional "DBG_PATH=<value>", "ENABLE_INI=<value>" and "LOG_MASK=<value>"
- * overrides from BTINTEL_PCIE_DBG_INI_FILE
- * and applies them to data->dbg_path_cache, data->enable_ini and data->log_mask.
- *
- * DBG_PATH accepts BTINTEL_PCIE_WIFI_DBGC (0x06, default) and
- * BTINTEL_PCIE_DRAM (0x01, legacy); an invalid or missing entry leaves
- * the cached value set by the caller unchanged.
- *
- * ENABLE_INI accepts 1 (enabled) or 0 (disabled); an invalid or missing
- * entry leaves data->enable_ini unchanged.
- *
- * LOG_MASK accepts any u32 bitmask (see BTINTEL_PCIE_DUMP_TX and friends).
- * The default enables alive interrupt and Sx logging; an invalid or missing
- * entry leaves data->log_mask unchanged.
- */
-static void btintel_pcie_load_dbg_path_from_ini(struct btintel_pcie_data *data)
-{
- const struct firmware *fw;
- const char *ini_file = BTINTEL_PCIE_DBG_INI_FILE;
- char *buf, *cursor, *line;
- bool dbg_path_applied = false;
- bool log_mask_applied = false;
- int err;
-
- err = request_firmware_direct(&fw, ini_file, &data->pdev->dev);
- if (err < 0) {
- BT_DBG("%s not found (%d), using dbg_path=0x%02x log_mask=0x%08x",
- ini_file, err, data->dbg_path_cache, data->log_mask);
- if (data->dbg_path_cache != BTINTEL_PCIE_DRAM)
- data->enable_ini = false;
- return;
- }
-
- buf = kmemdup_nul(fw->data, fw->size, GFP_KERNEL);
- release_firmware(fw);
- if (!buf)
- return;
-
- cursor = buf;
- while ((line = strsep(&cursor, "\n"))) {
- char *eq;
- char *val;
- uint parsed;
-
- line = strim(line);
- if (!line[0] || line[0] == '#' || line[0] == ';')
- continue;
-
- eq = strchr(line, '=');
- if (!eq)
- continue;
-
- *eq = '\0';
- line = strim(line);
- val = strim(eq + 1);
-
- /* Keys are case-insensitive. */
- if (!strcasecmp(line, "DBG_PATH")) {
- BT_INFO("Read DBG_PATH from %s: '%s'", ini_file, val);
-
- /* base 0 lets kstrtouint accept "0x06", "6", etc. */
- if (kstrtouint(val, 0, &parsed) == 0 &&
- (parsed == BTINTEL_PCIE_DRAM ||
- parsed == BTINTEL_PCIE_WIFI_DBGC)) {
- data->dbg_path_cache = parsed;
- dbg_path_applied = true;
- BT_INFO("WRT dbg_path accepted: 0x%02x",
- data->dbg_path_cache);
- } else {
- BT_WARN("Invalid DBG_PATH='%s' in %s, using dbg_path=0x%02x",
- val, ini_file, data->dbg_path_cache);
- }
- } else if (!strcasecmp(line, "LOG_MASK")) {
- BT_INFO("Read LOG_MASK from %s: '%s'", ini_file, val);
-
- if (kstrtouint(val, 0, &parsed) == 0) {
- data->log_mask = parsed;
- log_mask_applied = true;
- BT_INFO("WRT log_mask accepted: 0x%08x",
- data->log_mask);
- } else {
- BT_WARN("Invalid LOG_MASK='%s' in %s, using log_mask=0x%08x",
- val, ini_file, data->log_mask);
- }
- } else if (!strcasecmp(line, "ENABLE_INI")) {
- BT_INFO("Read ENABLE_INI from %s: '%s'", ini_file, val);
-
- if (kstrtouint(val, 0, &parsed) == 0 &&
- (parsed == 0 || parsed == 1)) {
- data->enable_ini = !!parsed;
- BT_INFO("WRT enable_ini accepted: %u",
- data->enable_ini);
- } else {
- BT_WARN("Invalid ENABLE_INI='%s' in %s, using enable_ini=%u",
- val, ini_file, data->enable_ini);
- }
- }
- }
-
- if (data->dbg_path_cache != BTINTEL_PCIE_DRAM)
- data->enable_ini = false;
-
- if (dbg_path_applied)
- BT_DBG("Loaded dbg_path=0x%02x from %s", data->dbg_path_cache, ini_file);
- else
- BT_WARN("No valid DBG_PATH in %s, dbg_path=0x%02x", ini_file, data->dbg_path_cache);
-
- BT_DBG("ENABLE_INI effective state: %u", data->enable_ini);
-
- if (log_mask_applied)
- BT_DBG("Loaded log_mask=0x%08x from %s", data->log_mask, ini_file);
- else
- BT_DBG("No valid LOG_MASK in %s, log_mask=0x%08x", ini_file, data->log_mask);
-
- kfree(buf);
-}
-
/* Helper function to allocate and setup a debug buffer group
* @data: driver data structure
* @buf: pointer to data_buf array pointer
diff --git a/drivers/bluetooth/btintel_pcie_debug.c b/drivers/bluetooth/btintel_pcie_debug.c
index 9f2d3f32bd99..f3409b8d70b5 100644
--- a/drivers/bluetooth/btintel_pcie_debug.c
+++ b/drivers/bluetooth/btintel_pcie_debug.c
@@ -1,22 +1,158 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
- * Intel Bluetooth YoYo Debug Framework
+ * Intel Bluetooth PCIe Debug Framework
*
* Copyright (C) 2026 Intel Corporation
*
* Runtime-configurable TLV-based debug collection framework for loading and
* parsing the optional YoYo firmware configuration used to enable debug
- * regions, triggers, HCI commands, and configuration sets.
+ * regions, triggers, HCI commands, and configuration sets. Also provides
+ * debug INI configuration.
*/
#include <linux/errno.h>
#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/slab.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/unaligned.h>
#include <net/bluetooth/bluetooth.h>
+#include "btintel_pcie.h"
#include "btintel_pcie_debug.h"
+static char *btintel_pcie_read_debug_ini(struct btintel_pcie_data *data)
+{
+ const struct firmware *fw;
+ char *buf;
+ int err;
+
+ err = request_firmware_direct(&fw, BTINTEL_PCIE_DBG_INI_FILE,
+ &data->pdev->dev);
+ if (err)
+ return ERR_PTR(err);
+
+ buf = kmemdup_nul(fw->data, fw->size, GFP_KERNEL);
+ release_firmware(fw);
+ if (!buf)
+ return ERR_PTR(-ENOMEM);
+
+ return buf;
+}
+
+static char *btintel_pcie_ini_next(char **cursor, char **key)
+{
+ char *line, *eq;
+
+ while ((line = strsep(cursor, "\n"))) {
+ line = strim(line);
+ if (!line[0] || line[0] == '#' || line[0] == ';')
+ continue;
+
+ eq = strchr(line, '=');
+ if (!eq)
+ continue;
+
+ *eq = '\0';
+ *key = strim(line);
+ return strim(eq + 1);
+ }
+
+ return NULL;
+}
+
+/* Loads optional "DBG_PATH=<value>", "ENABLE_INI=<value>" and
+ * "LOG_MASK=<value>" overrides from BTINTEL_PCIE_DBG_INI_FILE and applies
+ * them to data->dbg_path_cache, data->enable_ini and data->log_mask.
+ *
+ * DBG_PATH accepts BTINTEL_PCIE_WIFI_DBGC (0x06, default) and
+ * BTINTEL_PCIE_DRAM (0x01, legacy); an invalid or missing entry leaves
+ * the cached value set by the caller unchanged.
+ *
+ * ENABLE_INI accepts 1 (enabled) or 0 (disabled); an invalid or missing
+ * entry leaves data->enable_ini unchanged.
+ *
+ * LOG_MASK accepts any u32 bitmask (see BTINTEL_PCIE_DUMP_TX and friends).
+ * The default enables alive interrupt and Sx logging; an invalid or missing
+ * entry leaves data->log_mask unchanged.
+ */
+void btintel_pcie_load_dbg_path_from_ini(struct btintel_pcie_data *data)
+{
+ const char *ini_file = BTINTEL_PCIE_DBG_INI_FILE;
+ char *buf, *cursor, *key, *val;
+ bool dbg_path_applied = false;
+ bool log_mask_applied = false;
+
+ buf = btintel_pcie_read_debug_ini(data);
+ if (IS_ERR(buf)) {
+ BT_DBG("%s unavailable (%ld), using dbg_path=0x%02x log_mask=0x%08x",
+ ini_file, PTR_ERR(buf), data->dbg_path_cache,
+ data->log_mask);
+ if (data->dbg_path_cache != BTINTEL_PCIE_DRAM)
+ data->enable_ini = false;
+ return;
+ }
+
+ cursor = buf;
+ while ((val = btintel_pcie_ini_next(&cursor, &key))) {
+ unsigned int parsed;
+
+ if (!strcasecmp(key, "DBG_PATH")) {
+ BT_INFO("Read DBG_PATH from %s: '%s'", ini_file, val);
+ if (!kstrtouint(val, 0, &parsed) &&
+ (parsed == BTINTEL_PCIE_DRAM ||
+ parsed == BTINTEL_PCIE_WIFI_DBGC)) {
+ data->dbg_path_cache = parsed;
+ dbg_path_applied = true;
+ BT_INFO("WRT dbg_path accepted: 0x%02x",
+ data->dbg_path_cache);
+ } else {
+ BT_WARN("Invalid DBG_PATH='%s' in %s, using dbg_path=0x%02x",
+ val, ini_file, data->dbg_path_cache);
+ }
+ } else if (!strcasecmp(key, "LOG_MASK")) {
+ BT_INFO("Read LOG_MASK from %s: '%s'", ini_file, val);
+ if (!kstrtouint(val, 0, &parsed)) {
+ data->log_mask = parsed;
+ log_mask_applied = true;
+ BT_INFO("WRT log_mask accepted: 0x%08x",
+ data->log_mask);
+ } else {
+ BT_WARN("Invalid LOG_MASK='%s' in %s, using log_mask=0x%08x",
+ val, ini_file, data->log_mask);
+ }
+ } else if (!strcasecmp(key, "ENABLE_INI")) {
+ BT_INFO("Read ENABLE_INI from %s: '%s'", ini_file, val);
+ if (!kstrtouint(val, 0, &parsed) && parsed <= 1) {
+ data->enable_ini = !!parsed;
+ BT_INFO("WRT enable_ini accepted: %u",
+ data->enable_ini);
+ } else {
+ BT_WARN("Invalid ENABLE_INI='%s' in %s, using enable_ini=%u",
+ val, ini_file, data->enable_ini);
+ }
+ }
+ }
+
+ if (data->dbg_path_cache != BTINTEL_PCIE_DRAM)
+ data->enable_ini = false;
+
+ if (dbg_path_applied)
+ BT_DBG("Loaded dbg_path=0x%02x from %s", data->dbg_path_cache, ini_file);
+ else
+ BT_WARN("No valid DBG_PATH in %s, dbg_path=0x%02x", ini_file, data->dbg_path_cache);
+
+ BT_DBG("ENABLE_INI effective state: %u", data->enable_ini);
+
+ if (log_mask_applied)
+ BT_DBG("Loaded log_mask=0x%08x from %s", data->log_mask, ini_file);
+ else
+ BT_DBG("No valid LOG_MASK in %s, log_mask=0x%08x", ini_file, data->log_mask);
+
+ kfree(buf);
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_load_dbg_path_from_ini);
+
/* TLV-specific parser DEBUG_INFO TLV type */
static int btintel_pcie_yoyo_parse_dbg_info(struct btintel_pcie_yoyo_ctx *ctx,
const struct btintel_pcie_tlv_dbg_info *info,
@@ -327,5 +463,5 @@ btintel_pcie_yoyo_get_buf_alloc(struct btintel_pcie_yoyo_ctx *ctx, u32 alloc_id)
}
EXPORT_SYMBOL_GPL(btintel_pcie_yoyo_get_buf_alloc);
-MODULE_DESCRIPTION("Intel Bluetooth yoyo debug framework");
+MODULE_DESCRIPTION("Intel Bluetooth PCIe Debug Framework");
MODULE_LICENSE("GPL");
diff --git a/drivers/bluetooth/btintel_pcie_debug.h b/drivers/bluetooth/btintel_pcie_debug.h
index 5ed368fb13d1..04cfcef6f65b 100644
--- a/drivers/bluetooth/btintel_pcie_debug.h
+++ b/drivers/bluetooth/btintel_pcie_debug.h
@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
- * Intel Bluetooth YoYo Debug Framework
+ * Intel Bluetooth PCIe Debug Framework
*
* Copyright (C) 2026 Intel Corporation
*
@@ -14,6 +14,12 @@
#include <linux/device.h>
#include <linux/firmware.h>
+struct btintel_pcie_data;
+
+#define BTINTEL_PCIE_DBG_INI_FILE "ibt_bt_dbg_cfg.ini"
+
+void btintel_pcie_load_dbg_path_from_ini(struct btintel_pcie_data *data);
+
/* External YoYo binary file */
#define BTINTEL_PCIE_YOYO_FW_NAME "intel/ibt_debug_yoyo.bin"
--
2.53.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH v5 2/2] Bluetooth: btintel_pcie: Add fatal error injection test mode
2026-11-04 12:25 [PATCH v5 0/2] Bluetooth: btintel_pcie: debug INI rework and fatal error injection Sai Teja Aluvala
2026-11-04 12:25 ` [PATCH v5 1/2] Bluetooth: btintel_pcie: Move debug INI parsing to debug file Sai Teja Aluvala
@ 2026-11-04 12:25 ` Sai Teja Aluvala
2026-11-04 16:30 ` [PATCH v5 0/2] Bluetooth: btintel_pcie: debug INI rework and fatal error injection patchwork-bot+bluetooth
2 siblings, 0 replies; 5+ messages in thread
From: Sai Teja Aluvala @ 2026-11-04 12:25 UTC (permalink / raw)
To: linux-bluetooth; +Cc: kiran.k, chethan.tumkur.narayan, Sai Teja Aluvala
Add the FATAL_ERR_TESTMODE debug INI option to inject a firmware
exception for testing. The INI value selects the exception type and the
injection context (thread, IRQ or rfkill). Whether an injected
exception is expected to trigger recovery depends on its type.
The test mode is disabled when the OPFW API lock is set, unless the
unlocker firmware was loaded.
While HCI is up, the hardware rfkill button only triggers the
injection: an assertion injects the exception, a release is ignored,
and normal rfkill reporting to the HCI stack is disabled. While HCI is
down, normal rfkill handling applies.
The exception is also injected after every successful setup, with the
rfkill context and without sampling the rfkill state. The injection
stays pending until HCI is up, and open() reschedules it. After a
recovery re-probe it is injected again, until the INI entry is removed.
Signed-off-by: Sai Teja Aluvala <aluvala.sai.teja@intel.com>
---
drivers/bluetooth/btintel.c | 5 +-
drivers/bluetooth/btintel.h | 1 +
drivers/bluetooth/btintel_pcie.c | 39 +++++++
drivers/bluetooth/btintel_pcie.h | 5 +-
drivers/bluetooth/btintel_pcie_debug.c | 155 ++++++++++++++++++++++++-
drivers/bluetooth/btintel_pcie_debug.h | 24 ++++
6 files changed, 226 insertions(+), 3 deletions(-)
diff --git a/drivers/bluetooth/btintel.c b/drivers/bluetooth/btintel.c
index b9bb6980bada..a0aa110f4cdd 100644
--- a/drivers/bluetooth/btintel.c
+++ b/drivers/bluetooth/btintel.c
@@ -3579,8 +3579,11 @@ static int btintel_try_load_unlocker(struct hci_dev *hdev,
if (err) {
bt_dev_err(hdev, "Failed to load intel/unlocker.sfi (%d)", err);
data->unlocker = false;
+ return err;
}
- return err;
+
+ btintel_set_flag(hdev, INTEL_UNLOCKER_LOADED);
+ return 0;
}
int btintel_bootloader_setup_tlv(struct hci_dev *hdev,
diff --git a/drivers/bluetooth/btintel.h b/drivers/bluetooth/btintel.h
index d5e125ec5168..372c6d7d8cbe 100644
--- a/drivers/bluetooth/btintel.h
+++ b/drivers/bluetooth/btintel.h
@@ -259,6 +259,7 @@ enum {
INTEL_ROM_LEGACY_NO_WBS_SUPPORT,
INTEL_ACPI_RESET_ACTIVE,
INTEL_WAIT_FOR_D0,
+ INTEL_UNLOCKER_LOADED,
__INTEL_NUM_FLAGS,
};
diff --git a/drivers/bluetooth/btintel_pcie.c b/drivers/bluetooth/btintel_pcie.c
index 8b991ad2a107..5dd8e5083e88 100644
--- a/drivers/bluetooth/btintel_pcie.c
+++ b/drivers/bluetooth/btintel_pcie.c
@@ -2954,6 +2954,14 @@ static void btintel_pcie_hw_rfkill_delay_work(struct work_struct *wk)
if (!test_bit(BTINTEL_PCIE_SETUP_DONE, &data->flags))
return;
+ /* Intentional: with the fatal error test mode enabled, the post-setup
+ * injection consumes this rfkill pass, so the initial rfkill check is
+ * deferred to the next pass. This avoids a second, back-to-back
+ * injection while the recovery caused by the first one is running.
+ */
+ if (btintel_pcie_fatal_err_post_setup_pending(data))
+ return;
+
/* Do not report an initial clear when rfkill was never asserted.
* After resume, however, a previously asserted rfkill must be
* cleared and reported to the HCI stack.
@@ -2968,10 +2976,18 @@ static void btintel_pcie_hw_rfkill_delay_work(struct work_struct *wk)
!(ipc_ctrl & BTINTEL_PCIE_CSR_IPC_CONTROL_HW_RFKILL);
if (set_rfkill) {
bt_dev_dbg(data->hdev, "hw rfkill on");
+ /* Fatal error test mode: inject on every rfkill assertion seen
+ * here, not only on a transition. A work run queued behind the
+ * post-setup injection may inject once more.
+ */
+ if (btintel_pcie_fatal_err_handle_rfkill(data, true))
+ return;
set_bit(BTINTEL_PCIE_HWRFKILL_ON, &data->flags);
hci_rfkill_set_hw_state(data->hdev, true);
} else {
bt_dev_dbg(data->hdev, "hw rfkill off");
+ if (btintel_pcie_fatal_err_handle_rfkill(data, false))
+ return;
/* Nothing changed at the initial post-setup check, so there
* is no transition to report.
*/
@@ -3550,8 +3566,16 @@ static int btintel_pcie_alloc(struct btintel_pcie_data *data)
static int btintel_pcie_open(struct hci_dev *hdev)
{
+ struct btintel_pcie_data *data = hci_get_drvdata(hdev);
+
bt_dev_dbg(hdev, "");
+ /* Fatal error test mode: send the post-setup injection that was
+ * deferred because HCI was down.
+ */
+ if (test_bit(BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING, &data->flags))
+ btintel_delayed_hw_rfkill(data, true);
+
return 0;
}
@@ -3921,6 +3945,12 @@ static int btintel_pcie_setup_internal(struct hci_dev *hdev,
goto exit_error;
}
+ /* ver_tlv holds the operational firmware version after setup. A
+ * locked platform with the unlocker loaded can run the test mode.
+ */
+ btintel_pcie_fatal_err_check_api_lock(data, ver_tlv.api_lock &&
+ !btintel_test_flag(hdev, INTEL_UNLOCKER_LOADED));
+
data->dmp_hdr.cnvi_top = ver_tlv.cnvi_top;
data->dmp_hdr.cnvr_top = ver_tlv.cnvr_top;
data->dmp_hdr.fw_timestamp = ver_tlv.timestamp;
@@ -3947,6 +3977,8 @@ static int btintel_pcie_setup(struct hci_dev *hdev)
struct btintel_pcie_data *data = hci_get_drvdata(hdev);
bool fips_crc_failed;
+ btintel_pcie_fatal_err_load(data);
+
while ((err = btintel_pcie_setup_internal(hdev, &fips_crc_failed)) &&
fw_dl_retry++ < 1) {
if (fips_crc_failed)
@@ -3975,6 +4007,12 @@ static int btintel_pcie_setup(struct hci_dev *hdev)
}
if (!err) {
+ /* Fatal error test mode: arm the post-setup injection before
+ * SETUP_DONE so the rfkill work cannot inject a fault ahead of
+ * it.
+ */
+ if (btintel_pcie_fatal_err_testmode_active(data))
+ set_bit(BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING, &data->flags);
set_bit(BTINTEL_PCIE_SETUP_DONE, &data->flags);
set_bit(BTINTEL_PCIE_HW_RFKILL_STATE_CHECK, &data->flags);
btintel_pcie_unmask_hw_rfkill(data);
@@ -4567,6 +4605,7 @@ static int btintel_pcie_probe(struct pci_dev *pdev,
data->img_resp_cache = 0x00;
data->dbg_path_cache = BTINTEL_PCIE_WIFI_DBGC;
data->log_mask = BTINTEL_PCIE_LOG_ALIVE_INTR | BTINTEL_PCIE_LOG_SX;
+ btintel_pcie_fatal_err_init(data);
data->pcie_alloc_init = false;
data->enable_ini = false;
btintel_pcie_yoyo_init(&data->yoyo);
diff --git a/drivers/bluetooth/btintel_pcie.h b/drivers/bluetooth/btintel_pcie.h
index f04dfb0b30fa..4bffd95b6ec6 100644
--- a/drivers/bluetooth/btintel_pcie.h
+++ b/drivers/bluetooth/btintel_pcie.h
@@ -172,7 +172,8 @@ enum {
BTINTEL_PCIE_SETUP_DONE,
BTINTEL_PCIE_MAIL_BOX_INTR,
BTINTEL_PCIE_MBOX_PARSE_PENDING,
- BTINTEL_PCIE_MBOX_PARSE_READY
+ BTINTEL_PCIE_MBOX_PARSE_READY,
+ BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING,
};
enum btintel_pcie_tlv_type {
@@ -719,6 +720,7 @@ struct btintel_pcie_ini_dump_info {
* @dbg_path_cache: cached debug output routing mode (BT DRAM or WiFi DBGC)
* @log_mask: runtime diagnostic logging mask loaded from LOG_MASK in the
* debug INI file (alive interrupt and Sx logging are enabled by default)
+ * @fatal_err: fatal-error injection testmode state
* @cnvi: CNVi register value
* @cnvr: CNVr register value
* @gp0_received: condition for gp0 interrupt
@@ -775,6 +777,7 @@ struct btintel_pcie_data {
u32 dbg_path_cache;
u32 log_mask;
bool enable_ini;
+ struct btintel_pcie_fatal_err_cfg fatal_err;
struct btintel_pcie_yoyo_ctx yoyo;
u32 cnvi;
diff --git a/drivers/bluetooth/btintel_pcie_debug.c b/drivers/bluetooth/btintel_pcie_debug.c
index f3409b8d70b5..d675d3ff63dc 100644
--- a/drivers/bluetooth/btintel_pcie_debug.c
+++ b/drivers/bluetooth/btintel_pcie_debug.c
@@ -7,7 +7,7 @@
* Runtime-configurable TLV-based debug collection framework for loading and
* parsing the optional YoYo firmware configuration used to enable debug
* regions, triggers, HCI commands, and configuration sets. Also provides
- * debug INI configuration.
+ * debug INI configuration and fatal-error injection testmode.
*/
#include <linux/errno.h>
@@ -18,6 +18,7 @@
#include <linux/string.h>
#include <linux/unaligned.h>
#include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
#include "btintel_pcie.h"
#include "btintel_pcie_debug.h"
@@ -153,6 +154,158 @@ void btintel_pcie_load_dbg_path_from_ini(struct btintel_pcie_data *data)
}
EXPORT_SYMBOL_GPL(btintel_pcie_load_dbg_path_from_ini);
+void btintel_pcie_fatal_err_init(struct btintel_pcie_data *data)
+{
+ data->fatal_err.testmode_enabled = false;
+ data->fatal_err.context = BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_THREAD;
+ data->fatal_err.type = BTINTEL_PCIE_DEBUG_EXCEPTION_FAILURE_TYPE_DEFAULT;
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_init);
+
+void btintel_pcie_fatal_err_load(struct btintel_pcie_data *data)
+{
+ char *buf, *cursor, *key, *val;
+ u32 parsed;
+
+ WRITE_ONCE(data->fatal_err.testmode_enabled, false);
+ clear_bit(BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING, &data->flags);
+ buf = btintel_pcie_read_debug_ini(data);
+ if (IS_ERR(buf)) {
+ BT_DBG("%s unavailable (%ld); fatal-error testmode disabled",
+ BTINTEL_PCIE_DBG_INI_FILE, PTR_ERR(buf));
+ return;
+ }
+
+ cursor = buf;
+ while ((val = btintel_pcie_ini_next(&cursor, &key))) {
+ if (strcasecmp(key, "FATAL_ERR_TESTMODE"))
+ continue;
+
+ if (kstrtou32(val, 0, &parsed) ||
+ BTINTEL_PCIE_FATAL_ERR_ENABLE(parsed) > 1 ||
+ BTINTEL_PCIE_FATAL_ERR_CONTEXT(parsed) >
+ BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_RFKILL ||
+ parsed >> 24) {
+ BT_ERR("Invalid FATAL_ERR_TESTMODE='%s' in %s; testmode disabled",
+ val, BTINTEL_PCIE_DBG_INI_FILE);
+ break;
+ }
+
+ data->fatal_err.context = BTINTEL_PCIE_FATAL_ERR_CONTEXT(parsed);
+ data->fatal_err.type = BTINTEL_PCIE_FATAL_ERR_TYPE(parsed);
+ WRITE_ONCE(data->fatal_err.testmode_enabled,
+ BTINTEL_PCIE_FATAL_ERR_ENABLE(parsed));
+ BT_INFO("FATAL_ERR_TESTMODE accepted: 0x%08x", parsed);
+ break;
+ }
+
+ kfree(buf);
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_load);
+
+void btintel_pcie_fatal_err_check_api_lock(struct btintel_pcie_data *data,
+ bool api_lock)
+{
+ if (api_lock) {
+ if (READ_ONCE(data->fatal_err.testmode_enabled))
+ bt_dev_info(data->hdev,
+ "OPFW API lock enabled; disabling fatal-error testmode");
+ WRITE_ONCE(data->fatal_err.testmode_enabled, false);
+ } else if (READ_ONCE(data->fatal_err.testmode_enabled)) {
+ bt_dev_info(data->hdev, "fatal-error testmode active: ctx=0x%02x type=0x%02x",
+ data->fatal_err.context, data->fatal_err.type);
+ }
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_check_api_lock);
+
+static int btintel_pcie_inject_fatal_err(struct btintel_pcie_data *data,
+ u8 context)
+{
+ struct hci_dev *hdev = data->hdev;
+ struct sk_buff *skb;
+ u8 param[2];
+ int err = 0;
+
+ /* Setup and the rest of HCI initialization hold req_lock. Wait for
+ * them before testing HCI_UP; a delayed worker alone is not enough.
+ */
+ hci_req_sync_lock(hdev);
+ if (!test_bit(HCI_UP, &hdev->flags) ||
+ hci_dev_test_flag(hdev, HCI_UNREGISTER)) {
+ err = -ENETDOWN;
+ goto unlock;
+ }
+
+ if (!READ_ONCE(data->fatal_err.testmode_enabled))
+ goto unlock;
+
+ param[0] = data->fatal_err.type;
+ param[1] = context;
+ skb = __hci_cmd_sync(hdev, 0xfc4d, sizeof(param), param, HCI_CMD_TIMEOUT);
+ if (IS_ERR(skb)) {
+ err = PTR_ERR(skb);
+ goto unlock;
+ }
+
+ kfree_skb(skb);
+unlock:
+ hci_req_sync_unlock(hdev);
+ if (err && err != -ENETDOWN)
+ bt_dev_err(hdev, "fatal-error inject failed (ctx=0x%02x err=%d)",
+ context, err);
+ return err;
+}
+
+bool btintel_pcie_fatal_err_handle_rfkill(struct btintel_pcie_data *data,
+ bool rfkill_on)
+{
+ if (!READ_ONCE(data->fatal_err.testmode_enabled))
+ return false;
+
+ if (rfkill_on) {
+ /* HCI down: nothing to inject, use the normal handling */
+ if (btintel_pcie_inject_fatal_err(data, data->fatal_err.context) ==
+ -ENETDOWN)
+ return false;
+ return true;
+ }
+
+ /* Release of an assertion handled by the normal path: let it through */
+ if (test_bit(BTINTEL_PCIE_HWRFKILL_ON, &data->flags))
+ return false;
+
+ bt_dev_dbg(data->hdev, "fatal-error testmode active: ignoring RF-KILL OFF");
+ return true;
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_handle_rfkill);
+
+bool btintel_pcie_fatal_err_post_setup_pending(struct btintel_pcie_data *data)
+{
+ int err;
+
+ if (!test_bit(BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING, &data->flags))
+ return false;
+
+ /* Intentional: RFKILL context tells the controller testmode is enabled */
+ err = btintel_pcie_inject_fatal_err(data,
+ BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_RFKILL);
+ /* HCI is down: keep the injection pending for a later pass and let
+ * the normal rfkill handling run.
+ */
+ if (err == -ENETDOWN)
+ return false;
+
+ clear_bit(BTINTEL_PCIE_FATAL_ERR_POST_SETUP_PENDING, &data->flags);
+ return true;
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_post_setup_pending);
+
+bool btintel_pcie_fatal_err_testmode_active(struct btintel_pcie_data *data)
+{
+ return READ_ONCE(data->fatal_err.testmode_enabled);
+}
+EXPORT_SYMBOL_GPL(btintel_pcie_fatal_err_testmode_active);
+
/* TLV-specific parser DEBUG_INFO TLV type */
static int btintel_pcie_yoyo_parse_dbg_info(struct btintel_pcie_yoyo_ctx *ctx,
const struct btintel_pcie_tlv_dbg_info *info,
diff --git a/drivers/bluetooth/btintel_pcie_debug.h b/drivers/bluetooth/btintel_pcie_debug.h
index 04cfcef6f65b..b4d1d329886b 100644
--- a/drivers/bluetooth/btintel_pcie_debug.h
+++ b/drivers/bluetooth/btintel_pcie_debug.h
@@ -18,7 +18,31 @@ struct btintel_pcie_data;
#define BTINTEL_PCIE_DBG_INI_FILE "ibt_bt_dbg_cfg.ini"
+/* FATAL_ERR_TESTMODE: B0 enable, B1 context, B2 type, B3 reserved. */
+#define BTINTEL_PCIE_FATAL_ERR_ENABLE(v) ((u8)((v) & 0xff))
+#define BTINTEL_PCIE_FATAL_ERR_CONTEXT(v) ((u8)(((v) >> 8) & 0xff))
+#define BTINTEL_PCIE_FATAL_ERR_TYPE(v) ((u8)(((v) >> 16) & 0xff))
+
+#define BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_THREAD 0x00
+#define BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_IRQ 0x01
+#define BTINTEL_PCIE_DEBUG_EXCEPTION_CONTEXT_RFKILL 0x02
+#define BTINTEL_PCIE_DEBUG_EXCEPTION_FAILURE_TYPE_DEFAULT 0x00
+
+struct btintel_pcie_fatal_err_cfg {
+ bool testmode_enabled;
+ u8 context;
+ u8 type;
+};
+
void btintel_pcie_load_dbg_path_from_ini(struct btintel_pcie_data *data);
+void btintel_pcie_fatal_err_init(struct btintel_pcie_data *data);
+void btintel_pcie_fatal_err_load(struct btintel_pcie_data *data);
+void btintel_pcie_fatal_err_check_api_lock(struct btintel_pcie_data *data,
+ bool api_lock);
+bool btintel_pcie_fatal_err_handle_rfkill(struct btintel_pcie_data *data,
+ bool rfkill_on);
+bool btintel_pcie_fatal_err_post_setup_pending(struct btintel_pcie_data *data);
+bool btintel_pcie_fatal_err_testmode_active(struct btintel_pcie_data *data);
/* External YoYo binary file */
#define BTINTEL_PCIE_YOYO_FW_NAME "intel/ibt_debug_yoyo.bin"
--
2.53.0
^ permalink raw reply related [flat|nested] 5+ messages in thread