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