// SPDX-License-Identifier: GPL-2.0+

/** @file avm_reboot_status.c
 *
 * mbahr:
 * 1.) hold and get reboot-status after Soft/NMI-Reboot
 * 2.) handle die-notifier
 * 3.) handle panic-notifier
 */

#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kmsg_dump.h>
#include <linux/pm.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/kdebug.h>
#include <linux/signal.h>
#include <linux/interrupt.h>
#include <linux/nmi.h>
#include <linux/proc_fs.h>
#include <linux/env.h>
#include <linux/rtc.h>
#include <avm/tffs/tffs.h>
#include <linux/avm_hw_config.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
#include <uapi/avm/enh/fw_info.h>
#endif
#include <avm/enh/reboot_status.h>
#include <avm/sammel/simple_proc.h>
#include <avm/sammel/helpers.h>
#include <asm/mach_avm.h>


#if defined(CONFIG_AVM_FASTIRQ)
#if defined(CONFIG_AVM_FASTIRQ_ARCH_ARM_COMMON)
#include <asm/avm_enh/avm_fiq_os.h>
#else
#include <mach/avm_fiq_os.h>
#endif
#endif /*--- #if defined(CONFIG_AVM_FASTIRQ) ---*/
#include "avm_sammel.h"

#define MAILBOX_SIZE 512U

#if defined(CONFIG_SOC_GRX500)
#include "arch_grx.h"
#endif /*--- #if defined(CONFIG_SOC_GRX500) ---*/

#if defined(CONFIG_VR9) || defined(CONFIG_AR10)
#include "arch_ifx.h"
#endif /*--- #if defined(CONFIG_VR9) || defined(CONFIG_AR10) ---*/

#if defined(CONFIG_MACH_PUMA6)
#include "arch_puma6a.h"
#elif defined(CONFIG_X86) && !defined(CONFIG_X86_PUMA7)
#include "arch_puma6x.h"
#elif defined(CONFIG_MACH_PUMA7)

#if defined(CONFIG_X86_PUMA7)
#include "arch_puma7x.h"
#else
#include "arch_puma7.h"
#endif

#endif

#if defined(CONFIG_MACH_BCM963138) || defined(CONFIG_BCM963178)
#include "arch_brcma.h"
#endif /*--- #if defined(CONFIG_MACH_BCM963138) || defined(CONFIG_BCM963178) ---*/

#if defined(CONFIG_ARCH_IPQ40XX)
#include "arch_ipq40xx.h"
#endif /*--- #if defined(CONFIG_ARCH_IPQ40XX)  ---*/

#if defined(CONFIG_ARCH_IPQ5018)
#include "arch_ipq5018.h"
#endif

#if defined(CONFIG_SOC_AR724X) || defined(CONFIG_SOC_AR934X) ||                \
	defined(CONFIG_SOC_QCA955X) || defined(CONFIG_SOC_QCA953X) ||          \
	defined(CONFIG_SOC_QCA956X)
#include "arch_scrpn.h"
#endif /*--- #if defined(CONFIG_SOC_AR724X) || defined(CONFIG_SOC_AR934X) || defined(CONFIG_SOC_QCA955X) || defined(CONFIG_SOC_QCA953X) || defined(CONFIG_SOC_QCA956X)  ---*/

#include <avm/enh/fw_info.h>

#define DEBUG_MAILBOX 0

#define AVM_REBOOT_INFO_CURRENT 0
#define AVM_REBOOT_INFO_NEXT    1
static struct avm_reboot_info avm_reboot_info[2];
static struct avm_firmware_build_info reboot_buildinfo; /* parsed from mailbox */

/**
 * \brief Deliver last reboot-status
 */
enum _avm_reset_status avm_reset_status(void)
{
	return avm_reboot_info[AVM_REBOOT_INFO_CURRENT].reboot_status;
}
EXPORT_SYMBOL(avm_reset_status);

