Skip to contentSkip to conversation

ath10k: firmware crash dump

PATCH Superseded Kalle Valo 3 participants 27 messages Aug 19, 2014 – Aug 20, 2014 Qualcomm Atheros ATH10K wireless driver

v7 of 8 Superseded Latest is v8 →

lore
Share & tools
lore

Kalle Valo

author
#0 lore raw

v7 cover ath10k: firmware crash dump

Hi,

new version of the firmware crash dump support for ath10k. Hopefully the last one :)

Kalle

TODO for the future:

* atomic allocation in ath10k_pci_dump_dbglog() is bad. Should we allocate a big buffer with vmalloc and use that?

* dynamic allocation for BSS buffers

v7:

* really send "ath10k: print more driver info when firmware crashes", I had accidentally dropped it in previous series

* add ATH10K_FW_CRASH_DUMP_VERSION (Michal)

* remove extra newline (Michal)

* fix unprotected access of crashed_since_read in
ath10k_fw_crash_dump_open() (Michal)

* take data_lock only once in ath10k_build_dump_file() (Michal)

* use vzalloc() instead of vmalloc() and memset() in ath10k_build_dump_file()

* fix memory leak in ath10k_debug_create() (Michal)

* always use little endian in the dump file and drop endian field from the dump file (Michal)

* print uuid in LE format

v6:

* fix vzalloc(sizeof(ar->debug.fw_crash_data)), fixes the crash I saw (Ben)

* "Target Register Dump" -> "firmware register dump"

* add ath10k_print_driver_info()

* take timestamp at crash time instead of crash-dump-gather time (Ben)

* fix locking comment in struct ath10k::fw (Ben)

* move "crash_data->crashed_since_read = true" to
ath10k_debug_get_new_few_crash_data()

* ath10k_pci_hif_dump_area() holds the lock all the time so that we can guarantee that changes to ath10k_fw_crash_data are atomic

* take data_lock earlier in ath10k_build_dump_file() so that all access to crash_data is protected

* rename debugfs file fw_crash_dump

* fw_crash_dump debugfs files returns -ENODATA if there's no new crash dump

* store bss addresses and lengths as u32 in struct ath10k::fw

v5:

* dump_data->tv_sec and tv_nsec to 64 bits (because long can be 32 bits on some platforms)

* fix long lines

* renamed ath10k_dbg_save_fw_dbg_buffer() to ath10k_debug_dbglog_add()

* add helpers for ath10k_pci_diag* functions

* refactor and rename ath10k_pci_hif_dump_area()

* latest crash dump is always stored (instead of the oldest unread)

* add ath10k_debug_get_fw_crash_data()

* move fw_r?m_bss_* fields to ar->fw

* struct ath10k_fw_crash_data is allocated with vmalloc()

* atomic allocation in ath10k_pci_dump_bss() is bad, fix that by using vmalloc in module initialisation

* separate FW IE entries for BSS regions

* don't use ath10k_err()

* simplify locking and memory allocation for FW IE handling

* add uuid

* move struct ath10k_dump_file_data and enum ath10k_fw_error_dump_type to debug.c

* function and variable naming, using ath10k_fw_crash_ prefix etc

* change warning and debug messages to follow ath10k style

* add ath10k_debug_get_new_fw_crash_data() to avoid ifdefs in pci.c

---

Ben Greear (5):
ath10k: provide firmware crash info via debugfs
ath10k: save firmware debug log messages
ath10k: save firmware stack upon firmware crash
ath10k: dump exception stack contents on firmware crash
ath10k: save firmware RAM and ROM BSS sections on crash

Kalle Valo (3):
ath10k: add ath10k_pci_diag_* helpers
ath10k: rename ath10k_pci_hif_dump_area() to ath10k_pci_fw_crashed_dump()
ath10k: print more driver info when firmware crashes

 drivers/net/wireless/ath/ath10k/core.c  |   71 +++++-
 drivers/net/wireless/ath/ath10k/core.h  |   45 ++++
 drivers/net/wireless/ath/ath10k/debug.c |  349 +++++++++++++++++++++++++++++++
 drivers/net/wireless/ath/ath10k/debug.h |   23 ++
 drivers/net/wireless/ath/ath10k/hw.h    |   34 +++
 drivers/net/wireless/ath/ath10k/pci.c   |  257 +++++++++++++++++++++--
 drivers/net/wireless/ath/ath10k/pci.h   |    3 
 drivers/net/wireless/ath/ath10k/wmi.c   |   10 +
 8 files changed, 746 insertions(+), 46 deletions(-)
author
#1 lore raw

PATCH v7 1/8 ath10k: add ath10k_pci_diag_* helpers

ath10k_pci_diag_read32() is for reading u32 from a device and ath10k_pci_diag_read_hi() is a helper for reading data using "host interest" table.

---
 drivers/net/wireless/ath/ath10k/pci.c |   55 +++++++++++++++++++++++----------
 1 file changed, 38 insertions(+), 17 deletions(-)
drivers/net/wireless/ath/ath10k/pci.c +38 -17
index 98c029b7d0ab..b4ae4bb3fc09 100644
@@ -460,13 +460,46 @@ done:
 	return ret;
 }
 
+static int ath10k_pci_diag_read32(struct ath10k *ar, u32 address, u32 *value)
+{
+	return ath10k_pci_diag_read_mem(ar, address, value, sizeof(u32));
+}
+
+static int __ath10k_pci_diag_read_hi(struct ath10k *ar, void *dest,
+				     u32 src, u32 len)
+{
+	u32 host_addr, addr;
+	int ret;
+
+	host_addr = host_interest_item_address(src);
+
+	ret = ath10k_pci_diag_read32(ar, host_addr, &addr);
+	if (ret != 0) {
+		ath10k_warn("failed to get memcpy hi address for firmware address %d: %d\n",
+			    src, ret);
+		return ret;
+	}
+
+	ret = ath10k_pci_diag_read_mem(ar, addr, dest, len);
+	if (ret != 0) {
+		ath10k_warn("failed to memcpy firmware memory from %d (%d B): %d\n",
+			    addr, len, ret);
+		return ret;
+	}
+
+	return 0;
+}
+
+#define ath10k_pci_diag_read_hi(ar, dest, src, len)		\
+	__ath10k_pci_diag_read_hi(ar, dest, HI_ITEM(src), len);
+
 /* Read 4-byte aligned data from Target memory or register */
 static int ath10k_pci_diag_read_access(struct ath10k *ar, u32 address,
 				       u32 *data)
 {
 	/* Assume range doesn't cross this boundary */
 	if (address >= DRAM_BASE_ADDRESS)
-		return ath10k_pci_diag_read_mem(ar, address, data, sizeof(u32));
+		return ath10k_pci_diag_read32(ar, address, data);
 
 	*data = ath10k_pci_read32(ar, address);
 	return 0;
@@ -801,9 +834,7 @@ static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe)
 
 static void ath10k_pci_hif_dump_area(struct ath10k *ar)
 {
-	u32 reg_dump_area = 0;
 	u32 reg_dump_values[REG_DUMP_COUNT_QCA988X] = {};
-	u32 host_addr;
 	int ret;
 	u32 i;
 
@@ -812,21 +843,11 @@ static void ath10k_pci_hif_dump_area(struct ath10k *ar)
 		   ar->hw_params.name, ar->target_version);
 	ath10k_err("firmware version: %s\n", ar->hw->wiphy->fw_version);
 
-	host_addr = host_interest_item_address(HI_ITEM(hi_failure_state));
-	ret = ath10k_pci_diag_read_mem(ar, host_addr,
-				       &reg_dump_area, sizeof(u32));
+	ret = ath10k_pci_diag_read_hi(ar, &reg_dump_values[0],
+				      hi_failure_state,
+				      REG_DUMP_COUNT_QCA988X * sizeof(u32));
 	if (ret) {
-		ath10k_err("failed to read FW dump area address: %d\n", ret);
-		return;
-	}
-
-	ath10k_err("target register Dump Location: 0x%08X\n", reg_dump_area);
-
-	ret = ath10k_pci_diag_read_mem(ar, reg_dump_area,
-				       &reg_dump_values[0],
-				       REG_DUMP_COUNT_QCA988X * sizeof(u32));
-	if (ret != 0) {
-		ath10k_err("failed to read FW dump area: %d\n", ret);
+		ath10k_err("failed to read firmware dump area: %d\n", ret);
 		return;
 	}
 
author
#2 lore raw

PATCH v7 2/8 ath10k: provide firmware crash info via debugfs

In reply to Kalle Valo

From: Ben Greear <[email protected]>

Store the firmware crash registers and last 128 or so firmware debug-log ids and present them to user-space via debugfs.

Should help with figuring out why the firmware crashed.

