root/drivers/net/wireless/ralink/rt2x00/rt2x00reg.h

INCLUDED FROM

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3         Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
   4         <http://rt2x00.serialmonkey.com>
   5 
   6  */
   7 
   8 /*
   9         Module: rt2x00
  10         Abstract: rt2x00 generic register information.
  11  */
  12 
  13 #ifndef RT2X00REG_H
  14 #define RT2X00REG_H
  15 
  16 /*
  17  * RX crypto status
  18  */
  19 enum rx_crypto {
  20         RX_CRYPTO_SUCCESS = 0,
  21         RX_CRYPTO_FAIL_ICV = 1,
  22         RX_CRYPTO_FAIL_MIC = 2,
  23         RX_CRYPTO_FAIL_KEY = 3,
  24 };
  25 
  26 /*
  27  * Antenna values
  28  */
  29 enum antenna {
  30         ANTENNA_SW_DIVERSITY = 0,
  31         ANTENNA_A = 1,
  32         ANTENNA_B = 2,
  33         ANTENNA_HW_DIVERSITY = 3,
  34 };
  35 
  36 /*
  37  * Led mode values.
  38  */
  39 enum led_mode {
  40         LED_MODE_DEFAULT = 0,
  41         LED_MODE_TXRX_ACTIVITY = 1,
  42         LED_MODE_SIGNAL_STRENGTH = 2,
  43         LED_MODE_ASUS = 3,
  44         LED_MODE_ALPHA = 4,
  45 };
  46 
  47 /*
  48  * TSF sync values
  49  */
  50 enum tsf_sync {
  51         TSF_SYNC_NONE = 0,
  52         TSF_SYNC_INFRA = 1,
  53         TSF_SYNC_ADHOC = 2,
  54         TSF_SYNC_AP_NONE = 3,
  55 };
  56 
  57 /*
  58  * Device states
  59  */
  60 enum dev_state {
  61         STATE_DEEP_SLEEP = 0,
  62         STATE_SLEEP = 1,
  63         STATE_STANDBY = 2,
  64         STATE_AWAKE = 3,
  65 
  66 /*
  67  * Additional device states, these values are
  68  * not strict since they are not directly passed
  69  * into the device.
  70  */
  71         STATE_RADIO_ON,
  72         STATE_RADIO_OFF,
  73         STATE_RADIO_IRQ_ON,
  74         STATE_RADIO_IRQ_OFF,
  75 };
  76 
  77 /*
  78  * IFS backoff values
  79  */
  80 enum ifs {
  81         IFS_BACKOFF = 0,
  82         IFS_SIFS = 1,
  83         IFS_NEW_BACKOFF = 2,
  84         IFS_NONE = 3,
  85 };
  86 
  87 /*
  88  * IFS backoff values for HT devices
  89  */
  90 enum txop {
  91         TXOP_HTTXOP = 0,
  92         TXOP_PIFS = 1,
  93         TXOP_SIFS = 2,
  94         TXOP_BACKOFF = 3,
  95 };
  96 
  97 /*
  98  * Cipher types for hardware encryption
  99  */
 100 enum cipher {
 101         CIPHER_NONE = 0,
 102         CIPHER_WEP64 = 1,
 103         CIPHER_WEP128 = 2,
 104         CIPHER_TKIP = 3,
 105         CIPHER_AES = 4,
 106 /*
 107  * The following fields were added by rt61pci and rt73usb.
 108  */
 109         CIPHER_CKIP64 = 5,
 110         CIPHER_CKIP128 = 6,
 111         CIPHER_TKIP_NO_MIC = 7, /* Don't send to device */
 112 
 113 /*
 114  * Max cipher type.
 115  * Note that CIPHER_NONE isn't counted, and CKIP64 and CKIP128
 116  * are excluded due to limitations in mac80211.
 117  */
 118         CIPHER_MAX = 4,
 119 };
 120 
 121 /*
 122  * Rate modulations
 123  */
 124 enum rate_modulation {
 125         RATE_MODE_CCK = 0,
 126         RATE_MODE_OFDM = 1,
 127         RATE_MODE_HT_MIX = 2,
 128         RATE_MODE_HT_GREENFIELD = 3,
 129 };
 130 
 131 /*
 132  * Firmware validation error codes
 133  */
 134 enum firmware_errors {
 135         FW_OK,
 136         FW_BAD_CRC,
 137         FW_BAD_LENGTH,
 138         FW_BAD_VERSION,
 139 };
 140 
 141 /*
 142  * Register handlers.
 143  * We store the position of a register field inside a field structure,
 144  * This will simplify the process of setting and reading a certain field
 145  * inside the register while making sure the process remains byte order safe.
 146  */
 147 struct rt2x00_field8 {
 148         u8 bit_offset;
 149         u8 bit_mask;
 150 };
 151 
 152 struct rt2x00_field16 {
 153         u16 bit_offset;
 154         u16 bit_mask;
 155 };
 156 
 157 struct rt2x00_field32 {
 158         u32 bit_offset;
 159         u32 bit_mask;
 160 };
 161 
 162 /*
 163  * Power of two check, this will check
 164  * if the mask that has been given contains and contiguous set of bits.
 165  * Note that we cannot use the is_power_of_2() function since this
 166  * check must be done at compile-time.
 167  */
 168 #define is_power_of_two(x)      ( !((x) & ((x)-1)) )
 169 #define low_bit_mask(x)         ( ((x)-1) & ~(x) )
 170 #define is_valid_mask(x)        is_power_of_two(1LU + (x) + low_bit_mask(x))
 171 
 172 /*
 173  * Macros to find first set bit in a variable.
 174  * These macros behave the same as the __ffs() functions but
 175  * the most important difference that this is done during
 176  * compile-time rather then run-time.
 177  */
 178 #define compile_ffs2(__x) \
 179         __builtin_choose_expr(((__x) & 0x1), 0, 1)
 180 
 181 #define compile_ffs4(__x) \
 182         __builtin_choose_expr(((__x) & 0x3), \
 183                               (compile_ffs2((__x))), \
 184                               (compile_ffs2((__x) >> 2) + 2))
 185 
 186 #define compile_ffs8(__x) \
 187         __builtin_choose_expr(((__x) & 0xf), \
 188                               (compile_ffs4((__x))), \
 189                               (compile_ffs4((__x) >> 4) + 4))
 190 
 191 #define compile_ffs16(__x) \
 192         __builtin_choose_expr(((__x) & 0xff), \
 193                               (compile_ffs8((__x))), \
 194                               (compile_ffs8((__x) >> 8) + 8))
 195 
 196 #define compile_ffs32(__x) \
 197         __builtin_choose_expr(((__x) & 0xffff), \
 198                               (compile_ffs16((__x))), \
 199                               (compile_ffs16((__x) >> 16) + 16))
 200 
 201 /*
 202  * This macro will check the requirements for the FIELD{8,16,32} macros
 203  * The mask should be a constant non-zero contiguous set of bits which
 204  * does not exceed the given typelimit.
 205  */
 206 #define FIELD_CHECK(__mask, __type)                     \
 207         BUILD_BUG_ON(!(__mask) ||                       \
 208                      !is_valid_mask(__mask) ||          \
 209                      (__mask) != (__type)(__mask))      \
 210 
 211 #define FIELD8(__mask)                          \
 212 ({                                              \
 213         FIELD_CHECK(__mask, u8);                \
 214         (struct rt2x00_field8) {                \
 215                 compile_ffs8(__mask), (__mask)  \
 216         };                                      \
 217 })
 218 
 219 #define FIELD16(__mask)                         \
 220 ({                                              \
 221         FIELD_CHECK(__mask, u16);               \
 222         (struct rt2x00_field16) {               \
 223                 compile_ffs16(__mask), (__mask) \
 224         };                                      \
 225 })
 226 
 227 #define FIELD32(__mask)                         \
 228 ({                                              \
 229         FIELD_CHECK(__mask, u32);               \
 230         (struct rt2x00_field32) {               \
 231                 compile_ffs32(__mask), (__mask) \
 232         };                                      \
 233 })
 234 
 235 #define SET_FIELD(__reg, __type, __field, __value)\
 236 ({                                              \
 237         typecheck(__type, __field);             \
 238         *(__reg) &= ~((__field).bit_mask);      \
 239         *(__reg) |= ((__value) <<               \
 240             ((__field).bit_offset)) &           \
 241             ((__field).bit_mask);               \
 242 })
 243 
 244 #define GET_FIELD(__reg, __type, __field)       \
 245 ({                                              \
 246         typecheck(__type, __field);             \
 247         ((__reg) & ((__field).bit_mask)) >>     \
 248             ((__field).bit_offset);             \
 249 })
 250 
 251 #define rt2x00_set_field32(__reg, __field, __value) \
 252         SET_FIELD(__reg, struct rt2x00_field32, __field, __value)
 253 #define rt2x00_get_field32(__reg, __field) \
 254         GET_FIELD(__reg, struct rt2x00_field32, __field)
 255 
 256 #define rt2x00_set_field16(__reg, __field, __value) \
 257         SET_FIELD(__reg, struct rt2x00_field16, __field, __value)
 258 #define rt2x00_get_field16(__reg, __field) \
 259         GET_FIELD(__reg, struct rt2x00_field16, __field)
 260 
 261 #define rt2x00_set_field8(__reg, __field, __value) \
 262         SET_FIELD(__reg, struct rt2x00_field8, __field, __value)
 263 #define rt2x00_get_field8(__reg, __field) \
 264         GET_FIELD(__reg, struct rt2x00_field8, __field)
 265 
 266 #endif /* RT2X00REG_H */