enum _avm_reset_status avm_next_reset_status(void)
{
	return avm_reboot_info[AVM_REBOOT_INFO_NEXT].reboot_status;
}
EXPORT_SYMBOL(avm_next_reset_status);

struct _reboot_info {
	const enum _avm_reset_status status;
	const char *matchtext;
	int matchlen;
	const char *printouttext;
	const char *shortprintouttext;
	unsigned int reboot_count;
};

#define REBOOT_INFO_ENTRY(_status, user_txt, mbox_txt, mbox_counter) {	\
	.status = (_status),						\
	.matchtext = (mbox_txt),					\
	.matchlen  = (mbox_txt) ? sizeof(mbox_txt) : 0,			\
	.printouttext = (user_txt),					\
	.shortprintouttext = (mbox_counter),				\
}

// clang-format off
static struct _reboot_info reboot_info[] = {
	REBOOT_INFO_ENTRY(RS_SOFTWATCHDOG,      "Softwatchdog-Reboot",      SOFTWATCHDOG_REBOOT_STATUS_TEXT,         "WD"),
	REBOOT_INFO_ENTRY(RS_NMIWATCHDOG,       "NMI-Watchdog-Reset",       NMI_REBOOT_STATUS_TEXT,                  "NMI"),
	REBOOT_INFO_ENTRY(RS_FIRMWAREUPDATE,    "Fw-Update",                UPDATE_REBOOT_STATUS_TEXT,               NULL),
	REBOOT_INFO_ENTRY(RS_SHORTREBOOT,       "Short-PowerOff-Reboot",    POWERON_REBOOT_STATUS_TEXT,              "SHORTPOWERCUT"),
	REBOOT_INFO_ENTRY(RS_TEMP_REBOOT,       "Temperature-Reboot",       TEMP_REBOOT_STATUS_TEXT,                 "TEMPERATURE"),
	REBOOT_INFO_ENTRY(RS_REBOOT_FOR_UPDATE,	"Update-Reboot",            SOFT_REBOOT_STATUS_TEXT_UPDATE,          "UPDATE"),
	REBOOT_INFO_ENTRY(RS_PANIC,             "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_PANIC,           "PANIC"),
	REBOOT_INFO_ENTRY(RS_OOM,               "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_OOM,             "OOM"),
	REBOOT_INFO_ENTRY(RS_OOPS,              "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_OOPS,            "KCRASH"),
	REBOOT_INFO_ENTRY(RS_DOCSIS_LOCAL,      "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_DOCSIS_LOCAL,    "DOCSIS_LOCAL"),
	REBOOT_INFO_ENTRY(RS_DOCSIS_OPERATOR,   "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_DOCSIS_OPERATOR, "DOCSIS_OPERATOR"),
	REBOOT_INFO_ENTRY(RS_BOXCHANGE,         "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_BOXCHANGE,       "BOXCHANGE"),
	REBOOT_INFO_ENTRY(RS_OPERATOR,          "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT_OPERATOR,        "OPERATOR"),
	/*--- als vorletzter Eintrag, da dieser Untermenge von RS_PANIC/RS_OOM/RS_OOPS ---*/
	REBOOT_INFO_ENTRY(RS_REBOOT,            "Soft-Reboot",              SOFT_REBOOT_STATUS_TEXT,                 NULL),
	/*--- definition: have to be last entry: ---*/
	REBOOT_INFO_ENTRY(RS_POWERON,           "Power-On",                 NULL,                                    NULL),
};
// clang-format on

static int mailbox_get_value(const char *mbox, const char *mbkey,
			     char *buf, size_t bufsiz)
{
	const char *s, *e;
	size_t len;

	if (!bufsiz)
		return 0;

	s = mbox;
	while ((s = strstr(s, mbkey))) {
		s += strlen(mbkey);
		if (*s++ == '(')
			break;
	}

	if (!s)
		return -ENOENT;

	e = strnchr(s, bufsiz, ')');
	len = e ? e-s : bufsiz-1;

	strlcpy(buf, s, len+1);

	return 0;
}

/**
 */
static void read_reboot_counters(const char *mbox)
{
	unsigned int i, control, sum = 0;
	unsigned int counter[ARRAY_SIZE(reboot_info)];
	char val[32];
	int err;

	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		const char *mbkey;

		counter[i] = 0;

		mbkey = reboot_info[i].shortprintouttext;
		if (!mbkey)
			continue;

		err = mailbox_get_value(mbox, mbkey, val, sizeof(val));
		if (err)
			continue;

		sscanf(val, "%u", &counter[i]);
		sum += counter[i];
	}

	err = mailbox_get_value(mbox, "SUM", val, sizeof(val));
	if (!err) {
		sscanf(val, "%u", &control);
		if (control == sum) {
			for (i = 0; i < ARRAY_SIZE(reboot_info); i++)
				reboot_info[i].reboot_count = counter[i];
		}
	}
}

/**
 * read uptime and fw-info from mailbox
 * format UP(<time_sec>)UTC(<time>)FW(<version>)HW(<version>)HWS(<subversion>)BV(<version>)BN(<buildnumber>)FS(<firmwarestring>)BT(<buildtype>)BD(<builddirty)
 */
static void mailbox_get_reboot_info(const char *mbox, struct avm_reboot_info *info)
{
	struct avm_firmware_build_info *bi;
	char val[128];
	int err;

	info->fw.fwinfo_version = AVM_FWINFO_VERSION(3, 0);
	info->fw.src = AVM_FWINFO_SOURCE_MAILBOX;

	err = mailbox_get_value(mbox, "UP", val, sizeof(val));
	if (!err)
		sscanf(val, "%lu", &info->tm.uptime);

	err = mailbox_get_value(mbox, "UTC", val, sizeof(val));
	if (!err)
		sscanf(val, "%lld", (long long *)&info->tm.time);

	err = mailbox_get_value(mbox, "FW", val, sizeof(val));
	if (!err)
		strlcpy(info->fw.fw_version, val, sizeof(info->fw.fw_version));

	err = mailbox_get_value(mbox, "HW", val, sizeof(val));
	if (!err)
		strlcpy(info->fw.hw_revision, val, sizeof(info->fw.hw_revision));

	err = mailbox_get_value(mbox, "HWS", val, sizeof(val));
	if (!err)
		strlcpy(info->fw.hw_subrevision, val, sizeof(info->fw.hw_subrevision));

	bi = info->fw.build;
	if (bi == NULL)
		return;

	err = mailbox_get_value(mbox, "BN", val, sizeof(val));
	if (!err)
		strlcpy(bi->buildnumber, val, sizeof(bi->buildnumber));

	err = mailbox_get_value(mbox, "FS", val, sizeof(val));
	if (!err)
		strlcpy(bi->firmwarestring, val, sizeof(bi->firmwarestring));

	err = mailbox_get_value(mbox, "BT", val, sizeof(val));
	if (!err)
		sscanf(val, "%d", &bi->buildtype);
	err = mailbox_get_value(mbox, "BD", val, sizeof(val));
	if (!err)
		sscanf(val, "%d", &bi->builddirty);
}

static bool strempty(const char *str)
{
	return str[0] == 0;
}

static void fixup_fwinfo_from_mailbox(struct avm_reboot_info info[])
{
	struct avm_firmware_info *prev, *cur;

	prev = &info[AVM_REBOOT_INFO_CURRENT].fw;
	cur  = &info[AVM_REBOOT_INFO_NEXT].fw;

	if (strempty(prev->fw_version)) {
		prev->src = AVM_FWINFO_SOURCE_CURRENTFW;
		strcpy(prev->fw_version, cur->fw_version);
	}

	if (strempty(prev->hw_revision))
		strcpy(prev->hw_revision, cur->hw_revision);

	if (strempty(prev->hw_subrevision))
		strcpy(prev->hw_subrevision, cur->hw_subrevision);

	if (strempty(prev->bootloader_version))
		strcpy(prev->bootloader_version, cur->bootloader_version);
}

/**
 */
static void clear_reboot_counters(void)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		reboot_info[i].reboot_count = 0;
	}
}

/**
 */
static unsigned int sum_reboot_counters(void)
{
	unsigned int i, sum = 0;

	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		if (reboot_info[i].shortprintouttext) {
			sum += reboot_info[i].reboot_count;
		}
	}
	return sum;
}


static size_t write_reboot_counters_array(char *str, size_t size)
{
	struct _reboot_info *rinfo;
	size_t i, len;
	int ret;

	len = 0;
	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		rinfo = &reboot_info[i];
		if (!rinfo->shortprintouttext || !rinfo->reboot_count)
			continue;
		ret = snprintf(&str[len], size, "%s(%u) ",
				rinfo->shortprintouttext,
				rinfo->reboot_count);
		if (ret < 0)
			return len;
		len += ret;
		if (len >= size)
			return len;
	}
	if (len)
		str[--len] = '\0'; /* Strip final space */

	return len;
}

void avm_get_firmware_uptime(struct avm_firmware_uptime *tm)
{
	/* Use lockless API */
	tm->uptime = ktime_get_seconds();
	tm->time = __ktime_get_real_seconds();
}

static size_t write_reboot_counters(char *mbox, int maxlen)
{
	struct avm_firmware_build_info *bi;
	struct avm_reboot_info *info;
	unsigned int sum;
	size_t len;

	len = write_reboot_counters_array(mbox, maxlen);
	if (len >= (size_t)maxlen)
		return len;

	sum = sum_reboot_counters();
	if (sum)
		len += snprintf(&mbox[len], maxlen - len, "SUM(%u)", sum);

	info = &avm_reboot_info[AVM_REBOOT_INFO_NEXT];
	avm_get_firmware_uptime(&info->tm);

	len += snprintf(&mbox[len], maxlen - len, "%s(%lu)%s(%lld)%s(%s)%s(%s)%s(%s)%s(%s)",
			"UP",  info->tm.uptime,
			"UTC", info->tm.time,
			"FW",  info->fw.fw_version,
			"HW",  info->fw.hw_revision,
			"HWS", info->fw.hw_subrevision,
			"BV",  info->fw.bootloader_version);

	bi = info->fw.build;
	if (bi == NULL)
		return len;

	len += snprintf(&mbox[len], maxlen - len, "%s(%s)%s(%s)%s(%d)%s(%d)",
			"BN",  bi->buildnumber,
			"FS",  bi->firmwarestring,
			"BT",  bi->buildtype,
			"BD",  bi->builddirty);

	return len;
}

/**
 */
static int get_fieldindex_by_status(enum _avm_reset_status status)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		if (reboot_info[i].status == status) {
			return i;
		}
	}
	return -1;
}

