drivers/net/wireless/brcm80211/brcmsmac/srom.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/string.h>
  19 #include <linux/io.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/crc8.h>
  22 #include <stdarg.h>
  23
  24 #include <chipcommon.h>
  25 #include <brcmu_utils.h>
  26 #include "pub.h"
  27 #include "nicpci.h"
  28 #include "aiutils.h"
  29 #include "otp.h"
  30 #include "srom.h"
  31 #include "soc.h"
  32
  33 /*
  34  * SROM CRC8 polynomial value:
  35  *
  36  * x^8 + x^7 +x^6 + x^4 + x^2 + 1
  37  */
  38 #define SROM_CRC8_POLY          0xAB
  39
  40 /* Maximum srom: 6 Kilobits == 768 bytes */
  41 #define SROM_MAX                768
  42
  43 /* PCI fields */
  44 #define PCI_F0DEVID             48
  45
  46 #define SROM_WORDS              64
  47
  48 #define SROM_SSID               2
  49
  50 #define SROM_WL1LHMAXP          29
  51
  52 #define SROM_WL1LPAB0           30
  53 #define SROM_WL1LPAB1           31
  54 #define SROM_WL1LPAB2           32
  55
  56 #define SROM_WL1HPAB0           33
  57 #define SROM_WL1HPAB1           34
  58 #define SROM_WL1HPAB2           35
  59
  60 #define SROM_MACHI_IL0          36
  61 #define SROM_MACMID_IL0         37
  62 #define SROM_MACLO_IL0          38
  63 #define SROM_MACHI_ET1          42
  64 #define SROM_MACMID_ET1         43
  65 #define SROM_MACLO_ET1          44
  66 #define SROM3_MACHI             37
  67 #define SROM3_MACMID            38
  68 #define SROM3_MACLO             39
  69
  70 #define SROM_BXARSSI2G          40
  71 #define SROM_BXARSSI5G          41
  72
  73 #define SROM_TRI52G             42
  74 #define SROM_TRI5GHL            43
  75
  76 #define SROM_RXPO52G            45
  77
  78 #define SROM_AABREV             46
  79 /* Fields in AABREV */
  80 #define SROM_BR_MASK            0x00ff
  81 #define SROM_CC_MASK            0x0f00
  82 #define SROM_CC_SHIFT           8
  83 #define SROM_AA0_MASK           0x3000
  84 #define SROM_AA0_SHIFT          12
  85 #define SROM_AA1_MASK           0xc000
  86 #define SROM_AA1_SHIFT          14
  87
  88 #define SROM_WL0PAB0            47
  89 #define SROM_WL0PAB1            48
  90 #define SROM_WL0PAB2            49
  91
  92 #define SROM_LEDBH10            50
  93 #define SROM_LEDBH32            51
  94
  95 #define SROM_WL10MAXP           52
  96
  97 #define SROM_WL1PAB0            53
  98 #define SROM_WL1PAB1            54
  99 #define SROM_WL1PAB2            55
 100
 101 #define SROM_ITT                56
 102
 103 #define SROM_BFL                57
 104 #define SROM_BFL2               28
 105 #define SROM3_BFL2              61
 106
 107 #define SROM_AG10               58
 108
 109 #define SROM_CCODE              59
 110
 111 #define SROM_OPO                60
 112
 113 #define SROM3_LEDDC             62
 114
 115 #define SROM_CRCREV             63
 116
 117 /* SROM Rev 4: Reallocate the software part of the srom to accommodate
 118  * MIMO features. It assumes up to two PCIE functions and 440 bytes
 119  * of usable srom i.e. the usable storage in chips with OTP that
 120  * implements hardware redundancy.
 121  */
 122
 123 #define SROM4_WORDS             220
 124
 125 #define SROM4_SIGN              32
 126 #define SROM4_SIGNATURE         0x5372
 127
 128 #define SROM4_BREV              33
 129
 130 #define SROM4_BFL0              34
 131 #define SROM4_BFL1              35
 132 #define SROM4_BFL2              36
 133 #define SROM4_BFL3              37
 134 #define SROM5_BFL0              37
 135 #define SROM5_BFL1              38
 136 #define SROM5_BFL2              39
 137 #define SROM5_BFL3              40
 138
 139 #define SROM4_MACHI             38
 140 #define SROM4_MACMID            39
 141 #define SROM4_MACLO             40
 142 #define SROM5_MACHI             41
 143 #define SROM5_MACMID            42
 144 #define SROM5_MACLO             43
 145
 146 #define SROM4_CCODE             41
 147 #define SROM4_REGREV            42
 148 #define SROM5_CCODE             34
 149 #define SROM5_REGREV            35
 150
 151 #define SROM4_LEDBH10           43
 152 #define SROM4_LEDBH32           44
 153 #define SROM5_LEDBH10           59
 154 #define SROM5_LEDBH32           60
 155
 156 #define SROM4_LEDDC             45
 157 #define SROM5_LEDDC             45
 158
 159 #define SROM4_AA                46
 160
 161 #define SROM4_AG10              47
 162 #define SROM4_AG32              48
 163
 164 #define SROM4_TXPID2G           49
 165 #define SROM4_TXPID5G           51
 166 #define SROM4_TXPID5GL          53
 167 #define SROM4_TXPID5GH          55
 168
 169 #define SROM4_TXRXC             61
 170 #define SROM4_TXCHAIN_MASK      0x000f
 171 #define SROM4_TXCHAIN_SHIFT     0
 172 #define SROM4_RXCHAIN_MASK      0x00f0
 173 #define SROM4_RXCHAIN_SHIFT     4
 174 #define SROM4_SWITCH_MASK       0xff00
 175 #define SROM4_SWITCH_SHIFT      8
 176
 177 /* Per-path fields */
 178 #define MAX_PATH_SROM           4
 179 #define SROM4_PATH0             64
 180 #define SROM4_PATH1             87
 181 #define SROM4_PATH2             110
 182 #define SROM4_PATH3             133
 183
 184 #define SROM4_2G_ITT_MAXP       0
 185 #define SROM4_2G_PA             1
 186 #define SROM4_5G_ITT_MAXP       5
 187 #define SROM4_5GLH_MAXP         6
 188 #define SROM4_5G_PA             7
 189 #define SROM4_5GL_PA            11
 190 #define SROM4_5GH_PA            15
 191
 192 /* All the miriad power offsets */
 193 #define SROM4_2G_CCKPO          156
 194 #define SROM4_2G_OFDMPO         157
 195 #define SROM4_5G_OFDMPO         159
 196 #define SROM4_5GL_OFDMPO        161
 197 #define SROM4_5GH_OFDMPO        163
 198 #define SROM4_2G_MCSPO          165
 199 #define SROM4_5G_MCSPO          173
 200 #define SROM4_5GL_MCSPO         181
 201 #define SROM4_5GH_MCSPO         189
 202 #define SROM4_CDDPO             197
 203 #define SROM4_STBCPO            198
 204 #define SROM4_BW40PO            199
 205 #define SROM4_BWDUPPO           200
 206
 207 #define SROM4_CRCREV            219
 208
 209 /* SROM Rev 8: Make space for a 48word hardware header for PCIe rev >= 6.
 210  * This is acombined srom for both MIMO and SISO boards, usable in
 211  * the .130 4Kilobit OTP with hardware redundancy.
 212  */
 213 #define SROM8_BREV              65
 214
 215 #define SROM8_BFL0              66
 216 #define SROM8_BFL1              67
 217 #define SROM8_BFL2              68
 218 #define SROM8_BFL3              69
 219
 220 #define SROM8_MACHI             70
 221 #define SROM8_MACMID            71
 222 #define SROM8_MACLO             72
 223
 224 #define SROM8_CCODE             73
 225 #define SROM8_REGREV            74
 226
 227 #define SROM8_LEDBH10           75
 228 #define SROM8_LEDBH32           76
 229
 230 #define SROM8_LEDDC             77
 231
 232 #define SROM8_AA                78
 233
 234 #define SROM8_AG10              79
 235 #define SROM8_AG32              80
 236
 237 #define SROM8_TXRXC             81
 238
 239 #define SROM8_BXARSSI2G         82
 240 #define SROM8_BXARSSI5G         83
 241 #define SROM8_TRI52G            84
 242 #define SROM8_TRI5GHL           85
 243 #define SROM8_RXPO52G           86
 244
 245 #define SROM8_FEM2G             87
 246 #define SROM8_FEM5G             88
 247 #define SROM8_FEM_ANTSWLUT_MASK         0xf800
 248 #define SROM8_FEM_ANTSWLUT_SHIFT        11
 249 #define SROM8_FEM_TR_ISO_MASK           0x0700
 250 #define SROM8_FEM_TR_ISO_SHIFT          8
 251 #define SROM8_FEM_PDET_RANGE_MASK       0x00f8
 252 #define SROM8_FEM_PDET_RANGE_SHIFT      3
 253 #define SROM8_FEM_EXTPA_GAIN_MASK       0x0006
 254 #define SROM8_FEM_EXTPA_GAIN_SHIFT      1
 255 #define SROM8_FEM_TSSIPOS_MASK          0x0001
 256 #define SROM8_FEM_TSSIPOS_SHIFT         0
 257
 258 #define SROM8_THERMAL           89
 259
 260 /* Temp sense related entries */
 261 #define SROM8_MPWR_RAWTS                90
 262 #define SROM8_TS_SLP_OPT_CORRX  91
 263 /* FOC: freiquency offset correction, HWIQ: H/W IOCAL enable,
 264  * IQSWP: IQ CAL swap disable */
 265 #define SROM8_FOC_HWIQ_IQSWP    92
 266
 267 /* Temperature delta for PHY calibration */
 268 #define SROM8_PHYCAL_TEMPDELTA  93
 269
 270 /* Per-path offsets & fields */
 271 #define SROM8_PATH0             96
 272 #define SROM8_PATH1             112
 273 #define SROM8_PATH2             128
 274 #define SROM8_PATH3             144
 275
 276 #define SROM8_2G_ITT_MAXP       0
 277 #define SROM8_2G_PA             1
 278 #define SROM8_5G_ITT_MAXP       4
 279 #define SROM8_5GLH_MAXP         5
 280 #define SROM8_5G_PA             6
 281 #define SROM8_5GL_PA            9
 282 #define SROM8_5GH_PA            12
 283
 284 /* All the miriad power offsets */
 285 #define SROM8_2G_CCKPO          160
 286
 287 #define SROM8_2G_OFDMPO         161
 288 #define SROM8_5G_OFDMPO         163
 289 #define SROM8_5GL_OFDMPO        165
 290 #define SROM8_5GH_OFDMPO        167
 291
 292 #define SROM8_2G_MCSPO          169
 293 #define SROM8_5G_MCSPO          177
 294 #define SROM8_5GL_MCSPO         185
 295 #define SROM8_5GH_MCSPO         193
 296
 297 #define SROM8_CDDPO             201
 298 #define SROM8_STBCPO            202
 299 #define SROM8_BW40PO            203
 300 #define SROM8_BWDUPPO           204
 301
 302 /* SISO PA parameters are in the path0 spaces */
 303 #define SROM8_SISO              96
 304
 305 /* Legacy names for SISO PA paramters */
 306 #define SROM8_W0_ITTMAXP        (SROM8_SISO + SROM8_2G_ITT_MAXP)
 307 #define SROM8_W0_PAB0           (SROM8_SISO + SROM8_2G_PA)
 308 #define SROM8_W0_PAB1           (SROM8_SISO + SROM8_2G_PA + 1)
 309 #define SROM8_W0_PAB2           (SROM8_SISO + SROM8_2G_PA + 2)
 310 #define SROM8_W1_ITTMAXP        (SROM8_SISO + SROM8_5G_ITT_MAXP)
 311 #define SROM8_W1_MAXP_LCHC      (SROM8_SISO + SROM8_5GLH_MAXP)
 312 #define SROM8_W1_PAB0           (SROM8_SISO + SROM8_5G_PA)
 313 #define SROM8_W1_PAB1           (SROM8_SISO + SROM8_5G_PA + 1)
 314 #define SROM8_W1_PAB2           (SROM8_SISO + SROM8_5G_PA + 2)
 315 #define SROM8_W1_PAB0_LC        (SROM8_SISO + SROM8_5GL_PA)
 316 #define SROM8_W1_PAB1_LC        (SROM8_SISO + SROM8_5GL_PA + 1)
 317 #define SROM8_W1_PAB2_LC        (SROM8_SISO + SROM8_5GL_PA + 2)
 318 #define SROM8_W1_PAB0_HC        (SROM8_SISO + SROM8_5GH_PA)
 319 #define SROM8_W1_PAB1_HC        (SROM8_SISO + SROM8_5GH_PA + 1)
 320 #define SROM8_W1_PAB2_HC        (SROM8_SISO + SROM8_5GH_PA + 2)
 321
 322 /* SROM REV 9 */
 323 #define SROM9_2GPO_CCKBW20      160
 324 #define SROM9_2GPO_CCKBW20UL    161
 325 #define SROM9_2GPO_LOFDMBW20    162
 326 #define SROM9_2GPO_LOFDMBW20UL  164
 327
 328 #define SROM9_5GLPO_LOFDMBW20   166
 329 #define SROM9_5GLPO_LOFDMBW20UL 168
 330 #define SROM9_5GMPO_LOFDMBW20   170
 331 #define SROM9_5GMPO_LOFDMBW20UL 172
 332 #define SROM9_5GHPO_LOFDMBW20   174
 333 #define SROM9_5GHPO_LOFDMBW20UL 176
 334
 335 #define SROM9_2GPO_MCSBW20      178
 336 #define SROM9_2GPO_MCSBW20UL    180
 337 #define SROM9_2GPO_MCSBW40      182
 338
 339 #define SROM9_5GLPO_MCSBW20     184
 340 #define SROM9_5GLPO_MCSBW20UL   186
 341 #define SROM9_5GLPO_MCSBW40     188
 342 #define SROM9_5GMPO_MCSBW20     190
 343 #define SROM9_5GMPO_MCSBW20UL   192
 344 #define SROM9_5GMPO_MCSBW40     194
 345 #define SROM9_5GHPO_MCSBW20     196
 346 #define SROM9_5GHPO_MCSBW20UL   198
 347 #define SROM9_5GHPO_MCSBW40     200
 348
 349 #define SROM9_PO_MCS32          202
 350 #define SROM9_PO_LOFDM40DUP     203
 351
 352 /* SROM flags (see sromvar_t) */
 353
 354 /* value continues as described by the next entry */
 355 #define SRFL_MORE       1
 356 #define SRFL_NOFFS      2       /* value bits can't be all one's */
 357 #define SRFL_PRHEX      4       /* value is in hexdecimal format */
 358 #define SRFL_PRSIGN     8       /* value is in signed decimal format */
 359 #define SRFL_CCODE      0x10    /* value is in country code format */
 360 #define SRFL_ETHADDR    0x20    /* value is an Ethernet address */
 361 #define SRFL_LEDDC      0x40    /* value is an LED duty cycle */
 362 /* do not generate a nvram param, entry is for mfgc */
 363 #define SRFL_NOVAR      0x80
 364
 365 /* Max. nvram variable table size */
 366 #define MAXSZ_NVRAM_VARS        4096
 367
 368 /*
 369  * indicates type of value.
 370  */
 371 enum brcms_srom_var_type {
 372         BRCMS_SROM_STRING,
 373         BRCMS_SROM_SNUMBER,
 374         BRCMS_SROM_UNUMBER
 375 };
 376
 377 /*
 378  * storage type for srom variable.
 379  *
 380  * var_list: for linked list operations.
 381  * varid: identifier of the variable.
 382  * var_type: type of variable.
 383  * buf: variable value when var_type == BRCMS_SROM_STRING.
 384  * uval: unsigned variable value when var_type == BRCMS_SROM_UNUMBER.
 385  * sval: signed variable value when var_type == BRCMS_SROM_SNUMBER.
 386  */
 387 struct brcms_srom_list_head {
 388         struct list_head var_list;
 389         enum brcms_srom_id varid;
 390         enum brcms_srom_var_type var_type;
 391         union {
 392                 char buf[0];
 393                 u32 uval;
 394                 s32 sval;
 395         };
 396 };
 397
 398 struct brcms_sromvar {
 399         enum brcms_srom_id varid;
 400         u32 revmask;
 401         u32 flags;
 402         u16 off;
 403         u16 mask;
 404 };
 405
 406 struct brcms_varbuf {
 407         char *base;             /* pointer to buffer base */
 408         char *buf;              /* pointer to current position */
 409         unsigned int size;      /* current (residual) size in bytes */
 410 };
 411
 412 /*
 413  * Assumptions:
 414  * - Ethernet address spans across 3 consecutive words
 415  *
 416  * Table rules:
 417  * - Add multiple entries next to each other if a value spans across multiple
 418  *   words (even multiple fields in the same word) with each entry except the
 419  *   last having it's SRFL_MORE bit set.
 420  * - Ethernet address entry does not follow above rule and must not have
 421  *   SRFL_MORE bit set. Its SRFL_ETHADDR bit implies it takes multiple words.
 422  * - The last entry's name field must be NULL to indicate the end of the table.
 423  *   Other entries must have non-NULL name.
 424  */
 425 static const struct brcms_sromvar pci_sromvars[] = {
 426         {BRCMS_SROM_DEVID, 0xffffff00, SRFL_PRHEX | SRFL_NOVAR, PCI_F0DEVID,
 427          0xffff},
 428         {BRCMS_SROM_BOARDREV, 0x0000000e, SRFL_PRHEX, SROM_AABREV,
 429          SROM_BR_MASK},
 430         {BRCMS_SROM_BOARDREV, 0x000000f0, SRFL_PRHEX, SROM4_BREV, 0xffff},
 431         {BRCMS_SROM_BOARDREV, 0xffffff00, SRFL_PRHEX, SROM8_BREV, 0xffff},
 432         {BRCMS_SROM_BOARDFLAGS, 0x00000002, SRFL_PRHEX, SROM_BFL, 0xffff},
 433         {BRCMS_SROM_BOARDFLAGS, 0x00000004, SRFL_PRHEX | SRFL_MORE, SROM_BFL,
 434          0xffff},
 435         {BRCMS_SROM_CONT, 0, 0, SROM_BFL2, 0xffff},
 436         {BRCMS_SROM_BOARDFLAGS, 0x00000008, SRFL_PRHEX | SRFL_MORE, SROM_BFL,
 437          0xffff},
 438         {BRCMS_SROM_CONT, 0, 0, SROM3_BFL2, 0xffff},
 439         {BRCMS_SROM_BOARDFLAGS, 0x00000010, SRFL_PRHEX | SRFL_MORE, SROM4_BFL0,
 440          0xffff},
 441         {BRCMS_SROM_CONT, 0, 0, SROM4_BFL1, 0xffff},
 442         {BRCMS_SROM_BOARDFLAGS, 0x000000e0, SRFL_PRHEX | SRFL_MORE, SROM5_BFL0,
 443          0xffff},
 444         {BRCMS_SROM_CONT, 0, 0, SROM5_BFL1, 0xffff},
 445         {BRCMS_SROM_BOARDFLAGS, 0xffffff00, SRFL_PRHEX | SRFL_MORE, SROM8_BFL0,
 446          0xffff},
 447         {BRCMS_SROM_CONT, 0, 0, SROM8_BFL1, 0xffff},
 448         {BRCMS_SROM_BOARDFLAGS2, 0x00000010, SRFL_PRHEX | SRFL_MORE, SROM4_BFL2,
 449          0xffff},
 450         {BRCMS_SROM_CONT, 0, 0, SROM4_BFL3, 0xffff},
 451         {BRCMS_SROM_BOARDFLAGS2, 0x000000e0, SRFL_PRHEX | SRFL_MORE, SROM5_BFL2,
 452          0xffff},
 453         {BRCMS_SROM_CONT, 0, 0, SROM5_BFL3, 0xffff},
 454         {BRCMS_SROM_BOARDFLAGS2, 0xffffff00, SRFL_PRHEX | SRFL_MORE, SROM8_BFL2,
 455          0xffff},
 456         {BRCMS_SROM_CONT, 0, 0, SROM8_BFL3, 0xffff},
 457         {BRCMS_SROM_BOARDTYPE, 0xfffffffc, SRFL_PRHEX, SROM_SSID, 0xffff},
 458         {BRCMS_SROM_BOARDNUM, 0x00000006, 0, SROM_MACLO_IL0, 0xffff},
 459         {BRCMS_SROM_BOARDNUM, 0x00000008, 0, SROM3_MACLO, 0xffff},
 460         {BRCMS_SROM_BOARDNUM, 0x00000010, 0, SROM4_MACLO, 0xffff},
 461         {BRCMS_SROM_BOARDNUM, 0x000000e0, 0, SROM5_MACLO, 0xffff},
 462         {BRCMS_SROM_BOARDNUM, 0xffffff00, 0, SROM8_MACLO, 0xffff},
 463         {BRCMS_SROM_CC, 0x00000002, 0, SROM_AABREV, SROM_CC_MASK},
 464         {BRCMS_SROM_REGREV, 0x00000008, 0, SROM_OPO, 0xff00},
 465         {BRCMS_SROM_REGREV, 0x00000010, 0, SROM4_REGREV, 0x00ff},
 466         {BRCMS_SROM_REGREV, 0x000000e0, 0, SROM5_REGREV, 0x00ff},
 467         {BRCMS_SROM_REGREV, 0xffffff00, 0, SROM8_REGREV, 0x00ff},
 468         {BRCMS_SROM_LEDBH0, 0x0000000e, SRFL_NOFFS, SROM_LEDBH10, 0x00ff},
 469         {BRCMS_SROM_LEDBH1, 0x0000000e, SRFL_NOFFS, SROM_LEDBH10, 0xff00},
 470         {BRCMS_SROM_LEDBH2, 0x0000000e, SRFL_NOFFS, SROM_LEDBH32, 0x00ff},
 471         {BRCMS_SROM_LEDBH3, 0x0000000e, SRFL_NOFFS, SROM_LEDBH32, 0xff00},
 472         {BRCMS_SROM_LEDBH0, 0x00000010, SRFL_NOFFS, SROM4_LEDBH10, 0x00ff},
 473         {BRCMS_SROM_LEDBH1, 0x00000010, SRFL_NOFFS, SROM4_LEDBH10, 0xff00},
 474         {BRCMS_SROM_LEDBH2, 0x00000010, SRFL_NOFFS, SROM4_LEDBH32, 0x00ff},
 475         {BRCMS_SROM_LEDBH3, 0x00000010, SRFL_NOFFS, SROM4_LEDBH32, 0xff00},
 476         {BRCMS_SROM_LEDBH0, 0x000000e0, SRFL_NOFFS, SROM5_LEDBH10, 0x00ff},
 477         {BRCMS_SROM_LEDBH1, 0x000000e0, SRFL_NOFFS, SROM5_LEDBH10, 0xff00},
 478         {BRCMS_SROM_LEDBH2, 0x000000e0, SRFL_NOFFS, SROM5_LEDBH32, 0x00ff},
 479         {BRCMS_SROM_LEDBH3, 0x000000e0, SRFL_NOFFS, SROM5_LEDBH32, 0xff00},
 480         {BRCMS_SROM_LEDBH0, 0xffffff00, SRFL_NOFFS, SROM8_LEDBH10, 0x00ff},
 481         {BRCMS_SROM_LEDBH1, 0xffffff00, SRFL_NOFFS, SROM8_LEDBH10, 0xff00},
 482         {BRCMS_SROM_LEDBH2, 0xffffff00, SRFL_NOFFS, SROM8_LEDBH32, 0x00ff},
 483         {BRCMS_SROM_LEDBH3, 0xffffff00, SRFL_NOFFS, SROM8_LEDBH32, 0xff00},
 484         {BRCMS_SROM_PA0B0, 0x0000000e, SRFL_PRHEX, SROM_WL0PAB0, 0xffff},
 485         {BRCMS_SROM_PA0B1, 0x0000000e, SRFL_PRHEX, SROM_WL0PAB1, 0xffff},
 486         {BRCMS_SROM_PA0B2, 0x0000000e, SRFL_PRHEX, SROM_WL0PAB2, 0xffff},
 487         {BRCMS_SROM_PA0ITSSIT, 0x0000000e, 0, SROM_ITT, 0x00ff},
 488         {BRCMS_SROM_PA0MAXPWR, 0x0000000e, 0, SROM_WL10MAXP, 0x00ff},
 489         {BRCMS_SROM_PA0B0, 0xffffff00, SRFL_PRHEX, SROM8_W0_PAB0, 0xffff},
 490         {BRCMS_SROM_PA0B1, 0xffffff00, SRFL_PRHEX, SROM8_W0_PAB1, 0xffff},
 491         {BRCMS_SROM_PA0B2, 0xffffff00, SRFL_PRHEX, SROM8_W0_PAB2, 0xffff},
 492         {BRCMS_SROM_PA0ITSSIT, 0xffffff00, 0, SROM8_W0_ITTMAXP, 0xff00},
 493         {BRCMS_SROM_PA0MAXPWR, 0xffffff00, 0, SROM8_W0_ITTMAXP, 0x00ff},
 494         {BRCMS_SROM_OPO, 0x0000000c, 0, SROM_OPO, 0x00ff},
 495         {BRCMS_SROM_OPO, 0xffffff00, 0, SROM8_2G_OFDMPO, 0x00ff},
 496         {BRCMS_SROM_AA2G, 0x0000000e, 0, SROM_AABREV, SROM_AA0_MASK},
 497         {BRCMS_SROM_AA2G, 0x000000f0, 0, SROM4_AA, 0x00ff},
 498         {BRCMS_SROM_AA2G, 0xffffff00, 0, SROM8_AA, 0x00ff},
 499         {BRCMS_SROM_AA5G, 0x0000000e, 0, SROM_AABREV, SROM_AA1_MASK},
 500         {BRCMS_SROM_AA5G, 0x000000f0, 0, SROM4_AA, 0xff00},
 501         {BRCMS_SROM_AA5G, 0xffffff00, 0, SROM8_AA, 0xff00},
 502         {BRCMS_SROM_AG0, 0x0000000e, 0, SROM_AG10, 0x00ff},
 503         {BRCMS_SROM_AG1, 0x0000000e, 0, SROM_AG10, 0xff00},
 504         {BRCMS_SROM_AG0, 0x000000f0, 0, SROM4_AG10, 0x00ff},
 505         {BRCMS_SROM_AG1, 0x000000f0, 0, SROM4_AG10, 0xff00},
 506         {BRCMS_SROM_AG2, 0x000000f0, 0, SROM4_AG32, 0x00ff},
 507         {BRCMS_SROM_AG3, 0x000000f0, 0, SROM4_AG32, 0xff00},
 508         {BRCMS_SROM_AG0, 0xffffff00, 0, SROM8_AG10, 0x00ff},
 509         {BRCMS_SROM_AG1, 0xffffff00, 0, SROM8_AG10, 0xff00},
 510         {BRCMS_SROM_AG2, 0xffffff00, 0, SROM8_AG32, 0x00ff},
 511         {BRCMS_SROM_AG3, 0xffffff00, 0, SROM8_AG32, 0xff00},
 512         {BRCMS_SROM_PA1B0, 0x0000000e, SRFL_PRHEX, SROM_WL1PAB0, 0xffff},
 513         {BRCMS_SROM_PA1B1, 0x0000000e, SRFL_PRHEX, SROM_WL1PAB1, 0xffff},
 514         {BRCMS_SROM_PA1B2, 0x0000000e, SRFL_PRHEX, SROM_WL1PAB2, 0xffff},
 515         {BRCMS_SROM_PA1LOB0, 0x0000000c, SRFL_PRHEX, SROM_WL1LPAB0, 0xffff},
 516         {BRCMS_SROM_PA1LOB1, 0x0000000c, SRFL_PRHEX, SROM_WL1LPAB1, 0xffff},
 517         {BRCMS_SROM_PA1LOB2, 0x0000000c, SRFL_PRHEX, SROM_WL1LPAB2, 0xffff},
 518         {BRCMS_SROM_PA1HIB0, 0x0000000c, SRFL_PRHEX, SROM_WL1HPAB0, 0xffff},
 519         {BRCMS_SROM_PA1HIB1, 0x0000000c, SRFL_PRHEX, SROM_WL1HPAB1, 0xffff},
 520         {BRCMS_SROM_PA1HIB2, 0x0000000c, SRFL_PRHEX, SROM_WL1HPAB2, 0xffff},
 521         {BRCMS_SROM_PA1ITSSIT, 0x0000000e, 0, SROM_ITT, 0xff00},
 522         {BRCMS_SROM_PA1MAXPWR, 0x0000000e, 0, SROM_WL10MAXP, 0xff00},
 523         {BRCMS_SROM_PA1LOMAXPWR, 0x0000000c, 0, SROM_WL1LHMAXP, 0xff00},
 524         {BRCMS_SROM_PA1HIMAXPWR, 0x0000000c, 0, SROM_WL1LHMAXP, 0x00ff},
 525         {BRCMS_SROM_PA1B0, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB0, 0xffff},
 526         {BRCMS_SROM_PA1B1, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB1, 0xffff},
 527         {BRCMS_SROM_PA1B2, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB2, 0xffff},
 528         {BRCMS_SROM_PA1LOB0, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB0_LC, 0xffff},
 529         {BRCMS_SROM_PA1LOB1, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB1_LC, 0xffff},
 530         {BRCMS_SROM_PA1LOB2, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB2_LC, 0xffff},
 531         {BRCMS_SROM_PA1HIB0, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB0_HC, 0xffff},
 532         {BRCMS_SROM_PA1HIB1, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB1_HC, 0xffff},
 533         {BRCMS_SROM_PA1HIB2, 0xffffff00, SRFL_PRHEX, SROM8_W1_PAB2_HC, 0xffff},
 534         {BRCMS_SROM_PA1ITSSIT, 0xffffff00, 0, SROM8_W1_ITTMAXP, 0xff00},
 535         {BRCMS_SROM_PA1MAXPWR, 0xffffff00, 0, SROM8_W1_ITTMAXP, 0x00ff},
 536         {BRCMS_SROM_PA1LOMAXPWR, 0xffffff00, 0, SROM8_W1_MAXP_LCHC, 0xff00},
 537         {BRCMS_SROM_PA1HIMAXPWR, 0xffffff00, 0, SROM8_W1_MAXP_LCHC, 0x00ff},
 538         {BRCMS_SROM_BXA2G, 0x00000008, 0, SROM_BXARSSI2G, 0x1800},
 539         {BRCMS_SROM_RSSISAV2G, 0x00000008, 0, SROM_BXARSSI2G, 0x0700},
 540         {BRCMS_SROM_RSSISMC2G, 0x00000008, 0, SROM_BXARSSI2G, 0x00f0},
 541         {BRCMS_SROM_RSSISMF2G, 0x00000008, 0, SROM_BXARSSI2G, 0x000f},
 542         {BRCMS_SROM_BXA2G, 0xffffff00, 0, SROM8_BXARSSI2G, 0x1800},
 543         {BRCMS_SROM_RSSISAV2G, 0xffffff00, 0, SROM8_BXARSSI2G, 0x0700},
 544         {BRCMS_SROM_RSSISMC2G, 0xffffff00, 0, SROM8_BXARSSI2G, 0x00f0},
 545         {BRCMS_SROM_RSSISMF2G, 0xffffff00, 0, SROM8_BXARSSI2G, 0x000f},
 546         {BRCMS_SROM_BXA5G, 0x00000008, 0, SROM_BXARSSI5G, 0x1800},
 547         {BRCMS_SROM_RSSISAV5G, 0x00000008, 0, SROM_BXARSSI5G, 0x0700},
 548         {BRCMS_SROM_RSSISMC5G, 0x00000008, 0, SROM_BXARSSI5G, 0x00f0},
 549         {BRCMS_SROM_RSSISMF5G, 0x00000008, 0, SROM_BXARSSI5G, 0x000f},
 550         {BRCMS_SROM_BXA5G, 0xffffff00, 0, SROM8_BXARSSI5G, 0x1800},
 551         {BRCMS_SROM_RSSISAV5G, 0xffffff00, 0, SROM8_BXARSSI5G, 0x0700},
 552         {BRCMS_SROM_RSSISMC5G, 0xffffff00, 0, SROM8_BXARSSI5G, 0x00f0},
 553         {BRCMS_SROM_RSSISMF5G, 0xffffff00, 0, SROM8_BXARSSI5G, 0x000f},
 554         {BRCMS_SROM_TRI2G, 0x00000008, 0, SROM_TRI52G, 0x00ff},
 555         {BRCMS_SROM_TRI5G, 0x00000008, 0, SROM_TRI52G, 0xff00},
 556         {BRCMS_SROM_TRI5GL, 0x00000008, 0, SROM_TRI5GHL, 0x00ff},
 557         {BRCMS_SROM_TRI5GH, 0x00000008, 0, SROM_TRI5GHL, 0xff00},
 558         {BRCMS_SROM_TRI2G, 0xffffff00, 0, SROM8_TRI52G, 0x00ff},
 559         {BRCMS_SROM_TRI5G, 0xffffff00, 0, SROM8_TRI52G, 0xff00},
 560         {BRCMS_SROM_TRI5GL, 0xffffff00, 0, SROM8_TRI5GHL, 0x00ff},
 561         {BRCMS_SROM_TRI5GH, 0xffffff00, 0, SROM8_TRI5GHL, 0xff00},
 562         {BRCMS_SROM_RXPO2G, 0x00000008, SRFL_PRSIGN, SROM_RXPO52G, 0x00ff},
 563         {BRCMS_SROM_RXPO5G, 0x00000008, SRFL_PRSIGN, SROM_RXPO52G, 0xff00},
 564         {BRCMS_SROM_RXPO2G, 0xffffff00, SRFL_PRSIGN, SROM8_RXPO52G, 0x00ff},
 565         {BRCMS_SROM_RXPO5G, 0xffffff00, SRFL_PRSIGN, SROM8_RXPO52G, 0xff00},
 566         {BRCMS_SROM_TXCHAIN, 0x000000f0, SRFL_NOFFS, SROM4_TXRXC,
 567          SROM4_TXCHAIN_MASK},
 568         {BRCMS_SROM_RXCHAIN, 0x000000f0, SRFL_NOFFS, SROM4_TXRXC,
 569          SROM4_RXCHAIN_MASK},
 570         {BRCMS_SROM_ANTSWITCH, 0x000000f0, SRFL_NOFFS, SROM4_TXRXC,
 571          SROM4_SWITCH_MASK},
 572         {BRCMS_SROM_TXCHAIN, 0xffffff00, SRFL_NOFFS, SROM8_TXRXC,
 573          SROM4_TXCHAIN_MASK},
 574         {BRCMS_SROM_RXCHAIN, 0xffffff00, SRFL_NOFFS, SROM8_TXRXC,
 575          SROM4_RXCHAIN_MASK},
 576         {BRCMS_SROM_ANTSWITCH, 0xffffff00, SRFL_NOFFS, SROM8_TXRXC,
 577          SROM4_SWITCH_MASK},
 578         {BRCMS_SROM_TSSIPOS2G, 0xffffff00, 0, SROM8_FEM2G,
 579          SROM8_FEM_TSSIPOS_MASK},
 580         {BRCMS_SROM_EXTPAGAIN2G, 0xffffff00, 0, SROM8_FEM2G,
 581          SROM8_FEM_EXTPA_GAIN_MASK},
 582         {BRCMS_SROM_PDETRANGE2G, 0xffffff00, 0, SROM8_FEM2G,
 583          SROM8_FEM_PDET_RANGE_MASK},
 584         {BRCMS_SROM_TRISO2G, 0xffffff00, 0, SROM8_FEM2G, SROM8_FEM_TR_ISO_MASK},
 585         {BRCMS_SROM_ANTSWCTL2G, 0xffffff00, 0, SROM8_FEM2G,
 586          SROM8_FEM_ANTSWLUT_MASK},
 587         {BRCMS_SROM_TSSIPOS5G, 0xffffff00, 0, SROM8_FEM5G,
 588          SROM8_FEM_TSSIPOS_MASK},
 589         {BRCMS_SROM_EXTPAGAIN5G, 0xffffff00, 0, SROM8_FEM5G,
 590          SROM8_FEM_EXTPA_GAIN_MASK},
 591         {BRCMS_SROM_PDETRANGE5G, 0xffffff00, 0, SROM8_FEM5G,
 592          SROM8_FEM_PDET_RANGE_MASK},
 593         {BRCMS_SROM_TRISO5G, 0xffffff00, 0, SROM8_FEM5G, SROM8_FEM_TR_ISO_MASK},
 594         {BRCMS_SROM_ANTSWCTL5G, 0xffffff00, 0, SROM8_FEM5G,
 595          SROM8_FEM_ANTSWLUT_MASK},
 596         {BRCMS_SROM_TEMPTHRESH, 0xffffff00, 0, SROM8_THERMAL, 0xff00},
 597         {BRCMS_SROM_TEMPOFFSET, 0xffffff00, 0, SROM8_THERMAL, 0x00ff},
 598         {BRCMS_SROM_TXPID2GA0, 0x000000f0, 0, SROM4_TXPID2G, 0x00ff},
 599         {BRCMS_SROM_TXPID2GA1, 0x000000f0, 0, SROM4_TXPID2G, 0xff00},
 600         {BRCMS_SROM_TXPID2GA2, 0x000000f0, 0, SROM4_TXPID2G + 1, 0x00ff},
 601         {BRCMS_SROM_TXPID2GA3, 0x000000f0, 0, SROM4_TXPID2G + 1, 0xff00},
 602         {BRCMS_SROM_TXPID5GA0, 0x000000f0, 0, SROM4_TXPID5G, 0x00ff},
 603         {BRCMS_SROM_TXPID5GA1, 0x000000f0, 0, SROM4_TXPID5G, 0xff00},
 604         {BRCMS_SROM_TXPID5GA2, 0x000000f0, 0, SROM4_TXPID5G + 1, 0x00ff},
 605         {BRCMS_SROM_TXPID5GA3, 0x000000f0, 0, SROM4_TXPID5G + 1, 0xff00},
 606         {BRCMS_SROM_TXPID5GLA0, 0x000000f0, 0, SROM4_TXPID5GL, 0x00ff},
 607         {BRCMS_SROM_TXPID5GLA1, 0x000000f0, 0, SROM4_TXPID5GL, 0xff00},
 608         {BRCMS_SROM_TXPID5GLA2, 0x000000f0, 0, SROM4_TXPID5GL + 1, 0x00ff},
 609         {BRCMS_SROM_TXPID5GLA3, 0x000000f0, 0, SROM4_TXPID5GL + 1, 0xff00},
 610         {BRCMS_SROM_TXPID5GHA0, 0x000000f0, 0, SROM4_TXPID5GH, 0x00ff},
 611         {BRCMS_SROM_TXPID5GHA1, 0x000000f0, 0, SROM4_TXPID5GH, 0xff00},
 612         {BRCMS_SROM_TXPID5GHA2, 0x000000f0, 0, SROM4_TXPID5GH + 1, 0x00ff},
 613         {BRCMS_SROM_TXPID5GHA3, 0x000000f0, 0, SROM4_TXPID5GH + 1, 0xff00},
 614
 615         {BRCMS_SROM_CCODE, 0x0000000f, SRFL_CCODE, SROM_CCODE, 0xffff},
 616         {BRCMS_SROM_CCODE, 0x00000010, SRFL_CCODE, SROM4_CCODE, 0xffff},
 617         {BRCMS_SROM_CCODE, 0x000000e0, SRFL_CCODE, SROM5_CCODE, 0xffff},
 618         {BRCMS_SROM_CCODE, 0xffffff00, SRFL_CCODE, SROM8_CCODE, 0xffff},
 619         {BRCMS_SROM_MACADDR, 0xffffff00, SRFL_ETHADDR, SROM8_MACHI, 0xffff},
 620         {BRCMS_SROM_MACADDR, 0x000000e0, SRFL_ETHADDR, SROM5_MACHI, 0xffff},
 621         {BRCMS_SROM_MACADDR, 0x00000010, SRFL_ETHADDR, SROM4_MACHI, 0xffff},
 622         {BRCMS_SROM_MACADDR, 0x00000008, SRFL_ETHADDR, SROM3_MACHI, 0xffff},
 623         {BRCMS_SROM_IL0MACADDR, 0x00000007, SRFL_ETHADDR, SROM_MACHI_IL0,
 624          0xffff},
 625         {BRCMS_SROM_ET1MACADDR, 0x00000007, SRFL_ETHADDR, SROM_MACHI_ET1,
 626          0xffff},
 627         {BRCMS_SROM_LEDDC, 0xffffff00, SRFL_NOFFS | SRFL_LEDDC, SROM8_LEDDC,
 628          0xffff},
 629         {BRCMS_SROM_LEDDC, 0x000000e0, SRFL_NOFFS | SRFL_LEDDC, SROM5_LEDDC,
 630          0xffff},
 631         {BRCMS_SROM_LEDDC, 0x00000010, SRFL_NOFFS | SRFL_LEDDC, SROM4_LEDDC,
 632          0xffff},
 633         {BRCMS_SROM_LEDDC, 0x00000008, SRFL_NOFFS | SRFL_LEDDC, SROM3_LEDDC,
 634          0xffff},
 635         {BRCMS_SROM_RAWTEMPSENSE, 0xffffff00, SRFL_PRHEX, SROM8_MPWR_RAWTS,
 636          0x01ff},
 637         {BRCMS_SROM_MEASPOWER, 0xffffff00, SRFL_PRHEX, SROM8_MPWR_RAWTS,
 638          0xfe00},
 639         {BRCMS_SROM_TEMPSENSE_SLOPE, 0xffffff00, SRFL_PRHEX,
 640          SROM8_TS_SLP_OPT_CORRX, 0x00ff},
 641         {BRCMS_SROM_TEMPCORRX, 0xffffff00, SRFL_PRHEX, SROM8_TS_SLP_OPT_CORRX,
 642          0xfc00},
 643         {BRCMS_SROM_TEMPSENSE_OPTION, 0xffffff00, SRFL_PRHEX,
 644          SROM8_TS_SLP_OPT_CORRX, 0x0300},
 645         {BRCMS_SROM_FREQOFFSET_CORR, 0xffffff00, SRFL_PRHEX,
 646          SROM8_FOC_HWIQ_IQSWP, 0x000f},
 647         {BRCMS_SROM_IQCAL_SWP_DIS, 0xffffff00, SRFL_PRHEX, SROM8_FOC_HWIQ_IQSWP,
 648          0x0010},
 649         {BRCMS_SROM_HW_IQCAL_EN, 0xffffff00, SRFL_PRHEX, SROM8_FOC_HWIQ_IQSWP,
 650          0x0020},
 651         {BRCMS_SROM_PHYCAL_TEMPDELTA, 0xffffff00, 0, SROM8_PHYCAL_TEMPDELTA,
 652          0x00ff},
 653
 654         {BRCMS_SROM_CCK2GPO, 0x000000f0, 0, SROM4_2G_CCKPO, 0xffff},
 655         {BRCMS_SROM_CCK2GPO, 0x00000100, 0, SROM8_2G_CCKPO, 0xffff},
 656         {BRCMS_SROM_OFDM2GPO, 0x000000f0, SRFL_MORE, SROM4_2G_OFDMPO, 0xffff},
 657         {BRCMS_SROM_CONT, 0, 0, SROM4_2G_OFDMPO + 1, 0xffff},
 658         {BRCMS_SROM_OFDM5GPO, 0x000000f0, SRFL_MORE, SROM4_5G_OFDMPO, 0xffff},
 659         {BRCMS_SROM_CONT, 0, 0, SROM4_5G_OFDMPO + 1, 0xffff},
 660         {BRCMS_SROM_OFDM5GLPO, 0x000000f0, SRFL_MORE, SROM4_5GL_OFDMPO, 0xffff},
 661         {BRCMS_SROM_CONT, 0, 0, SROM4_5GL_OFDMPO + 1, 0xffff},
 662         {BRCMS_SROM_OFDM5GHPO, 0x000000f0, SRFL_MORE, SROM4_5GH_OFDMPO, 0xffff},
 663         {BRCMS_SROM_CONT, 0, 0, SROM4_5GH_OFDMPO + 1, 0xffff},
 664         {BRCMS_SROM_OFDM2GPO, 0x00000100, SRFL_MORE, SROM8_2G_OFDMPO, 0xffff},
 665         {BRCMS_SROM_CONT, 0, 0, SROM8_2G_OFDMPO + 1, 0xffff},
 666         {BRCMS_SROM_OFDM5GPO, 0x00000100, SRFL_MORE, SROM8_5G_OFDMPO, 0xffff},
 667         {BRCMS_SROM_CONT, 0, 0, SROM8_5G_OFDMPO + 1, 0xffff},
 668         {BRCMS_SROM_OFDM5GLPO, 0x00000100, SRFL_MORE, SROM8_5GL_OFDMPO, 0xffff},
 669         {BRCMS_SROM_CONT, 0, 0, SROM8_5GL_OFDMPO + 1, 0xffff},
 670         {BRCMS_SROM_OFDM5GHPO, 0x00000100, SRFL_MORE, SROM8_5GH_OFDMPO, 0xffff},
 671         {BRCMS_SROM_CONT, 0, 0, SROM8_5GH_OFDMPO + 1, 0xffff},
 672         {BRCMS_SROM_MCS2GPO0, 0x000000f0, 0, SROM4_2G_MCSPO, 0xffff},
 673         {BRCMS_SROM_MCS2GPO1, 0x000000f0, 0, SROM4_2G_MCSPO + 1, 0xffff},
 674         {BRCMS_SROM_MCS2GPO2, 0x000000f0, 0, SROM4_2G_MCSPO + 2, 0xffff},
 675         {BRCMS_SROM_MCS2GPO3, 0x000000f0, 0, SROM4_2G_MCSPO + 3, 0xffff},
 676         {BRCMS_SROM_MCS2GPO4, 0x000000f0, 0, SROM4_2G_MCSPO + 4, 0xffff},
 677         {BRCMS_SROM_MCS2GPO5, 0x000000f0, 0, SROM4_2G_MCSPO + 5, 0xffff},
 678         {BRCMS_SROM_MCS2GPO6, 0x000000f0, 0, SROM4_2G_MCSPO + 6, 0xffff},
 679         {BRCMS_SROM_MCS2GPO7, 0x000000f0, 0, SROM4_2G_MCSPO + 7, 0xffff},
 680         {BRCMS_SROM_MCS5GPO0, 0x000000f0, 0, SROM4_5G_MCSPO, 0xffff},
 681         {BRCMS_SROM_MCS5GPO1, 0x000000f0, 0, SROM4_5G_MCSPO + 1, 0xffff},
 682         {BRCMS_SROM_MCS5GPO2, 0x000000f0, 0, SROM4_5G_MCSPO + 2, 0xffff},
 683         {BRCMS_SROM_MCS5GPO3, 0x000000f0, 0, SROM4_5G_MCSPO + 3, 0xffff},
 684         {BRCMS_SROM_MCS5GPO4, 0x000000f0, 0, SROM4_5G_MCSPO + 4, 0xffff},
 685         {BRCMS_SROM_MCS5GPO5, 0x000000f0, 0, SROM4_5G_MCSPO + 5, 0xffff},
 686         {BRCMS_SROM_MCS5GPO6, 0x000000f0, 0, SROM4_5G_MCSPO + 6, 0xffff},
 687         {BRCMS_SROM_MCS5GPO7, 0x000000f0, 0, SROM4_5G_MCSPO + 7, 0xffff},
 688         {BRCMS_SROM_MCS5GLPO0, 0x000000f0, 0, SROM4_5GL_MCSPO, 0xffff},
 689         {BRCMS_SROM_MCS5GLPO1, 0x000000f0, 0, SROM4_5GL_MCSPO + 1, 0xffff},
 690         {BRCMS_SROM_MCS5GLPO2, 0x000000f0, 0, SROM4_5GL_MCSPO + 2, 0xffff},
 691         {BRCMS_SROM_MCS5GLPO3, 0x000000f0, 0, SROM4_5GL_MCSPO + 3, 0xffff},
 692         {BRCMS_SROM_MCS5GLPO4, 0x000000f0, 0, SROM4_5GL_MCSPO + 4, 0xffff},
 693         {BRCMS_SROM_MCS5GLPO5, 0x000000f0, 0, SROM4_5GL_MCSPO + 5, 0xffff},
 694         {BRCMS_SROM_MCS5GLPO6, 0x000000f0, 0, SROM4_5GL_MCSPO + 6, 0xffff},
 695         {BRCMS_SROM_MCS5GLPO7, 0x000000f0, 0, SROM4_5GL_MCSPO + 7, 0xffff},
 696         {BRCMS_SROM_MCS5GHPO0, 0x000000f0, 0, SROM4_5GH_MCSPO, 0xffff},
 697         {BRCMS_SROM_MCS5GHPO1, 0x000000f0, 0, SROM4_5GH_MCSPO + 1, 0xffff},
 698         {BRCMS_SROM_MCS5GHPO2, 0x000000f0, 0, SROM4_5GH_MCSPO + 2, 0xffff},
 699         {BRCMS_SROM_MCS5GHPO3, 0x000000f0, 0, SROM4_5GH_MCSPO + 3, 0xffff},
 700         {BRCMS_SROM_MCS5GHPO4, 0x000000f0, 0, SROM4_5GH_MCSPO + 4, 0xffff},
 701         {BRCMS_SROM_MCS5GHPO5, 0x000000f0, 0, SROM4_5GH_MCSPO + 5, 0xffff},
 702         {BRCMS_SROM_MCS5GHPO6, 0x000000f0, 0, SROM4_5GH_MCSPO + 6, 0xffff},
 703         {BRCMS_SROM_MCS5GHPO7, 0x000000f0, 0, SROM4_5GH_MCSPO + 7, 0xffff},
 704         {BRCMS_SROM_MCS2GPO0, 0x00000100, 0, SROM8_2G_MCSPO, 0xffff},
 705         {BRCMS_SROM_MCS2GPO1, 0x00000100, 0, SROM8_2G_MCSPO + 1, 0xffff},
 706         {BRCMS_SROM_MCS2GPO2, 0x00000100, 0, SROM8_2G_MCSPO + 2, 0xffff},
 707         {BRCMS_SROM_MCS2GPO3, 0x00000100, 0, SROM8_2G_MCSPO + 3, 0xffff},
 708         {BRCMS_SROM_MCS2GPO4, 0x00000100, 0, SROM8_2G_MCSPO + 4, 0xffff},
 709         {BRCMS_SROM_MCS2GPO5, 0x00000100, 0, SROM8_2G_MCSPO + 5, 0xffff},
 710         {BRCMS_SROM_MCS2GPO6, 0x00000100, 0, SROM8_2G_MCSPO + 6, 0xffff},
 711         {BRCMS_SROM_MCS2GPO7, 0x00000100, 0, SROM8_2G_MCSPO + 7, 0xffff},
 712         {BRCMS_SROM_MCS5GPO0, 0x00000100, 0, SROM8_5G_MCSPO, 0xffff},
 713         {BRCMS_SROM_MCS5GPO1, 0x00000100, 0, SROM8_5G_MCSPO + 1, 0xffff},
 714         {BRCMS_SROM_MCS5GPO2, 0x00000100, 0, SROM8_5G_MCSPO + 2, 0xffff},
 715         {BRCMS_SROM_MCS5GPO3, 0x00000100, 0, SROM8_5G_MCSPO + 3, 0xffff},
 716         {BRCMS_SROM_MCS5GPO4, 0x00000100, 0, SROM8_5G_MCSPO + 4, 0xffff},
 717         {BRCMS_SROM_MCS5GPO5, 0x00000100, 0, SROM8_5G_MCSPO + 5, 0xffff},
 718         {BRCMS_SROM_MCS5GPO6, 0x00000100, 0, SROM8_5G_MCSPO + 6, 0xffff},
 719         {BRCMS_SROM_MCS5GPO7, 0x00000100, 0, SROM8_5G_MCSPO + 7, 0xffff},
 720         {BRCMS_SROM_MCS5GLPO0, 0x00000100, 0, SROM8_5GL_MCSPO, 0xffff},
 721         {BRCMS_SROM_MCS5GLPO1, 0x00000100, 0, SROM8_5GL_MCSPO + 1, 0xffff},
 722         {BRCMS_SROM_MCS5GLPO2, 0x00000100, 0, SROM8_5GL_MCSPO + 2, 0xffff},
 723         {BRCMS_SROM_MCS5GLPO3, 0x00000100, 0, SROM8_5GL_MCSPO + 3, 0xffff},
 724         {BRCMS_SROM_MCS5GLPO4, 0x00000100, 0, SROM8_5GL_MCSPO + 4, 0xffff},
 725         {BRCMS_SROM_MCS5GLPO5, 0x00000100, 0, SROM8_5GL_MCSPO + 5, 0xffff},
 726         {BRCMS_SROM_MCS5GLPO6, 0x00000100, 0, SROM8_5GL_MCSPO + 6, 0xffff},
 727         {BRCMS_SROM_MCS5GLPO7, 0x00000100, 0, SROM8_5GL_MCSPO + 7, 0xffff},
 728         {BRCMS_SROM_MCS5GHPO0, 0x00000100, 0, SROM8_5GH_MCSPO, 0xffff},
 729         {BRCMS_SROM_MCS5GHPO1, 0x00000100, 0, SROM8_5GH_MCSPO + 1, 0xffff},
 730         {BRCMS_SROM_MCS5GHPO2, 0x00000100, 0, SROM8_5GH_MCSPO + 2, 0xffff},
 731         {BRCMS_SROM_MCS5GHPO3, 0x00000100, 0, SROM8_5GH_MCSPO + 3, 0xffff},
 732         {BRCMS_SROM_MCS5GHPO4, 0x00000100, 0, SROM8_5GH_MCSPO + 4, 0xffff},
 733         {BRCMS_SROM_MCS5GHPO5, 0x00000100, 0, SROM8_5GH_MCSPO + 5, 0xffff},
 734         {BRCMS_SROM_MCS5GHPO6, 0x00000100, 0, SROM8_5GH_MCSPO + 6, 0xffff},
 735         {BRCMS_SROM_MCS5GHPO7, 0x00000100, 0, SROM8_5GH_MCSPO + 7, 0xffff},
 736         {BRCMS_SROM_CDDPO, 0x000000f0, 0, SROM4_CDDPO, 0xffff},
 737         {BRCMS_SROM_STBCPO, 0x000000f0, 0, SROM4_STBCPO, 0xffff},
 738         {BRCMS_SROM_BW40PO, 0x000000f0, 0, SROM4_BW40PO, 0xffff},
 739         {BRCMS_SROM_BWDUPPO, 0x000000f0, 0, SROM4_BWDUPPO, 0xffff},
 740         {BRCMS_SROM_CDDPO, 0x00000100, 0, SROM8_CDDPO, 0xffff},
 741         {BRCMS_SROM_STBCPO, 0x00000100, 0, SROM8_STBCPO, 0xffff},
 742         {BRCMS_SROM_BW40PO, 0x00000100, 0, SROM8_BW40PO, 0xffff},
 743         {BRCMS_SROM_BWDUPPO, 0x00000100, 0, SROM8_BWDUPPO, 0xffff},
 744
 745         /* power per rate from sromrev 9 */
 746         {BRCMS_SROM_CCKBW202GPO, 0xfffffe00, 0, SROM9_2GPO_CCKBW20, 0xffff},
 747         {BRCMS_SROM_CCKBW20UL2GPO, 0xfffffe00, 0, SROM9_2GPO_CCKBW20UL, 0xffff},
 748         {BRCMS_SROM_LEGOFDMBW202GPO, 0xfffffe00, SRFL_MORE,
 749          SROM9_2GPO_LOFDMBW20, 0xffff},
 750         {BRCMS_SROM_CONT, 0, 0, SROM9_2GPO_LOFDMBW20 + 1, 0xffff},
 751         {BRCMS_SROM_LEGOFDMBW20UL2GPO, 0xfffffe00, SRFL_MORE,
 752          SROM9_2GPO_LOFDMBW20UL, 0xffff},
 753         {BRCMS_SROM_CONT, 0, 0, SROM9_2GPO_LOFDMBW20UL + 1, 0xffff},
 754         {BRCMS_SROM_LEGOFDMBW205GLPO, 0xfffffe00, SRFL_MORE,
 755          SROM9_5GLPO_LOFDMBW20, 0xffff},
 756         {BRCMS_SROM_CONT, 0, 0, SROM9_5GLPO_LOFDMBW20 + 1, 0xffff},
 757         {BRCMS_SROM_LEGOFDMBW20UL5GLPO, 0xfffffe00, SRFL_MORE,
 758          SROM9_5GLPO_LOFDMBW20UL, 0xffff},
 759         {BRCMS_SROM_CONT, 0, 0, SROM9_5GLPO_LOFDMBW20UL + 1, 0xffff},
 760         {BRCMS_SROM_LEGOFDMBW205GMPO, 0xfffffe00, SRFL_MORE,
 761          SROM9_5GMPO_LOFDMBW20, 0xffff},
 762         {BRCMS_SROM_CONT, 0, 0, SROM9_5GMPO_LOFDMBW20 + 1, 0xffff},
 763         {BRCMS_SROM_LEGOFDMBW20UL5GMPO, 0xfffffe00, SRFL_MORE,
 764          SROM9_5GMPO_LOFDMBW20UL, 0xffff},
 765         {BRCMS_SROM_CONT, 0, 0, SROM9_5GMPO_LOFDMBW20UL + 1, 0xffff},
 766         {BRCMS_SROM_LEGOFDMBW205GHPO, 0xfffffe00, SRFL_MORE,
 767          SROM9_5GHPO_LOFDMBW20, 0xffff},
 768         {BRCMS_SROM_CONT, 0, 0, SROM9_5GHPO_LOFDMBW20 + 1, 0xffff},
 769         {BRCMS_SROM_LEGOFDMBW20UL5GHPO, 0xfffffe00, SRFL_MORE,
 770          SROM9_5GHPO_LOFDMBW20UL, 0xffff},
 771         {BRCMS_SROM_CONT, 0, 0, SROM9_5GHPO_LOFDMBW20UL + 1, 0xffff},
 772         {BRCMS_SROM_MCSBW202GPO, 0xfffffe00, SRFL_MORE, SROM9_2GPO_MCSBW20,
 773          0xffff},
 774         {BRCMS_SROM_CONT, 0, 0, SROM9_2GPO_MCSBW20 + 1, 0xffff},
 775         {BRCMS_SROM_MCSBW20UL2GPO, 0xfffffe00, SRFL_MORE, SROM9_2GPO_MCSBW20UL,
 776          0xffff},
 777         {BRCMS_SROM_CONT, 0, 0, SROM9_2GPO_MCSBW20UL + 1, 0xffff},
 778         {BRCMS_SROM_MCSBW402GPO, 0xfffffe00, SRFL_MORE, SROM9_2GPO_MCSBW40,
 779          0xffff},
 780         {BRCMS_SROM_CONT, 0, 0, SROM9_2GPO_MCSBW40 + 1, 0xffff},
 781         {BRCMS_SROM_MCSBW205GLPO, 0xfffffe00, SRFL_MORE, SROM9_5GLPO_MCSBW20,
 782          0xffff},
 783         {BRCMS_SROM_CONT, 0, 0, SROM9_5GLPO_MCSBW20 + 1, 0xffff},
 784         {BRCMS_SROM_MCSBW20UL5GLPO, 0xfffffe00, SRFL_MORE,
 785          SROM9_5GLPO_MCSBW20UL, 0xffff},
 786         {BRCMS_SROM_CONT, 0, 0, SROM9_5GLPO_MCSBW20UL + 1, 0xffff},
 787         {BRCMS_SROM_MCSBW405GLPO, 0xfffffe00, SRFL_MORE, SROM9_5GLPO_MCSBW40,
 788          0xffff},
 789         {BRCMS_SROM_CONT, 0, 0, SROM9_5GLPO_MCSBW40 + 1, 0xffff},
 790         {BRCMS_SROM_MCSBW205GMPO, 0xfffffe00, SRFL_MORE, SROM9_5GMPO_MCSBW20,
 791          0xffff},
 792         {BRCMS_SROM_CONT, 0, 0, SROM9_5GMPO_MCSBW20 + 1, 0xffff},
 793         {BRCMS_SROM_MCSBW20UL5GMPO, 0xfffffe00, SRFL_MORE,
 794          SROM9_5GMPO_MCSBW20UL, 0xffff},
 795         {BRCMS_SROM_CONT, 0, 0, SROM9_5GMPO_MCSBW20UL + 1, 0xffff},
 796         {BRCMS_SROM_MCSBW405GMPO, 0xfffffe00, SRFL_MORE, SROM9_5GMPO_MCSBW40,
 797          0xffff},
 798         {BRCMS_SROM_CONT, 0, 0, SROM9_5GMPO_MCSBW40 + 1, 0xffff},
 799         {BRCMS_SROM_MCSBW205GHPO, 0xfffffe00, SRFL_MORE, SROM9_5GHPO_MCSBW20,
 800          0xffff},
 801         {BRCMS_SROM_CONT, 0, 0, SROM9_5GHPO_MCSBW20 + 1, 0xffff},
 802         {BRCMS_SROM_MCSBW20UL5GHPO, 0xfffffe00, SRFL_MORE,
 803          SROM9_5GHPO_MCSBW20UL, 0xffff},
 804         {BRCMS_SROM_CONT, 0, 0, SROM9_5GHPO_MCSBW20UL + 1, 0xffff},
 805         {BRCMS_SROM_MCSBW405GHPO, 0xfffffe00, SRFL_MORE, SROM9_5GHPO_MCSBW40,
 806          0xffff},
 807         {BRCMS_SROM_CONT, 0, 0, SROM9_5GHPO_MCSBW40 + 1, 0xffff},
 808         {BRCMS_SROM_MCS32PO, 0xfffffe00, 0, SROM9_PO_MCS32, 0xffff},
 809         {BRCMS_SROM_LEGOFDM40DUPPO, 0xfffffe00, 0, SROM9_PO_LOFDM40DUP, 0xffff},
 810
 811         {BRCMS_SROM_NULL, 0, 0, 0, 0}
 812 };
 813
 814 static const struct brcms_sromvar perpath_pci_sromvars[] = {
 815         {BRCMS_SROM_MAXP2GA0, 0x000000f0, 0, SROM4_2G_ITT_MAXP, 0x00ff},
 816         {BRCMS_SROM_ITT2GA0, 0x000000f0, 0, SROM4_2G_ITT_MAXP, 0xff00},
 817         {BRCMS_SROM_ITT5GA0, 0x000000f0, 0, SROM4_5G_ITT_MAXP, 0xff00},
 818         {BRCMS_SROM_PA2GW0A0, 0x000000f0, SRFL_PRHEX, SROM4_2G_PA, 0xffff},
 819         {BRCMS_SROM_PA2GW1A0, 0x000000f0, SRFL_PRHEX, SROM4_2G_PA + 1, 0xffff},
 820         {BRCMS_SROM_PA2GW2A0, 0x000000f0, SRFL_PRHEX, SROM4_2G_PA + 2, 0xffff},
 821         {BRCMS_SROM_PA2GW3A0, 0x000000f0, SRFL_PRHEX, SROM4_2G_PA + 3, 0xffff},
 822         {BRCMS_SROM_MAXP5GA0, 0x000000f0, 0, SROM4_5G_ITT_MAXP, 0x00ff},
 823         {BRCMS_SROM_MAXP5GHA0, 0x000000f0, 0, SROM4_5GLH_MAXP, 0x00ff},
 824         {BRCMS_SROM_MAXP5GLA0, 0x000000f0, 0, SROM4_5GLH_MAXP, 0xff00},
 825         {BRCMS_SROM_PA5GW0A0, 0x000000f0, SRFL_PRHEX, SROM4_5G_PA, 0xffff},
 826         {BRCMS_SROM_PA5GW1A0, 0x000000f0, SRFL_PRHEX, SROM4_5G_PA + 1, 0xffff},
 827         {BRCMS_SROM_PA5GW2A0, 0x000000f0, SRFL_PRHEX, SROM4_5G_PA + 2, 0xffff},
 828         {BRCMS_SROM_PA5GW3A0, 0x000000f0, SRFL_PRHEX, SROM4_5G_PA + 3, 0xffff},
 829         {BRCMS_SROM_PA5GLW0A0, 0x000000f0, SRFL_PRHEX, SROM4_5GL_PA, 0xffff},
 830         {BRCMS_SROM_PA5GLW1A0, 0x000000f0, SRFL_PRHEX, SROM4_5GL_PA + 1,
 831          0xffff},
 832         {BRCMS_SROM_PA5GLW2A0, 0x000000f0, SRFL_PRHEX, SROM4_5GL_PA + 2,
 833          0xffff},
 834         {BRCMS_SROM_PA5GLW3A0, 0x000000f0, SRFL_PRHEX, SROM4_5GL_PA + 3,
 835          0xffff},
 836         {BRCMS_SROM_PA5GHW0A0, 0x000000f0, SRFL_PRHEX, SROM4_5GH_PA, 0xffff},
 837         {BRCMS_SROM_PA5GHW1A0, 0x000000f0, SRFL_PRHEX, SROM4_5GH_PA + 1,
 838          0xffff},
 839         {BRCMS_SROM_PA5GHW2A0, 0x000000f0, SRFL_PRHEX, SROM4_5GH_PA + 2,
 840          0xffff},
 841         {BRCMS_SROM_PA5GHW3A0, 0x000000f0, SRFL_PRHEX, SROM4_5GH_PA + 3,
 842          0xffff},
 843         {BRCMS_SROM_MAXP2GA0, 0xffffff00, 0, SROM8_2G_ITT_MAXP, 0x00ff},
 844         {BRCMS_SROM_ITT2GA0, 0xffffff00, 0, SROM8_2G_ITT_MAXP, 0xff00},
 845         {BRCMS_SROM_ITT5GA0, 0xffffff00, 0, SROM8_5G_ITT_MAXP, 0xff00},
 846         {BRCMS_SROM_PA2GW0A0, 0xffffff00, SRFL_PRHEX, SROM8_2G_PA, 0xffff},
 847         {BRCMS_SROM_PA2GW1A0, 0xffffff00, SRFL_PRHEX, SROM8_2G_PA + 1, 0xffff},
 848         {BRCMS_SROM_PA2GW2A0, 0xffffff00, SRFL_PRHEX, SROM8_2G_PA + 2, 0xffff},
 849         {BRCMS_SROM_MAXP5GA0, 0xffffff00, 0, SROM8_5G_ITT_MAXP, 0x00ff},
 850         {BRCMS_SROM_MAXP5GHA0, 0xffffff00, 0, SROM8_5GLH_MAXP, 0x00ff},
 851         {BRCMS_SROM_MAXP5GLA0, 0xffffff00, 0, SROM8_5GLH_MAXP, 0xff00},
 852         {BRCMS_SROM_PA5GW0A0, 0xffffff00, SRFL_PRHEX, SROM8_5G_PA, 0xffff},
 853         {BRCMS_SROM_PA5GW1A0, 0xffffff00, SRFL_PRHEX, SROM8_5G_PA + 1, 0xffff},
 854         {BRCMS_SROM_PA5GW2A0, 0xffffff00, SRFL_PRHEX, SROM8_5G_PA + 2, 0xffff},
 855         {BRCMS_SROM_PA5GLW0A0, 0xffffff00, SRFL_PRHEX, SROM8_5GL_PA, 0xffff},
 856         {BRCMS_SROM_PA5GLW1A0, 0xffffff00, SRFL_PRHEX, SROM8_5GL_PA + 1,
 857          0xffff},
 858         {BRCMS_SROM_PA5GLW2A0, 0xffffff00, SRFL_PRHEX, SROM8_5GL_PA + 2,
 859          0xffff},
 860         {BRCMS_SROM_PA5GHW0A0, 0xffffff00, SRFL_PRHEX, SROM8_5GH_PA, 0xffff},
 861         {BRCMS_SROM_PA5GHW1A0, 0xffffff00, SRFL_PRHEX, SROM8_5GH_PA + 1,
 862          0xffff},
 863         {BRCMS_SROM_PA5GHW2A0, 0xffffff00, SRFL_PRHEX, SROM8_5GH_PA + 2,
 864          0xffff},
 865         {BRCMS_SROM_NULL, 0, 0, 0, 0}
 866 };
 867
 868 /* crc table has the same contents for every device instance, so it can be
 869  * shared between devices. */
 870 static u8 brcms_srom_crc8_table[CRC8_TABLE_SIZE];
 871
 872 static u16 __iomem *
 873 srom_window_address(struct si_pub *sih, u8 __iomem *curmap)
 874 {
 875         if (sih->ccrev < 32)
 876                 return (u16 __iomem *)(curmap + PCI_BAR0_SPROM_OFFSET);
 877         if (sih->cccaps & CC_CAP_SROM)
 878                 return (u16 __iomem *)
 879                        (curmap + PCI_16KB0_CCREGS_OFFSET + CC_SROM_OTP);
 880
 881         return NULL;
 882 }
 883
 884 /* Parse SROM and create name=value pairs. 'srom' points to
 885  * the SROM word array. 'off' specifies the offset of the
 886  * first word 'srom' points to, which should be either 0 or
 887  * SROM3_SWRG_OFF (full SROM or software region).
 888  */
 889
 890 static uint mask_shift(u16 mask)
 891 {
 892         uint i;
 893         for (i = 0; i < (sizeof(mask) << 3); i++) {
 894                 if (mask & (1 << i))
 895                         return i;
 896         }
 897         return 0;
 898 }
 899
 900 static uint mask_width(u16 mask)
 901 {
 902         int i;
 903         for (i = (sizeof(mask) << 3) - 1; i >= 0; i--) {
 904                 if (mask & (1 << i))
 905                         return (uint) (i - mask_shift(mask) + 1);
 906         }
 907         return 0;
 908 }
 909
 910 static inline void ltoh16_buf(u16 *buf, unsigned int size)
 911 {
 912         size /= 2;
 913         while (size--)
 914                 *(buf + size) = le16_to_cpu(*(__le16 *)(buf + size));
 915 }
 916
 917 static inline void htol16_buf(u16 *buf, unsigned int size)
 918 {
 919         size /= 2;
 920         while (size--)
 921                 *(__le16 *)(buf + size) = cpu_to_le16(*(buf + size));
 922 }
 923
 924 /*
 925  * convert binary srom data into linked list of srom variable items.
 926  */
 927 static void
 928 _initvars_srom_pci(u8 sromrev, u16 *srom, struct list_head *var_list)
 929 {
 930         struct brcms_srom_list_head *entry;
 931         enum brcms_srom_id id;
 932         u16 w;
 933         u32 val;
 934         const struct brcms_sromvar *srv;
 935         uint width;
 936         uint flags;
 937         u32 sr = (1 << sromrev);
 938
 939         /* first store the srom revision */
 940         entry = kzalloc(sizeof(struct brcms_srom_list_head), GFP_KERNEL);
 941         entry->varid = BRCMS_SROM_REV;
 942         entry->var_type = BRCMS_SROM_UNUMBER;
 943         entry->uval = sromrev;
 944         list_add(&entry->var_list, var_list);
 945
 946         for (srv = pci_sromvars; srv->varid != BRCMS_SROM_NULL; srv++) {
 947                 enum brcms_srom_var_type type;
 948                 u8 ea[ETH_ALEN];
 949                 u8 extra_space = 0;
 950
 951                 if ((srv->revmask & sr) == 0)
 952                         continue;
 953
 954                 flags = srv->flags;
 955                 id = srv->varid;
 956
 957                 /* This entry is for mfgc only. Don't generate param for it, */
 958                 if (flags & SRFL_NOVAR)
 959                         continue;
 960
 961                 if (flags & SRFL_ETHADDR) {
 962                         /*
 963                          * stored in string format XX:XX:XX:XX:XX:XX (17 chars)
 964                          */
 965                         ea[0] = (srom[srv->off] >> 8) & 0xff;
 966                         ea[1] = srom[srv->off] & 0xff;
 967                         ea[2] = (srom[srv->off + 1] >> 8) & 0xff;
 968                         ea[3] = srom[srv->off + 1] & 0xff;
 969                         ea[4] = (srom[srv->off + 2] >> 8) & 0xff;
 970                         ea[5] = srom[srv->off + 2] & 0xff;
 971                         /* 17 characters + string terminator - union size */
 972                         extra_space = 18 - sizeof(s32);
 973                         type = BRCMS_SROM_STRING;
 974                 } else {
 975                         w = srom[srv->off];
 976                         val = (w & srv->mask) >> mask_shift(srv->mask);
 977                         width = mask_width(srv->mask);
 978
 979                         while (srv->flags & SRFL_MORE) {
 980                                 srv++;
 981                                 if (srv->off == 0)
 982                                         continue;
 983
 984                                 w = srom[srv->off];
 985                                 val +=
 986                                     ((w & srv->mask) >> mask_shift(srv->
 987                                                                    mask)) <<
 988                                     width;
 989                                 width += mask_width(srv->mask);
 990                         }
 991
 992                         if ((flags & SRFL_NOFFS)
 993                             && ((int)val == (1 << width) - 1))
 994                                 continue;
 995
 996                         if (flags & SRFL_CCODE) {
 997                                 type = BRCMS_SROM_STRING;
 998                         } else if (flags & SRFL_LEDDC) {
 999                                 /* LED Powersave duty cycle has to be scaled:
1000                                  *(oncount >> 24) (offcount >> 8)
1001                                  */
1002                                 u32 w32 = /* oncount */
1003                                           (((val >> 8) & 0xff) << 24) |
1004                                           /* offcount */
1005                                           (((val & 0xff)) << 8);
1006                                 type = BRCMS_SROM_UNUMBER;
1007                                 val = w32;
1008                         } else if ((flags & SRFL_PRSIGN)
1009                                  && (val & (1 << (width - 1)))) {
1010                                 type = BRCMS_SROM_SNUMBER;
1011                                 val |= ~0 << width;
1012                         } else
1013                                 type = BRCMS_SROM_UNUMBER;
1014                 }
1015
1016                 entry = kzalloc(sizeof(struct brcms_srom_list_head) +
1017                                 extra_space, GFP_KERNEL);
1018                 entry->varid = id;
1019                 entry->var_type = type;
1020                 if (flags & SRFL_ETHADDR) {
1021                         snprintf(entry->buf, 18, "%pM", ea);
1022                 } else if (flags & SRFL_CCODE) {
1023                         if (val == 0)
1024                                 entry->buf[0] = '\0';
1025                         else
1026                                 snprintf(entry->buf, 3, "%c%c",
1027                                          (val >> 8), (val & 0xff));
1028                 } else {
1029                         entry->uval = val;
1030                 }
1031
1032                 list_add(&entry->var_list, var_list);
1033         }
1034
1035         if (sromrev >= 4) {
1036                 /* Do per-path variables */
1037                 uint p, pb, psz;
1038
1039                 if (sromrev >= 8) {
1040                         pb = SROM8_PATH0;
1041                         psz = SROM8_PATH1 - SROM8_PATH0;
1042                 } else {
1043                         pb = SROM4_PATH0;
1044                         psz = SROM4_PATH1 - SROM4_PATH0;
1045                 }
1046
1047                 for (p = 0; p < MAX_PATH_SROM; p++) {
1048                         for (srv = perpath_pci_sromvars;
1049                              srv->varid != BRCMS_SROM_NULL; srv++) {
1050                                 if ((srv->revmask & sr) == 0)
1051                                         continue;
1052
1053                                 if (srv->flags & SRFL_NOVAR)
1054                                         continue;
1055
1056                                 w = srom[pb + srv->off];
1057                                 val = (w & srv->mask) >> mask_shift(srv->mask);
1058                                 width = mask_width(srv->mask);
1059
1060                                 /* Cheating: no per-path var is more than
1061                                  * 1 word */
1062                                 if ((srv->flags & SRFL_NOFFS)
1063                                     && ((int)val == (1 << width) - 1))
1064                                         continue;
1065
1066                                 entry =
1067                                     kzalloc(sizeof(struct brcms_srom_list_head),
1068                                             GFP_KERNEL);
1069                                 entry->varid = srv->varid+p;
1070                                 entry->var_type = BRCMS_SROM_UNUMBER;
1071                                 entry->uval = val;
1072                                 list_add(&entry->var_list, var_list);
1073                         }
1074                         pb += psz;
1075                 }
1076         }
1077 }
1078
1079 /*
1080  * Read in and validate sprom.
1081  * Return 0 on success, nonzero on error.
1082  */
1083 static int
1084 sprom_read_pci(struct si_pub *sih, u16 __iomem *sprom, uint wordoff,
1085                u16 *buf, uint nwords, bool check_crc)
1086 {
1087         int err = 0;
1088         uint i;
1089
1090         /* read the sprom */
1091         for (i = 0; i < nwords; i++)
1092                 buf[i] = R_REG(&sprom[wordoff + i]);
1093
1094         if (check_crc) {
1095
1096                 if (buf[0] == 0xffff)
1097                         /*
1098                          * The hardware thinks that an srom that starts with
1099                          * 0xffff is blank, regardless of the rest of the
1100                          * content, so declare it bad.
1101                          */
1102                         return -ENODATA;
1103
1104                 /* fixup the endianness so crc8 will pass */
1105                 htol16_buf(buf, nwords * 2);
1106                 if (crc8(brcms_srom_crc8_table, (u8 *) buf, nwords * 2,
1107                          CRC8_INIT_VALUE) !=
1108                          CRC8_GOOD_VALUE(brcms_srom_crc8_table))
1109                         /* DBG only pci always read srom4 first, then srom8/9 */
1110                         err = -EIO;
1111
1112                 /* now correct the endianness of the byte array */
1113                 ltoh16_buf(buf, nwords * 2);
1114         }
1115         return err;
1116 }
1117
1118 static int otp_read_pci(struct si_pub *sih, u16 *buf, uint bufsz)
1119 {
1120         u8 *otp;
1121         uint sz = OTP_SZ_MAX / 2;       /* size in words */
1122         int err = 0;
1123
1124         otp = kzalloc(OTP_SZ_MAX, GFP_ATOMIC);
1125         if (otp == NULL)
1126                 return -ENOMEM;
1127
1128         err = otp_read_region(sih, OTP_HW_RGN, (u16 *) otp, &sz);
1129
1130         memcpy(buf, otp, bufsz);
1131
1132         kfree(otp);
1133
1134         /* Check CRC */
1135         if (buf[0] == 0xffff)
1136                 /* The hardware thinks that an srom that starts with 0xffff
1137                  * is blank, regardless of the rest of the content, so declare
1138                  * it bad.
1139                  */
1140                 return -ENODATA;
1141
1142         /* fixup the endianness so crc8 will pass */
1143         htol16_buf(buf, bufsz);
1144         if (crc8(brcms_srom_crc8_table, (u8 *) buf, SROM4_WORDS * 2,
1145                  CRC8_INIT_VALUE) != CRC8_GOOD_VALUE(brcms_srom_crc8_table))
1146                 err = -EIO;
1147
1148         /* now correct the endianness of the byte array */
1149         ltoh16_buf(buf, bufsz);
1150
1151         return err;
1152 }
1153
1154 /*
1155  * Initialize nonvolatile variable table from sprom.
1156  * Return 0 on success, nonzero on error.
1157  */
1158 static int initvars_srom_pci(struct si_pub *sih, void __iomem *curmap)
1159 {
1160         u16 *srom;
1161         u16 __iomem *sromwindow;
1162         u8 sromrev = 0;
1163         u32 sr;
1164         int err = 0;
1165
1166         /*
1167          * Apply CRC over SROM content regardless SROM is present or not.
1168          */
1169         srom = kmalloc(SROM_MAX, GFP_ATOMIC);
1170         if (!srom)
1171                 return -ENOMEM;
1172
1173         sromwindow = srom_window_address(sih, curmap);
1174
1175         crc8_populate_lsb(brcms_srom_crc8_table, SROM_CRC8_POLY);
1176         if (ai_is_sprom_available(sih)) {
1177                 err = sprom_read_pci(sih, sromwindow, 0, srom, SROM_WORDS,
1178                                      true);
1179
1180                 if ((srom[SROM4_SIGN] == SROM4_SIGNATURE) ||
1181                     (((sih->buscoretype == PCIE_CORE_ID)
1182                       && (sih->buscorerev >= 6))
1183                      || ((sih->buscoretype == PCI_CORE_ID)
1184                          && (sih->buscorerev >= 0xe)))) {
1185                         /* sromrev >= 4, read more */
1186                         err = sprom_read_pci(sih, sromwindow, 0, srom,
1187                                              SROM4_WORDS, true);
1188                         sromrev = srom[SROM4_CRCREV] & 0xff;
1189                 } else if (err == 0) {
1190                         /* srom is good and is rev < 4 */
1191                         /* top word of sprom contains version and crc8 */
1192                         sromrev = srom[SROM_CRCREV] & 0xff;
1193                         /* bcm4401 sroms misprogrammed */
1194                         if (sromrev == 0x10)
1195                                 sromrev = 1;
1196                 }
1197         } else {
1198                 /* Use OTP if SPROM not available */
1199                 err = otp_read_pci(sih, srom, SROM_MAX);
1200                 if (err == 0)
1201                         /* OTP only contain SROM rev8/rev9 for now */
1202                         sromrev = srom[SROM4_CRCREV] & 0xff;
1203         }
1204
1205         if (!err) {
1206                 struct si_info *sii = (struct si_info *)sih;
1207
1208                 /* Bitmask for the sromrev */
1209                 sr = 1 << sromrev;
1210
1211                 /*
1212                  * srom version check: Current valid versions: 1, 2, 3, 4, 5, 8,
1213                  * 9
1214                  */
1215                 if ((sr & 0x33e) == 0) {
1216                         err = -EINVAL;
1217                         goto errout;
1218                 }
1219
1220                 INIT_LIST_HEAD(&sii->var_list);
1221
1222                 /* parse SROM into name=value pairs. */
1223                 _initvars_srom_pci(sromrev, srom, &sii->var_list);
1224         }
1225
1226 errout:
1227         kfree(srom);
1228         return err;
1229 }
1230
1231 void srom_free_vars(struct si_pub *sih)
1232 {
1233         struct si_info *sii;
1234         struct brcms_srom_list_head *entry, *next;
1235
1236         sii = (struct si_info *)sih;
1237         list_for_each_entry_safe(entry, next, &sii->var_list, var_list) {
1238                 list_del(&entry->var_list);
1239                 kfree(entry);
1240         }
1241 }
1242 /*
1243  * Initialize local vars from the right source for this platform.
1244  * Return 0 on success, nonzero on error.
1245  */
1246 int srom_var_init(struct si_pub *sih, void __iomem *curmap)
1247 {
1248         uint len;
1249
1250         len = 0;
1251
1252         if (curmap != NULL)
1253                 return initvars_srom_pci(sih, curmap);
1254
1255         return -EINVAL;
1256 }
1257
1258 /*
1259  * Search the name=value vars for a specific one and return its value.
1260  * Returns NULL if not found.
1261  */
1262 char *getvar(struct si_pub *sih, enum brcms_srom_id id)
1263 {
1264         struct si_info *sii;
1265         struct brcms_srom_list_head *entry;
1266
1267         sii = (struct si_info *)sih;
1268
1269         list_for_each_entry(entry, &sii->var_list, var_list)
1270                 if (entry->varid == id)
1271                         return &entry->buf[0];
1272
1273         /* nothing found */
1274         return NULL;
1275 }
1276
1277 /*
1278  * Search the vars for a specific one and return its value as
1279  * an integer. Returns 0 if not found.-
1280  */
1281 int getintvar(struct si_pub *sih, enum brcms_srom_id id)
1282 {
1283         struct si_info *sii;
1284         struct brcms_srom_list_head *entry;
1285         unsigned long res;
1286
1287         sii = (struct si_info *)sih;
1288
1289         list_for_each_entry(entry, &sii->var_list, var_list)
1290                 if (entry->varid == id) {
1291                         if (entry->var_type == BRCMS_SROM_SNUMBER ||
1292                             entry->var_type == BRCMS_SROM_UNUMBER)
1293                                 return (int)entry->sval;
1294                         else if (!kstrtoul(&entry->buf[0], 0, &res))
1295                                 return (int)res;
1296                 }
1297
1298         return 0;
1299 }