Root/drivers/staging/rtl8192e/rtllib_endianfree.h

1#ifndef __INC_ENDIANFREE_H
2#define __INC_ENDIANFREE_H
3
4/*
5 * Call endian free function when
6 * 1. Read/write packet content.
7 * 2. Before write integer to IO.
8 * 3. After read integer from IO.
9 */
10
11#define __MACHINE_LITTLE_ENDIAN 1234 /* LSB first: i386, vax */
12#define __MACHINE_BIG_ENDIAN 4321 /* MSB first: 68000, ibm, net, ppc */
13
14#define BYTE_ORDER __MACHINE_LITTLE_ENDIAN
15
16#if BYTE_ORDER == __MACHINE_LITTLE_ENDIAN
17#define EF1Byte(_val) ((u8)(_val))
18#define EF2Byte(_val) ((u16)(_val))
19#define EF4Byte(_val) ((u32)(_val))
20
21#else
22#define EF1Byte(_val) ((u8)(_val))
23#define EF2Byte(_val) \
24    (((((u16)(_val))&0x00ff)<<8)|((((u16)(_val))&0xff00)>>8))
25#define EF4Byte(_val) \
26    (((((u32)(_val))&0x000000ff)<<24)|\
27    ((((u32)(_val))&0x0000ff00)<<8)|\
28    ((((u32)(_val))&0x00ff0000)>>8)|\
29    ((((u32)(_val))&0xff000000)>>24))
30#endif
31
32#define ReadEF1Byte(_ptr) EF1Byte(*((u8 *)(_ptr)))
33#define ReadEF2Byte(_ptr) EF2Byte(*((u16 *)(_ptr)))
34#define ReadEF4Byte(_ptr) EF4Byte(*((u32 *)(_ptr)))
35
36#define WriteEF1Byte(_ptr, _val) (*((u8 *)(_ptr))) = EF1Byte(_val)
37#define WriteEF2Byte(_ptr, _val) (*((u16 *)(_ptr))) = EF2Byte(_val)
38#define WriteEF4Byte(_ptr, _val) (*((u32 *)(_ptr))) = EF4Byte(_val)
39#if BYTE_ORDER == __MACHINE_LITTLE_ENDIAN
40#define H2N1BYTE(_val) ((u8)(_val))
41#define H2N2BYTE(_val) (((((u16)(_val))&0x00ff)<<8)|\
42            ((((u16)(_val))&0xff00)>>8))
43#define H2N4BYTE(_val) (((((u32)(_val))&0x000000ff)<<24)|\
44            ((((u32)(_val))&0x0000ff00)<<8) |\
45            ((((u32)(_val))&0x00ff0000)>>8) |\
46            ((((u32)(_val))&0xff000000)>>24))
47#else
48#define H2N1BYTE(_val) ((u8)(_val))
49#define H2N2BYTE(_val) ((u16)(_val))
50#define H2N4BYTE(_val) ((u32)(_val))
51#endif
52
53#if BYTE_ORDER == __MACHINE_LITTLE_ENDIAN
54#define N2H1BYTE(_val) ((u8)(_val))
55#define N2H2BYTE(_val) (((((u16)(_val))&0x00ff)<<8)|\
56            ((((u16)(_val))&0xff00)>>8))
57#define N2H4BYTE(_val) (((((u32)(_val))&0x000000ff)<<24)|\
58            ((((u32)(_val))&0x0000ff00)<<8) |\
59            ((((u32)(_val))&0x00ff0000)>>8) |\
60            ((((u32)(_val))&0xff000000)>>24))
61#else
62#define N2H1BYTE(_val) ((u8)(_val))
63#define N2H2BYTE(_val) ((u16)(_val))
64#define N2H4BYTE(_val) ((u32)(_val))
65#endif
66
67#define BIT_LEN_MASK_32(__BitLen) (0xFFFFFFFF >> (32 - (__BitLen)))
68#define BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen) \
69    (BIT_LEN_MASK_32(__BitLen) << (__BitOffset))
70
71#define LE_P4BYTE_TO_HOST_4BYTE(__pStart) (EF4Byte(*((u32 *)(__pStart))))
72
73#define LE_BITS_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
74    ( \
75      (LE_P4BYTE_TO_HOST_4BYTE(__pStart) >> (__BitOffset)) \
76      & \
77      BIT_LEN_MASK_32(__BitLen) \
78    )
79
80#define LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
81    ( \
82      LE_P4BYTE_TO_HOST_4BYTE(__pStart) \
83      & \
84      (~BIT_OFFSET_LEN_MASK_32(__BitOffset, __BitLen)) \
85    )
86
87#define SET_BITS_TO_LE_4BYTE(__pStart, __BitOffset, __BitLen, __Value) \
88    *((u32 *)(__pStart)) = \
89    EF4Byte( \
90    LE_BITS_CLEARED_TO_4BYTE(__pStart, __BitOffset, __BitLen) \
91    | \
92    ((((u32)__Value) & BIT_LEN_MASK_32(__BitLen)) << (__BitOffset)) \
93    );
94
95
96#define BIT_LEN_MASK_16(__BitLen) \
97    (0xFFFF >> (16 - (__BitLen)))
98
99#define BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen) \
100    (BIT_LEN_MASK_16(__BitLen) << (__BitOffset))
101
102#define LE_P2BYTE_TO_HOST_2BYTE(__pStart) \
103    (EF2Byte(*((u16 *)(__pStart))))
104
105#define LE_BITS_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
106    ( \
107      (LE_P2BYTE_TO_HOST_2BYTE(__pStart) >> (__BitOffset)) \
108      & \
109      BIT_LEN_MASK_16(__BitLen) \
110    )
111
112#define LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
113    ( \
114      LE_P2BYTE_TO_HOST_2BYTE(__pStart) \
115      & \
116      (~BIT_OFFSET_LEN_MASK_16(__BitOffset, __BitLen)) \
117    )
118
119#define SET_BITS_TO_LE_2BYTE(__pStart, __BitOffset, __BitLen, __Value) \
120    *((u16 *)(__pStart)) = \
121    EF2Byte( \
122        LE_BITS_CLEARED_TO_2BYTE(__pStart, __BitOffset, __BitLen) \
123        | ((((u16)__Value) & BIT_LEN_MASK_16(__BitLen)) << \
124        (__BitOffset)) \
125    );
126
127#define BIT_LEN_MASK_8(__BitLen) \
128    (0xFF >> (8 - (__BitLen)))
129
130#define BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen) \
131    (BIT_LEN_MASK_8(__BitLen) << (__BitOffset))
132
133#define LE_P1BYTE_TO_HOST_1BYTE(__pStart) \
134    (EF1Byte(*((u8 *)(__pStart))))
135
136#define LE_BITS_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
137    ( \
138      (LE_P1BYTE_TO_HOST_1BYTE(__pStart) >> (__BitOffset)) \
139      & \
140      BIT_LEN_MASK_8(__BitLen) \
141    )
142
143#define LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
144    ( \
145      LE_P1BYTE_TO_HOST_1BYTE(__pStart) \
146      & \
147      (~BIT_OFFSET_LEN_MASK_8(__BitOffset, __BitLen)) \
148    )
149
150#define SET_BITS_TO_LE_1BYTE(__pStart, __BitOffset, __BitLen, __Value) \
151    *((u8 *)(__pStart)) = EF1Byte( \
152        LE_BITS_CLEARED_TO_1BYTE(__pStart, __BitOffset, __BitLen) \
153        | ((((u8)__Value) & BIT_LEN_MASK_8(__BitLen)) << \
154        (__BitOffset)) \
155    );
156
157#define N_BYTE_ALIGMENT(__Value, __Aligment) \
158     ((__Aligment == 1) ? (__Value) : (((__Value + __Aligment - 1) / \
159    __Aligment) * __Aligment))
160#endif
161

Archive Download this file



interactive