/* Newer chips can access PCI/PCIE and CC core without requiring to change
  * PCI BAR0 WIN
  */
-#define SI_FAST(si) (((si)->pub.buscoretype == PCIE_CORE_ID) ||        \
-                    (((si)->pub.buscoretype == PCI_CORE_ID) && \
-                     (si)->pub.buscorerev >= 13))
+#define SI_FAST(sih) ((ai_get_buscoretype(sih) == PCIE_CORE_ID) || \
+                    ((ai_get_buscoretype(sih) == PCI_CORE_ID) && \
+                     ai_get_buscorerev(sih) >= 13))
 
 #define CCREGS_FAST(si) (((char __iomem *)((si)->curmap) + \
                          PCI_16KB0_CCREGS_OFFSET))
            (si)->coreid[(si)->curidx] == (si)->dev_coreid) \
                (*(si)->intrsrestore_fn)((si)->intr_arg, intr_val)
 
-#define PCI(si)                ((si)->pub.buscoretype == PCI_CORE_ID)
-#define PCIE(si)       ((si)->pub.buscoretype == PCIE_CORE_ID)
+#define PCI(sih)       (ai_get_buscoretype(sih) == PCI_CORE_ID)
+#define PCIE(sih)      (ai_get_buscoretype(sih) == PCIE_CORE_ID)
 
-#define PCI_FORCEHT(si)        (PCIE(si) && (si->pub.chip == BCM4716_CHIP_ID))
+#define PCI_FORCEHT(sih) (PCIE(sih) && (ai_get_chip_id(sih) == BCM4716_CHIP_ID))
 
 #ifdef BCMDBG
 #define        SI_MSG(fmt, ...)        pr_debug(fmt, ##__VA_ARGS__)
        sii->pub.ccrev = (int)ai_corerev(&sii->pub);
 
        /* get chipcommon chipstatus */
-       if (sii->pub.ccrev >= 11)
+       if (ai_get_ccrev(&sii->pub) >= 11)
                sii->chipst = R_REG(&cc->chipstatus);
 
        /* get chipcommon capabilites */
        sii->pub.cccaps = R_REG(&cc->capabilities);
 
        /* get pmu rev and caps */
-       if (sii->pub.cccaps & CC_CAP_PMU) {
+       if (ai_get_cccaps(&sii->pub) & CC_CAP_PMU) {
                sii->pub.pmucaps = R_REG(&cc->pmucapabilities);
                sii->pub.pmurev = sii->pub.pmucaps & PCAP_REV_MASK;
        }
        }
 
        /* fixup necessary chip/core configurations */
