mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/drivers/watchdog/st_lpc_wdt.c
..
..
@@ -142,13 +142,18 @@
142
142
 	.ops		= &st_wdog_ops,
143
143
 };
144
144
 
145
+static void st_clk_disable_unprepare(void *data)
146
+{
147
+	clk_disable_unprepare(data);
148
+}
149
+
145
150
 static int st_wdog_probe(struct platform_device *pdev)
146
151
 {
152
+	struct device *dev = &pdev->dev;
147
153
 	const struct of_device_id *match;
148
-	struct device_node *np = pdev->dev.of_node;
154
+	struct device_node *np = dev->of_node;
149
155
 	struct st_wdog *st_wdog;
150
156
 	struct regmap *regmap;
151
-	struct resource *res;
152
157
 	struct clk *clk;
153
158
 	void __iomem *base;
154
159
 	uint32_t mode;
..
..
@@ -156,7 +161,7 @@
156
161
 
157
162
 	ret = of_property_read_u32(np, "st,lpc-mode", &mode);
158
163
 	if (ret) {
159
-		dev_err(&pdev->dev, "An LPC mode must be provided\n");
164
+		dev_err(dev, "An LPC mode must be provided\n");
160
165
 		return -EINVAL;
161
166
 	}
162
167
 
..
..
@@ -164,35 +169,34 @@
164
169
 	if (mode != ST_LPC_MODE_WDT)
165
170
 		return -ENODEV;
166
171
 
167
-	st_wdog = devm_kzalloc(&pdev->dev, sizeof(*st_wdog), GFP_KERNEL);
172
+	st_wdog = devm_kzalloc(dev, sizeof(*st_wdog), GFP_KERNEL);
168
173
 	if (!st_wdog)
169
174
 		return -ENOMEM;
170
175
 
171
-	match = of_match_device(st_wdog_match, &pdev->dev);
176
+	match = of_match_device(st_wdog_match, dev);
172
177
 	if (!match) {
173
-		dev_err(&pdev->dev, "Couldn't match device\n");
178
+		dev_err(dev, "Couldn't match device\n");
174
179
 		return -ENODEV;
175
180
 	}
176
181
 	st_wdog->syscfg	= (struct st_wdog_syscfg *)match->data;
177
182
 
178
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
179
-	base = devm_ioremap_resource(&pdev->dev, res);
183
+	base = devm_platform_ioremap_resource(pdev, 0);
180
184
 	if (IS_ERR(base))
181
185
 		return PTR_ERR(base);
182
186
 
183
187
 	regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg");
184
188
 	if (IS_ERR(regmap)) {
185
-		dev_err(&pdev->dev, "No syscfg phandle specified\n");
189
+		dev_err(dev, "No syscfg phandle specified\n");
186
190
 		return PTR_ERR(regmap);
187
191
 	}
188
192
 
189
-	clk = devm_clk_get(&pdev->dev, NULL);
193
+	clk = devm_clk_get(dev, NULL);
190
194
 	if (IS_ERR(clk)) {
191
-		dev_err(&pdev->dev, "Unable to request clock\n");
195
+		dev_err(dev, "Unable to request clock\n");
192
196
 		return PTR_ERR(clk);
193
197
 	}
194
198
 
195
-	st_wdog->dev		= &pdev->dev;
199
+	st_wdog->dev		= dev;
196
200
 	st_wdog->base		= base;
197
201
 	st_wdog->clk		= clk;
198
202
 	st_wdog->regmap		= regmap;
..
..
@@ -200,39 +204,36 @@
200
204
 	st_wdog->clkrate	= clk_get_rate(st_wdog->clk);
201
205
 
202
206
 	if (!st_wdog->clkrate) {
203
-		dev_err(&pdev->dev, "Unable to fetch clock rate\n");
207
+		dev_err(dev, "Unable to fetch clock rate\n");
204
208
 		return -EINVAL;
205
209
 	}
206
210
 	st_wdog_dev.max_timeout = 0xFFFFFFFF / st_wdog->clkrate;
207
-	st_wdog_dev.parent = &pdev->dev;
211
+	st_wdog_dev.parent = dev;
208
212
 
209
213
 	ret = clk_prepare_enable(clk);
210
214
 	if (ret) {
211
-		dev_err(&pdev->dev, "Unable to enable clock\n");
215
+		dev_err(dev, "Unable to enable clock\n");
212
216
 		return ret;
213
217
 	}
218
+	ret = devm_add_action_or_reset(dev, st_clk_disable_unprepare, clk);
219
+	if (ret)
220
+		return ret;
214
221
 
215
222
 	watchdog_set_drvdata(&st_wdog_dev, st_wdog);
216
223
 	watchdog_set_nowayout(&st_wdog_dev, WATCHDOG_NOWAYOUT);
217
224
 
218
225
 	/* Init Watchdog timeout with value in DT */
219
-	ret = watchdog_init_timeout(&st_wdog_dev, 0, &pdev->dev);
220
-	if (ret) {
221
-		dev_err(&pdev->dev, "Unable to initialise watchdog timeout\n");
222
-		clk_disable_unprepare(clk);
226
+	ret = watchdog_init_timeout(&st_wdog_dev, 0, dev);
227
+	if (ret)
223
228
 		return ret;
224
-	}
225
229
 
226
-	ret = watchdog_register_device(&st_wdog_dev);
227
-	if (ret) {
228
-		dev_err(&pdev->dev, "Unable to register watchdog\n");
229
-		clk_disable_unprepare(clk);
230
+	ret = devm_watchdog_register_device(dev, &st_wdog_dev);
231
+	if (ret)
230
232
 		return ret;
231
-	}
232
233
 
233
234
 	st_wdog_setup(st_wdog, true);
234
235
 
235
-	dev_info(&pdev->dev, "LPC Watchdog driver registered, reset type is %s",
236
+	dev_info(dev, "LPC Watchdog driver registered, reset type is %s",
236
237
 		 st_wdog->warm_reset ? "warm" : "cold");
237
238
 
238
239
 	return ret;
..
..
@@ -243,8 +244,6 @@
243
244
 	struct st_wdog *st_wdog = watchdog_get_drvdata(&st_wdog_dev);
244
245
 
245
246
 	st_wdog_setup(st_wdog, false);
246
-	watchdog_unregister_device(&st_wdog_dev);
247
-	clk_disable_unprepare(st_wdog->clk);
248
247
 
249
248
 	return 0;
250
249
 }