1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * ARM Secure Monitor Call watchdog driver |
4 | * |
5 | * Copyright 2020 Google LLC. |
6 | * Julius Werner <jwerner@chromium.org> |
7 | * Based on mtk_wdt.c |
8 | */ |
9 | |
10 | #include <linux/arm-smccc.h> |
11 | #include <linux/err.h> |
12 | #include <linux/module.h> |
13 | #include <linux/moduleparam.h> |
14 | #include <linux/of.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/types.h> |
17 | #include <linux/watchdog.h> |
18 | #include <uapi/linux/psci.h> |
19 | |
20 | #define DRV_NAME "arm_smc_wdt" |
21 | #define DRV_VERSION "1.0" |
22 | |
23 | enum smcwd_call { |
24 | SMCWD_INIT = 0, |
25 | SMCWD_SET_TIMEOUT = 1, |
26 | SMCWD_ENABLE = 2, |
27 | SMCWD_PET = 3, |
28 | SMCWD_GET_TIMELEFT = 4, |
29 | }; |
30 | |
31 | static bool nowayout = WATCHDOG_NOWAYOUT; |
32 | static unsigned int timeout; |
33 | |
34 | static int smcwd_call(struct watchdog_device *wdd, enum smcwd_call call, |
35 | unsigned long arg, struct arm_smccc_res *res) |
36 | { |
37 | struct arm_smccc_res local_res; |
38 | |
39 | if (!res) |
40 | res = &local_res; |
41 | |
42 | arm_smccc_smc((u32)(uintptr_t)watchdog_get_drvdata(wdd), call, arg, 0, |
43 | 0, 0, 0, 0, res); |
44 | |
45 | if (res->a0 == PSCI_RET_NOT_SUPPORTED) |
46 | return -ENODEV; |
47 | if (res->a0 == PSCI_RET_INVALID_PARAMS) |
48 | return -EINVAL; |
49 | if (res->a0 != PSCI_RET_SUCCESS) |
50 | return -EIO; |
51 | return 0; |
52 | } |
53 | |
54 | static int smcwd_ping(struct watchdog_device *wdd) |
55 | { |
56 | return smcwd_call(wdd, call: SMCWD_PET, arg: 0, NULL); |
57 | } |
58 | |
59 | static unsigned int smcwd_get_timeleft(struct watchdog_device *wdd) |
60 | { |
61 | struct arm_smccc_res res; |
62 | |
63 | smcwd_call(wdd, call: SMCWD_GET_TIMELEFT, arg: 0, res: &res); |
64 | if (res.a0) |
65 | return 0; |
66 | return res.a1; |
67 | } |
68 | |
69 | static int smcwd_set_timeout(struct watchdog_device *wdd, unsigned int timeout) |
70 | { |
71 | int res; |
72 | |
73 | res = smcwd_call(wdd, call: SMCWD_SET_TIMEOUT, arg: timeout, NULL); |
74 | if (!res) |
75 | wdd->timeout = timeout; |
76 | return res; |
77 | } |
78 | |
79 | static int smcwd_stop(struct watchdog_device *wdd) |
80 | { |
81 | return smcwd_call(wdd, call: SMCWD_ENABLE, arg: 0, NULL); |
82 | } |
83 | |
84 | static int smcwd_start(struct watchdog_device *wdd) |
85 | { |
86 | return smcwd_call(wdd, call: SMCWD_ENABLE, arg: 1, NULL); |
87 | } |
88 | |
89 | static const struct watchdog_info smcwd_info = { |
90 | .identity = DRV_NAME, |
91 | .options = WDIOF_SETTIMEOUT | |
92 | WDIOF_KEEPALIVEPING | |
93 | WDIOF_MAGICCLOSE, |
94 | }; |
95 | |
96 | static const struct watchdog_ops smcwd_ops = { |
97 | .start = smcwd_start, |
98 | .stop = smcwd_stop, |
99 | .ping = smcwd_ping, |
100 | .set_timeout = smcwd_set_timeout, |
101 | }; |
102 | |
103 | static const struct watchdog_ops smcwd_timeleft_ops = { |
104 | .start = smcwd_start, |
105 | .stop = smcwd_stop, |
106 | .ping = smcwd_ping, |
107 | .set_timeout = smcwd_set_timeout, |
108 | .get_timeleft = smcwd_get_timeleft, |
109 | }; |
110 | |
111 | static int smcwd_probe(struct platform_device *pdev) |
112 | { |
113 | struct watchdog_device *wdd; |
114 | int err; |
115 | struct arm_smccc_res res; |
116 | u32 smc_func_id; |
117 | |
118 | wdd = devm_kzalloc(dev: &pdev->dev, size: sizeof(*wdd), GFP_KERNEL); |
119 | if (!wdd) |
120 | return -ENOMEM; |
121 | platform_set_drvdata(pdev, data: wdd); |
122 | |
123 | if (of_property_read_u32(np: pdev->dev.of_node, propname: "arm,smc-id" , |
124 | out_value: &smc_func_id)) |
125 | smc_func_id = 0x82003D06; |
126 | watchdog_set_drvdata(wdd, data: (void *)(uintptr_t)smc_func_id); |
127 | |
128 | err = smcwd_call(wdd, call: SMCWD_INIT, arg: 0, res: &res); |
129 | if (err < 0) |
130 | return err; |
131 | |
132 | wdd->info = &smcwd_info; |
133 | /* get_timeleft is optional */ |
134 | if (smcwd_call(wdd, call: SMCWD_GET_TIMELEFT, arg: 0, NULL)) |
135 | wdd->ops = &smcwd_ops; |
136 | else |
137 | wdd->ops = &smcwd_timeleft_ops; |
138 | wdd->timeout = res.a2; |
139 | wdd->max_timeout = res.a2; |
140 | wdd->min_timeout = res.a1; |
141 | wdd->parent = &pdev->dev; |
142 | |
143 | watchdog_stop_on_reboot(wdd); |
144 | watchdog_stop_on_unregister(wdd); |
145 | watchdog_set_nowayout(wdd, nowayout); |
146 | watchdog_init_timeout(wdd, timeout_parm: timeout, dev: &pdev->dev); |
147 | err = smcwd_set_timeout(wdd, timeout: wdd->timeout); |
148 | if (err) |
149 | return err; |
150 | |
151 | err = devm_watchdog_register_device(dev: &pdev->dev, wdd); |
152 | if (err) |
153 | return err; |
154 | |
155 | dev_info(&pdev->dev, |
156 | "Watchdog registered (timeout=%d sec, nowayout=%d)\n" , |
157 | wdd->timeout, nowayout); |
158 | |
159 | return 0; |
160 | } |
161 | |
162 | static const struct of_device_id smcwd_dt_ids[] = { |
163 | { .compatible = "arm,smc-wdt" }, |
164 | {} |
165 | }; |
166 | MODULE_DEVICE_TABLE(of, smcwd_dt_ids); |
167 | |
168 | static struct platform_driver smcwd_driver = { |
169 | .probe = smcwd_probe, |
170 | .driver = { |
171 | .name = DRV_NAME, |
172 | .of_match_table = smcwd_dt_ids, |
173 | }, |
174 | }; |
175 | |
176 | module_platform_driver(smcwd_driver); |
177 | |
178 | module_param(timeout, uint, 0); |
179 | MODULE_PARM_DESC(timeout, "Watchdog heartbeat in seconds" ); |
180 | |
181 | module_param(nowayout, bool, 0); |
182 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" |
183 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")" ); |
184 | |
185 | MODULE_LICENSE("GPL" ); |
186 | MODULE_AUTHOR("Julius Werner <jwerner@chromium.org>" ); |
187 | MODULE_DESCRIPTION("ARM Secure Monitor Call Watchdog Driver" ); |
188 | MODULE_VERSION(DRV_VERSION); |
189 | |