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