[linux-2.6-block.git] / drivers / acpi / acpi_watchdog.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * ACPI watchdog table parsing support.
 *
 * Copyright (C) 2016, Intel Corporation
 * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
 */

#define pr_fmt(fmt) "ACPI: watchdog: " fmt

#include <linux/acpi.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>

#include "internal.h"

#ifdef CONFIG_RTC_MC146818_LIB
#include <linux/mc146818rtc.h>

/*
 * There are several systems where the WDAT table is accessing RTC SRAM to
 * store persistent information. This does not work well with the Linux RTC
 * driver so on those systems we skip WDAT driver and prefer iTCO_wdt
 * instead.
 *
 * See also https://bugzilla.kernel.org/show_bug.cgi?id=199033.
 */
static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat)
{
	const struct acpi_wdat_entry *entries;
	int i;

	entries = (struct acpi_wdat_entry *)(wdat + 1);
	for (i = 0; i < wdat->entries; i++) {
		const struct acpi_generic_address *gas;

		gas = &entries[i].register_region;
		if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
			switch (gas->address) {
			case RTC_PORT(0):
			case RTC_PORT(1):
			case RTC_PORT(2):
			case RTC_PORT(3):
				return true;
			}
		}
	}

	return false;
}
#else
static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat)
{
	return false;
}
#endif

static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void)
{
	const struct acpi_table_wdat *wdat = NULL;
	acpi_status status;

	if (acpi_disabled)
		return NULL;

	status = acpi_get_table(ACPI_SIG_WDAT, 0,
				(struct acpi_table_header **)&wdat);
	if (ACPI_FAILURE(status)) {
		/* It is fine if there is no WDAT */
		return NULL;
	}

	if (acpi_watchdog_uses_rtc(wdat)) {
		pr_info("Skipping WDAT on this system because it uses RTC SRAM\n");
		return NULL;
	}

	return wdat;
}

/**
 * Returns true if this system should prefer ACPI based watchdog instead of
 * the native one (which are typically the same hardware).
 */
bool acpi_has_watchdog(void)
{
	return !!acpi_watchdog_get_wdat();
}
EXPORT_SYMBOL_GPL(acpi_has_watchdog);

void __init acpi_watchdog_init(void)
{
	const struct acpi_wdat_entry *entries;
	const struct acpi_table_wdat *wdat;
	struct list_head resource_list;
	struct resource_entry *rentry;
	struct platform_device *pdev;
	struct resource *resources;
	size_t nresources = 0;
	int i;

	wdat = acpi_watchdog_get_wdat();
	if (!wdat) {
		/* It is fine if there is no WDAT */
		return;
	}

	/* Watchdog disabled by BIOS */
	if (!(wdat->flags & ACPI_WDAT_ENABLED))
		return;

	/* Skip legacy PCI WDT devices */
	if (wdat->pci_segment != 0xff || wdat->pci_bus != 0xff ||
	    wdat->pci_device != 0xff || wdat->pci_function != 0xff)
		return;

	INIT_LIST_HEAD(&resource_list);

	entries = (struct acpi_wdat_entry *)(wdat + 1);
	for (i = 0; i < wdat->entries; i++) {
		const struct acpi_generic_address *gas;
		struct resource_entry *rentry;
		struct resource res = {};
		bool found;

		gas = &entries[i].register_region;

		res.start = gas->address;
		if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
			res.flags = IORESOURCE_MEM;
			res.end = res.start + ALIGN(gas->access_width, 4) - 1;
		} else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
			res.flags = IORESOURCE_IO;
			res.end = res.start + gas->access_width - 1;
		} else {
			pr_warn("Unsupported address space: %u\n",
				gas->space_id);
			goto fail_free_resource_list;
		}

		found = false;
		resource_list_for_each_entry(rentry, &resource_list) {
			if (rentry->res->flags == res.flags &&
			    resource_overlaps(rentry->res, &res)) {
				if (res.start < rentry->res->start)
					rentry->res->start = res.start;
				if (res.end > rentry->res->end)
					rentry->res->end = res.end;
				found = true;
				break;
			}
		}

		if (!found) {
			rentry = resource_list_create_entry(NULL, 0);
			if (!rentry)
				goto fail_free_resource_list;

			*rentry->res = res;
			resource_list_add_tail(rentry, &resource_list);
			nresources++;
		}
	}

	resources = kcalloc(nresources, sizeof(*resources), GFP_KERNEL);
	if (!resources)
		goto fail_free_resource_list;

	i = 0;
	resource_list_for_each_entry(rentry, &resource_list)
		resources[i++] = *rentry->res;

	pdev = platform_device_register_simple("wdat_wdt", PLATFORM_DEVID_NONE,
					       resources, nresources);
	if (IS_ERR(pdev))
		pr_err("Device creation failed: %ld\n", PTR_ERR(pdev));

	kfree(resources);

