Commit 878161d5 authored by Ryder Lee's avatar Ryder Lee Committed by Felix Fietkau
Browse files

wifi: mt76: mt7996: enable coredump support 



Host triggered and catastrophic event triggered firmware core dumping
for basic firmware issues triage, including state reporting, function
calltrace and MCU memory dump.

Signed-off-by: default avatarRyder Lee <ryder.lee@mediatek.com>
Signed-off-by: default avatarFelix Fietkau <nbd@nbd.name>
parent 672662f0

drivers/net/wireless/mediatek/mt76/mt7996/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
config MT7996E

	tristate "MediaTek MT7996 (PCIe) support"

	select MT76_CONNAC_LIB

	select WANT_DEV_COREDUMP

	select RELAY

	depends on MAC80211

	depends on PCI

drivers/net/wireless/mediatek/mt76/mt7996/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -4,3 +4,5 @@ obj-$(CONFIG_MT7996E) += mt7996e.o 


mt7996e-y := pci.o init.o dma.o eeprom.o main.o mcu.o mac.o \

	     debugfs.o mmio.o



mt7996e-$(CONFIG_DEV_COREDUMP) += coredump.o

drivers/net/wireless/mediatek/mt76/mt7996/coredump.c

0 → 100644
+268 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: ISC

/* Copyright (C) 2023 MediaTek Inc. */



#include <linux/devcoredump.h>

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/utsname.h>

#include "coredump.h"



static bool coredump_memdump;

module_param(coredump_memdump, bool, 0644);

MODULE_PARM_DESC(coredump_memdump, "Optional ability to dump firmware memory");



static const struct mt7996_mem_region mt7996_mem_regions[] = {

	{

		.start = 0x00800000,

		.len = 0x0004ffff,

		.name = "ULM0",

	},

	{

		.start = 0x00900000,

		.len = 0x00037fff,

		.name = "ULM1",

	},

	{

		.start = 0x02200000,

		.len = 0x0003ffff,

		.name = "ULM2",

	},

	{

		.start = 0x00400000,

		.len = 0x00067fff,

		.name = "SRAM",

	},

	{

		.start = 0xe0000000,

		.len = 0x0015ffff,

		.name = "CRAM0",

	},

	{

		.start = 0xe0160000,

		.len = 0x0011bfff,

		.name = "CRAM1",

	},

};



const struct mt7996_mem_region*

mt7996_coredump_get_mem_layout(struct mt7996_dev *dev, u32 *num)

{

	switch (mt76_chip(&dev->mt76)) {

	case 0x7990:

	case 0x7991:

		*num = ARRAY_SIZE(mt7996_mem_regions);

		return &mt7996_mem_regions[0];

	default:

		return NULL;

	}

}



static int mt7996_coredump_get_mem_size(struct mt7996_dev *dev)

{

	const struct mt7996_mem_region *mem_region;

	size_t size = 0;

	u32 num;

	int i;



	mem_region = mt7996_coredump_get_mem_layout(dev, &num);

	if (!mem_region)

		return 0;



	for (i = 0; i < num; i++) {

		size += mem_region->len;

		mem_region++;

	}



	/* reserve space for the headers */

	size += num * sizeof(struct mt7996_mem_hdr);

	/* make sure it is aligned 4 bytes for debug message print out */

	size = ALIGN(size, 4);



	return size;

}



struct mt7996_crash_data *mt7996_coredump_new(struct mt7996_dev *dev)

{

	struct mt7996_crash_data *crash_data = dev->coredump.crash_data;



	lockdep_assert_held(&dev->dump_mutex);



	if (coredump_memdump &&

	    !mt76_poll_msec(dev, MT_FW_DUMP_STATE, 0x3, 0x2, 500))

		return NULL;



	guid_gen(&crash_data->guid);

	ktime_get_real_ts64(&crash_data->timestamp);



	return crash_data;

}



static void

mt7996_coredump_fw_state(struct mt7996_dev *dev, struct mt7996_coredump *dump,

			 bool *exception)

{

	u32 count;



	count = mt76_rr(dev, MT_FW_ASSERT_CNT);



	/* normal mode: driver can manually trigger assert for detail info */

	if (!count)

		strscpy(dump->fw_state, "normal", sizeof(dump->fw_state));

	else

		strscpy(dump->fw_state, "exception", sizeof(dump->fw_state));



	*exception = !!count;

}



static void

mt7996_coredump_fw_stack(struct mt7996_dev *dev, struct mt7996_coredump *dump,

			 bool exception)

