kernel/drivers/staging/rtl8188eu/include/basic_types.h

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   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.
   8  *
   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
  12  * more details.
  13  *
  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
  17  *
  18  *
  19  ******************************************************************************/
  20 #ifndef __BASIC_TYPES_H__
  21 #define __BASIC_TYPES_H__
  22
  23 #include <linux/types.h>
  24 #define NDIS_OID uint
  25
  26 typedef void (*proc_t)(void *);
  27
  28 #define FIELD_OFFSET(s, field)  ((ssize_t)&((s *)(0))->field)
  29
  30 /* port from fw */
  31 /*  TODO: Macros Below are Sync from SD7-Driver. It is necessary
  32  * to check correctness */
  33
  34 /*
  35  *      Call endian free function when
  36  *              1. Read/write packet content.
  37  *              2. Before write integer to IO.
  38  *              3. After read integer from IO.
  39 */
  40
  41 /* Convert little data endian to host ordering */
  42 #define EF1BYTE(_val)           \
  43         ((u8)(_val))
  44 #define EF2BYTE(_val)           \
  45         (le16_to_cpu(_val))
  46 #define EF4BYTE(_val)           \
  47         (le32_to_cpu(_val))
  48
  49 /* Read data from memory */
  50 #define READEF1BYTE(_ptr)       \
  51         EF1BYTE(*((u8 *)(_ptr)))
  52 /* Read le16 data from memory and convert to host ordering */
  53 #define READEF2BYTE(_ptr)       \
  54         EF2BYTE(*(_ptr))
  55 #define READEF4BYTE(_ptr)       \
  56         EF4BYTE(*(_ptr))
  57
  58 /* Write data to memory */
  59 #define WRITEEF1BYTE(_ptr, _val)                        \
  60         do {                                            \
  61                 (*((u8 *)(_ptr))) = EF1BYTE(_val)       \
  62         } while (0)
  63 /* Write le data to memory in host ordering */
  64 #define WRITEEF2BYTE(_ptr, _val)                        \
  65         do {                                            \
  66                 (*((u16 *)(_ptr))) = EF2BYTE(_val)      \
  67         } while (0)
  68
  69 #define WRITEEF4BYTE(_ptr, _val)                        \
  70         do {                                            \
  71                 (*((u32 *)(_ptr))) = EF2BYTE(_val)      \
  72         } while (0)
  73
  74 /* Create a bit mask
  75  * Examples:
  76  * BIT_LEN_MASK_32(0) => 0x00000000
  77  * BIT_LEN_MASK_32(1) => 0x00000001
  78  * BIT_LEN_MASK_32(2) => 0x00000003
  79  * BIT_LEN_MASK_32(32) => 0xFFFFFFFF
  80  */
  81 #define BIT_LEN_MASK_32(__bitlen)        \
  82         (0xFFFFFFFF >> (32 - (__bitlen)))
  83 #define BIT_LEN_MASK_16(__bitlen)        \
  84         (0xFFFF >> (16 - (__bitlen)))
  85 #define BIT_LEN_MASK_8(__bitlen) \
  86         (0xFF >> (8 - (__bitlen)))
  87
  88 /* Create an offset bit mask
  89  * Examples:
  90  * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
  91  * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
  92  */
  93 #define BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen) \
  94         (BIT_LEN_MASK_32(__bitlen) << (__bitoffset))
  95 #define BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen) \
  96         (BIT_LEN_MASK_16(__bitlen) << (__bitoffset))
  97 #define BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen) \
  98         (BIT_LEN_MASK_8(__bitlen) << (__bitoffset))
  99
 100 /*Description:
 101  * Return 4-byte value in host byte ordering from
 102  * 4-byte pointer in little-endian system.
 103  */
 104 #define LE_P4BYTE_TO_HOST_4BYTE(__pstart) \
 105         (EF4BYTE(*((__le32 *)(__pstart))))
 106 #define LE_P2BYTE_TO_HOST_2BYTE(__pstart) \
 107         (EF2BYTE(*((__le16 *)(__pstart))))
 108 #define LE_P1BYTE_TO_HOST_1BYTE(__pstart) \
 109         (EF1BYTE(*((u8 *)(__pstart))))
 110
 111 /*Description:
 112 Translate subfield (continuous bits in little-endian) of 4-byte
 113 value to host byte ordering.*/
 114 #define LE_BITS_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
 115         ( \
 116                 (LE_P4BYTE_TO_HOST_4BYTE(__pstart) >> (__bitoffset))  & \
 117                 BIT_LEN_MASK_32(__bitlen) \
 118         )
 119 #define LE_BITS_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 120         ( \
 121                 (LE_P2BYTE_TO_HOST_2BYTE(__pstart) >> (__bitoffset)) & \
 122                 BIT_LEN_MASK_16(__bitlen) \
 123         )
 124 #define LE_BITS_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 125         ( \
 126                 (LE_P1BYTE_TO_HOST_1BYTE(__pstart) >> (__bitoffset)) & \
 127                 BIT_LEN_MASK_8(__bitlen) \
 128         )
 129
 130 /* Description:
 131  * Mask subfield (continuous bits in little-endian) of 4-byte value
 132  * and return the result in 4-byte value in host byte ordering.
 133  */
 134 #define LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
 135         ( \
 136                 LE_P4BYTE_TO_HOST_4BYTE(__pstart)  & \
 137                 (~BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen)) \
 138         )
 139 #define LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 140         ( \
 141                 LE_P2BYTE_TO_HOST_2BYTE(__pstart) & \
 142                 (~BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen)) \
 143         )
 144 #define LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 145         ( \
 146                 LE_P1BYTE_TO_HOST_1BYTE(__pstart) & \
 147                 (~BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen)) \
 148         )
 149
 150 /* Description:
 151  * Set subfield of little-endian 4-byte value to specified value.
 152  */
 153 #define SET_BITS_TO_LE_4BYTE(__pstart, __bitoffset, __bitlen, __val) \
 154                 *((u32 *)(__pstart)) =                          \
 155                 (                                                       \
 156                 LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) | \
 157                 ((((u32)__val) & BIT_LEN_MASK_32(__bitlen)) << (__bitoffset)) \
 158                 )
 159
 160 #define SET_BITS_TO_LE_2BYTE(__pstart, __bitoffset, __bitlen, __val) \
 161                 *((u16 *)(__pstart)) =                          \
 162                 (                                               \
 163                 LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
 164                 ((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
 165                 );
 166
 167 #define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
 168                 *((u8 *)(__pstart)) = EF1BYTE                   \
 169                 (                                               \
 170                 LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) | \
 171                 ((((u8)__val) & BIT_LEN_MASK_8(__bitlen)) << (__bitoffset)) \
 172                 )
 173
 174 /*  Get the N-bytes aligment offset from the current length */
 175 #define N_BYTE_ALIGMENT(__value, __aligment) ((__aligment == 1) ? \
 176         (__value) : (((__value + __aligment - 1) / __aligment) * __aligment))
 177
 178 #endif /* __BASIC_TYPES_H__ */