granicus.if.org Git - esp-idf/blob - components/soc/esp32/rtc_clk.c

   1 // Copyright 2015-2017 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include <stdbool.h>
  16 #include <stdint.h>
  17 #include <stddef.h>
  18 #include <assert.h>
  19 #include "rom/ets_sys.h"
  20 #include "rom/rtc.h"
  21 #include "rom/uart.h"
  22 #include "soc/rtc.h"
  23 #include "soc/rtc_cntl_reg.h"
  24 #include "soc/rtc_io_reg.h"
  25 #include "soc/sens_reg.h"
  26 #include "soc/dport_reg.h"
  27 #include "soc/efuse_reg.h"
  28 #include "soc/apb_ctrl_reg.h"
  29 #include "i2c_rtc_clk.h"
  30 #include "soc_log.h"
  31 #include "sdkconfig.h"
  32
  33 #define MHZ (1000000)
  34
  35 /* Frequency of the 8M oscillator is 8.5MHz +/- 5%, at the default DCAP setting */
  36 #define RTC_FAST_CLK_FREQ_8M        8500000
  37 #define RTC_SLOW_CLK_FREQ_150K      150000
  38 #define RTC_SLOW_CLK_FREQ_8MD256    (RTC_FAST_CLK_FREQ_8M / 256)
  39 #define RTC_SLOW_CLK_FREQ_32K       32768
  40
  41 static const char* TAG = "rtc_clk";
  42
  43 /* Various constants related to the analog internals of the chip.
  44  * Defined here because they don't have any use outside of this file.
  45  */
  46
  47 #define BBPLL_ENDIV5_VAL_320M       0x43
  48 #define BBPLL_BBADC_DSMP_VAL_320M   0x84
  49 #define BBPLL_ENDIV5_VAL_480M       0xc3
  50 #define BBPLL_BBADC_DSMP_VAL_480M   0x74
  51
  52 #define APLL_SDM_STOP_VAL_1         0x09
  53 #define APLL_SDM_STOP_VAL_2_REV0    0x69
  54 #define APLL_SDM_STOP_VAL_2_REV1    0x49
  55
  56 #define APLL_CAL_DELAY_1            0x0f
  57 #define APLL_CAL_DELAY_2            0x3f
  58 #define APLL_CAL_DELAY_3            0x1f
  59
  60 #define XTAL_32K_DAC_VAL    1
  61 #define XTAL_32K_DRES_VAL   3
  62 #define XTAL_32K_DBIAS_VAL  0
  63
  64 #define XTAL_32K_BOOTSTRAP_DAC_VAL      3
  65 #define XTAL_32K_BOOTSTRAP_DRES_VAL     3
  66 #define XTAL_32K_BOOTSTRAP_DBIAS_VAL    0
  67 #define XTAL_32K_BOOTSTRAP_TIME_US      7
  68
  69 /* Delays for various clock sources to be enabled/switched.
  70  * All values are in microseconds.
  71  * TODO: some of these are excessive, and should be reduced.
  72  */
  73 #define DELAY_CPU_FREQ_SWITCH_TO_XTAL_WITH_150K  80
  74 #define DELAY_CPU_FREQ_SWITCH_TO_XTAL_WITH_32K   160
  75 #define DELAY_CPU_FREQ_SWITCH_TO_PLL    10
  76 #define DELAY_PLL_DBIAS_RAISE           3
  77 #define DELAY_PLL_ENABLE_WITH_150K      80
  78 #define DELAY_PLL_ENABLE_WITH_32K       160
  79 #define DELAY_FAST_CLK_SWITCH           3
  80 #define DELAY_SLOW_CLK_SWITCH           300
  81 #define DELAY_8M_ENABLE                 50
  82
  83 /* Number of 8M/256 clock cycles to use for XTAL frequency estimation.
  84  * 10 cycles will take approximately 300 microseconds.
  85  */
  86 #define XTAL_FREQ_EST_CYCLES            10
  87
  88
  89 static void rtc_clk_32k_enable_internal(int dac, int dres, int dbias)
  90 {
  91     SET_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32N_MUX_SEL | RTC_IO_X32P_MUX_SEL);
  92     CLEAR_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG,
  93             RTC_IO_X32P_RDE | RTC_IO_X32P_RUE | RTC_IO_X32N_RUE |
  94             RTC_IO_X32N_RDE | RTC_IO_X32N_MUX_SEL | RTC_IO_X32P_MUX_SEL);
  95     REG_SET_FIELD(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_DAC_XTAL_32K, dac);
  96     REG_SET_FIELD(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_DRES_XTAL_32K, dres);
  97     REG_SET_FIELD(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_DBIAS_XTAL_32K, dbias);
  98     SET_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_XPD_XTAL_32K);
  99 }
 100
 101 void rtc_clk_32k_enable(bool enable)
 102 {
 103     if (enable) {
 104         rtc_clk_32k_enable_internal(XTAL_32K_DAC_VAL, XTAL_32K_DRES_VAL, XTAL_32K_DBIAS_VAL);
 105     } else {
 106         CLEAR_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_XPD_XTAL_32K);
 107     }
 108 }
 109
 110 void rtc_clk_32k_bootstrap()
 111 {
 112     CLEAR_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_XPD_XTAL_32K);
 113     SET_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_X32P_RUE | RTC_IO_X32N_RDE);
 114     ets_delay_us(XTAL_32K_BOOTSTRAP_TIME_US);
 115     rtc_clk_32k_enable_internal(XTAL_32K_BOOTSTRAP_DAC_VAL,
 116             XTAL_32K_BOOTSTRAP_DRES_VAL, XTAL_32K_BOOTSTRAP_DBIAS_VAL);
 117 }
 118
 119 bool rtc_clk_32k_enabled()
 120 {
 121     return GET_PERI_REG_MASK(RTC_IO_XTAL_32K_PAD_REG, RTC_IO_XPD_XTAL_32K) != 0;
 122 }
 123
 124 void rtc_clk_8m_enable(bool clk_8m_en, bool d256_en)
 125 {
 126     if (clk_8m_en) {
 127         CLEAR_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M);
 128         /* no need to wait once enabled by software */
 129         REG_SET_FIELD(RTC_CNTL_TIMER1_REG, RTC_CNTL_CK8M_WAIT, 1);
 130         if (d256_en) {
 131             CLEAR_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M_DIV);
 132         } else {
 133             SET_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M_DIV);
 134         }
 135         ets_delay_us(DELAY_8M_ENABLE);
 136     } else {
 137         SET_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M);
 138         REG_SET_FIELD(RTC_CNTL_TIMER1_REG, RTC_CNTL_CK8M_WAIT, RTC_CNTL_CK8M_WAIT_DEFAULT);
 139     }
 140 }
 141
 142 bool rtc_clk_8m_enabled()
 143 {
 144     return GET_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M) == 0;
 145 }
 146
 147 bool rtc_clk_8md256_enabled()
 148 {
 149     return GET_PERI_REG_MASK(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ENB_CK8M_DIV) == 0;
 150 }
 151
 152 void rtc_clk_apll_enable(bool enable, uint32_t sdm0, uint32_t sdm1, uint32_t sdm2, uint32_t o_div)
 153 {
 154     REG_SET_FIELD(RTC_CNTL_ANA_CONF_REG, RTC_CNTL_PLLA_FORCE_PD, enable ? 0 : 1);
 155     REG_SET_FIELD(RTC_CNTL_ANA_CONF_REG, RTC_CNTL_PLLA_FORCE_PU, enable ? 1 : 0);
 156     REG_SET_FIELD(RTC_CNTL_OPTIONS0_REG, RTC_CNTL_BIAS_I2C_FORCE_PD, enable ? 0 : 1);
 157
 158     if (!enable &&
 159         REG_GET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL) != RTC_CNTL_SOC_CLK_SEL_PLL) {
 160         SET_PERI_REG_MASK(RTC_CNTL_OPTIONS0_REG, RTC_CNTL_BIAS_I2C_FORCE_PD);
 161     }
 162
 163     if (enable) {
 164         uint8_t sdm_stop_val_2 = APLL_SDM_STOP_VAL_2_REV1;
 165         uint32_t is_rev0 = (GET_PERI_REG_BITS2(EFUSE_BLK0_RDATA3_REG, 1, 15) == 0);
 166         if (is_rev0) {
 167             sdm0 = 0;
 168             sdm1 = 0;
 169             sdm_stop_val_2 = APLL_SDM_STOP_VAL_2_REV0;
 170         }
 171         I2C_WRITEREG_MASK_RTC(I2C_APLL, I2C_APLL_DSDM2, sdm2);
 172         I2C_WRITEREG_MASK_RTC(I2C_APLL, I2C_APLL_DSDM0, sdm0);
 173         I2C_WRITEREG_MASK_RTC(I2C_APLL, I2C_APLL_DSDM1, sdm1);
 174         I2C_WRITEREG_RTC(I2C_APLL, I2C_APLL_SDM_STOP, APLL_SDM_STOP_VAL_1);
 175         I2C_WRITEREG_RTC(I2C_APLL, I2C_APLL_SDM_STOP, sdm_stop_val_2);
 176         I2C_WRITEREG_MASK_RTC(I2C_APLL, I2C_APLL_OR_OUTPUT_DIV, o_div);
 177
 178         /* calibration */
 179         I2C_WRITEREG_RTC(I2C_APLL, I2C_APLL_IR_CAL_DELAY, APLL_CAL_DELAY_1);
 180         I2C_WRITEREG_RTC(I2C_APLL, I2C_APLL_IR_CAL_DELAY, APLL_CAL_DELAY_2);
 181         I2C_WRITEREG_RTC(I2C_APLL, I2C_APLL_IR_CAL_DELAY, APLL_CAL_DELAY_3);
 182
 183         /* wait for calibration end */
 184         while (!(I2C_READREG_MASK_RTC(I2C_APLL, I2C_APLL_OR_CAL_END))) {
 185             /* use ets_delay_us so the RTC bus doesn't get flooded */
 186             ets_delay_us(1);
 187         }
 188     }
 189 }
 190
 191 void rtc_clk_slow_freq_set(rtc_slow_freq_t slow_freq)
 192 {
 193     REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ANA_CLK_RTC_SEL, slow_freq);
 194     ets_delay_us(DELAY_SLOW_CLK_SWITCH);
 195 }
 196
 197 rtc_slow_freq_t rtc_clk_slow_freq_get()
 198 {
 199     return REG_GET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_ANA_CLK_RTC_SEL);
 200 }
 201
 202 uint32_t rtc_clk_slow_freq_get_hz()
 203 {
 204     switch(rtc_clk_slow_freq_get()) {
 205         case RTC_SLOW_FREQ_RTC: return RTC_SLOW_CLK_FREQ_150K;
 206         case RTC_SLOW_FREQ_32K_XTAL: return RTC_SLOW_CLK_FREQ_32K;
 207         case RTC_SLOW_FREQ_8MD256: return RTC_SLOW_CLK_FREQ_8MD256;
 208     }
 209     return 0;
 210 }
 211
 212 void rtc_clk_fast_freq_set(rtc_fast_freq_t fast_freq)
 213 {
 214     REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_FAST_CLK_RTC_SEL, fast_freq);
 215     ets_delay_us(DELAY_FAST_CLK_SWITCH);
 216 }
 217
 218 rtc_fast_freq_t rtc_clk_fast_freq_get()
 219 {
 220     return REG_GET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_FAST_CLK_RTC_SEL);
 221 }
 222
 223 void rtc_clk_bbpll_set(rtc_xtal_freq_t xtal_freq, rtc_cpu_freq_t cpu_freq)
 224 {
 225     uint8_t div_ref;
 226     uint8_t div7_0;
 227     uint8_t div10_8;
 228     uint8_t lref;
 229     uint8_t dcur;
 230     uint8_t bw;
 231
 232     if (cpu_freq != RTC_CPU_FREQ_240M) {
 233         /* Configure 320M PLL */
 234         switch (xtal_freq) {
 235             case RTC_XTAL_FREQ_40M:
 236                 div_ref = 0;
 237                 div7_0 = 32;
 238                 div10_8 = 0;
 239                 lref = 0;
 240                 dcur = 6;
 241                 bw = 3;
 242                 break;
 243             case RTC_XTAL_FREQ_26M:
 244                 div_ref = 12;
 245                 div7_0 = 224;
 246                 div10_8 = 4;
 247                 lref = 1;
 248                 dcur = 0;
 249                 bw = 1;
 250                 break;
 251             case RTC_XTAL_FREQ_24M:
 252                 div_ref = 11;
 253                 div7_0 = 224;
 254                 div10_8 = 4;
 255                 lref = 1;
 256                 dcur = 0;
 257                 bw = 1;
 258                 break;
 259             default:
 260                 div_ref = 12;
 261                 div7_0 = 224;
 262                 div10_8 = 4;
 263                 lref = 0;
 264                 dcur = 0;
 265                 bw = 0;
 266                 break;
 267         }
 268         I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_ENDIV5, BBPLL_ENDIV5_VAL_320M);
 269         I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_BBADC_DSMP, BBPLL_BBADC_DSMP_VAL_320M);
 270     } else {
 271         /* Raise the voltage */
 272         REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_DIG_DBIAS_WAK, RTC_CNTL_DBIAS_1V25);
 273         ets_delay_us(DELAY_PLL_DBIAS_RAISE);
 274         /* Configure 480M PLL */
 275         switch (xtal_freq) {
 276             case RTC_XTAL_FREQ_40M:
 277                 div_ref = 0;
 278                 div7_0 = 28;
 279                 div10_8 = 0;
 280                 lref = 0;
 281                 dcur = 6;
 282                 bw = 3;
 283                 break;
 284             case RTC_XTAL_FREQ_26M:
 285                 div_ref = 12;
 286                 div7_0 = 144;
 287                 div10_8 = 4;
 288                 lref = 1;
 289                 dcur = 0;
 290                 bw = 1;
 291                 break;
 292             case RTC_XTAL_FREQ_24M:
 293                 div_ref = 11;
 294                 div7_0 = 144;
 295                 div10_8 = 4;
 296                 lref = 1;
 297                 dcur = 0;
 298                 bw = 1;
 299                 break;
 300             default:
 301                 div_ref = 12;
 302                 div7_0 = 224;
 303                 div10_8 = 4;
 304                 lref = 0;
 305                 dcur = 0;
 306                 bw = 0;
 307                 break;
 308         }
 309         I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_ENDIV5, BBPLL_ENDIV5_VAL_480M);
 310         I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_BBADC_DSMP, BBPLL_BBADC_DSMP_VAL_480M);
 311     }
 312
 313     uint8_t i2c_bbpll_lref  = (lref << 7) | (div10_8 << 4) | (div_ref);
 314     uint8_t i2c_bbpll_div_7_0 = div7_0;
 315     uint8_t i2c_bbpll_dcur = (bw << 6) | dcur;
 316     I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_OC_LREF, i2c_bbpll_lref);
 317     I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_OC_DIV_7_0, i2c_bbpll_div_7_0);
 318     I2C_WRITEREG_RTC(I2C_BBPLL, I2C_BBPLL_OC_DCUR, i2c_bbpll_dcur);
 319     uint32_t delay_pll_en = (rtc_clk_slow_freq_get() == RTC_SLOW_FREQ_RTC) ?
 320             DELAY_PLL_ENABLE_WITH_150K : DELAY_PLL_ENABLE_WITH_32K;
 321     ets_delay_us(delay_pll_en);
 322 }
 323
 324 void rtc_clk_cpu_freq_set(rtc_cpu_freq_t cpu_freq)
 325 {
 326     rtc_xtal_freq_t xtal_freq = rtc_clk_xtal_freq_get();
 327     /* Switch CPU to XTAL frequency first */
 328     REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_DIG_DBIAS_WAK, RTC_CNTL_DBIAS_1V10);
 329     REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL, RTC_CNTL_SOC_CLK_SEL_XTL);
 330     REG_SET_FIELD(APB_CTRL_SYSCLK_CONF_REG, APB_CTRL_PRE_DIV_CNT, 0);
 331     ets_update_cpu_frequency(xtal_freq);
 332     uint32_t delay_xtal_switch = (rtc_clk_slow_freq_get() == RTC_SLOW_FREQ_RTC) ?
 333             DELAY_CPU_FREQ_SWITCH_TO_XTAL_WITH_150K : DELAY_CPU_FREQ_SWITCH_TO_XTAL_WITH_32K;
 334     ets_delay_us(delay_xtal_switch);
 335     REG_SET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL, 0);
 336     SET_PERI_REG_MASK(RTC_CNTL_OPTIONS0_REG,
 337             RTC_CNTL_BB_I2C_FORCE_PD | RTC_CNTL_BBPLL_FORCE_PD |
 338             RTC_CNTL_BBPLL_I2C_FORCE_PD);
 339     rtc_clk_apb_freq_update(xtal_freq * MHZ);
 340
 341     /* is APLL under force power down? */
 342     uint32_t apll_fpd = REG_GET_FIELD(RTC_CNTL_ANA_CONF_REG, RTC_CNTL_PLLA_FORCE_PD);
 343     if (apll_fpd) {
 344         /* then also power down the internal I2C bus */
 345         SET_PERI_REG_MASK(RTC_CNTL_OPTIONS0_REG, RTC_CNTL_BIAS_I2C_FORCE_PD);
 346     }
 347     /* now switch to the desired frequency */
 348     if (cpu_freq == RTC_CPU_FREQ_XTAL) {
 349         /* already at XTAL, nothing to do */
 350     } else if (cpu_freq == RTC_CPU_FREQ_2M) {
 351         /* set up divider to produce 2MHz from XTAL */
 352         REG_SET_FIELD(APB_CTRL_SYSCLK_CONF_REG, APB_CTRL_PRE_DIV_CNT, (xtal_freq / 2) - 1);
 353         ets_update_cpu_frequency(2);
 354         rtc_clk_apb_freq_update(2 * MHZ);
 355         /* lower the voltage */
 356         REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_DIG_DBIAS_WAK, RTC_CNTL_DBIAS_1V00);
 357     } else {
 358         /* use PLL as clock source */
 359         CLEAR_PERI_REG_MASK(RTC_CNTL_OPTIONS0_REG,
 360                 RTC_CNTL_BIAS_I2C_FORCE_PD | RTC_CNTL_BB_I2C_FORCE_PD |
 361                 RTC_CNTL_BBPLL_FORCE_PD | RTC_CNTL_BBPLL_I2C_FORCE_PD);
 362         rtc_clk_bbpll_set(xtal_freq, cpu_freq);
 363         if (cpu_freq == RTC_CPU_FREQ_80M) {
 364             REG_SET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL, 0);
 365             ets_update_cpu_frequency(80);
 366         } else if (cpu_freq == RTC_CPU_FREQ_160M) {
 367             REG_SET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL, 1);
 368             ets_update_cpu_frequency(160);
 369         } else if (cpu_freq == RTC_CPU_FREQ_240M) {
 370             REG_SET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL, 2);
 371             ets_update_cpu_frequency(240);
 372         }
 373         REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL, RTC_CNTL_SOC_CLK_SEL_PLL);
 374         ets_delay_us(DELAY_CPU_FREQ_SWITCH_TO_PLL);
 375         rtc_clk_apb_freq_update(80 * MHZ);
 376     }
 377 }
 378
 379 rtc_cpu_freq_t rtc_clk_cpu_freq_get()
 380 {
 381     uint32_t soc_clk_sel = REG_GET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL);
 382     switch (soc_clk_sel) {
 383         case RTC_CNTL_SOC_CLK_SEL_XTL: {
 384             uint32_t pre_div = REG_GET_FIELD(APB_CTRL_SYSCLK_CONF_REG, APB_CTRL_PRE_DIV_CNT);
 385             if (pre_div == 0) {
 386                 return RTC_CPU_FREQ_XTAL;
 387             } else if (pre_div == rtc_clk_xtal_freq_get() / 2 - 1) {
 388                 return RTC_CPU_FREQ_2M;
 389             } else {
 390                 assert(false && "unsupported frequency");
 391             }
 392             break;
 393         }
 394         case RTC_CNTL_SOC_CLK_SEL_PLL: {
 395             uint32_t cpuperiod_sel = REG_GET_FIELD(DPORT_CPU_PER_CONF_REG, DPORT_CPUPERIOD_SEL);
 396             if (cpuperiod_sel == 0) {
 397                 return RTC_CPU_FREQ_80M;
 398             } else if (cpuperiod_sel == 1) {
 399                 return RTC_CPU_FREQ_160M;
 400             } else if (cpuperiod_sel == 2) {
 401                 return RTC_CPU_FREQ_240M;
 402             } else {
 403                 assert(false && "unsupported frequency");
 404             }
 405             break;
 406         }
 407         case RTC_CNTL_SOC_CLK_SEL_APLL:
 408         case RTC_CNTL_SOC_CLK_SEL_8M:
 409         default:
 410             assert(false && "unsupported frequency");
 411     }
 412     return RTC_CNTL_SOC_CLK_SEL_XTL;
 413 }
 414
 415 uint32_t rtc_clk_cpu_freq_value(rtc_cpu_freq_t cpu_freq)
 416 {
 417     switch (cpu_freq) {
 418         case RTC_CPU_FREQ_XTAL:
 419             return ((uint32_t) rtc_clk_xtal_freq_get()) * MHZ;
 420         case RTC_CPU_FREQ_2M:
 421             return 2 * MHZ;
 422         case RTC_CPU_FREQ_80M:
 423             return 80 * MHZ;
 424         case RTC_CPU_FREQ_160M:
 425             return 160 * MHZ;
 426         case RTC_CPU_FREQ_240M:
 427             return 240 * MHZ;
 428         default:
 429             assert(false && "invalid rtc_cpu_freq_t value");
 430             return 0;
 431     }
 432 }
 433
 434 /* Values of RTC_XTAL_FREQ_REG and RTC_APB_FREQ_REG are stored as two copies in
 435  * lower and upper 16-bit halves. These are the routines to work with such a
 436  * representation.
 437  */
 438 static bool clk_val_is_valid(uint32_t val) {
 439     return (val & 0xffff) == ((val >> 16) & 0xffff) &&
 440             val != 0 &&
 441             val != UINT32_MAX;
 442 }
 443
 444 static uint32_t reg_val_to_clk_val(uint32_t val) {
 445     return val & UINT16_MAX;
 446 }
 447
 448 static uint32_t clk_val_to_reg_val(uint32_t val) {
 449     return (val & UINT16_MAX) | ((val & UINT16_MAX) << 16);
 450 }
 451
 452 rtc_xtal_freq_t rtc_clk_xtal_freq_get()
 453 {
 454     /* We may have already written XTAL value into RTC_XTAL_FREQ_REG */
 455     uint32_t xtal_freq_reg = READ_PERI_REG(RTC_XTAL_FREQ_REG);
 456     if (!clk_val_is_valid(xtal_freq_reg)) {
 457         SOC_LOGW(TAG, "invalid RTC_XTAL_FREQ_REG value: 0x%08x", xtal_freq_reg);
 458         return RTC_XTAL_FREQ_AUTO;
 459     }
 460     return reg_val_to_clk_val(xtal_freq_reg);
 461 }
 462
 463 void rtc_clk_xtal_freq_update(rtc_xtal_freq_t xtal_freq)
 464 {
 465     WRITE_PERI_REG(RTC_XTAL_FREQ_REG, clk_val_to_reg_val(xtal_freq));
 466 }
 467
 468 static rtc_xtal_freq_t rtc_clk_xtal_freq_estimate()
 469 {
 470     uint64_t cal_val = rtc_clk_cal_ratio(RTC_CAL_8MD256, XTAL_FREQ_EST_CYCLES);
 471     /* cal_val contains period of 8M/256 clock in XTAL clock cycles
 472      * (shifted by RTC_CLK_CAL_FRACT bits).
 473      * Xtal frequency will be (cal_val * 8M / 256) / 2^19
 474      */
 475     uint32_t freq_mhz = (cal_val * (RTC_FAST_CLK_FREQ_APPROX / MHZ) / 256 ) >> RTC_CLK_CAL_FRACT;
 476     /* Guess the XTAL type. For now, only 40 and 26MHz are supported.
 477      */
 478     switch (freq_mhz) {
 479         case 21 ... 31:
 480             return RTC_XTAL_FREQ_26M;
 481         case 32 ... 33:
 482             SOC_LOGW(TAG, "Potentially bogus XTAL frequency: %d MHz, guessing 26 MHz", freq_mhz);
 483             return RTC_XTAL_FREQ_26M;
 484         case 34 ... 35:
 485             SOC_LOGW(TAG, "Potentially bogus XTAL frequency: %d MHz, guessing 40 MHz", freq_mhz);
 486             return RTC_XTAL_FREQ_40M;
 487         case 36 ... 45:
 488             return RTC_XTAL_FREQ_40M;
 489         default:
 490             SOC_LOGW(TAG, "Bogus XTAL frequency: %d MHz", freq_mhz);
 491             return RTC_XTAL_FREQ_AUTO;
 492     }
 493 }
 494
 495 void rtc_clk_apb_freq_update(uint32_t apb_freq)
 496 {
 497     WRITE_PERI_REG(RTC_APB_FREQ_REG, clk_val_to_reg_val(apb_freq >> 12));
 498 }
 499
 500 uint32_t rtc_clk_apb_freq_get()
 501 {
 502     return reg_val_to_clk_val(READ_PERI_REG(RTC_APB_FREQ_REG)) << 12;
 503 }
 504
 505
 506 void rtc_clk_init(rtc_clk_config_t cfg)
 507 {
 508     /* If we get a TG WDT system reset while running at 240MHz,
 509      * DPORT_CPUPERIOD_SEL register will be reset to 0 resulting in 120MHz
 510      * APB and CPU frequencies after reset. This will cause issues with XTAL
 511      * frequency estimation, so we switch to XTAL frequency first.
 512      *
 513      * Ideally we would only do this if RTC_CNTL_SOC_CLK_SEL == PLL and
 514      * PLL is configured for 480M, but it takes less time to switch to 40M and
 515      * run the following code than querying the PLL does.
 516      */
 517     if (REG_GET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_SOC_CLK_SEL) == RTC_CNTL_SOC_CLK_SEL_PLL) {
 518         rtc_clk_cpu_freq_set(RTC_CPU_FREQ_XTAL);
 519     }
 520
 521     /* Set tuning parameters for 8M and 150k clocks.
 522      * Note: this doesn't attempt to set the clocks to precise frequencies.
 523      * Instead, we calibrate these clocks against XTAL frequency later, when necessary.
 524      * - SCK_DCAP value controls tuning of 150k clock.
 525      *   The higher the value of DCAP is, the lower is the frequency.
 526      * - CK8M_DFREQ value controls tuning of 8M clock.
 527      *   CLK_8M_DFREQ constant gives the best temperature characteristics.
 528      */
 529     REG_SET_FIELD(RTC_CNTL_REG, RTC_CNTL_SCK_DCAP, cfg.slow_clk_dcap);
 530     REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_CK8M_DFREQ, cfg.clk_8m_dfreq);
 531
 532     /* Configure 8M clock division */
 533     REG_SET_FIELD(RTC_CNTL_CLK_CONF_REG, RTC_CNTL_CK8M_DIV_SEL, cfg.clk_8m_div);
 534
 535     /* Enable the internal bus used to configure PLLs */
 536     SET_PERI_REG_BITS(ANA_CONFIG_REG, ANA_CONFIG_M, ANA_CONFIG_M, ANA_CONFIG_S);
 537     CLEAR_PERI_REG_MASK(ANA_CONFIG_REG, I2C_APLL_M | I2C_BBPLL_M);
 538
 539     /* Estimate XTAL frequency if requested */
 540     rtc_xtal_freq_t xtal_freq = cfg.xtal_freq;
 541     if (xtal_freq == RTC_XTAL_FREQ_AUTO) {
 542         if (clk_val_is_valid(READ_PERI_REG(RTC_XTAL_FREQ_REG))) {
 543             /* XTAL frequency has already been set, use existing value */
 544             xtal_freq = rtc_clk_xtal_freq_get();
 545         } else {
 546             /* Not set yet, estimate XTAL frequency based on RTC_FAST_CLK */
 547             xtal_freq = rtc_clk_xtal_freq_estimate();
 548             if (xtal_freq == RTC_XTAL_FREQ_AUTO) {
 549                 SOC_LOGW(TAG, "Can't estimate XTAL frequency, assuming 26MHz");
 550                 xtal_freq = RTC_XTAL_FREQ_26M;
 551             }
 552         }
 553     }
 554     rtc_clk_xtal_freq_update(xtal_freq);
 555     rtc_clk_apb_freq_update(xtal_freq * MHZ);
 556     /* Set CPU frequency */
 557     rtc_clk_cpu_freq_set(cfg.cpu_freq);
 558
 559     /* Slow & fast clocks setup */
 560     if (cfg.slow_freq == RTC_SLOW_FREQ_32K_XTAL) {
 561         rtc_clk_32k_enable(true);
 562     }
 563     if (cfg.fast_freq == RTC_FAST_FREQ_8M) {
 564         bool need_8md256 = cfg.slow_freq == RTC_SLOW_FREQ_8MD256;
 565         rtc_clk_8m_enable(true, need_8md256);
 566     }
 567     rtc_clk_fast_freq_set(cfg.fast_freq);
 568     rtc_clk_slow_freq_set(cfg.slow_freq);
 569 }
 570
 571 /* Name used in libphy.a:phy_chip_v7.o
 572  * TODO: update the library to use rtc_clk_xtal_freq_get
 573  */
 574 rtc_xtal_freq_t rtc_get_xtal() __attribute__((alias("rtc_clk_xtal_freq_get")));