移去rt

hc

2023-12-08 01573e231f18eb2d99162747186f59511f56b64d

 kernel/drivers/uio/uio_pdrv_genirq.c
..
..
@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * drivers/uio/uio_pdrv_genirq.c
3
4
  *
..
..
@@ -8,10 +9,6 @@
8
9
  * Based on uio_pdrv.c by Uwe Kleine-Koenig,
9
10
  * Copyright (C) 2008 by Digi International Inc.
10
11
  * All rights reserved.
11
- *
12
- * This program is free software; you can redistribute it and/or modify it
13
- * under the terms of the GNU General Public License version 2 as published by
14
- * the Free Software Foundation.
15
12
  */
16
13
 
17
14
 #include <linux/platform_device.h>
..
..
@@ -23,6 +20,7 @@
23
20
 #include <linux/stringify.h>
24
21
 #include <linux/pm_runtime.h>
25
22
 #include <linux/slab.h>
23
+#include <linux/irq.h>
26
24
 
27
25
 #include <linux/of.h>
28
26
 #include <linux/of_platform.h>
..
..
@@ -102,15 +100,25 @@
102
100
 	return 0;
103
101
 }
104
102
 
103
+static void uio_pdrv_genirq_cleanup(void *data)
104
+{
105
+	struct device *dev = data;
106
+
107
+	pm_runtime_disable(dev);
108
+}
109
+
105
110
 static int uio_pdrv_genirq_probe(struct platform_device *pdev)
106
111
 {
107
112
 	struct uio_info *uioinfo = dev_get_platdata(&pdev->dev);
113
+	struct device_node *node = pdev->dev.of_node;
108
114
 	struct uio_pdrv_genirq_platdata *priv;
109
115
 	struct uio_mem *uiomem;
110
116
 	int ret = -EINVAL;
111
117
 	int i;
112
118
 
113
-	if (pdev->dev.of_node) {
119
+	if (node) {
120
+		const char *name;
121
+
114
122
 		/* alloc uioinfo for one device */
115
123
 		uioinfo = devm_kzalloc(&pdev->dev, sizeof(*uioinfo),
116
124
 				       GFP_KERNEL);
..
..
@@ -118,7 +126,13 @@
118
126
 			dev_err(&pdev->dev, "unable to kmalloc\n");
119
127
 			return -ENOMEM;
120
128
 		}
121
-		uioinfo->name = pdev->dev.of_node->name;
129
+
130
+		if (!of_property_read_string(node, "linux,uio-name", &name))
131
+			uioinfo->name = devm_kstrdup(&pdev->dev, name, GFP_KERNEL);
132
+		else
133
+			uioinfo->name = devm_kasprintf(&pdev->dev, GFP_KERNEL,
134
+						       "%pOFn", node);
135
+
122
136
 		uioinfo->version = "devicetree";
123
137
 		/* Multiple IRQs are not supported */
124
138
 	}
..
..
@@ -146,13 +160,32 @@
146
160
 	priv->pdev = pdev;
147
161
 
148
162
 	if (!uioinfo->irq) {
149
-		ret = platform_get_irq(pdev, 0);
163
+		ret = platform_get_irq_optional(pdev, 0);
150
164
 		uioinfo->irq = ret;
151
165
 		if (ret == -ENXIO)
152
166
 			uioinfo->irq = UIO_IRQ_NONE;
167
+		else if (ret == -EPROBE_DEFER)
168
+			return ret;
153
169
 		else if (ret < 0) {
154
170
 			dev_err(&pdev->dev, "failed to get IRQ\n");
155
171
 			return ret;
172
+		}
173
+	}
174
+
175
+	if (uioinfo->irq) {
176
+		struct irq_data *irq_data = irq_get_irq_data(uioinfo->irq);
177
+
178
+		/*
179
+		 * If a level interrupt, dont do lazy disable. Otherwise the
180
+		 * irq will fire again since clearing of the actual cause, on
181
+		 * device level, is done in userspace
182
+		 * irqd_is_level_type() isn't used since isn't valid until
183
+		 * irq is configured.
184
+		 */
185
+		if (irq_data &&
186
+		    irqd_get_trigger_type(irq_data) & IRQ_TYPE_LEVEL_MASK) {
187
+			dev_dbg(&pdev->dev, "disable lazy unmask\n");
188
+			irq_set_status_flags(uioinfo->irq, IRQ_DISABLE_UNLAZY);
156
189
 		}
157
190
 	}
158
191
 
..
..
@@ -172,8 +205,10 @@
172
205
 		}
173
206
 
174
207
 		uiomem->memtype = UIO_MEM_PHYS;
175
-		uiomem->addr = r->start;
176
-		uiomem->size = resource_size(r);
208
+		uiomem->addr = r->start & PAGE_MASK;
209
+		uiomem->offs = r->start & ~PAGE_MASK;
210
+		uiomem->size = (uiomem->offs + resource_size(r)
211
+				+ PAGE_SIZE - 1) & PAGE_MASK;
177
212
 		uiomem->name = r->name;
178
213
 		++uiomem;
179
214
 	}
..
..
@@ -205,28 +240,16 @@
205
240
 	 */
206
241
 	pm_runtime_enable(&pdev->dev);
207
242
 
208
-	ret = uio_register_device(&pdev->dev, priv->uioinfo);
209
-	if (ret) {
210
-		dev_err(&pdev->dev, "unable to register uio device\n");
211
-		pm_runtime_disable(&pdev->dev);
243
+	ret = devm_add_action_or_reset(&pdev->dev, uio_pdrv_genirq_cleanup,
244
+				       &pdev->dev);
245
+	if (ret)
212
246
 		return ret;
213
-	}
214
247
 
215
-	platform_set_drvdata(pdev, priv);
216
-	return 0;
217
-}
248
+	ret = devm_uio_register_device(&pdev->dev, priv->uioinfo);
249
+	if (ret)
250
+		dev_err(&pdev->dev, "unable to register uio device\n");
218
251
 
219
-static int uio_pdrv_genirq_remove(struct platform_device *pdev)
220
-{
221
-	struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev);
222
-
223
-	uio_unregister_device(priv->uioinfo);
224
-	pm_runtime_disable(&pdev->dev);
225
-
226
-	priv->uioinfo->handler = NULL;
227
-	priv->uioinfo->irqcontrol = NULL;
228
-
229
-	return 0;
252
+	return ret;
230
253
 }
231
254
 
232
255
 static int uio_pdrv_genirq_runtime_nop(struct device *dev)
..
..
@@ -263,7 +286,6 @@
263
286
 
264
287
 static struct platform_driver uio_pdrv_genirq = {
265
288
 	.probe = uio_pdrv_genirq_probe,
266
-	.remove = uio_pdrv_genirq_remove,
267
289
 	.driver = {
268
290
 		.name = DRIVER_NAME,
269
291
 		.pm = &uio_pdrv_genirq_dev_pm_ops,