---
 drivers/net/wireless/ath/ath10k/core.h  |   27 +++
 drivers/net/wireless/ath/ath10k/debug.c |  280 +++++++++++++++++++++++++++++++
 drivers/net/wireless/ath/ath10k/debug.h |   22 ++
 drivers/net/wireless/ath/ath10k/hw.h    |   29 +++
 drivers/net/wireless/ath/ath10k/pci.c   |  133 ++++++++++++++-
 drivers/net/wireless/ath/ath10k/pci.h   |    3 
 6 files changed, 481 insertions(+), 13 deletions(-)
drivers/net/wireless/ath/ath10k/core.h +27 -0
index cca6060dbf30..09c0a109368a 100644
@@ -22,6 +22,8 @@
 #include <linux/if_ether.h>
 #include <linux/types.h>
 #include <linux/pci.h>
+#include <linux/uuid.h>
+#include <linux/time.h>
 
 #include "htt.h"
 #include "htc.h"
@@ -278,6 +280,29 @@ struct ath10k_vif_iter {
 	struct ath10k_vif *arvif;
 };
 
+/* This will store at least the last 128 entries.  Each dbglog message
+ * is a max of 7 32-bit integers in length, but the length can be less
+ * than that as well.
+ */
+#define ATH10K_DBGLOG_DATA_LEN (128 * 7 * sizeof(u32))
+
+struct ath10k_dbglog_entry_storage {
+	/* where to write next chunk of data */
+	u32 next_idx;
+
+	u8 data[ATH10K_DBGLOG_DATA_LEN];
+};
+
+/* used for crash-dump storage, protected by data-lock */
+struct ath10k_fw_crash_data {
+	bool crashed_since_read;
+
+	uuid_le uuid;
+	struct timespec timestamp;
+	struct ath10k_dbglog_entry_storage dbglog_entry_data;
+	u32 reg_dump_values[REG_DUMP_COUNT_QCA988X];
+};
+
 struct ath10k_debug {
 	struct dentry *debugfs_phy;
 
@@ -295,6 +320,8 @@ struct ath10k_debug {
 
 	u8 htt_max_amsdu;
 	u8 htt_max_ampdu;
+
+	struct ath10k_fw_crash_data *fw_crash_data;
 };
 
 enum ath10k_state {
drivers/net/wireless/ath/ath10k/debug.c +277 -3

322 lines not on this page · raw message

drivers/net/wireless/ath/ath10k/debug.h +22 -0
index a5824990bd2a..80ff14e4db9b 100644
@@ -53,6 +53,10 @@ void ath10k_debug_read_service_map(struct ath10k *ar,
 				   size_t map_size);
 void ath10k_debug_read_target_stats(struct ath10k *ar,
 				    struct wmi_stats_event *ev);
+struct ath10k_fw_crash_data *
+ath10k_debug_get_new_fw_crash_data(struct ath10k *ar);
+
+void ath10k_debug_dbglog_add(struct ath10k *ar, u8 *buffer, int len);
 
 #define ATH10K_DFS_STAT_INC(ar, c) (ar->debug.dfs_stats.c++)
 
@@ -86,6 +90,17 @@ static inline void ath10k_debug_read_target_stats(struct ath10k *ar,
 {
 }
 
+static inline void ath10k_debug_dbglog_add(struct ath10k *ar, u8 *buffer,
+					   int len)
+{
+}
+
+static inline struct ath10k_fw_crash_data *
+ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
+{
+	return NULL;
+}
+
 #define ATH10K_DFS_STAT_INC(ar, c) do { } while (0)
 
 #endif /* CONFIG_ATH10K_DEBUGFS */
@@ -96,6 +111,7 @@ __printf(2, 3) void ath10k_dbg(enum ath10k_debug_mask mask,
 void ath10k_dbg_dump(enum ath10k_debug_mask mask,
 		     const char *msg, const char *prefix,
 		     const void *buf, size_t len);
+
 #else /* CONFIG_ATH10K_DEBUG */
 
 static inline int ath10k_dbg(enum ath10k_debug_mask dbg_mask,
@@ -109,5 +125,11 @@ static inline void ath10k_dbg_dump(enum ath10k_debug_mask mask,
 				   const void *buf, size_t len)
 {
 }
+
+static inline void ath10k_dbg_save_fw_dbg_buffer(struct ath10k *ar,
+						 u8 *buffer, int len)
+{
+}
 #endif /* CONFIG_ATH10K_DEBUG */
+
 #endif /* _DEBUG_H_ */
drivers/net/wireless/ath/ath10k/hw.h +29 -0
index ffd04890407e..c931cce17063 100644
@@ -39,6 +39,8 @@
 /* includes also the null byte */
 #define ATH10K_FIRMWARE_MAGIC               "QCA-ATH10K"
 
+#define REG_DUMP_COUNT_QCA988X 60
+
 struct ath10k_fw_ie {
 	__le32 id;
 	__le32 len;
@@ -362,4 +364,31 @@ enum ath10k_mcast2ucast_mode {
 
 #define RTC_STATE_V_GET(x) (((x) & RTC_STATE_V_MASK) >> RTC_STATE_V_LSB)
 
+
+/* Target debug log related defines and structs */
+
+/* Target is 32-bit CPU, so we just use u32 for
+ * the pointers.  The memory space is relative to the
+ * target, not the host.
+ */
+struct ath10k_fw_dbglog_buf {
+	/* pointer to dblog_buf_s */
+	u32 next;
+
+	/* pointer to u8 buffer */
+	u32 buffer;
+
+	u32 bufsize;
+	u32 length;
+	u32 count;
+	u32 free;
+} __packed;
+
+struct ath10k_fw_dbglog_hdr {
+	/* pointer to dbglog_buf_s */
+	u32 dbuf;
+
+	u32 dropped;
+} __packed;
+
 #endif /* _HW_H_ */
drivers/net/wireless/ath/ath10k/pci.c +126 -7

148 lines not on this page · raw message

drivers/net/wireless/ath/ath10k/pci.h +0 -3
index 662bca3922ef..294a72e01909 100644
@@ -23,9 +23,6 @@
 #include "hw.h"
 #include "ce.h"
 
-/* FW dump area */
-#define REG_DUMP_COUNT_QCA988X 60
-
 /*
  * maximum number of bytes that can be handled atomically by DiagRead/DiagWrite
  */
#3 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 11 lines · Kalle Valo

From: Ben Greear <[email protected]>

Store the firmware crash registers and last 128 or so firmware debug-log ids and present them to user-space via debugfs.

Should help with figuring out why the firmware crashed.

---

[...]

Quoted 21 lines
drivers/net/wireless/ath/ath10k/debug.c +21 -0
+struct ath10k_dump_file_data {
+       /* dump file information */
+
+       /* "ATH10K-FW-DUMP" */
+       char df_magic[16];
+
+       __le32 len;
+
+       /* file dump version */
+       __le32 version;
+
+       /* some info we can get from ath10k struct that might help */
+
+       u8 uuid[16];
+
+       __le32 chip_id;
+
+       /* 0 for now, in place for later hardware */
+       __le32 bus_type;
+
+       __le32 target_version;

drivers/net/wireless/ath/ath10k/debug.c line 85

Quoted 10 lines
drivers/net/wireless/ath/ath10k/debug.c +10 -0
+       __le32 fw_version_major;
+       __le32 fw_version_minor;
+       __le32 fw_version_release;
+       __le32 fw_version_build;
+       __le32 phy_capability;
+       __le32 hw_min_tx_power;
+       __le32 hw_max_tx_power;
+       __le32 ht_cap_info;
+       __le32 vht_cap_info;
+       __le32 num_rf_chains;

Hmm.. some of these values don't really change once driver is loaded so we could probably just export them as separate debugfs entries but perhaps that's an overkill just for dumping.

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 777

Quoted 12 lines
drivers/net/wireless/ath/ath10k/debug.c +12 -0
+
+       dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
+       strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
+               sizeof(dump_data->kernel_ver));
+
+       dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
+       dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
+
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 788

Quoted 11 lines
drivers/net/wireless/ath/ath10k/debug.c +11 -0
+       memcpy(dump_tlv->tlv_data, &crash_data->dbglog_entry_data,
+              sizeof(crash_data->dbglog_entry_data));
+       sofar += sizeof(*dump_tlv) + sizeof(crash_data->dbglog_entry_data);
+
+       /* Gather crash-dump */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGDUMP);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->reg_dump_values));
+       memcpy(dump_tlv->tlv_data, &crash_data->reg_dump_values,
+              sizeof(crash_data->reg_dump_values));
+       sofar += sizeof(*dump_tlv) + sizeof(crash_data->reg_dump_values);

I haven't seen you mention that your latest patchset is based on my patches that remove implicit byte swap from some diag functions so I infer you're might've missed that reg_dump_values will be byte swapped on big-endian hosts and userspace will remain unaware of that since there is no endianess indication in the crash dump structure anymore.

reg_dump_values must be swapped cpu_to_le32 here (or should be never implicit byte swapped in the first place).

It's probably worth stating in the comments that ATH10K_FW_CRASH_DUMP_REGDUMP returns a list of __le32.

drivers/net/wireless/ath/ath10k/pci.c static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe) · line 911

Quoted 11 lines
drivers/net/wireless/ath/ath10k/pci.c +11 -0
+               ret = ath10k_pci_diag_read_mem(ar, dbuf.buffer, buffer,
+                                              dbuf.length);
+               if (ret != 0) {
+                       ath10k_warn("failed to read debug log buffer from address 0x%x: %d\n",
+                                   dbuf.buffer, ret);
+                       kfree(buffer);
+                       return;
+               }
+
+               ath10k_debug_dbglog_add(ar, buffer, dbuf.length);
+               kfree(buffer);

Is the buffer really a string of bytes (u8) or just u32 in disguise? If it's the former then on big-endian host the implicit byte swap will mess it up and userspace will have no way of knowing that now.

Michał

#4 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 40 lines · Michal Kazior
Quoted 11 lines · Kalle Valo

From: Ben Greear <[email protected]>

Store the firmware crash registers and last 128 or so firmware debug-log ids and present them to user-space via debugfs.

Should help with figuring out why the firmware crashed.

---

[...]

Quoted 27 lines
drivers/net/wireless/ath/ath10k/debug.c +27 -0
+struct ath10k_dump_file_data {
+       /* dump file information */
+
+       /* "ATH10K-FW-DUMP" */
+       char df_magic[16];
+
+       __le32 len;
+
+       /* file dump version */
+       __le32 version;
+
+       /* some info we can get from ath10k struct that might help */
+
+       u8 uuid[16];
+
+       __le32 chip_id;
+
+       /* 0 for now, in place for later hardware */
+       __le32 bus_type;
+
+       __le32 target_version;
+       __le32 fw_version_major;
+       __le32 fw_version_minor;
+       __le32 fw_version_release;
+       __le32 fw_version_build;
+       __le32 phy_capability;
+       __le32 hw_min_tx_power;
Quoted 8 lines

drivers/net/wireless/ath/ath10k/debug.c line 85

Quoted 4 lines
drivers/net/wireless/ath/ath10k/debug.c +4 -0
+       __le32 hw_max_tx_power;
+       __le32 ht_cap_info;
+       __le32 vht_cap_info;
+       __le32 num_rf_chains;

Hmm.. some of these values don't really change once driver is loaded so we could probably just export them as separate debugfs entries but perhaps that's an overkill just for dumping.

I think it will be easier for all involved if there is a single dump image that has all needed info. Likely the end user of the dump file will have little or no interaction with the host that dumped the file to begin with.

Quoted 6 lines
Quoted 6 lines
drivers/net/wireless/ath/ath10k/debug.c +6 -0
+       dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
+       strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
+               sizeof(dump_data->kernel_ver));
+
+       dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
+       dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
Quoted 8 lines

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 777

Quoted 5 lines
drivers/net/wireless/ath/ath10k/debug.c +5 -0
+
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

Quoted 37 lines

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 788

Quoted 11 lines
drivers/net/wireless/ath/ath10k/debug.c +11 -0
+       memcpy(dump_tlv->tlv_data, &crash_data->dbglog_entry_data,
+              sizeof(crash_data->dbglog_entry_data));
+       sofar += sizeof(*dump_tlv) + sizeof(crash_data->dbglog_entry_data);
+
+       /* Gather crash-dump */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGDUMP);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->reg_dump_values));
+       memcpy(dump_tlv->tlv_data, &crash_data->reg_dump_values,
+              sizeof(crash_data->reg_dump_values));
+       sofar += sizeof(*dump_tlv) + sizeof(crash_data->reg_dump_values);

