forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-08 01573e231f18eb2d99162747186f59511f56b64d 
 kernel/include/linux/virtio_config.h
....@@ -6,12 +6,23 @@
66 #include <linux/bug.h>
77 #include <linux/virtio.h>
88 #include <linux/virtio_byteorder.h>
9
+#include <linux/compiler_types.h>
910 #include <uapi/linux/virtio_config.h>
1011 
1112 struct irq_affinity;
1213 
14
+struct virtio_shm_region {
15
+	u64 addr;
16
+	u64 len;
17
+};
18
+
1319 /**
1420  * virtio_config_ops - operations for configuring a virtio device
21
+ * Note: Do not assume that a transport implements all of the operations
22
+ *       getting/setting a value as a simple read/write! Generally speaking,
23
+ *       any of @get/@set, @get_status/@set_status, or @get_features/
24
+ *       @finalize_features are NOT safe to be called from an atomic
25
+ *       context.
1526  * @get: read the value of a configuration field
1627  *	vdev: the virtio_device
1728  *	offset: the offset of the configuration field
....@@ -22,7 +33,7 @@
2233  *	offset: the offset of the configuration field
2334  *	buf: the buffer to read the field value from.
2435  *	len: the length of the buffer
25
- * @generation: config generation counter
36
+ * @generation: config generation counter (optional)
2637  *	vdev: the virtio_device
2738  *	Returns the config generation counter
2839  * @get_status: read the status byte
....@@ -48,18 +59,20 @@
4859  * @del_vqs: free virtqueues found by find_vqs().
4960  * @get_features: get the array of feature bits for this device.
5061  *	vdev: the virtio_device
51
- *	Returns the first 32 feature bits (all we currently need).
62
+ *	Returns the first 64 feature bits (all we currently need).
5263  * @finalize_features: confirm what device features we'll be using.
5364  *	vdev: the virtio_device
54
- *	This gives the final feature bits for the device: it can change
65
+ *	This sends the driver feature bits to the device: it can change
5566  *	the dev->feature bits if it wants.
67
+ * Note: despite the name this can be called any number of times.
5668  *	Returns 0 on success or error status
57
- * @bus_name: return the bus name associated with the device
69
+ * @bus_name: return the bus name associated with the device (optional)
5870  *	vdev: the virtio_device
5971  *      This returns a pointer to the bus name a la pci_name from which
6072  *      the caller can then copy.
61
- * @set_vq_affinity: set the affinity for a virtqueue.
73
+ * @set_vq_affinity: set the affinity for a virtqueue (optional).
6274  * @get_vq_affinity: get the affinity for a virtqueue (optional).
75
+ * @get_shm_region: get a shared memory region based on the index.
6376  */
6477 typedef void vq_callback_t(struct virtqueue *);
6578 struct virtio_config_ops {
....@@ -83,6 +96,8 @@
8396 			       const struct cpumask *cpu_mask);
8497 	const struct cpumask *(*get_vq_affinity)(struct virtio_device *vdev,
8598 			int index);
99
+	bool (*get_shm_region)(struct virtio_device *vdev,
100
+			       struct virtio_shm_region *region, u8 id);
86101 };
87102 
88103 /* If driver didn't advertise the feature, it will never appear. */
....@@ -157,16 +172,16 @@
157172 }
158173 
159174 /**
160
- * virtio_has_iommu_quirk - determine whether this device has the iommu quirk
175
+ * virtio_has_dma_quirk - determine whether this device has the DMA quirk
161176  * @vdev: the device
162177  */
163
-static inline bool virtio_has_iommu_quirk(const struct virtio_device *vdev)
178
+static inline bool virtio_has_dma_quirk(const struct virtio_device *vdev)
164179 {
165180 	/*
166181 	 * Note the reverse polarity of the quirk feature (compared to most
167182 	 * other features), this is for compatibility with legacy systems.
168183 	 */
169
-	return !virtio_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM);
184
+	return !virtio_has_feature(vdev, VIRTIO_F_ACCESS_PLATFORM);
170185 }
171186 
172187 static inline
....@@ -245,6 +260,15 @@
245260 	return 0;
246261 }
247262 
263
+static inline
264
+bool virtio_get_shm_region(struct virtio_device *vdev,
265
+			   struct virtio_shm_region *region, u8 id)
266
+{
267
+	if (!vdev->config->get_shm_region)
268
+		return false;
269
+	return vdev->config->get_shm_region(vdev, region, id);
270
+}
271
+
248272 static inline bool virtio_is_little_endian(struct virtio_device *vdev)
249273 {
250274 	return virtio_has_feature(vdev, VIRTIO_F_VERSION_1) ||
....@@ -282,67 +306,132 @@
282306 	return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
283307 }
284308 
309
+#define virtio_to_cpu(vdev, x) \
310
+	_Generic((x), \
311
+		__u8: (x), \
312
+		__virtio16: virtio16_to_cpu((vdev), (x)), \
313
+		__virtio32: virtio32_to_cpu((vdev), (x)), \
314
+		__virtio64: virtio64_to_cpu((vdev), (x)) \
315
+		)
316
+
317
+#define cpu_to_virtio(vdev, x, m) \
318
+	_Generic((m), \
319
+		__u8: (x), \
320
+		__virtio16: cpu_to_virtio16((vdev), (x)), \
321
+		__virtio32: cpu_to_virtio32((vdev), (x)), \
322
+		__virtio64: cpu_to_virtio64((vdev), (x)) \
323
+		)
324
+
325
+#define __virtio_native_type(structname, member) \
326
+	typeof(virtio_to_cpu(NULL, ((structname*)0)->member))
327
+
285328 /* Config space accessors. */
286329 #define virtio_cread(vdev, structname, member, ptr)			\
287330 	do {								\
288
-		/* Must match the member's type, and be integer */	\
289
-		if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \
290
-			(*ptr) = 1;					\
331
+		typeof(((structname*)0)->member) virtio_cread_v;	\
291332 									\
292
-		switch (sizeof(*ptr)) {					\
333
+		might_sleep();						\
334
+		/* Sanity check: must match the member's type */	\
335
+		typecheck(typeof(virtio_to_cpu((vdev), virtio_cread_v)), *(ptr)); \
336
+									\
337
+		switch (sizeof(virtio_cread_v)) {			\
293338 		case 1:							\
294
-			*(ptr) = virtio_cread8(vdev,			\
295
-					       offsetof(structname, member)); \
296
-			break;						\
297339 		case 2:							\
298
-			*(ptr) = virtio_cread16(vdev,			\
299
-						offsetof(structname, member)); \
300
-			break;						\
301340 		case 4:							\
302
-			*(ptr) = virtio_cread32(vdev,			\
303
-						offsetof(structname, member)); \
304
-			break;						\
305
-		case 8:							\
306
-			*(ptr) = virtio_cread64(vdev,			\
307
-						offsetof(structname, member)); \
341
+			vdev->config->get((vdev), 			\
342
+					  offsetof(structname, member), \
343
+					  &virtio_cread_v,		\
344
+					  sizeof(virtio_cread_v));	\
308345 			break;						\
309346 		default:						\
310
-			BUG();						\
347
+			__virtio_cread_many((vdev), 			\
348
+					  offsetof(structname, member), \
349
+					  &virtio_cread_v,		\
350
+					  1,				\
351
+					  sizeof(virtio_cread_v));	\
352
+			break;						\
311353 		}							\
354
+		*(ptr) = virtio_to_cpu(vdev, virtio_cread_v);		\
312355 	} while(0)
313356 
314357 /* Config space accessors. */
315358 #define virtio_cwrite(vdev, structname, member, ptr)			\
316359 	do {								\
317
-		/* Must match the member's type, and be integer */	\
318
-		if (!typecheck(typeof((((structname*)0)->member)), *(ptr))) \
319
-			BUG_ON((*ptr) == 1);				\
360
+		typeof(((structname*)0)->member) virtio_cwrite_v =	\
361
+			cpu_to_virtio(vdev, *(ptr), ((structname*)0)->member); \
320362 									\
321
-		switch (sizeof(*ptr)) {					\
363
+		might_sleep();						\
364
+		/* Sanity check: must match the member's type */	\
365
+		typecheck(typeof(virtio_to_cpu((vdev), virtio_cwrite_v)), *(ptr)); \
366
+									\
367
+		vdev->config->set((vdev), offsetof(structname, member),	\
368
+				  &virtio_cwrite_v,			\
369
+				  sizeof(virtio_cwrite_v));		\
370
+	} while(0)
371
+
372
+/*
373
+ * Nothing virtio-specific about these, but let's worry about generalizing
374
+ * these later.
375
+ */
376
+#define virtio_le_to_cpu(x) \
377
+	_Generic((x), \
378
+		__u8: (u8)(x), \
379
+		 __le16: (u16)le16_to_cpu(x), \
380
+		 __le32: (u32)le32_to_cpu(x), \
381
+		 __le64: (u64)le64_to_cpu(x) \
382
+		)
383
+
384
+#define virtio_cpu_to_le(x, m) \
385
+	_Generic((m), \
386
+		 __u8: (x), \
387
+		 __le16: cpu_to_le16(x), \
388
+		 __le32: cpu_to_le32(x), \
389
+		 __le64: cpu_to_le64(x) \
390
+		)
391
+
392
+/* LE (e.g. modern) Config space accessors. */
393
+#define virtio_cread_le(vdev, structname, member, ptr)			\
394
+	do {								\
395
+		typeof(((structname*)0)->member) virtio_cread_v;	\
396
+									\
397
+		might_sleep();						\
398
+		/* Sanity check: must match the member's type */	\
399
+		typecheck(typeof(virtio_le_to_cpu(virtio_cread_v)), *(ptr)); \
400
+									\
401
+		switch (sizeof(virtio_cread_v)) {			\
322402 		case 1:							\
323
-			virtio_cwrite8(vdev,				\
324
-				       offsetof(structname, member),	\
325
-				       *(ptr));				\
326
-			break;						\
327403 		case 2:							\
328
-			virtio_cwrite16(vdev,				\
329
-					offsetof(structname, member),	\
330
-					*(ptr));			\
331
-			break;						\
332404 		case 4:							\
333
-			virtio_cwrite32(vdev,				\
334
-					offsetof(structname, member),	\
335
-					*(ptr));			\
336
-			break;						\
337
-		case 8:							\
338
-			virtio_cwrite64(vdev,				\
339
-					offsetof(structname, member),	\
340
-					*(ptr));			\
405
+			vdev->config->get((vdev), 			\
406
+					  offsetof(structname, member), \
407
+					  &virtio_cread_v,		\
408
+					  sizeof(virtio_cread_v));	\
341409 			break;						\
342410 		default:						\
343
-			BUG();						\
411
+			__virtio_cread_many((vdev), 			\
412
+					  offsetof(structname, member), \
413
+					  &virtio_cread_v,		\
414
+					  1,				\
415
+					  sizeof(virtio_cread_v));	\
416
+			break;						\
344417 		}							\
418
+		*(ptr) = virtio_le_to_cpu(virtio_cread_v);		\
345419 	} while(0)
420
+
421
+#define virtio_cwrite_le(vdev, structname, member, ptr)			\
422
+	do {								\
423
+		typeof(((structname*)0)->member) virtio_cwrite_v =	\
424
+			virtio_cpu_to_le(*(ptr), ((structname*)0)->member); \
425
+									\
426
+		might_sleep();						\
427
+		/* Sanity check: must match the member's type */	\
428
+		typecheck(typeof(virtio_le_to_cpu(virtio_cwrite_v)), *(ptr)); \
429
+									\
430
+		vdev->config->set((vdev), offsetof(structname, member),	\
431
+				  &virtio_cwrite_v,			\
432
+				  sizeof(virtio_cwrite_v));		\
433
+	} while(0)
434
+
346435 
347436 /* Read @count fields, @bytes each. */
348437 static inline void __virtio_cread_many(struct virtio_device *vdev,
....@@ -353,6 +442,7 @@
353442 		vdev->config->generation(vdev) : 0;
354443 	int i;
355444 
445
+	might_sleep();
356446 	do {
357447 		old = gen;
358448 
....@@ -375,6 +465,8 @@
375465 static inline u8 virtio_cread8(struct virtio_device *vdev, unsigned int offset)
376466 {
377467 	u8 ret;
468
+
469
+	might_sleep();
378470 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
379471 	return ret;
380472 }
....@@ -382,52 +474,67 @@
382474 static inline void virtio_cwrite8(struct virtio_device *vdev,
383475 				  unsigned int offset, u8 val)
384476 {
477
+	might_sleep();
385478 	vdev->config->set(vdev, offset, &val, sizeof(val));
386479 }
387480 
388481 static inline u16 virtio_cread16(struct virtio_device *vdev,
389482 				 unsigned int offset)
390483 {
391
-	u16 ret;
484
+	__virtio16 ret;
485
+
486
+	might_sleep();
392487 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
393
-	return virtio16_to_cpu(vdev, (__force __virtio16)ret);
488
+	return virtio16_to_cpu(vdev, ret);
394489 }
395490 
396491 static inline void virtio_cwrite16(struct virtio_device *vdev,
397492 				   unsigned int offset, u16 val)
398493 {
399
-	val = (__force u16)cpu_to_virtio16(vdev, val);
400
-	vdev->config->set(vdev, offset, &val, sizeof(val));
494
+	__virtio16 v;
495
+
496
+	might_sleep();
497
+	v = cpu_to_virtio16(vdev, val);
498
+	vdev->config->set(vdev, offset, &v, sizeof(v));
401499 }
402500 
403501 static inline u32 virtio_cread32(struct virtio_device *vdev,
404502 				 unsigned int offset)
405503 {
406
-	u32 ret;
504
+	__virtio32 ret;
505
+
506
+	might_sleep();
407507 	vdev->config->get(vdev, offset, &ret, sizeof(ret));
408
-	return virtio32_to_cpu(vdev, (__force __virtio32)ret);
508
+	return virtio32_to_cpu(vdev, ret);
409509 }
410510 
411511 static inline void virtio_cwrite32(struct virtio_device *vdev,
412512 				   unsigned int offset, u32 val)
413513 {
414
-	val = (__force u32)cpu_to_virtio32(vdev, val);
415
-	vdev->config->set(vdev, offset, &val, sizeof(val));
514
+	__virtio32 v;
515
+
516
+	might_sleep();
517
+	v = cpu_to_virtio32(vdev, val);
518
+	vdev->config->set(vdev, offset, &v, sizeof(v));
416519 }
417520 
418521 static inline u64 virtio_cread64(struct virtio_device *vdev,
419522 				 unsigned int offset)
420523 {
421
-	u64 ret;
524
+	__virtio64 ret;
525
+
422526 	__virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
423
-	return virtio64_to_cpu(vdev, (__force __virtio64)ret);
527
+	return virtio64_to_cpu(vdev, ret);
424528 }
425529 
426530 static inline void virtio_cwrite64(struct virtio_device *vdev,
427531 				   unsigned int offset, u64 val)
428532 {
429
-	val = (__force u64)cpu_to_virtio64(vdev, val);
430
-	vdev->config->set(vdev, offset, &val, sizeof(val));
533
+	__virtio64 v;
534
+
535
+	might_sleep();
536
+	v = cpu_to_virtio64(vdev, val);
537
+	vdev->config->set(vdev, offset, &v, sizeof(v));
431538 }
432539 
433540 /* Conditional config space accessors. */
....@@ -441,4 +548,24 @@
441548 		_r;							\
442549 	})
443550 
551
+/* Conditional config space accessors. */
552
+#define virtio_cread_le_feature(vdev, fbit, structname, member, ptr)	\
553
+	({								\
554
+		int _r = 0;						\
555
+		if (!virtio_has_feature(vdev, fbit))			\
556
+			_r = -ENOENT;					\
557
+		else							\
558
+			virtio_cread_le((vdev), structname, member, ptr); \
559
+		_r;							\
560
+	})
561
+
562
+#ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS
563
+int arch_has_restricted_virtio_memory_access(void);
564
+#else
565
+static inline int arch_has_restricted_virtio_memory_access(void)
566
+{
567
+	return 0;
568
+}
569
+#endif /* CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS */
570
+
444571 #endif /* _LINUX_VIRTIO_CONFIG_H */