{

	u32 oldest, i, idx;



	strscpy(dump->pc_current, "program counter", sizeof(dump->pc_current));



	/* 0: WM PC log output */

	mt76_wr(dev, MT_CONN_DBG_CTL_OUT_SEL, 0);

	/* choose 33th PC log buffer to read current PC index */

	mt76_wr(dev, MT_CONN_DBG_CTL_PC_LOG_SEL, 0x3f);



	/* read current PC */

	dump->pc_stack[0] = mt76_rr(dev, MT_CONN_DBG_CTL_PC_LOG);



	/* stop call stack record */

	if (!exception) {

		mt76_clear(dev, MT_MCU_WM_EXCP_PC_CTRL, BIT(0));

		mt76_clear(dev, MT_MCU_WM_EXCP_LR_CTRL, BIT(0));

	}



	oldest = (u32)mt76_get_field(dev, MT_MCU_WM_EXCP_PC_CTRL,

				     GENMASK(20, 16)) + 2;

	for (i = 0; i < 16; i++) {

		idx = ((oldest + 2 * i + 1) % 32);

		dump->pc_stack[i + 1] =

			mt76_rr(dev, MT_MCU_WM_EXCP_PC_LOG + idx * 4);

	}



	oldest = (u32)mt76_get_field(dev, MT_MCU_WM_EXCP_LR_CTRL,

				     GENMASK(20, 16)) + 2;

	for (i = 0; i < 16; i++) {

		idx = ((oldest + 2 * i + 1) % 32);

		dump->lr_stack[i] =

			mt76_rr(dev, MT_MCU_WM_EXCP_LR_LOG + idx * 4);

	}



	/* start call stack record */

	if (!exception) {

		mt76_set(dev, MT_MCU_WM_EXCP_PC_CTRL, BIT(0));

		mt76_set(dev, MT_MCU_WM_EXCP_LR_CTRL, BIT(0));

	}

}



static struct mt7996_coredump *mt7996_coredump_build(struct mt7996_dev *dev)

{

	struct mt7996_crash_data *crash_data = dev->coredump.crash_data;

	struct mt7996_coredump *dump;

	struct mt7996_coredump_mem *dump_mem;

	size_t len, sofar = 0, hdr_len = sizeof(*dump);

	unsigned char *buf;

	bool exception;



	len = hdr_len;



	if (coredump_memdump && crash_data->memdump_buf_len)

		len += sizeof(*dump_mem) + crash_data->memdump_buf_len;



	sofar += hdr_len;



	/* this is going to get big when we start dumping memory and such,

	 * so go ahead and use vmalloc.

	 */

	buf = vzalloc(len);

	if (!buf)

		return NULL;



	mutex_lock(&dev->dump_mutex);



	dump = (struct mt7996_coredump *)(buf);

	dump->len = len;



	/* plain text */

	strscpy(dump->magic, "mt76-crash-dump", sizeof(dump->magic));

	strscpy(dump->kernel, init_utsname()->release, sizeof(dump->kernel));

	strscpy(dump->fw_ver, dev->mt76.hw->wiphy->fw_version,

		sizeof(dump->fw_ver));



	guid_copy(&dump->guid, &crash_data->guid);

	dump->tv_sec = crash_data->timestamp.tv_sec;

	dump->tv_nsec = crash_data->timestamp.tv_nsec;

	dump->device_id = mt76_chip(&dev->mt76);



	mt7996_coredump_fw_state(dev, dump, &exception);

	mt7996_coredump_fw_stack(dev, dump, exception);



	/* gather memory content */

	dump_mem = (struct mt7996_coredump_mem *)(buf + sofar);

	dump_mem->len = crash_data->memdump_buf_len;

	if (coredump_memdump && crash_data->memdump_buf_len)

		memcpy(dump_mem->data, crash_data->memdump_buf,

		       crash_data->memdump_buf_len);



	mutex_unlock(&dev->dump_mutex);



	return dump;

}



int mt7996_coredump_submit(struct mt7996_dev *dev)

{

	struct mt7996_coredump *dump;



	dump = mt7996_coredump_build(dev);

	if (!dump) {

		dev_warn(dev->mt76.dev, "no crash dump data found\n");

		return -ENODATA;

	}



	dev_coredumpv(dev->mt76.dev, dump, dump->len, GFP_KERNEL);



	return 0;

}



int mt7996_coredump_register(struct mt7996_dev *dev)

{

	struct mt7996_crash_data *crash_data;



	crash_data = vzalloc(sizeof(*dev->coredump.crash_data));

	if (!crash_data)

		return -ENOMEM;



	dev->coredump.crash_data = crash_data;



	if (coredump_memdump) {

		crash_data->memdump_buf_len = mt7996_coredump_get_mem_size(dev);

		if (!crash_data->memdump_buf_len)

			/* no memory content */

			return 0;



		crash_data->memdump_buf = vzalloc(crash_data->memdump_buf_len);

		if (!crash_data->memdump_buf) {

			vfree(crash_data);

			return -ENOMEM;

		}

	}



	return 0;

}



