change system file

hc

2024-10-09 244b2c5ca8b14627e4a17755e5922221e121c771

 kernel/drivers/watchdog/ts4800_wdt.c
..
..
@@ -108,7 +108,8 @@
108
108
 
109
109
 static int ts4800_wdt_probe(struct platform_device *pdev)
110
110
 {
111
-	struct device_node *np = pdev->dev.of_node;
111
+	struct device *dev = &pdev->dev;
112
+	struct device_node *np = dev->of_node;
112
113
 	struct device_node *syscon_np;
113
114
 	struct watchdog_device *wdd;
114
115
 	struct ts4800_wdt *wdt;
..
..
@@ -117,32 +118,36 @@
117
118
 
118
119
 	syscon_np = of_parse_phandle(np, "syscon", 0);
119
120
 	if (!syscon_np) {
120
-		dev_err(&pdev->dev, "no syscon property\n");
121
+		dev_err(dev, "no syscon property\n");
121
122
 		return -ENODEV;
122
123
 	}
123
124
 
124
125
 	ret = of_property_read_u32_index(np, "syscon", 1, &reg);
125
126
 	if (ret < 0) {
126
-		dev_err(&pdev->dev, "no offset in syscon\n");
127
+		dev_err(dev, "no offset in syscon\n");
128
+		of_node_put(syscon_np);
127
129
 		return ret;
128
130
 	}
129
131
 
130
132
 	/* allocate memory for watchdog struct */
131
-	wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
132
-	if (!wdt)
133
+	wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
134
+	if (!wdt) {
135
+		of_node_put(syscon_np);
133
136
 		return -ENOMEM;
137
+	}
134
138
 
135
139
 	/* set regmap and offset to know where to write */
136
140
 	wdt->feed_offset = reg;
137
141
 	wdt->regmap = syscon_node_to_regmap(syscon_np);
142
+	of_node_put(syscon_np);
138
143
 	if (IS_ERR(wdt->regmap)) {
139
-		dev_err(&pdev->dev, "cannot get parent's regmap\n");
144
+		dev_err(dev, "cannot get parent's regmap\n");
140
145
 		return PTR_ERR(wdt->regmap);
141
146
 	}
142
147
 
143
148
 	/* Initialize struct watchdog_device */
144
149
 	wdd = &wdt->wdd;
145
-	wdd->parent = &pdev->dev;
150
+	wdd->parent = dev;
146
151
 	wdd->info = &ts4800_wdt_info;
147
152
 	wdd->ops = &ts4800_wdt_ops;
148
153
 	wdd->min_timeout = ts4800_wdt_map[0].timeout;
..
..
@@ -150,7 +155,7 @@
150
155
 
151
156
 	watchdog_set_drvdata(wdd, wdt);
152
157
 	watchdog_set_nowayout(wdd, nowayout);
153
-	watchdog_init_timeout(wdd, 0, &pdev->dev);
158
+	watchdog_init_timeout(wdd, 0, dev);
154
159
 
155
160
 	/*
156
161
 	 * As this watchdog supports only a few values, ts4800_wdt_set_timeout
..
..
@@ -168,27 +173,14 @@
168
173
 	 */
169
174
 	ts4800_wdt_stop(wdd);
170
175
 
171
-	ret = watchdog_register_device(wdd);
172
-	if (ret) {
173
-		dev_err(&pdev->dev,
174
-			"failed to register watchdog device\n");
176
+	ret = devm_watchdog_register_device(dev, wdd);
177
+	if (ret)
175
178
 		return ret;
176
-	}
177
179
 
178
180
 	platform_set_drvdata(pdev, wdt);
179
181
 
180
-	dev_info(&pdev->dev,
181
-		 "initialized (timeout = %d sec, nowayout = %d)\n",
182
+	dev_info(dev, "initialized (timeout = %d sec, nowayout = %d)\n",
182
183
 		 wdd->timeout, nowayout);
183
-
184
-	return 0;
185
-}
186
-
187
-static int ts4800_wdt_remove(struct platform_device *pdev)
188
-{
189
-	struct ts4800_wdt *wdt = platform_get_drvdata(pdev);
190
-
191
-	watchdog_unregister_device(&wdt->wdd);
192
184
 
193
185
 	return 0;
194
186
 }
..
..
@@ -201,7 +193,6 @@
201
193
 
202
194
 static struct platform_driver ts4800_wdt_driver = {
203
195
 	.probe		= ts4800_wdt_probe,
204
-	.remove		= ts4800_wdt_remove,
205
196
 	.driver		= {
206
197
 		.name	= "ts4800_wdt",
207
198
 		.of_match_table = ts4800_wdt_of_match,