1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * linux/fs/befs/endian.h |
4 | * |
5 | * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com> |
6 | * |
7 | * Partially based on similar funtions in the sysv driver. |
8 | */ |
9 | |
10 | #ifndef LINUX_BEFS_ENDIAN |
11 | #define LINUX_BEFS_ENDIAN |
12 | |
13 | #include <asm/byteorder.h> |
14 | |
15 | static inline u64 |
16 | fs64_to_cpu(const struct super_block *sb, fs64 n) |
17 | { |
18 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
19 | return le64_to_cpu((__force __le64)n); |
20 | else |
21 | return be64_to_cpu((__force __be64)n); |
22 | } |
23 | |
24 | static inline fs64 |
25 | cpu_to_fs64(const struct super_block *sb, u64 n) |
26 | { |
27 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
28 | return (__force fs64)cpu_to_le64(n); |
29 | else |
30 | return (__force fs64)cpu_to_be64(n); |
31 | } |
32 | |
33 | static inline u32 |
34 | fs32_to_cpu(const struct super_block *sb, fs32 n) |
35 | { |
36 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
37 | return le32_to_cpu((__force __le32)n); |
38 | else |
39 | return be32_to_cpu((__force __be32)n); |
40 | } |
41 | |
42 | static inline fs32 |
43 | cpu_to_fs32(const struct super_block *sb, u32 n) |
44 | { |
45 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
46 | return (__force fs32)cpu_to_le32(n); |
47 | else |
48 | return (__force fs32)cpu_to_be32(n); |
49 | } |
50 | |
51 | static inline u16 |
52 | fs16_to_cpu(const struct super_block *sb, fs16 n) |
53 | { |
54 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
55 | return le16_to_cpu((__force __le16)n); |
56 | else |
57 | return be16_to_cpu((__force __be16)n); |
58 | } |
59 | |
60 | static inline fs16 |
61 | cpu_to_fs16(const struct super_block *sb, u16 n) |
62 | { |
63 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) |
64 | return (__force fs16)cpu_to_le16(n); |
65 | else |
66 | return (__force fs16)cpu_to_be16(n); |
67 | } |
68 | |
69 | /* Composite types below here */ |
70 | |
71 | static inline befs_block_run |
72 | fsrun_to_cpu(const struct super_block *sb, befs_disk_block_run n) |
73 | { |
74 | befs_block_run run; |
75 | |
76 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) { |
77 | run.allocation_group = le32_to_cpu((__force __le32)n.allocation_group); |
78 | run.start = le16_to_cpu((__force __le16)n.start); |
79 | run.len = le16_to_cpu((__force __le16)n.len); |
80 | } else { |
81 | run.allocation_group = be32_to_cpu((__force __be32)n.allocation_group); |
82 | run.start = be16_to_cpu((__force __be16)n.start); |
83 | run.len = be16_to_cpu((__force __be16)n.len); |
84 | } |
85 | return run; |
86 | } |
87 | |
88 | static inline befs_disk_block_run |
89 | cpu_to_fsrun(const struct super_block *sb, befs_block_run n) |
90 | { |
91 | befs_disk_block_run run; |
92 | |
93 | if (BEFS_SB(super: sb)->byte_order == BEFS_BYTESEX_LE) { |
94 | run.allocation_group = cpu_to_le32(n.allocation_group); |
95 | run.start = cpu_to_le16(n.start); |
96 | run.len = cpu_to_le16(n.len); |
97 | } else { |
98 | run.allocation_group = cpu_to_be32(n.allocation_group); |
99 | run.start = cpu_to_be16(n.start); |
100 | run.len = cpu_to_be16(n.len); |
101 | } |
102 | return run; |
103 | } |
104 | |
105 | static inline befs_data_stream |
106 | fsds_to_cpu(const struct super_block *sb, const befs_disk_data_stream *n) |
107 | { |
108 | befs_data_stream data; |
109 | int i; |
110 | |
111 | for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; ++i) |
112 | data.direct[i] = fsrun_to_cpu(sb, n: n->direct[i]); |
113 | |
114 | data.max_direct_range = fs64_to_cpu(sb, n: n->max_direct_range); |
115 | data.indirect = fsrun_to_cpu(sb, n: n->indirect); |
116 | data.max_indirect_range = fs64_to_cpu(sb, n: n->max_indirect_range); |
117 | data.double_indirect = fsrun_to_cpu(sb, n: n->double_indirect); |
118 | data.max_double_indirect_range = fs64_to_cpu(sb, |
119 | n: n-> |
120 | max_double_indirect_range); |
121 | data.size = fs64_to_cpu(sb, n: n->size); |
122 | |
123 | return data; |
124 | } |
125 | |
126 | #endif //LINUX_BEFS_ENDIAN |
127 | |