arch/arm/cpu/arm926ejs/mxs/spl_power_init.c

   1 /*
   2  * Freescale i.MX28 Boot PMIC init
   3  *
   4  * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
   5  * on behalf of DENX Software Engineering GmbH
   6  *
   7  * See file CREDITS for list of people who contributed to this
   8  * project.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23  * MA 02111-1307 USA
  24  */
  25
  26 #include <common.h>
  27 #include <config.h>
  28 #include <asm/io.h>
  29 #include <asm/arch/imx-regs.h>
  30
  31 #include "mxs_init.h"
  32
  33 static void mxs_power_clock2xtal(void)
  34 {
  35         struct mxs_clkctrl_regs *clkctrl_regs =
  36                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
  37
  38         /* Set XTAL as CPU reference clock */
  39         writel(CLKCTRL_CLKSEQ_BYPASS_CPU,
  40                 &clkctrl_regs->hw_clkctrl_clkseq_set);
  41 }
  42
  43 static void mxs_power_clock2pll(void)
  44 {
  45         struct mxs_clkctrl_regs *clkctrl_regs =
  46                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
  47
  48         setbits_le32(&clkctrl_regs->hw_clkctrl_pll0ctrl0,
  49                         CLKCTRL_PLL0CTRL0_POWER);
  50         early_delay(100);
  51         setbits_le32(&clkctrl_regs->hw_clkctrl_clkseq,
  52                         CLKCTRL_CLKSEQ_BYPASS_CPU);
  53 }
  54
  55 static void mxs_power_clear_auto_restart(void)
  56 {
  57         struct mxs_rtc_regs *rtc_regs =
  58                 (struct mxs_rtc_regs *)MXS_RTC_BASE;
  59
  60         writel(RTC_CTRL_SFTRST, &rtc_regs->hw_rtc_ctrl_clr);
  61         while (readl(&rtc_regs->hw_rtc_ctrl) & RTC_CTRL_SFTRST)
  62                 ;
  63
  64         writel(RTC_CTRL_CLKGATE, &rtc_regs->hw_rtc_ctrl_clr);
  65         while (readl(&rtc_regs->hw_rtc_ctrl) & RTC_CTRL_CLKGATE)
  66                 ;
  67
  68         /*
  69          * Due to the hardware design bug of mx28 EVK-A
  70          * we need to set the AUTO_RESTART bit.
  71          */
  72         if (readl(&rtc_regs->hw_rtc_persistent0) & RTC_PERSISTENT0_AUTO_RESTART)
  73                 return;
  74
  75         while (readl(&rtc_regs->hw_rtc_stat) & RTC_STAT_NEW_REGS_MASK)
  76                 ;
  77
  78         setbits_le32(&rtc_regs->hw_rtc_persistent0,
  79                         RTC_PERSISTENT0_AUTO_RESTART);
  80         writel(RTC_CTRL_FORCE_UPDATE, &rtc_regs->hw_rtc_ctrl_set);
  81         writel(RTC_CTRL_FORCE_UPDATE, &rtc_regs->hw_rtc_ctrl_clr);
  82         while (readl(&rtc_regs->hw_rtc_stat) & RTC_STAT_NEW_REGS_MASK)
  83                 ;
  84         while (readl(&rtc_regs->hw_rtc_stat) & RTC_STAT_STALE_REGS_MASK)
  85                 ;
  86 }
  87
  88 static void mxs_power_set_linreg(void)
  89 {
  90         struct mxs_power_regs *power_regs =
  91                 (struct mxs_power_regs *)MXS_POWER_BASE;
  92
  93         /* Set linear regulator 25mV below switching converter */
  94         clrsetbits_le32(&power_regs->hw_power_vdddctrl,
  95                         POWER_VDDDCTRL_LINREG_OFFSET_MASK,
  96                         POWER_VDDDCTRL_LINREG_OFFSET_1STEPS_BELOW);
  97
  98         clrsetbits_le32(&power_regs->hw_power_vddactrl,
  99                         POWER_VDDACTRL_LINREG_OFFSET_MASK,
 100                         POWER_VDDACTRL_LINREG_OFFSET_1STEPS_BELOW);
 101
 102         clrsetbits_le32(&power_regs->hw_power_vddioctrl,
 103                         POWER_VDDIOCTRL_LINREG_OFFSET_MASK,
 104                         POWER_VDDIOCTRL_LINREG_OFFSET_1STEPS_BELOW);
 105 }
 106
 107 static int mxs_get_batt_volt(void)
 108 {
 109         struct mxs_power_regs *power_regs =
 110                 (struct mxs_power_regs *)MXS_POWER_BASE;
 111         uint32_t volt = readl(&power_regs->hw_power_battmonitor);
 112         volt &= POWER_BATTMONITOR_BATT_VAL_MASK;
 113         volt >>= POWER_BATTMONITOR_BATT_VAL_OFFSET;
 114         volt *= 8;
 115         return volt;
 116 }
 117
 118 static int mxs_is_batt_ready(void)
 119 {
 120         return (mxs_get_batt_volt() >= 3600);
 121 }
 122
 123 static int mxs_is_batt_good(void)
 124 {
 125         struct mxs_power_regs *power_regs =
 126                 (struct mxs_power_regs *)MXS_POWER_BASE;
 127         uint32_t volt = mxs_get_batt_volt();
 128
 129         if ((volt >= 2400) && (volt <= 4300))
 130                 return 1;
 131
 132         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 133                 POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK,
 134                 0x3 << POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET);
 135         writel(POWER_5VCTRL_PWD_CHARGE_4P2_MASK,
 136                 &power_regs->hw_power_5vctrl_clr);
 137
 138         clrsetbits_le32(&power_regs->hw_power_charge,
 139                 POWER_CHARGE_STOP_ILIMIT_MASK | POWER_CHARGE_BATTCHRG_I_MASK,
 140                 POWER_CHARGE_STOP_ILIMIT_10MA | 0x3);
 141
 142         writel(POWER_CHARGE_PWD_BATTCHRG, &power_regs->hw_power_charge_clr);
 143         writel(POWER_5VCTRL_PWD_CHARGE_4P2_MASK,
 144                 &power_regs->hw_power_5vctrl_clr);
 145
 146         early_delay(500000);
 147
 148         volt = mxs_get_batt_volt();
 149
 150         if (volt >= 3500)
 151                 return 0;
 152
 153         if (volt >= 2400)
 154                 return 1;
 155
 156         writel(POWER_CHARGE_STOP_ILIMIT_MASK | POWER_CHARGE_BATTCHRG_I_MASK,
 157                 &power_regs->hw_power_charge_clr);
 158         writel(POWER_CHARGE_PWD_BATTCHRG, &power_regs->hw_power_charge_set);
 159
 160         return 0;
 161 }
 162
 163 static void mxs_power_setup_5v_detect(void)
 164 {
 165         struct mxs_power_regs *power_regs =
 166                 (struct mxs_power_regs *)MXS_POWER_BASE;
 167
 168         /* Start 5V detection */
 169         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 170                         POWER_5VCTRL_VBUSVALID_TRSH_MASK,
 171                         POWER_5VCTRL_VBUSVALID_TRSH_4V4 |
 172                         POWER_5VCTRL_PWRUP_VBUS_CMPS);
 173 }
 174
 175 static void mxs_src_power_init(void)
 176 {
 177         struct mxs_power_regs *power_regs =
 178                 (struct mxs_power_regs *)MXS_POWER_BASE;
 179
 180         /* Improve efficieny and reduce transient ripple */
 181         writel(POWER_LOOPCTRL_TOGGLE_DIF | POWER_LOOPCTRL_EN_CM_HYST |
 182                 POWER_LOOPCTRL_EN_DF_HYST, &power_regs->hw_power_loopctrl_set);
 183
 184         clrsetbits_le32(&power_regs->hw_power_dclimits,
 185                         POWER_DCLIMITS_POSLIMIT_BUCK_MASK,
 186                         0x30 << POWER_DCLIMITS_POSLIMIT_BUCK_OFFSET);
 187
 188         setbits_le32(&power_regs->hw_power_battmonitor,
 189                         POWER_BATTMONITOR_EN_BATADJ);
 190
 191         /* Increase the RCSCALE level for quick DCDC response to dynamic load */
 192         clrsetbits_le32(&power_regs->hw_power_loopctrl,
 193                         POWER_LOOPCTRL_EN_RCSCALE_MASK,
 194                         POWER_LOOPCTRL_RCSCALE_THRESH |
 195                         POWER_LOOPCTRL_EN_RCSCALE_8X);
 196
 197         clrsetbits_le32(&power_regs->hw_power_minpwr,
 198                         POWER_MINPWR_HALFFETS, POWER_MINPWR_DOUBLE_FETS);
 199
 200         /* 5V to battery handoff ... FIXME */
 201         setbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_DCDC_XFER);
 202         early_delay(30);
 203         clrbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_DCDC_XFER);
 204 }
 205
 206 static void mxs_power_init_4p2_params(void)
 207 {
 208         struct mxs_power_regs *power_regs =
 209                 (struct mxs_power_regs *)MXS_POWER_BASE;
 210
 211         /* Setup 4P2 parameters */
 212         clrsetbits_le32(&power_regs->hw_power_dcdc4p2,
 213                 POWER_DCDC4P2_CMPTRIP_MASK | POWER_DCDC4P2_TRG_MASK,
 214                 POWER_DCDC4P2_TRG_4V2 | (31 << POWER_DCDC4P2_CMPTRIP_OFFSET));
 215
 216         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 217                 POWER_5VCTRL_HEADROOM_ADJ_MASK,
 218                 0x4 << POWER_5VCTRL_HEADROOM_ADJ_OFFSET);
 219
 220         clrsetbits_le32(&power_regs->hw_power_dcdc4p2,
 221                 POWER_DCDC4P2_DROPOUT_CTRL_MASK,
 222                 POWER_DCDC4P2_DROPOUT_CTRL_100MV |
 223                 POWER_DCDC4P2_DROPOUT_CTRL_SRC_SEL);
 224
 225         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 226                 POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK,
 227                 0x3f << POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET);
 228 }
 229
 230 static void mxs_enable_4p2_dcdc_input(int xfer)
 231 {
 232         struct mxs_power_regs *power_regs =
 233                 (struct mxs_power_regs *)MXS_POWER_BASE;
 234         uint32_t tmp, vbus_thresh, vbus_5vdetect, pwd_bo;
 235         uint32_t prev_5v_brnout, prev_5v_droop;
 236
 237         prev_5v_brnout = readl(&power_regs->hw_power_5vctrl) &
 238                                 POWER_5VCTRL_PWDN_5VBRNOUT;
 239         prev_5v_droop = readl(&power_regs->hw_power_ctrl) &
 240                                 POWER_CTRL_ENIRQ_VDD5V_DROOP;
 241
 242         clrbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_PWDN_5VBRNOUT);
 243         writel(POWER_RESET_UNLOCK_KEY | POWER_RESET_PWD_OFF,
 244                 &power_regs->hw_power_reset);
 245
 246         clrbits_le32(&power_regs->hw_power_ctrl, POWER_CTRL_ENIRQ_VDD5V_DROOP);
 247
 248         if (xfer && (readl(&power_regs->hw_power_5vctrl) &
 249                         POWER_5VCTRL_ENABLE_DCDC)) {
 250                 return;
 251         }
 252
 253         /*
 254          * Recording orignal values that will be modified temporarlily
 255          * to handle a chip bug. See chip errata for CQ ENGR00115837
 256          */
 257         tmp = readl(&power_regs->hw_power_5vctrl);
 258         vbus_thresh = tmp & POWER_5VCTRL_VBUSVALID_TRSH_MASK;
 259         vbus_5vdetect = tmp & POWER_5VCTRL_VBUSVALID_5VDETECT;
 260
 261         pwd_bo = readl(&power_regs->hw_power_minpwr) & POWER_MINPWR_PWD_BO;
 262
 263         /*
 264          * Disable mechanisms that get erroneously tripped by when setting
 265          * the DCDC4P2 EN_DCDC
 266          */
 267         clrbits_le32(&power_regs->hw_power_5vctrl,
 268                 POWER_5VCTRL_VBUSVALID_5VDETECT |
 269                 POWER_5VCTRL_VBUSVALID_TRSH_MASK);
 270
 271         writel(POWER_MINPWR_PWD_BO, &power_regs->hw_power_minpwr_set);
 272
 273         if (xfer) {
 274                 setbits_le32(&power_regs->hw_power_5vctrl,
 275                                 POWER_5VCTRL_DCDC_XFER);
 276                 early_delay(20);
 277                 clrbits_le32(&power_regs->hw_power_5vctrl,
 278                                 POWER_5VCTRL_DCDC_XFER);
 279
 280                 setbits_le32(&power_regs->hw_power_5vctrl,
 281                                 POWER_5VCTRL_ENABLE_DCDC);
 282         } else {
 283                 setbits_le32(&power_regs->hw_power_dcdc4p2,
 284                                 POWER_DCDC4P2_ENABLE_DCDC);
 285         }
 286
 287         early_delay(25);
 288
 289         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 290                         POWER_5VCTRL_VBUSVALID_TRSH_MASK, vbus_thresh);
 291
 292         if (vbus_5vdetect)
 293                 writel(vbus_5vdetect, &power_regs->hw_power_5vctrl_set);
 294
 295         if (!pwd_bo)
 296                 clrbits_le32(&power_regs->hw_power_minpwr, POWER_MINPWR_PWD_BO);
 297
 298         while (readl(&power_regs->hw_power_ctrl) & POWER_CTRL_VBUS_VALID_IRQ)
 299                 writel(POWER_CTRL_VBUS_VALID_IRQ,
 300                         &power_regs->hw_power_ctrl_clr);
 301
 302         if (prev_5v_brnout) {
 303                 writel(POWER_5VCTRL_PWDN_5VBRNOUT,
 304                         &power_regs->hw_power_5vctrl_set);
 305                 writel(POWER_RESET_UNLOCK_KEY,
 306                         &power_regs->hw_power_reset);
 307         } else {
 308                 writel(POWER_5VCTRL_PWDN_5VBRNOUT,
 309                         &power_regs->hw_power_5vctrl_clr);
 310                 writel(POWER_RESET_UNLOCK_KEY | POWER_RESET_PWD_OFF,
 311                         &power_regs->hw_power_reset);
 312         }
 313
 314         while (readl(&power_regs->hw_power_ctrl) & POWER_CTRL_VDD5V_DROOP_IRQ)
 315                 writel(POWER_CTRL_VDD5V_DROOP_IRQ,
 316                         &power_regs->hw_power_ctrl_clr);
 317
 318         if (prev_5v_droop)
 319                 clrbits_le32(&power_regs->hw_power_ctrl,
 320                                 POWER_CTRL_ENIRQ_VDD5V_DROOP);
 321         else
 322                 setbits_le32(&power_regs->hw_power_ctrl,
 323                                 POWER_CTRL_ENIRQ_VDD5V_DROOP);
 324 }
 325
 326 static void mxs_power_init_4p2_regulator(void)
 327 {
 328         struct mxs_power_regs *power_regs =
 329                 (struct mxs_power_regs *)MXS_POWER_BASE;
 330         uint32_t tmp, tmp2;
 331
 332         setbits_le32(&power_regs->hw_power_dcdc4p2, POWER_DCDC4P2_ENABLE_4P2);
 333
 334         writel(POWER_CHARGE_ENABLE_LOAD, &power_regs->hw_power_charge_set);
 335
 336         writel(POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK,
 337                 &power_regs->hw_power_5vctrl_clr);
 338         clrbits_le32(&power_regs->hw_power_dcdc4p2, POWER_DCDC4P2_TRG_MASK);
 339
 340         /* Power up the 4p2 rail and logic/control */
 341         writel(POWER_5VCTRL_PWD_CHARGE_4P2_MASK,
 342                 &power_regs->hw_power_5vctrl_clr);
 343
 344         /*
 345          * Start charging up the 4p2 capacitor. We ramp of this charge
 346          * gradually to avoid large inrush current from the 5V cable which can
 347          * cause transients/problems
 348          */
 349         mxs_enable_4p2_dcdc_input(0);
 350
 351         if (readl(&power_regs->hw_power_ctrl) & POWER_CTRL_VBUS_VALID_IRQ) {
 352                 /*
 353                  * If we arrived here, we were unable to recover from mx23 chip
 354                  * errata 5837. 4P2 is disabled and sufficient battery power is
 355                  * not present. Exiting to not enable DCDC power during 5V
 356                  * connected state.
 357                  */
 358                 clrbits_le32(&power_regs->hw_power_dcdc4p2,
 359                         POWER_DCDC4P2_ENABLE_DCDC);
 360                 writel(POWER_5VCTRL_PWD_CHARGE_4P2_MASK,
 361                         &power_regs->hw_power_5vctrl_set);
 362                 hang();
 363         }
 364
 365         /*
 366          * Here we set the 4p2 brownout level to something very close to 4.2V.
 367          * We then check the brownout status. If the brownout status is false,
 368          * the voltage is already close to the target voltage of 4.2V so we
 369          * can go ahead and set the 4P2 current limit to our max target limit.
 370          * If the brownout status is true, we need to ramp us the current limit
 371          * so that we don't cause large inrush current issues. We step up the
 372          * current limit until the brownout status is false or until we've
 373          * reached our maximum defined 4p2 current limit.
 374          */
 375         clrsetbits_le32(&power_regs->hw_power_dcdc4p2,
 376                         POWER_DCDC4P2_BO_MASK,
 377                         22 << POWER_DCDC4P2_BO_OFFSET); /* 4.15V */
 378
 379         if (!(readl(&power_regs->hw_power_sts) & POWER_STS_DCDC_4P2_BO)) {
 380                 setbits_le32(&power_regs->hw_power_5vctrl,
 381                         0x3f << POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET);
 382         } else {
 383                 tmp = (readl(&power_regs->hw_power_5vctrl) &
 384                         POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK) >>
 385                         POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET;
 386                 while (tmp < 0x3f) {
 387                         if (!(readl(&power_regs->hw_power_sts) &
 388                                         POWER_STS_DCDC_4P2_BO)) {
 389                                 tmp = readl(&power_regs->hw_power_5vctrl);
 390                                 tmp |= POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK;
 391                                 early_delay(100);
 392                                 writel(tmp, &power_regs->hw_power_5vctrl);
 393                                 break;
 394                         } else {
 395                                 tmp++;
 396                                 tmp2 = readl(&power_regs->hw_power_5vctrl);
 397                                 tmp2 &= ~POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK;
 398                                 tmp2 |= tmp <<
 399                                         POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET;
 400                                 writel(tmp2, &power_regs->hw_power_5vctrl);
 401                                 early_delay(100);
 402                         }
 403                 }
 404         }
 405
 406         clrbits_le32(&power_regs->hw_power_dcdc4p2, POWER_DCDC4P2_BO_MASK);
 407         writel(POWER_CTRL_DCDC4P2_BO_IRQ, &power_regs->hw_power_ctrl_clr);
 408 }
 409
 410 static void mxs_power_init_dcdc_4p2_source(void)
 411 {
 412         struct mxs_power_regs *power_regs =
 413                 (struct mxs_power_regs *)MXS_POWER_BASE;
 414
 415         if (!(readl(&power_regs->hw_power_dcdc4p2) &
 416                 POWER_DCDC4P2_ENABLE_DCDC)) {
 417                 hang();
 418         }
 419
 420         mxs_enable_4p2_dcdc_input(1);
 421
 422         if (readl(&power_regs->hw_power_ctrl) & POWER_CTRL_VBUS_VALID_IRQ) {
 423                 clrbits_le32(&power_regs->hw_power_dcdc4p2,
 424                         POWER_DCDC4P2_ENABLE_DCDC);
 425                 writel(POWER_5VCTRL_ENABLE_DCDC,
 426                         &power_regs->hw_power_5vctrl_clr);
 427                 writel(POWER_5VCTRL_PWD_CHARGE_4P2_MASK,
 428                         &power_regs->hw_power_5vctrl_set);
 429         }
 430 }
 431
 432 static void mxs_power_enable_4p2(void)
 433 {
 434         struct mxs_power_regs *power_regs =
 435                 (struct mxs_power_regs *)MXS_POWER_BASE;
 436         uint32_t vdddctrl, vddactrl, vddioctrl;
 437         uint32_t tmp;
 438
 439         vdddctrl = readl(&power_regs->hw_power_vdddctrl);
 440         vddactrl = readl(&power_regs->hw_power_vddactrl);
 441         vddioctrl = readl(&power_regs->hw_power_vddioctrl);
 442
 443         setbits_le32(&power_regs->hw_power_vdddctrl,
 444                 POWER_VDDDCTRL_DISABLE_FET | POWER_VDDDCTRL_ENABLE_LINREG |
 445                 POWER_VDDDCTRL_PWDN_BRNOUT);
 446
 447         setbits_le32(&power_regs->hw_power_vddactrl,
 448                 POWER_VDDACTRL_DISABLE_FET | POWER_VDDACTRL_ENABLE_LINREG |
 449                 POWER_VDDACTRL_PWDN_BRNOUT);
 450
 451         setbits_le32(&power_regs->hw_power_vddioctrl,
 452                 POWER_VDDIOCTRL_DISABLE_FET | POWER_VDDIOCTRL_PWDN_BRNOUT);
 453
 454         mxs_power_init_4p2_params();
 455         mxs_power_init_4p2_regulator();
 456
 457         /* Shutdown battery (none present) */
 458         if (!mxs_is_batt_ready()) {
 459                 clrbits_le32(&power_regs->hw_power_dcdc4p2,
 460                                 POWER_DCDC4P2_BO_MASK);
 461                 writel(POWER_CTRL_DCDC4P2_BO_IRQ,
 462                                 &power_regs->hw_power_ctrl_clr);
 463                 writel(POWER_CTRL_ENIRQ_DCDC4P2_BO,
 464                                 &power_regs->hw_power_ctrl_clr);
 465         }
 466
 467         mxs_power_init_dcdc_4p2_source();
 468
 469         writel(vdddctrl, &power_regs->hw_power_vdddctrl);
 470         early_delay(20);
 471         writel(vddactrl, &power_regs->hw_power_vddactrl);
 472         early_delay(20);
 473         writel(vddioctrl, &power_regs->hw_power_vddioctrl);
 474
 475         /*
 476          * Check if FET is enabled on either powerout and if so,
 477          * disable load.
 478          */
 479         tmp = 0;
 480         tmp |= !(readl(&power_regs->hw_power_vdddctrl) &
 481                         POWER_VDDDCTRL_DISABLE_FET);
 482         tmp |= !(readl(&power_regs->hw_power_vddactrl) &
 483                         POWER_VDDACTRL_DISABLE_FET);
 484         tmp |= !(readl(&power_regs->hw_power_vddioctrl) &
 485                         POWER_VDDIOCTRL_DISABLE_FET);
 486         if (tmp)
 487                 writel(POWER_CHARGE_ENABLE_LOAD,
 488                         &power_regs->hw_power_charge_clr);
 489 }
 490
 491 static void mxs_boot_valid_5v(void)
 492 {
 493         struct mxs_power_regs *power_regs =
 494                 (struct mxs_power_regs *)MXS_POWER_BASE;
 495
 496         /*
 497          * Use VBUSVALID level instead of VDD5V_GT_VDDIO level to trigger a 5V
 498          * disconnect event. FIXME
 499          */
 500         writel(POWER_5VCTRL_VBUSVALID_5VDETECT,
 501                 &power_regs->hw_power_5vctrl_set);
 502
 503         /* Configure polarity to check for 5V disconnection. */
 504         writel(POWER_CTRL_POLARITY_VBUSVALID |
 505                 POWER_CTRL_POLARITY_VDD5V_GT_VDDIO,
 506                 &power_regs->hw_power_ctrl_clr);
 507
 508         writel(POWER_CTRL_VBUS_VALID_IRQ | POWER_CTRL_VDD5V_GT_VDDIO_IRQ,
 509                 &power_regs->hw_power_ctrl_clr);
 510
 511         mxs_power_enable_4p2();
 512 }
 513
 514 static void mxs_powerdown(void)
 515 {
 516         struct mxs_power_regs *power_regs =
 517                 (struct mxs_power_regs *)MXS_POWER_BASE;
 518         writel(POWER_RESET_UNLOCK_KEY, &power_regs->hw_power_reset);
 519         writel(POWER_RESET_UNLOCK_KEY | POWER_RESET_PWD_OFF,
 520                 &power_regs->hw_power_reset);
 521 }
 522
 523 static void mxs_batt_boot(void)
 524 {
 525         struct mxs_power_regs *power_regs =
 526                 (struct mxs_power_regs *)MXS_POWER_BASE;
 527
 528         clrbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_PWDN_5VBRNOUT);
 529         clrbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_ENABLE_DCDC);
 530
 531         clrbits_le32(&power_regs->hw_power_dcdc4p2,
 532                         POWER_DCDC4P2_ENABLE_DCDC | POWER_DCDC4P2_ENABLE_4P2);
 533         writel(POWER_CHARGE_ENABLE_LOAD, &power_regs->hw_power_charge_clr);
 534
 535         /* 5V to battery handoff. */
 536         setbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_DCDC_XFER);
 537         early_delay(30);
 538         clrbits_le32(&power_regs->hw_power_5vctrl, POWER_5VCTRL_DCDC_XFER);
 539
 540         writel(POWER_CTRL_ENIRQ_DCDC4P2_BO, &power_regs->hw_power_ctrl_clr);
 541
 542         clrsetbits_le32(&power_regs->hw_power_minpwr,
 543                         POWER_MINPWR_HALFFETS, POWER_MINPWR_DOUBLE_FETS);
 544
 545         mxs_power_set_linreg();
 546
 547         clrbits_le32(&power_regs->hw_power_vdddctrl,
 548                 POWER_VDDDCTRL_DISABLE_FET | POWER_VDDDCTRL_ENABLE_LINREG);
 549
 550         clrbits_le32(&power_regs->hw_power_vddactrl,
 551                 POWER_VDDACTRL_DISABLE_FET | POWER_VDDACTRL_ENABLE_LINREG);
 552
 553         clrbits_le32(&power_regs->hw_power_vddioctrl,
 554                 POWER_VDDIOCTRL_DISABLE_FET);
 555
 556         setbits_le32(&power_regs->hw_power_5vctrl,
 557                 POWER_5VCTRL_PWD_CHARGE_4P2_MASK);
 558
 559         setbits_le32(&power_regs->hw_power_5vctrl,
 560                 POWER_5VCTRL_ENABLE_DCDC);
 561
 562         clrsetbits_le32(&power_regs->hw_power_5vctrl,
 563                 POWER_5VCTRL_CHARGE_4P2_ILIMIT_MASK,
 564                 0x8 << POWER_5VCTRL_CHARGE_4P2_ILIMIT_OFFSET);
 565 }
 566
 567 static void mxs_handle_5v_conflict(void)
 568 {
 569         struct mxs_power_regs *power_regs =
 570                 (struct mxs_power_regs *)MXS_POWER_BASE;
 571         uint32_t tmp;
 572
 573         setbits_le32(&power_regs->hw_power_vddioctrl,
 574                         POWER_VDDIOCTRL_BO_OFFSET_MASK);
 575
 576         for (;;) {
 577                 tmp = readl(&power_regs->hw_power_sts);
 578
 579                 if (tmp & POWER_STS_VDDIO_BO) {
 580                         /*
 581                          * VDDIO has a brownout, then the VDD5V_GT_VDDIO becomes
 582                          * unreliable
 583                          */
 584                         mxs_powerdown();
 585                         break;
 586                 }
 587
 588                 if (tmp & POWER_STS_VDD5V_GT_VDDIO) {
 589                         mxs_boot_valid_5v();
 590                         break;
 591                 } else {
 592                         mxs_powerdown();
 593                         break;
 594                 }
 595
 596                 if (tmp & POWER_STS_PSWITCH_MASK) {
 597                         mxs_batt_boot();
 598                         break;
 599                 }
 600         }
 601 }
 602
 603 static void mxs_5v_boot(void)
 604 {
 605         struct mxs_power_regs *power_regs =
 606                 (struct mxs_power_regs *)MXS_POWER_BASE;
 607
 608         /*
 609          * NOTE: In original IMX-Bootlets, this also checks for VBUSVALID,
 610          * but their implementation always returns 1 so we omit it here.
 611          */
 612         if (readl(&power_regs->hw_power_sts) & POWER_STS_VDD5V_GT_VDDIO) {
 613                 mxs_boot_valid_5v();
 614                 return;
 615         }
 616
 617         early_delay(1000);
 618         if (readl(&power_regs->hw_power_sts) & POWER_STS_VDD5V_GT_VDDIO) {
 619                 mxs_boot_valid_5v();
 620                 return;
 621         }
 622
 623         mxs_handle_5v_conflict();
 624 }
 625
 626 static void mxs_init_batt_bo(void)
 627 {
 628         struct mxs_power_regs *power_regs =
 629                 (struct mxs_power_regs *)MXS_POWER_BASE;
 630
 631         /* Brownout at 3V */
 632         clrsetbits_le32(&power_regs->hw_power_battmonitor,
 633                 POWER_BATTMONITOR_BRWNOUT_LVL_MASK,
 634                 15 << POWER_BATTMONITOR_BRWNOUT_LVL_OFFSET);
 635
 636         writel(POWER_CTRL_BATT_BO_IRQ, &power_regs->hw_power_ctrl_clr);
 637         writel(POWER_CTRL_ENIRQ_BATT_BO, &power_regs->hw_power_ctrl_clr);
 638 }
 639
 640 static void mxs_switch_vddd_to_dcdc_source(void)
 641 {
 642         struct mxs_power_regs *power_regs =
 643                 (struct mxs_power_regs *)MXS_POWER_BASE;
 644
 645         clrsetbits_le32(&power_regs->hw_power_vdddctrl,
 646                 POWER_VDDDCTRL_LINREG_OFFSET_MASK,
 647                 POWER_VDDDCTRL_LINREG_OFFSET_1STEPS_BELOW);
 648
 649         clrbits_le32(&power_regs->hw_power_vdddctrl,
 650                 POWER_VDDDCTRL_DISABLE_FET | POWER_VDDDCTRL_ENABLE_LINREG |
 651                 POWER_VDDDCTRL_DISABLE_STEPPING);
 652 }
 653
 654 static void mxs_power_configure_power_source(void)
 655 {
 656         int batt_ready, batt_good;
 657         struct mxs_power_regs *power_regs =
 658                 (struct mxs_power_regs *)MXS_POWER_BASE;
 659         struct mxs_lradc_regs *lradc_regs =
 660                 (struct mxs_lradc_regs *)MXS_LRADC_BASE;
 661
 662         mxs_src_power_init();
 663
 664         if (readl(&power_regs->hw_power_sts) & POWER_STS_VDD5V_GT_VDDIO) {
 665                 batt_ready = mxs_is_batt_ready();
 666                 if (batt_ready) {
 667                         /* 5V source detected, good battery detected. */
 668                         mxs_batt_boot();
 669                 } else {
 670                         batt_good = mxs_is_batt_good();
 671                         if (!batt_good) {
 672                                 /* 5V source detected, bad battery detected. */
 673                                 writel(LRADC_CONVERSION_AUTOMATIC,
 674                                         &lradc_regs->hw_lradc_conversion_clr);
 675                                 clrbits_le32(&power_regs->hw_power_battmonitor,
 676                                         POWER_BATTMONITOR_BATT_VAL_MASK);
 677                         }
 678                         mxs_5v_boot();
 679                 }
 680         } else {
 681                 /* 5V not detected, booting from battery. */
 682                 mxs_batt_boot();
 683         }
 684
 685         mxs_power_clock2pll();
 686
 687         mxs_init_batt_bo();
 688
 689         mxs_switch_vddd_to_dcdc_source();
 690 }
 691
 692 static void mxs_enable_output_rail_protection(void)
 693 {
 694         struct mxs_power_regs *power_regs =
 695                 (struct mxs_power_regs *)MXS_POWER_BASE;
 696
 697         writel(POWER_CTRL_VDDD_BO_IRQ | POWER_CTRL_VDDA_BO_IRQ |
 698                 POWER_CTRL_VDDIO_BO_IRQ, &power_regs->hw_power_ctrl_clr);
 699
 700         setbits_le32(&power_regs->hw_power_vdddctrl,
 701                         POWER_VDDDCTRL_PWDN_BRNOUT);
 702
 703         setbits_le32(&power_regs->hw_power_vddactrl,
 704                         POWER_VDDACTRL_PWDN_BRNOUT);
 705
 706         setbits_le32(&power_regs->hw_power_vddioctrl,
 707                         POWER_VDDIOCTRL_PWDN_BRNOUT);
 708 }
 709
 710 static int mxs_get_vddio_power_source_off(void)
 711 {
 712         struct mxs_power_regs *power_regs =
 713                 (struct mxs_power_regs *)MXS_POWER_BASE;
 714         uint32_t tmp;
 715
 716         if (readl(&power_regs->hw_power_sts) & POWER_STS_VDD5V_GT_VDDIO) {
 717                 tmp = readl(&power_regs->hw_power_vddioctrl);
 718                 if (tmp & POWER_VDDIOCTRL_DISABLE_FET) {
 719                         if ((tmp & POWER_VDDIOCTRL_LINREG_OFFSET_MASK) ==
 720                                 POWER_VDDIOCTRL_LINREG_OFFSET_0STEPS) {
 721                                 return 1;
 722                         }
 723                 }
 724
 725                 if (!(readl(&power_regs->hw_power_5vctrl) &
 726                         POWER_5VCTRL_ENABLE_DCDC)) {
 727                         if ((tmp & POWER_VDDIOCTRL_LINREG_OFFSET_MASK) ==
 728                                 POWER_VDDIOCTRL_LINREG_OFFSET_0STEPS) {
 729                                 return 1;
 730                         }
 731                 }
 732         }
 733
 734         return 0;
 735
 736 }
 737
 738 static int mxs_get_vddd_power_source_off(void)
 739 {
 740         struct mxs_power_regs *power_regs =
 741                 (struct mxs_power_regs *)MXS_POWER_BASE;
 742         uint32_t tmp;
 743
 744         tmp = readl(&power_regs->hw_power_vdddctrl);
 745         if (tmp & POWER_VDDDCTRL_DISABLE_FET) {
 746                 if ((tmp & POWER_VDDDCTRL_LINREG_OFFSET_MASK) ==
 747                         POWER_VDDDCTRL_LINREG_OFFSET_0STEPS) {
 748                         return 1;
 749                 }
 750         }
 751
 752         if (readl(&power_regs->hw_power_sts) & POWER_STS_VDD5V_GT_VDDIO) {
 753                 if (!(readl(&power_regs->hw_power_5vctrl) &
 754                         POWER_5VCTRL_ENABLE_DCDC)) {
 755                         return 1;
 756                 }
 757         }
 758
 759         if (!(tmp & POWER_VDDDCTRL_ENABLE_LINREG)) {
 760                 if ((tmp & POWER_VDDDCTRL_LINREG_OFFSET_MASK) ==
 761                         POWER_VDDDCTRL_LINREG_OFFSET_1STEPS_BELOW) {
 762                         return 1;
 763                 }
 764         }
 765
 766         return 0;
 767 }
 768
 769 struct mxs_vddx_cfg {
 770         uint32_t                *reg;
 771         uint8_t                 step_mV;
 772         uint16_t                lowest_mV;
 773         int                     (*powered_by_linreg)(void);
 774         uint32_t                trg_mask;
 775         uint32_t                bo_irq;
 776         uint32_t                bo_enirq;
 777         uint32_t                bo_offset_mask;
 778         uint32_t                bo_offset_offset;
 779 };
 780
 781 static const struct mxs_vddx_cfg mxs_vddio_cfg = {
 782         .reg                    = &(((struct mxs_power_regs *)MXS_POWER_BASE)->
 783                                         hw_power_vddioctrl),
 784         .step_mV                = 50,
 785         .lowest_mV              = 2800,
 786         .powered_by_linreg      = mxs_get_vddio_power_source_off,
 787         .trg_mask               = POWER_VDDIOCTRL_TRG_MASK,
 788         .bo_irq                 = POWER_CTRL_VDDIO_BO_IRQ,
 789         .bo_enirq               = POWER_CTRL_ENIRQ_VDDIO_BO,
 790         .bo_offset_mask         = POWER_VDDIOCTRL_BO_OFFSET_MASK,
 791         .bo_offset_offset       = POWER_VDDIOCTRL_BO_OFFSET_OFFSET,
 792 };
 793
 794 static const struct mxs_vddx_cfg mxs_vddd_cfg = {
 795         .reg                    = &(((struct mxs_power_regs *)MXS_POWER_BASE)->
 796                                         hw_power_vdddctrl),
 797         .step_mV                = 25,
 798         .lowest_mV              = 800,
 799         .powered_by_linreg      = mxs_get_vddd_power_source_off,
 800         .trg_mask               = POWER_VDDDCTRL_TRG_MASK,
 801         .bo_irq                 = POWER_CTRL_VDDD_BO_IRQ,
 802         .bo_enirq               = POWER_CTRL_ENIRQ_VDDD_BO,
 803         .bo_offset_mask         = POWER_VDDDCTRL_BO_OFFSET_MASK,
 804         .bo_offset_offset       = POWER_VDDDCTRL_BO_OFFSET_OFFSET,
 805 };
 806
 807 static void mxs_power_set_vddx(const struct mxs_vddx_cfg *cfg,
 808                                 uint32_t new_target, uint32_t new_brownout)
 809 {
 810         struct mxs_power_regs *power_regs =
 811                 (struct mxs_power_regs *)MXS_POWER_BASE;
 812         uint32_t cur_target, diff, bo_int = 0;
 813         uint32_t powered_by_linreg = 0;
 814         int adjust_up, tmp;
 815
 816         new_brownout = DIV_ROUND(new_target - new_brownout, cfg->step_mV);
 817
 818         cur_target = readl(cfg->reg);
 819         cur_target &= cfg->trg_mask;
 820         cur_target *= cfg->step_mV;
 821         cur_target += cfg->lowest_mV;
 822
 823         adjust_up = new_target > cur_target;
 824         powered_by_linreg = cfg->powered_by_linreg();
 825
 826         if (adjust_up) {
 827                 if (powered_by_linreg) {
 828                         bo_int = readl(cfg->reg);
 829                         clrbits_le32(cfg->reg, cfg->bo_enirq);
 830                 }
 831                 setbits_le32(cfg->reg, cfg->bo_offset_mask);
 832         }
 833
 834         do {
 835                 if (abs(new_target - cur_target) > 100) {
 836                         if (adjust_up)
 837                                 diff = cur_target + 100;
 838                         else
 839                                 diff = cur_target - 100;
 840                 } else {
 841                         diff = new_target;
 842                 }
 843
 844                 diff -= cfg->lowest_mV;
 845                 diff /= cfg->step_mV;
 846
 847                 clrsetbits_le32(cfg->reg, cfg->trg_mask, diff);
 848
 849                 if (powered_by_linreg ||
 850                         (readl(&power_regs->hw_power_sts) &
 851                                 POWER_STS_VDD5V_GT_VDDIO))
 852                         early_delay(500);
 853                 else {
 854                         for (;;) {
 855                                 tmp = readl(&power_regs->hw_power_sts);
 856                                 if (tmp & POWER_STS_DC_OK)
 857                                         break;
 858                         }
 859                 }
 860
 861                 cur_target = readl(cfg->reg);
 862                 cur_target &= cfg->trg_mask;
 863                 cur_target *= cfg->step_mV;
 864                 cur_target += cfg->lowest_mV;
 865         } while (new_target > cur_target);
 866
 867         if (adjust_up && powered_by_linreg) {
 868                 writel(cfg->bo_irq, &power_regs->hw_power_ctrl_clr);
 869                 if (bo_int & cfg->bo_enirq)
 870                         setbits_le32(cfg->reg, cfg->bo_enirq);
 871         }
 872
 873         clrsetbits_le32(cfg->reg, cfg->bo_offset_mask,
 874                         new_brownout << cfg->bo_offset_offset);
 875 }
 876
 877 static void mxs_setup_batt_detect(void)
 878 {
 879         mxs_lradc_init();
 880         mxs_lradc_enable_batt_measurement();
 881         early_delay(10);
 882 }
 883
 884 static void mxs_ungate_power(void)
 885 {
 886 #ifdef CONFIG_MX23
 887         struct mxs_power_regs *power_regs =
 888                 (struct mxs_power_regs *)MXS_POWER_BASE;
 889
 890         writel(POWER_CTRL_CLKGATE, &power_regs->hw_power_ctrl_clr);
 891 #endif
 892 }
 893
 894 void mxs_power_init(void)
 895 {
 896         struct mxs_power_regs *power_regs =
 897                 (struct mxs_power_regs *)MXS_POWER_BASE;
 898
 899         mxs_ungate_power();
 900
 901         mxs_power_clock2xtal();
 902         mxs_power_clear_auto_restart();
 903         mxs_power_set_linreg();
 904         mxs_power_setup_5v_detect();
 905
 906         mxs_setup_batt_detect();
 907
 908         mxs_power_configure_power_source();
 909         mxs_enable_output_rail_protection();
 910
 911         mxs_power_set_vddx(&mxs_vddio_cfg, 3300, 3150);
 912         mxs_power_set_vddx(&mxs_vddd_cfg, 1500, 1000);
 913
 914         writel(POWER_CTRL_VDDD_BO_IRQ | POWER_CTRL_VDDA_BO_IRQ |
 915                 POWER_CTRL_VDDIO_BO_IRQ | POWER_CTRL_VDD5V_DROOP_IRQ |
 916                 POWER_CTRL_VBUS_VALID_IRQ | POWER_CTRL_BATT_BO_IRQ |
 917                 POWER_CTRL_DCDC4P2_BO_IRQ, &power_regs->hw_power_ctrl_clr);
 918
 919         writel(POWER_5VCTRL_PWDN_5VBRNOUT, &power_regs->hw_power_5vctrl_set);
 920
 921         early_delay(1000);
 922 }
 923
 924 #ifdef  CONFIG_SPL_MXS_PSWITCH_WAIT
 925 void mxs_power_wait_pswitch(void)
 926 {
 927         struct mxs_power_regs *power_regs =
 928                 (struct mxs_power_regs *)MXS_POWER_BASE;
 929
 930         while (!(readl(&power_regs->hw_power_sts) & POWER_STS_PSWITCH_MASK))
 931                 ;
 932 }
 933 #endif