drivers/staging/rtl8723bs/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  ******************************************************************************/
  15 #ifndef __BASIC_TYPES_H__
  16 #define __BASIC_TYPES_H__
  17
  18
  19 #define SUCCESS 0
  20 #define FAIL    (-1)
  21
  22 #include <linux/types.h>
  23
  24 typedef signed int sint;
  25
  26 #define FIELD_OFFSET(s, field)  ((__kernel_ssize_t)&((s*)(0))->field)
  27
  28 #define SIZE_PTR __kernel_size_t
  29 #define SSIZE_PTR __kernel_ssize_t
  30
  31 /* port from fw by thomas */
  32 /*  TODO: Belows are Sync from SD7-Driver. It is necessary 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 /*  */
  42 /*  Byte Swapping routine. */
  43 /*  */
  44 #define EF1Byte (u8)
  45 #define EF2Byte         le16_to_cpu
  46 #define EF4Byte le32_to_cpu
  47
  48 /* Convert little data endian to host ordering */
  49 #define EF1BYTE(_val)           \
  50         ((u8)(_val))
  51 #define EF2BYTE(_val)           \
  52         (le16_to_cpu(_val))
  53 #define EF4BYTE(_val)           \
  54         (le32_to_cpu(_val))
  55
  56 /* Read data from memory */
  57 #define READEF1BYTE(_ptr)       \
  58         EF1BYTE(*((u8 *)(_ptr)))
  59 /* Read le16 data from memory and convert to host ordering */
  60 #define READEF2BYTE(_ptr)       \
  61         EF2BYTE(*(_ptr))
  62 #define READEF4BYTE(_ptr)       \
  63         EF4BYTE(*(_ptr))
  64
  65 /* Write data to memory */
  66 #define WRITEEF1BYTE(_ptr, _val)                        \
  67         do {                                            \
  68                 (*((u8 *)(_ptr))) = EF1BYTE(_val);      \
  69         } while (0)
  70 /* Write le data to memory in host ordering */
  71 #define WRITEEF2BYTE(_ptr, _val)                        \
  72         do {                                            \
  73                 (*((u16 *)(_ptr))) = EF2BYTE(_val);     \
  74         } while (0)
  75
  76 #define WRITEEF4BYTE(_ptr, _val)                        \
  77         do {                                            \
  78                 (*((u32 *)(_ptr))) = EF2BYTE(_val);     \
  79         } while (0)
  80
  81 /* Create a bit mask
  82  * Examples:
  83  * BIT_LEN_MASK_32(0) => 0x00000000
  84  * BIT_LEN_MASK_32(1) => 0x00000001
  85  * BIT_LEN_MASK_32(2) => 0x00000003
  86  * BIT_LEN_MASK_32(32) => 0xFFFFFFFF
  87  */
  88 #define BIT_LEN_MASK_32(__bitlen)        \
  89         (0xFFFFFFFF >> (32 - (__bitlen)))
  90 #define BIT_LEN_MASK_16(__bitlen)        \
  91         (0xFFFF >> (16 - (__bitlen)))
  92 #define BIT_LEN_MASK_8(__bitlen) \
  93         (0xFF >> (8 - (__bitlen)))
  94
  95 /* Create an offset bit mask
  96  * Examples:
  97  * BIT_OFFSET_LEN_MASK_32(0, 2) => 0x00000003
  98  * BIT_OFFSET_LEN_MASK_32(16, 2) => 0x00030000
  99  */
 100 #define BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen) \
 101         (BIT_LEN_MASK_32(__bitlen) << (__bitoffset))
 102 #define BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen) \
 103         (BIT_LEN_MASK_16(__bitlen) << (__bitoffset))
 104 #define BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen) \
 105         (BIT_LEN_MASK_8(__bitlen) << (__bitoffset))
 106
 107 /*Description:
 108  * Return 4-byte value in host byte ordering from
 109  * 4-byte pointer in little-endian system.
 110  */
 111 #define LE_P4BYTE_TO_HOST_4BYTE(__pstart) \
 112         (EF4BYTE(*((__le32 *)(__pstart))))
 113 #define LE_P2BYTE_TO_HOST_2BYTE(__pstart) \
 114         (EF2BYTE(*((__le16 *)(__pstart))))
 115 #define LE_P1BYTE_TO_HOST_1BYTE(__pstart) \
 116         (EF1BYTE(*((u8 *)(__pstart))))
 117
 118 /*  */
 119 /*      Description: */
 120 /*              Translate subfield (continuous bits in little-endian) of 4-byte value in litten byte to */
 121 /*              4-byte value in host byte ordering. */
 122 /*  */
 123 #define LE_BITS_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
 124         (\
 125                 (LE_P4BYTE_TO_HOST_4BYTE(__pstart) >> (__bitoffset))  & \
 126                 BIT_LEN_MASK_32(__bitlen) \
 127         )
 128 #define LE_BITS_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 129         (\
 130                 (LE_P2BYTE_TO_HOST_2BYTE(__pstart) >> (__bitoffset)) & \
 131                 BIT_LEN_MASK_16(__bitlen) \
 132         )
 133 #define LE_BITS_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 134         (\
 135                 (LE_P1BYTE_TO_HOST_1BYTE(__pstart) >> (__bitoffset)) & \
 136                 BIT_LEN_MASK_8(__bitlen) \
 137         )
 138
 139 /*  */
 140 /*      Description: */
 141 /*              Mask subfield (continuous bits in little-endian) of 4-byte value in litten byte oredering */
 142 /*              and return the result in 4-byte value in host byte ordering. */
 143 /*  */
 144 #define LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) \
 145         (\
 146                 LE_P4BYTE_TO_HOST_4BYTE(__pstart)  & \
 147                 (~BIT_OFFSET_LEN_MASK_32(__bitoffset, __bitlen)) \
 148         )
 149 #define LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) \
 150         (\
 151                 LE_P2BYTE_TO_HOST_2BYTE(__pstart) & \
 152                 (~BIT_OFFSET_LEN_MASK_16(__bitoffset, __bitlen)) \
 153         )
 154 #define LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) \
 155         (\
 156                 LE_P1BYTE_TO_HOST_1BYTE(__pstart) & \
 157                 (~BIT_OFFSET_LEN_MASK_8(__bitoffset, __bitlen)) \
 158         )
 159
 160 /*  */
 161 /*      Description: */
 162 /*              Set subfield of little-endian 4-byte value to specified value. */
 163 /*  */
 164 #define SET_BITS_TO_LE_4BYTE(__pstart, __bitoffset, __bitlen, __val) \
 165                 *((u32 *)(__pstart)) =                          \
 166                 (                                               \
 167                 LE_BITS_CLEARED_TO_4BYTE(__pstart, __bitoffset, __bitlen) | \
 168                 ((((u32)__val) & BIT_LEN_MASK_32(__bitlen)) << (__bitoffset)) \
 169                 )
 170
 171 #define SET_BITS_TO_LE_2BYTE(__pstart, __bitoffset, __bitlen, __val) \
 172                 *((u16 *)(__pstart)) =                          \
 173                 (                                       \
 174                 LE_BITS_CLEARED_TO_2BYTE(__pstart, __bitoffset, __bitlen) | \
 175                 ((((u16)__val) & BIT_LEN_MASK_16(__bitlen)) << (__bitoffset)) \
 176                 );
 177
 178 #define SET_BITS_TO_LE_1BYTE(__pstart, __bitoffset, __bitlen, __val) \
 179                 *((u8 *)(__pstart)) = EF1BYTE                   \
 180                 (                                       \
 181                 LE_BITS_CLEARED_TO_1BYTE(__pstart, __bitoffset, __bitlen) | \
 182                 ((((u8)__val) & BIT_LEN_MASK_8(__bitlen)) << (__bitoffset)) \
 183                 )
 184
 185 #define LE_BITS_CLEARED_TO_1BYTE_8BIT(__pStart, __BitOffset, __BitLen) \
 186         (\
 187                 LE_P1BYTE_TO_HOST_1BYTE(__pStart) \
 188         )
 189
 190 #define SET_BITS_TO_LE_1BYTE_8BIT(__pStart, __BitOffset, __BitLen, __Value) \
 191 { \
 192         *((u8 *)(__pStart)) = \
 193                 EF1Byte(\
 194                         LE_BITS_CLEARED_TO_1BYTE_8BIT(__pStart, __BitOffset, __BitLen) \
 195                         | \
 196                         ((u8)__Value) \
 197                 ); \
 198 }
 199
 200 /*  Get the N-bytes aligment offset from the current length */
 201 #define N_BYTE_ALIGMENT(__Value, __Aligment) ((__Aligment == 1) ? (__Value) : (((__Value + __Aligment - 1) / __Aligment) * __Aligment))
 202
 203 #define TEST_FLAG(__Flag, __testFlag)           (((__Flag) & (__testFlag)) != 0)
 204 #define SET_FLAG(__Flag, __setFlag)                     ((__Flag) |= __setFlag)
 205 #define CLEAR_FLAG(__Flag, __clearFlag)         ((__Flag) &= ~(__clearFlag))
 206 #define CLEAR_FLAGS(__Flag)                                     ((__Flag) = 0)
 207 #define TEST_FLAGS(__Flag, __testFlags)         (((__Flag) & (__testFlags)) == (__testFlags))
 208
 209 #endif /* __BASIC_TYPES_H__ */