1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2016 Cavium, Inc 3 */ 4 5 #ifndef _RTE_IO_ARM64_H_ 6 #define _RTE_IO_ARM64_H_ 7 8 #include <stdint.h> 9 10 #define RTE_OVERRIDE_IO_H 11 12 #include "generic/rte_io.h" 13 #include <rte_compat.h> 14 #include "rte_atomic_64.h" 15 16 #ifdef __cplusplus 17 extern "C" { 18 #endif 19 20 static __rte_always_inline uint8_t 21 rte_read8_relaxed(const volatile void *addr) 22 { 23 uint8_t val; 24 25 asm volatile( 26 "ldrb %w[val], [%x[addr]]" 27 : [val] "=r" (val) 28 : [addr] "r" (addr)); 29 return val; 30 } 31 32 static __rte_always_inline uint16_t 33 rte_read16_relaxed(const volatile void *addr) 34 { 35 uint16_t val; 36 37 asm volatile( 38 "ldrh %w[val], [%x[addr]]" 39 : [val] "=r" (val) 40 : [addr] "r" (addr)); 41 return val; 42 } 43 44 static __rte_always_inline uint32_t 45 rte_read32_relaxed(const volatile void *addr) 46 { 47 uint32_t val; 48 49 asm volatile( 50 "ldr %w[val], [%x[addr]]" 51 : [val] "=r" (val) 52 : [addr] "r" (addr)); 53 return val; 54 } 55 56 static __rte_always_inline uint64_t 57 rte_read64_relaxed(const volatile void *addr) 58 { 59 uint64_t val; 60 61 asm volatile( 62 "ldr %x[val], [%x[addr]]" 63 : [val] "=r" (val) 64 : [addr] "r" (addr)); 65 return val; 66 } 67 68 static __rte_always_inline void 69 rte_write8_relaxed(uint8_t val, volatile void *addr) 70 { 71 asm volatile( 72 "strb %w[val], [%x[addr]]" 73 : 74 : [val] "r" (val), [addr] "r" (addr)); 75 } 76 77 static __rte_always_inline void 78 rte_write16_relaxed(uint16_t val, volatile void *addr) 79 { 80 asm volatile( 81 "strh %w[val], [%x[addr]]" 82 : 83 : [val] "r" (val), [addr] "r" (addr)); 84 } 85 86 static __rte_always_inline void 87 rte_write32_relaxed(uint32_t val, volatile void *addr) 88 { 89 asm volatile( 90 "str %w[val], [%x[addr]]" 91 : 92 : [val] "r" (val), [addr] "r" (addr)); 93 } 94 95 static __rte_always_inline void 96 rte_write64_relaxed(uint64_t val, volatile void *addr) 97 { 98 asm volatile( 99 "str %x[val], [%x[addr]]" 100 : 101 : [val] "r" (val), [addr] "r" (addr)); 102 } 103 104 static __rte_always_inline uint8_t 105 rte_read8(const volatile void *addr) 106 { 107 uint8_t val; 108 val = rte_read8_relaxed(addr); 109 rte_io_rmb(); 110 return val; 111 } 112 113 static __rte_always_inline uint16_t 114 rte_read16(const volatile void *addr) 115 { 116 uint16_t val; 117 val = rte_read16_relaxed(addr); 118 rte_io_rmb(); 119 return val; 120 } 121 122 static __rte_always_inline uint32_t 123 rte_read32(const volatile void *addr) 124 { 125 uint32_t val; 126 val = rte_read32_relaxed(addr); 127 rte_io_rmb(); 128 return val; 129 } 130 131 static __rte_always_inline uint64_t 132 rte_read64(const volatile void *addr) 133 { 134 uint64_t val; 135 val = rte_read64_relaxed(addr); 136 rte_io_rmb(); 137 return val; 138 } 139 140 static __rte_always_inline void 141 rte_write8(uint8_t value, volatile void *addr) 142 { 143 rte_io_wmb(); 144 rte_write8_relaxed(value, addr); 145 } 146 147 static __rte_always_inline void 148 rte_write16(uint16_t value, volatile void *addr) 149 { 150 rte_io_wmb(); 151 rte_write16_relaxed(value, addr); 152 } 153 154 static __rte_always_inline void 155 rte_write32(uint32_t value, volatile void *addr) 156 { 157 rte_io_wmb(); 158 rte_write32_relaxed(value, addr); 159 } 160 161 static __rte_always_inline void 162 rte_write64(uint64_t value, volatile void *addr) 163 { 164 rte_io_wmb(); 165 rte_write64_relaxed(value, addr); 166 } 167 168 __rte_experimental 169 static __rte_always_inline void 170 rte_write32_wc(uint32_t value, volatile void *addr) 171 { 172 rte_write32(value, addr); 173 } 174 175 __rte_experimental 176 static __rte_always_inline void 177 rte_write32_wc_relaxed(uint32_t value, volatile void *addr) 178 { 179 rte_write32_relaxed(value, addr); 180 } 181 182 #ifdef __cplusplus 183 } 184 #endif 185 186 #endif /* _RTE_IO_ARM64_H_ */ 187