-       if (SI_FAST(sii)) {
+       if (SI_FAST(&sii->pub)) {
                if (!sii->pch) {
                        sii->pch = pcicore_init(&sii->pub, sii->pbus,
                                                (__iomem void *)PCIEREGS(sii));
        ai_setcoreidx(sih, origidx);
 
        /* PMU specific initializations */
-       if (sih->cccaps & CC_CAP_PMU) {
+       if (ai_get_cccaps(sih) & CC_CAP_PMU) {
                u32 xtalfreq;
                si_pmu_init(sih);
                si_pmu_chip_init(sih);
        ai_corereg(sih, SI_CC_IDX, offsetof(struct chipcregs, gpiotimerval),
                   ~0, w);
 
-       if (PCIE(sii))
+       if (PCIE(sih))
                pcicore_attach(sii->pch, SI_DOATTACH);
 
-       if (sih->chip == BCM43224_CHIP_ID) {
+       if (ai_get_chip_id(sih) == BCM43224_CHIP_ID) {
                /*
                 * enable 12 mA drive strenth for 43224 and
                 * set chipControl register bit 15
                 */
-               if (sih->chiprev == 0) {
+               if (ai_get_chiprev(sih) == 0) {
                        SI_MSG("Applying 43224A0 WARs\n");
                        ai_corereg(sih, SI_CC_IDX,
                                   offsetof(struct chipcregs, chipcontrol),
                        si_pmu_chipcontrol(sih, 0, CCTRL_43224A0_12MA_LED_DRIVE,
                                           CCTRL_43224A0_12MA_LED_DRIVE);
                }
-               if (sih->chiprev >= 1) {
+               if (ai_get_chiprev(sih) >= 1) {
                        SI_MSG("Applying 43224B0+ WARs\n");
                        si_pmu_chipcontrol(sih, 0, CCTRL_43224B0_12MA_LED_DRIVE,
                                           CCTRL_43224B0_12MA_LED_DRIVE);
                }
        }
 
-       if (sih->chip == BCM4313_CHIP_ID) {
+       if (ai_get_chip_id(sih) == BCM4313_CHIP_ID) {
                /*
                 * enable 12 mA drive strenth for 4313 and
                 * set chipControl register bit 1
 
 bool ai_backplane64(struct si_pub *sih)
 {
-       return (sih->cccaps & CC_CAP_BKPLN64) != 0;
+       return (ai_get_cccaps(sih) & CC_CAP_BKPLN64) != 0;
 }
 
 /* return index of coreid or BADIDX if not found */
 
        sii = (struct si_info *)sih;
 
-       if (SI_FAST(sii)) {
+       if (SI_FAST(sih)) {
                /* Overloading the origidx variable to remember the coreid,
                 * this works because the core ids cannot be confused with
                 * core indices.
                *origidx = coreid;
                if (coreid == CC_CORE_ID)
                        return CCREGS_FAST(sii);
-               else if (coreid == sih->buscoretype)
+               else if (coreid == ai_get_buscoretype(sih))
                        return PCIEREGS(sii);
        }
        INTR_OFF(sii, *intr_val);
        struct si_info *sii;
 
        sii = (struct si_info *)sih;
-       if (SI_FAST(sii)
-           && ((coreid == CC_CORE_ID) || (coreid == sih->buscoretype)))
+       if (SI_FAST(sih)
+           && ((coreid == CC_CORE_ID) || (coreid == ai_get_buscoretype(sih))))
                return;
 
        ai_setcoreidx(sih, coreid);
         * If pci/pcie, we can get at pci/pcie regs
         * and on newer cores to chipc
         */
-       if ((sii->coreid[coreidx] == CC_CORE_ID) && SI_FAST(sii)) {
+       if ((sii->coreid[coreidx] == CC_CORE_ID) && SI_FAST(sih)) {
                /* Chipc registers are mapped at 12KB */
                fast = true;
                r = (u32 __iomem *)((__iomem char *)sii->curmap +
                 * an 8KB window or, in pcie and pci rev 13 at 8KB
                 */
                fast = true;
-               if (SI_FAST(sii))
+               if (SI_FAST(sih))
                        r = (u32 __iomem *)((__iomem char *)sii->curmap +
                                    PCI_16KB0_PCIREGS_OFFSET + regoff);
                else
        struct chipcregs __iomem *cc;
        u32 val;
 
-       if (sii->pub.ccrev < 6) {
+       if (ai_get_ccrev(&sii->pub) < 6) {
                pci_read_config_dword(sii->pbus, PCI_GPIO_OUT,
                                      &val);
                if (val & PCI_CFG_GPIO_SCS)
                        return SCC_SS_PCI;
                return SCC_SS_XTAL;
-       } else if (sii->pub.ccrev < 10) {
+       } else if (ai_get_ccrev(&sii->pub) < 10) {
                cc = (struct chipcregs __iomem *)
                        ai_setcoreidx(&sii->pub, sii->curidx);
                return R_REG(&cc->slow_clk_ctl) & SCC_SS_MASK;
        uint div;
 
        slowclk = ai_slowclk_src(sii);
-       if (sii->pub.ccrev < 6) {
+       if (ai_get_ccrev(&sii->pub) < 6) {
                if (slowclk == SCC_SS_PCI)
                        return max_freq ? (PCIMAXFREQ / 64)
                                : (PCIMINFREQ / 64);
                else
                        return max_freq ? (XTALMAXFREQ / 32)
                                : (XTALMINFREQ / 32);
-       } else if (sii->pub.ccrev < 10) {
+       } else if (ai_get_ccrev(&sii->pub) < 10) {
                div = 4 *
                    (((R_REG(&cc->slow_clk_ctl) & SCC_CD_MASK) >>
                      SCC_CD_SHIFT) + 1);
 
        /* Starting with 4318 it is ILP that is used for the delays */
        slowmaxfreq =
-           ai_slowclk_freq(sii, (sii->pub.ccrev >= 10) ? false : true, cc);
+           ai_slowclk_freq(sii,
+                           (ai_get_ccrev(&sii->pub) >= 10) ? false : true, cc);
 
        pll_on_delay = ((slowmaxfreq * pll_delay) + 999999) / 1000000;
        fref_sel_delay = ((slowmaxfreq * FREF_DELAY) + 999999) / 1000000;
        struct chipcregs __iomem *cc;
        bool fast;
 
-       if (!(sih->cccaps & CC_CAP_PWR_CTL))
+       if (!(ai_get_cccaps(sih) & CC_CAP_PWR_CTL))
                return;
 
        sii = (struct si_info *)sih;
-       fast = SI_FAST(sii);
+       fast = SI_FAST(sih);
        if (!fast) {
                origidx = sii->curidx;
                cc = (struct chipcregs __iomem *)
        }
 
        /* set all Instaclk chip ILP to 1 MHz */
-       if (sih->ccrev >= 10)
+       if (ai_get_ccrev(sih) >= 10)
                SET_REG(&cc->system_clk_ctl, SYCC_CD_MASK,
                        (ILP_DIV_1MHZ << SYCC_CD_SHIFT));
 
        bool fast;
 
        sii = (struct si_info *)sih;
-       if (sih->cccaps & CC_CAP_PMU) {
+       if (ai_get_cccaps(sih) & CC_CAP_PMU) {
                INTR_OFF(sii, intr_val);
                fpdelay = si_pmu_fast_pwrup_delay(sih);
                INTR_RESTORE(sii, intr_val);
                return fpdelay;
        }
 
-       if (!(sih->cccaps & CC_CAP_PWR_CTL))
+       if (!(ai_get_cccaps(sih) & CC_CAP_PWR_CTL))
                return 0;
 
-       fast = SI_FAST(sii);
+       fast = SI_FAST(sih);
        fpdelay = 0;
        if (!fast) {
                origidx = sii->curidx;
        sii = (struct si_info *)sih;
 
        /* pcie core doesn't have any mapping to control the xtal pu */
-       if (PCIE(sii))
+       if (PCIE(sih))
                return -1;
 
        pci_read_config_dword(sii->pbus, PCI_GPIO_IN, &in);
        struct chipcregs __iomem *cc;
        u32 scc;
        uint intr_val = 0;
-       bool fast = SI_FAST(sii);
+       bool fast = SI_FAST(&sii->pub);
 
        /* chipcommon cores prior to rev6 don't support dynamic clock control */
-       if (sii->pub.ccrev < 6)
+       if (ai_get_ccrev(&sii->pub) < 6)
                return false;
 
        if (!fast) {
                        goto done;
        }
 
-       if (!(sii->pub.cccaps & CC_CAP_PWR_CTL) && (sii->pub.ccrev < 20))
+       if (!(ai_get_cccaps(&sii->pub) & CC_CAP_PWR_CTL) &&
+           (ai_get_ccrev(&sii->pub) < 20))
                goto done;
 
        switch (mode) {
        case CLK_FAST:          /* FORCEHT, fast (pll) clock */
-               if (sii->pub.ccrev < 10) {
+               if (ai_get_ccrev(&sii->pub) < 10) {
                        /*
                         * don't forget to force xtal back
                         * on before we clear SCC_DYN_XTAL..
                        ai_clkctl_xtal(&sii->pub, XTAL, ON);
                        SET_REG(&cc->slow_clk_ctl,
                                (SCC_XC | SCC_FS | SCC_IP), SCC_IP);
-               } else if (sii->pub.ccrev < 20) {
+               } else if (ai_get_ccrev(&sii->pub) < 20) {
                        OR_REG(&cc->system_clk_ctl, SYCC_HR);
                } else {
                        OR_REG(&cc->clk_ctl_st, CCS_FORCEHT);
                }
 
                /* wait for the PLL */
-               if (sii->pub.cccaps & CC_CAP_PMU) {
+               if (ai_get_cccaps(&sii->pub) & CC_CAP_PMU) {
                        u32 htavail = CCS_HTAVAIL;
                        SPINWAIT(((R_REG(&cc->clk_ctl_st) & htavail)
                                  == 0), PMU_MAX_TRANSITION_DLY);
                break;
 
        case CLK_DYNAMIC:       /* enable dynamic clock control */
-               if (sii->pub.ccrev < 10) {
+               if (ai_get_ccrev(&sii->pub) < 10) {
                        scc = R_REG(&cc->slow_clk_ctl);
                        scc &= ~(SCC_FS | SCC_IP | SCC_XC);
                        if ((scc & SCC_SS_MASK) != SCC_SS_XTAL)
                         */
                        if (scc & SCC_XC)
                                ai_clkctl_xtal(&sii->pub, XTAL, OFF);
-               } else if (sii->pub.ccrev < 20) {
+               } else if (ai_get_ccrev(&sii->pub) < 20) {
                        /* Instaclock */
                        AND_REG(&cc->system_clk_ctl, ~SYCC_HR);
                } else {
        sii = (struct si_info *)sih;
 
        /* chipcommon cores prior to rev6 don't support dynamic clock control */
-       if (sih->ccrev < 6)
+       if (ai_get_ccrev(sih) < 6)
                return false;
 
-       if (PCI_FORCEHT(sii))
+       if (PCI_FORCEHT(sih))
                return mode == CLK_FAST;
 
        return _ai_clkctl_cc(sii, mode);
 
        sii = (struct si_info *)sih;
 
-       if (PCI_FORCEHT(sii))
+       if (PCI_FORCEHT(sih))
                _ai_clkctl_cc(sii, CLK_FAST);
 
-       if (PCIE(sii))
+       if (PCIE(sih))
                pcicore_up(sii->pch, SI_PCIUP);
 
 }
        sii = (struct si_info *)sih;
 
        /* release FORCEHT since chip is going to "down" state */
-       if (PCI_FORCEHT(sii))
+       if (PCI_FORCEHT(sih))
                _ai_clkctl_cc(sii, CLK_DYNAMIC);
 
        pcicore_down(sii->pch, SI_PCIDOWN);
 
        sii = (struct si_info *)sih;
 
-       if (PCI(sii)) {
+       if (PCI(sih)) {
                /* get current core index */
                idx = sii->curidx;
 
         * Enable sb->pci interrupts.  Assume
         * PCI rev 2.3 support was added in pci core rev 6 and things changed..
         */
-       if (PCIE(sii) || (PCI(sii) && ((sii->pub.buscorerev) >= 6))) {
+       if (PCIE(sih) || (PCI(sih) && (ai_get_buscorerev(sih) >= 6))) {
                /* pci config write to set this core bit in PCIIntMask */
                pci_read_config_dword(sii->pbus, PCI_INT_MASK, &w);
                w |= (coremask << PCI_SBIM_SHIFT);
                ai_setint(sih, siflag);
        }
 
-       if (PCI(sii)) {
+       if (PCI(sih)) {
                pcicore_pci_setup(sii->pch, regs);
 
                /* switch back to previous core */
        origidx = ai_coreidx(&sii->pub);
 
        /* check 'pi' is correct and fix it if not */
-       regs = ai_setcore(&sii->pub, sii->pub.buscoretype, 0);
-       if (sii->pub.buscoretype == PCIE_CORE_ID)
+       regs = ai_setcore(&sii->pub, ai_get_buscoretype(sih), 0);
+       if (ai_get_buscoretype(sih) == PCIE_CORE_ID)
                pcicore_fixcfg_pcie(sii->pch,
                                    (struct sbpcieregs __iomem *)regs);
-       else if (sii->pub.buscoretype == PCI_CORE_ID)
+       else if (ai_get_buscoretype(sih) == PCI_CORE_ID)
                pcicore_fixcfg_pci(sii->pch, (struct sbpciregs __iomem *)regs);
 
        /* restore the original index */
        val = R_REG(&cc->chipcontrol);
 
        if (on) {
-               if (sih->chippkg == 9 || sih->chippkg == 0xb)
+               if (ai_get_chippkg(sih) == 9 || ai_get_chippkg(sih) == 0xb)
                        /* Ext PA Controls for 4331 12x9 Package */
                        W_REG(&cc->chipcontrol, val |
                              CCTRL4331_EXTPA_EN |
 {
        struct si_info *sii = (struct si_info *)sih;
 
-       if (sih->ccrev >= 31) {
+       if (ai_get_ccrev(sih) >= 31) {
                uint origidx;
                struct chipcregs __iomem *cc;
                u32 sromctrl;
 
-               if ((sih->cccaps & CC_CAP_SROM) == 0)
+               if ((ai_get_cccaps(sih) & CC_CAP_SROM) == 0)
                        return false;
 
                origidx = sii->curidx;
                return sromctrl & SRC_PRESENT;
        }
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM4313_CHIP_ID:
                return (sii->chipst & CST4313_SPROM_PRESENT) != 0;
        default:
 {
        struct si_info *sii = (struct si_info *)sih;
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM4313_CHIP_ID:
                return (sii->chipst & CST4313_OTP_PRESENT) == 0;
                /* These chips always have their OTP on */
 
 /* Enable Ex-PA for 4313 */
 extern void ai_epa_4313war(struct si_pub *sih);
 
+static inline uint ai_get_buscoretype(struct si_pub *sih)
+{
+       return sih->buscoretype;
+}
+
+static inline uint ai_get_buscorerev(struct si_pub *sih)
+{
+       return sih->buscorerev;
+}
+static inline int ai_get_ccrev(struct si_pub *sih)
+{
+       return sih->ccrev;
+}
+static inline u32 ai_get_cccaps(struct si_pub *sih)
+{
+       return sih->cccaps;
+}
+static inline int ai_get_pmurev(struct si_pub *sih)
+{
+       return sih->pmurev;
+}
+static inline u32 ai_get_pmucaps(struct si_pub *sih)
+{
+       return sih->pmucaps;
+}
+static inline uint ai_get_boardtype(struct si_pub *sih)
+{
+       return sih->boardtype;
+}
+static inline uint ai_get_boardvendor(struct si_pub *sih)
+{
+       return sih->boardvendor;
+}
+static inline uint ai_get_chip_id(struct si_pub *sih)
+{
+       return sih->chip;
+}
+static inline uint ai_get_chiprev(struct si_pub *sih)
+{
+       return sih->chiprev;
+}
+static inline uint ai_get_chippkg(struct si_pub *sih)
+{
+       return sih->chippkg;
+}
+
 #endif                         /* _BRCM_AIUTILS_H_ */
 
 /* control chip clock to save power, enable dynamic clock or force fast clock */
 static void brcms_b_clkctl_clk(struct brcms_hardware *wlc_hw, uint mode)
 {
-       if (wlc_hw->sih->cccaps & CC_CAP_PMU) {
+       if (ai_get_cccaps(wlc_hw->sih) & CC_CAP_PMU) {
                /* new chips with PMU, CCS_FORCEHT will distribute the HT clock
                 * on backplane, but mac core will still run on ALP(not HT) when
                 * it enters powersave mode, which means the FCA bit may not be
                                          (&wlc_hw->regs->
                                           clk_ctl_st) & CCS_HTAVAIL));
                        } else {
-                               if ((wlc_hw->sih->pmurev == 0) &&
+                               if ((ai_get_pmurev(wlc_hw->sih) == 0) &&
                                    (R_REG
                                     (&wlc_hw->regs->
                                      clk_ctl_st) & (CCS_FORCEHT | CCS_HTAREQ)))
        uint b2 = boardrev & 0xf;
 
        /* voards from other vendors are always considered valid */
-       if (wlc_hw->sih->boardvendor != PCI_VENDOR_ID_BROADCOM)
+       if (ai_get_boardvendor(wlc_hw->sih) != PCI_VENDOR_ID_BROADCOM)
                return true;
 
        /* do some boardrev sanity checks when boardvendor is Broadcom */
                 * AI chip doesn't restore bar0win2 on
                 * hibernation/resume, need sw fixup
                 */
-               if ((wlc_hw->sih->chip == BCM43224_CHIP_ID) ||
-                   (wlc_hw->sih->chip == BCM43225_CHIP_ID))
+               if ((ai_get_chip_id(wlc_hw->sih) == BCM43224_CHIP_ID) ||
+                   (ai_get_chip_id(wlc_hw->sih) == BCM43225_CHIP_ID))
                        wlc_hw->regs = (struct d11regs __iomem *)
                                        ai_setcore(wlc_hw->sih, D11_CORE_ID, 0);
                ai_core_reset(wlc_hw->sih, flags, resetbits);
 
        brcms_c_mctrl_reset(wlc_hw);
 
-       if (wlc_hw->sih->cccaps & CC_CAP_PMU)
+       if (ai_get_cccaps(wlc_hw->sih) & CC_CAP_PMU)
                brcms_b_clkctl_clk(wlc_hw, CLK_FAST);
 
        brcms_b_phy_reset(wlc_hw);
 {
        struct d11regs __iomem *regs = wlc_hw->regs;
 
-       if ((wlc_hw->sih->chip == BCM43224_CHIP_ID) ||
-           (wlc_hw->sih->chip == BCM43225_CHIP_ID)) {
+       if ((ai_get_chip_id(wlc_hw->sih) == BCM43224_CHIP_ID) ||
+           (ai_get_chip_id(wlc_hw->sih) == BCM43225_CHIP_ID)) {
                if (spurmode == WL_SPURAVOID_ON2) {     /* 126Mhz */
                        W_REG(®s->tsf_clk_frac_l, 0x2082);
                        W_REG(®s->tsf_clk_frac_h, 0x8);
        regs = wlc_hw->regs;
 
        if (on) {
-               if ((wlc_hw->sih->chip == BCM4313_CHIP_ID)) {
+               if ((ai_get_chip_id(wlc_hw->sih) == BCM4313_CHIP_ID)) {
                        OR_REG(®s->clk_ctl_st,
                               (CCS_ERSRC_REQ_HT | CCS_ERSRC_REQ_D11PLL |
                                CCS_ERSRC_REQ_PHYPLL));
        wlc_hw->boardrev = (u16) j;
        if (!brcms_c_validboardtype(wlc_hw)) {
                wiphy_err(wiphy, "wl%d: brcms_b_attach: Unsupported Broadcom "
-                       "board type (0x%x)" " or revision level (0x%x)\n",
-                        unit, wlc_hw->sih->boardtype, wlc_hw->boardrev);
+                         "board type (0x%x)" " or revision level (0x%x)\n",
+                         unit, ai_get_boardtype(wlc_hw->sih),
+                         wlc_hw->boardrev);
                err = 15;
                goto fail;
        }
        else
                wlc_hw->_nbands = 1;
 
-       if ((wlc_hw->sih->chip == BCM43225_CHIP_ID))
+       if ((ai_get_chip_id(wlc_hw->sih) == BCM43225_CHIP_ID))
                wlc_hw->_nbands = 1;
 
        /* BMAC_NOTE: remove init of pub values when brcms_c_attach()
        sha_params.corerev = wlc_hw->corerev;
        sha_params.vid = wlc_hw->vendorid;
        sha_params.did = wlc_hw->deviceid;
-       sha_params.chip = wlc_hw->sih->chip;
-       sha_params.chiprev = wlc_hw->sih->chiprev;
-       sha_params.chippkg = wlc_hw->sih->chippkg;
+       sha_params.chip = ai_get_chip_id(wlc_hw->sih);
+       sha_params.chiprev = ai_get_chiprev(wlc_hw->sih);
+       sha_params.chippkg = ai_get_chippkg(wlc_hw->sih);
        sha_params.sromrev = wlc_hw->sromrev;
-       sha_params.boardtype = wlc_hw->sih->boardtype;
+       sha_params.boardtype = ai_get_boardtype(wlc_hw->sih);
        sha_params.boardrev = wlc_hw->boardrev;
-       sha_params.boardvendor = wlc_hw->sih->boardvendor;
        sha_params.boardflags = wlc_hw->boardflags;
        sha_params.boardflags2 = wlc_hw->boardflags2;
-       sha_params.buscorerev = wlc_hw->sih->buscorerev;
 
        /* alloc and save pointer to shared phy state area */
        wlc_hw->phy_sh = wlc_phy_shared_attach(&sha_params);
                goto fail;
        }
 
-       BCMMSG(wlc->wiphy,
-                "deviceid 0x%x nbands %d board 0x%x macaddr: %s\n",
-                wlc_hw->deviceid, wlc_hw->_nbands,
-                wlc_hw->sih->boardtype, macaddr);
+       BCMMSG(wlc->wiphy, "deviceid 0x%x nbands %d board 0x%x macaddr: %s\n",
+              wlc_hw->deviceid, wlc_hw->_nbands, ai_get_boardtype(wlc_hw->sih),
+              macaddr);
 
        return err;
 
         * AI chip doesn't restore bar0win2 on
         * hibernation/resume, need sw fixup
         */
-       if ((wlc_hw->sih->chip == BCM43224_CHIP_ID) ||
-           (wlc_hw->sih->chip == BCM43225_CHIP_ID))
+       if ((ai_get_chip_id(wlc_hw->sih) == BCM43224_CHIP_ID) ||
+           (ai_get_chip_id(wlc_hw->sih) == BCM43225_CHIP_ID))
                wlc_hw->regs = (struct d11regs __iomem *)
                                ai_setcore(wlc_hw->sih, D11_CORE_ID, 0);
 
        wlc_hw->wlc->pub->hw_up = true;
 
        if ((wlc_hw->boardflags & BFL_FEM)
-           && (wlc_hw->sih->chip == BCM4313_CHIP_ID)) {
+           && (ai_get_chip_id(wlc_hw->sih) == BCM4313_CHIP_ID)) {
                if (!
                    (wlc_hw->boardrev >= 0x1250
                     && (wlc_hw->boardflags & BFL_FEM_BT)))
        }
 
        if ((wlc->pub->boardflags & BFL_FEM)
-           && (wlc->pub->sih->chip == BCM4313_CHIP_ID)) {
+           && (ai_get_chip_id(wlc->hw->sih) == BCM4313_CHIP_ID)) {
                if (wlc->pub->boardrev >= 0x1250
                    && (wlc->pub->boardflags & BFL_FEM_BT))
                        brcms_b_mhf(wlc->hw, MHF5, MHF5_4313_GPIOCTRL,
 
        if (macintstatus & MI_GP0) {
                wiphy_err(wiphy, "wl%d: PSM microcode watchdog fired at %d "
-                       "(seconds). Resetting.\n", wlc_hw->unit, wlc_hw->now);
+                         "(seconds). Resetting.\n", wlc_hw->unit, wlc_hw->now);
 
                printk_once("%s : PSM Watchdog, chipid 0x%x, chiprev 0x%x\n",
-                                       __func__, wlc_hw->sih->chip,
-                                       wlc_hw->sih->chiprev);
+                           __func__, ai_get_chip_id(wlc_hw->sih),
+                           ai_get_chiprev(wlc_hw->sih));
                brcms_fatal_error(wlc_hw->wlc->wl);
        }
 
 
 };
 
 #define PCIE_ASPM(sih)                                                 \
-       (((sih)->buscoretype == PCIE_CORE_ID) &&                        \
-        (((sih)->buscorerev >= 3) &&                                   \
-         ((sih)->buscorerev <= 5)))
+       ((ai_get_buscoretype(sih) == PCIE_CORE_ID) &&                   \
+        ((ai_get_buscorerev(sih) >= 3) &&                              \
+         (ai_get_buscorerev(sih) <= 5)))
 
 
 /* delay needed between the mdio control/ mdiodata register data access */
        pi->sih = sih;
        pi->dev = pdev;
 
-       if (sih->buscoretype == PCIE_CORE_ID) {
+       if (ai_get_buscoretype(sih) == PCIE_CORE_ID) {
                u8 cap_ptr;
                pi->regs.pcieregs = regs;
                cap_ptr = pcicore_find_pci_capability(pi->dev, PCI_CAP_ID_EXP,
        struct si_pub *sih = pi->sih;
        struct sbpcieregs __iomem *pcieregs = pi->regs.pcieregs;
 
-       if (sih->buscoretype != PCIE_CORE_ID || sih->buscorerev < 7)
+       if (ai_get_buscoretype(sih) != PCIE_CORE_ID ||
+           ai_get_buscorerev(sih) < 7)
                return;
 
        w = pcie_readreg(pcieregs, PCIE_PCIEREGS, PCIE_DLLP_PMTHRESHREG);
                        pcie_clkreq(pi, 1, 0);
                break;
        case SI_PCIDOWN:
-               if (sih->buscorerev == 6) {     /* turn on serdes PLL down */
+               /* turn on serdes PLL down */
+               if (ai_get_buscorerev(sih) == 6) {
                        ai_corereg(sih, SI_CC_IDX,
                                   offsetof(struct chipcregs, chipcontrol_addr),
                                   ~0, 0);
                }
                break;
        case SI_PCIUP:
-               if (sih->buscorerev == 6) {     /* turn off serdes PLL down */
+               /* turn off serdes PLL down */
+               if (ai_get_buscorerev(sih) == 6) {
                        ai_corereg(sih, SI_CC_IDX,
                                   offsetof(struct chipcregs, chipcontrol_addr),
                                   ~0, 0);
        struct sbpcieregs __iomem *pcieregs = pi->regs.pcieregs;
        u32 w;
 
-       if (sih->buscorerev == 0 || sih->buscorerev == 1) {
+       if (ai_get_buscorerev(sih) == 0 || ai_get_buscorerev(sih) == 1) {
                w = pcie_readreg(pcieregs, PCIE_PCIEREGS,
                                 PCIE_TLP_WORKAROUNDSREG);
                w |= 0x8;
                              PCIE_TLP_WORKAROUNDSREG, w);
        }
 
-       if (sih->buscorerev == 1) {
+       if (ai_get_buscorerev(sih) == 1) {
                w = pcie_readreg(pcieregs, PCIE_PCIEREGS, PCIE_DLLP_LCREG);
                w |= 0x40;
                pcie_writereg(pcieregs, PCIE_PCIEREGS, PCIE_DLLP_LCREG, w);
        }
 
-       if (sih->buscorerev == 0) {
+       if (ai_get_buscorerev(sih) == 0) {
                pcie_mdiowrite(pi, MDIODATA_DEV_RX, SERDES_RX_TIMER1, 0x8128);
                pcie_mdiowrite(pi, MDIODATA_DEV_RX, SERDES_RX_CDR, 0x0100);
                pcie_mdiowrite(pi, MDIODATA_DEV_RX, SERDES_RX_CDRBW, 0x1466);
                pcie_war_serdes(pi);
 
                pcie_war_aspm_clkreq(pi);
-       } else if (pi->sih->buscorerev == 7)
+       } else if (ai_get_buscorerev(pi->sih) == 7)
                pcie_war_noplldown(pi);
 
        /* Note that the fix is actually in the SROM,
         * that's why this is open-ended
         */
-       if (pi->sih->buscorerev >= 6)
+       if (ai_get_buscorerev(pi->sih) >= 6)
                pcie_misc_config_fixup(pi);
 }
 
 
 void pcicore_hwup(struct pcicore_info *pi)
 {
-       if (!pi || pi->sih->buscoretype != PCIE_CORE_ID)
+       if (!pi || ai_get_buscoretype(pi->sih) != PCIE_CORE_ID)
                return;
 
        pcie_war_pci_setup(pi);
 
 void pcicore_up(struct pcicore_info *pi, int state)
 {
-       if (!pi || pi->sih->buscoretype != PCIE_CORE_ID)
+       if (!pi || ai_get_buscoretype(pi->sih) != PCIE_CORE_ID)
                return;
 
        /* Restore L1 timer for better performance */
 
 void pcicore_down(struct pcicore_info *pi, int state)
 {
-       if (!pi || pi->sih->buscoretype != PCIE_CORE_ID)
+       if (!pi || ai_get_buscoretype(pi->sih) != PCIE_CORE_ID)
                return;
 
        pcie_clkreq_upd(pi, state);
 
        OR_REG(&pciregs->sbtopci2, SBTOPCI_PREF | SBTOPCI_BURST);
 
-       if (((struct si_info *)(pi->sih))->pub.buscorerev >= 11) {
+       if (ai_get_buscorerev(pi->sih) >= 11) {
                OR_REG(&pciregs->sbtopci2, SBTOPCI_RC_READMULTI);
                w = R_REG(&pciregs->clkrun);
                W_REG(&pciregs->clkrun, w | PCI_CLKRUN_DSBL);
 
 {
        int ret = 0;
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
                ret = osizew * 2 - OTP_SZ_FU_72 - OTP_SZ_CHECKSUM;
         * record word offset of General Use Region
         * for various chipcommon revs
         */
-       if (oi->sih->ccrev == 21 || oi->sih->ccrev == 24
-           || oi->sih->ccrev == 27) {
+       if (oi->ccrev == 21 || oi->ccrev == 24
+           || oi->ccrev == 27) {
                oi->otpgu_base = REVA4_OTPGU_BASE;
-       } else if (oi->sih->ccrev == 36) {
+       } else if (oi->ccrev == 36) {
                /*
                 * OTP size greater than equal to 2KB (128 words),
                 * otpgu_base is similar to rev23
                        oi->otpgu_base = REVB8_OTPGU_BASE;
                else
                        oi->otpgu_base = REV36_OTPGU_BASE;
-       } else if (oi->sih->ccrev == 23 || oi->sih->ccrev >= 25) {
+       } else if (oi->ccrev == 23 || oi->ccrev >= 25) {
                oi->otpgu_base = REVB8_OTPGU_BASE;
        }
 
        /* Read OTP lock bits and subregion programmed indication bits */
        oi->status = R_REG(&cc->otpstatus);
 
-       if ((oi->sih->chip == BCM43224_CHIP_ID)
-           || (oi->sih->chip == BCM43225_CHIP_ID)) {
+       if ((ai_get_chip_id(oi->sih) == BCM43224_CHIP_ID)
+           || (ai_get_chip_id(oi->sih) == BCM43225_CHIP_ID)) {
                u32 p_bits;
                p_bits =
                    (ipxotp_otpr(oi, cc, oi->otpgu_base + OTPGU_P_OFF) &
        struct chipcregs __iomem *cc;
 
        /* Make sure we're running IPX OTP */
-       if (!OTPTYPE_IPX(sih->ccrev))
+       if (!OTPTYPE_IPX(oi->ccrev))
                return -EBADE;
 
        /* Make sure OTP is not disabled */
                return -EBADE;
 
        /* Check for otp size */
-       switch ((sih->cccaps & CC_CAP_OTPSIZE) >> CC_CAP_OTPSIZE_SHIFT) {
+       switch ((ai_get_cccaps(sih) & CC_CAP_OTPSIZE) >> CC_CAP_OTPSIZE_SHIFT) {
        case 0:
                /* Nothing there */
                return -EBADE;
 
        memset(oi, 0, sizeof(struct otpinfo));
 
-       oi->ccrev = sih->ccrev;
+       oi->ccrev = ai_get_ccrev(sih);
 
        if (OTPTYPE_IPX(oi->ccrev))
                oi->fn = &ipxotp_fn;
 
        sh->sromrev = shp->sromrev;
        sh->boardtype = shp->boardtype;
        sh->boardrev = shp->boardrev;
-       sh->boardvendor = shp->boardvendor;
        sh->boardflags = shp->boardflags;
        sh->boardflags2 = shp->boardflags2;
-       sh->buscorerev = shp->buscorerev;
 
        sh->fast_timer = PHY_SW_TIMER_FAST;
        sh->slow_timer = PHY_SW_TIMER_SLOW;
 
        struct phy_shim_info *physhim;
        uint unit;
        uint corerev;
-       uint buscorerev;
        u16 vid;
        u16 did;
        uint chip;
        uint sromrev;
        uint boardtype;
        uint boardrev;
-       uint boardvendor;
        u32 boardflags;
        u32 boardflags2;
 };
 
        uint sromrev;
        uint boardtype;
        uint boardrev;
-       uint boardvendor;
        u32 boardflags;
        u32 boardflags2;
-       uint buscorerev;
        uint fast_timer;
        uint slow_timer;
        uint glacial_timer;
 
        uint rsrcs;
 
        /* # resources */
-       rsrcs = (sih->pmucaps & PCAP_RC_MASK) >> PCAP_RC_SHIFT;
+       rsrcs = (ai_get_pmucaps(sih) & PCAP_RC_MASK) >> PCAP_RC_SHIFT;
 
        /* determine min/max rsrc masks */
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
                /* ??? */
 {
        u32 tmp = 0;
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
                if (spuravoid == 1) {
 {
        uint delay = PMU_MAX_TRANSITION_DLY;
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
        case BCM4313_CHIP_ID:
        u32 clock = ALP_CLOCK;
 
        /* bail out with default */
-       if (!(sih->cccaps & CC_CAP_PMU))
+       if (!(ai_get_cccaps(sih) & CC_CAP_PMU))
                return clock;
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
        case BCM4313_CHIP_ID:
        origidx = ai_coreidx(sih);
        cc = ai_setcoreidx(sih, SI_CC_IDX);
 
-       if (sih->pmurev == 1)
+       if (ai_get_pmurev(sih) == 1)
                AND_REG(&cc->pmucontrol, ~PCTL_NOILP_ON_WAIT);
-       else if (sih->pmurev >= 2)
+       else if (ai_get_pmurev(sih) >= 2)
                OR_REG(&cc->pmucontrol, PCTL_NOILP_ON_WAIT);
 
        /* Return to original core */
        origidx = ai_coreidx(sih);
        cc = ai_setcoreidx(sih, SI_CC_IDX);
 
-       switch (sih->chip) {
+       switch (ai_get_chip_id(sih)) {
        case BCM4313_CHIP_ID:
        case BCM43224_CHIP_ID:
        case BCM43225_CHIP_ID:
        uint origidx;
        u32 alp_khz;
 
-       if (sih->pmurev < 10)
+       if (ai_get_pmurev(sih) < 10)
                return 0;
 
        /* Remember original core before switch to chipc */
 
 static u8 __iomem *
 srom_window_address(struct si_pub *sih, u8 __iomem *curmap)
 {
-       if (sih->ccrev < 32)
+       if (ai_get_ccrev(sih) < 32)
                return curmap + PCI_BAR0_SPROM_OFFSET;
-       if (sih->cccaps & CC_CAP_SROM)
+       if (ai_get_cccaps(sih) & CC_CAP_SROM)
                return curmap + PCI_16KB0_CCREGS_OFFSET + CC_SROM_OTP;
 
        return NULL;