Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[platform/kernel/linux-starfive.git] / drivers / acpi / acpi_watchdog.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ACPI watchdog table parsing support.
4  *
5  * Copyright (C) 2016, Intel Corporation
6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
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
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
57
58 static bool acpi_no_watchdog;
59
60 static const struct acpi_table_wdat *acpi_watchdog_get_wdat(void)
61 {
62         const struct acpi_table_wdat *wdat = NULL;
63         acpi_status status;
64
65         if (acpi_disabled || acpi_no_watchdog)
66                 return NULL;
67
68         status = acpi_get_table(ACPI_SIG_WDAT, 0,
69                                 (struct acpi_table_header **)&wdat);
70         if (ACPI_FAILURE(status)) {
71                 /* It is fine if there is no WDAT */
72                 return NULL;
73         }
74
75         if (acpi_watchdog_uses_rtc(wdat)) {
76                 acpi_put_table((struct acpi_table_header *)wdat);
77                 pr_info("Skipping WDAT on this system because it uses RTC SRAM\n");
78                 return NULL;
79         }
80
81         return wdat;
82 }
83
84 /**
85  * Returns true if this system should prefer ACPI based watchdog instead of
86  * the native one (which are typically the same hardware).
87  */
88 bool acpi_has_watchdog(void)
89 {
90         return !!acpi_watchdog_get_wdat();
91 }
92 EXPORT_SYMBOL_GPL(acpi_has_watchdog);
93
94 /* ACPI watchdog can be disabled on boot command line */
95 static int __init disable_acpi_watchdog(char *str)
96 {
97         acpi_no_watchdog = true;
98         return 1;
99 }
100 __setup("acpi_no_watchdog", disable_acpi_watchdog);
101
102 void __init acpi_watchdog_init(void)
103 {
104         const struct acpi_wdat_entry *entries;
105         const struct acpi_table_wdat *wdat;
106         struct list_head resource_list;
107         struct resource_entry *rentry;
108         struct platform_device *pdev;
109         struct resource *resources;
110         size_t nresources = 0;
111         int i;
112
113         wdat = acpi_watchdog_get_wdat();
114         if (!wdat) {
115                 /* It is fine if there is no WDAT */
116                 return;
117         }
118
119         /* Watchdog disabled by BIOS */
120         if (!(wdat->flags & ACPI_WDAT_ENABLED))
121                 goto fail_put_wdat;
122
123         /* Skip legacy PCI WDT devices */
124         if (wdat->pci_segment != 0xff || wdat->pci_bus != 0xff ||
125             wdat->pci_device != 0xff || wdat->pci_function != 0xff)
126                 goto fail_put_wdat;
127
128         INIT_LIST_HEAD(&resource_list);
129
130         entries = (struct acpi_wdat_entry *)(wdat + 1);
131         for (i = 0; i < wdat->entries; i++) {
132                 const struct acpi_generic_address *gas;
133                 struct resource_entry *rentry;
134                 struct resource res = {};
135                 bool found;
136
137                 gas = &entries[i].register_region;
138
139                 res.start = gas->address;
140                 res.end = res.start + ACPI_ACCESS_BYTE_WIDTH(gas->access_width) - 1;
141                 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
142                         res.flags = IORESOURCE_MEM;
143                 } else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
144                         res.flags = IORESOURCE_IO;
145                 } else {
146                         pr_warn("Unsupported address space: %u\n",
147                                 gas->space_id);
148                         goto fail_free_resource_list;
149                 }
150
151                 found = false;
152                 resource_list_for_each_entry(rentry, &resource_list) {
153                         if (rentry->res->flags == res.flags &&
154                             resource_union(rentry->res, &res, rentry->res)) {
155                                 found = true;
156                                 break;
157                         }
158                 }
159
160                 if (!found) {
161                         rentry = resource_list_create_entry(NULL, 0);
162                         if (!rentry)
163                                 goto fail_free_resource_list;
164
165                         *rentry->res = res;
166                         resource_list_add_tail(rentry, &resource_list);
167                         nresources++;
168                 }
169         }
170
171         resources = kcalloc(nresources, sizeof(*resources), GFP_KERNEL);
172         if (!resources)
173                 goto fail_free_resource_list;
174
175         i = 0;
176         resource_list_for_each_entry(rentry, &resource_list)
177                 resources[i++] = *rentry->res;
178
179         pdev = platform_device_register_simple("wdat_wdt", PLATFORM_DEVID_NONE,
180                                                resources, nresources);
181         if (IS_ERR(pdev))
182                 pr_err("Device creation failed: %ld\n", PTR_ERR(pdev));
183
184         kfree(resources);
185
186 fail_free_resource_list:
187         resource_list_free(&resource_list);
188 fail_put_wdat:
189         acpi_put_table((struct acpi_table_header *)wdat);
190 }