static char *avm_rebootcounter_string(char *txt, unsigned int maxlen)
{
	unsigned int len, sum;

	txt[0] = 0;

	sum = sum_reboot_counters();
	if (sum == 0)
		return txt;

	len = snprintf(txt, maxlen, "SUM(%u) - ", sum);
	if (len >= maxlen)
		return txt;

	write_reboot_counters_array(&txt[len], maxlen - len);

	return txt;
}

static void debug_mailbox_dump(const char *prefix, const char *mbox, size_t len)
{
	char __mb[MAILBOX_SIZE] = "";
	size_t size, pos = 0;

	if (!DEBUG_MAILBOX)
		return;

	if (len == 0)
		goto dump;

	size = len;
	if (mbox[size - 1]) {
		/* No terminating NUL, need to append one */
		++size;
	} else {
		/*
		 * While the mailbox data may contain embedded NUL chars,
		 * we merge trailing consecutive NUL chars to one.
		 */
		while (size > 1 && !mbox[size - 2])
			--size;
	}
	size = min(sizeof(__mb), size);

	/*
	 * Copy strings, mapping intermediate NUL delimiters to an
	 * alternate, printable character.
	 */
	while (true) {
		pos += strlcpy(&__mb[pos], &mbox[pos], size - pos);
		if (pos + 1 >= size)
			break;
		__mb[pos++] = '+';
	}

dump:
	pr_info("%s: %s\n", prefix, __mb);
}

