URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [befs/] [endian.h] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * linux/fs/befs/endian.h
 *
 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com>
 *
 * Partially based on similar funtions in the sysv driver.
 */
 
#ifndef LINUX_BEFS_ENDIAN
#define LINUX_BEFS_ENDIAN
 
#include <linux/byteorder/generic.h>
 
static inline u64
fs64_to_cpu(const struct super_block *sb, u64 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return le64_to_cpu(n);
        else
                return be64_to_cpu(n);
}
 
static inline u64
cpu_to_fs64(const struct super_block *sb, u64 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return cpu_to_le64(n);
        else
                return cpu_to_be64(n);
}
 
static inline u32
fs32_to_cpu(const struct super_block *sb, u32 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return le32_to_cpu(n);
        else
                return be32_to_cpu(n);
}
 
static inline u32
cpu_to_fs32(const struct super_block *sb, u32 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return cpu_to_le32(n);
        else
                return cpu_to_be32(n);
}
 
static inline u16
fs16_to_cpu(const struct super_block *sb, u16 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return le16_to_cpu(n);
        else
                return be16_to_cpu(n);
}
 
static inline u16
cpu_to_fs16(const struct super_block *sb, u16 n)
{
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE)
                return cpu_to_le16(n);
        else
                return cpu_to_be16(n);
}
 
/* Composite types below here */
 
static inline befs_block_run
fsrun_to_cpu(const struct super_block *sb, befs_block_run n)
{
        befs_block_run run;
 
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
                run.allocation_group = le32_to_cpu(n.allocation_group);
                run.start = le16_to_cpu(n.start);
                run.len = le16_to_cpu(n.len);
        } else {
                run.allocation_group = be32_to_cpu(n.allocation_group);
                run.start = be16_to_cpu(n.start);
                run.len = be16_to_cpu(n.len);
        }
        return run;
}
 
static inline befs_block_run
cpu_to_fsrun(const struct super_block *sb, befs_block_run n)
{
        befs_block_run run;
 
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
                run.allocation_group = cpu_to_le32(n.allocation_group);
                run.start = cpu_to_le16(n.start);
                run.len = cpu_to_le16(n.len);
        } else {
                run.allocation_group = cpu_to_be32(n.allocation_group);
                run.start = cpu_to_be16(n.start);
                run.len = cpu_to_be16(n.len);
        }
        return run;
}
 
static inline befs_data_stream
fsds_to_cpu(const struct super_block *sb, befs_data_stream n)
{
        befs_data_stream data;
        int i;
 
        for (i = 0; i < BEFS_NUM_DIRECT_BLOCKS; ++i)
                data.direct[i] = fsrun_to_cpu(sb, n.direct[i]);
 
        data.max_direct_range = fs64_to_cpu(sb, n.max_direct_range);
        data.indirect = fsrun_to_cpu(sb, n.indirect);
        data.max_indirect_range = fs64_to_cpu(sb, n.max_indirect_range);
        data.double_indirect = fsrun_to_cpu(sb, n.double_indirect);
        data.max_double_indirect_range = fs64_to_cpu(sb,
                                                     n.
                                                     max_double_indirect_range);
        data.size = fs64_to_cpu(sb, n.size);
 
        return data;
}
 
#endif                          //LINUX_BEFS_ENDIAN

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

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [befs/] [endian.h] - Blame information for rev 1765