]> git.ipfire.org Git - thirdparty/u-boot.git/blob - include/virtio.h
common: Drop net.h from common header
[thirdparty/u-boot.git] / include / virtio.h
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
4 * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
5 *
6 * VirtIO is a virtualization standard for network and disk device drivers
7 * where just the guest's device driver "knows" it is running in a virtual
8 * environment, and cooperates with the hypervisor. This enables guests to
9 * get high performance network and disk operations, and gives most of the
10 * performance benefits of paravirtualization. In the U-Boot case, the guest
11 * is U-Boot itself, while the virtual environment are normally QEMU targets
12 * like ARM, RISC-V and x86.
13 *
14 * See http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.pdf for
15 * the VirtIO specification v1.0.
16 *
17 * This file is largely based on Linux kernel virtio_*.h files
18 */
19
20 #ifndef __VIRTIO_H__
21 #define __VIRTIO_H__
22
23 #define VIRTIO_ID_NET 1 /* virtio net */
24 #define VIRTIO_ID_BLOCK 2 /* virtio block */
25 #define VIRTIO_ID_RNG 4 /* virtio rng */
26 #define VIRTIO_ID_MAX_NUM 5
27
28 #define VIRTIO_NET_DRV_NAME "virtio-net"
29 #define VIRTIO_BLK_DRV_NAME "virtio-blk"
30 #define VIRTIO_RNG_DRV_NAME "virtio-rng"
31
32 /* Status byte for guest to report progress, and synchronize features */
33
34 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
35 #define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
36 /* We have found a driver for the device */
37 #define VIRTIO_CONFIG_S_DRIVER 2
38 /* Driver has used its parts of the config, and is happy */
39 #define VIRTIO_CONFIG_S_DRIVER_OK 4
40 /* Driver has finished configuring features */
41 #define VIRTIO_CONFIG_S_FEATURES_OK 8
42 /* Device entered invalid state, driver must reset it */
43 #define VIRTIO_CONFIG_S_NEEDS_RESET 0x40
44 /* We've given up on this device */
45 #define VIRTIO_CONFIG_S_FAILED 0x80
46
47 /*
48 * Virtio feature bits VIRTIO_TRANSPORT_F_START through VIRTIO_TRANSPORT_F_END
49 * are reserved for the transport being used (eg: virtio_ring, virtio_pci etc.),
50 * the rest are per-device feature bits.
51 */
52 #define VIRTIO_TRANSPORT_F_START 28
53 #define VIRTIO_TRANSPORT_F_END 38
54
55 #ifndef VIRTIO_CONFIG_NO_LEGACY
56 /*
57 * Do we get callbacks when the ring is completely used,
58 * even if we've suppressed them?
59 */
60 #define VIRTIO_F_NOTIFY_ON_EMPTY 24
61
62 /* Can the device handle any descriptor layout? */
63 #define VIRTIO_F_ANY_LAYOUT 27
64 #endif /* VIRTIO_CONFIG_NO_LEGACY */
65
66 /* v1.0 compliant */
67 #define VIRTIO_F_VERSION_1 32
68
69 /*
70 * If clear - device has the IOMMU bypass quirk feature.
71 * If set - use platform tools to detect the IOMMU.
72 *
73 * Note the reverse polarity (compared to most other features),
74 * this is for compatibility with legacy systems.
75 */
76 #define VIRTIO_F_IOMMU_PLATFORM 33
77
78 /* Does the device support Single Root I/O Virtualization? */
79 #define VIRTIO_F_SR_IOV 37
80
81 /**
82 * virtio scatter-gather struct
83 *
84 * @addr: sg buffer address
85 * @lengh: sg buffer length
86 */
87 struct virtio_sg {
88 void *addr;
89 size_t length;
90 };
91
92 struct virtqueue;
93
94 /* virtio bus operations */
95 struct dm_virtio_ops {
96 /**
97 * get_config() - read the value of a configuration field
98 *
99 * @vdev: the real virtio device
100 * @offset: the offset of the configuration field
101 * @buf: the buffer to write the field value into
102 * @len: the length of the buffer
103 * @return 0 if OK, -ve on error
104 */
105 int (*get_config)(struct udevice *vdev, unsigned int offset,
106 void *buf, unsigned int len);
107 /**
108 * set_config() - write the value of a configuration field
109 *
110 * @vdev: the real virtio device
111 * @offset: the offset of the configuration field
112 * @buf: the buffer to read the field value from
113 * @len: the length of the buffer
114 * @return 0 if OK, -ve on error
115 */
116 int (*set_config)(struct udevice *vdev, unsigned int offset,
117 const void *buf, unsigned int len);
118 /**
119 * generation() - config generation counter
120 *
121 * @vdev: the real virtio device
122 * @counter: the returned config generation counter
123 * @return 0 if OK, -ve on error
124 */
125 int (*generation)(struct udevice *vdev, u32 *counter);
126 /**
127 * get_status() - read the status byte
128 *
129 * @vdev: the real virtio device
130 * @status: the returned status byte
131 * @return 0 if OK, -ve on error
132 */
133 int (*get_status)(struct udevice *vdev, u8 *status);
134 /**
135 * set_status() - write the status byte
136 *
137 * @vdev: the real virtio device
138 * @status: the new status byte
139 * @return 0 if OK, -ve on error
140 */
141 int (*set_status)(struct udevice *vdev, u8 status);
142 /**
143 * reset() - reset the device
144 *
145 * @vdev: the real virtio device
146 * @return 0 if OK, -ve on error
147 */
148 int (*reset)(struct udevice *vdev);
149 /**
150 * get_features() - get the array of feature bits for this device
151 *
152 * @vdev: the real virtio device
153 * @features: the first 32 feature bits (all we currently need)
154 * @return 0 if OK, -ve on error
155 */
156 int (*get_features)(struct udevice *vdev, u64 *features);
157 /**
158 * set_features() - confirm what device features we'll be using
159 *
160 * @vdev: the real virtio device
161 * @return 0 if OK, -ve on error
162 */
163 int (*set_features)(struct udevice *vdev);
164 /**
165 * find_vqs() - find virtqueues and instantiate them
166 *
167 * @vdev: the real virtio device
168 * @nvqs: the number of virtqueues to find
169 * @vqs: on success, includes new virtqueues
170 * @return 0 if OK, -ve on error
171 */
172 int (*find_vqs)(struct udevice *vdev, unsigned int nvqs,
173 struct virtqueue *vqs[]);
174 /**
175 * del_vqs() - free virtqueues found by find_vqs()
176 *
177 * @vdev: the real virtio device
178 * @return 0 if OK, -ve on error
179 */
180 int (*del_vqs)(struct udevice *vdev);
181 /**
182 * notify() - notify the device to process the queue
183 *
184 * @vdev: the real virtio device
185 * @vq: virtqueue to process
186 * @return 0 if OK, -ve on error
187 */
188 int (*notify)(struct udevice *vdev, struct virtqueue *vq);
189 };
190
191 /* Get access to a virtio bus' operations */
192 #define virtio_get_ops(dev) ((struct dm_virtio_ops *)(dev)->driver->ops)
193
194 /**
195 * virtio uclass per device private data
196 *
197 * @vqs: virtualqueue for the virtio device
198 * @vdev: the real virtio device underneath
199 * @legacy: is it a legacy device?
200 * @device: virtio device ID
201 * @vendor: virtio vendor ID
202 * @features: negotiated supported features
203 * @feature_table: an array of feature supported by the driver
204 * @feature_table_size: number of entries in the feature table array
205 * @feature_table_legacy: same as feature_table but working in legacy mode
206 * @feature_table_size_legacy: number of entries in feature table legacy array
207 */
208 struct virtio_dev_priv {
209 struct list_head vqs;
210 struct udevice *vdev;
211 bool legacy;
212 u32 device;
213 u32 vendor;
214 u64 features;
215 const u32 *feature_table;
216 u32 feature_table_size;
217 const u32 *feature_table_legacy;
218 u32 feature_table_size_legacy;
219 };
220
221 /**
222 * virtio_get_config() - read the value of a configuration field
223 *
224 * @vdev: the real virtio device
225 * @offset: the offset of the configuration field
226 * @buf: the buffer to write the field value into
227 * @len: the length of the buffer
228 * @return 0 if OK, -ve on error
229 */
230 int virtio_get_config(struct udevice *vdev, unsigned int offset,
231 void *buf, unsigned int len);
232
233 /**
234 * virtio_set_config() - write the value of a configuration field
235 *
236 * @vdev: the real virtio device
237 * @offset: the offset of the configuration field
238 * @buf: the buffer to read the field value from
239 * @len: the length of the buffer
240 * @return 0 if OK, -ve on error
241 */
242 int virtio_set_config(struct udevice *vdev, unsigned int offset,
243 void *buf, unsigned int len);
244
245 /**
246 * virtio_generation() - config generation counter
247 *
248 * @vdev: the real virtio device
249 * @counter: the returned config generation counter
250 * @return 0 if OK, -ve on error
251 */
252 int virtio_generation(struct udevice *vdev, u32 *counter);
253
254 /**
255 * virtio_get_status() - read the status byte
256 *
257 * @vdev: the real virtio device
258 * @status: the returned status byte
259 * @return 0 if OK, -ve on error
260 */
261 int virtio_get_status(struct udevice *vdev, u8 *status);
262
263 /**
264 * virtio_set_status() - write the status byte
265 *
266 * @vdev: the real virtio device
267 * @status: the new status byte
268 * @return 0 if OK, -ve on error
269 */
270 int virtio_set_status(struct udevice *vdev, u8 status);
271
272 /**
273 * virtio_reset() - reset the device
274 *
275 * @vdev: the real virtio device
276 * @return 0 if OK, -ve on error
277 */
278 int virtio_reset(struct udevice *vdev);
279
280 /**
281 * virtio_get_features() - get the array of feature bits for this device
282 *
283 * @vdev: the real virtio device
284 * @features: the first 32 feature bits (all we currently need)
285 * @return 0 if OK, -ve on error
286 */
287 int virtio_get_features(struct udevice *vdev, u64 *features);
288
289 /**
290 * virtio_set_features() - confirm what device features we'll be using
291 *
292 * @vdev: the real virtio device
293 * @return 0 if OK, -ve on error
294 */
295 int virtio_set_features(struct udevice *vdev);
296
297 /**
298 * virtio_find_vqs() - find virtqueues and instantiate them
299 *
300 * @vdev: the real virtio device
301 * @nvqs: the number of virtqueues to find
302 * @vqs: on success, includes new virtqueues
303 * @return 0 if OK, -ve on error
304 */
305 int virtio_find_vqs(struct udevice *vdev, unsigned int nvqs,
306 struct virtqueue *vqs[]);
307
308 /**
309 * virtio_del_vqs() - free virtqueues found by find_vqs()
310 *
311 * @vdev: the real virtio device
312 * @return 0 if OK, -ve on error
313 */
314 int virtio_del_vqs(struct udevice *vdev);
315
316 /**
317 * virtio_notify() - notify the device to process the queue
318 *
319 * @vdev: the real virtio device
320 * @vq: virtqueue to process
321 * @return 0 if OK, -ve on error
322 */
323 int virtio_notify(struct udevice *vdev, struct virtqueue *vq);
324
325 /**
326 * virtio_add_status() - helper to set a new status code to the device
327 *
328 * @vdev: the real virtio device
329 * @status: new status code to be added
330 */
331 void virtio_add_status(struct udevice *vdev, u8 status);
332
333 /**
334 * virtio_finalize_features() - helper to finalize features
335 *
336 * @vdev: the real virtio device
337 * @return 0 if OK, -ve on error
338 */
339 int virtio_finalize_features(struct udevice *vdev);
340
341 /**
342 * virtio_driver_features_init() - initialize driver supported features
343 *
344 * This fills in the virtio device parent per child private data with the given
345 * information, which contains driver supported features and legacy features.
346 *
347 * This API should be called in the virtio device driver's bind method, so that
348 * later virtio transport uclass driver can utilize the driver supplied features
349 * to negotiate with the device on the final supported features.
350 *
351 * @priv: virtio uclass per device private data
352 * @feature: an array of feature supported by the driver
353 * @feature_size: number of entries in the feature table array
354 * @feature_legacy: same as feature_table but working in legacy mode
355 * @feature_legacy_size:number of entries in feature table legacy array
356 */
357 void virtio_driver_features_init(struct virtio_dev_priv *priv,
358 const u32 *feature,
359 u32 feature_size,
360 const u32 *feature_legacy,
361 u32 feature_legacy_size);
362
363 /**
364 * virtio_init() - helper to enumerate all known virtio devices
365 *
366 * @return 0 if OK, -ve on error
367 */
368 int virtio_init(void);
369
370 static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
371 {
372 if (little_endian)
373 return le16_to_cpu((__force __le16)val);
374 else
375 return be16_to_cpu((__force __be16)val);
376 }
377
378 static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
379 {
380 if (little_endian)
381 return (__force __virtio16)cpu_to_le16(val);
382 else
383 return (__force __virtio16)cpu_to_be16(val);
384 }
385
386 static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
387 {
388 if (little_endian)
389 return le32_to_cpu((__force __le32)val);
390 else
391 return be32_to_cpu((__force __be32)val);
392 }
393
394 static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
395 {
396 if (little_endian)
397 return (__force __virtio32)cpu_to_le32(val);
398 else
399 return (__force __virtio32)cpu_to_be32(val);
400 }
401
402 static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
403 {
404 if (little_endian)
405 return le64_to_cpu((__force __le64)val);
406 else
407 return be64_to_cpu((__force __be64)val);
408 }
409
410 static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
411 {
412 if (little_endian)
413 return (__force __virtio64)cpu_to_le64(val);
414 else
415 return (__force __virtio64)cpu_to_be64(val);
416 }
417
418 /**
419 * __virtio_test_bit - helper to test feature bits
420 *
421 * For use by transports. Devices should normally use virtio_has_feature,
422 * which includes more checks.
423 *
424 * @udev: the transport device
425 * @fbit: the feature bit
426 */
427 static inline bool __virtio_test_bit(struct udevice *udev, unsigned int fbit)
428 {
429 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
430
431 /* Did you forget to fix assumptions on max features? */
432 if (__builtin_constant_p(fbit))
433 BUILD_BUG_ON(fbit >= 64);
434 else
435 WARN_ON(fbit >= 64);
436
437 return uc_priv->features & BIT_ULL(fbit);
438 }
439
440 /**
441 * __virtio_set_bit - helper to set feature bits
442 *
443 * For use by transports.
444 *
445 * @udev: the transport device
446 * @fbit: the feature bit
447 */
448 static inline void __virtio_set_bit(struct udevice *udev, unsigned int fbit)
449 {
450 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
451
452 /* Did you forget to fix assumptions on max features? */
453 if (__builtin_constant_p(fbit))
454 BUILD_BUG_ON(fbit >= 64);
455 else
456 WARN_ON(fbit >= 64);
457
458 uc_priv->features |= BIT_ULL(fbit);
459 }
460
461 /**
462 * __virtio_clear_bit - helper to clear feature bits
463 *
464 * For use by transports.
465 *
466 * @vdev: the transport device
467 * @fbit: the feature bit
468 */
469 static inline void __virtio_clear_bit(struct udevice *udev, unsigned int fbit)
470 {
471 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
472
473 /* Did you forget to fix assumptions on max features? */
474 if (__builtin_constant_p(fbit))
475 BUILD_BUG_ON(fbit >= 64);
476 else
477 WARN_ON(fbit >= 64);
478
479 uc_priv->features &= ~BIT_ULL(fbit);
480 }
481
482 /**
483 * virtio_has_feature - helper to determine if this device has this feature
484 *
485 * Note this API is only usable after the virtio device driver's bind phase,
486 * as the feature has been negotiated between the device and the driver.
487 *
488 * @vdev: the virtio device
489 * @fbit: the feature bit
490 */
491 static inline bool virtio_has_feature(struct udevice *vdev, unsigned int fbit)
492 {
493 if (!(vdev->flags & DM_FLAG_BOUND))
494 WARN_ON(true);
495
496 return __virtio_test_bit(vdev->parent, fbit);
497 }
498
499 static inline bool virtio_legacy_is_little_endian(void)
500 {
501 #ifdef __LITTLE_ENDIAN
502 return true;
503 #else
504 return false;
505 #endif
506 }
507
508 static inline bool virtio_is_little_endian(struct udevice *vdev)
509 {
510 struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(vdev->parent);
511
512 return !uc_priv->legacy || virtio_legacy_is_little_endian();
513 }
514
515 /* Memory accessors */
516 static inline u16 virtio16_to_cpu(struct udevice *vdev, __virtio16 val)
517 {
518 return __virtio16_to_cpu(virtio_is_little_endian(vdev), val);
519 }
520
521 static inline __virtio16 cpu_to_virtio16(struct udevice *vdev, u16 val)
522 {
523 return __cpu_to_virtio16(virtio_is_little_endian(vdev), val);
524 }
525
526 static inline u32 virtio32_to_cpu(struct udevice *vdev, __virtio32 val)
527 {
528 return __virtio32_to_cpu(virtio_is_little_endian(vdev), val);
529 }
530
531 static inline __virtio32 cpu_to_virtio32(struct udevice *vdev, u32 val)
532 {
533 return __cpu_to_virtio32(virtio_is_little_endian(vdev), val);
534 }
535
536 static inline u64 virtio64_to_cpu(struct udevice *vdev, __virtio64 val)
537 {
538 return __virtio64_to_cpu(virtio_is_little_endian(vdev), val);
539 }
540
541 static inline __virtio64 cpu_to_virtio64(struct udevice *vdev, u64 val)
542 {
543 return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
544 }
545
546 /* Read @count fields, @bytes each */
547 static inline void __virtio_cread_many(struct udevice *vdev,
548 unsigned int offset,
549 void *buf, size_t count, size_t bytes)
550 {
551 u32 old, gen;
552 int i;
553
554 /* no need to check return value as generation can be optional */
555 virtio_generation(vdev, &gen);
556 do {
557 old = gen;
558
559 for (i = 0; i < count; i++)
560 virtio_get_config(vdev, offset + bytes * i,
561 buf + i * bytes, bytes);
562
563 virtio_generation(vdev, &gen);
564 } while (gen != old);
565 }
566
567 static inline void virtio_cread_bytes(struct udevice *vdev,
568 unsigned int offset,
569 void *buf, size_t len)
570 {
571 __virtio_cread_many(vdev, offset, buf, len, 1);
572 }
573
574 static inline u8 virtio_cread8(struct udevice *vdev, unsigned int offset)
575 {
576 u8 ret;
577
578 virtio_get_config(vdev, offset, &ret, sizeof(ret));
579 return ret;
580 }
581
582 static inline void virtio_cwrite8(struct udevice *vdev,
583 unsigned int offset, u8 val)
584 {
585 virtio_set_config(vdev, offset, &val, sizeof(val));
586 }
587
588 static inline u16 virtio_cread16(struct udevice *vdev,
589 unsigned int offset)
590 {
591 u16 ret;
592
593 virtio_get_config(vdev, offset, &ret, sizeof(ret));
594 return virtio16_to_cpu(vdev, (__force __virtio16)ret);
595 }
596
597 static inline void virtio_cwrite16(struct udevice *vdev,
598 unsigned int offset, u16 val)
599 {
600 val = (__force u16)cpu_to_virtio16(vdev, val);
601 virtio_set_config(vdev, offset, &val, sizeof(val));
602 }
603
604 static inline u32 virtio_cread32(struct udevice *vdev,
605 unsigned int offset)
606 {
607 u32 ret;
608
609 virtio_get_config(vdev, offset, &ret, sizeof(ret));
610 return virtio32_to_cpu(vdev, (__force __virtio32)ret);
611 }
612
613 static inline void virtio_cwrite32(struct udevice *vdev,
614 unsigned int offset, u32 val)
615 {
616 val = (__force u32)cpu_to_virtio32(vdev, val);
617 virtio_set_config(vdev, offset, &val, sizeof(val));
618 }
619
620 static inline u64 virtio_cread64(struct udevice *vdev,
621 unsigned int offset)
622 {
623 u64 ret;
624
625 __virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
626 return virtio64_to_cpu(vdev, (__force __virtio64)ret);
627 }
628
629 static inline void virtio_cwrite64(struct udevice *vdev,
630 unsigned int offset, u64 val)
631 {
632 val = (__force u64)cpu_to_virtio64(vdev, val);
633 virtio_set_config(vdev, offset, &val, sizeof(val));
634 }
635
636 /* Config space read accessor */
637 #define virtio_cread(vdev, structname, member, ptr) \
638 do { \
639 /* Must match the member's type, and be integer */ \
640 if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
641 (*ptr) = 1; \
642 \
643 switch (sizeof(*ptr)) { \
644 case 1: \
645 *(ptr) = virtio_cread8(vdev, \
646 offsetof(structname, member)); \
647 break; \
648 case 2: \
649 *(ptr) = virtio_cread16(vdev, \
650 offsetof(structname, member)); \
651 break; \
652 case 4: \
653 *(ptr) = virtio_cread32(vdev, \
654 offsetof(structname, member)); \
655 break; \
656 case 8: \
657 *(ptr) = virtio_cread64(vdev, \
658 offsetof(structname, member)); \
659 break; \
660 default: \
661 WARN_ON(true); \
662 } \
663 } while (0)
664
665 /* Config space write accessor */
666 #define virtio_cwrite(vdev, structname, member, ptr) \
667 do { \
668 /* Must match the member's type, and be integer */ \
669 if (!typecheck(typeof((((structname *)0)->member)), *(ptr))) \
670 WARN_ON((*ptr) == 1); \
671 \
672 switch (sizeof(*ptr)) { \
673 case 1: \
674 virtio_cwrite8(vdev, \
675 offsetof(structname, member), \
676 *(ptr)); \
677 break; \
678 case 2: \
679 virtio_cwrite16(vdev, \
680 offsetof(structname, member), \
681 *(ptr)); \
682 break; \
683 case 4: \
684 virtio_cwrite32(vdev, \
685 offsetof(structname, member), \
686 *(ptr)); \
687 break; \
688 case 8: \
689 virtio_cwrite64(vdev, \
690 offsetof(structname, member), \
691 *(ptr)); \
692 break; \
693 default: \
694 WARN_ON(true); \
695 } \
696 } while (0)
697
698 /* Conditional config space accessors */
699 #define virtio_cread_feature(vdev, fbit, structname, member, ptr) \
700 ({ \
701 int _r = 0; \
702 if (!virtio_has_feature(vdev, fbit)) \
703 _r = -ENOENT; \
704 else \
705 virtio_cread(vdev, structname, member, ptr); \
706 _r; \
707 })
708
709 #endif /* __VIRTIO_H__ */