drivers/staging/brcm80211/util/hndpmu.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 <typedefs.h>
  18 #include <bcmdefs.h>
  19 #include <osl.h>
  20 #include <linux/string.h>
  21 #include <linuxver.h>
  22 #include <linux/kernel.h>
  23 #include <bcmutils.h>
  24 #include <siutils.h>
  25 #include <bcmdevs.h>
  26 #include <hndsoc.h>
  27 #include <sbchipc.h>
  28 #include <hndpmu.h>
  29 #include "siutils_priv.h"
  30
  31 #define PMU_ERROR(args)
  32
  33 #ifdef BCMDBG
  34 #define PMU_MSG(args)   printf args
  35 #else
  36 #define PMU_MSG(args)
  37 #endif                          /* BCMDBG */
  38
  39 /* To check in verbose debugging messages not intended
  40  * to be on except on private builds.
  41  */
  42 #define PMU_NONE(args)
  43
  44 /* PLL controls/clocks */
  45 static void si_pmu1_pllinit0(si_t *sih, osl_t *osh, chipcregs_t *cc,
  46                              u32 xtal);
  47 static u32 si_pmu1_cpuclk0(si_t *sih, osl_t *osh, chipcregs_t *cc);
  48 static u32 si_pmu1_alpclk0(si_t *sih, osl_t *osh, chipcregs_t *cc);
  49
  50 /* PMU resources */
  51 static bool si_pmu_res_depfltr_bb(si_t *sih);
  52 static bool si_pmu_res_depfltr_ncb(si_t *sih);
  53 static bool si_pmu_res_depfltr_paldo(si_t *sih);
  54 static bool si_pmu_res_depfltr_npaldo(si_t *sih);
  55 static u32 si_pmu_res_deps(si_t *sih, osl_t *osh, chipcregs_t *cc,
  56                               u32 rsrcs, bool all);
  57 static uint si_pmu_res_uptime(si_t *sih, osl_t *osh, chipcregs_t *cc,
  58                               u8 rsrc);
  59 static void si_pmu_res_masks(si_t *sih, u32 * pmin, u32 * pmax);
  60 static void si_pmu_spuravoid_pllupdate(si_t *sih, chipcregs_t *cc,
  61                                        osl_t *osh, u8 spuravoid);
  62
  63 static void si_pmu_set_4330_plldivs(si_t *sih);
  64
  65 /* FVCO frequency */
  66 #define FVCO_880        880000  /* 880MHz */
  67 #define FVCO_1760       1760000 /* 1760MHz */
  68 #define FVCO_1440       1440000 /* 1440MHz */
  69 #define FVCO_960        960000  /* 960MHz */
  70
  71 /* Read/write a chipcontrol reg */
  72 u32 si_pmu_chipcontrol(si_t *sih, uint reg, u32 mask, u32 val)
  73 {
  74         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, chipcontrol_addr), ~0,
  75                    reg);
  76         return si_corereg(sih, SI_CC_IDX,
  77                           offsetof(chipcregs_t, chipcontrol_data), mask, val);
  78 }
  79
  80 /* Read/write a regcontrol reg */
  81 u32 si_pmu_regcontrol(si_t *sih, uint reg, u32 mask, u32 val)
  82 {
  83         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, regcontrol_addr), ~0,
  84                    reg);
  85         return si_corereg(sih, SI_CC_IDX,
  86                           offsetof(chipcregs_t, regcontrol_data), mask, val);
  87 }
  88
  89 /* Read/write a pllcontrol reg */
  90 u32 si_pmu_pllcontrol(si_t *sih, uint reg, u32 mask, u32 val)
  91 {
  92         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, pllcontrol_addr), ~0,
  93                    reg);
  94         return si_corereg(sih, SI_CC_IDX,
  95                           offsetof(chipcregs_t, pllcontrol_data), mask, val);
  96 }
  97
  98 /* PMU PLL update */
  99 void si_pmu_pllupd(si_t *sih)
 100 {
 101         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, pmucontrol),
 102                    PCTL_PLL_PLLCTL_UPD, PCTL_PLL_PLLCTL_UPD);
 103 }
 104
 105 /* Setup switcher voltage */
 106 void
 107 BCMATTACHFN(si_pmu_set_switcher_voltage) (si_t *sih, osl_t *osh,
 108                                           u8 bb_voltage, u8 rf_voltage) {
 109         chipcregs_t *cc;
 110         uint origidx;
 111
 112         ASSERT(sih->cccaps & CC_CAP_PMU);
 113
 114         /* Remember original core before switch to chipc */
 115         origidx = si_coreidx(sih);
 116         cc = si_setcoreidx(sih, SI_CC_IDX);
 117         ASSERT(cc != NULL);
 118
 119         W_REG(osh, &cc->regcontrol_addr, 0x01);
 120         W_REG(osh, &cc->regcontrol_data, (u32) (bb_voltage & 0x1f) << 22);
 121
 122         W_REG(osh, &cc->regcontrol_addr, 0x00);
 123         W_REG(osh, &cc->regcontrol_data, (u32) (rf_voltage & 0x1f) << 14);
 124
 125         /* Return to original core */
 126         si_setcoreidx(sih, origidx);
 127 }
 128
 129 void
 130 BCMATTACHFN(si_pmu_set_ldo_voltage) (si_t *sih, osl_t *osh, u8 ldo,
 131                                      u8 voltage) {
 132         u8 sr_cntl_shift = 0, rc_shift = 0, shift = 0, mask = 0;
 133         u8 addr = 0;
 134
 135         ASSERT(sih->cccaps & CC_CAP_PMU);
 136
 137         switch (CHIPID(sih->chip)) {
 138         case BCM4336_CHIP_ID:
 139                 switch (ldo) {
 140                 case SET_LDO_VOLTAGE_CLDO_PWM:
 141                         addr = 4;
 142                         rc_shift = 1;
 143                         mask = 0xf;
 144                         break;
 145                 case SET_LDO_VOLTAGE_CLDO_BURST:
 146                         addr = 4;
 147                         rc_shift = 5;
 148                         mask = 0xf;
 149                         break;
 150                 case SET_LDO_VOLTAGE_LNLDO1:
 151                         addr = 4;
 152                         rc_shift = 17;
 153                         mask = 0xf;
 154                         break;
 155                 default:
 156                         ASSERT(FALSE);
 157                         return;
 158                 }
 159                 break;
 160         case BCM4330_CHIP_ID:
 161                 switch (ldo) {
 162                 case SET_LDO_VOLTAGE_CBUCK_PWM:
 163                         addr = 3;
 164                         rc_shift = 0;
 165                         mask = 0x1f;
 166                         break;
 167                 default:
 168                         ASSERT(FALSE);
 169                         break;
 170                 }
 171                 break;
 172         default:
 173                 ASSERT(FALSE);
 174                 return;
 175         }
 176
 177         shift = sr_cntl_shift + rc_shift;
 178
 179         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, regcontrol_addr),
 180                    ~0, addr);
 181         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, regcontrol_data),
 182                    mask << shift, (voltage & mask) << shift);
 183 }
 184
 185 /* d11 slow to fast clock transition time in slow clock cycles */
 186 #define D11SCC_SLOW2FAST_TRANSITION     2
 187
 188 u16 BCMINITFN(si_pmu_fast_pwrup_delay) (si_t *sih, osl_t *osh)
 189 {
 190         uint delay = PMU_MAX_TRANSITION_DLY;
 191         chipcregs_t *cc;
 192         uint origidx;
 193 #ifdef BCMDBG
 194         char chn[8];
 195         chn[0] = 0;             /* to suppress compile error */
 196 #endif
 197
 198         ASSERT(sih->cccaps & CC_CAP_PMU);
 199
 200         /* Remember original core before switch to chipc */
 201         origidx = si_coreidx(sih);
 202         cc = si_setcoreidx(sih, SI_CC_IDX);
 203         ASSERT(cc != NULL);
 204
 205         switch (CHIPID(sih->chip)) {
 206         case BCM43224_CHIP_ID:
 207         case BCM43225_CHIP_ID:
 208         case BCM43421_CHIP_ID:
 209         case BCM43235_CHIP_ID:
 210         case BCM43236_CHIP_ID:
 211         case BCM43238_CHIP_ID:
 212         case BCM4331_CHIP_ID:
 213         case BCM6362_CHIP_ID:
 214         case BCM4313_CHIP_ID:
 215                 delay = ISSIM_ENAB(sih) ? 70 : 3700;
 216                 break;
 217         case BCM4329_CHIP_ID:
 218                 if (ISSIM_ENAB(sih))
 219                         delay = 70;
 220                 else {
 221                         u32 ilp = si_ilp_clock(sih);
 222                         delay =
 223                             (si_pmu_res_uptime(sih, osh, cc, RES4329_HT_AVAIL) +
 224                              D11SCC_SLOW2FAST_TRANSITION) * ((1000000 + ilp -
 225                                                               1) / ilp);
 226                         delay = (11 * delay) / 10;
 227                 }
 228                 break;
 229         case BCM4319_CHIP_ID:
 230                 delay = ISSIM_ENAB(sih) ? 70 : 3700;
 231                 break;
 232         case BCM4336_CHIP_ID:
 233                 if (ISSIM_ENAB(sih))
 234                         delay = 70;
 235                 else {
 236                         u32 ilp = si_ilp_clock(sih);
 237                         delay =
 238                             (si_pmu_res_uptime(sih, osh, cc, RES4336_HT_AVAIL) +
 239                              D11SCC_SLOW2FAST_TRANSITION) * ((1000000 + ilp -
 240                                                               1) / ilp);
 241                         delay = (11 * delay) / 10;
 242                 }
 243                 break;
 244         case BCM4330_CHIP_ID:
 245                 if (ISSIM_ENAB(sih))
 246                         delay = 70;
 247                 else {
 248                         u32 ilp = si_ilp_clock(sih);
 249                         delay =
 250                             (si_pmu_res_uptime(sih, osh, cc, RES4330_HT_AVAIL) +
 251                              D11SCC_SLOW2FAST_TRANSITION) * ((1000000 + ilp -
 252                                                               1) / ilp);
 253                         delay = (11 * delay) / 10;
 254                 }
 255                 break;
 256         default:
 257                 break;
 258         }
 259         /* Return to original core */
 260         si_setcoreidx(sih, origidx);
 261
 262         return (u16) delay;
 263 }
 264
 265 u32 BCMATTACHFN(si_pmu_force_ilp) (si_t *sih, osl_t *osh, bool force)
 266 {
 267         chipcregs_t *cc;
 268         uint origidx;
 269         u32 oldpmucontrol;
 270
 271         ASSERT(sih->cccaps & CC_CAP_PMU);
 272
 273         /* Remember original core before switch to chipc */
 274         origidx = si_coreidx(sih);
 275         cc = si_setcoreidx(sih, SI_CC_IDX);
 276         ASSERT(cc != NULL);
 277
 278         oldpmucontrol = R_REG(osh, &cc->pmucontrol);
 279         if (force)
 280                 W_REG(osh, &cc->pmucontrol, oldpmucontrol &
 281                       ~(PCTL_HT_REQ_EN | PCTL_ALP_REQ_EN));
 282         else
 283                 W_REG(osh, &cc->pmucontrol, oldpmucontrol |
 284                       (PCTL_HT_REQ_EN | PCTL_ALP_REQ_EN));
 285
 286         /* Return to original core */
 287         si_setcoreidx(sih, origidx);
 288
 289         return oldpmucontrol;
 290 }
 291
 292 /* Setup resource up/down timers */
 293 typedef struct {
 294         u8 resnum;
 295         u16 updown;
 296 } pmu_res_updown_t;
 297
 298 /* Change resource dependancies masks */
 299 typedef struct {
 300         u32 res_mask;   /* resources (chip specific) */
 301         s8 action;              /* action */
 302         u32 depend_mask;        /* changes to the dependancies mask */
 303          bool(*filter) (si_t *sih);     /* action is taken when filter is NULL or return TRUE */
 304 } pmu_res_depend_t;
 305
 306 /* Resource dependancies mask change action */
 307 #define RES_DEPEND_SET          0       /* Override the dependancies mask */
 308 #define RES_DEPEND_ADD          1       /* Add to the  dependancies mask */
 309 #define RES_DEPEND_REMOVE       -1      /* Remove from the dependancies mask */
 310
 311 static const pmu_res_updown_t BCMATTACHDATA(bcm4328a0_res_updown)[] = {
 312         {
 313         RES4328_EXT_SWITCHER_PWM, 0x0101}, {
 314         RES4328_BB_SWITCHER_PWM, 0x1f01}, {
 315         RES4328_BB_SWITCHER_BURST, 0x010f}, {
 316         RES4328_BB_EXT_SWITCHER_BURST, 0x0101}, {
 317         RES4328_ILP_REQUEST, 0x0202}, {
 318         RES4328_RADIO_SWITCHER_PWM, 0x0f01}, {
 319         RES4328_RADIO_SWITCHER_BURST, 0x0f01}, {
 320         RES4328_ROM_SWITCH, 0x0101}, {
 321         RES4328_PA_REF_LDO, 0x0f01}, {
 322         RES4328_RADIO_LDO, 0x0f01}, {
 323         RES4328_AFE_LDO, 0x0f01}, {
 324         RES4328_PLL_LDO, 0x0f01}, {
 325         RES4328_BG_FILTBYP, 0x0101}, {
 326         RES4328_TX_FILTBYP, 0x0101}, {
 327         RES4328_RX_FILTBYP, 0x0101}, {
 328         RES4328_XTAL_PU, 0x0101}, {
 329         RES4328_XTAL_EN, 0xa001}, {
 330         RES4328_BB_PLL_FILTBYP, 0x0101}, {
 331         RES4328_RF_PLL_FILTBYP, 0x0101}, {
 332         RES4328_BB_PLL_PU, 0x0701}
 333 };
 334
 335 static const pmu_res_depend_t BCMATTACHDATA(bcm4328a0_res_depend)[] = {
 336         /* Adjust ILP request resource not to force ext/BB switchers into burst mode */
 337         {
 338         PMURES_BIT(RES4328_ILP_REQUEST),
 339                     RES_DEPEND_SET,
 340                     PMURES_BIT(RES4328_EXT_SWITCHER_PWM) |
 341                     PMURES_BIT(RES4328_BB_SWITCHER_PWM), NULL}
 342 };
 343
 344 static const pmu_res_updown_t BCMATTACHDATA(bcm4325a0_res_updown_qt)[] = {
 345         {
 346         RES4325_HT_AVAIL, 0x0300}, {
 347         RES4325_BBPLL_PWRSW_PU, 0x0101}, {
 348         RES4325_RFPLL_PWRSW_PU, 0x0101}, {
 349         RES4325_ALP_AVAIL, 0x0100}, {
 350         RES4325_XTAL_PU, 0x1000}, {
 351         RES4325_LNLDO1_PU, 0x0800}, {
 352         RES4325_CLDO_CBUCK_PWM, 0x0101}, {
 353         RES4325_CBUCK_PWM, 0x0803}
 354 };
 355
 356 static const pmu_res_updown_t BCMATTACHDATA(bcm4325a0_res_updown)[] = {
 357         {
 358         RES4325_XTAL_PU, 0x1501}
 359 };
 360
 361 static const pmu_res_depend_t BCMATTACHDATA(bcm4325a0_res_depend)[] = {
 362         /* Adjust OTP PU resource dependencies - remove BB BURST */
 363         {
 364         PMURES_BIT(RES4325_OTP_PU),
 365                     RES_DEPEND_REMOVE,
 366                     PMURES_BIT(RES4325_BUCK_BOOST_BURST), NULL},
 367             /* Adjust ALP/HT Avail resource dependencies - bring up BB along if it is used. */
 368         {
 369         PMURES_BIT(RES4325_ALP_AVAIL) | PMURES_BIT(RES4325_HT_AVAIL),
 370                     RES_DEPEND_ADD,
 371                     PMURES_BIT(RES4325_BUCK_BOOST_BURST) |
 372                     PMURES_BIT(RES4325_BUCK_BOOST_PWM), si_pmu_res_depfltr_bb},
 373             /* Adjust HT Avail resource dependencies - bring up RF switches along with HT. */
 374         {
 375         PMURES_BIT(RES4325_HT_AVAIL),
 376                     RES_DEPEND_ADD,
 377                     PMURES_BIT(RES4325_RX_PWRSW_PU) |
 378                     PMURES_BIT(RES4325_TX_PWRSW_PU) |
 379                     PMURES_BIT(RES4325_LOGEN_PWRSW_PU) |
 380                     PMURES_BIT(RES4325_AFE_PWRSW_PU), NULL},
 381             /* Adjust ALL resource dependencies - remove CBUCK dependancies if it is not used. */
 382         {
 383         PMURES_BIT(RES4325_ILP_REQUEST) |
 384                     PMURES_BIT(RES4325_ABUCK_BURST) |
 385                     PMURES_BIT(RES4325_ABUCK_PWM) |
 386                     PMURES_BIT(RES4325_LNLDO1_PU) |
 387                     PMURES_BIT(RES4325C1_LNLDO2_PU) |
 388                     PMURES_BIT(RES4325_XTAL_PU) |
 389                     PMURES_BIT(RES4325_ALP_AVAIL) |
 390                     PMURES_BIT(RES4325_RX_PWRSW_PU) |
 391                     PMURES_BIT(RES4325_TX_PWRSW_PU) |
 392                     PMURES_BIT(RES4325_RFPLL_PWRSW_PU) |
 393                     PMURES_BIT(RES4325_LOGEN_PWRSW_PU) |
 394                     PMURES_BIT(RES4325_AFE_PWRSW_PU) |
 395                     PMURES_BIT(RES4325_BBPLL_PWRSW_PU) |
 396                     PMURES_BIT(RES4325_HT_AVAIL), RES_DEPEND_REMOVE,
 397                     PMURES_BIT(RES4325B0_CBUCK_LPOM) |
 398                     PMURES_BIT(RES4325B0_CBUCK_BURST) |
 399                     PMURES_BIT(RES4325B0_CBUCK_PWM), si_pmu_res_depfltr_ncb}
 400 };
 401
 402 static const pmu_res_updown_t BCMATTACHDATA(bcm4315a0_res_updown_qt)[] = {
 403         {
 404         RES4315_HT_AVAIL, 0x0101}, {
 405         RES4315_XTAL_PU, 0x0100}, {
 406         RES4315_LNLDO1_PU, 0x0100}, {
 407         RES4315_PALDO_PU, 0x0100}, {
 408         RES4315_CLDO_PU, 0x0100}, {
 409         RES4315_CBUCK_PWM, 0x0100}, {
 410         RES4315_CBUCK_BURST, 0x0100}, {
 411         RES4315_CBUCK_LPOM, 0x0100}
 412 };
 413
 414 static const pmu_res_updown_t BCMATTACHDATA(bcm4315a0_res_updown)[] = {
 415         {
 416         RES4315_XTAL_PU, 0x2501}
 417 };
 418
 419 static const pmu_res_depend_t BCMATTACHDATA(bcm4315a0_res_depend)[] = {
 420         /* Adjust OTP PU resource dependencies - not need PALDO unless write */
 421         {
 422         PMURES_BIT(RES4315_OTP_PU),
 423                     RES_DEPEND_REMOVE,
 424                     PMURES_BIT(RES4315_PALDO_PU), si_pmu_res_depfltr_npaldo},
 425             /* Adjust ALP/HT Avail resource dependencies - bring up PALDO along if it is used. */
 426         {
 427         PMURES_BIT(RES4315_ALP_AVAIL) | PMURES_BIT(RES4315_HT_AVAIL),
 428                     RES_DEPEND_ADD,
 429                     PMURES_BIT(RES4315_PALDO_PU), si_pmu_res_depfltr_paldo},
 430             /* Adjust HT Avail resource dependencies - bring up RF switches along with HT. */
 431         {
 432         PMURES_BIT(RES4315_HT_AVAIL),
 433                     RES_DEPEND_ADD,
 434                     PMURES_BIT(RES4315_RX_PWRSW_PU) |
 435                     PMURES_BIT(RES4315_TX_PWRSW_PU) |
 436                     PMURES_BIT(RES4315_LOGEN_PWRSW_PU) |
 437                     PMURES_BIT(RES4315_AFE_PWRSW_PU), NULL},
 438             /* Adjust ALL resource dependencies - remove CBUCK dependancies if it is not used. */
 439         {
 440         PMURES_BIT(RES4315_CLDO_PU) | PMURES_BIT(RES4315_ILP_REQUEST) |
 441                     PMURES_BIT(RES4315_LNLDO1_PU) |
 442                     PMURES_BIT(RES4315_OTP_PU) |
 443                     PMURES_BIT(RES4315_LNLDO2_PU) |
 444                     PMURES_BIT(RES4315_XTAL_PU) |
 445                     PMURES_BIT(RES4315_ALP_AVAIL) |
 446                     PMURES_BIT(RES4315_RX_PWRSW_PU) |
 447                     PMURES_BIT(RES4315_TX_PWRSW_PU) |
 448                     PMURES_BIT(RES4315_RFPLL_PWRSW_PU) |
 449                     PMURES_BIT(RES4315_LOGEN_PWRSW_PU) |
 450                     PMURES_BIT(RES4315_AFE_PWRSW_PU) |
 451                     PMURES_BIT(RES4315_BBPLL_PWRSW_PU) |
 452                     PMURES_BIT(RES4315_HT_AVAIL), RES_DEPEND_REMOVE,
 453                     PMURES_BIT(RES4315_CBUCK_LPOM) |
 454                     PMURES_BIT(RES4315_CBUCK_BURST) |
 455                     PMURES_BIT(RES4315_CBUCK_PWM), si_pmu_res_depfltr_ncb}
 456 };
 457
 458         /* 4329 specific. needs to come back this issue later */
 459 static const pmu_res_updown_t BCMINITDATA(bcm4329_res_updown)[] = {
 460         {
 461         RES4329_XTAL_PU, 0x1501}
 462 };
 463
 464 static const pmu_res_depend_t BCMINITDATA(bcm4329_res_depend)[] = {
 465         /* Adjust HT Avail resource dependencies */
 466         {
 467         PMURES_BIT(RES4329_HT_AVAIL),
 468                     RES_DEPEND_ADD,
 469                     PMURES_BIT(RES4329_CBUCK_LPOM) |
 470                     PMURES_BIT(RES4329_CBUCK_BURST) |
 471                     PMURES_BIT(RES4329_CBUCK_PWM) |
 472                     PMURES_BIT(RES4329_CLDO_PU) |
 473                     PMURES_BIT(RES4329_PALDO_PU) |
 474                     PMURES_BIT(RES4329_LNLDO1_PU) |
 475                     PMURES_BIT(RES4329_XTAL_PU) |
 476                     PMURES_BIT(RES4329_ALP_AVAIL) |
 477                     PMURES_BIT(RES4329_RX_PWRSW_PU) |
 478                     PMURES_BIT(RES4329_TX_PWRSW_PU) |
 479                     PMURES_BIT(RES4329_RFPLL_PWRSW_PU) |
 480                     PMURES_BIT(RES4329_LOGEN_PWRSW_PU) |
 481                     PMURES_BIT(RES4329_AFE_PWRSW_PU) |
 482                     PMURES_BIT(RES4329_BBPLL_PWRSW_PU), NULL}
 483 };
 484
 485 static const pmu_res_updown_t BCMATTACHDATA(bcm4319a0_res_updown_qt)[] = {
 486         {
 487         RES4319_HT_AVAIL, 0x0101}, {
 488         RES4319_XTAL_PU, 0x0100}, {
 489         RES4319_LNLDO1_PU, 0x0100}, {
 490         RES4319_PALDO_PU, 0x0100}, {
 491         RES4319_CLDO_PU, 0x0100}, {
 492         RES4319_CBUCK_PWM, 0x0100}, {
 493         RES4319_CBUCK_BURST, 0x0100}, {
 494         RES4319_CBUCK_LPOM, 0x0100}
 495 };
 496
 497 static const pmu_res_updown_t BCMATTACHDATA(bcm4319a0_res_updown)[] = {
 498         {
 499         RES4319_XTAL_PU, 0x3f01}
 500 };
 501
 502 static const pmu_res_depend_t BCMATTACHDATA(bcm4319a0_res_depend)[] = {
 503         /* Adjust OTP PU resource dependencies - not need PALDO unless write */
 504         {
 505         PMURES_BIT(RES4319_OTP_PU),
 506                     RES_DEPEND_REMOVE,
 507                     PMURES_BIT(RES4319_PALDO_PU), si_pmu_res_depfltr_npaldo},
 508             /* Adjust HT Avail resource dependencies - bring up PALDO along if it is used. */
 509         {
 510         PMURES_BIT(RES4319_HT_AVAIL),
 511                     RES_DEPEND_ADD,
 512                     PMURES_BIT(RES4319_PALDO_PU), si_pmu_res_depfltr_paldo},
 513             /* Adjust HT Avail resource dependencies - bring up RF switches along with HT. */
 514         {
 515         PMURES_BIT(RES4319_HT_AVAIL),
 516                     RES_DEPEND_ADD,
 517                     PMURES_BIT(RES4319_RX_PWRSW_PU) |
 518                     PMURES_BIT(RES4319_TX_PWRSW_PU) |
 519                     PMURES_BIT(RES4319_RFPLL_PWRSW_PU) |
 520                     PMURES_BIT(RES4319_LOGEN_PWRSW_PU) |
 521                     PMURES_BIT(RES4319_AFE_PWRSW_PU), NULL}
 522 };
 523
 524 static const pmu_res_updown_t BCMATTACHDATA(bcm4336a0_res_updown_qt)[] = {
 525         {
 526         RES4336_HT_AVAIL, 0x0101}, {
 527         RES4336_XTAL_PU, 0x0100}, {
 528         RES4336_CLDO_PU, 0x0100}, {
 529         RES4336_CBUCK_PWM, 0x0100}, {
 530         RES4336_CBUCK_BURST, 0x0100}, {
 531         RES4336_CBUCK_LPOM, 0x0100}
 532 };
 533
 534 static const pmu_res_updown_t BCMATTACHDATA(bcm4336a0_res_updown)[] = {
 535         {
 536         RES4336_HT_AVAIL, 0x0D01}
 537 };
 538
 539 static const pmu_res_depend_t BCMATTACHDATA(bcm4336a0_res_depend)[] = {
 540         /* Just a dummy entry for now */
 541         {
 542         PMURES_BIT(RES4336_RSVD), RES_DEPEND_ADD, 0, NULL}
 543 };
 544
 545 static const pmu_res_updown_t BCMATTACHDATA(bcm4330a0_res_updown_qt)[] = {
 546         {
 547         RES4330_HT_AVAIL, 0x0101}, {
 548         RES4330_XTAL_PU, 0x0100}, {
 549         RES4330_CLDO_PU, 0x0100}, {
 550         RES4330_CBUCK_PWM, 0x0100}, {
 551         RES4330_CBUCK_BURST, 0x0100}, {
 552         RES4330_CBUCK_LPOM, 0x0100}
 553 };
 554
 555 static const pmu_res_updown_t BCMATTACHDATA(bcm4330a0_res_updown)[] = {
 556         {
 557         RES4330_HT_AVAIL, 0x0e02}
 558 };
 559
 560 static const pmu_res_depend_t BCMATTACHDATA(bcm4330a0_res_depend)[] = {
 561         /* Just a dummy entry for now */
 562         {
 563         PMURES_BIT(RES4330_HT_AVAIL), RES_DEPEND_ADD, 0, NULL}
 564 };
 565
 566 /* TRUE if the power topology uses the buck boost to provide 3.3V to VDDIO_RF and WLAN PA */
 567 static bool BCMATTACHFN(si_pmu_res_depfltr_bb) (si_t *sih)
 568 {
 569         return (sih->boardflags & BFL_BUCKBOOST) != 0;
 570 }
 571
 572 /* TRUE if the power topology doesn't use the cbuck. Key on chiprev also if the chip is BCM4325. */
 573 static bool BCMATTACHFN(si_pmu_res_depfltr_ncb) (si_t *sih)
 574 {
 575
 576         return (sih->boardflags & BFL_NOCBUCK) != 0;
 577 }
 578
 579 /* TRUE if the power topology uses the PALDO */
 580 static bool BCMATTACHFN(si_pmu_res_depfltr_paldo) (si_t *sih)
 581 {
 582         return (sih->boardflags & BFL_PALDO) != 0;
 583 }
 584
 585 /* TRUE if the power topology doesn't use the PALDO */
 586 static bool BCMATTACHFN(si_pmu_res_depfltr_npaldo) (si_t *sih)
 587 {
 588         return (sih->boardflags & BFL_PALDO) == 0;
 589 }
 590
 591 #define BCM94325_BBVDDIOSD_BOARDS(sih) (sih->boardtype == BCM94325DEVBU_BOARD || \
 592                                         sih->boardtype == BCM94325BGABU_BOARD)
 593
 594 /* Determine min/max rsrc masks. Value 0 leaves hardware at default. */
 595 static void si_pmu_res_masks(si_t *sih, u32 * pmin, u32 * pmax)
 596 {
 597         u32 min_mask = 0, max_mask = 0;
 598         uint rsrcs;
 599         char *val;
 600
 601         /* # resources */
 602         rsrcs = (sih->pmucaps & PCAP_RC_MASK) >> PCAP_RC_SHIFT;
 603
 604         /* determine min/max rsrc masks */
 605         switch (CHIPID(sih->chip)) {
 606         case BCM43224_CHIP_ID:
 607         case BCM43225_CHIP_ID:
 608         case BCM43421_CHIP_ID:
 609         case BCM43235_CHIP_ID:
 610         case BCM43236_CHIP_ID:
 611         case BCM43238_CHIP_ID:
 612         case BCM4331_CHIP_ID:
 613         case BCM6362_CHIP_ID:
 614                 /* ??? */
 615                 break;
 616
 617         case BCM4329_CHIP_ID:
 618                 /* 4329 spedific issue. Needs to come back this issue later */
 619                 /* Down to save the power. */
 620                 min_mask =
 621                     PMURES_BIT(RES4329_CBUCK_LPOM) |
 622                     PMURES_BIT(RES4329_CLDO_PU);
 623                 /* Allow (but don't require) PLL to turn on */
 624                 max_mask = 0x3ff63e;
 625                 break;
 626         case BCM4319_CHIP_ID:
 627                 /* We only need a few resources to be kept on all the time */
 628                 min_mask = PMURES_BIT(RES4319_CBUCK_LPOM) |
 629                     PMURES_BIT(RES4319_CLDO_PU);
 630
 631                 /* Allow everything else to be turned on upon requests */
 632                 max_mask = ~(~0 << rsrcs);
 633                 break;
 634         case BCM4336_CHIP_ID:
 635                 /* Down to save the power. */
 636                 min_mask =
 637                     PMURES_BIT(RES4336_CBUCK_LPOM) | PMURES_BIT(RES4336_CLDO_PU)
 638                     | PMURES_BIT(RES4336_LDO3P3_PU) | PMURES_BIT(RES4336_OTP_PU)
 639                     | PMURES_BIT(RES4336_DIS_INT_RESET_PD);
 640                 /* Allow (but don't require) PLL to turn on */
 641                 max_mask = 0x1ffffff;
 642                 break;
 643
 644         case BCM4330_CHIP_ID:
 645                 /* Down to save the power. */
 646                 min_mask =
 647                     PMURES_BIT(RES4330_CBUCK_LPOM) | PMURES_BIT(RES4330_CLDO_PU)
 648                     | PMURES_BIT(RES4330_DIS_INT_RESET_PD) |
 649                     PMURES_BIT(RES4330_LDO3P3_PU) | PMURES_BIT(RES4330_OTP_PU);
 650                 /* Allow (but don't require) PLL to turn on */
 651                 max_mask = 0xfffffff;
 652                 break;
 653
 654         case BCM4313_CHIP_ID:
 655                 min_mask = PMURES_BIT(RES4313_BB_PU_RSRC) |
 656                     PMURES_BIT(RES4313_XTAL_PU_RSRC) |
 657                     PMURES_BIT(RES4313_ALP_AVAIL_RSRC) |
 658                     PMURES_BIT(RES4313_BB_PLL_PWRSW_RSRC);
 659                 max_mask = 0xffff;
 660                 break;
 661         default:
 662                 break;
 663         }
 664
 665         /* Apply nvram override to min mask */
 666         val = getvar(NULL, "rmin");
 667         if (val != NULL) {
 668                 PMU_MSG(("Applying rmin=%s to min_mask\n", val));
 669                 min_mask = (u32) simple_strtoul(val, NULL, 0);
 670         }
 671         /* Apply nvram override to max mask */
 672         val = getvar(NULL, "rmax");
 673         if (val != NULL) {
 674                 PMU_MSG(("Applying rmax=%s to max_mask\n", val));
 675                 max_mask = (u32) simple_strtoul(val, NULL, 0);
 676         }
 677
 678         *pmin = min_mask;
 679         *pmax = max_mask;
 680 }
 681
 682 /* initialize PMU resources */
 683 void BCMATTACHFN(si_pmu_res_init) (si_t *sih, osl_t *osh)
 684 {
 685         chipcregs_t *cc;
 686         uint origidx;
 687         const pmu_res_updown_t *pmu_res_updown_table = NULL;
 688         uint pmu_res_updown_table_sz = 0;
 689         const pmu_res_depend_t *pmu_res_depend_table = NULL;
 690         uint pmu_res_depend_table_sz = 0;
 691         u32 min_mask = 0, max_mask = 0;
 692         char name[8], *val;
 693         uint i, rsrcs;
 694
 695         ASSERT(sih->cccaps & CC_CAP_PMU);
 696
 697         /* Remember original core before switch to chipc */
 698         origidx = si_coreidx(sih);
 699         cc = si_setcoreidx(sih, SI_CC_IDX);
 700         ASSERT(cc != NULL);
 701
 702         switch (CHIPID(sih->chip)) {
 703         case BCM4329_CHIP_ID:
 704                 /* Optimize resources up/down timers */
 705                 if (ISSIM_ENAB(sih)) {
 706                         pmu_res_updown_table = NULL;
 707                         pmu_res_updown_table_sz = 0;
 708                 } else {
 709                         pmu_res_updown_table = bcm4329_res_updown;
 710                         pmu_res_updown_table_sz = ARRAY_SIZE(bcm4329_res_updown);
 711                 }
 712                 /* Optimize resources dependencies */
 713                 pmu_res_depend_table = bcm4329_res_depend;
 714                 pmu_res_depend_table_sz = ARRAY_SIZE(bcm4329_res_depend);
 715                 break;
 716
 717         case BCM4319_CHIP_ID:
 718                 /* Optimize resources up/down timers */
 719                 if (ISSIM_ENAB(sih)) {
 720                         pmu_res_updown_table = bcm4319a0_res_updown_qt;
 721                         pmu_res_updown_table_sz =
 722                             ARRAY_SIZE(bcm4319a0_res_updown_qt);
 723                 } else {
 724                         pmu_res_updown_table = bcm4319a0_res_updown;
 725                         pmu_res_updown_table_sz =
 726                             ARRAY_SIZE(bcm4319a0_res_updown);
 727                 }
 728                 /* Optimize resources dependancies masks */
 729                 pmu_res_depend_table = bcm4319a0_res_depend;
 730                 pmu_res_depend_table_sz = ARRAY_SIZE(bcm4319a0_res_depend);
 731                 break;
 732
 733         case BCM4336_CHIP_ID:
 734                 /* Optimize resources up/down timers */
 735                 if (ISSIM_ENAB(sih)) {
 736                         pmu_res_updown_table = bcm4336a0_res_updown_qt;
 737                         pmu_res_updown_table_sz =
 738                             ARRAY_SIZE(bcm4336a0_res_updown_qt);
 739                 } else {
 740                         pmu_res_updown_table = bcm4336a0_res_updown;
 741                         pmu_res_updown_table_sz =
 742                             ARRAY_SIZE(bcm4336a0_res_updown);
 743                 }
 744                 /* Optimize resources dependancies masks */
 745                 pmu_res_depend_table = bcm4336a0_res_depend;
 746                 pmu_res_depend_table_sz = ARRAY_SIZE(bcm4336a0_res_depend);
 747                 break;
 748
 749         case BCM4330_CHIP_ID:
 750                 /* Optimize resources up/down timers */
 751                 if (ISSIM_ENAB(sih)) {
 752                         pmu_res_updown_table = bcm4330a0_res_updown_qt;
 753                         pmu_res_updown_table_sz =
 754                             ARRAY_SIZE(bcm4330a0_res_updown_qt);
 755                 } else {
 756                         pmu_res_updown_table = bcm4330a0_res_updown;
 757                         pmu_res_updown_table_sz =
 758                             ARRAY_SIZE(bcm4330a0_res_updown);
 759                 }
 760                 /* Optimize resources dependancies masks */
 761                 pmu_res_depend_table = bcm4330a0_res_depend;
 762                 pmu_res_depend_table_sz = ARRAY_SIZE(bcm4330a0_res_depend);
 763                 break;
 764
 765         default:
 766                 break;
 767         }
 768
 769         /* # resources */
 770         rsrcs = (sih->pmucaps & PCAP_RC_MASK) >> PCAP_RC_SHIFT;
 771
 772         /* Program up/down timers */
 773         while (pmu_res_updown_table_sz--) {
 774                 ASSERT(pmu_res_updown_table != NULL);
 775                 PMU_MSG(("Changing rsrc %d res_updn_timer to 0x%x\n",
 776                          pmu_res_updown_table[pmu_res_updown_table_sz].resnum,
 777                          pmu_res_updown_table[pmu_res_updown_table_sz].updown));
 778                 W_REG(osh, &cc->res_table_sel,
 779                       pmu_res_updown_table[pmu_res_updown_table_sz].resnum);
 780                 W_REG(osh, &cc->res_updn_timer,
 781                       pmu_res_updown_table[pmu_res_updown_table_sz].updown);
 782         }
 783         /* Apply nvram overrides to up/down timers */
 784         for (i = 0; i < rsrcs; i++) {
 785                 snprintf(name, sizeof(name), "r%dt", i);
 786                 val = getvar(NULL, name);
 787                 if (val == NULL)
 788                         continue;
 789                 PMU_MSG(("Applying %s=%s to rsrc %d res_updn_timer\n", name,
 790                          val, i));
 791                 W_REG(osh, &cc->res_table_sel, (u32) i);
 792                 W_REG(osh, &cc->res_updn_timer,
 793                       (u32) simple_strtoul(val, NULL, 0));
 794         }
 795
 796         /* Program resource dependencies table */
 797         while (pmu_res_depend_table_sz--) {
 798                 ASSERT(pmu_res_depend_table != NULL);
 799                 if (pmu_res_depend_table[pmu_res_depend_table_sz].filter != NULL
 800                     && !(pmu_res_depend_table[pmu_res_depend_table_sz].
 801                          filter) (sih))
 802                         continue;
 803                 for (i = 0; i < rsrcs; i++) {
 804                         if ((pmu_res_depend_table[pmu_res_depend_table_sz].
 805                              res_mask & PMURES_BIT(i)) == 0)
 806                                 continue;
 807                         W_REG(osh, &cc->res_table_sel, i);
 808                         switch (pmu_res_depend_table[pmu_res_depend_table_sz].
 809                                 action) {
 810                         case RES_DEPEND_SET:
 811                                 PMU_MSG(("Changing rsrc %d res_dep_mask to 0x%x\n", i, pmu_res_depend_table[pmu_res_depend_table_sz].depend_mask));
 812                                 W_REG(osh, &cc->res_dep_mask,
 813                                       pmu_res_depend_table
 814                                       [pmu_res_depend_table_sz].depend_mask);
 815                                 break;
 816                         case RES_DEPEND_ADD:
 817                                 PMU_MSG(("Adding 0x%x to rsrc %d res_dep_mask\n", pmu_res_depend_table[pmu_res_depend_table_sz].depend_mask, i));
 818                                 OR_REG(osh, &cc->res_dep_mask,
 819                                        pmu_res_depend_table
 820                                        [pmu_res_depend_table_sz].depend_mask);
 821                                 break;
 822                         case RES_DEPEND_REMOVE:
 823                                 PMU_MSG(("Removing 0x%x from rsrc %d res_dep_mask\n", pmu_res_depend_table[pmu_res_depend_table_sz].depend_mask, i));
 824                                 AND_REG(osh, &cc->res_dep_mask,
 825                                         ~pmu_res_depend_table
 826                                         [pmu_res_depend_table_sz].depend_mask);
 827                                 break;
 828                         default:
 829                                 ASSERT(0);
 830                                 break;
 831                         }
 832                 }
 833         }
 834         /* Apply nvram overrides to dependancies masks */
 835         for (i = 0; i < rsrcs; i++) {
 836                 snprintf(name, sizeof(name), "r%dd", i);
 837                 val = getvar(NULL, name);
 838                 if (val == NULL)
 839                         continue;
 840                 PMU_MSG(("Applying %s=%s to rsrc %d res_dep_mask\n", name, val,
 841                          i));
 842                 W_REG(osh, &cc->res_table_sel, (u32) i);
 843                 W_REG(osh, &cc->res_dep_mask,
 844                       (u32) simple_strtoul(val, NULL, 0));
 845         }
 846
 847         /* Determine min/max rsrc masks */
 848         si_pmu_res_masks(sih, &min_mask, &max_mask);
 849
 850         /* It is required to program max_mask first and then min_mask */
 851
 852         /* Program max resource mask */
 853
 854         if (max_mask) {
 855                 PMU_MSG(("Changing max_res_mask to 0x%x\n", max_mask));
 856                 W_REG(osh, &cc->max_res_mask, max_mask);
 857         }
 858
 859         /* Program min resource mask */
 860
 861         if (min_mask) {
 862                 PMU_MSG(("Changing min_res_mask to 0x%x\n", min_mask));
 863                 W_REG(osh, &cc->min_res_mask, min_mask);
 864         }
 865
 866         /* Add some delay; allow resources to come up and settle. */
 867         OSL_DELAY(2000);
 868
 869         /* Return to original core */
 870         si_setcoreidx(sih, origidx);
 871 }
 872
 873 /* setup pll and query clock speed */
 874 typedef struct {
 875         u16 freq;
 876         u8 xf;
 877         u8 wbint;
 878         u32 wbfrac;
 879 } pmu0_xtaltab0_t;
 880
 881 /* the following table is based on 880Mhz fvco */
 882 static const pmu0_xtaltab0_t BCMINITDATA(pmu0_xtaltab0)[] = {
 883         {
 884         12000, 1, 73, 349525}, {
 885         13000, 2, 67, 725937}, {
 886         14400, 3, 61, 116508}, {
 887         15360, 4, 57, 305834}, {
 888         16200, 5, 54, 336579}, {
 889         16800, 6, 52, 399457}, {
 890         19200, 7, 45, 873813}, {
 891         19800, 8, 44, 466033}, {
 892         20000, 9, 44, 0}, {
 893         25000, 10, 70, 419430}, {
 894         26000, 11, 67, 725937}, {
 895         30000, 12, 58, 699050}, {
 896         38400, 13, 45, 873813}, {
 897         40000, 14, 45, 0}, {
 898         0, 0, 0, 0}
 899 };
 900
 901 #define PMU0_XTAL0_DEFAULT      8
 902
 903 /* setup pll and query clock speed */
 904 typedef struct {
 905         u16 fref;
 906         u8 xf;
 907         u8 p1div;
 908         u8 p2div;
 909         u8 ndiv_int;
 910         u32 ndiv_frac;
 911 } pmu1_xtaltab0_t;
 912
 913 static const pmu1_xtaltab0_t BCMINITDATA(pmu1_xtaltab0_880_4329)[] = {
 914         {
 915         12000, 1, 3, 22, 0x9, 0xFFFFEF}, {
 916         13000, 2, 1, 6, 0xb, 0x483483}, {
 917         14400, 3, 1, 10, 0xa, 0x1C71C7}, {
 918         15360, 4, 1, 5, 0xb, 0x755555}, {
 919         16200, 5, 1, 10, 0x5, 0x6E9E06}, {
 920         16800, 6, 1, 10, 0x5, 0x3Cf3Cf}, {
 921         19200, 7, 1, 4, 0xb, 0x755555}, {
 922         19800, 8, 1, 11, 0x4, 0xA57EB}, {
 923         20000, 9, 1, 11, 0x4, 0x0}, {
 924         24000, 10, 3, 11, 0xa, 0x0}, {
 925         25000, 11, 5, 16, 0xb, 0x0}, {
 926         26000, 12, 1, 1, 0x21, 0xD89D89}, {
 927         30000, 13, 3, 8, 0xb, 0x0}, {
 928         37400, 14, 3, 1, 0x46, 0x969696}, {
 929         38400, 15, 1, 1, 0x16, 0xEAAAAA}, {
 930         40000, 16, 1, 2, 0xb, 0}, {
 931         0, 0, 0, 0, 0, 0}
 932 };
 933
 934 /* the following table is based on 880Mhz fvco */
 935 static const pmu1_xtaltab0_t BCMINITDATA(pmu1_xtaltab0_880)[] = {
 936         {
 937         12000, 1, 3, 22, 0x9, 0xFFFFEF}, {
 938         13000, 2, 1, 6, 0xb, 0x483483}, {
 939         14400, 3, 1, 10, 0xa, 0x1C71C7}, {
 940         15360, 4, 1, 5, 0xb, 0x755555}, {
 941         16200, 5, 1, 10, 0x5, 0x6E9E06}, {
 942         16800, 6, 1, 10, 0x5, 0x3Cf3Cf}, {
 943         19200, 7, 1, 4, 0xb, 0x755555}, {
 944         19800, 8, 1, 11, 0x4, 0xA57EB}, {
 945         20000, 9, 1, 11, 0x4, 0x0}, {
 946         24000, 10, 3, 11, 0xa, 0x0}, {
 947         25000, 11, 5, 16, 0xb, 0x0}, {
 948         26000, 12, 1, 2, 0x10, 0xEC4EC4}, {
 949         30000, 13, 3, 8, 0xb, 0x0}, {
 950         33600, 14, 1, 2, 0xd, 0x186186}, {
 951         38400, 15, 1, 2, 0xb, 0x755555}, {
 952         40000, 16, 1, 2, 0xb, 0}, {
 953         0, 0, 0, 0, 0, 0}
 954 };
 955
 956 #define PMU1_XTALTAB0_880_12000K        0
 957 #define PMU1_XTALTAB0_880_13000K        1
 958 #define PMU1_XTALTAB0_880_14400K        2
 959 #define PMU1_XTALTAB0_880_15360K        3
 960 #define PMU1_XTALTAB0_880_16200K        4
 961 #define PMU1_XTALTAB0_880_16800K        5
 962 #define PMU1_XTALTAB0_880_19200K        6
 963 #define PMU1_XTALTAB0_880_19800K        7
 964 #define PMU1_XTALTAB0_880_20000K        8
 965 #define PMU1_XTALTAB0_880_24000K        9
 966 #define PMU1_XTALTAB0_880_25000K        10
 967 #define PMU1_XTALTAB0_880_26000K        11
 968 #define PMU1_XTALTAB0_880_30000K        12
 969 #define PMU1_XTALTAB0_880_37400K        13
 970 #define PMU1_XTALTAB0_880_38400K        14
 971 #define PMU1_XTALTAB0_880_40000K        15
 972
 973 /* the following table is based on 1760Mhz fvco */
 974 static const pmu1_xtaltab0_t BCMINITDATA(pmu1_xtaltab0_1760)[] = {
 975         {
 976         12000, 1, 3, 44, 0x9, 0xFFFFEF}, {
 977         13000, 2, 1, 12, 0xb, 0x483483}, {
 978         14400, 3, 1, 20, 0xa, 0x1C71C7}, {
 979         15360, 4, 1, 10, 0xb, 0x755555}, {
 980         16200, 5, 1, 20, 0x5, 0x6E9E06}, {
 981         16800, 6, 1, 20, 0x5, 0x3Cf3Cf}, {
 982         19200, 7, 1, 18, 0x5, 0x17B425}, {
 983         19800, 8, 1, 22, 0x4, 0xA57EB}, {
 984         20000, 9, 1, 22, 0x4, 0x0}, {
 985         24000, 10, 3, 22, 0xa, 0x0}, {
 986         25000, 11, 5, 32, 0xb, 0x0}, {
 987         26000, 12, 1, 4, 0x10, 0xEC4EC4}, {
 988         30000, 13, 3, 16, 0xb, 0x0}, {
 989         38400, 14, 1, 10, 0x4, 0x955555}, {
 990         40000, 15, 1, 4, 0xb, 0}, {
 991         0, 0, 0, 0, 0, 0}
 992 };
 993
 994 /* table index */
 995 #define PMU1_XTALTAB0_1760_12000K       0
 996 #define PMU1_XTALTAB0_1760_13000K       1
 997 #define PMU1_XTALTAB0_1760_14400K       2
 998 #define PMU1_XTALTAB0_1760_15360K       3
 999 #define PMU1_XTALTAB0_1760_16200K       4