I haven't seen you mention that your latest patchset is based on my patches that remove implicit byte swap from some diag functions so I infer you're might've missed that reg_dump_values will be byte swapped on big-endian hosts and userspace will remain unaware of that since there is no endianess indication in the crash dump structure anymore.

reg_dump_values must be swapped cpu_to_le32 here (or should be never implicit byte swapped in the first place).

It's probably worth stating in the comments that ATH10K_FW_CRASH_DUMP_REGDUMP returns a list of __le32.

drivers/net/wireless/ath/ath10k/pci.c static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe) · line 911

Quoted 11 lines
drivers/net/wireless/ath/ath10k/pci.c +11 -0
+               ret = ath10k_pci_diag_read_mem(ar, dbuf.buffer, buffer,
+                                              dbuf.length);
+               if (ret != 0) {
+                       ath10k_warn("failed to read debug log buffer from address 0x%x: %d\n",
+                                   dbuf.buffer, ret);
+                       kfree(buffer);
+                       return;
+               }
+
+               ath10k_debug_dbglog_add(ar, buffer, dbuf.length);
+               kfree(buffer);
Quoted 3 lines

Is the buffer really a string of bytes (u8) or just u32 in disguise? If it's the former then on big-endian host the implicit byte swap will mess it up and userspace will have no way of knowing that now.

dbglog is array of 32 bit ints.

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
#5 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 15 lines · Ben Greear
Quoted 6 lines
Quoted 6 lines
drivers/net/wireless/ath/ath10k/debug.c +6 -0
+       dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
+       strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
+               sizeof(dump_data->kernel_ver));
+
+       dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
+       dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
Quoted 8 lines

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 777

Quoted 5 lines
drivers/net/wireless/ath/ath10k/debug.c +5 -0
+
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

Quoted 2 lines

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

I thought some more on this on the way to work..and I think it will not be easy to decode this if we do not know the starting point for the messages. Each report from firmware will start at the beginning of a message, so we either need to do a lot of memory copying, or play tricks with a circular buffer storage.

A long time ago, Kalle mentioned he didn't want any ability to decode the messages in the kernel, so the 'start' boundary will need to be the start of the message(s) received from firmware.

This means that the ath10k_debug_dbglog_add will need to be improved to handle wraps more intelligently, somehow.

This series has taken a long time already, so it would be fine with me to deal with the dbglog cleanup in subsequent patches, and just assume for now that the dbglog messages start at index 0 in the dbglog-entry-data.

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
author
#6 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 3 lines · Ben Greear

This series has taken a long time already, so it would be fine with me to deal with the dbglog cleanup in subsequent patches, and just assume for now that the dbglog messages start at index 0 in the dbglog-entry-data.

I also would like to get this support finally in. As the basic infrastructure seems to be mostly ok, I'm planning to split the patchset into two and the first containing just the basic infrastructure and register dump:

	ATH10K_FW_CRASH_DUMP_REGDUMP = 1,

Which I'll actually rename to ATH10K_FW_CRASH_DUMP_REGISTERS. And I'll also fix the endian problem Michal pointed out.

And then we can later add the rest, once they are properly tested and the endian issues are solved:

	ATH10K_FW_CRASH_DUMP_DBGLOG = 0,
	ATH10K_FW_CRASH_DUMP_STACK = 2,
	ATH10K_FW_CRASH_DUMP_EXC_STACK = 3,
	ATH10K_FW_CRASH_DUMP_RAM_BSS = 4,
	ATH10K_FW_CRASH_DUMP_ROM_BSS = 5,

And as we use TLV format this split doesn't break anything in user space. How does that sound?

Signature · 1 line
Kalle Valo
#7 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

In reply to Ben Greear
Quoted 2 lines · Ben Greear
Quoted 1 line · Michal Kazior

On 19 August 2014 10:22, Kalle Valo <[email protected]> wrote:

[...]

Quoted 18 lines
Quoted 13 lines

drivers/net/wireless/ath/ath10k/debug.c line 85

Quoted 11 lines
drivers/net/wireless/ath/ath10k/debug.c +11 -0
+       __le32 target_version;
+       __le32 fw_version_major;
+       __le32 fw_version_minor;
+       __le32 fw_version_release;
+       __le32 fw_version_build;
+       __le32 phy_capability;
+       __le32 hw_min_tx_power;
+       __le32 hw_max_tx_power;
+       __le32 ht_cap_info;
+       __le32 vht_cap_info;
+       __le32 num_rf_chains;
Quoted 3 lines

Hmm.. some of these values don't really change once driver is loaded so we could probably just export them as separate debugfs entries but perhaps that's an overkill just for dumping.

Quoted 5 lines

I think it will be easier for all involved if there is a single dump image that
has all needed info. Likely the end user of the dump file will have little or no
interaction with the host that dumped the file to begin with.

I think there's been this idea about moving dumping to udev somewhat, no? Since this is just debugfs then I imagine you could have a userspace program that would create the single blob/crash report from things it thinks is important, e.g.. uname -a, debugfs entries (fw stack traces, dbglog, etc), recent kernel log buffer, etc. It could even all be stored in plaintext (with binary data encoded as a hexdump). But that, I guess, could be cumbersome, at least initially, until all major distros adapt.