static DEFINE_SEMAPHORE(mailbox_lock);

static char *get_mailbox(void)
{
	int ret;

	ret = rte_down_trylock(&mailbox_lock);
	if (ret)
		return ERR_PTR(-EAGAIN);

	return arch_get_mailbox();
}

static void put_mailbox(void)
{
	rte_up(&mailbox_lock);
}

#ifndef arch_read_mailbox
#define arch_read_mailbox __default_read_mailbox
#else
static int __default_read_mailbox(char *mbox, size_t size) __maybe_unused;
#endif
static int __default_read_mailbox(char *mbox, size_t size)
{
	char *arch_mailbox;

	arch_mailbox = arch_get_mailbox();
	if (!arch_mailbox)
		return -ENOSYS;
	memcpy(mbox, arch_mailbox, size);

	return 0;
}

static __init int read_mailbox(char *mbox, size_t size)
{
	int ret;

	down(&mailbox_lock);
	ret = arch_read_mailbox(mbox, size);
	up(&mailbox_lock);

	return ret;
}

/* On armp7, we allow using reboot_status w/o a mailbox.
 *
 * Doing this on other boxes hasn't been evaluated when adding this; it is
 * confined to armp7 in order not to silently change behavior on other
 * platforms.
 */
#if defined(CONFIG_MACH_PUMA7) && defined(CONFIG_ARCH_AVALANCHE)
#  define IGNORE_MISSING_MAILBOX 1
#else
#  define IGNORE_MISSING_MAILBOX 0
#endif

