1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Siemens SIMATIC IPC driver for Watchdogs 4 * 5 * Copyright (c) Siemens AG, 2020-2021 6 * 7 * Authors: 8 * Gerd Haeussler <gerd.haeussler.ext@siemens.com> 9 */ 10 11 #include <linux/device.h> 12 #include <linux/errno.h> 13 #include <linux/init.h> 14 #include <linux/io.h> 15 #include <linux/ioport.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/pci.h> 19 #include <linux/platform_data/x86/p2sb.h> 20 #include <linux/platform_data/x86/simatic-ipc-base.h> 21 #include <linux/platform_device.h> 22 #include <linux/sizes.h> 23 #include <linux/util_macros.h> 24 #include <linux/watchdog.h> 25 #include <linux/stringify.h> 26 27 #define WD_ENABLE_IOADR 0x62 28 #define WD_TRIGGER_IOADR 0x66 29 #define GPIO_COMMUNITY0_PORT_ID 0xaf 30 #define PAD_CFG_DW0_GPP_A_23 0x4b8 31 #define SAFE_EN_N_427E 0x01 32 #define SAFE_EN_N_227E 0x04 33 #define WD_ENABLED 0x01 34 #define WD_TRIGGERED 0x80 35 #define WD_MACROMODE 0x02 36 37 #define TIMEOUT_MIN 2 38 #define TIMEOUT_DEF 64 39 #define TIMEOUT_MAX 64 40 41 #define GP_STATUS_REG_227E 0x404D /* IO PORT for SAFE_EN_N on 227E */ 42 43 static bool nowayout = WATCHDOG_NOWAYOUT; 44 module_param(nowayout, bool, 0000); 45 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 46 __stringify(WATCHDOG_NOWAYOUT) ")"); 47 48 static struct resource gp_status_reg_227e_res = 49 DEFINE_RES_IO_NAMED(GP_STATUS_REG_227E, SZ_1, KBUILD_MODNAME); 50 51 static struct resource io_resource_enable = 52 DEFINE_RES_IO_NAMED(WD_ENABLE_IOADR, SZ_1, 53 KBUILD_MODNAME " WD_ENABLE_IOADR"); 54 55 static struct resource io_resource_trigger = 56 DEFINE_RES_IO_NAMED(WD_TRIGGER_IOADR, SZ_1, 57 KBUILD_MODNAME " WD_TRIGGER_IOADR"); 58 59 /* the actual start will be discovered with p2sb, 0 is a placeholder */ 60 static struct resource mem_resource = 61 DEFINE_RES_MEM_NAMED(0, 0, "WD_RESET_BASE_ADR"); 62 63 static u32 wd_timeout_table[] = {2, 4, 6, 8, 16, 32, 48, 64 }; 64 static void __iomem *wd_reset_base_addr; 65 66 static int wd_start(struct watchdog_device *wdd) 67 { 68 outb(inb(WD_ENABLE_IOADR) | WD_ENABLED, WD_ENABLE_IOADR); 69 return 0; 70 } 71 72 static int wd_stop(struct watchdog_device *wdd) 73 { 74 outb(inb(WD_ENABLE_IOADR) & ~WD_ENABLED, WD_ENABLE_IOADR); 75 return 0; 76 } 77 78 static int wd_ping(struct watchdog_device *wdd) 79 { 80 inb(WD_TRIGGER_IOADR); 81 return 0; 82 } 83 84 static int wd_set_timeout(struct watchdog_device *wdd, unsigned int t) 85 { 86 int timeout_idx = find_closest(t, wd_timeout_table, 87 ARRAY_SIZE(wd_timeout_table)); 88 89 outb((inb(WD_ENABLE_IOADR) & 0xc7) | timeout_idx << 3, WD_ENABLE_IOADR); 90 wdd->timeout = wd_timeout_table[timeout_idx]; 91 return 0; 92 } 93 94 static const struct watchdog_info wdt_ident = { 95 .options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING | 96 WDIOF_SETTIMEOUT, 97 .identity = KBUILD_MODNAME, 98 }; 99 100 static const struct watchdog_ops wdt_ops = { 101 .owner = THIS_MODULE, 102 .start = wd_start, 103 .stop = wd_stop, 104 .ping = wd_ping, 105 .set_timeout = wd_set_timeout, 106 }; 107 108 static void wd_secondary_enable(u32 wdtmode) 109 { 110 u16 resetbit; 111 112 /* set safe_en_n so we are not just WDIOF_ALARMONLY */ 113 if (wdtmode == SIMATIC_IPC_DEVICE_227E) { 114 /* enable SAFE_EN_N on GP_STATUS_REG_227E */ 115 resetbit = inb(GP_STATUS_REG_227E); 116 outb(resetbit & ~SAFE_EN_N_227E, GP_STATUS_REG_227E); 117 } else { 118 /* enable SAFE_EN_N on PCH D1600 */ 119 resetbit = ioread16(wd_reset_base_addr); 120 iowrite16(resetbit & ~SAFE_EN_N_427E, wd_reset_base_addr); 121 } 122 } 123 124 static int wd_setup(u32 wdtmode) 125 { 126 unsigned int bootstatus = 0; 127 int timeout_idx; 128 129 timeout_idx = find_closest(TIMEOUT_DEF, wd_timeout_table, 130 ARRAY_SIZE(wd_timeout_table)); 131 132 if (inb(WD_ENABLE_IOADR) & WD_TRIGGERED) 133 bootstatus |= WDIOF_CARDRESET; 134 135 /* reset alarm bit, set macro mode, and set timeout */ 136 outb(WD_TRIGGERED | WD_MACROMODE | timeout_idx << 3, WD_ENABLE_IOADR); 137 138 wd_secondary_enable(wdtmode); 139 140 return bootstatus; 141 } 142 143 static struct watchdog_device wdd_data = { 144 .info = &wdt_ident, 145 .ops = &wdt_ops, 146 .min_timeout = TIMEOUT_MIN, 147 .max_timeout = TIMEOUT_MAX 148 }; 149 150 static int simatic_ipc_wdt_probe(struct platform_device *pdev) 151 { 152 struct simatic_ipc_platform *plat = pdev->dev.platform_data; 153 struct device *dev = &pdev->dev; 154 struct resource *res; 155 int ret; 156 157 switch (plat->devmode) { 158 case SIMATIC_IPC_DEVICE_227E: 159 res = &gp_status_reg_227e_res; 160 if (!request_muxed_region(res->start, resource_size(res), res->name)) { 161 dev_err(dev, 162 "Unable to register IO resource at %pR\n", 163 &gp_status_reg_227e_res); 164 return -EBUSY; 165 } 166 fallthrough; 167 case SIMATIC_IPC_DEVICE_427E: 168 wdd_data.parent = dev; 169 break; 170 default: 171 return -EINVAL; 172 } 173 174 if (!devm_request_region(dev, io_resource_enable.start, 175 resource_size(&io_resource_enable), 176 io_resource_enable.name)) { 177 dev_err(dev, 178 "Unable to register IO resource at %#x\n", 179 WD_ENABLE_IOADR); 180 return -EBUSY; 181 } 182 183 if (!devm_request_region(dev, io_resource_trigger.start, 184 resource_size(&io_resource_trigger), 185 io_resource_trigger.name)) { 186 dev_err(dev, 187 "Unable to register IO resource at %#x\n", 188 WD_TRIGGER_IOADR); 189 return -EBUSY; 190 } 191 192 if (plat->devmode == SIMATIC_IPC_DEVICE_427E) { 193 res = &mem_resource; 194 195 ret = p2sb_bar(NULL, 0, res); 196 if (ret) 197 return ret; 198 199 /* do the final address calculation */ 200 res->start = res->start + (GPIO_COMMUNITY0_PORT_ID << 16) + 201 PAD_CFG_DW0_GPP_A_23; 202 res->end = res->start + SZ_4 - 1; 203 204 wd_reset_base_addr = devm_ioremap_resource(dev, res); 205 if (IS_ERR(wd_reset_base_addr)) 206 return PTR_ERR(wd_reset_base_addr); 207 } 208 209 wdd_data.bootstatus = wd_setup(plat->devmode); 210 if (wdd_data.bootstatus) 211 dev_warn(dev, "last reboot caused by watchdog reset\n"); 212 213 if (plat->devmode == SIMATIC_IPC_DEVICE_227E) 214 release_region(gp_status_reg_227e_res.start, 215 resource_size(&gp_status_reg_227e_res)); 216 217 watchdog_set_nowayout(&wdd_data, nowayout); 218 watchdog_stop_on_reboot(&wdd_data); 219 return devm_watchdog_register_device(dev, &wdd_data); 220 } 221 222 static struct platform_driver simatic_ipc_wdt_driver = { 223 .probe = simatic_ipc_wdt_probe, 224 .driver = { 225 .name = KBUILD_MODNAME, 226 }, 227 }; 228 229 module_platform_driver(simatic_ipc_wdt_driver); 230 231 MODULE_DESCRIPTION("Siemens SIMATIC IPC driver for Watchdogs"); 232 MODULE_LICENSE("GPL v2"); 233 MODULE_ALIAS("platform:" KBUILD_MODNAME); 234 MODULE_AUTHOR("Gerd Haeussler <gerd.haeussler.ext@siemens.com>"); 235