xref: /linux/drivers/watchdog/cgbc_wdt.c (revision 98b5f7706f6bfd863e50317742f7d566b86fabdc)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Congatec Board Controller watchdog driver
4  *
5  * Copyright (C) 2024 Bootlin
6  * Author: Thomas Richard <thomas.richard@bootlin.com>
7  */
8 
9 #include <linux/build_bug.h>
10 #include <linux/device.h>
11 #include <linux/limits.h>
12 #include <linux/module.h>
13 #include <linux/platform_device.h>
14 #include <linux/watchdog.h>
15 
16 #include <linux/mfd/cgbc.h>
17 
18 #define CGBC_WDT_CMD_TRIGGER	0x27
19 #define CGBC_WDT_CMD_INIT	0x28
20 #define CGBC_WDT_DISABLE	0x00
21 
22 #define CGBC_WDT_MODE_SINGLE_EVENT 0x02
23 
24 #define CGBC_WDT_MIN_TIMEOUT	1
25 #define CGBC_WDT_MAX_TIMEOUT	((U32_MAX >> 8) / 1000)
26 
27 #define CGBC_WDT_DEFAULT_TIMEOUT	30
28 #define CGBC_WDT_DEFAULT_PRETIMEOUT	0
29 
30 enum action {
31 	ACTION_INT = 0,
32 	ACTION_SMI,
33 	ACTION_RESET,
34 	ACTION_BUTTON,
35 };
36 
37 static unsigned int timeout;
38 module_param(timeout, uint, 0);
39 MODULE_PARM_DESC(timeout,
40 		 "Watchdog timeout in seconds. (>=0, default="
41 		 __MODULE_STRING(CGBC_WDT_DEFAULT_TIMEOUT) ")");
42 
43 static unsigned int pretimeout = CGBC_WDT_DEFAULT_PRETIMEOUT;
44 module_param(pretimeout, uint, 0);
45 MODULE_PARM_DESC(pretimeout,
46 		 "Watchdog pretimeout in seconds. (>=0, default="
47 		 __MODULE_STRING(CGBC_WDT_DEFAULT_PRETIMEOUT) ")");
48 
49 static bool nowayout = WATCHDOG_NOWAYOUT;
50 module_param(nowayout, bool, 0);
51 MODULE_PARM_DESC(nowayout,
52 		 "Watchdog cannot be stopped once started (default="
53 		 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
54 
55 struct cgbc_wdt_data {
56 	struct cgbc_device_data	*cgbc;
57 	struct watchdog_device	wdd;
58 };
59 
60 struct cgbc_wdt_cmd_cfg {
61 	u8 cmd;
62 	u8 mode;
63 	u8 action;
64 	u8 timeout1[3];
65 	u8 timeout2[3];
66 	u8 reserved[3];
67 	u8 delay[3];
68 } __packed;
69 
70 static_assert(sizeof(struct cgbc_wdt_cmd_cfg) == 15);
71 
cgbc_wdt_start(struct watchdog_device * wdd)72 static int cgbc_wdt_start(struct watchdog_device *wdd)
73 {
74 	struct cgbc_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
75 	struct cgbc_device_data *cgbc = wdt_data->cgbc;
76 	unsigned int timeout1 = (wdd->timeout - wdd->pretimeout) * 1000;
77 	unsigned int timeout2 = wdd->pretimeout * 1000;
78 	u8 action;
79 
80 	struct cgbc_wdt_cmd_cfg cmd_start = {
81 		.cmd = CGBC_WDT_CMD_INIT,
82 		.mode = CGBC_WDT_MODE_SINGLE_EVENT,
83 		.timeout1[0] = (u8)timeout1,
84 		.timeout1[1] = (u8)(timeout1 >> 8),
85 		.timeout1[2] = (u8)(timeout1 >> 16),
86 		.timeout2[0] = (u8)timeout2,
87 		.timeout2[1] = (u8)(timeout2 >> 8),
88 		.timeout2[2] = (u8)(timeout2 >> 16),
89 	};
90 
91 	if (wdd->pretimeout) {
92 		action = 2;
93 		action |= ACTION_SMI << 2;
94 		action |= ACTION_RESET << 4;
95 	} else {
96 		action = 1;
97 		action |= ACTION_RESET << 2;
98 	}
99 
100 	cmd_start.action = action;
101 
102 	return cgbc_command(cgbc, &cmd_start, sizeof(cmd_start), NULL, 0, NULL);
103 }
104 
cgbc_wdt_stop(struct watchdog_device * wdd)105 static int cgbc_wdt_stop(struct watchdog_device *wdd)
106 {
107 	struct cgbc_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
108 	struct cgbc_device_data *cgbc = wdt_data->cgbc;
109 	struct cgbc_wdt_cmd_cfg cmd_stop = {
110 		.cmd = CGBC_WDT_CMD_INIT,
111 		.mode = CGBC_WDT_DISABLE,
112 	};
113 
114 	return cgbc_command(cgbc, &cmd_stop, sizeof(cmd_stop), NULL, 0, NULL);
115 }
116 
cgbc_wdt_keepalive(struct watchdog_device * wdd)117 static int cgbc_wdt_keepalive(struct watchdog_device *wdd)
118 {
119 	struct cgbc_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
120 	struct cgbc_device_data *cgbc = wdt_data->cgbc;
121 	u8 cmd_ping = CGBC_WDT_CMD_TRIGGER;
122 
123 	return cgbc_command(cgbc, &cmd_ping, sizeof(cmd_ping), NULL, 0, NULL);
124 }
125 
cgbc_wdt_set_pretimeout(struct watchdog_device * wdd,unsigned int pretimeout)126 static int cgbc_wdt_set_pretimeout(struct watchdog_device *wdd,
127 				   unsigned int pretimeout)
128 {
129 	wdd->pretimeout = pretimeout;
130 
131 	if (watchdog_active(wdd))
132 		return cgbc_wdt_start(wdd);
133 
134 	return 0;
135 }
136 
cgbc_wdt_set_timeout(struct watchdog_device * wdd,unsigned int timeout)137 static int cgbc_wdt_set_timeout(struct watchdog_device *wdd,
138 				unsigned int timeout)
139 {
140 	if (timeout < wdd->pretimeout)
141 		wdd->pretimeout = 0;
142 
143 	wdd->timeout = timeout;
144 
145 	if (watchdog_active(wdd))
146 		return cgbc_wdt_start(wdd);
147 
148 	return 0;
149 }
150 
151 static const struct watchdog_info cgbc_wdt_info = {
152 	.identity	= "CGBC Watchdog",
153 	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
154 		WDIOF_MAGICCLOSE | WDIOF_PRETIMEOUT
155 };
156 
157 static const struct watchdog_ops cgbc_wdt_ops = {
158 	.owner		= THIS_MODULE,
159 	.start		= cgbc_wdt_start,
160 	.stop		= cgbc_wdt_stop,
161 	.ping		= cgbc_wdt_keepalive,
162 	.set_timeout	= cgbc_wdt_set_timeout,
163 	.set_pretimeout = cgbc_wdt_set_pretimeout,
164 };
165 
cgbc_wdt_probe(struct platform_device * pdev)166 static int cgbc_wdt_probe(struct platform_device *pdev)
167 {
168 	struct cgbc_device_data *cgbc = dev_get_drvdata(pdev->dev.parent);
169 	struct device *dev = &pdev->dev;
170 	struct cgbc_wdt_data *wdt_data;
171 	struct watchdog_device *wdd;
172 
173 	wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL);
174 	if (!wdt_data)
175 		return -ENOMEM;
176 
177 	wdt_data->cgbc = cgbc;
178 	wdd = &wdt_data->wdd;
179 	wdd->parent = dev;
180 
181 	wdd->info = &cgbc_wdt_info;
182 	wdd->ops = &cgbc_wdt_ops;
183 	wdd->max_timeout = CGBC_WDT_MAX_TIMEOUT;
184 	wdd->min_timeout = CGBC_WDT_MIN_TIMEOUT;
185 
186 	watchdog_set_drvdata(wdd, wdt_data);
187 	watchdog_set_nowayout(wdd, nowayout);
188 
189 	wdd->timeout = CGBC_WDT_DEFAULT_TIMEOUT;
190 	watchdog_init_timeout(wdd, timeout, dev);
191 	cgbc_wdt_set_pretimeout(wdd, pretimeout);
192 
193 	platform_set_drvdata(pdev, wdt_data);
194 	watchdog_stop_on_reboot(wdd);
195 	watchdog_stop_on_unregister(wdd);
196 
197 	return devm_watchdog_register_device(dev, wdd);
198 }
199 
200 static struct platform_driver cgbc_wdt_driver = {
201 	.driver		= {
202 		.name	= "cgbc-wdt",
203 	},
204 	.probe		= cgbc_wdt_probe,
205 };
206 
207 module_platform_driver(cgbc_wdt_driver);
208 
209 MODULE_DESCRIPTION("Congatec Board Controller Watchdog Driver");
210 MODULE_AUTHOR("Thomas Richard <thomas.richard@bootlin.com>");
211 MODULE_LICENSE("GPL");
212