1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
20 #ifndef __BASIC_TYPES_H__
21 #define __BASIC_TYPES_H__
26 #include <linux/types.h>
29 typedef void (*proc_t)(void *);
31 #define FIELD_OFFSET(s, field) ((ssize_t)&((s *)(0))->field)
33 #define MEM_ALIGNMENT_OFFSET (sizeof(size_t))
34 #define MEM_ALIGNMENT_PADDING (sizeof(size_t) - 1)
37 /* TODO: Macros Below are Sync from SD7-Driver. It is necessary
38 * to check correctness */
41 * Call endian free function when
42 * 1. Read/write packet content.
43 * 2. Before write integer to IO.
44 * 3. After read integer from IO.
47 /* Convert little data endian to host ordering */
48 #define EF1BYTE(_val) \
50 #define EF2BYTE(_val) \
52 #define EF4BYTE(_val) \
55 /* Read data from memory */
56 #define READEF1BYTE(_ptr) \
57 EF1BYTE(*((u8 *)(_ptr)))
58 /* Read le16 data from memory and convert to host ordering */
59 #define READEF2BYTE(_ptr) \
61 #define READEF4BYTE(_ptr) \
64 /* Write data to memory */
65 #define WRITEEF1BYTE(_ptr, _val) \
67 (*((u8 *)(_ptr))) = EF1BYTE(_val) \
69 /* Write le data to memory in host ordering */
70 #define WRITEEF2BYTE(_ptr, _val) \
72 (*((u16 *)(_ptr))) = EF2BYTE(_val) \
75 #define WRITEEF4BYTE(_ptr, _val) \
77 (*((u32 *)(_ptr))) = EF2BYTE(_val) \
82 * BIT_LEN_MASK_32(0) => 0x00000000
83 * BIT_LEN_MASK_32(1) => 0x00000001
84 * BIT_LEN_MASK_32(2) => 0x00000003
85 * BIT_LEN_MASK_32(32) => 0xFFFFFFFF
87 #define BIT_LEN_MASK_32(__bitlen) \
88 (0xFFFFFFFF >> (32 - (__bitlen)))
89 #define BIT_LEN_MASK_16(__bitlen) \
90 (0xFFFF >> (16 - (__bitlen)))
91 #define BIT_LEN_MASK_8(__bitlen) \
92 (0xFF >> (8 - (__bitlen)))
94 /* Create an offset bit mask
96 * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
97 * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
99 #define BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen) \
100 (BIT_LEN_MASK_32(__bitlen) << (__bitoffset))
101 #define BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen) \
102 (BIT_LEN_MASK_16(__bitlen) << (__bitoffset))
103 #define BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen) \
104 (BIT_LEN_MASK_8(__bitlen) << (__bitoffset))
107 * Return 4-byte value in host byte ordering from
108 * 4-byte pointer in little-endian system.
110 #define LE_P4BYTE_TO_HOST_4BYTE(__pstart) \
111 (EF4BYTE(*((__le32 *)(__pstart))))
112 #define LE_P2BYTE_TO_HOST_2BYTE(__pstart) \
113 (EF2BYTE(*((__le16 *)(__pstart))))
114 #define LE_P1BYTE_TO_HOST_1BYTE(__pstart) \
115 (EF1BYTE(*((u8 *)(__pstart))))
118 Translate subfield (continuous bits in little-endian) of 4-byte
119 value to host byte ordering.*/
120 #define LE_BITS_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
122 (LE_P4BYTE_TO_HOST_4BYTE(__pstart) >> (__bitoffset)) & \
123 BIT_LEN_MASK_32(__bitlen) \
125 #define LE_BITS_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
127 (LE_P2BYTE_TO_HOST_2BYTE(__pstart) >> (__bitoffset)) & \
128 BIT_LEN_MASK_16(__bitlen) \
130 #define LE_BITS_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
132 (LE_P1BYTE_TO_HOST_1BYTE(__pstart) >> (__bitoffset)) & \
133 BIT_LEN_MASK_8(__bitlen) \
137 * Mask subfield (continuous bits in little-endian) of 4-byte value
138 * and return the result in 4-byte value in host byte ordering.
140 #define LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
142 LE_P4BYTE_TO_HOST_4BYTE(__pstart) & \
143 (~BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen)) \
145 #define LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
147 LE_P2BYTE_TO_HOST_2BYTE(__pstart) & \
148 (~BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen)) \
150 #define LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
152 LE_P1BYTE_TO_HOST_1BYTE(__pstart) & \
153 (~BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen)) \
157 * Set subfield of little-endian 4-byte value to specified value.
159 #define SET_BITS_TO_LE_4BYTE(__pstart, __bitoffset, __bitlen, __val) \
160 *((u32 *)(__pstart)) = \
162 LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) | \
163 ((((u32)__val) & BIT_LEN_MASK_32(__bitlen)) << (__bitoffset)) \
166 #define SET_BITS_TO_LE_2BYTE(__pstart, __bitoffset, __bitlen, __val) \
167 *((u16 *)(__pstart)) = \
169 LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
170 ((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
173 #define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
174 *((u8 *)(__pstart)) = EF1BYTE \
176 LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) | \
177 ((((u8)__val) & BIT_LEN_MASK_8(__bitlen)) << (__bitoffset)) \
180 /* Get the N-bytes aligment offset from the current length */
181 #define N_BYTE_ALIGMENT(__value, __aligment) ((__aligment == 1) ? \
182 (__value) : (((__value + __aligment - 1) / __aligment) * __aligment))
184 #endif /* __BASIC_TYPES_H__ */