/**
 */
static void set_reboot_status(int nofix, enum _avm_reset_status status)
{
	int idx, ret;
	const char *text = "-----";
	unsigned int len = strlen(text) + 1;
	static const char *reboot_cause_written;
	char *mailbox;
	char *reboot_counters_str;

	/*--- only if not valid set before: ---*/
	if (reboot_cause_written != NULL) {
		return;
	}

	mailbox = get_mailbox();
	if (IS_ERR(mailbox)) {
		pr_err("Error saving reboot status to mailbox: %ld\n",
			PTR_ERR(mailbox));
		return;
	}
	if (!mailbox && !IGNORE_MISSING_MAILBOX)
		goto out;

	if ((status == RS_REBOOT) && oops_in_progress) {
		status = RS_OOPS;
	}
	pr_debug("Setting reboot status: %d\n", status);
	idx = get_fieldindex_by_status(status);
	if (idx < 0) {
		goto out;
	}

	if (reboot_info[idx].matchtext) {
		text = reboot_info[idx].matchtext;
		len = reboot_info[idx].matchlen;
	}
	if (nofix == 0) {
		reboot_cause_written = text;
		/**
		 * Reboot-Counter updaten/loeschen
		 */
		switch (status) {
		case RS_REBOOT:
			clear_reboot_counters();
			break;
		case RS_FIRMWAREUPDATE:
			clear_reboot_counters();
			break;
		default:
			if (reboot_info[idx].shortprintouttext) {
				reboot_info[idx].reboot_count++;
			}
			break;
		}
	}

	avm_reboot_info[AVM_REBOOT_INFO_NEXT].reboot_status = status;

	/* Without a mailbox, that's all we can do */
	if (!mailbox)
		goto out;

	memset(mailbox, 0, MAILBOX_SIZE);
	memcpy(mailbox, text, len);

	/* Append reboot counter string AFTER terminating zero */
	reboot_counters_str = &mailbox[len];
	len += write_reboot_counters(reboot_counters_str, MAILBOX_SIZE - len);
	if (len > MAILBOX_SIZE) {
		pr_err("Mailbox overflow when saving reboot status, data truncated\n");
		len = MAILBOX_SIZE;
	}

	ret = arch_flush_mailbox(mailbox, len);
	if (ret)
		pr_err("Error flushing mailbox: %d\n", ret);

	debug_mailbox_dump("Writing mailbox: ", mailbox, len);

	if (nofix == 0) {
		pr_err("%s: %s%s%s%s%s%s\n", __func__,
		       reboot_info[idx].printouttext,
		       reboot_info[idx].shortprintouttext ? "(" : "",
		       reboot_info[idx].shortprintouttext ?
			       reboot_info[idx].shortprintouttext :
			       "",
		       reboot_info[idx].shortprintouttext ? ") " : " ",
		       *reboot_counters_str ? " - " : "",
		       reboot_counters_str);
	}
out:
	put_mailbox();
}
/**
 * \brief set actual reboot-status once - following settings will be ignored.
 * special case: status = RS_POWERON - it happens as a cold-start
 * (PCMCR-workarround for GRX)
 * \param status reboot-status
 */