Quoted 19 lines
Quoted 17 lines
Quoted 12 lines
drivers/net/wireless/ath/ath10k/debug.c +11 -0
+       dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
+       strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
+               sizeof(dump_data->kernel_ver));
+
+       dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
+       dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
+
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len =
Quoted 1 line

cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

Quoted 2 lines

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

So basically a (length, payload) encoding would be necessary here instead of a single stream, right?

Quoted 14 lines
Quoted 14 lines
Quoted 12 lines
drivers/net/wireless/ath/ath10k/pci.c +4 -0
+               ret = ath10k_pci_diag_read_mem(ar, dbuf.buffer, buffer,
+                                              dbuf.length);
+               if (ret != 0) {
+                       ath10k_warn("failed to read debug log buffer from

address 0x%x: %d\n",

drivers/net/wireless/ath/ath10k/pci.c +7 -0
+                                   dbuf.buffer, ret);
+                       kfree(buffer);
+                       return;
+               }
+
+               ath10k_debug_dbglog_add(ar, buffer, dbuf.length);
+               kfree(buffer);
Quoted 6 lines
Quoted 3 lines

Is the buffer really a string of bytes (u8) or just u32 in disguise? If it's the former then on big-endian host the implicit byte swap will mess it up and userspace will have no way of knowing that now.

dbglog is array of 32 bit ints.

Thanks, this clears things. Then it is necessary to byte-swap cpu_to_le32 before calling debug_dbglog_add.

Michał

author
#8 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 22 lines · Michal Kazior
Quoted 2 lines · Ben Greear
Quoted 1 line · Michal Kazior

On 19 August 2014 10:22, Kalle Valo <[email protected]> wrote:

[...]

Quoted 18 lines
Quoted 16 lines

drivers/net/wireless/ath/ath10k/debug.c line 85

Quoted 11 lines
drivers/net/wireless/ath/ath10k/debug.c +11 -0
+       __le32 target_version;
+       __le32 fw_version_major;
+       __le32 fw_version_minor;
+       __le32 fw_version_release;
+       __le32 fw_version_build;
+       __le32 phy_capability;
+       __le32 hw_min_tx_power;
+       __le32 hw_max_tx_power;
+       __le32 ht_cap_info;
+       __le32 vht_cap_info;
+       __le32 num_rf_chains;

Hmm.. some of these values don't really change once driver is loaded so we could probably just export them as separate debugfs entries but perhaps that's an overkill just for dumping.

Quoted 8 lines
Quoted 5 lines

I think it will be easier for all involved if there is a single dump image that
has all needed info. Likely the end user of the dump file will have little or no
interaction with the host that dumped the file to begin with.

I think there's been this idea about moving dumping to udev somewhat, no?

Yeah. But I'm thinking that should just signal user space that there's a new crash dump available, nothing else.

Quoted 7 lines

Since this is just debugfs then I imagine you could have a userspace program that would create the single blob/crash report from things it thinks is important, e.g.. uname -a, debugfs entries (fw stack traces, dbglog, etc), recent kernel log buffer, etc. It could even all be stored in plaintext (with binary data encoded as a hexdump). But that, I guess, could be cumbersome, at least initially, until all major distros adapt.

Sure, we can push lots of this to user space. But what's the point?

With the current approach we get a self-contained crash dump which the user (be it a real person or automated) can store with a simple file copy operatation and can be easily post-processed afterwards. What you propose is a lot of work for everyone, most likely even more bugs and without any clear benefits. At least the memory consumption should be the same (if not even increase due to increased complexity).

Signature · 1 line
Kalle Valo
author
#9 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 8 lines · Kalle Valo
Quoted 7 lines

Since this is just debugfs then I imagine you could have a userspace program that would create the single blob/crash report from things it thinks is important, e.g.. uname -a, debugfs entries (fw stack traces, dbglog, etc), recent kernel log buffer, etc. It could even all be stored in plaintext (with binary data encoded as a hexdump). But that, I guess, could be cumbersome, at least initially, until all major distros adapt.

Quoted 8 lines

Sure, we can push lots of this to user space. But what's the point?

With the current approach we get a self-contained crash dump which the user (be it a real person or automated) can store with a simple file copy operatation and can be easily post-processed afterwards. What you propose is a lot of work for everyone, most likely even more bugs and without any clear benefits. At least the memory consumption should be the same (if not even increase due to increased complexity).

I forgot to mention that also I would not want to rely on debugfs except at the moment to deliver the dump to user space. I'm hoping that we would get a generic firmware crash dump support to cfg80211 (hopefully we can talk about that in Dusseldorf) and we might switch to ethtool or some another user space interface. Then it might be possible to enable this even without debugfs, if we are happy to take the hit on memory use.

Signature · 1 line
Kalle Valo
#10 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

In reply to Michal Kazior
Quoted 10 lines
Quoted 7 lines
Quoted 3 lines

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

So basically a (length, payload) encoding would be necessary here instead of a single stream, right?

As long as you know the starting point for a message, you can decode the rest of the message(s) as a stream of 32 bit ints. The current code that I wrote is a circular buffer, so after first wrap, we lose an idea of where to start reading.

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
author
#11 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

In reply to Ben Greear
Quoted 10 lines · Ben Greear
Quoted 7 lines

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 777

Quoted 4 lines
drivers/net/wireless/ath/ath10k/debug.c +4 -0
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

I really don't like the idea of having untested code in ath10k. Buggy code is okay (preferably document the known bugs when submitting code), but untested code is not.

Signature · 1 line
Kalle Valo
#12 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 10 lines · Kalle Valo
Quoted 8 lines · Ben Greear
Quoted 7 lines

drivers/net/wireless/ath/ath10k/debug.c static const struct file_operations fops_chip_id = { · line 777

Quoted 4 lines
drivers/net/wireless/ath/ath10k/debug.c +4 -0
+       /* Gather dbg-log */
+       dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+       dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG);
+       dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

Quoted 6 lines
Quoted 2 lines

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

I really don't like the idea of having untested code in ath10k. Buggy code is okay (preferably document the known bugs when submitting code), but untested code is not.

It would be quite a waste of time to keep re-writing a user-space dump tool while the patch set is in this much churn, I think.

It's not like ath10k is going to blow up, but maybe the decode is less useful in that we cannot actually get a useful debuglog decode until the problem is resolved. We get zero firmware dbglog messages currently, so nothing is lost.

When at least the first patch or two is in, and endian issue is resolved, I'll write a decode tool (or modify the one I have that parses /var/log/messages to deal with the new binary dump file).

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
author
#13 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 15 lines · Ben Greear
Quoted 6 lines · Kalle Valo
Quoted 4 lines · Ben Greear
Quoted 4 lines
Quoted 4 lines

+ /* Gather dbg-log */ + dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar); + dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG); + dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Quoted 7 lines
Quoted 4 lines
Quoted 2 lines

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

I really don't like the idea of having untested code in ath10k. Buggy code is okay (preferably document the known bugs when submitting code), but untested code is not.

Quoted 7 lines

It would be quite a waste of time to keep re-writing a user-space dump tool while the patch set is in this much churn, I think.

It's not like ath10k is going to blow up, but maybe the decode is less useful in that we cannot actually get a useful debuglog decode until the problem is resolved. We get zero firmware dbglog messages currently, so nothing is lost.

Of course ath10k won't blow up, but every patch and every line of code increases the maintenance cost. For example, if I had known that the dbglog dump in your patchset doesn't work at all, I would have dropped it immediately and saved a lot of time of everyone's time, especially mine.

So next time you send me untested code PLEASE clearly mention that. I assume that the developer has tested the submitted code well enough that it really works. Hoping it to work is not enough! Unless you are Johannes, Linus or Davem :)

Signature · 1 line
Kalle Valo
#14 lore raw

Re: [PATCH v7 2/8] ath10k: provide firmware crash info via debugfs

Quoted 31 lines · Kalle Valo
Quoted 15 lines · Ben Greear
Quoted 6 lines · Kalle Valo
Quoted 4 lines · Ben Greear
Quoted 4 lines
Quoted 4 lines

+ /* Gather dbg-log */ + dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar); + dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_DBGLOG); + dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->dbglog_entry_data));

Quoted 7 lines
Quoted 4 lines
Quoted 2 lines

Hmm should this really be sizeof()? Not next_idx (which effectively defines number of bytes of the dbglog)?

I haven't tried decoding this yet, but we may need to know the next_idx to decode this properly.

I really don't like the idea of having untested code in ath10k. Buggy code is okay (preferably document the known bugs when submitting code), but untested code is not.

Quoted 7 lines

It would be quite a waste of time to keep re-writing a user-space dump tool while the patch set is in this much churn, I think.

It's not like ath10k is going to blow up, but maybe the decode is less useful in that we cannot actually get a useful debuglog decode until the problem is resolved. We get zero firmware dbglog messages currently, so nothing is lost.