1000 #define PMU1_XTALTAB0_1760_16800K       5
1001 #define PMU1_XTALTAB0_1760_19200K       6
1002 #define PMU1_XTALTAB0_1760_19800K       7
1003 #define PMU1_XTALTAB0_1760_20000K       8
1004 #define PMU1_XTALTAB0_1760_24000K       9
1005 #define PMU1_XTALTAB0_1760_25000K       10
1006 #define PMU1_XTALTAB0_1760_26000K       11
1007 #define PMU1_XTALTAB0_1760_30000K       12
1008 #define PMU1_XTALTAB0_1760_38400K       13
1009 #define PMU1_XTALTAB0_1760_40000K       14
1010
1011 /* the following table is based on 1440Mhz fvco */
1012 static const pmu1_xtaltab0_t BCMINITDATA(pmu1_xtaltab0_1440)[] = {
1013         {
1014         12000, 1, 1, 1, 0x78, 0x0}, {
1015         13000, 2, 1, 1, 0x6E, 0xC4EC4E}, {
1016         14400, 3, 1, 1, 0x64, 0x0}, {
1017         15360, 4, 1, 1, 0x5D, 0xC00000}, {
1018         16200, 5, 1, 1, 0x58, 0xE38E38}, {
1019         16800, 6, 1, 1, 0x55, 0xB6DB6D}, {
1020         19200, 7, 1, 1, 0x4B, 0}, {
1021         19800, 8, 1, 1, 0x48, 0xBA2E8B}, {
1022         20000, 9, 1, 1, 0x48, 0x0}, {
1023         25000, 10, 1, 1, 0x39, 0x999999}, {
1024         26000, 11, 1, 1, 0x37, 0x627627}, {
1025         30000, 12, 1, 1, 0x30, 0x0}, {
1026         37400, 13, 2, 1, 0x4D, 0x15E76}, {
1027         38400, 13, 2, 1, 0x4B, 0x0}, {
1028         40000, 14, 2, 1, 0x48, 0x0}, {
1029         48000, 15, 2, 1, 0x3c, 0x0}, {
1030         0, 0, 0, 0, 0, 0}
1031 };
1032
1033 /* table index */
1034 #define PMU1_XTALTAB0_1440_12000K       0
1035 #define PMU1_XTALTAB0_1440_13000K       1
1036 #define PMU1_XTALTAB0_1440_14400K       2
1037 #define PMU1_XTALTAB0_1440_15360K       3
1038 #define PMU1_XTALTAB0_1440_16200K       4
1039 #define PMU1_XTALTAB0_1440_16800K       5
1040 #define PMU1_XTALTAB0_1440_19200K       6
1041 #define PMU1_XTALTAB0_1440_19800K       7
1042 #define PMU1_XTALTAB0_1440_20000K       8
1043 #define PMU1_XTALTAB0_1440_25000K       9
1044 #define PMU1_XTALTAB0_1440_26000K       10
1045 #define PMU1_XTALTAB0_1440_30000K       11
1046 #define PMU1_XTALTAB0_1440_37400K       12
1047 #define PMU1_XTALTAB0_1440_38400K       13
1048 #define PMU1_XTALTAB0_1440_40000K       14
1049 #define PMU1_XTALTAB0_1440_48000K       15
1050
1051 #define XTAL_FREQ_24000MHZ              24000
1052 #define XTAL_FREQ_30000MHZ              30000
1053 #define XTAL_FREQ_37400MHZ              37400
1054 #define XTAL_FREQ_48000MHZ              48000
1055
1056 static const pmu1_xtaltab0_t BCMINITDATA(pmu1_xtaltab0_960)[] = {
1057         {
1058         12000, 1, 1, 1, 0x50, 0x0}, {
1059         13000, 2, 1, 1, 0x49, 0xD89D89}, {
1060         14400, 3, 1, 1, 0x42, 0xAAAAAA}, {
1061         15360, 4, 1, 1, 0x3E, 0x800000}, {
1062         16200, 5, 1, 1, 0x39, 0x425ED0}, {
1063         16800, 6, 1, 1, 0x39, 0x249249}, {
1064         19200, 7, 1, 1, 0x32, 0x0}, {
1065         19800, 8, 1, 1, 0x30, 0x7C1F07}, {
1066         20000, 9, 1, 1, 0x30, 0x0}, {
1067         25000, 10, 1, 1, 0x26, 0x666666}, {
1068         26000, 11, 1, 1, 0x24, 0xEC4EC4}, {
1069         30000, 12, 1, 1, 0x20, 0x0}, {
1070         37400, 13, 2, 1, 0x33, 0x563EF9}, {
1071         38400, 14, 2, 1, 0x32, 0x0}, {
1072         40000, 15, 2, 1, 0x30, 0x0}, {
1073         48000, 16, 2, 1, 0x28, 0x0}, {
1074         0, 0, 0, 0, 0, 0}
1075 };
1076
1077 /* table index */
1078 #define PMU1_XTALTAB0_960_12000K        0
1079 #define PMU1_XTALTAB0_960_13000K        1
1080 #define PMU1_XTALTAB0_960_14400K        2
1081 #define PMU1_XTALTAB0_960_15360K        3
1082 #define PMU1_XTALTAB0_960_16200K        4
1083 #define PMU1_XTALTAB0_960_16800K        5
1084 #define PMU1_XTALTAB0_960_19200K        6
1085 #define PMU1_XTALTAB0_960_19800K        7
1086 #define PMU1_XTALTAB0_960_20000K        8
1087 #define PMU1_XTALTAB0_960_25000K        9
1088 #define PMU1_XTALTAB0_960_26000K        10
1089 #define PMU1_XTALTAB0_960_30000K        11
1090 #define PMU1_XTALTAB0_960_37400K        12
1091 #define PMU1_XTALTAB0_960_38400K        13
1092 #define PMU1_XTALTAB0_960_40000K        14
1093 #define PMU1_XTALTAB0_960_48000K        15
1094
1095 /* select xtal table for each chip */
1096 static const pmu1_xtaltab0_t *BCMINITFN(si_pmu1_xtaltab0) (si_t *sih)
1097 {
1098 #ifdef BCMDBG
1099         char chn[8];
1100 #endif
1101         switch (CHIPID(sih->chip)) {
1102         case BCM4329_CHIP_ID:
1103                 return pmu1_xtaltab0_880_4329;
1104         case BCM4319_CHIP_ID:
1105                 return pmu1_xtaltab0_1440;
1106         case BCM4336_CHIP_ID:
1107                 return pmu1_xtaltab0_960;
1108         case BCM4330_CHIP_ID:
1109                 if (CST4330_CHIPMODE_SDIOD(sih->chipst))
1110                         return pmu1_xtaltab0_960;
1111                 else
1112                         return pmu1_xtaltab0_1440;
1113         default:
1114                 PMU_MSG(("si_pmu1_xtaltab0: Unknown chipid %s\n",
1115                          bcm_chipname(sih->chip, chn, 8)));
1116                 break;
1117         }
1118         ASSERT(0);
1119         return NULL;
1120 }
1121
1122 /* select default xtal frequency for each chip */
1123 static const pmu1_xtaltab0_t *BCMINITFN(si_pmu1_xtaldef0) (si_t *sih)
1124 {
1125 #ifdef BCMDBG
1126         char chn[8];
1127 #endif
1128
1129         switch (CHIPID(sih->chip)) {
1130         case BCM4329_CHIP_ID:
1131                 /* Default to 38400Khz */
1132                 return &pmu1_xtaltab0_880_4329[PMU1_XTALTAB0_880_38400K];
1133         case BCM4319_CHIP_ID:
1134                 /* Default to 30000Khz */
1135                 return &pmu1_xtaltab0_1440[PMU1_XTALTAB0_1440_30000K];
1136         case BCM4336_CHIP_ID:
1137                 /* Default to 26000Khz */
1138                 return &pmu1_xtaltab0_960[PMU1_XTALTAB0_960_26000K];
1139         case BCM4330_CHIP_ID:
1140                 /* Default to 37400Khz */
1141                 if (CST4330_CHIPMODE_SDIOD(sih->chipst))
1142                         return &pmu1_xtaltab0_960[PMU1_XTALTAB0_960_37400K];
1143                 else
1144                         return &pmu1_xtaltab0_1440[PMU1_XTALTAB0_1440_37400K];
1145         default:
1146                 PMU_MSG(("si_pmu1_xtaldef0: Unknown chipid %s\n",
1147                          bcm_chipname(sih->chip, chn, 8)));
1148                 break;
1149         }
1150         ASSERT(0);
1151         return NULL;
1152 }
1153
1154 /* select default pll fvco for each chip */
1155 static u32 BCMINITFN(si_pmu1_pllfvco0) (si_t *sih)
1156 {
1157 #ifdef BCMDBG
1158         char chn[8];
1159 #endif
1160
1161         switch (CHIPID(sih->chip)) {
1162         case BCM4329_CHIP_ID:
1163                 return FVCO_880;
1164         case BCM4319_CHIP_ID:
1165                 return FVCO_1440;
1166         case BCM4336_CHIP_ID:
1167                 return FVCO_960;
1168         case BCM4330_CHIP_ID:
1169                 if (CST4330_CHIPMODE_SDIOD(sih->chipst))
1170                         return FVCO_960;
1171                 else
1172                         return FVCO_1440;
1173         default:
1174                 PMU_MSG(("si_pmu1_pllfvco0: Unknown chipid %s\n",
1175                          bcm_chipname(sih->chip, chn, 8)));
1176                 break;
1177         }
1178         ASSERT(0);
1179         return 0;
1180 }
1181
1182 /* query alp/xtal clock frequency */
1183 static u32
1184 BCMINITFN(si_pmu1_alpclk0) (si_t *sih, osl_t *osh, chipcregs_t *cc)
1185 {
1186         const pmu1_xtaltab0_t *xt;
1187         u32 xf;
1188
1189         /* Find the frequency in the table */
1190         xf = (R_REG(osh, &cc->pmucontrol) & PCTL_XTALFREQ_MASK) >>
1191             PCTL_XTALFREQ_SHIFT;
1192         for (xt = si_pmu1_xtaltab0(sih); xt != NULL && xt->fref != 0; xt++)
1193                 if (xt->xf == xf)
1194                         break;
1195         /* Could not find it so assign a default value */
1196         if (xt == NULL || xt->fref == 0)
1197                 xt = si_pmu1_xtaldef0(sih);
1198         ASSERT(xt != NULL && xt->fref != 0);
1199
1200         return xt->fref * 1000;
1201 }
1202
1203 /* Set up PLL registers in the PMU as per the crystal speed.
1204  * XtalFreq field in pmucontrol register being 0 indicates the PLL
1205  * is not programmed and the h/w default is assumed to work, in which
1206  * case the xtal frequency is unknown to the s/w so we need to call
1207  * si_pmu1_xtaldef0() wherever it is needed to return a default value.
1208  */
1209 static void
1210 BCMATTACHFN(si_pmu1_pllinit0) (si_t *sih, osl_t *osh, chipcregs_t *cc,
1211                                u32 xtal) {
1212         const pmu1_xtaltab0_t *xt;
1213         u32 tmp;
1214         u32 buf_strength = 0;
1215         u8 ndiv_mode = 1;
1216
1217         /* Use h/w default PLL config */
1218         if (xtal == 0) {
1219                 PMU_MSG(("Unspecified xtal frequency, skip PLL configuration\n"));
1220                 return;
1221         }
1222
1223         /* Find the frequency in the table */
1224         for (xt = si_pmu1_xtaltab0(sih); xt != NULL && xt->fref != 0; xt++)
1225                 if (xt->fref == xtal)
1226                         break;
1227
1228         /* Check current PLL state, bail out if it has been programmed or
1229          * we don't know how to program it.
1230          */
1231         if (xt == NULL || xt->fref == 0) {
1232                 PMU_MSG(("Unsupported xtal frequency %d.%d MHz, skip PLL configuration\n", xtal / 1000, xtal % 1000));
1233                 return;
1234         }
1235         /*  for 4319 bootloader already programs the PLL but bootloader does not program the
1236            PLL4 and PLL5. So Skip this check for 4319
1237          */
1238         if ((((R_REG(osh, &cc->pmucontrol) & PCTL_XTALFREQ_MASK) >>
1239               PCTL_XTALFREQ_SHIFT) == xt->xf) &&
1240             !((CHIPID(sih->chip) == BCM4319_CHIP_ID)
1241               || (CHIPID(sih->chip) == BCM4330_CHIP_ID))) {
1242                 PMU_MSG(("PLL already programmed for %d.%d MHz\n",
1243                          xt->fref / 1000, xt->fref % 1000));
1244                 return;
1245         }
1246
1247         PMU_MSG(("XTAL %d.%d MHz (%d)\n", xtal / 1000, xtal % 1000, xt->xf));
1248         PMU_MSG(("Programming PLL for %d.%d MHz\n", xt->fref / 1000,
1249                  xt->fref % 1000));
1250
1251         switch (CHIPID(sih->chip)) {
1252         case BCM4329_CHIP_ID:
1253                 /* Change the BBPLL drive strength to 8 for all channels */
1254                 buf_strength = 0x888888;
1255                 AND_REG(osh, &cc->min_res_mask,
1256                         ~(PMURES_BIT(RES4329_BBPLL_PWRSW_PU) |
1257                           PMURES_BIT(RES4329_HT_AVAIL)));
1258                 AND_REG(osh, &cc->max_res_mask,
1259                         ~(PMURES_BIT(RES4329_BBPLL_PWRSW_PU) |
1260                           PMURES_BIT(RES4329_HT_AVAIL)));
1261                 SPINWAIT(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL,
1262                          PMU_MAX_TRANSITION_DLY);
1263                 ASSERT(!(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL));
1264                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
1265                 if (xt->fref == 38400)
1266                         tmp = 0x200024C0;
1267                 else if (xt->fref == 37400)
1268                         tmp = 0x20004500;
1269                 else if (xt->fref == 26000)
1270                         tmp = 0x200024C0;
1271                 else
1272                         tmp = 0x200005C0;       /* Chip Dflt Settings */
1273                 W_REG(osh, &cc->pllcontrol_data, tmp);
1274                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
1275                 tmp =
1276                     R_REG(osh,
1277                           &cc->pllcontrol_data) & PMU1_PLL0_PC5_CLK_DRV_MASK;
1278                 if ((xt->fref == 38400) || (xt->fref == 37400)
1279                     || (xt->fref == 26000))
1280                         tmp |= 0x15;
1281                 else
1282                         tmp |= 0x25;    /* Chip Dflt Settings */
1283                 W_REG(osh, &cc->pllcontrol_data, tmp);
1284                 break;
1285
1286         case BCM4319_CHIP_ID:
1287                 /* Change the BBPLL drive strength to 2 for all channels */
1288                 buf_strength = 0x222222;
1289
1290                 /* Make sure the PLL is off */
1291                 /* WAR65104: Disable the HT_AVAIL resource first and then
1292                  * after a delay (more than downtime for HT_AVAIL) remove the
1293                  * BBPLL resource; backplane clock moves to ALP from HT.
1294                  */
1295                 AND_REG(osh, &cc->min_res_mask,
1296                         ~(PMURES_BIT(RES4319_HT_AVAIL)));
1297                 AND_REG(osh, &cc->max_res_mask,
1298                         ~(PMURES_BIT(RES4319_HT_AVAIL)));
1299
1300                 OSL_DELAY(100);
1301                 AND_REG(osh, &cc->min_res_mask,
1302                         ~(PMURES_BIT(RES4319_BBPLL_PWRSW_PU)));
1303                 AND_REG(osh, &cc->max_res_mask,
1304                         ~(PMURES_BIT(RES4319_BBPLL_PWRSW_PU)));
1305
1306                 OSL_DELAY(100);
1307                 SPINWAIT(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL,
1308                          PMU_MAX_TRANSITION_DLY);
1309                 ASSERT(!(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL));
1310                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
1311                 tmp = 0x200005c0;
1312                 W_REG(osh, &cc->pllcontrol_data, tmp);
1313                 break;
1314
1315         case BCM4336_CHIP_ID:
1316                 AND_REG(osh, &cc->min_res_mask,
1317                         ~(PMURES_BIT(RES4336_HT_AVAIL) |
1318                           PMURES_BIT(RES4336_MACPHY_CLKAVAIL)));
1319                 AND_REG(osh, &cc->max_res_mask,
1320                         ~(PMURES_BIT(RES4336_HT_AVAIL) |
1321                           PMURES_BIT(RES4336_MACPHY_CLKAVAIL)));
1322                 OSL_DELAY(100);
1323                 SPINWAIT(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL,
1324                          PMU_MAX_TRANSITION_DLY);
1325                 ASSERT(!(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL));
1326                 break;
1327
1328         case BCM4330_CHIP_ID:
1329                 AND_REG(osh, &cc->min_res_mask,
1330                         ~(PMURES_BIT(RES4330_HT_AVAIL) |
1331                           PMURES_BIT(RES4330_MACPHY_CLKAVAIL)));
1332                 AND_REG(osh, &cc->max_res_mask,
1333                         ~(PMURES_BIT(RES4330_HT_AVAIL) |
1334                           PMURES_BIT(RES4330_MACPHY_CLKAVAIL)));
1335                 OSL_DELAY(100);
1336                 SPINWAIT(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL,
1337                          PMU_MAX_TRANSITION_DLY);
1338                 ASSERT(!(R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL));
1339                 break;
1340
1341         default:
1342                 ASSERT(0);
1343         }
1344
1345         PMU_MSG(("Done masking\n"));
1346
1347         /* Write p1div and p2div to pllcontrol[0] */
1348         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
1349         tmp = R_REG(osh, &cc->pllcontrol_data) &
1350             ~(PMU1_PLL0_PC0_P1DIV_MASK | PMU1_PLL0_PC0_P2DIV_MASK);
1351         tmp |=
1352             ((xt->
1353               p1div << PMU1_PLL0_PC0_P1DIV_SHIFT) & PMU1_PLL0_PC0_P1DIV_MASK) |
1354             ((xt->
1355               p2div << PMU1_PLL0_PC0_P2DIV_SHIFT) & PMU1_PLL0_PC0_P2DIV_MASK);
1356         W_REG(osh, &cc->pllcontrol_data, tmp);
1357
1358         if ((CHIPID(sih->chip) == BCM4330_CHIP_ID))
1359                 si_pmu_set_4330_plldivs(sih);
1360
1361         if ((CHIPID(sih->chip) == BCM4329_CHIP_ID)
1362             && (CHIPREV(sih->chiprev) == 0)) {
1363
1364                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
1365                 tmp = R_REG(osh, &cc->pllcontrol_data);
1366                 tmp = tmp & (~DOT11MAC_880MHZ_CLK_DIVISOR_MASK);
1367                 tmp = tmp | DOT11MAC_880MHZ_CLK_DIVISOR_VAL;
1368                 W_REG(osh, &cc->pllcontrol_data, tmp);
1369         }
1370         if ((CHIPID(sih->chip) == BCM4319_CHIP_ID) ||
1371             (CHIPID(sih->chip) == BCM4336_CHIP_ID) ||
1372             (CHIPID(sih->chip) == BCM4330_CHIP_ID))
1373                 ndiv_mode = PMU1_PLL0_PC2_NDIV_MODE_MFB;
1374         else
1375                 ndiv_mode = PMU1_PLL0_PC2_NDIV_MODE_MASH;
1376
1377         /* Write ndiv_int and ndiv_mode to pllcontrol[2] */
1378         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
1379         tmp = R_REG(osh, &cc->pllcontrol_data) &
1380             ~(PMU1_PLL0_PC2_NDIV_INT_MASK | PMU1_PLL0_PC2_NDIV_MODE_MASK);
1381         tmp |=
1382             ((xt->
1383               ndiv_int << PMU1_PLL0_PC2_NDIV_INT_SHIFT) &
1384              PMU1_PLL0_PC2_NDIV_INT_MASK) | ((ndiv_mode <<
1385                                               PMU1_PLL0_PC2_NDIV_MODE_SHIFT) &
1386                                              PMU1_PLL0_PC2_NDIV_MODE_MASK);
1387         W_REG(osh, &cc->pllcontrol_data, tmp);
1388
1389         /* Write ndiv_frac to pllcontrol[3] */
1390         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
1391         tmp = R_REG(osh, &cc->pllcontrol_data) & ~PMU1_PLL0_PC3_NDIV_FRAC_MASK;
1392         tmp |= ((xt->ndiv_frac << PMU1_PLL0_PC3_NDIV_FRAC_SHIFT) &
1393                 PMU1_PLL0_PC3_NDIV_FRAC_MASK);
1394         W_REG(osh, &cc->pllcontrol_data, tmp);
1395
1396         /* Write clock driving strength to pllcontrol[5] */
1397         if (buf_strength) {
1398                 PMU_MSG(("Adjusting PLL buffer drive strength: %x\n",
1399                          buf_strength));
1400
1401                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
1402                 tmp =
1403                     R_REG(osh,
1404                           &cc->pllcontrol_data) & ~PMU1_PLL0_PC5_CLK_DRV_MASK;
1405                 tmp |= (buf_strength << PMU1_PLL0_PC5_CLK_DRV_SHIFT);
1406                 W_REG(osh, &cc->pllcontrol_data, tmp);
1407         }
1408
1409         PMU_MSG(("Done pll\n"));
1410
1411         /* to operate the 4319 usb in 24MHz/48MHz; chipcontrol[2][84:83] needs
1412          * to be updated.
1413          */
1414         if ((CHIPID(sih->chip) == BCM4319_CHIP_ID)
1415             && (xt->fref != XTAL_FREQ_30000MHZ)) {
1416                 W_REG(osh, &cc->chipcontrol_addr, PMU1_PLL0_CHIPCTL2);
1417                 tmp =
1418                     R_REG(osh,
1419                           &cc->chipcontrol_data) & ~CCTL_4319USB_XTAL_SEL_MASK;
1420                 if (xt->fref == XTAL_FREQ_24000MHZ) {
1421                         tmp |=
1422                             (CCTL_4319USB_24MHZ_PLL_SEL <<
1423                              CCTL_4319USB_XTAL_SEL_SHIFT);
1424                 } else if (xt->fref == XTAL_FREQ_48000MHZ) {
1425                         tmp |=
1426                             (CCTL_4319USB_48MHZ_PLL_SEL <<
1427                              CCTL_4319USB_XTAL_SEL_SHIFT);
1428                 }
1429                 W_REG(osh, &cc->chipcontrol_data, tmp);
1430         }
1431
1432         /* Flush deferred pll control registers writes */
1433         if (sih->pmurev >= 2)
1434                 OR_REG(osh, &cc->pmucontrol, PCTL_PLL_PLLCTL_UPD);
1435
1436         /* Write XtalFreq. Set the divisor also. */
1437         tmp = R_REG(osh, &cc->pmucontrol) &
1438             ~(PCTL_ILP_DIV_MASK | PCTL_XTALFREQ_MASK);
1439         tmp |= (((((xt->fref + 127) / 128) - 1) << PCTL_ILP_DIV_SHIFT) &
1440                 PCTL_ILP_DIV_MASK) |
1441             ((xt->xf << PCTL_XTALFREQ_SHIFT) & PCTL_XTALFREQ_MASK);
1442
1443         if ((CHIPID(sih->chip) == BCM4329_CHIP_ID)
1444             && CHIPREV(sih->chiprev) == 0) {
1445                 /* clear the htstretch before clearing HTReqEn */
1446                 AND_REG(osh, &cc->clkstretch, ~CSTRETCH_HT);
1447                 tmp &= ~PCTL_HT_REQ_EN;
1448         }
1449
1450         W_REG(osh, &cc->pmucontrol, tmp);
1451 }
1452
1453 /* query the CPU clock frequency */
1454 static u32
1455 BCMINITFN(si_pmu1_cpuclk0) (si_t *sih, osl_t *osh, chipcregs_t *cc)
1456 {
1457         u32 tmp, m1div;
1458 #ifdef BCMDBG
1459         u32 ndiv_int, ndiv_frac, p2div, p1div, fvco;
1460         u32 fref;
1461 #endif
1462         u32 FVCO = si_pmu1_pllfvco0(sih);
1463
1464         /* Read m1div from pllcontrol[1] */
1465         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
1466         tmp = R_REG(osh, &cc->pllcontrol_data);
1467         m1div = (tmp & PMU1_PLL0_PC1_M1DIV_MASK) >> PMU1_PLL0_PC1_M1DIV_SHIFT;
1468
1469 #ifdef BCMDBG
1470         /* Read p2div/p1div from pllcontrol[0] */
1471         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
1472         tmp = R_REG(osh, &cc->pllcontrol_data);
1473         p2div = (tmp & PMU1_PLL0_PC0_P2DIV_MASK) >> PMU1_PLL0_PC0_P2DIV_SHIFT;
1474         p1div = (tmp & PMU1_PLL0_PC0_P1DIV_MASK) >> PMU1_PLL0_PC0_P1DIV_SHIFT;
1475
1476         /* Calculate fvco based on xtal freq and ndiv and pdiv */
1477         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
1478         tmp = R_REG(osh, &cc->pllcontrol_data);
1479         ndiv_int =
1480             (tmp & PMU1_PLL0_PC2_NDIV_INT_MASK) >> PMU1_PLL0_PC2_NDIV_INT_SHIFT;
1481
1482         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
1483         tmp = R_REG(osh, &cc->pllcontrol_data);
1484         ndiv_frac =
1485             (tmp & PMU1_PLL0_PC3_NDIV_FRAC_MASK) >>
1486             PMU1_PLL0_PC3_NDIV_FRAC_SHIFT;
1487
1488         fref = si_pmu1_alpclk0(sih, osh, cc) / 1000;
1489
1490         fvco = (fref * ndiv_int) << 8;
1491         fvco += (fref * (ndiv_frac >> 12)) >> 4;
1492         fvco += (fref * (ndiv_frac & 0xfff)) >> 12;
1493         fvco >>= 8;
1494         fvco *= p2div;
1495         fvco /= p1div;
1496         fvco /= 1000;
1497         fvco *= 1000;
1498
1499         PMU_MSG(("si_pmu1_cpuclk0: ndiv_int %u ndiv_frac %u p2div %u p1div %u fvco %u\n", ndiv_int, ndiv_frac, p2div, p1div, fvco));
1500
1501         FVCO = fvco;
1502 #endif                          /* BCMDBG */
1503
1504         /* Return ARM/SB clock */
1505         return FVCO / m1div * 1000;
1506 }
1507
1508 /* initialize PLL */
1509 void BCMATTACHFN(si_pmu_pll_init) (si_t *sih, osl_t *osh, uint xtalfreq)
1510 {
1511         chipcregs_t *cc;
1512         uint origidx;
1513 #ifdef BCMDBG
1514         char chn[8];
1515 #endif
1516
1517         ASSERT(sih->cccaps & CC_CAP_PMU);
1518
1519         /* Remember original core before switch to chipc */
1520         origidx = si_coreidx(sih);
1521         cc = si_setcoreidx(sih, SI_CC_IDX);
1522         ASSERT(cc != NULL);
1523
1524         switch (CHIPID(sih->chip)) {
1525         case BCM4329_CHIP_ID:
1526                 if (xtalfreq == 0)
1527                         xtalfreq = 38400;
1528                 si_pmu1_pllinit0(sih, osh, cc, xtalfreq);
1529                 break;
1530         case BCM4313_CHIP_ID:
1531         case BCM43224_CHIP_ID:
1532         case BCM43225_CHIP_ID:
1533         case BCM43421_CHIP_ID:
1534         case BCM43235_CHIP_ID:
1535         case BCM43236_CHIP_ID:
1536         case BCM43238_CHIP_ID:
1537         case BCM4331_CHIP_ID:
1538         case BCM6362_CHIP_ID:
1539                 /* ??? */
1540                 break;
1541         case BCM4319_CHIP_ID:
1542         case BCM4336_CHIP_ID:
1543         case BCM4330_CHIP_ID:
1544                 si_pmu1_pllinit0(sih, osh, cc, xtalfreq);
1545                 break;
1546         default:
1547                 PMU_MSG(("No PLL init done for chip %s rev %d pmurev %d\n",
1548                          bcm_chipname(sih->chip, chn, 8), sih->chiprev,
1549                          sih->pmurev));
1550                 break;
1551         }
1552
1553 #ifdef BCMDBG_FORCEHT
1554         OR_REG(osh, &cc->clk_ctl_st, CCS_FORCEHT);
1555 #endif
1556
1557         /* Return to original core */
1558         si_setcoreidx(sih, origidx);
1559 }
1560
1561 /* query alp/xtal clock frequency */
1562 u32 BCMINITFN(si_pmu_alp_clock) (si_t *sih, osl_t *osh)
1563 {
1564         chipcregs_t *cc;
1565         uint origidx;
1566         u32 clock = ALP_CLOCK;
1567 #ifdef BCMDBG
1568         char chn[8];
1569 #endif
1570
1571         ASSERT(sih->cccaps & CC_CAP_PMU);
1572
1573         /* Remember original core before switch to chipc */
1574         origidx = si_coreidx(sih);
1575         cc = si_setcoreidx(sih, SI_CC_IDX);
1576         ASSERT(cc != NULL);
1577
1578         switch (CHIPID(sih->chip)) {
1579         case BCM43224_CHIP_ID:
1580         case BCM43225_CHIP_ID:
1581         case BCM43421_CHIP_ID:
1582         case BCM43235_CHIP_ID:
1583         case BCM43236_CHIP_ID:
1584         case BCM43238_CHIP_ID:
1585         case BCM4331_CHIP_ID:
1586         case BCM6362_CHIP_ID:
1587         case BCM4716_CHIP_ID:
1588         case BCM4748_CHIP_ID:
1589         case BCM47162_CHIP_ID:
1590         case BCM4313_CHIP_ID:
1591         case BCM5357_CHIP_ID:
1592                 /* always 20Mhz */
1593                 clock = 20000 * 1000;
1594                 break;
1595         case BCM4329_CHIP_ID:
1596         case BCM4319_CHIP_ID:
1597         case BCM4336_CHIP_ID:
1598         case BCM4330_CHIP_ID:
1599
1600                 clock = si_pmu1_alpclk0(sih, osh, cc);
1601                 break;
1602         case BCM5356_CHIP_ID:
1603                 /* always 25Mhz */
1604                 clock = 25000 * 1000;
1605                 break;
1606         default:
1607                 PMU_MSG(("No ALP clock specified "
1608                          "for chip %s rev %d pmurev %d, using default %d Hz\n",
1609                          bcm_chipname(sih->chip, chn, 8), sih->chiprev,
1610                          sih->pmurev, clock));
1611                 break;
1612         }
1613
1614         /* Return to original core */
1615         si_setcoreidx(sih, origidx);
1616         return clock;
1617 }
1618
1619 /* Find the output of the "m" pll divider given pll controls that start with
1620  * pllreg "pll0" i.e. 12 for main 6 for phy, 0 for misc.
1621  */
1622 static u32
1623 BCMINITFN(si_pmu5_clock) (si_t *sih, osl_t *osh, chipcregs_t *cc, uint pll0,
1624                           uint m) {
1625         u32 tmp, div, ndiv, p1, p2, fc;
1626
1627         if ((pll0 & 3) || (pll0 > PMU4716_MAINPLL_PLL0)) {
1628                 PMU_ERROR(("%s: Bad pll0: %d\n", __func__, pll0));
1629                 return 0;
1630         }
1631
1632         /* Strictly there is an m5 divider, but I'm not sure we use it */
1633         if ((m == 0) || (m > 4)) {
1634                 PMU_ERROR(("%s: Bad m divider: %d\n", __func__, m));
1635                 return 0;
1636         }
1637
1638         if (CHIPID(sih->chip) == BCM5357_CHIP_ID) {
1639                 /* Detect failure in clock setting */
1640                 if ((R_REG(osh, &cc->chipstatus) & 0x40000) != 0) {
1641                         return 133 * 1000000;
1642                 }
1643         }
1644
1645         W_REG(osh, &cc->pllcontrol_addr, pll0 + PMU5_PLL_P1P2_OFF);
1646         (void)R_REG(osh, &cc->pllcontrol_addr);
1647         tmp = R_REG(osh, &cc->pllcontrol_data);
1648         p1 = (tmp & PMU5_PLL_P1_MASK) >> PMU5_PLL_P1_SHIFT;
1649         p2 = (tmp & PMU5_PLL_P2_MASK) >> PMU5_PLL_P2_SHIFT;
1650
1651         W_REG(osh, &cc->pllcontrol_addr, pll0 + PMU5_PLL_M14_OFF);
1652         (void)R_REG(osh, &cc->pllcontrol_addr);
1653         tmp = R_REG(osh, &cc->pllcontrol_data);
1654         div = (tmp >> ((m - 1) * PMU5_PLL_MDIV_WIDTH)) & PMU5_PLL_MDIV_MASK;
1655
1656         W_REG(osh, &cc->pllcontrol_addr, pll0 + PMU5_PLL_NM5_OFF);
1657         (void)R_REG(osh, &cc->pllcontrol_addr);
1658         tmp = R_REG(osh, &cc->pllcontrol_data);
1659         ndiv = (tmp & PMU5_PLL_NDIV_MASK) >> PMU5_PLL_NDIV_SHIFT;
1660
1661         /* Do calculation in Mhz */
1662         fc = si_pmu_alp_clock(sih, osh) / 1000000;
1663         fc = (p1 * ndiv * fc) / p2;
1664
1665         PMU_NONE(("%s: p1=%d, p2=%d, ndiv=%d(0x%x), m%d=%d; fc=%d, clock=%d\n",
1666                   __func__, p1, p2, ndiv, ndiv, m, div, fc, fc / div));
1667
1668         /* Return clock in Hertz */
1669         return (fc / div) * 1000000;
1670 }
1671
1672 /* query backplane clock frequency */
1673 /* For designs that feed the same clock to both backplane
1674  * and CPU just return the CPU clock speed.
1675  */
1676 u32 BCMINITFN(si_pmu_si_clock) (si_t *sih, osl_t *osh)
1677 {
1678         chipcregs_t *cc;
1679         uint origidx;
1680         u32 clock = HT_CLOCK;
1681 #ifdef BCMDBG
1682         char chn[8];
1683 #endif
1684
1685         ASSERT(sih->cccaps & CC_CAP_PMU);
1686
1687         /* Remember original core before switch to chipc */
1688         origidx = si_coreidx(sih);
1689         cc = si_setcoreidx(sih, SI_CC_IDX);
1690         ASSERT(cc != NULL);
1691
1692         switch (CHIPID(sih->chip)) {
1693         case BCM43224_CHIP_ID:
1694         case BCM43225_CHIP_ID:
1695         case BCM43421_CHIP_ID:
1696         case BCM4331_CHIP_ID:
1697         case BCM6362_CHIP_ID:
1698                 /* 96MHz backplane clock */
1699                 clock = 96000 * 1000;
1700                 break;
1701         case BCM4716_CHIP_ID:
1702         case BCM4748_CHIP_ID:
1703         case BCM47162_CHIP_ID:
1704                 clock =
1705                     si_pmu5_clock(sih, osh, cc, PMU4716_MAINPLL_PLL0,
1706                                   PMU5_MAINPLL_SI);
1707                 break;
1708         case BCM4329_CHIP_ID:
1709                 if (CHIPREV(sih->chiprev) == 0)
1710                         clock = 38400 * 1000;
1711                 else
1712                         clock = si_pmu1_cpuclk0(sih, osh, cc);
1713                 break;
1714         case BCM4319_CHIP_ID:
1715         case BCM4336_CHIP_ID:
1716         case BCM4330_CHIP_ID:
1717                 clock = si_pmu1_cpuclk0(sih, osh, cc);
1718                 break;
1719         case BCM4313_CHIP_ID:
1720                 /* 80MHz backplane clock */
1721                 clock = 80000 * 1000;
1722                 break;
1723         case BCM43235_CHIP_ID:
1724         case BCM43236_CHIP_ID:
1725         case BCM43238_CHIP_ID:
1726                 clock =
1727                     (cc->chipstatus & CST43236_BP_CLK) ? (120000 *
1728                                                           1000) : (96000 *
1729                                                                    1000);
1730                 break;
1731         case BCM5356_CHIP_ID:
1732                 clock =
1733                     si_pmu5_clock(sih, osh, cc, PMU5356_MAINPLL_PLL0,
1734                                   PMU5_MAINPLL_SI);
1735                 break;
1736         case BCM5357_CHIP_ID:
1737                 clock =
1738                     si_pmu5_clock(sih, osh, cc, PMU5357_MAINPLL_PLL0,
1739                                   PMU5_MAINPLL_SI);
1740                 break;
1741         default:
1742                 PMU_MSG(("No backplane clock specified "
1743                          "for chip %s rev %d pmurev %d, using default %d Hz\n",
1744                          bcm_chipname(sih->chip, chn, 8), sih->chiprev,
1745                          sih->pmurev, clock));
1746                 break;
1747         }
1748
1749         /* Return to original core */
1750         si_setcoreidx(sih, origidx);
1751         return clock;
1752 }
1753
1754 /* query CPU clock frequency */
1755 u32 BCMINITFN(si_pmu_cpu_clock) (si_t *sih, osl_t *osh)
1756 {
1757         chipcregs_t *cc;
1758         uint origidx;
1759         u32 clock;
1760
1761         ASSERT(sih->cccaps & CC_CAP_PMU);
1762
1763         if ((sih->pmurev >= 5) &&
1764             !((CHIPID(sih->chip) == BCM4329_CHIP_ID) ||
1765               (CHIPID(sih->chip) == BCM4319_CHIP_ID) ||
1766               (CHIPID(sih->chip) == BCM43236_CHIP_ID) ||
1767               (CHIPID(sih->chip) == BCM4336_CHIP_ID) ||
1768               (CHIPID(sih->chip) == BCM4330_CHIP_ID))) {
1769                 uint pll;
1770
1771                 switch (CHIPID(sih->chip)) {
1772                 case BCM5356_CHIP_ID:
1773                         pll = PMU5356_MAINPLL_PLL0;
1774                         break;
1775                 case BCM5357_CHIP_ID:
1776                         pll = PMU5357_MAINPLL_PLL0;
1777                         break;
1778                 default:
1779                         pll = PMU4716_MAINPLL_PLL0;
1780                         break;
1781                 }
1782
1783                 /* Remember original core before switch to chipc */
1784                 origidx = si_coreidx(sih);
1785                 cc = si_setcoreidx(sih, SI_CC_IDX);
1786                 ASSERT(cc != NULL);
1787
1788                 clock = si_pmu5_clock(sih, osh, cc, pll, PMU5_MAINPLL_CPU);
1789
1790                 /* Return to original core */
1791                 si_setcoreidx(sih, origidx);
1792         } else
1793                 clock = si_pmu_si_clock(sih, osh);
1794
1795         return clock;
1796 }
1797
1798 /* query memory clock frequency */
1799 u32 BCMINITFN(si_pmu_mem_clock) (si_t *sih, osl_t *osh)
1800 {
1801         chipcregs_t *cc;
1802         uint origidx;
1803         u32 clock;
1804
1805         ASSERT(sih->cccaps & CC_CAP_PMU);
1806
1807         if ((sih->pmurev >= 5) &&
1808             !((CHIPID(sih->chip) == BCM4329_CHIP_ID) ||
1809               (CHIPID(sih->chip) == BCM4319_CHIP_ID) ||
1810               (CHIPID(sih->chip) == BCM4330_CHIP_ID) ||
1811               (CHIPID(sih->chip) == BCM4336_CHIP_ID) ||
1812               (CHIPID(sih->chip) == BCM43236_CHIP_ID))) {
1813                 uint pll;
1814
1815                 switch (CHIPID(sih->chip)) {
1816                 case BCM5356_CHIP_ID:
1817                         pll = PMU5356_MAINPLL_PLL0;
1818                         break;
1819                 case BCM5357_CHIP_ID:
1820                         pll = PMU5357_MAINPLL_PLL0;
1821                         break;
1822                 default:
1823                         pll = PMU4716_MAINPLL_PLL0;
1824                         break;
1825                 }
1826
1827                 /* Remember original core before switch to chipc */
1828                 origidx = si_coreidx(sih);
1829                 cc = si_setcoreidx(sih, SI_CC_IDX);
1830                 ASSERT(cc != NULL);
1831
1832                 clock = si_pmu5_clock(sih, osh, cc, pll, PMU5_MAINPLL_MEM);
1833
1834                 /* Return to original core */
1835                 si_setcoreidx(sih, origidx);
1836         } else {
1837                 clock = si_pmu_si_clock(sih, osh);
1838         }
1839
1840         return clock;
1841 }
1842
1843 /* Measure ILP clock frequency */
1844 #define ILP_CALC_DUR    10      /* ms, make sure 1000 can be divided by it. */
1845
1846 static u32 ilpcycles_per_sec;
1847
1848 u32 BCMINITFN(si_pmu_ilp_clock) (si_t *sih, osl_t *osh)
1849 {
1850         if (ISSIM_ENAB(sih))
1851                 return ILP_CLOCK;
1852
1853         if (ilpcycles_per_sec == 0) {
1854                 u32 start, end, delta;
1855                 u32 origidx = si_coreidx(sih);
1856                 chipcregs_t *cc = si_setcoreidx(sih, SI_CC_IDX);
1857                 ASSERT(cc != NULL);
1858                 start = R_REG(osh, &cc->pmutimer);
1859                 OSL_DELAY(ILP_CALC_DUR * 1000);
1860                 end = R_REG(osh, &cc->pmutimer);
1861                 delta = end - start;
1862                 ilpcycles_per_sec = delta * (1000 / ILP_CALC_DUR);
1863                 si_setcoreidx(sih, origidx);
1864         }
1865
1866         return ilpcycles_per_sec;
1867 }
1868
1869 /* SDIO Pad drive strength to select value mappings */
1870 typedef struct {
1871         u8 strength;            /* Pad Drive Strength in mA */
1872         u8 sel;         /* Chip-specific select value */
1873 } sdiod_drive_str_t;
1874
1875 /* SDIO Drive Strength to sel value table for PMU Rev 1 */
1876 static const sdiod_drive_str_t BCMINITDATA(sdiod_drive_strength_tab1)[] = {
1877         {
1878         4, 0x2}, {
1879         2, 0x3}, {
1880         1, 0x0}, {
1881         0, 0x0}
1882         };
1883
1884 /* SDIO Drive Strength to sel value table for PMU Rev 2, 3 */
1885 static const sdiod_drive_str_t BCMINITDATA(sdiod_drive_strength_tab2)[] = {
1886         {
1887         12, 0x7}, {
1888         10, 0x6}, {
1889         8, 0x5}, {
1890         6, 0x4}, {
1891         4, 0x2}, {
1892         2, 0x1}, {
1893         0, 0x0}
1894         };
1895
1896 /* SDIO Drive Strength to sel value table for PMU Rev 8 (1.8V) */
1897 static const sdiod_drive_str_t BCMINITDATA(sdiod_drive_strength_tab3)[] = {
1898         {
1899         32, 0x7}, {
1900         26, 0x6}, {
1901         22, 0x5}, {
1902         16, 0x4}, {
1903         12, 0x3}, {
1904         8, 0x2}, {
1905         4, 0x1}, {
1906         0, 0x0}
1907         };
1908
1909 #define SDIOD_DRVSTR_KEY(chip, pmu)     (((chip) << 16) | (pmu))
1910
1911 void
1912 BCMINITFN(si_sdiod_drive_strength_init) (si_t *sih, osl_t *osh,
1913                                          u32 drivestrength) {
1914         chipcregs_t *cc;
1915         uint origidx, intr_val = 0;
1916         sdiod_drive_str_t *str_tab = NULL;
1917         u32 str_mask = 0;
1918         u32 str_shift = 0;
1919 #ifdef BCMDBG
1920         char chn[8];
1921 #endif
1922
1923         if (!(sih->cccaps & CC_CAP_PMU)) {
1924                 return;
1925         }
1926
1927         /* Remember original core before switch to chipc */
1928         cc = (chipcregs_t *) si_switch_core(sih, CC_CORE_ID, &origidx,
1929                                             &intr_val);
1930
1931         switch (SDIOD_DRVSTR_KEY(sih->chip, sih->pmurev)) {
1932         case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 1):
1933                 str_tab = (sdiod_drive_str_t *)&sdiod_drive_strength_tab1;
1934                 str_mask = 0x30000000;
1935                 str_shift = 28;
1936                 break;
1937         case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 2):
1938         case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 3):
1939                 str_tab = (sdiod_drive_str_t *)&sdiod_drive_strength_tab2;
1940                 str_mask = 0x00003800;
1941                 str_shift = 11;
1942                 break;
1943         case SDIOD_DRVSTR_KEY(BCM4336_CHIP_ID, 8):
1944                 str_tab = (sdiod_drive_str_t *) &sdiod_drive_strength_tab3;
1945                 str_mask = 0x00003800;
1946                 str_shift = 11;
1947                 break;
1948
1949         default:
1950                 PMU_MSG(("No SDIO Drive strength init done for chip %s rev %d pmurev %d\n", bcm_chipname(sih->chip, chn, 8), sih->chiprev, sih->pmurev));
1951
1952                 break;
1953         }
1954
1955         if (str_tab != NULL) {
1956                 u32 drivestrength_sel = 0;
1957                 u32 cc_data_temp;
1958                 int i;
1959
1960                 for (i = 0; str_tab[i].strength != 0; i++) {
1961                         if (drivestrength >= str_tab[i].strength) {
1962                                 drivestrength_sel = str_tab[i].sel;
1963                                 break;
1964                         }
1965                 }
1966
1967                 W_REG(osh, &cc->chipcontrol_addr, 1);
1968                 cc_data_temp = R_REG(osh, &cc->chipcontrol_data);
1969                 cc_data_temp &= ~str_mask;
1970                 drivestrength_sel <<= str_shift;
1971                 cc_data_temp |= drivestrength_sel;
1972                 W_REG(osh, &cc->chipcontrol_data, cc_data_temp);
1973
1974                 PMU_MSG(("SDIO: %dmA drive strength selected, set to 0x%08x\n",
1975                          drivestrength, cc_data_temp));
1976         }
1977
1978         /* Return to original core */
1979         si_restore_core(sih, origidx, intr_val);
1980 }
1981
1982 /* initialize PMU */
1983 void BCMATTACHFN(si_pmu_init) (si_t *sih, osl_t *osh)
1984 {
1985         chipcregs_t *cc;
1986         uint origidx;
1987
1988         ASSERT(sih->cccaps & CC_CAP_PMU);
1989
1990         /* Remember original core before switch to chipc */
1991         origidx = si_coreidx(sih);
1992         cc = si_setcoreidx(sih, SI_CC_IDX);
1993         ASSERT(cc != NULL);
1994
1995         if (sih->pmurev == 1)
1996                 AND_REG(osh, &cc->pmucontrol, ~PCTL_NOILP_ON_WAIT);
1997         else if (sih->pmurev >= 2)
1998                 OR_REG(osh, &cc->pmucontrol, PCTL_NOILP_ON_WAIT);
1999
2000         if ((CHIPID(sih->chip) == BCM4329_CHIP_ID) && (sih->chiprev == 2)) {
2001                 /* Fix for 4329b0 bad LPOM state. */
2002                 W_REG(osh, &cc->regcontrol_addr, 2);
2003                 OR_REG(osh, &cc->regcontrol_data, 0x100);
2004
2005                 W_REG(osh, &cc->regcontrol_addr, 3);
2006                 OR_REG(osh, &cc->regcontrol_data, 0x4);
2007         }
2008
2009         /* Return to original core */
2010         si_setcoreidx(sih, origidx);
2011 }
2012
2013 /* Return up time in ILP cycles for the given resource. */
2014 static uint
2015 BCMINITFN(si_pmu_res_uptime) (si_t *sih, osl_t *osh, chipcregs_t *cc,
2016                               u8 rsrc) {
2017         u32 deps;
2018         uint up, i, dup, dmax;
2019         u32 min_mask = 0, max_mask = 0;
2020
2021         /* uptime of resource 'rsrc' */
2022         W_REG(osh, &cc->res_table_sel, rsrc);
2023         up = (R_REG(osh, &cc->res_updn_timer) >> 8) & 0xff;
2024
2025         /* direct dependancies of resource 'rsrc' */
2026         deps = si_pmu_res_deps(sih, osh, cc, PMURES_BIT(rsrc), FALSE);
2027         for (i = 0; i <= PMURES_MAX_RESNUM; i++) {
2028                 if (!(deps & PMURES_BIT(i)))
2029                         continue;
2030                 deps &= ~si_pmu_res_deps(sih, osh, cc, PMURES_BIT(i), TRUE);
2031         }
2032         si_pmu_res_masks(sih, &min_mask, &max_mask);
2033         deps &= ~min_mask;
2034
2035         /* max uptime of direct dependancies */
2036         dmax = 0;
2037         for (i = 0; i <= PMURES_MAX_RESNUM; i++) {
2038                 if (!(deps & PMURES_BIT(i)))
2039                         continue;
2040                 dup = si_pmu_res_uptime(sih, osh, cc, (u8) i);
2041                 if (dmax < dup)
2042                         dmax = dup;
2043         }
2044
2045         PMU_MSG(("si_pmu_res_uptime: rsrc %u uptime %u(deps 0x%08x uptime %u)\n", rsrc, up, deps, dmax));
2046
2047         return up + dmax + PMURES_UP_TRANSITION;
2048 }
2049
2050 /* Return dependancies (direct or all/indirect) for the given resources */
2051 static u32
2052 si_pmu_res_deps(si_t *sih, osl_t *osh, chipcregs_t *cc, u32 rsrcs,
2053                 bool all)
2054 {
2055         u32 deps = 0;
2056         u32 i;
2057
2058         for (i = 0; i <= PMURES_MAX_RESNUM; i++) {
2059                 if (!(rsrcs & PMURES_BIT(i)))
2060                         continue;
2061                 W_REG(osh, &cc->res_table_sel, i);
2062                 deps |= R_REG(osh, &cc->res_dep_mask);
2063         }
2064
2065         return !all ? deps : (deps
2066                               ? (deps |
2067                                  si_pmu_res_deps(sih, osh, cc, deps,
2068                                                  TRUE)) : 0);
2069 }
2070
2071 /* power up/down OTP through PMU resources */
2072 void si_pmu_otp_power(si_t *sih, osl_t *osh, bool on)
2073 {
2074         chipcregs_t *cc;
2075         uint origidx;
2076         u32 rsrcs = 0;  /* rsrcs to turn on/off OTP power */
2077
2078         ASSERT(sih->cccaps & CC_CAP_PMU);
2079
2080         /* Don't do anything if OTP is disabled */
2081         if (si_is_otp_disabled(sih)) {
2082                 PMU_MSG(("si_pmu_otp_power: OTP is disabled\n"));
2083                 return;
2084         }
2085
2086         /* Remember original core before switch to chipc */
2087         origidx = si_coreidx(sih);
2088         cc = si_setcoreidx(sih, SI_CC_IDX);
2089         ASSERT(cc != NULL);
2090
2091         switch (CHIPID(sih->chip)) {
2092         case BCM4329_CHIP_ID:
2093                 rsrcs = PMURES_BIT(RES4329_OTP_PU);
2094                 break;
2095         case BCM4319_CHIP_ID:
2096                 rsrcs = PMURES_BIT(RES4319_OTP_PU);
2097                 break;
2098         case BCM4336_CHIP_ID:
2099                 rsrcs = PMURES_BIT(RES4336_OTP_PU);
2100                 break;
2101         case BCM4330_CHIP_ID:
2102                 rsrcs = PMURES_BIT(RES4330_OTP_PU);
2103                 break;
2104         default:
2105                 break;
2106         }
2107
2108         if (rsrcs != 0) {
2109                 u32 otps;
2110
2111                 /* Figure out the dependancies (exclude min_res_mask) */
2112                 u32 deps = si_pmu_res_deps(sih, osh, cc, rsrcs, TRUE);
2113                 u32 min_mask = 0, max_mask = 0;
2114                 si_pmu_res_masks(sih, &min_mask, &max_mask);
2115                 deps &= ~min_mask;
2116                 /* Turn on/off the power */
2117                 if (on) {
2118                         PMU_MSG(("Adding rsrc 0x%x to min_res_mask\n",
2119                                  rsrcs | deps));
2120                         OR_REG(osh, &cc->min_res_mask, (rsrcs | deps));
2121                         SPINWAIT(!(R_REG(osh, &cc->res_state) & rsrcs),
2122                                  PMU_MAX_TRANSITION_DLY);
2123                         ASSERT(R_REG(osh, &cc->res_state) & rsrcs);
2124                 } else {
2125                         PMU_MSG(("Removing rsrc 0x%x from min_res_mask\n",
2126                                  rsrcs | deps));
2127                         AND_REG(osh, &cc->min_res_mask, ~(rsrcs | deps));
2128                 }
2129
2130                 SPINWAIT((((otps = R_REG(osh, &cc->otpstatus)) & OTPS_READY) !=
2131                           (on ? OTPS_READY : 0)), 100);
2132                 ASSERT((otps & OTPS_READY) == (on ? OTPS_READY : 0));
2133                 if ((otps & OTPS_READY) != (on ? OTPS_READY : 0))
2134                         PMU_MSG(("OTP ready bit not %s after wait\n",
2135                                  (on ? "ON" : "OFF")));
2136         }
2137
2138         /* Return to original core */
2139         si_setcoreidx(sih, origidx);
2140 }
2141
2142 void si_pmu_rcal(si_t *sih, osl_t *osh)
2143 {
2144         chipcregs_t *cc;
2145         uint origidx;
2146
2147         ASSERT(sih->cccaps & CC_CAP_PMU);
2148
2149         /* Remember original core before switch to chipc */
2150         origidx = si_coreidx(sih);
2151         cc = si_setcoreidx(sih, SI_CC_IDX);
2152         ASSERT(cc != NULL);
2153
2154         switch (CHIPID(sih->chip)) {
2155         case BCM4329_CHIP_ID:{
2156                         u8 rcal_code;
2157                         u32 val;
2158
2159                         /* Kick RCal */
2160                         W_REG(osh, &cc->chipcontrol_addr, 1);
2161
2162                         /* Power Down RCAL Block */
2163                         AND_REG(osh, &cc->chipcontrol_data, ~0x04);
2164
2165                         /* Power Up RCAL block */
2166                         OR_REG(osh, &cc->chipcontrol_data, 0x04);
2167
2168                         /* Wait for completion */
2169                         SPINWAIT(0 == (R_REG(osh, &cc->chipstatus) & 0x08),
2170                                  10 * 1000 * 1000);
2171                         ASSERT(R_REG(osh, &cc->chipstatus) & 0x08);
2172
2173                         /* Drop the LSB to convert from 5 bit code to 4 bit code */
2174                         rcal_code =
2175                             (u8) (R_REG(osh, &cc->chipstatus) >> 5) & 0x0f;
2176
2177                         PMU_MSG(("RCal completed, status 0x%x, code 0x%x\n",
2178                                  R_REG(osh, &cc->chipstatus), rcal_code));
2179
2180                         /* Write RCal code into pmu_vreg_ctrl[32:29] */
2181                         W_REG(osh, &cc->regcontrol_addr, 0);
2182                         val =
2183                             R_REG(osh,
2184                                   &cc->
2185                                   regcontrol_data) & ~((u32) 0x07 << 29);
2186                         val |= (u32) (rcal_code & 0x07) << 29;
2187                         W_REG(osh, &cc->regcontrol_data, val);
2188                         W_REG(osh, &cc->regcontrol_addr, 1);
2189                         val = R_REG(osh, &cc->regcontrol_data) & ~(u32) 0x01;
2190                         val |= (u32) ((rcal_code >> 3) & 0x01);
2191                         W_REG(osh, &cc->regcontrol_data, val);
2192
2193                         /* Write RCal code into pmu_chip_ctrl[33:30] */
2194                         W_REG(osh, &cc->chipcontrol_addr, 0);
2195                         val =
2196                             R_REG(osh,
2197                                   &cc->
2198                                   chipcontrol_data) & ~((u32) 0x03 << 30);
2199                         val |= (u32) (rcal_code & 0x03) << 30;
2200                         W_REG(osh, &cc->chipcontrol_data, val);
2201                         W_REG(osh, &cc->chipcontrol_addr, 1);
2202                         val =
2203                             R_REG(osh, &cc->chipcontrol_data) & ~(u32) 0x03;
2204                         val |= (u32) ((rcal_code >> 2) & 0x03);
2205                         W_REG(osh, &cc->chipcontrol_data, val);
2206
2207                         /* Set override in pmu_chip_ctrl[29] */
2208                         W_REG(osh, &cc->chipcontrol_addr, 0);
2209                         OR_REG(osh, &cc->chipcontrol_data, (0x01 << 29));
2210
2211                         /* Power off RCal block */
2212                         W_REG(osh, &cc->chipcontrol_addr, 1);
2213                         AND_REG(osh, &cc->chipcontrol_data, ~0x04);
2214
2215                         break;
2216                 }
2217         default:
2218                 break;
2219         }
2220
2221         /* Return to original core */
2222         si_setcoreidx(sih, origidx);
2223 }
2224
2225 void si_pmu_spuravoid(si_t *sih, osl_t *osh, u8 spuravoid)
2226 {
2227         chipcregs_t *cc;
2228         uint origidx, intr_val;
2229         u32 tmp = 0;
2230
2231         /* Remember original core before switch to chipc */
2232         cc = (chipcregs_t *) si_switch_core(sih, CC_CORE_ID, &origidx,
2233                                             &intr_val);
2234         ASSERT(cc != NULL);
2235
2236         /* force the HT off  */
2237         if (CHIPID(sih->chip) == BCM4336_CHIP_ID) {
2238                 tmp = R_REG(osh, &cc->max_res_mask);
2239                 tmp &= ~RES4336_HT_AVAIL;
2240                 W_REG(osh, &cc->max_res_mask, tmp);
2241                 /* wait for the ht to really go away */
2242                 SPINWAIT(((R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL) == 0),
2243                          10000);
2244                 ASSERT((R_REG(osh, &cc->clk_ctl_st) & CCS_HTAVAIL) == 0);
2245         }
2246
2247         /* update the pll changes */
2248         si_pmu_spuravoid_pllupdate(sih, cc, osh, spuravoid);
2249
2250         /* enable HT back on  */
2251         if (CHIPID(sih->chip) == BCM4336_CHIP_ID) {
2252                 tmp = R_REG(osh, &cc->max_res_mask);
2253                 tmp |= RES4336_HT_AVAIL;
2254                 W_REG(osh, &cc->max_res_mask, tmp);
2255         }
2256
2257         /* Return to original core */
2258         si_restore_core(sih, origidx, intr_val);
2259 }
2260
2261 static void
2262 si_pmu_spuravoid_pllupdate(si_t *sih, chipcregs_t *cc, osl_t *osh,
2263                            u8 spuravoid)
2264 {
2265         u32 tmp = 0;
2266         u8 phypll_offset = 0;
2267         u8 bcm5357_bcm43236_p1div[] = { 0x1, 0x5, 0x5 };
2268         u8 bcm5357_bcm43236_ndiv[] = { 0x30, 0xf6, 0xfc };
2269
2270         switch (CHIPID(sih->chip)) {
2271         case BCM5357_CHIP_ID:
2272         case BCM43235_CHIP_ID:
2273         case BCM43236_CHIP_ID:
2274         case BCM43238_CHIP_ID:
2275
2276                 /* BCM5357 needs to touch PLL1_PLLCTL[02], so offset PLL0_PLLCTL[02] by 6 */
2277                 phypll_offset = (CHIPID(sih->chip) == BCM5357_CHIP_ID) ? 6 : 0;
2278
2279                 /* RMW only the P1 divider */
2280                 W_REG(osh, &cc->pllcontrol_addr,
2281                       PMU1_PLL0_PLLCTL0 + phypll_offset);
2282                 tmp = R_REG(osh, &cc->pllcontrol_data);
2283                 tmp &= (~(PMU1_PLL0_PC0_P1DIV_MASK));
2284                 tmp |=
2285                     (bcm5357_bcm43236_p1div[spuravoid] <<
2286                      PMU1_PLL0_PC0_P1DIV_SHIFT);
2287                 W_REG(osh, &cc->pllcontrol_data, tmp);
2288
2289                 /* RMW only the int feedback divider */
2290                 W_REG(osh, &cc->pllcontrol_addr,
2291                       PMU1_PLL0_PLLCTL2 + phypll_offset);
2292                 tmp = R_REG(osh, &cc->pllcontrol_data);
2293                 tmp &= ~(PMU1_PLL0_PC2_NDIV_INT_MASK);
2294                 tmp |=
2295                     (bcm5357_bcm43236_ndiv[spuravoid]) <<
2296                     PMU1_PLL0_PC2_NDIV_INT_SHIFT;
2297                 W_REG(osh, &cc->pllcontrol_data, tmp);
2298
2299                 tmp = 1 << 10;
2300                 break;
2301
2302         case BCM4331_CHIP_ID:
2303                 if (spuravoid == 2) {
2304                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2305                         W_REG(osh, &cc->pllcontrol_data, 0x11500014);
2306                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2307                         W_REG(osh, &cc->pllcontrol_data, 0x0FC00a08);
2308                 } else if (spuravoid == 1) {
2309                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2310                         W_REG(osh, &cc->pllcontrol_data, 0x11500014);
2311                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2312                         W_REG(osh, &cc->pllcontrol_data, 0x0F600a08);
2313                 } else {
2314                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2315                         W_REG(osh, &cc->pllcontrol_data, 0x11100014);
2316                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2317                         W_REG(osh, &cc->pllcontrol_data, 0x03000a08);
2318                 }
2319                 tmp = 1 << 10;
2320                 break;
2321
2322         case BCM43224_CHIP_ID:
2323         case BCM43225_CHIP_ID:
2324         case BCM43421_CHIP_ID:
2325         case BCM6362_CHIP_ID:
2326                 if (spuravoid == 1) {
2327                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2328                         W_REG(osh, &cc->pllcontrol_data, 0x11500010);
2329                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2330                         W_REG(osh, &cc->pllcontrol_data, 0x000C0C06);
2331                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2332                         W_REG(osh, &cc->pllcontrol_data, 0x0F600a08);
2333                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2334                         W_REG(osh, &cc->pllcontrol_data, 0x00000000);
2335                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2336                         W_REG(osh, &cc->pllcontrol_data, 0x2001E920);
2337                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2338                         W_REG(osh, &cc->pllcontrol_data, 0x88888815);
2339                 } else {
2340                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2341                         W_REG(osh, &cc->pllcontrol_data, 0x11100010);
2342                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2343                         W_REG(osh, &cc->pllcontrol_data, 0x000c0c06);
2344                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2345                         W_REG(osh, &cc->pllcontrol_data, 0x03000a08);
2346                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2347                         W_REG(osh, &cc->pllcontrol_data, 0x00000000);
2348                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2349                         W_REG(osh, &cc->pllcontrol_data, 0x200005c0);
2350                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2351                         W_REG(osh, &cc->pllcontrol_data, 0x88888815);
2352                 }
2353                 tmp = 1 << 10;
2354                 break;
2355
2356                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2357                 W_REG(osh, &cc->pllcontrol_data, 0x11100008);
2358                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2359                 W_REG(osh, &cc->pllcontrol_data, 0x0c000c06);
2360                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2361                 W_REG(osh, &cc->pllcontrol_data, 0x03000a08);
2362                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2363                 W_REG(osh, &cc->pllcontrol_data, 0x00000000);
2364                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2365                 W_REG(osh, &cc->pllcontrol_data, 0x200005c0);
2366                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2367                 W_REG(osh, &cc->pllcontrol_data, 0x88888855);
2368
2369                 tmp = 1 << 10;
2370                 break;
2371
2372         case BCM4716_CHIP_ID:
2373         case BCM4748_CHIP_ID:
2374         case BCM47162_CHIP_ID:
2375                 if (spuravoid == 1) {
2376                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2377                         W_REG(osh, &cc->pllcontrol_data, 0x11500060);
2378                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2379                         W_REG(osh, &cc->pllcontrol_data, 0x080C0C06);
2380                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2381                         W_REG(osh, &cc->pllcontrol_data, 0x0F600000);
2382                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2383                         W_REG(osh, &cc->pllcontrol_data, 0x00000000);
2384                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2385                         W_REG(osh, &cc->pllcontrol_data, 0x2001E924);
2386                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2387                         W_REG(osh, &cc->pllcontrol_data, 0x88888815);
2388                 } else {
2389                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2390                         W_REG(osh, &cc->pllcontrol_data, 0x11100060);
2391                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2392                         W_REG(osh, &cc->pllcontrol_data, 0x080c0c06);
2393                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2394                         W_REG(osh, &cc->pllcontrol_data, 0x03000000);
2395                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2396                         W_REG(osh, &cc->pllcontrol_data, 0x00000000);
2397                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2398                         W_REG(osh, &cc->pllcontrol_data, 0x200005c0);
2399                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2400                         W_REG(osh, &cc->pllcontrol_data, 0x88888815);
2401                 }
2402
2403                 tmp = 3 << 9;
2404                 break;
2405
2406         case BCM4319_CHIP_ID:
2407                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2408                 W_REG(osh, &cc->pllcontrol_data, 0x11100070);
2409                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2410                 W_REG(osh, &cc->pllcontrol_data, 0x1014140a);
2411                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2412                 W_REG(osh, &cc->pllcontrol_data, 0x88888854);
2413
2414                 if (spuravoid == 1) {   /* spur_avoid ON, enable 41/82/164Mhz clock mode */
2415                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2416                         W_REG(osh, &cc->pllcontrol_data, 0x05201828);
2417                 } else {        /* enable 40/80/160Mhz clock mode */
2418                         W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2419                         W_REG(osh, &cc->pllcontrol_data, 0x05001828);
2420                 }
2421                 break;
2422         case BCM4336_CHIP_ID:
2423                 /* Looks like these are only for default xtal freq 26MHz */
2424                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL0);
2425                 W_REG(osh, &cc->pllcontrol_data, 0x02100020);
2426
2427                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL1);
2428                 W_REG(osh, &cc->pllcontrol_data, 0x0C0C0C0C);
2429
2430                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL2);
2431                 W_REG(osh, &cc->pllcontrol_data, 0x01240C0C);
2432
2433                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL4);
2434                 W_REG(osh, &cc->pllcontrol_data, 0x202C2820);
2435
2436                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL5);
2437                 W_REG(osh, &cc->pllcontrol_data, 0x88888825);
2438
2439                 W_REG(osh, &cc->pllcontrol_addr, PMU1_PLL0_PLLCTL3);
2440                 if (spuravoid == 1) {
2441                         W_REG(osh, &cc->pllcontrol_data, 0x00EC4EC4);
2442                 } else {
2443                         W_REG(osh, &cc->pllcontrol_data, 0x00762762);
2444                 }
2445
2446                 tmp = PCTL_PLL_PLLCTL_UPD;
2447                 break;
2448
2449         default:
2450                 PMU_ERROR(("%s: unknown spuravoidance settings for chip %s, not changing PLL\n", __func__, bcm_chipname(sih->chip, chn, 8)));
2451                 break;
2452         }
2453
2454         tmp |= R_REG(osh, &cc->pmucontrol);
2455         W_REG(osh, &cc->pmucontrol, tmp);
2456 }
2457
2458 bool si_pmu_is_otp_powered(si_t *sih, osl_t *osh)
2459 {
2460         uint idx;
2461         chipcregs_t *cc;
2462         bool st;
2463
2464         /* Remember original core before switch to chipc */
2465         idx = si_coreidx(sih);
2466         cc = si_setcoreidx(sih, SI_CC_IDX);
2467         ASSERT(cc != NULL);
2468
2469         switch (CHIPID(sih->chip)) {
2470         case BCM4329_CHIP_ID:
2471                 st = (R_REG(osh, &cc->res_state) & PMURES_BIT(RES4329_OTP_PU))
2472                     != 0;
2473                 break;
2474         case BCM4319_CHIP_ID:
2475                 st = (R_REG(osh, &cc->res_state) & PMURES_BIT(RES4319_OTP_PU))
2476                     != 0;
2477                 break;
2478         case BCM4336_CHIP_ID:
2479                 st = (R_REG(osh, &cc->res_state) & PMURES_BIT(RES4336_OTP_PU))
2480                     != 0;
2481                 break;
2482         case BCM4330_CHIP_ID:
2483                 st = (R_REG(osh, &cc->res_state) & PMURES_BIT(RES4330_OTP_PU))
2484                     != 0;
2485                 break;
2486
2487                 /* These chip doesn't use PMU bit to power up/down OTP. OTP always on.
2488                  * Use OTP_INIT command to reset/refresh state.
2489                  */
2490         case BCM43224_CHIP_ID:
2491         case BCM43225_CHIP_ID:
2492         case BCM43421_CHIP_ID:
2493         case BCM43236_CHIP_ID:
2494         case BCM43235_CHIP_ID:
2495         case BCM43238_CHIP_ID:
2496                 st = TRUE;
2497                 break;
2498         default:
2499                 st = TRUE;
2500                 break;
2501         }
2502
2503         /* Return to original core */
2504         si_setcoreidx(sih, idx);
2505         return st;
2506 }
2507
2508 void
2509 #if defined(BCMDBG)
2510 si_pmu_sprom_enable(si_t *sih, osl_t *osh, bool enable)
2511 #else
2512 BCMATTACHFN(si_pmu_sprom_enable) (si_t *sih, osl_t *osh, bool enable)
2513 #endif
2514 {
2515         chipcregs_t *cc;
2516         uint origidx;
2517
2518         /* Remember original core before switch to chipc */
2519         origidx = si_coreidx(sih);
2520         cc = si_setcoreidx(sih, SI_CC_IDX);
2521         ASSERT(cc != NULL);
2522
2523         /* Return to original core */
2524         si_setcoreidx(sih, origidx);
2525 }
2526
2527 /* initialize PMU chip controls and other chip level stuff */
2528 void BCMATTACHFN(si_pmu_chip_init) (si_t *sih, osl_t *osh)
2529 {
2530         uint origidx;
2531
2532         ASSERT(sih->cccaps & CC_CAP_PMU);
2533
2534 #ifdef CHIPC_UART_ALWAYS_ON
2535         si_corereg(sih, SI_CC_IDX, offsetof(chipcregs_t, clk_ctl_st),
2536                    CCS_FORCEALP, CCS_FORCEALP);
2537 #endif                          /* CHIPC_UART_ALWAYS_ON */
2538
2539         /* Gate off SPROM clock and chip select signals */
2540         si_pmu_sprom_enable(sih, osh, FALSE);
2541
2542         /* Remember original core */
2543         origidx = si_coreidx(sih);
2544
2545         /* Return to original core */
2546         si_setcoreidx(sih, origidx);
2547 }
2548
2549 /* initialize PMU switch/regulators */
2550 void BCMATTACHFN(si_pmu_swreg_init) (si_t *sih, osl_t *osh)
2551 {
2552         ASSERT(sih->cccaps & CC_CAP_PMU);
2553
2554         switch (CHIPID(sih->chip)) {
2555         case BCM4336_CHIP_ID:
2556                 /* Reduce CLDO PWM output voltage to 1.2V */
2557                 si_pmu_set_ldo_voltage(sih, osh, SET_LDO_VOLTAGE_CLDO_PWM, 0xe);
2558                 /* Reduce CLDO BURST output voltage to 1.2V */
2559                 si_pmu_set_ldo_voltage(sih, osh, SET_LDO_VOLTAGE_CLDO_BURST,
2560                                        0xe);
2561                 /* Reduce LNLDO1 output voltage to 1.2V */
2562                 si_pmu_set_ldo_voltage(sih, osh, SET_LDO_VOLTAGE_LNLDO1, 0xe);
2563                 if (CHIPREV(sih->chiprev) == 0)
2564                         si_pmu_regcontrol(sih, 2, 0x400000, 0x400000);
2565                 break;
2566
2567         case BCM4330_CHIP_ID:
2568                 /* CBUCK Voltage is 1.8 by default and set that to 1.5 */
2569                 si_pmu_set_ldo_voltage(sih, osh, SET_LDO_VOLTAGE_CBUCK_PWM, 0);
2570                 break;
2571         default:
2572                 break;
2573         }
2574 }
2575
2576 void si_pmu_radio_enable(si_t *sih, bool enable)
2577 {
2578         ASSERT(sih->cccaps & CC_CAP_PMU);
2579
2580         switch (CHIPID(sih->chip)) {
2581         case BCM4319_CHIP_ID:
2582                 if (enable)
2583                         si_write_wrapperreg(sih, AI_OOBSELOUTB74,
2584                                             (u32) 0x868584);
2585                 else
2586                         si_write_wrapperreg(sih, AI_OOBSELOUTB74,
2587                                             (u32) 0x060584);
2588                 break;
2589         }
2590 }
2591
2592 /* Wait for a particular clock level to be on the backplane */
2593 u32
2594 si_pmu_waitforclk_on_backplane(si_t *sih, osl_t *osh, u32 clk,
2595                                u32 delay)
2596 {
2597         chipcregs_t *cc;
2598         uint origidx;
2599
2600         ASSERT(sih->cccaps & CC_CAP_PMU);
2601
2602         /* Remember original core before switch to chipc */
2603         origidx = si_coreidx(sih);
2604         cc = si_setcoreidx(sih, SI_CC_IDX);
2605         ASSERT(cc != NULL);
2606
2607         if (delay)
2608                 SPINWAIT(((R_REG(osh, &cc->pmustatus) & clk) != clk), delay);
2609
2610         /* Return to original core */
2611         si_setcoreidx(sih, origidx);
2612
2613         return R_REG(osh, &cc->pmustatus) & clk;
2614 }
2615
2616 /*
2617  * Measures the ALP clock frequency in KHz.  Returns 0 if not possible.
2618  * Possible only if PMU rev >= 10 and there is an external LPO 32768Hz crystal.
2619  */
2620
2621 #define EXT_ILP_HZ 32768
2622
2623 u32 BCMATTACHFN(si_pmu_measure_alpclk) (si_t *sih, osl_t *osh)
2624 {
2625         chipcregs_t *cc;
2626         uint origidx;
2627         u32 alp_khz;
2628
2629         if (sih->pmurev < 10)
2630                 return 0;
2631
2632         ASSERT(sih->cccaps & CC_CAP_PMU);
2633
2634         /* Remember original core before switch to chipc */
2635         origidx = si_coreidx(sih);
2636         cc = si_setcoreidx(sih, SI_CC_IDX);
2637         ASSERT(cc != NULL);
2638
2639         if (R_REG(osh, &cc->pmustatus) & PST_EXTLPOAVAIL) {
2640                 u32 ilp_ctr, alp_hz;
2641
2642                 /* Enable the reg to measure the freq, in case disabled before */
2643                 W_REG(osh, &cc->pmu_xtalfreq,
2644                       1U << PMU_XTALFREQ_REG_MEASURE_SHIFT);
2645
2646                 /* Delay for well over 4 ILP clocks */
2647                 OSL_DELAY(1000);
2648
2649                 /* Read the latched number of ALP ticks per 4 ILP ticks */
2650                 ilp_ctr =
2651                     R_REG(osh,
2652                           &cc->pmu_xtalfreq) & PMU_XTALFREQ_REG_ILPCTR_MASK;
2653
2654                 /* Turn off the PMU_XTALFREQ_REG_MEASURE_SHIFT bit to save power */
2655                 W_REG(osh, &cc->pmu_xtalfreq, 0);
2656
2657                 /* Calculate ALP frequency */
2658                 alp_hz = (ilp_ctr * EXT_ILP_HZ) / 4;
2659
2660                 /* Round to nearest 100KHz, and at the same time convert to KHz */
2661                 alp_khz = (alp_hz + 50000) / 100000 * 100;
2662         } else
2663                 alp_khz = 0;
2664
2665         /* Return to original core */
2666         si_setcoreidx(sih, origidx);
2667
2668         return alp_khz;
2669 }
2670
2671 static void BCMATTACHFN(si_pmu_set_4330_plldivs) (si_t *sih)
2672 {
2673         u32 FVCO = si_pmu1_pllfvco0(sih) / 1000;
2674         u32 m1div, m2div, m3div, m4div, m5div, m6div;
2675         u32 pllc1, pllc2;
2676
2677         m2div = m3div = m4div = m6div = FVCO / 80;
2678         m5div = FVCO / 160;
2679
2680         if (CST4330_CHIPMODE_SDIOD(sih->chipst))
2681                 m1div = FVCO / 80;
2682         else
2683                 m1div = FVCO / 90;
2684         pllc1 =
2685             (m1div << PMU1_PLL0_PC1_M1DIV_SHIFT) | (m2div <<
2686                                                     PMU1_PLL0_PC1_M2DIV_SHIFT) |
2687             (m3div << PMU1_PLL0_PC1_M3DIV_SHIFT) | (m4div <<
2688                                                     PMU1_PLL0_PC1_M4DIV_SHIFT);
2689         si_pmu_pllcontrol(sih, PMU1_PLL0_PLLCTL1, ~0, pllc1);
2690
2691         pllc2 = si_pmu_pllcontrol(sih, PMU1_PLL0_PLLCTL1, 0, 0);
2692         pllc2 &= ~(PMU1_PLL0_PC2_M5DIV_MASK | PMU1_PLL0_PC2_M6DIV_MASK);
2693         pllc2 |=
2694             ((m5div << PMU1_PLL0_PC2_M5DIV_SHIFT) |
2695              (m6div << PMU1_PLL0_PC2_M6DIV_SHIFT));
2696         si_pmu_pllcontrol(sih, PMU1_PLL0_PLLCTL2, ~0, pllc2);
2697 }