1 /* 2 * Virtio Accessor Support: In case your target can change endian. 3 * 4 * Copyright IBM, Corp. 2013 5 * 6 * Authors: 7 * Rusty Russell <rusty@au.ibm.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation, either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 */ 15 16 #ifndef QEMU_VIRTIO_ACCESS_H 17 #define QEMU_VIRTIO_ACCESS_H 18 19 #include "hw/virtio/virtio.h" 20 #include "hw/virtio/virtio-bus.h" 21 #include "exec/address-spaces.h" 22 23 #if defined(TARGET_PPC64) || defined(TARGET_ARM) 24 #define LEGACY_VIRTIO_IS_BIENDIAN 1 25 #endif 26 27 static inline bool virtio_access_is_big_endian(VirtIODevice *vdev) 28 { 29 #if defined(LEGACY_VIRTIO_IS_BIENDIAN) 30 return virtio_is_big_endian(vdev); 31 #elif defined(TARGET_WORDS_BIGENDIAN) 32 if (virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) { 33 /* Devices conforming to VIRTIO 1.0 or later are always LE. */ 34 return false; 35 } 36 return true; 37 #else 38 return false; 39 #endif 40 } 41 42 static inline uint16_t virtio_lduw_phys(VirtIODevice *vdev, hwaddr pa) 43 { 44 AddressSpace *dma_as = vdev->dma_as; 45 46 if (virtio_access_is_big_endian(vdev)) { 47 return lduw_be_phys(dma_as, pa); 48 } 49 return lduw_le_phys(dma_as, pa); 50 } 51 52 static inline uint32_t virtio_ldl_phys(VirtIODevice *vdev, hwaddr pa) 53 { 54 AddressSpace *dma_as = vdev->dma_as; 55 56 if (virtio_access_is_big_endian(vdev)) { 57 return ldl_be_phys(dma_as, pa); 58 } 59 return ldl_le_phys(dma_as, pa); 60 } 61 62 static inline uint64_t virtio_ldq_phys(VirtIODevice *vdev, hwaddr pa) 63 { 64 AddressSpace *dma_as = vdev->dma_as; 65 66 if (virtio_access_is_big_endian(vdev)) { 67 return ldq_be_phys(dma_as, pa); 68 } 69 return ldq_le_phys(dma_as, pa); 70 } 71 72 static inline void virtio_stw_phys(VirtIODevice *vdev, hwaddr pa, 73 uint16_t value) 74 { 75 AddressSpace *dma_as = vdev->dma_as; 76 77 if (virtio_access_is_big_endian(vdev)) { 78 stw_be_phys(dma_as, pa, value); 79 } else { 80 stw_le_phys(dma_as, pa, value); 81 } 82 } 83 84 static inline void virtio_stl_phys(VirtIODevice *vdev, hwaddr pa, 85 uint32_t value) 86 { 87 AddressSpace *dma_as = vdev->dma_as; 88 89 if (virtio_access_is_big_endian(vdev)) { 90 stl_be_phys(dma_as, pa, value); 91 } else { 92 stl_le_phys(dma_as, pa, value); 93 } 94 } 95 96 static inline void virtio_stw_p(VirtIODevice *vdev, void *ptr, uint16_t v) 97 { 98 if (virtio_access_is_big_endian(vdev)) { 99 stw_be_p(ptr, v); 100 } else { 101 stw_le_p(ptr, v); 102 } 103 } 104 105 static inline void virtio_stl_p(VirtIODevice *vdev, void *ptr, uint32_t v) 106 { 107 if (virtio_access_is_big_endian(vdev)) { 108 stl_be_p(ptr, v); 109 } else { 110 stl_le_p(ptr, v); 111 } 112 } 113 114 static inline void virtio_stq_p(VirtIODevice *vdev, void *ptr, uint64_t v) 115 { 116 if (virtio_access_is_big_endian(vdev)) { 117 stq_be_p(ptr, v); 118 } else { 119 stq_le_p(ptr, v); 120 } 121 } 122 123 static inline int virtio_lduw_p(VirtIODevice *vdev, const void *ptr) 124 { 125 if (virtio_access_is_big_endian(vdev)) { 126 return lduw_be_p(ptr); 127 } else { 128 return lduw_le_p(ptr); 129 } 130 } 131 132 static inline int virtio_ldl_p(VirtIODevice *vdev, const void *ptr) 133 { 134 if (virtio_access_is_big_endian(vdev)) { 135 return ldl_be_p(ptr); 136 } else { 137 return ldl_le_p(ptr); 138 } 139 } 140 141 static inline uint64_t virtio_ldq_p(VirtIODevice *vdev, const void *ptr) 142 { 143 if (virtio_access_is_big_endian(vdev)) { 144 return ldq_be_p(ptr); 145 } else { 146 return ldq_le_p(ptr); 147 } 148 } 149 150 static inline uint16_t virtio_tswap16(VirtIODevice *vdev, uint16_t s) 151 { 152 #ifdef HOST_WORDS_BIGENDIAN 153 return virtio_access_is_big_endian(vdev) ? s : bswap16(s); 154 #else 155 return virtio_access_is_big_endian(vdev) ? bswap16(s) : s; 156 #endif 157 } 158 159 static inline void virtio_tswap16s(VirtIODevice *vdev, uint16_t *s) 160 { 161 *s = virtio_tswap16(vdev, *s); 162 } 163 164 static inline uint32_t virtio_tswap32(VirtIODevice *vdev, uint32_t s) 165 { 166 #ifdef HOST_WORDS_BIGENDIAN 167 return virtio_access_is_big_endian(vdev) ? s : bswap32(s); 168 #else 169 return virtio_access_is_big_endian(vdev) ? bswap32(s) : s; 170 #endif 171 } 172 173 static inline void virtio_tswap32s(VirtIODevice *vdev, uint32_t *s) 174 { 175 *s = virtio_tswap32(vdev, *s); 176 } 177 178 static inline uint64_t virtio_tswap64(VirtIODevice *vdev, uint64_t s) 179 { 180 #ifdef HOST_WORDS_BIGENDIAN 181 return virtio_access_is_big_endian(vdev) ? s : bswap64(s); 182 #else 183 return virtio_access_is_big_endian(vdev) ? bswap64(s) : s; 184 #endif 185 } 186 187 static inline void virtio_tswap64s(VirtIODevice *vdev, uint64_t *s) 188 { 189 *s = virtio_tswap64(vdev, *s); 190 } 191 #endif /* QEMU_VIRTIO_ACCESS_H */ 192