Of course ath10k won't blow up, but every patch and every line of code increases the maintenance cost. For example, if I had known that the dbglog dump in your patchset doesn't work at all, I would have dropped it immediately and saved a lot of time of everyone's time, especially mine.

Quoted 4 lines

So next time you send me untested code PLEASE clearly mention that. I assume that the developer has tested the submitted code well enough that it really works. Hoping it to work is not enough! Unless you are Johannes, Linus or Davem :)

I know that I mentioned I have not actually written the decode tool. I did test my original patches to make sure they properly dumped a data file and did not crash the kernel or otherwise muck up the driver.

And, actually I think I could make a decode tool able to decode the dbglog as written, especially if the next-idx is included...the messages are normalized enough that I can just read ints until I find something that is a legit start of message. Not super clean, but kernel would remain simpler.

I think we would make more progress if we were slightly less picky on style issues and details for patches, and just make more improvements after the initial patches go in. It would certainly make it easier to do things like write and test and improve the decode tool.

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
author
#15 lore raw

PATCH v7 3/8 ath10k: save firmware debug log messages

In reply to Kalle Valo

From: Ben Greear <[email protected]>

They may be dumped through the firmware dump debugfs file.

---
 drivers/net/wireless/ath/ath10k/wmi.c |   10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/net/wireless/ath/ath10k/wmi.c +10 -0
index 23acbadeb8fa..eafc565240f1 100644
@@ -1290,6 +1290,16 @@ static int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb)
 
 	trace_ath10k_wmi_dbglog(skb->data, skb->len);
 
+	spin_lock_bh(&ar->data_lock);
+
+	/* First 4 bytes are a messages-dropped-due-to-overflow counter,
+	 * and should not be recorded in the dbglog buffer, so we skip
+	 * them.
+	 */
+	ath10k_debug_dbglog_add(ar, skb->data + 4, skb->len - 4);
+
+	spin_unlock_bh(&ar->data_lock);
+
 	return 0;
 }
 
#16 lore raw

Re: [PATCH v7 3/8] ath10k: save firmware debug log messages

Quoted 37 lines · Kalle Valo

From: Ben Greear <[email protected]>

They may be dumped through the firmware dump debugfs file.

---
 drivers/net/wireless/ath/ath10k/wmi.c |   10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/net/wireless/ath/ath10k/wmi.c +10 -1
index 23acbadeb8fa..eafc565240f1 100644
@@ -1290,6 +1290,16 @@ static int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb)
 
        trace_ath10k_wmi_dbglog(skb->data, skb->len);
 
+       spin_lock_bh(&ar->data_lock);
+
+       /* First 4 bytes are a messages-dropped-due-to-overflow counter,
+        * and should not be recorded in the dbglog buffer, so we skip
+        * them.
+        */
+       ath10k_debug_dbglog_add(ar, skb->data + 4, skb->len - 4);
+
+       spin_unlock_bh(&ar->data_lock);
+
        return 0;
 }
 
 
--

To unsubscribe from this list: send the line "unsubscribe linux-wireless" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#17 lore raw

Re: [PATCH v7 3/8] ath10k: save firmware debug log messages

On 19 August 2014 11:39, Michal Kazior <[email protected]> wrote:

I miss-clicked, sorry for the noise.

Quoted 20 lines · Kalle Valo
Quoted 19 lines

From: Ben Greear <[email protected]>

They may be dumped through the firmware dump debugfs file.

---
 drivers/net/wireless/ath/ath10k/wmi.c |   10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/net/wireless/ath/ath10k/wmi.c +0 -0
index 23acbadeb8fa..eafc565240f1 100644
@@ -1290,6 +1290,16 @@ static int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb)
 
        trace_ath10k_wmi_dbglog(skb->data, skb->len);
 
Quoted 7 lines

drivers/net/wireless/ath/ath10k/wmi.c static int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb) · line 1299

Quoted 7 lines
drivers/net/wireless/ath/ath10k/wmi.c +7 -0
+       spin_lock_bh(&ar->data_lock);
+
+       /* First 4 bytes are a messages-dropped-due-to-overflow counter,
+        * and should not be recorded in the dbglog buffer, so we skip
+        * them.
+        */
+       ath10k_debug_dbglog_add(ar, skb->data + 4, skb->len - 4);

Can't we just:

struct wmi_dbg_msg {
__le32 num_dropped_due_to_overflow;
u8 payload[0]; // is this an array of u8 or __le32 actually?
};

Michał

#18 lore raw

Re: [PATCH v7 3/8] ath10k: save firmware debug log messages

Quoted 9 lines
Quoted 8 lines

drivers/net/wireless/ath/ath10k/wmi.c static int ath10k_wmi_event_debug_mesg(struct ath10k *ar, struct sk_buff *skb) · line 1299

Quoted 8 lines
drivers/net/wireless/ath/ath10k/wmi.c +7 -0
+       spin_lock_bh(&ar->data_lock);
+
+       /* First 4 bytes are a messages-dropped-due-to-overflow counter,
+        * and should not be recorded in the dbglog buffer, so we skip
+        * them.
+        */
+       ath10k_debug_dbglog_add(ar, skb->data + 4, skb->len - 4);
Quoted 6 lines

Can't we just:

struct wmi_dbg_msg {
__le32 num_dropped_due_to_overflow;
u8 payload[0]; // is this an array of u8 or __le32 actually?
};

When I wrote this, I was more paranoid about exposing
any possible details of firmware. It is an array of 32-bit ints in firmware, and it decodes as ints instead of bytes, so probably u32 payload instead of u8.

Thanks,
Ben

Signature · 2 lines
Ben Greear <[email protected]>
Candela Technologies Inc  http://www.candelatech.com
author
#19 lore raw

PATCH v7 4/8 ath10k: save firmware stack upon firmware crash

In reply to Kalle Valo

From: Ben Greear <[email protected]>

Should help debug firmware crashes, and give users a way to provide some useful debug reports to firmware developers.

---
 drivers/net/wireless/ath/ath10k/core.h  |    1 +
 drivers/net/wireless/ath/ath10k/debug.c |   12 ++++++++++++
 drivers/net/wireless/ath/ath10k/hw.h    |    1 +
 drivers/net/wireless/ath/ath10k/pci.c   |   13 +++++++++++++
 4 files changed, 27 insertions(+)
drivers/net/wireless/ath/ath10k/core.h +1 -0
index 09c0a109368a..c397b064b72d 100644
@@ -301,6 +301,7 @@ struct ath10k_fw_crash_data {
 	struct timespec timestamp;
 	struct ath10k_dbglog_entry_storage dbglog_entry_data;
 	u32 reg_dump_values[REG_DUMP_COUNT_QCA988X];
+	u8 stack_buf[ATH10K_FW_STACK_SIZE];
 };
 
 struct ath10k_debug {
drivers/net/wireless/ath/ath10k/debug.c +12 -0
index 8c3f9acd6492..faf3d36dbdeb 100644
@@ -33,10 +33,12 @@
  * enum ath10k_fw_crash_dump_type - types of data in the dump file
  * @ATH10K_FW_CRASH_DUMP_DBGLOG:  Recent firmware debug log entries
  * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
+ * @ATH10K_FW_CRASH_DUMP_STACK:   Stack memory contents.
  */
 enum ath10k_fw_crash_dump_type {
 	ATH10K_FW_CRASH_DUMP_DBGLOG = 0,
 	ATH10K_FW_CRASH_DUMP_REGDUMP = 1,
+	ATH10K_FW_CRASH_DUMP_STACK = 2,
 
 	ATH10K_FW_CRASH_DUMP_MAX,
 };
@@ -721,6 +723,7 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	len = hdr_len;
 	len += sizeof(*dump_tlv) + sizeof(crash_data->reg_dump_values);
 	len += sizeof(*dump_tlv) + sizeof(crash_data->dbglog_entry_data);
+	len += sizeof(*dump_tlv) + sizeof(crash_data->stack_buf);
 
 	sofar += hdr_len;
 
@@ -787,10 +790,19 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	       sizeof(crash_data->reg_dump_values));
 	sofar += sizeof(*dump_tlv) + sizeof(crash_data->reg_dump_values);
 
+	/* Gather firmware stack dump */
+	dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+	dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_STACK);
+	dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->stack_buf));
+	memcpy(dump_tlv->tlv_data, crash_data->stack_buf,
+	       sizeof(crash_data->stack_buf));
+	sofar += sizeof(*dump_tlv) + sizeof(crash_data->stack_buf);
+
 	ar->debug.fw_crash_data->crashed_since_read = false;
 
 	spin_unlock_bh(&ar->data_lock);
 
+	WARN_ON(sofar != len);
 	return dump_data;
 }
 
drivers/net/wireless/ath/ath10k/hw.h +1 -0
index c931cce17063..db52a55e5bd1 100644
@@ -40,6 +40,7 @@
 #define ATH10K_FIRMWARE_MAGIC               "QCA-ATH10K"
 
 #define REG_DUMP_COUNT_QCA988X 60
