Quelle  coredump.c   Sprache: C

// 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 MT7996_DEVICE_ID:
 case MT7996_DEVICE_ID_2:
  *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;
}