drivers/bcma/sprom.c

   1 /*
   2  * Broadcom specific AMBA
   3  * SPROM reading
   4  *
   5  * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de>
   6  *
   7  * Licensed under the GNU/GPL. See COPYING for details.
   8  */
   9
  10 #include "bcma_private.h"
  11
  12 #include <linux/bcma/bcma.h>
  13 #include <linux/bcma/bcma_regs.h>
  14 #include <linux/pci.h>
  15 #include <linux/io.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/slab.h>
  18
  19 static int(*get_fallback_sprom)(struct bcma_bus *dev, struct ssb_sprom *out);
  20
  21 /**
  22  * bcma_arch_register_fallback_sprom - Registers a method providing a
  23  * fallback SPROM if no SPROM is found.
  24  *
  25  * @sprom_callback: The callback function.
  26  *
  27  * With this function the architecture implementation may register a
  28  * callback handler which fills the SPROM data structure. The fallback is
  29  * used for PCI based BCMA devices, where no valid SPROM can be found
  30  * in the shadow registers and to provide the SPROM for SoCs where BCMA is
  31  * to controll the system bus.
  32  *
  33  * This function is useful for weird architectures that have a half-assed
  34  * BCMA device hardwired to their PCI bus.
  35  *
  36  * This function is available for architecture code, only. So it is not
  37  * exported.
  38  */
  39 int bcma_arch_register_fallback_sprom(int (*sprom_callback)(struct bcma_bus *bus,
  40                                      struct ssb_sprom *out))
  41 {
  42         if (get_fallback_sprom)
  43                 return -EEXIST;
  44         get_fallback_sprom = sprom_callback;
  45
  46         return 0;
  47 }
  48
  49 static int bcma_fill_sprom_with_fallback(struct bcma_bus *bus,
  50                                          struct ssb_sprom *out)
  51 {
  52         int err;
  53
  54         if (!get_fallback_sprom) {
  55                 err = -ENOENT;
  56                 goto fail;
  57         }
  58
  59         err = get_fallback_sprom(bus, out);
  60         if (err)
  61                 goto fail;
  62
  63         bcma_debug(bus, "Using SPROM revision %d provided by platform.\n",
  64                    bus->sprom.revision);
  65         return 0;
  66 fail:
  67         bcma_warn(bus, "Using fallback SPROM failed (err %d)\n", err);
  68         return err;
  69 }
  70
  71 /**************************************************
  72  * R/W ops.
  73  **************************************************/
  74
  75 static void bcma_sprom_read(struct bcma_bus *bus, u16 offset, u16 *sprom,
  76                             size_t words)
  77 {
  78         int i;
  79         for (i = 0; i < words; i++)
  80                 sprom[i] = bcma_read16(bus->drv_cc.core, offset + (i * 2));
  81 }
  82
  83 /**************************************************
  84  * Validation.
  85  **************************************************/
  86
  87 static inline u8 bcma_crc8(u8 crc, u8 data)
  88 {
  89         /* Polynomial:   x^8 + x^7 + x^6 + x^4 + x^2 + 1   */
  90         static const u8 t[] = {
  91                 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
  92                 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
  93                 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
  94                 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
  95                 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
  96                 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
  97                 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
  98                 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
  99                 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
 100                 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
 101                 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
 102                 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
 103                 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
 104                 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
 105                 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
 106                 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
 107                 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
 108                 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
 109                 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
 110                 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
 111                 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
 112                 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
 113                 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
 114                 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
 115                 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
 116                 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
 117                 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
 118                 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
 119                 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
 120                 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
 121                 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
 122                 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
 123         };
 124         return t[crc ^ data];
 125 }
 126
 127 static u8 bcma_sprom_crc(const u16 *sprom, size_t words)
 128 {
 129         int word;
 130         u8 crc = 0xFF;
 131
 132         for (word = 0; word < words - 1; word++) {
 133                 crc = bcma_crc8(crc, sprom[word] & 0x00FF);
 134                 crc = bcma_crc8(crc, (sprom[word] & 0xFF00) >> 8);
 135         }
 136         crc = bcma_crc8(crc, sprom[words - 1] & 0x00FF);
 137         crc ^= 0xFF;
 138
 139         return crc;
 140 }
 141
 142 static int bcma_sprom_check_crc(const u16 *sprom, size_t words)
 143 {
 144         u8 crc;
 145         u8 expected_crc;
 146         u16 tmp;
 147
 148         crc = bcma_sprom_crc(sprom, words);
 149         tmp = sprom[words - 1] & SSB_SPROM_REVISION_CRC;
 150         expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
 151         if (crc != expected_crc)
 152                 return -EPROTO;
 153
 154         return 0;
 155 }
 156
 157 static int bcma_sprom_valid(struct bcma_bus *bus, const u16 *sprom,
 158                             size_t words)
 159 {
 160         u16 revision;
 161         int err;
 162
 163         err = bcma_sprom_check_crc(sprom, words);
 164         if (err)
 165                 return err;
 166
 167         revision = sprom[words - 1] & SSB_SPROM_REVISION_REV;
 168         if (revision != 8 && revision != 9 && revision != 10) {
 169                 pr_err("Unsupported SPROM revision: %d\n", revision);
 170                 return -ENOENT;
 171         }
 172
 173         bus->sprom.revision = revision;
 174         bcma_debug(bus, "Found SPROM revision %d\n", revision);
 175
 176         return 0;
 177 }
 178
 179 /**************************************************
 180  * SPROM extraction.
 181  **************************************************/
 182
 183 #define SPOFF(offset)   ((offset) / sizeof(u16))
 184
 185 #define SPEX(_field, _offset, _mask, _shift)    \
 186         bus->sprom._field = ((sprom[SPOFF(_offset)] & (_mask)) >> (_shift))
 187
 188 #define SPEX32(_field, _offset, _mask, _shift)  \
 189         bus->sprom._field = ((((u32)sprom[SPOFF((_offset)+2)] << 16 | \
 190                                 sprom[SPOFF(_offset)]) & (_mask)) >> (_shift))
 191
 192 #define SPEX_ARRAY8(_field, _offset, _mask, _shift)     \
 193         do {    \
 194                 SPEX(_field[0], _offset +  0, _mask, _shift);   \
 195                 SPEX(_field[1], _offset +  2, _mask, _shift);   \
 196                 SPEX(_field[2], _offset +  4, _mask, _shift);   \
 197                 SPEX(_field[3], _offset +  6, _mask, _shift);   \
 198                 SPEX(_field[4], _offset +  8, _mask, _shift);   \
 199                 SPEX(_field[5], _offset + 10, _mask, _shift);   \
 200                 SPEX(_field[6], _offset + 12, _mask, _shift);   \
 201                 SPEX(_field[7], _offset + 14, _mask, _shift);   \
 202         } while (0)
 203
 204 static s8 sprom_extract_antgain(const u16 *in, u16 offset, u16 mask, u16 shift)
 205 {
 206         u16 v;
 207         u8 gain;
 208
 209         v = in[SPOFF(offset)];
 210         gain = (v & mask) >> shift;
 211         if (gain == 0xFF) {
 212                 gain = 8; /* If unset use 2dBm */
 213         } else {
 214                 /* Q5.2 Fractional part is stored in 0xC0 */
 215                 gain = ((gain & 0xC0) >> 6) | ((gain & 0x3F) << 2);
 216         }
 217
 218         return (s8)gain;
 219 }
 220
 221 static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
 222 {
 223         u16 v, o;
 224         int i;
 225         u16 pwr_info_offset[] = {
 226                 SSB_SROM8_PWR_INFO_CORE0, SSB_SROM8_PWR_INFO_CORE1,
 227                 SSB_SROM8_PWR_INFO_CORE2, SSB_SROM8_PWR_INFO_CORE3
 228         };
 229         BUILD_BUG_ON(ARRAY_SIZE(pwr_info_offset) !=
 230                         ARRAY_SIZE(bus->sprom.core_pwr_info));
 231
 232         for (i = 0; i < 3; i++) {
 233                 v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i];
 234                 *(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v);
 235         }
 236
 237         SPEX(board_rev, SSB_SPROM8_BOARDREV, ~0, 0);
 238         SPEX(board_type, SSB_SPROM1_SPID, ~0, 0);
 239
 240         SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01, SSB_SPROM4_TXPID2G0,
 241              SSB_SPROM4_TXPID2G0_SHIFT);
 242         SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01, SSB_SPROM4_TXPID2G1,
 243              SSB_SPROM4_TXPID2G1_SHIFT);
 244         SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23, SSB_SPROM4_TXPID2G2,
 245              SSB_SPROM4_TXPID2G2_SHIFT);
 246         SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23, SSB_SPROM4_TXPID2G3,
 247              SSB_SPROM4_TXPID2G3_SHIFT);
 248
 249         SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01, SSB_SPROM4_TXPID5GL0,
 250              SSB_SPROM4_TXPID5GL0_SHIFT);
 251         SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01, SSB_SPROM4_TXPID5GL1,
 252              SSB_SPROM4_TXPID5GL1_SHIFT);
 253         SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23, SSB_SPROM4_TXPID5GL2,
 254              SSB_SPROM4_TXPID5GL2_SHIFT);
 255         SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23, SSB_SPROM4_TXPID5GL3,
 256              SSB_SPROM4_TXPID5GL3_SHIFT);
 257
 258         SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01, SSB_SPROM4_TXPID5G0,
 259              SSB_SPROM4_TXPID5G0_SHIFT);
 260         SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01, SSB_SPROM4_TXPID5G1,
 261              SSB_SPROM4_TXPID5G1_SHIFT);
 262         SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23, SSB_SPROM4_TXPID5G2,
 263              SSB_SPROM4_TXPID5G2_SHIFT);
 264         SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23, SSB_SPROM4_TXPID5G3,
 265              SSB_SPROM4_TXPID5G3_SHIFT);
 266
 267         SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01, SSB_SPROM4_TXPID5GH0,
 268              SSB_SPROM4_TXPID5GH0_SHIFT);
 269         SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01, SSB_SPROM4_TXPID5GH1,
 270              SSB_SPROM4_TXPID5GH1_SHIFT);
 271         SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23, SSB_SPROM4_TXPID5GH2,
 272              SSB_SPROM4_TXPID5GH2_SHIFT);
 273         SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23, SSB_SPROM4_TXPID5GH3,
 274              SSB_SPROM4_TXPID5GH3_SHIFT);
 275
 276         SPEX(boardflags_lo, SSB_SPROM8_BFLLO, ~0, 0);
 277         SPEX(boardflags_hi, SSB_SPROM8_BFLHI, ~0, 0);
 278         SPEX(boardflags2_lo, SSB_SPROM8_BFL2LO, ~0, 0);
 279         SPEX(boardflags2_hi, SSB_SPROM8_BFL2HI, ~0, 0);
 280
 281         SPEX(alpha2[0], SSB_SPROM8_CCODE, 0xff00, 8);
 282         SPEX(alpha2[1], SSB_SPROM8_CCODE, 0x00ff, 0);
 283
 284         /* Extract cores power info info */
 285         for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
 286                 o = pwr_info_offset[i];
 287                 SPEX(core_pwr_info[i].itssi_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 288                         SSB_SPROM8_2G_ITSSI, SSB_SPROM8_2G_ITSSI_SHIFT);
 289                 SPEX(core_pwr_info[i].maxpwr_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 290                         SSB_SPROM8_2G_MAXP, 0);
 291
 292                 SPEX(core_pwr_info[i].pa_2g[0], o + SSB_SROM8_2G_PA_0, ~0, 0);
 293                 SPEX(core_pwr_info[i].pa_2g[1], o + SSB_SROM8_2G_PA_1, ~0, 0);
 294                 SPEX(core_pwr_info[i].pa_2g[2], o + SSB_SROM8_2G_PA_2, ~0, 0);
 295
 296                 SPEX(core_pwr_info[i].itssi_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 297                         SSB_SPROM8_5G_ITSSI, SSB_SPROM8_5G_ITSSI_SHIFT);
 298                 SPEX(core_pwr_info[i].maxpwr_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 299                         SSB_SPROM8_5G_MAXP, 0);
 300                 SPEX(core_pwr_info[i].maxpwr_5gh, o + SSB_SPROM8_5GHL_MAXP,
 301                         SSB_SPROM8_5GH_MAXP, 0);
 302                 SPEX(core_pwr_info[i].maxpwr_5gl, o + SSB_SPROM8_5GHL_MAXP,
 303                         SSB_SPROM8_5GL_MAXP, SSB_SPROM8_5GL_MAXP_SHIFT);
 304
 305                 SPEX(core_pwr_info[i].pa_5gl[0], o + SSB_SROM8_5GL_PA_0, ~0, 0);
 306                 SPEX(core_pwr_info[i].pa_5gl[1], o + SSB_SROM8_5GL_PA_1, ~0, 0);
 307                 SPEX(core_pwr_info[i].pa_5gl[2], o + SSB_SROM8_5GL_PA_2, ~0, 0);
 308                 SPEX(core_pwr_info[i].pa_5g[0], o + SSB_SROM8_5G_PA_0, ~0, 0);
 309                 SPEX(core_pwr_info[i].pa_5g[1], o + SSB_SROM8_5G_PA_1, ~0, 0);
 310                 SPEX(core_pwr_info[i].pa_5g[2], o + SSB_SROM8_5G_PA_2, ~0, 0);
 311                 SPEX(core_pwr_info[i].pa_5gh[0], o + SSB_SROM8_5GH_PA_0, ~0, 0);
 312                 SPEX(core_pwr_info[i].pa_5gh[1], o + SSB_SROM8_5GH_PA_1, ~0, 0);
 313                 SPEX(core_pwr_info[i].pa_5gh[2], o + SSB_SROM8_5GH_PA_2, ~0, 0);
 314         }
 315
 316         SPEX(fem.ghz2.tssipos, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_TSSIPOS,
 317              SSB_SROM8_FEM_TSSIPOS_SHIFT);
 318         SPEX(fem.ghz2.extpa_gain, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_EXTPA_GAIN,
 319              SSB_SROM8_FEM_EXTPA_GAIN_SHIFT);
 320         SPEX(fem.ghz2.pdet_range, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_PDET_RANGE,
 321              SSB_SROM8_FEM_PDET_RANGE_SHIFT);
 322         SPEX(fem.ghz2.tr_iso, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_TR_ISO,
 323              SSB_SROM8_FEM_TR_ISO_SHIFT);
 324         SPEX(fem.ghz2.antswlut, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_ANTSWLUT,
 325              SSB_SROM8_FEM_ANTSWLUT_SHIFT);
 326
 327         SPEX(fem.ghz5.tssipos, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_TSSIPOS,
 328              SSB_SROM8_FEM_TSSIPOS_SHIFT);
 329         SPEX(fem.ghz5.extpa_gain, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_EXTPA_GAIN,
 330              SSB_SROM8_FEM_EXTPA_GAIN_SHIFT);
 331         SPEX(fem.ghz5.pdet_range, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_PDET_RANGE,
 332              SSB_SROM8_FEM_PDET_RANGE_SHIFT);
 333         SPEX(fem.ghz5.tr_iso, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_TR_ISO,
 334              SSB_SROM8_FEM_TR_ISO_SHIFT);
 335         SPEX(fem.ghz5.antswlut, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_ANTSWLUT,
 336              SSB_SROM8_FEM_ANTSWLUT_SHIFT);
 337
 338         SPEX(ant_available_a, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_A,
 339              SSB_SPROM8_ANTAVAIL_A_SHIFT);
 340         SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG,
 341              SSB_SPROM8_ANTAVAIL_BG_SHIFT);
 342         SPEX(maxpwr_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_MAXP_BG_MASK, 0);
 343         SPEX(itssi_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_ITSSI_BG,
 344              SSB_SPROM8_ITSSI_BG_SHIFT);
 345         SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0);
 346         SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A,
 347              SSB_SPROM8_ITSSI_A_SHIFT);
 348         SPEX(maxpwr_ah, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AH_MASK, 0);
 349         SPEX(maxpwr_al, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AL_MASK,
 350              SSB_SPROM8_MAXP_AL_SHIFT);
 351         SPEX(gpio0, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P0, 0);
 352         SPEX(gpio1, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P1,
 353              SSB_SPROM8_GPIOA_P1_SHIFT);
 354         SPEX(gpio2, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P2, 0);
 355         SPEX(gpio3, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P3,
 356              SSB_SPROM8_GPIOB_P3_SHIFT);
 357         SPEX(tri2g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI2G, 0);
 358         SPEX(tri5g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI5G,
 359              SSB_SPROM8_TRI5G_SHIFT);
 360         SPEX(tri5gl, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GL, 0);
 361         SPEX(tri5gh, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GH,
 362              SSB_SPROM8_TRI5GH_SHIFT);
 363         SPEX(rxpo2g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO2G,
 364              SSB_SPROM8_RXPO2G_SHIFT);
 365         SPEX(rxpo5g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO5G,
 366              SSB_SPROM8_RXPO5G_SHIFT);
 367         SPEX(rssismf2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMF2G, 0);
 368         SPEX(rssismc2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMC2G,
 369              SSB_SPROM8_RSSISMC2G_SHIFT);
 370         SPEX(rssisav2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISAV2G,
 371              SSB_SPROM8_RSSISAV2G_SHIFT);
 372         SPEX(bxa2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_BXA2G,
 373              SSB_SPROM8_BXA2G_SHIFT);
 374         SPEX(rssismf5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMF5G, 0);
 375         SPEX(rssismc5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMC5G,
 376              SSB_SPROM8_RSSISMC5G_SHIFT);
 377         SPEX(rssisav5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISAV5G,
 378              SSB_SPROM8_RSSISAV5G_SHIFT);
 379         SPEX(bxa5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_BXA5G,
 380              SSB_SPROM8_BXA5G_SHIFT);
 381
 382         SPEX(pa0b0, SSB_SPROM8_PA0B0, ~0, 0);
 383         SPEX(pa0b1, SSB_SPROM8_PA0B1, ~0, 0);
 384         SPEX(pa0b2, SSB_SPROM8_PA0B2, ~0, 0);
 385         SPEX(pa1b0, SSB_SPROM8_PA1B0, ~0, 0);
 386         SPEX(pa1b1, SSB_SPROM8_PA1B1, ~0, 0);
 387         SPEX(pa1b2, SSB_SPROM8_PA1B2, ~0, 0);
 388         SPEX(pa1lob0, SSB_SPROM8_PA1LOB0, ~0, 0);
 389         SPEX(pa1lob1, SSB_SPROM8_PA1LOB1, ~0, 0);
 390         SPEX(pa1lob2, SSB_SPROM8_PA1LOB2, ~0, 0);
 391         SPEX(pa1hib0, SSB_SPROM8_PA1HIB0, ~0, 0);
 392         SPEX(pa1hib1, SSB_SPROM8_PA1HIB1, ~0, 0);
 393         SPEX(pa1hib2, SSB_SPROM8_PA1HIB2, ~0, 0);
 394         SPEX(cck2gpo, SSB_SPROM8_CCK2GPO, ~0, 0);
 395         SPEX32(ofdm2gpo, SSB_SPROM8_OFDM2GPO, ~0, 0);
 396         SPEX32(ofdm5glpo, SSB_SPROM8_OFDM5GLPO, ~0, 0);
 397         SPEX32(ofdm5gpo, SSB_SPROM8_OFDM5GPO, ~0, 0);
 398         SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, ~0, 0);
 399
 400         /* Extract the antenna gain values. */
 401         bus->sprom.antenna_gain.a0 = sprom_extract_antgain(sprom,
 402                                                            SSB_SPROM8_AGAIN01,
 403                                                            SSB_SPROM8_AGAIN0,
 404                                                            SSB_SPROM8_AGAIN0_SHIFT);
 405         bus->sprom.antenna_gain.a1 = sprom_extract_antgain(sprom,
 406                                                            SSB_SPROM8_AGAIN01,
 407                                                            SSB_SPROM8_AGAIN1,
 408                                                            SSB_SPROM8_AGAIN1_SHIFT);
 409         bus->sprom.antenna_gain.a2 = sprom_extract_antgain(sprom,
 410                                                            SSB_SPROM8_AGAIN23,
 411                                                            SSB_SPROM8_AGAIN2,
 412                                                            SSB_SPROM8_AGAIN2_SHIFT);
 413         bus->sprom.antenna_gain.a3 = sprom_extract_antgain(sprom,
 414                                                            SSB_SPROM8_AGAIN23,
 415                                                            SSB_SPROM8_AGAIN3,
 416                                                            SSB_SPROM8_AGAIN3_SHIFT);
 417
 418         SPEX(leddc_on_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_ON,
 419              SSB_SPROM8_LEDDC_ON_SHIFT);
 420         SPEX(leddc_off_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_OFF,
 421              SSB_SPROM8_LEDDC_OFF_SHIFT);
 422
 423         SPEX(txchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_TXCHAIN,
 424              SSB_SPROM8_TXRXC_TXCHAIN_SHIFT);
 425         SPEX(rxchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_RXCHAIN,
 426              SSB_SPROM8_TXRXC_RXCHAIN_SHIFT);
 427         SPEX(antswitch, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_SWITCH,
 428              SSB_SPROM8_TXRXC_SWITCH_SHIFT);
 429
 430         SPEX(opo, SSB_SPROM8_OFDM2GPO, 0x00ff, 0);
 431
 432         SPEX_ARRAY8(mcs2gpo, SSB_SPROM8_2G_MCSPO, ~0, 0);
 433         SPEX_ARRAY8(mcs5gpo, SSB_SPROM8_5G_MCSPO, ~0, 0);
 434         SPEX_ARRAY8(mcs5glpo, SSB_SPROM8_5GL_MCSPO, ~0, 0);
 435         SPEX_ARRAY8(mcs5ghpo, SSB_SPROM8_5GH_MCSPO, ~0, 0);
 436
 437         SPEX(rawtempsense, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_RAWTEMP,
 438              SSB_SPROM8_RAWTS_RAWTEMP_SHIFT);
 439         SPEX(measpower, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_MEASPOWER,
 440              SSB_SPROM8_RAWTS_MEASPOWER_SHIFT);
 441         SPEX(tempsense_slope, SSB_SPROM8_OPT_CORRX,
 442              SSB_SPROM8_OPT_CORRX_TEMP_SLOPE,
 443              SSB_SPROM8_OPT_CORRX_TEMP_SLOPE_SHIFT);
 444         SPEX(tempcorrx, SSB_SPROM8_OPT_CORRX, SSB_SPROM8_OPT_CORRX_TEMPCORRX,
 445              SSB_SPROM8_OPT_CORRX_TEMPCORRX_SHIFT);
 446         SPEX(tempsense_option, SSB_SPROM8_OPT_CORRX,
 447              SSB_SPROM8_OPT_CORRX_TEMP_OPTION,
 448              SSB_SPROM8_OPT_CORRX_TEMP_OPTION_SHIFT);
 449         SPEX(freqoffset_corr, SSB_SPROM8_HWIQ_IQSWP,
 450              SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR,
 451              SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR_SHIFT);
 452         SPEX(iqcal_swp_dis, SSB_SPROM8_HWIQ_IQSWP,
 453              SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP,
 454              SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP_SHIFT);
 455         SPEX(hw_iqcal_en, SSB_SPROM8_HWIQ_IQSWP, SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL,
 456              SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL_SHIFT);
 457
 458         SPEX(bw40po, SSB_SPROM8_BW40PO, ~0, 0);
 459         SPEX(cddpo, SSB_SPROM8_CDDPO, ~0, 0);
 460         SPEX(stbcpo, SSB_SPROM8_STBCPO, ~0, 0);
 461         SPEX(bwduppo, SSB_SPROM8_BWDUPPO, ~0, 0);
 462
 463         SPEX(tempthresh, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_TRESH,
 464              SSB_SPROM8_THERMAL_TRESH_SHIFT);
 465         SPEX(tempoffset, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_OFFSET,
 466              SSB_SPROM8_THERMAL_OFFSET_SHIFT);
 467         SPEX(phycal_tempdelta, SSB_SPROM8_TEMPDELTA,
 468              SSB_SPROM8_TEMPDELTA_PHYCAL,
 469              SSB_SPROM8_TEMPDELTA_PHYCAL_SHIFT);
 470         SPEX(temps_period, SSB_SPROM8_TEMPDELTA, SSB_SPROM8_TEMPDELTA_PERIOD,
 471              SSB_SPROM8_TEMPDELTA_PERIOD_SHIFT);
 472         SPEX(temps_hysteresis, SSB_SPROM8_TEMPDELTA,
 473              SSB_SPROM8_TEMPDELTA_HYSTERESIS,
 474              SSB_SPROM8_TEMPDELTA_HYSTERESIS_SHIFT);
 475 }
 476
 477 /*
 478  * Indicates the presence of external SPROM.
 479  */
 480 static bool bcma_sprom_ext_available(struct bcma_bus *bus)
 481 {
 482         u32 chip_status;
 483         u32 srom_control;
 484         u32 present_mask;
 485
 486         if (bus->drv_cc.core->id.rev >= 31) {
 487                 if (!(bus->drv_cc.capabilities & BCMA_CC_CAP_SPROM))
 488                         return false;
 489
 490                 srom_control = bcma_read32(bus->drv_cc.core,
 491                                            BCMA_CC_SROM_CONTROL);
 492                 return srom_control & BCMA_CC_SROM_CONTROL_PRESENT;
 493         }
 494
 495         /* older chipcommon revisions use chip status register */
 496         chip_status = bcma_read32(bus->drv_cc.core, BCMA_CC_CHIPSTAT);
 497         switch (bus->chipinfo.id) {
 498         case BCMA_CHIP_ID_BCM4313:
 499                 present_mask = BCMA_CC_CHIPST_4313_SPROM_PRESENT;
 500                 break;
 501
 502         case BCMA_CHIP_ID_BCM4331:
 503                 present_mask = BCMA_CC_CHIPST_4331_SPROM_PRESENT;
 504                 break;
 505
 506         default:
 507                 return true;
 508         }
 509
 510         return chip_status & present_mask;
 511 }
 512
 513 /*
 514  * Indicates that on-chip OTP memory is present and enabled.
 515  */
 516 static bool bcma_sprom_onchip_available(struct bcma_bus *bus)
 517 {
 518         u32 chip_status;
 519         u32 otpsize = 0;
 520         bool present;
 521
 522         chip_status = bcma_read32(bus->drv_cc.core, BCMA_CC_CHIPSTAT);
 523         switch (bus->chipinfo.id) {
 524         case BCMA_CHIP_ID_BCM4313:
 525                 present = chip_status & BCMA_CC_CHIPST_4313_OTP_PRESENT;
 526                 break;
 527
 528         case BCMA_CHIP_ID_BCM4331:
 529                 present = chip_status & BCMA_CC_CHIPST_4331_OTP_PRESENT;
 530                 break;
 531         case BCMA_CHIP_ID_BCM43142:
 532         case BCMA_CHIP_ID_BCM43224:
 533         case BCMA_CHIP_ID_BCM43225:
 534                 /* for these chips OTP is always available */
 535                 present = true;
 536                 break;
 537         case BCMA_CHIP_ID_BCM43131:
 538         case BCMA_CHIP_ID_BCM43217:
 539         case BCMA_CHIP_ID_BCM43227:
 540         case BCMA_CHIP_ID_BCM43228:
 541         case BCMA_CHIP_ID_BCM43428:
 542                 present = chip_status & BCMA_CC_CHIPST_43228_OTP_PRESENT;
 543                 break;
 544         default:
 545                 present = false;
 546                 break;
 547         }
 548
 549         if (present) {
 550                 otpsize = bus->drv_cc.capabilities & BCMA_CC_CAP_OTPS;
 551                 otpsize >>= BCMA_CC_CAP_OTPS_SHIFT;
 552         }
 553
 554         return otpsize != 0;
 555 }
 556
 557 /*
 558  * Verify OTP is filled and determine the byte
 559  * offset where SPROM data is located.
 560  *
 561  * On error, returns 0; byte offset otherwise.
 562  */
 563 static int bcma_sprom_onchip_offset(struct bcma_bus *bus)
 564 {
 565         struct bcma_device *cc = bus->drv_cc.core;
 566         u32 offset;
 567
 568         /* verify OTP status */
 569         if ((bcma_read32(cc, BCMA_CC_OTPS) & BCMA_CC_OTPS_GU_PROG_HW) == 0)
 570                 return 0;
 571
 572         /* obtain bit offset from otplayout register */
 573         offset = (bcma_read32(cc, BCMA_CC_OTPL) & BCMA_CC_OTPL_GURGN_OFFSET);
 574         return BCMA_CC_SPROM + (offset >> 3);
 575 }
 576
 577 int bcma_sprom_get(struct bcma_bus *bus)
 578 {
 579         u16 offset = BCMA_CC_SPROM;
 580         u16 *sprom;
 581         size_t sprom_sizes[] = { SSB_SPROMSIZE_WORDS_R4,
 582                                  SSB_SPROMSIZE_WORDS_R10,
 583                                  SSB_SPROMSIZE_WORDS_R11, };
 584         int i, err = 0;
 585
 586         if (!bus->drv_cc.core)
 587                 return -EOPNOTSUPP;
 588
 589         if (!bcma_sprom_ext_available(bus)) {
 590                 bool sprom_onchip;
 591
 592                 /*
 593                  * External SPROM takes precedence so check
 594                  * on-chip OTP only when no external SPROM
 595                  * is present.
 596                  */
 597                 sprom_onchip = bcma_sprom_onchip_available(bus);
 598                 if (sprom_onchip) {
 599                         /* determine offset */
 600                         offset = bcma_sprom_onchip_offset(bus);
 601                 }
 602                 if (!offset || !sprom_onchip) {
 603                         /*
 604                          * Maybe there is no SPROM on the device?
 605                          * Now we ask the arch code if there is some sprom
 606                          * available for this device in some other storage.
 607                          */
 608                         err = bcma_fill_sprom_with_fallback(bus, &bus->sprom);
 609                         return err;
 610                 }
 611         }
 612
 613         if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4331 ||
 614             bus->chipinfo.id == BCMA_CHIP_ID_BCM43431)
 615                 bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, false);
 616
 617         bcma_debug(bus, "SPROM offset 0x%x\n", offset);
 618         for (i = 0; i < ARRAY_SIZE(sprom_sizes); i++) {
 619                 size_t words = sprom_sizes[i];
 620
 621                 sprom = kcalloc(words, sizeof(u16), GFP_KERNEL);
 622                 if (!sprom)
 623                         return -ENOMEM;
 624
 625                 bcma_sprom_read(bus, offset, sprom, words);
 626                 err = bcma_sprom_valid(bus, sprom, words);
 627                 if (!err)
 628                         break;
 629
 630                 kfree(sprom);
 631         }
 632
 633         if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4331 ||
 634             bus->chipinfo.id == BCMA_CHIP_ID_BCM43431)
 635                 bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, true);
 636
 637         if (err) {
 638                 bcma_warn(bus, "Invalid SPROM read from the PCIe card, trying to use fallback SPROM\n");
 639                 err = bcma_fill_sprom_with_fallback(bus, &bus->sprom);
 640         } else {
 641                 bcma_sprom_extract_r8(bus, sprom);
 642                 kfree(sprom);
 643         }
 644
 645         return err;
 646 }