+#define ATH10K_FW_STACK_SIZE 4096
 
 struct ath10k_fw_ie {
 	__le32 id;
drivers/net/wireless/ath/ath10k/pci.c +13 -0
index 41ff620e1af2..81897b2db49f 100644
@@ -832,6 +832,18 @@ static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe)
 	return ath10k_ce_num_free_src_entries(ar_pci->pipe_info[pipe].ce_hdl);
 }
 
+/* Save the main firmware stack */
+static void ath10k_pci_dump_stack(struct ath10k *ar,
+				  struct ath10k_fw_crash_data *crash_data)
+{
+	lockdep_assert_held(&ar->data_lock);
+
+	BUILD_BUG_ON(ATH10K_FW_STACK_SIZE % 4);
+
+	ath10k_pci_diag_read_hi(ar, crash_data->stack_buf,
+				hi_stack, ATH10K_FW_STACK_SIZE);
+}
+
 static void ath10k_pci_dump_dbglog(struct ath10k *ar,
 				   struct ath10k_fw_crash_data *crash_data)
 {
@@ -975,6 +987,7 @@ static void ath10k_pci_hif_dump_area(struct ath10k *ar)
 	if (!crash_data)
 		goto exit;
 
+	ath10k_pci_dump_stack(ar, crash_data);
 	ath10k_pci_dump_registers(ar, crash_data);
 	ath10k_pci_dump_dbglog(ar, crash_data);
 
#20 lore raw

Re: [PATCH v7 4/8] ath10k: save firmware stack upon firmware crash

Quoted 8 lines · Kalle Valo

From: Ben Greear <[email protected]>

Should help debug firmware crashes, and give users a way to provide some useful debug reports to firmware developers.

---

[...]

drivers/net/wireless/ath/ath10k/pci.c static u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe) · line 844

Quoted 10 lines
drivers/net/wireless/ath/ath10k/pci.c +10 -0
+/* Save the main firmware stack */
+static void ath10k_pci_dump_stack(struct ath10k *ar,
+                                 struct ath10k_fw_crash_data *crash_data)
+{
+       lockdep_assert_held(&ar->data_lock);
+
+       BUILD_BUG_ON(ATH10K_FW_STACK_SIZE % 4);
+
+       ath10k_pci_diag_read_hi(ar, crash_data->stack_buf,
+                               hi_stack, ATH10K_FW_STACK_SIZE);

Current master tree performs an implicit byte swap so the stack read from target will be in host endianess. IOW on big-endian host you'll messed up data and there's no indication of endianess anymore.

Michał

author
#21 lore raw

PATCH v7 5/8 ath10k: dump exception stack contents on firmware crash

In reply to Kalle Valo

From: Ben Greear <[email protected]>

Firmware developers can decode this and maybe figure out why the firmware crashed.

---
 drivers/net/wireless/ath/ath10k/core.h  |    1 +
 drivers/net/wireless/ath/ath10k/debug.c |   11 +++++++++++
 drivers/net/wireless/ath/ath10k/pci.c   |   13 +++++++++++++
 3 files changed, 25 insertions(+)
drivers/net/wireless/ath/ath10k/core.h +1 -0
index c397b064b72d..34d6d255cca7 100644
@@ -302,6 +302,7 @@ struct ath10k_fw_crash_data {
 	struct ath10k_dbglog_entry_storage dbglog_entry_data;
 	u32 reg_dump_values[REG_DUMP_COUNT_QCA988X];
 	u8 stack_buf[ATH10K_FW_STACK_SIZE];
+	u8 exc_stack_buf[ATH10K_FW_STACK_SIZE];
 };
 
 struct ath10k_debug {
drivers/net/wireless/ath/ath10k/debug.c +11 -0
index faf3d36dbdeb..3a24b4fec6ce 100644
@@ -34,11 +34,13 @@
  * @ATH10K_FW_CRASH_DUMP_DBGLOG:  Recent firmware debug log entries
  * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
  * @ATH10K_FW_CRASH_DUMP_STACK:   Stack memory contents.
+ * @ATH10K_FW_CRASH_DUMP_EXC_STACK:  Exception stack contents
  */
 enum ath10k_fw_crash_dump_type {
 	ATH10K_FW_CRASH_DUMP_DBGLOG = 0,
 	ATH10K_FW_CRASH_DUMP_REGDUMP = 1,
 	ATH10K_FW_CRASH_DUMP_STACK = 2,
+	ATH10K_FW_CRASH_DUMP_EXC_STACK = 3,
 
 	ATH10K_FW_CRASH_DUMP_MAX,
 };
@@ -724,6 +726,7 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	len += sizeof(*dump_tlv) + sizeof(crash_data->reg_dump_values);
 	len += sizeof(*dump_tlv) + sizeof(crash_data->dbglog_entry_data);
 	len += sizeof(*dump_tlv) + sizeof(crash_data->stack_buf);
+	len += sizeof(*dump_tlv) + sizeof(crash_data->exc_stack_buf);
 
 	sofar += hdr_len;
 
@@ -798,6 +801,14 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	       sizeof(crash_data->stack_buf));
 	sofar += sizeof(*dump_tlv) + sizeof(crash_data->stack_buf);
 
+	/* Gather firmware exception (irq) stack dump */
+	dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+	dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_EXC_STACK);
+	dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->exc_stack_buf));
+	memcpy(dump_tlv->tlv_data, &crash_data->exc_stack_buf,
+	       sizeof(crash_data->exc_stack_buf));
+	sofar += sizeof(*dump_tlv) + sizeof(crash_data->exc_stack_buf);
+
 	ar->debug.fw_crash_data->crashed_since_read = false;
 
 	spin_unlock_bh(&ar->data_lock);
drivers/net/wireless/ath/ath10k/pci.c +13 -0
index 81897b2db49f..8266cc94f718 100644
@@ -844,6 +844,18 @@ static void ath10k_pci_dump_stack(struct ath10k *ar,
 				hi_stack, ATH10K_FW_STACK_SIZE);
 }
 
