write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/watchdog/pic32-dmt.c
..
..
@@ -1,13 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
1
2
 /*
2
3
  * PIC32 deadman timer driver
3
4
  *
4
5
  * Purna Chandra Mandal <purna.mandal@microchip.com>
5
6
  * Copyright (c) 2016, Microchip Technology Inc.
6
- *
7
- * This program is free software; you can redistribute it and/or
8
- * modify it under the terms of the GNU General Public License
9
- * as published by the Free Software Foundation; either version
10
- * 2 of the License, or (at your option) any later version.
11
7
  */
12
8
 #include <linux/clk.h>
13
9
 #include <linux/device.h>
..
..
@@ -168,69 +164,58 @@
168
164
 	.ops		= &pic32_dmt_fops,
169
165
 };
170
166
 
167
+static void pic32_clk_disable_unprepare(void *data)
168
+{
169
+	clk_disable_unprepare(data);
170
+}
171
+
171
172
 static int pic32_dmt_probe(struct platform_device *pdev)
172
173
 {
174
+	struct device *dev = &pdev->dev;
173
175
 	int ret;
174
176
 	struct pic32_dmt *dmt;
175
-	struct resource *mem;
176
177
 	struct watchdog_device *wdd = &pic32_dmt_wdd;
177
178
 
178
-	dmt = devm_kzalloc(&pdev->dev, sizeof(*dmt), GFP_KERNEL);
179
+	dmt = devm_kzalloc(dev, sizeof(*dmt), GFP_KERNEL);
179
180
 	if (!dmt)
180
181
 		return -ENOMEM;
181
182
 
182
-	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
183
-	dmt->regs = devm_ioremap_resource(&pdev->dev, mem);
183
+	dmt->regs = devm_platform_ioremap_resource(pdev, 0);
184
184
 	if (IS_ERR(dmt->regs))
185
185
 		return PTR_ERR(dmt->regs);
186
186
 
187
-	dmt->clk = devm_clk_get(&pdev->dev, NULL);
187
+	dmt->clk = devm_clk_get(dev, NULL);
188
188
 	if (IS_ERR(dmt->clk)) {
189
-		dev_err(&pdev->dev, "clk not found\n");
189
+		dev_err(dev, "clk not found\n");
190
190
 		return PTR_ERR(dmt->clk);
191
191
 	}
192
192
 
193
193
 	ret = clk_prepare_enable(dmt->clk);
194
194
 	if (ret)
195
195
 		return ret;
196
+	ret = devm_add_action_or_reset(dev, pic32_clk_disable_unprepare,
197
+				       dmt->clk);
198
+	if (ret)
199
+		return ret;
196
200
 
197
201
 	wdd->timeout = pic32_dmt_get_timeout_secs(dmt);
198
202
 	if (!wdd->timeout) {
199
-		dev_err(&pdev->dev,
200
-			"failed to read watchdog register timeout\n");
201
-		ret = -EINVAL;
202
-		goto out_disable_clk;
203
+		dev_err(dev, "failed to read watchdog register timeout\n");
204
+		return -EINVAL;
203
205
 	}
204
206
 
205
-	dev_info(&pdev->dev, "timeout %d\n", wdd->timeout);
207
+	dev_info(dev, "timeout %d\n", wdd->timeout);
206
208
 
207
209
 	wdd->bootstatus = pic32_dmt_bootstatus(dmt) ? WDIOF_CARDRESET : 0;
208
210
 
209
211
 	watchdog_set_nowayout(wdd, WATCHDOG_NOWAYOUT);
210
212
 	watchdog_set_drvdata(wdd, dmt);
211
213
 
212
-	ret = watchdog_register_device(wdd);
213
-	if (ret) {
214
-		dev_err(&pdev->dev, "watchdog register failed, err %d\n", ret);
215
-		goto out_disable_clk;
216
-	}
214
+	ret = devm_watchdog_register_device(dev, wdd);
215
+	if (ret)
216
+		return ret;
217
217
 
218
218
 	platform_set_drvdata(pdev, wdd);
219
-	return 0;
220
-
221
-out_disable_clk:
222
-	clk_disable_unprepare(dmt->clk);
223
-	return ret;
224
-}
225
-
226
-static int pic32_dmt_remove(struct platform_device *pdev)
227
-{
228
-	struct watchdog_device *wdd = platform_get_drvdata(pdev);
229
-	struct pic32_dmt *dmt = watchdog_get_drvdata(wdd);
230
-
231
-	watchdog_unregister_device(wdd);
232
-	clk_disable_unprepare(dmt->clk);
233
-
234
219
 	return 0;
235
220
 }
236
221
 
..
..
@@ -242,7 +227,6 @@
242
227
 
243
228
 static struct platform_driver pic32_dmt_driver = {
244
229
 	.probe		= pic32_dmt_probe,
245
-	.remove		= pic32_dmt_remove,
246
230
 	.driver		= {
247
231
 		.name		= "pic32-dmt",
248
232
 		.of_match_table = of_match_ptr(pic32_dmt_of_ids),