enable docker ppp

hc

2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87

 kernel/drivers/watchdog/sprd_wdt.c
..
..
@@ -1,15 +1,7 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Spreadtrum watchdog driver
3
4
  * Copyright (C) 2017 Spreadtrum - http://www.spreadtrum.com
4
- *
5
- * This program is free software; you can redistribute it and/or
6
- * modify it under the terms of the GNU General Public License
7
- * version 2 as published by the Free Software Foundation.
8
- *
9
- * This program is distributed in the hope that it will be useful, but
10
- * WITHOUT ANY WARRANTY; without even the implied warranty of
11
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
- * General Public License for more details.
13
5
  */
14
6
 
15
7
 #include <linux/bitops.h>
..
..
@@ -246,9 +238,7 @@
246
238
 	u32 val;
247
239
 
248
240
 	val = sprd_wdt_get_cnt_value(wdt);
249
-	val = val / SPRD_WDT_CNT_STEP;
250
-
251
-	return val;
241
+	return val / SPRD_WDT_CNT_STEP;
252
242
 }
253
243
 
254
244
 static const struct watchdog_ops sprd_wdt_ops = {
..
..
@@ -270,70 +260,65 @@
270
260
 
271
261
 static int sprd_wdt_probe(struct platform_device *pdev)
272
262
 {
273
-	struct resource *wdt_res;
263
+	struct device *dev = &pdev->dev;
274
264
 	struct sprd_wdt *wdt;
275
265
 	int ret;
276
266
 
277
-	wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
267
+	wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
278
268
 	if (!wdt)
279
269
 		return -ENOMEM;
280
270
 
281
-	wdt_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
282
-	wdt->base = devm_ioremap_resource(&pdev->dev, wdt_res);
271
+	wdt->base = devm_platform_ioremap_resource(pdev, 0);
283
272
 	if (IS_ERR(wdt->base))
284
273
 		return PTR_ERR(wdt->base);
285
274
 
286
-	wdt->enable = devm_clk_get(&pdev->dev, "enable");
275
+	wdt->enable = devm_clk_get(dev, "enable");
287
276
 	if (IS_ERR(wdt->enable)) {
288
-		dev_err(&pdev->dev, "can't get the enable clock\n");
277
+		dev_err(dev, "can't get the enable clock\n");
289
278
 		return PTR_ERR(wdt->enable);
290
279
 	}
291
280
 
292
-	wdt->rtc_enable = devm_clk_get(&pdev->dev, "rtc_enable");
281
+	wdt->rtc_enable = devm_clk_get(dev, "rtc_enable");
293
282
 	if (IS_ERR(wdt->rtc_enable)) {
294
-		dev_err(&pdev->dev, "can't get the rtc enable clock\n");
283
+		dev_err(dev, "can't get the rtc enable clock\n");
295
284
 		return PTR_ERR(wdt->rtc_enable);
296
285
 	}
297
286
 
298
287
 	wdt->irq = platform_get_irq(pdev, 0);
299
-	if (wdt->irq < 0) {
300
-		dev_err(&pdev->dev, "failed to get IRQ resource\n");
288
+	if (wdt->irq < 0)
301
289
 		return wdt->irq;
302
-	}
303
290
 
304
-	ret = devm_request_irq(&pdev->dev, wdt->irq, sprd_wdt_isr,
305
-			       IRQF_NO_SUSPEND, "sprd-wdt", (void *)wdt);
291
+	ret = devm_request_irq(dev, wdt->irq, sprd_wdt_isr, IRQF_NO_SUSPEND,
292
+			       "sprd-wdt", (void *)wdt);
306
293
 	if (ret) {
307
-		dev_err(&pdev->dev, "failed to register irq\n");
294
+		dev_err(dev, "failed to register irq\n");
308
295
 		return ret;
309
296
 	}
310
297
 
311
298
 	wdt->wdd.info = &sprd_wdt_info;
312
299
 	wdt->wdd.ops = &sprd_wdt_ops;
313
-	wdt->wdd.parent = &pdev->dev;
300
+	wdt->wdd.parent = dev;
314
301
 	wdt->wdd.min_timeout = SPRD_WDT_MIN_TIMEOUT;
315
302
 	wdt->wdd.max_timeout = SPRD_WDT_MAX_TIMEOUT;
316
303
 	wdt->wdd.timeout = SPRD_WDT_MAX_TIMEOUT;
317
304
 
318
305
 	ret = sprd_wdt_enable(wdt);
319
306
 	if (ret) {
320
-		dev_err(&pdev->dev, "failed to enable wdt\n");
307
+		dev_err(dev, "failed to enable wdt\n");
321
308
 		return ret;
322
309
 	}
323
-	ret = devm_add_action(&pdev->dev, sprd_wdt_disable, wdt);
310
+	ret = devm_add_action_or_reset(dev, sprd_wdt_disable, wdt);
324
311
 	if (ret) {
325
-		sprd_wdt_disable(wdt);
326
-		dev_err(&pdev->dev, "Failed to add wdt disable action\n");
312
+		dev_err(dev, "Failed to add wdt disable action\n");
327
313
 		return ret;
328
314
 	}
329
315
 
330
316
 	watchdog_set_nowayout(&wdt->wdd, WATCHDOG_NOWAYOUT);
331
-	watchdog_init_timeout(&wdt->wdd, 0, &pdev->dev);
317
+	watchdog_init_timeout(&wdt->wdd, 0, dev);
332
318
 
333
-	ret = devm_watchdog_register_device(&pdev->dev, &wdt->wdd);
319
+	ret = devm_watchdog_register_device(dev, &wdt->wdd);
334
320
 	if (ret) {
335
321
 		sprd_wdt_disable(wdt);
336
-		dev_err(&pdev->dev, "failed to register watchdog\n");
337
322
 		return ret;
338
323
 	}
339
324
 	platform_set_drvdata(pdev, wdt);