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