void mt7996_coredump_unregister(struct mt7996_dev *dev)

{

	if (dev->coredump.crash_data->memdump_buf) {

		vfree(dev->coredump.crash_data->memdump_buf);

		dev->coredump.crash_data->memdump_buf = NULL;

		dev->coredump.crash_data->memdump_buf_len = 0;

	}



	vfree(dev->coredump.crash_data);

	dev->coredump.crash_data = NULL;

}

drivers/net/wireless/mediatek/mt76/mt7996/coredump.h

0 → 100644
+97 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: ISC */

/* Copyright (C) 2023 MediaTek Inc. */



#ifndef _COREDUMP_H_

#define _COREDUMP_H_



#include "mt7996.h"



struct mt7996_coredump {

	char magic[16];



	u32 len;



	guid_t guid;



	/* time-of-day stamp */

	u64 tv_sec;

	/* time-of-day stamp, nano-seconds */

	u64 tv_nsec;

	/* kernel version */

	char kernel[64];

	/* firmware version */

	char fw_ver[ETHTOOL_FWVERS_LEN];



	u32 device_id;



	/* exception state */

	char fw_state[12];



	/* program counters */

	char pc_current[16];

	u32 pc_stack[17];

	/* link registers */

	u32 lr_stack[16];



	/* memory content */

	u8 data[];

} __packed;



struct mt7996_coredump_mem {

	u32 len;

	u8 data[];

} __packed;



struct mt7996_mem_hdr {

	u32 start;

	u32 len;

	u8 data[];

};



struct mt7996_mem_region {

	u32 start;

	size_t len;



	const char *name;

};



#ifdef CONFIG_DEV_COREDUMP



const struct mt7996_mem_region *

mt7996_coredump_get_mem_layout(struct mt7996_dev *dev, u32 *num);

struct mt7996_crash_data *mt7996_coredump_new(struct mt7996_dev *dev);

int mt7996_coredump_submit(struct mt7996_dev *dev);

int mt7996_coredump_register(struct mt7996_dev *dev);

void mt7996_coredump_unregister(struct mt7996_dev *dev);



#else /* CONFIG_DEV_COREDUMP */



static inline const struct mt7996_mem_region *

mt7996_coredump_get_mem_layout(struct mt7996_dev *dev, u32 *num)

{

	return NULL;

}



static inline int mt7996_coredump_submit(struct mt7996_dev *dev)

{

	return 0;

}



static inline struct

mt7996_crash_data *mt7996_coredump_new(struct mt7996_dev *dev)

{

	return NULL;

}



static inline int mt7996_coredump_register(struct mt7996_dev *dev)

{

	return 0;

}



static inline void mt7996_coredump_unregister(struct mt7996_dev *dev)

{

}



#endif /* CONFIG_DEV_COREDUMP */



#endif /* _COREDUMP_H_ */

drivers/net/wireless/mediatek/mt76/mt7996/init.c

+9 −1
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#include "mt7996.h"

#include "mac.h"

#include "mcu.h"

#include "coredump.h"

#include "eeprom.h"



static const struct ieee80211_iface_limit if_limits[] = {
@@ -841,6 +842,8 @@ int mt7996_register_device(struct mt7996_dev *dev) 


	init_waitqueue_head(&dev->reset_wait);

	INIT_WORK(&dev->reset_work, mt7996_mac_reset_work);

	INIT_WORK(&dev->dump_work, mt7996_mac_dump_work);

	mutex_init(&dev->dump_mutex);



	ret = mt7996_init_hardware(dev);

	if (ret)
@@ -871,13 +874,18 @@ int mt7996_register_device(struct mt7996_dev *dev) 


	dev->recovery.hw_init_done = true;



	return mt7996_init_debugfs(&dev->phy);

	ret = mt7996_init_debugfs(&dev->phy);

	if (ret)

		return ret;



	return mt7996_coredump_register(dev);

}



void mt7996_unregister_device(struct mt7996_dev *dev)

{

	mt7996_unregister_phy(mt7996_phy3(dev), MT_BAND2);

	mt7996_unregister_phy(mt7996_phy2(dev), MT_BAND1);

	mt7996_coredump_unregister(dev);

	mt76_unregister_device(&dev->mt76);

	mt7996_mcu_exit(dev);

	mt7996_tx_token_put(dev);