fail_free_resource_list:
	resource_list_free(&resource_list);
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
058dfc76 MW	2	/*
	3	* ACPI watchdog table parsing support.
	4	*
	5	* Copyright (C) 2016, Intel Corporation
	6	* Author: Mika Westerberg <mika.westerberg@linux.intel.com>
058dfc76 MW	7	*/
	8
	9	#define pr_fmt(fmt) "ACPI: watchdog: " fmt
	10
	11	#include <linux/acpi.h>
	12	#include <linux/ioport.h>
	13	#include <linux/platform_device.h>
	14
	15	#include "internal.h"
	16
5a802a7a MW	17	#ifdef CONFIG_RTC_MC146818_LIB
	18	#include <linux/mc146818rtc.h>
	19
	20	/*
	21	* There are several systems where the WDAT table is accessing RTC SRAM to
	22	* store persistent information. This does not work well with the Linux RTC
	23	* driver so on those systems we skip WDAT driver and prefer iTCO_wdt
	24	* instead.
	25	*
	26	* See also https://bugzilla.kernel.org/show_bug.cgi?id=199033.
	27	*/
	28	static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat)
	29	{
	30	const struct acpi_wdat_entry *entries;
	31	int i;
	32
	33	entries = (struct acpi_wdat_entry *)(wdat + 1);
	34	for (i = 0; i < wdat->entries; i++) {
	35	const struct acpi_generic_address *gas;
	36
	37	gas = &entries[i].register_region;
	38	if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
	39	switch (gas->address) {
	40	case RTC_PORT(0):
	41	case RTC_PORT(1):
	42	case RTC_PORT(2):
	43	case RTC_PORT(3):
	44	return true;
	45	}
	46	}
	47	}
	48
	49	return false;
	50	}
	51	#else
	52	static bool acpi_watchdog_uses_rtc(const struct acpi_table_wdat *wdat)
	53	{
	54	return false;
	55	}
	56	#endif
a0a37862 MW	57
	58	static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void)
	59	{
	60	const struct acpi_table_wdat *wdat = NULL;
	61	acpi_status status;
	62
	63	if (acpi_disabled)
	64	return NULL;
	65
a0a37862 MW	66	status = acpi_get_table(ACPI_SIG_WDAT, 0,
	67	(struct acpi_table_header **)&wdat);
	68	if (ACPI_FAILURE(status)) {
	69	/* It is fine if there is no WDAT */
	70	return NULL;
	71	}
	72
5a802a7a MW	73	if (acpi_watchdog_uses_rtc(wdat)) {
	74	pr_info("Skipping WDAT on this system because it uses RTC SRAM\n");
	75	return NULL;
	76	}
	77
a0a37862 MW	78	return wdat;
	79	}
	80