void avm_set_reset_status(enum _avm_reset_status status)
{
	if (status == RS_POWERON) {
		set_reboot_status(1, RS_POWERON);
		return;
	}
	set_reboot_status(0, status);
}
EXPORT_SYMBOL(avm_set_reset_status);

/**
 */
static int avm_reboot_handler(struct notifier_block *nb, unsigned long event,
			      void *buf);
static struct notifier_block avm_reboot_notifier = {
	.notifier_call = avm_reboot_handler, /* callback   */
	.priority = INT_MAX
};

/**
 */
#ifndef arch_reboot_handler
#  define arch_reboot_handler(nb, ev, data) NOTIFY_DONE
#endif
static int avm_reboot_handler(struct notifier_block *nb,
			      unsigned long event,
			      void *buf)
{
	printk_avm_console_bend(0); /* force serial-output */
	avm_set_reset_status(RS_REBOOT);
	avm_stack_check(NULL);
	return arch_reboot_handler(nb, event, buf);
}

#if defined(CONFIG_AVM_FASTIRQ)
#ifdef CONFIG_ARCH_QCOM
void avm_set_crashed_cpu(int cpu)
{
	SET_CRASHED_CPU(cpu);
}
int avm_get_crashed_cpu(void)
{
	return GET_CRASHED_CPU();
}
#endif /*--- #ifdef CONFIG_ARCH_QCOM ---*/
#endif /*--- #ifdef CONFIG_AVM_FASTIRQ ---*/
static int panic_handler(struct notifier_block *notifier_block,
			 unsigned long event, void *cause_string);
static struct notifier_block panic_notifier[] = {

	{.notifier_call	= panic_handler, .next = NULL, .priority = 1 },
#if defined(arch_panic_notifier)
	{.notifier_call	= arch_panic_notifier, .next = NULL, .priority = arch_panic_notifier_priority },
#endif
};

/**
 */
static int panic_handler(struct notifier_block *notifier_block,
			 unsigned long event,
			 void *cause_string)
{
	console_verbose();
	avm_set_reset_status(RS_PANIC);
	avm_stack_check(NULL);
	avm_oom_show_memstat(AVM_OOM_MEMSTAT_ONCE);
	printk_avm_console_bend(0); /*--- force serial output ---*/
	return NOTIFY_DONE;
}

/**
 */
static int die_notifier(struct notifier_block *self, unsigned long cmd,
			void *ptr);
static struct notifier_block die_nb = {
	.notifier_call = die_notifier,
	.priority = 0,
};

/**
 */