+/* Save the firmware exception stack */
+static void ath10k_pci_dump_exc_stack(struct ath10k *ar,
+				      struct ath10k_fw_crash_data *crash_data)
+{
+	lockdep_assert_held(&ar->data_lock);
+
+	BUILD_BUG_ON(ATH10K_FW_STACK_SIZE % 4);
+
+	ath10k_pci_diag_read_hi(ar, crash_data->exc_stack_buf,
+				hi_err_stack, ATH10K_FW_STACK_SIZE);
+}
+
 static void ath10k_pci_dump_dbglog(struct ath10k *ar,
 				   struct ath10k_fw_crash_data *crash_data)
 {
@@ -988,6 +1000,7 @@ static void ath10k_pci_hif_dump_area(struct ath10k *ar)
 		goto exit;
 
 	ath10k_pci_dump_stack(ar, crash_data);
+	ath10k_pci_dump_exc_stack(ar, crash_data);
 	ath10k_pci_dump_registers(ar, crash_data);
 	ath10k_pci_dump_dbglog(ar, crash_data);
 
#22 lore raw

Re: [PATCH v7 5/8] ath10k: dump exception stack contents on firmware crash

Quoted 8 lines · Kalle Valo

From: Ben Greear <[email protected]>

Firmware developers can decode this and maybe figure out why the firmware crashed.

---

[...]

drivers/net/wireless/ath/ath10k/pci.c static void ath10k_pci_dump_stack(struct ath10k *ar, · line 856

Quoted 10 lines
drivers/net/wireless/ath/ath10k/pci.c +10 -0
+/* Save the firmware exception stack */
+static void ath10k_pci_dump_exc_stack(struct ath10k *ar,
+                                     struct ath10k_fw_crash_data *crash_data)
+{
+       lockdep_assert_held(&ar->data_lock);
+
+       BUILD_BUG_ON(ATH10K_FW_STACK_SIZE % 4);
+
+       ath10k_pci_diag_read_hi(ar, crash_data->exc_stack_buf,
+                               hi_err_stack, ATH10K_FW_STACK_SIZE);

Current master tree performs an implicit byte swap so the stack read from target will be in host endianess. IOW on big-endian host you'll messed up data and there's no indication of endianess anymore.

Michał

author
#23 lore raw

PATCH v7 6/8 ath10k: save firmware RAM and ROM BSS sections on crash

In reply to Kalle Valo

From: Ben Greear <[email protected]>

This can be used to get a useful back trace out of a firmware crash that involves an interrupt handler. For instance, a null-pointer-exception would be this kind of trace. A user-space tool can read the debugfs file and decode things as wished.

This requires a packaged firmware with a new IE to describe the BSS section starts and length.

---
 drivers/net/wireless/ath/ath10k/core.c  |   54 +++++++++++++++++++++++++++++++
 drivers/net/wireless/ath/ath10k/core.h  |   16 +++++++++
 drivers/net/wireless/ath/ath10k/debug.c |   28 ++++++++++++++++
 drivers/net/wireless/ath/ath10k/hw.h    |    4 ++
 drivers/net/wireless/ath/ath10k/pci.c   |   43 +++++++++++++++++++++++++
 5 files changed, 145 insertions(+)
drivers/net/wireless/ath/ath10k/core.c +54 -0
index ba2e87ab19bd..1472c0a767e2 100644
@@ -479,6 +479,60 @@ static int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name)
 			ar->otp_len = ie_len;
 
 			break;
+		case ATH10K_FW_IE_RAM_BSS_ADDR:
+			if (ie_len != sizeof(u32))
+				break;
+
+			ar->fw.ram_bss_addr = le32_to_cpup((__le32 *)data);
+
+			ath10k_dbg(ATH10K_DBG_BOOT,
+				   "found RAM BSS address 0x%x\n",
+				   ar->fw.ram_bss_addr);
+			break;
+		case ATH10K_FW_IE_RAM_BSS_LEN:
+			if (ie_len != sizeof(u32))
+				break;
+
+			ar->fw.ram_bss_len = le32_to_cpup((__le32 *)data);
+
+			ath10k_dbg(ATH10K_DBG_BOOT,
+				   "found RAM BSS length 0x%x\n",
+				   ar->fw.ram_bss_len);
+
+			if (ar->fw.ram_bss_len > ATH10K_RAM_BSS_BUF_LEN) {
+				ath10k_warn("too long firmware RAM BSS length: %d\n",
+					    ar->fw.ram_bss_len);
+				ar->fw.ram_bss_len = 0;
+			}
+
+			break;
+		case ATH10K_FW_IE_ROM_BSS_ADDR:
+			if (ie_len != sizeof(u32))
+				break;
+
+			ar->fw.rom_bss_addr = le32_to_cpup((__le32 *)data);
+
+			ath10k_dbg(ATH10K_DBG_BOOT,
+				   "found ROM BSS address 0x%x\n",
+				   ar->fw.rom_bss_addr);
+			break;
+		case ATH10K_FW_IE_ROM_BSS_LEN:
+			if (ie_len != sizeof(u32))
+				break;
+
+			ar->fw.rom_bss_len = le32_to_cpup((__le32 *)data);
+
+			ath10k_dbg(ATH10K_DBG_BOOT,
+				   "found ROM BSS length 0x%x\n",
+				   ar->fw.rom_bss_len);
+
+			if (ar->fw.ram_bss_len > ATH10K_RAM_BSS_BUF_LEN) {
+				ath10k_warn("too long firmware RAM BSS length: %d\n",
+					    ar->fw.ram_bss_len);
+				ar->fw.rom_bss_len = 0;
+			}
+
+			break;
 		default:
 			ath10k_warn("Unknown FW IE: %u\n",
 				    le32_to_cpu(hdr->id));
drivers/net/wireless/ath/ath10k/core.h +16 -0
index 34d6d255cca7..31bf18c588c7 100644
@@ -293,6 +293,10 @@ struct ath10k_dbglog_entry_storage {
 	u8 data[ATH10K_DBGLOG_DATA_LEN];
 };
 
+/* estimated values, hopefully these are enough */
+#define ATH10K_ROM_BSS_BUF_LEN 10000
+#define ATH10K_RAM_BSS_BUF_LEN 30000
+
 /* used for crash-dump storage, protected by data-lock */
 struct ath10k_fw_crash_data {
 	bool crashed_since_read;
@@ -303,6 +307,9 @@ struct ath10k_fw_crash_data {
 	u32 reg_dump_values[REG_DUMP_COUNT_QCA988X];
 	u8 stack_buf[ATH10K_FW_STACK_SIZE];
 	u8 exc_stack_buf[ATH10K_FW_STACK_SIZE];
+
+	u8 rom_bss_buf[ATH10K_ROM_BSS_BUF_LEN];
+	u8 ram_bss_buf[ATH10K_RAM_BSS_BUF_LEN];
 };
 
 struct ath10k_debug {
@@ -450,6 +457,15 @@ struct ath10k {
 		} fw;
 	} hw_params;
 
+	/* These are written to only during first firmware load from user
+	 * space so no need for any locking. */
+	struct {
+		u32 ram_bss_addr;
+		u32 ram_bss_len;
+		u32 rom_bss_addr;
+		u32 rom_bss_len;
+	} fw;
+
 	const struct firmware *board;
 	const void *board_data;
 	size_t board_len;
drivers/net/wireless/ath/ath10k/debug.c +28 -0
index 3a24b4fec6ce..67bb53c64ead 100644
@@ -35,12 +35,16 @@
  * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
  * @ATH10K_FW_CRASH_DUMP_STACK:   Stack memory contents.
  * @ATH10K_FW_CRASH_DUMP_EXC_STACK:  Exception stack contents
+ * @ATH10K_FW_CRASH_DUMP_RAM_BSS:  BSS area for RAM code
+ * @ATH10K_FW_CRASH_DUMP_ROM_BSS:  BSS area for ROM code
  */
 enum ath10k_fw_crash_dump_type {
 	ATH10K_FW_CRASH_DUMP_DBGLOG = 0,
 	ATH10K_FW_CRASH_DUMP_REGDUMP = 1,
 	ATH10K_FW_CRASH_DUMP_STACK = 2,
 	ATH10K_FW_CRASH_DUMP_EXC_STACK = 3,
+	ATH10K_FW_CRASH_DUMP_RAM_BSS = 4,
+	ATH10K_FW_CRASH_DUMP_ROM_BSS = 5,
 
 	ATH10K_FW_CRASH_DUMP_MAX,
 };
@@ -728,6 +732,12 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	len += sizeof(*dump_tlv) + sizeof(crash_data->stack_buf);
 	len += sizeof(*dump_tlv) + sizeof(crash_data->exc_stack_buf);
 
+	if (ar->fw.ram_bss_addr && ar->fw.ram_bss_len)
+		len += sizeof(*dump_tlv) + ar->fw.ram_bss_len;
+
+	if (ar->fw.rom_bss_addr && ar->fw.rom_bss_len)
+		len += sizeof(*dump_tlv) + ar->fw.rom_bss_len;
+
 	sofar += hdr_len;
 
 	/* This is going to get big when we start dumping FW RAM and such,
@@ -809,6 +819,24 @@ static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 	       sizeof(crash_data->exc_stack_buf));
 	sofar += sizeof(*dump_tlv) + sizeof(crash_data->exc_stack_buf);
 
+	if (ar->fw.ram_bss_addr && ar->fw.ram_bss_len) {
+		dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+		dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_RAM_BSS);
+		dump_tlv->tlv_len = cpu_to_le32(ar->fw.ram_bss_len);
+		memcpy(dump_tlv->tlv_data, crash_data->ram_bss_buf,
+		       ar->fw.ram_bss_len);
+		sofar += sizeof(*dump_tlv) + ar->fw.ram_bss_len;
+	}
+
+	if (ar->fw.rom_bss_addr && ar->fw.rom_bss_len) {
+		dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
+		dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_ROM_BSS);
+		dump_tlv->tlv_len = cpu_to_le32(ar->fw.rom_bss_len);
+		memcpy(dump_tlv->tlv_data, crash_data->rom_bss_buf,
+		       ar->fw.rom_bss_len);
+		sofar += sizeof(*dump_tlv) + ar->fw.rom_bss_len;
+	}
+
 	ar->debug.fw_crash_data->crashed_since_read = false;
 
 	spin_unlock_bh(&ar->data_lock);
drivers/net/wireless/ath/ath10k/hw.h +4 -0
index db52a55e5bd1..90fa4b0f56a4 100644
@@ -54,6 +54,10 @@ enum ath10k_fw_ie_type {
 	ATH10K_FW_IE_FEATURES = 2,
 	ATH10K_FW_IE_FW_IMAGE = 3,
 	ATH10K_FW_IE_OTP_IMAGE = 4,
+	ATH10K_FW_IE_RAM_BSS_ADDR = 5,
+	ATH10K_FW_IE_RAM_BSS_LEN = 6,
+	ATH10K_FW_IE_ROM_BSS_ADDR = 7,
+	ATH10K_FW_IE_ROM_BSS_LEN = 8,
 };
 
 /* Known pecularities:
drivers/net/wireless/ath/ath10k/pci.c +43 -0

55 lines not on this page · raw message

#24 lore raw

Re: [PATCH v7 6/8] ath10k: save firmware RAM and ROM BSS sections on crash

Quoted 13 lines · Kalle Valo

From: Ben Greear <[email protected]>

This can be used to get a useful back trace out of a firmware crash that involves an interrupt handler. For instance, a null-pointer-exception would be this kind of trace. A user-space tool can read the debugfs file and decode things as wished.

This requires a packaged firmware with a new IE to describe the BSS section starts and length.

---

[...]

Quoted 30 lines
drivers/net/wireless/ath/ath10k/pci.c +30 -0
+static void ath10k_pci_dump_bss_ram(struct ath10k *ar,
+                                   struct ath10k_fw_crash_data *crash_data) {
+       int ret;
+
+       lockdep_assert_held(&ar->data_lock);
+
+       if (!ar->fw.ram_bss_addr)
+               return;
+
+       if (!ar->fw.ram_bss_len)
+               return;
+
+       ret = ath10k_pci_diag_read_mem(ar, ar->fw.ram_bss_addr,
+                                      crash_data->ram_bss_buf,
+                                      ar->fw.ram_bss_len);
+       if (ret)
+               ath10k_warn("failed to read firmware RAM BSS memory from %d (%d B): %d\n",
+                           ar->fw.ram_bss_addr, ar->fw.ram_bss_len, ret);
+}
+
+static void ath10k_pci_dump_bss_rom(struct ath10k *ar,
+                                   struct ath10k_fw_crash_data *crash_data)
+{
+       int ret;
+
+       lockdep_assert_held(&ar->data_lock);
+
+       if (!ar->fw.rom_bss_addr)
+               return;
+

drivers/net/wireless/ath/ath10k/pci.c static void ath10k_pci_dump_exc_stack(struct ath10k *ar, · line 898

Quoted 10 lines
drivers/net/wireless/ath/ath10k/pci.c +10 -0
+       if (!ar->fw.rom_bss_len)
+               return;
+
+       ret = ath10k_pci_diag_read_mem(ar, ar->fw.rom_bss_addr,
+                                      crash_data->rom_bss_buf,
+                                      ar->fw.rom_bss_len);
+       if (ret)
+               ath10k_warn("failed to read firmware ROM BSS memory from %d (%d B): %d\n",
+                           ar->fw.rom_bss_addr, ar->fw.rom_bss_len, ret);
+}

Ditto as with other patches - endianess mess.

Michał

author
#25 lore raw

PATCH v7 7/8 ath10k: rename ath10k_pci_hif_dump_area() to ath10k_pci_fw_crashed_dump()

In reply to Kalle Valo

Better to have a clear name for the function. While at it, clear up the title for the register dump.

---
 drivers/net/wireless/ath/ath10k/pci.c |   10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/net/wireless/ath/ath10k/pci.c +5 -5
index 4825cef69c6e..8aaaeda7d20b 100644
@@ -1005,7 +1005,7 @@ static void ath10k_pci_dump_registers(struct ath10k *ar,
 
 	BUILD_BUG_ON(REG_DUMP_COUNT_QCA988X % 4);
 
-	ath10k_err("target Register Dump\n");
+	ath10k_err("firmware register dump:\n");
 	for (i = 0; i < REG_DUMP_COUNT_QCA988X; i += 4)
 		ath10k_err("[%02d]: 0x%08X 0x%08X 0x%08X 0x%08X\n",
 			   i,
@@ -1018,7 +1018,7 @@ static void ath10k_pci_dump_registers(struct ath10k *ar,
 	       sizeof(crash_data->reg_dump_values));
 }
 
-static void ath10k_pci_hif_dump_area(struct ath10k *ar)
+static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
 {
 	struct ath10k_fw_crash_data *crash_data;
 	char uuid[50];
@@ -1970,7 +1970,7 @@ static void ath10k_pci_fw_interrupt_handler(struct ath10k *ar)
 				   fw_indicator & ~FW_IND_EVENT_PENDING);
 
 		if (ar_pci->started) {
-			ath10k_pci_hif_dump_area(ar);
+			ath10k_pci_fw_crashed_dump(ar);
 		} else {
 			/*
 			 * Probable Target failure before we're prepared
@@ -2391,7 +2391,7 @@ static void ath10k_pci_early_irq_tasklet(unsigned long data)
 	if (fw_ind & FW_IND_EVENT_PENDING) {
 		ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS,
 				   fw_ind & ~FW_IND_EVENT_PENDING);
-		ath10k_pci_hif_dump_area(ar);
+		ath10k_pci_fw_crashed_dump(ar);
 	}
 
 	ath10k_pci_enable_legacy_irq(ar);
@@ -2642,7 +2642,7 @@ static int ath10k_pci_wait_for_target_init(struct ath10k *ar)
 		ath10k_warn("device has crashed during init\n");
 		ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS,
 				   val & ~FW_IND_EVENT_PENDING);
-		ath10k_pci_hif_dump_area(ar);
+		ath10k_pci_fw_crashed_dump(ar);
 		return -ECOMM;
 	}
 
author
#26 lore raw

PATCH v7 8/8 ath10k: print more driver info when firmware crashes

In reply to Kalle Valo
---
 drivers/net/wireless/ath/ath10k/core.c  |   17 ++---------------
 drivers/net/wireless/ath/ath10k/debug.c |   18 ++++++++++++++++++
 drivers/net/wireless/ath/ath10k/debug.h |    1 +
 drivers/net/wireless/ath/ath10k/pci.c   |    4 +---
 4 files changed, 22 insertions(+), 18 deletions(-)
drivers/net/wireless/ath/ath10k/core.c +2 -15
index 1472c0a767e2..e90f41dc6ae6 100644
@@ -869,21 +869,8 @@ int ath10k_core_start(struct ath10k *ar)
 
 	INIT_LIST_HEAD(&ar->arvifs);
 
-	if (!test_bit(ATH10K_FLAG_FIRST_BOOT_DONE, &ar->dev_flags)) {
-		ath10k_info("%s (0x%08x, 0x%08x) fw %s api %d htt %d.%d\n",
-			    ar->hw_params.name,
-			    ar->target_version,
-			    ar->chip_id,
-			    ar->hw->wiphy->fw_version,
-			    ar->fw_api,
-			    ar->htt.target_version_major,
-			    ar->htt.target_version_minor);
-		ath10k_info("debug %d debugfs %d tracing %d dfs %d\n",
-			    config_enabled(CONFIG_ATH10K_DEBUG),
-			    config_enabled(CONFIG_ATH10K_DEBUGFS),
-			    config_enabled(CONFIG_ATH10K_TRACING),
-			    config_enabled(CONFIG_ATH10K_DFS_CERTIFIED));
-	}
+	if (!test_bit(ATH10K_FLAG_FIRST_BOOT_DONE, &ar->dev_flags))
+		ath10k_print_driver_info(ar);
 
 	__set_bit(ATH10K_FLAG_FIRST_BOOT_DONE, &ar->dev_flags);
 
drivers/net/wireless/ath/ath10k/debug.c +18 -0
index 67bb53c64ead..27ddce6ca1da 100644
@@ -152,6 +152,24 @@ int ath10k_info(const char *fmt, ...)
 }
 EXPORT_SYMBOL(ath10k_info);
 
+void ath10k_print_driver_info(struct ath10k *ar)
+{
+	ath10k_info("%s (0x%08x, 0x%08x) fw %s api %d htt %d.%d\n",
+		    ar->hw_params.name,
+		    ar->target_version,
+		    ar->chip_id,
+		    ar->hw->wiphy->fw_version,
+		    ar->fw_api,
+		    ar->htt.target_version_major,
+		    ar->htt.target_version_minor);
+	ath10k_info("debug %d debugfs %d tracing %d dfs %d\n",
+		    config_enabled(CONFIG_ATH10K_DEBUG),
+		    config_enabled(CONFIG_ATH10K_DEBUGFS),
+		    config_enabled(CONFIG_ATH10K_TRACING),
+		    config_enabled(CONFIG_ATH10K_DFS_CERTIFIED));
+}
+EXPORT_SYMBOL(ath10k_print_driver_info);
+
 int ath10k_err(const char *fmt, ...)
 {
 	struct va_format vaf = {
drivers/net/wireless/ath/ath10k/debug.h +1 -0
index 80ff14e4db9b..494044a89226 100644
@@ -42,6 +42,7 @@ extern unsigned int ath10k_debug_mask;
 __printf(1, 2) int ath10k_info(const char *fmt, ...);
 __printf(1, 2) int ath10k_err(const char *fmt, ...);
 __printf(1, 2) int ath10k_warn(const char *fmt, ...);
+void ath10k_print_driver_info(struct ath10k *ar);
 
 #ifdef CONFIG_ATH10K_DEBUGFS
 int ath10k_debug_start(struct ath10k *ar);
drivers/net/wireless/ath/ath10k/pci.c +1 -3
index 8aaaeda7d20b..55b027a77b8e 100644
@@ -1033,9 +1033,7 @@ static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
 		scnprintf(uuid, sizeof(uuid), "n/a");
 
 	ath10k_err("firmware crashed! (uuid %s)\n", uuid);
-	ath10k_err("hardware name %s version 0x%x\n",
-		   ar->hw_params.name, ar->target_version);
-	ath10k_err("firmware version: %s\n", ar->hw->wiphy->fw_version);
+	ath10k_print_driver_info(ar);
 
 	if (!crash_data)
 		goto exit;