change system file

hc

2024-10-09 244b2c5ca8b14627e4a17755e5922221e121c771

 kernel/drivers/watchdog/lpc18xx_wdt.c
..
..
@@ -1,11 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * NXP LPC18xx Watchdog Timer (WDT)
3
4
  *
4
5
  * Copyright (c) 2015 Ariel D'Alessandro <ariel@vanguardiasur.com>
5
- *
6
- * This program is free software; you can redistribute it and/or modify it
7
- * under the terms of the GNU General Public License version 2 as published by
8
- * the Free Software Foundation.
9
6
  *
10
7
  * Notes
11
8
  * -----
..
..
@@ -200,19 +197,22 @@
200
197
 	.restart        = lpc18xx_wdt_restart,
201
198
 };
202
199
 
200
+static void lpc18xx_clk_disable_unprepare(void *data)
201
+{
202
+	clk_disable_unprepare(data);
203
+}
204
+
203
205
 static int lpc18xx_wdt_probe(struct platform_device *pdev)
204
206
 {
205
207
 	struct lpc18xx_wdt_dev *lpc18xx_wdt;
206
208
 	struct device *dev = &pdev->dev;
207
-	struct resource *res;
208
209
 	int ret;
209
210
 
210
211
 	lpc18xx_wdt = devm_kzalloc(dev, sizeof(*lpc18xx_wdt), GFP_KERNEL);
211
212
 	if (!lpc18xx_wdt)
212
213
 		return -ENOMEM;
213
214
 
214
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
215
-	lpc18xx_wdt->base = devm_ioremap_resource(dev, res);
215
+	lpc18xx_wdt->base = devm_platform_ioremap_resource(pdev, 0);
216
216
 	if (IS_ERR(lpc18xx_wdt->base))
217
217
 		return PTR_ERR(lpc18xx_wdt->base);
218
218
 
..
..
@@ -233,19 +233,26 @@
233
233
 		dev_err(dev, "could not prepare or enable sys clock\n");
234
234
 		return ret;
235
235
 	}
236
+	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
237
+				       lpc18xx_wdt->reg_clk);
238
+	if (ret)
239
+		return ret;
236
240
 
237
241
 	ret = clk_prepare_enable(lpc18xx_wdt->wdt_clk);
238
242
 	if (ret) {
239
243
 		dev_err(dev, "could not prepare or enable wdt clock\n");
240
-		goto disable_reg_clk;
244
+		return ret;
241
245
 	}
246
+	ret = devm_add_action_or_reset(dev, lpc18xx_clk_disable_unprepare,
247
+				       lpc18xx_wdt->wdt_clk);
248
+	if (ret)
249
+		return ret;
242
250
 
243
251
 	/* We use the clock rate to calculate timeouts */
244
252
 	lpc18xx_wdt->clk_rate = clk_get_rate(lpc18xx_wdt->wdt_clk);
245
253
 	if (lpc18xx_wdt->clk_rate == 0) {
246
254
 		dev_err(dev, "failed to get clock rate\n");
247
-		ret = -EINVAL;
248
-		goto disable_wdt_clk;
255
+		return -EINVAL;
249
256
 	}
250
257
 
251
258
 	lpc18xx_wdt->wdt_dev.info = &lpc18xx_wdt_info;
..
..
@@ -276,24 +283,8 @@
276
283
 
277
284
 	platform_set_drvdata(pdev, lpc18xx_wdt);
278
285
 
279
-	ret = watchdog_register_device(&lpc18xx_wdt->wdt_dev);
280
-	if (ret)
281
-		goto disable_wdt_clk;
282
-
283
-	return 0;
284
-
285
-disable_wdt_clk:
286
-	clk_disable_unprepare(lpc18xx_wdt->wdt_clk);
287
-disable_reg_clk:
288
-	clk_disable_unprepare(lpc18xx_wdt->reg_clk);
289
-	return ret;
290
-}
291
-
292
-static void lpc18xx_wdt_shutdown(struct platform_device *pdev)
293
-{
294
-	struct lpc18xx_wdt_dev *lpc18xx_wdt = platform_get_drvdata(pdev);
295
-
296
-	lpc18xx_wdt_stop(&lpc18xx_wdt->wdt_dev);
286
+	watchdog_stop_on_reboot(&lpc18xx_wdt->wdt_dev);
287
+	return devm_watchdog_register_device(dev, &lpc18xx_wdt->wdt_dev);
297
288
 }
298
289
 
299
290
 static int lpc18xx_wdt_remove(struct platform_device *pdev)
..
..
@@ -302,10 +293,6 @@
302
293
 
303
294
 	dev_warn(&pdev->dev, "I quit now, hardware will probably reboot!\n");
304
295
 	del_timer_sync(&lpc18xx_wdt->timer);
305
-
306
-	watchdog_unregister_device(&lpc18xx_wdt->wdt_dev);
307
-	clk_disable_unprepare(lpc18xx_wdt->wdt_clk);
308
-	clk_disable_unprepare(lpc18xx_wdt->reg_clk);
309
296
 
310
297
 	return 0;
311
298
 }
..
..
@@ -323,7 +310,6 @@
323
310
 	},
324
311
 	.probe = lpc18xx_wdt_probe,
325
312
 	.remove = lpc18xx_wdt_remove,
326
-	.shutdown = lpc18xx_wdt_shutdown,
327
313
 };
328
314
 module_platform_driver(lpc18xx_wdt_driver);
329
315