static int die_notifier(struct notifier_block *self, unsigned long cmd,
			void *ptr)
{
	console_verbose();
	avm_set_reset_status(RS_OOPS);
	avm_stack_check(NULL);
#if defined(arch_die_notifier)
	return arch_die_notifier(self, cmd, ptr);
#else
	return NOTIFY_OK;
#endif /*--- #if #defined(arch_die_notifier) ---*/
}
/**
 * \brief initial function called over arch_initcall-chain of linux-os
 * get the last reboot-status from architecture-depend reboot-safe
 * further functions:
 *  - print out last reboot-status
 *  - initialize actual reboot-status to overwritable short-power-on
 *  - register die-notifier
 *  - register panic-notifier
 */
static __init int get_reboot_status(void)
{
	unsigned int i, len;
	char Buffer[MAILBOX_SIZE] = {0};
	int ret;

	ret = read_mailbox(Buffer, MAILBOX_SIZE);
	if (ret == -ENOSYS) {
		if (IGNORE_MISSING_MAILBOX)
			goto no_mailbox;
		return 0;
	}
	if (ret) {
		pr_err("Error reading reboot status: %d\n", ret);
		return ret;
	}
	avm_reboot_info[AVM_REBOOT_INFO_CURRENT].fw.build = &reboot_buildinfo;
	Buffer[MAILBOX_SIZE - 1] = '\0';
	debug_mailbox_dump("Found mailbox: ", Buffer, MAILBOX_SIZE);

	for (i = 0; i < ARRAY_SIZE(reboot_info); i++) {
		if (reboot_info[i].matchtext == NULL) {
			break;
		}
		len = reboot_info[i].matchlen;
		BUG_ON(len > MAILBOX_SIZE - 1);
		if (memcmp(Buffer, reboot_info[i].matchtext, len) == 0) {
			mailbox_get_reboot_info(&Buffer[len],
				&avm_reboot_info[AVM_REBOOT_INFO_CURRENT]);

			read_reboot_counters(&Buffer[len]);
#if defined(CONFIG_TFFS_DUMMY_PANIC_LOG_AFTER_RESET)
			/*--- workarround - should be a nmi/freezer  ---*/
			if (reboot_info[i].status == RS_SHORTREBOOT) {
				int idx = get_fieldindex_by_status(RS_NMIWATCHDOG);

				if (idx >= 0) {
					char txt[128];
					unsigned long error_epc =
						read_c0_errorepc();
					unsigned int sticky_reg = ath_reg_rd(
						ATH_RESET_BASE +
						ATH_RESET_REG_STICKY);
					i = idx;
					reboot_info[i].reboot_count++;
					snprintf(
						txt, sizeof(txt),
						"Maybe watchdog without log\nerror-epc=%pS\nsticky-reg=0x%08x\n",
						(void *)error_epc, sticky_reg);
					TFFS3_panic_dummy_log(txt);
				}
			}
#endif
			if (reboot_info[i].status == RS_SHORTREBOOT) {
				reboot_info[i].reboot_count++;
			}
			break;
		}
	}
	avm_reboot_info[AVM_REBOOT_INFO_CURRENT].reboot_status = reboot_info[i].status;
	pr_err("Reboot Status is: %s%s%s%s%s\n",
	       reboot_info[i].printouttext,
	       reboot_info[i].shortprintouttext ? "(" : "",
	       reboot_info[i].shortprintouttext ?
		       reboot_info[i].shortprintouttext :
		       "",
	       reboot_info[i].shortprintouttext ? ") " : " ",
	       avm_rebootcounter_string(Buffer, sizeof(Buffer)));
#if defined(CONFIG_TFFS_DUMMY_PANIC_LOG_AFTER_RESET)
	write_c0_errorepc(0x0);
#endif
no_mailbox:
	avm_get_firmware_info(&avm_reboot_info[AVM_REBOOT_INFO_NEXT].fw,
			AVM_FWINFO_VERSION(3, 0));
	fixup_fwinfo_from_mailbox(avm_reboot_info);
	set_reboot_status(1, RS_SHORTREBOOT);
	register_die_notifier(&die_nb);

	for (i = 0; i < ARRAY_SIZE(panic_notifier); i++)
		atomic_notifier_chain_register(&panic_notifier_list, &panic_notifier[i]);

	register_reboot_notifier(&avm_reboot_notifier);
	return 0;
}
#if defined(CONFIG_X86_PUMA7)
fs_initcall(get_reboot_status);
#else
arch_initcall(get_reboot_status);
#endif

