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 #define SUCCESS 0
  24 #define FAIL    (-1)
  25
  26 #include <linux/types.h>
  27 #define NDIS_OID uint
  28
  29 typedef void (*proc_t)(void *);
  30
  31 #define FIELD_OFFSET(s, field)  ((ssize_t)&((s *)(0))->field)
  32
  33 #define MEM_ALIGNMENT_OFFSET    (sizeof(size_t))
  34 #define MEM_ALIGNMENT_PADDING   (sizeof(size_t) - 1)
  35
  36 /* port from fw */
  37 /*  TODO: Macros Below are Sync from SD7-Driver. It is necessary
  38  * to check correctness */
  39
  40 /*
  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.
  45 */
  46
  47 /* Convert little data endian to host ordering */
  48 #define EF1BYTE(_val)           \
  49         ((u8)(_val))
  50 #define EF2BYTE(_val)           \
  51         (le16_to_cpu(_val))
  52 #define EF4BYTE(_val)           \
  53         (le32_to_cpu(_val))
  54
  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)       \
  60         EF2BYTE(*(_ptr))
  61 #define READEF4BYTE(_ptr)       \
  62         EF4BYTE(*(_ptr))
  63
  64 /* Write data to memory */
  65 #define WRITEEF1BYTE(_ptr, _val)                        \
  66         do {                                            \
  67                 (*((u8 *)(_ptr))) = EF1BYTE(_val)       \
  68         } while (0)
  69 /* Write le data to memory in host ordering */
  70 #define WRITEEF2BYTE(_ptr, _val)                        \
  71         do {                                            \
  72                 (*((u16 *)(_ptr))) = EF2BYTE(_val)      \
  73         } while (0)
  74
  75 #define WRITEEF4BYTE(_ptr, _val)                        \
  76         do {                                            \
  77                 (*((u32 *)(_ptr))) = EF2BYTE(_val)      \
  78         } while (0)
  79
  80 /* Create a bit mask
  81  * Examples:
  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
  86  */
  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)))
  93
  94 /* Create an offset bit mask
  95  * Examples:
  96  * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
  97  * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
  98  */
  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))
 105
 106 /*Description:
 107  * Return 4-byte value in host byte ordering from
 108  * 4-byte pointer in little-endian system.
 109  */
 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))))
 116
 117 /*Description:
 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) \
 121         ( \
 122                 (LE_P4BYTE_TO_HOST_4BYTE(__pstart) >> (__bitoffset))  & \
 123                 BIT_LEN_MASK_32(__bitlen) \
 124         )
 125 #define LE_BITS_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 126         ( \
 127                 (LE_P2BYTE_TO_HOST_2BYTE(__pstart) >> (__bitoffset)) & \
 128                 BIT_LEN_MASK_16(__bitlen) \
 129         )
 130 #define LE_BITS_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 131         ( \
 132                 (LE_P1BYTE_TO_HOST_1BYTE(__pstart) >> (__bitoffset)) & \
 133                 BIT_LEN_MASK_8(__bitlen) \
 134         )
 135
 136 /* Description:
 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.
 139  */
 140 #define LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
 141         ( \
 142                 LE_P4BYTE_TO_HOST_4BYTE(__pstart)  & \
 143                 (~BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen)) \
 144         )
 145 #define LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 146         ( \
 147                 LE_P2BYTE_TO_HOST_2BYTE(__pstart) & \
 148                 (~BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen)) \
 149         )
 150 #define LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 151         ( \
 152                 LE_P1BYTE_TO_HOST_1BYTE(__pstart) & \
 153                 (~BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen)) \
 154         )
 155
 156 /* Description:
 157  * Set subfield of little-endian 4-byte value to specified value.
 158  */
 159 #define SET_BITS_TO_LE_4BYTE(__pstart, __bitoffset, __bitlen, __val) \
 160                 *((u32 *)(__pstart)) =                          \
 161                 (                                                       \
 162                 LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) | \
 163                 ((((u32)__val) & BIT_LEN_MASK_32(__bitlen)) << (__bitoffset)) \
 164                 )
 165
 166 #define SET_BITS_TO_LE_2BYTE(__pstart, __bitoffset, __bitlen, __val) \
 167                 *((u16 *)(__pstart)) =                          \
 168                 (                                               \
 169                 LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
 170                 ((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
 171                 );
 172
 173 #define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
 174                 *((u8 *)(__pstart)) = EF1BYTE                   \
 175                 (                                               \
 176                 LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) | \
 177                 ((((u8)__val) & BIT_LEN_MASK_8(__bitlen)) << (__bitoffset)) \
 178                 )
 179
 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))
 183
 184 #endif /* __BASIC_TYPES_H__ */