tools/include/linux/unaligned.h

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