/**
 * maxsize of buf: 14 + 10 + 2 + 2 + 2  = 30
 */
static char *human_readable_time(unsigned long time, char *buf, unsigned long buf_size)
{
	unsigned long seconds, minutes, hours, days;

	seconds = time % 60;
	time /= 60;
	minutes = time % 60;
	time /= 60;
	hours = time % 24;
	time /= 24;
	days = time;
	snprintf(buf, buf_size, "%lu d %lu h %lu min %lu s", days, hours, minutes, seconds);
	return buf;
}

size_t avm_snprint_reboot_info(const struct avm_reboot_info *reboot_info,
			       char *buf, size_t bufsiz)
{
	const struct avm_firmware_info *fwinfo = &reboot_info->fw;
	const struct avm_firmware_uptime *tm = &reboot_info->tm;
	char reboot_counter_str[128] = "";
	size_t len = 0;

	if (!bufsiz)
		return 0;

	if (!fwinfo->fwinfo_version) {
		buf[0] = 0;
		return 0;
	}

	len += scnprintf(&buf[len], bufsiz - len, "Uptime: %lu\n", tm->uptime);
	if (tm->uptime) {
		char htime[32], huptime[128];

		human_readable_time(tm->uptime, huptime, sizeof(huptime));
		time_to_ascii(tm->time, htime, sizeof(htime));

		len += scnprintf(&buf[len], bufsiz - len,
				 "Uptime-String: %s - panic on %s\n", huptime, htime);
	}

	if (fwinfo->fwinfo_version >= AVM_FWINFO_VERSION(2, 1)) {
		avm_rebootcounter_string(reboot_counter_str, sizeof(reboot_counter_str));
		if (!strempty(reboot_counter_str)) {
			len += scnprintf(&buf[len], bufsiz - len,
					"%s: %s %s\n",
					"Irregular-Reboots",
					reboot_counter_str,
					"(since last regular reboot/power-cut)");
		}
	}

	len += avm_snprint_firmware_info_kernel(fwinfo, &buf[len], bufsiz - len);

	return len;
}

static struct proc_dir_entry *rebootprocdir;
#define PROC_REBOOTDIR "avm/reboot"

static void proc_reboot_info_read(struct seq_file *seq, void *priv)
{
	const struct avm_reboot_info *info;
	char buf[AVM_REBOOT_INFO_SIZE];

	info = &avm_reboot_info[AVM_REBOOT_INFO_CURRENT];

	avm_snprint_reboot_info(info, buf, sizeof(buf));
	seq_puts(seq, buf);
	seq_puts(seq, "\n");
}

static int proc_reboot_info_write(char *buf, void *priv)
{
	if (strstr(buf, "clear_rebootcounter")) {
		clear_reboot_counters();
	} else {
		pr_err("/proc/avm/reboot/info: invalid input (\"clear_rebootcounter\" resets counters)\n");
		return -EINVAL;
	}

	return 0;
}

/**
 */
static __init int proc_reboot_status(void)
{
	rebootprocdir = proc_mkdir(PROC_REBOOTDIR, NULL);
	if (rebootprocdir == NULL) {
		return 0;
	}
	return add_simple_proc_file("avm/reboot/info",
		proc_reboot_info_write, proc_reboot_info_read, NULL);
}
late_initcall(proc_reboot_status);