058dfc76 MW	81	/**
	82	* Returns true if this system should prefer ACPI based watchdog instead of
	83	* the native one (which are typically the same hardware).
	84	*/
	85	bool acpi_has_watchdog(void)
	86	{
a0a37862	87	return !!acpi_watchdog_get_wdat();
058dfc76 MW	88	}
	89	EXPORT_SYMBOL_GPL(acpi_has_watchdog);
	90
	91	void __init acpi_watchdog_init(void)
	92	{
	93	const struct acpi_wdat_entry *entries;
	94	const struct acpi_table_wdat *wdat;
	95	struct list_head resource_list;
	96	struct resource_entry *rentry;
	97	struct platform_device *pdev;
	98	struct resource *resources;
	99	size_t nresources = 0;
058dfc76 MW	100	int i;
058dfc76 MW	101
a0a37862 MW	102	wdat = acpi_watchdog_get_wdat();
a0a37862 MW	103	if (!wdat) {
058dfc76 MW	104	/* It is fine if there is no WDAT */
	105	return;
	106	}
	107
	108	/* Watchdog disabled by BIOS */
	109	if (!(wdat->flags & ACPI_WDAT_ENABLED))
	110	return;
	111
	112	/* Skip legacy PCI WDT devices */
	113	if (wdat->pci_segment != 0xff \|\| wdat->pci_bus != 0xff \|\|
	114	wdat->pci_device != 0xff \|\| wdat->pci_function != 0xff)
	115	return;
	116
	117	INIT_LIST_HEAD(&resource_list);
	118
	119	entries = (struct acpi_wdat_entry *)(wdat + 1);
	120	for (i = 0; i < wdat->entries; i++) {
	121	const struct acpi_generic_address *gas;
	122	struct resource_entry *rentry;
6ce14f64	123	struct resource res = {};
058dfc76 MW	124	bool found;
	125
	126	gas = &entries[i].register_region;
	127
	128	res.start = gas->address;
	129	if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
	130	res.flags = IORESOURCE_MEM;
b1abf6fc	131	res.end = res.start + ALIGN(gas->access_width, 4) - 1;
058dfc76 MW	132	} else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
058dfc76 MW	133	res.flags = IORESOURCE_IO;
b1abf6fc	134	res.end = res.start + gas->access_width - 1;
058dfc76 MW	135	} else {
	136	pr_warn("Unsupported address space: %u\n",
	137	gas->space_id);
	138	goto fail_free_resource_list;
	139	}
	140
	141	found = false;
	142	resource_list_for_each_entry(rentry, &resource_list) {
31e86cb9 RK	143	if (rentry->res->flags == res.flags &&
	144	resource_overlaps(rentry->res, &res)) {
	145	if (res.start < rentry->res->start)
	146	rentry->res->start = res.start;
	147	if (res.end > rentry->res->end)
	148	rentry->res->end = res.end;
058dfc76 MW	149	found = true;
	150	break;
	151	}
	152	}
	153
	154	if (!found) {
	155	rentry = resource_list_create_entry(NULL, 0);
	156	if (!rentry)
	157	goto fail_free_resource_list;
	158
	159	*rentry->res = res;
	160	resource_list_add_tail(rentry, &resource_list);
	161	nresources++;
	162	}
	163	}
	164
	165	resources = kcalloc(nresources, sizeof(*resources), GFP_KERNEL);
	166	if (!resources)
	167	goto fail_free_resource_list;
	168
	169	i = 0;
	170	resource_list_for_each_entry(rentry, &resource_list)
	171	resources[i++] = *rentry->res;
	172
	173	pdev = platform_device_register_simple("wdat_wdt", PLATFORM_DEVID_NONE,
	174	resources, nresources);
	175	if (IS_ERR(pdev))
c6e2c1e1	176	pr_err("Device creation failed: %ld\n", PTR_ERR(pdev));
058dfc76 MW	177
	178	kfree(resources);
	179
	180	fail_free_resource_list:
	181	resource_list_free(&resource_list);
	182	}