1/* SPDX-License-Identifier: GPL-2.0 */ 2#ifndef __ASM_GENERIC_UNALIGNED_H 3#define __ASM_GENERIC_UNALIGNED_H 4 5/* 6 * This is the most generic implementation of unaligned accesses 7 * and should work almost anywhere. 8 */ 9#pragma GCC diagnostic push 10#pragma GCC diagnostic ignored "-Wpacked" 11#pragma GCC diagnostic ignored "-Wattributes" 12 13#define __get_unaligned_t(type, ptr) ({ \ 14 const struct { type x; } __packed *__pptr = (typeof(__pptr))(ptr); \ 15 __pptr->x; \ 16}) 17 18#define __put_unaligned_t(type, val, ptr) do { \ 19 struct { type x; } __packed *__pptr = (typeof(__pptr))(ptr); \ 20 __pptr->x = (val); \ 21} while (0) 22 23#define get_unaligned(ptr) __get_unaligned_t(typeof(*(ptr)), (ptr)) 24#define put_unaligned(val, ptr) __put_unaligned_t(typeof(*(ptr)), (val), (ptr)) 25 26static inline u16 get_unaligned_le16(const void *p) 27{ 28 return le16_to_cpu(__get_unaligned_t(__le16, p)); 29} 30 31static inline u32 get_unaligned_le32(const void *p) 32{ 33 return le32_to_cpu(__get_unaligned_t(__le32, p)); 34} 35 36static inline u64 get_unaligned_le64(const void *p) 37{ 38 return le64_to_cpu(__get_unaligned_t(__le64, p)); 39} 40 41static inline void put_unaligned_le16(u16 val, void *p) 42{ 43 __put_unaligned_t(__le16, cpu_to_le16(val), p); 44} 45 46static inline void put_unaligned_le32(u32 val, void *p) 47{ 48 __put_unaligned_t(__le32, cpu_to_le32(val), p); 49} 50 51static inline void put_unaligned_le64(u64 val, void *p) 52{ 53 __put_unaligned_t(__le64, cpu_to_le64(val), p); 54} 55 56static inline u16 get_unaligned_be16(const void *p) 57{ 58 return be16_to_cpu(__get_unaligned_t(__be16, p)); 59} 60 61static inline u32 get_unaligned_be32(const void *p) 62{ 63 return be32_to_cpu(__get_unaligned_t(__be32, p)); 64} 65 66static inline u64 get_unaligned_be64(const void *p) 67{ 68 return be64_to_cpu(__get_unaligned_t(__be64, p)); 69} 70 71static inline void put_unaligned_be16(u16 val, void *p) 72{ 73 __put_unaligned_t(__be16, cpu_to_be16(val), p); 74} 75 76static inline void put_unaligned_be32(u32 val, void *p) 77{ 78 __put_unaligned_t(__be32, cpu_to_be32(val), p); 79} 80 81static inline void put_unaligned_be64(u64 val, void *p) 82{ 83 __put_unaligned_t(__be64, cpu_to_be64(val), p); 84} 85 86static inline u32 __get_unaligned_be24(const u8 *p) 87{ 88 return p[0] << 16 | p[1] << 8 | p[2]; 89} 90 91static inline u32 get_unaligned_be24(const void *p) 92{ 93 return __get_unaligned_be24(p); 94} 95 96static inline u32 __get_unaligned_le24(const u8 *p) 97{ 98 return p[0] | p[1] << 8 | p[2] << 16; 99} 100 101static inline u32 get_unaligned_le24(const void *p) 102{ 103 return __get_unaligned_le24(p); 104} 105 106static inline void __put_unaligned_be24(const u32 val, u8 *p) 107{ 108 *p++ = (val >> 16) & 0xff; 109 *p++ = (val >> 8) & 0xff; 110 *p++ = val & 0xff; 111} 112 113static inline void put_unaligned_be24(const u32 val, void *p) 114{ 115 __put_unaligned_be24(val, p); 116} 117 118static inline void __put_unaligned_le24(const u32 val, u8 *p) 119{ 120 *p++ = val & 0xff; 121 *p++ = (val >> 8) & 0xff; 122 *p++ = (val >> 16) & 0xff; 123} 124 125static inline void put_unaligned_le24(const u32 val, void *p) 126{ 127 __put_unaligned_le24(val, p); 128} 129 130static inline void __put_unaligned_be48(const u64 val, u8 *p) 131{ 132 *p++ = (val >> 40) & 0xff; 133 *p++ = (val >> 32) & 0xff; 134 *p++ = (val >> 24) & 0xff; 135 *p++ = (val >> 16) & 0xff; 136 *p++ = (val >> 8) & 0xff; 137 *p++ = val & 0xff; 138} 139 140static inline void put_unaligned_be48(const u64 val, void *p) 141{ 142 __put_unaligned_be48(val, p); 143} 144 145static inline u64 __get_unaligned_be48(const u8 *p) 146{ 147 return (u64)p[0] << 40 | (u64)p[1] << 32 | (u64)p[2] << 24 | 148 p[3] << 16 | p[4] << 8 | p[5]; 149} 150 151static inline u64 get_unaligned_be48(const void *p) 152{ 153 return __get_unaligned_be48(p); 154} 155#pragma GCC diagnostic pop 156 157#endif /* __ASM_GENERIC_UNALIGNED_H */ 158