drivers/staging/r8188eu/include/basic_types.h

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