arch/arm/cpu/armv7/mx7ulp/scg.c

   1 /*
   2  * Copyright (C) 2016 Freescale Semiconductor, Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <div64.h>
   9 #include <asm/io.h>
  10 #include <errno.h>
  11 #include <asm/arch/imx-regs.h>
  12 #include <asm/arch/pcc.h>
  13 #include <asm/arch/sys_proto.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16
  17 scg_p scg1_regs = (scg_p)SCG1_RBASE;
  18
  19 static u32 scg_src_get_rate(enum scg_clk clksrc)
  20 {
  21         u32 reg;
  22
  23         switch (clksrc) {
  24         case SCG_SOSC_CLK:
  25                 reg = readl(&scg1_regs->sosccsr);
  26                 if (!(reg & SCG_SOSC_CSR_SOSCVLD_MASK))
  27                         return 0;
  28
  29                 return 24000000;
  30         case SCG_FIRC_CLK:
  31                 reg = readl(&scg1_regs->firccsr);
  32                 if (!(reg & SCG_FIRC_CSR_FIRCVLD_MASK))
  33                         return 0;
  34
  35                 return 48000000;
  36         case SCG_SIRC_CLK:
  37                 reg = readl(&scg1_regs->sirccsr);
  38                 if (!(reg & SCG_SIRC_CSR_SIRCVLD_MASK))
  39                         return 0;
  40
  41                 return 16000000;
  42         case SCG_ROSC_CLK:
  43                 reg = readl(&scg1_regs->rtccsr);
  44                 if (!(reg & SCG_ROSC_CSR_ROSCVLD_MASK))
  45                         return 0;
  46
  47                 return 32768;
  48         default:
  49                 break;
  50         }
  51
  52         return 0;
  53 }
  54
  55 static u32 scg_sircdiv_get_rate(enum scg_clk clk)
  56 {
  57         u32 reg, val, rate;
  58         u32 shift, mask;
  59
  60         switch (clk) {
  61         case SCG_SIRC_DIV1_CLK:
  62                 mask = SCG_SIRCDIV_DIV1_MASK;
  63                 shift = SCG_SIRCDIV_DIV1_SHIFT;
  64                 break;
  65         case SCG_SIRC_DIV2_CLK:
  66                 mask = SCG_SIRCDIV_DIV2_MASK;
  67                 shift = SCG_SIRCDIV_DIV2_SHIFT;
  68                 break;
  69         case SCG_SIRC_DIV3_CLK:
  70                 mask = SCG_SIRCDIV_DIV3_MASK;
  71                 shift = SCG_SIRCDIV_DIV3_SHIFT;
  72                 break;
  73         default:
  74                 return 0;
  75         }
  76
  77         reg = readl(&scg1_regs->sirccsr);
  78         if (!(reg & SCG_SIRC_CSR_SIRCVLD_MASK))
  79                 return 0;
  80
  81         reg = readl(&scg1_regs->sircdiv);
  82         val = (reg & mask) >> shift;
  83
  84         if (!val) /*clock disabled*/
  85                 return 0;
  86
  87         rate = scg_src_get_rate(SCG_SIRC_CLK);
  88         rate = rate / (1 << (val - 1));
  89
  90         return rate;
  91 }
  92
  93 static u32 scg_fircdiv_get_rate(enum scg_clk clk)
  94 {
  95         u32 reg, val, rate;
  96         u32 shift, mask;
  97
  98         switch (clk) {
  99         case SCG_FIRC_DIV1_CLK:
 100                 mask = SCG_FIRCDIV_DIV1_MASK;
 101                 shift = SCG_FIRCDIV_DIV1_SHIFT;
 102                 break;
 103         case SCG_FIRC_DIV2_CLK:
 104                 mask = SCG_FIRCDIV_DIV2_MASK;
 105                 shift = SCG_FIRCDIV_DIV2_SHIFT;
 106                 break;
 107         case SCG_FIRC_DIV3_CLK:
 108                 mask = SCG_FIRCDIV_DIV3_MASK;
 109                 shift = SCG_FIRCDIV_DIV3_SHIFT;
 110                 break;
 111         default:
 112                 return 0;
 113         }
 114
 115         reg = readl(&scg1_regs->firccsr);
 116         if (!(reg & SCG_FIRC_CSR_FIRCVLD_MASK))
 117                 return 0;
 118
 119         reg = readl(&scg1_regs->fircdiv);
 120         val = (reg & mask) >> shift;
 121
 122         if (!val) /*clock disabled*/
 123                 return 0;
 124
 125         rate = scg_src_get_rate(SCG_FIRC_CLK);
 126         rate = rate / (1 << (val - 1));
 127
 128         return rate;
 129 }
 130
 131 static u32 scg_soscdiv_get_rate(enum scg_clk clk)
 132 {
 133         u32 reg, val, rate;
 134         u32 shift, mask;
 135
 136         switch (clk) {
 137         case SCG_SOSC_DIV1_CLK:
 138                 mask = SCG_SOSCDIV_DIV1_MASK;
 139                 shift = SCG_SOSCDIV_DIV1_SHIFT;
 140                 break;
 141         case SCG_SOSC_DIV2_CLK:
 142                 mask = SCG_SOSCDIV_DIV2_MASK;
 143                 shift = SCG_SOSCDIV_DIV2_SHIFT;
 144                 break;
 145         case SCG_SOSC_DIV3_CLK:
 146                 mask = SCG_SOSCDIV_DIV3_MASK;
 147                 shift = SCG_SOSCDIV_DIV3_SHIFT;
 148                 break;
 149         default:
 150                 return 0;
 151         }
 152
 153         reg = readl(&scg1_regs->sosccsr);
 154         if (!(reg & SCG_SOSC_CSR_SOSCVLD_MASK))
 155                 return 0;
 156
 157         reg = readl(&scg1_regs->soscdiv);
 158         val = (reg & mask) >> shift;
 159
 160         if (!val) /*clock disabled*/
 161                 return 0;
 162
 163         rate = scg_src_get_rate(SCG_SOSC_CLK);
 164         rate = rate / (1 << (val - 1));
 165
 166         return rate;
 167 }
 168
 169 static u32 scg_apll_pfd_get_rate(enum scg_clk clk)
 170 {
 171         u32 reg, val, rate;
 172         u32 shift, mask, gate, valid;
 173
 174         switch (clk) {
 175         case SCG_APLL_PFD0_CLK:
 176                 gate = SCG_PLL_PFD0_GATE_MASK;
 177                 valid = SCG_PLL_PFD0_VALID_MASK;
 178                 mask = SCG_PLL_PFD0_FRAC_MASK;
 179                 shift = SCG_PLL_PFD0_FRAC_SHIFT;
 180                 break;
 181         case SCG_APLL_PFD1_CLK:
 182                 gate = SCG_PLL_PFD1_GATE_MASK;
 183                 valid = SCG_PLL_PFD1_VALID_MASK;
 184                 mask = SCG_PLL_PFD1_FRAC_MASK;
 185                 shift = SCG_PLL_PFD1_FRAC_SHIFT;
 186                 break;
 187         case SCG_APLL_PFD2_CLK:
 188                 gate = SCG_PLL_PFD2_GATE_MASK;
 189                 valid = SCG_PLL_PFD2_VALID_MASK;
 190                 mask = SCG_PLL_PFD2_FRAC_MASK;
 191                 shift = SCG_PLL_PFD2_FRAC_SHIFT;
 192                 break;
 193         case SCG_APLL_PFD3_CLK:
 194                 gate = SCG_PLL_PFD3_GATE_MASK;
 195                 valid = SCG_PLL_PFD3_VALID_MASK;
 196                 mask = SCG_PLL_PFD3_FRAC_MASK;
 197                 shift = SCG_PLL_PFD3_FRAC_SHIFT;
 198                 break;
 199         default:
 200                 return 0;
 201         }
 202
 203         reg = readl(&scg1_regs->apllpfd);
 204         if (reg & gate || !(reg & valid))
 205                 return 0;
 206
 207         clk_debug("scg_apll_pfd_get_rate reg 0x%x\n", reg);
 208
 209         val = (reg & mask) >> shift;
 210         rate = decode_pll(PLL_A7_APLL);
 211
 212         rate = rate / val * 18;
 213
 214         clk_debug("scg_apll_pfd_get_rate rate %u\n", rate);
 215
 216         return rate;
 217 }
 218
 219 static u32 scg_spll_pfd_get_rate(enum scg_clk clk)
 220 {
 221         u32 reg, val, rate;
 222         u32 shift, mask, gate, valid;
 223
 224         switch (clk) {
 225         case SCG_SPLL_PFD0_CLK:
 226                 gate = SCG_PLL_PFD0_GATE_MASK;
 227                 valid = SCG_PLL_PFD0_VALID_MASK;
 228                 mask = SCG_PLL_PFD0_FRAC_MASK;
 229                 shift = SCG_PLL_PFD0_FRAC_SHIFT;
 230                 break;
 231         case SCG_SPLL_PFD1_CLK:
 232                 gate = SCG_PLL_PFD1_GATE_MASK;
 233                 valid = SCG_PLL_PFD1_VALID_MASK;
 234                 mask = SCG_PLL_PFD1_FRAC_MASK;
 235                 shift = SCG_PLL_PFD1_FRAC_SHIFT;
 236                 break;
 237         case SCG_SPLL_PFD2_CLK:
 238                 gate = SCG_PLL_PFD2_GATE_MASK;
 239                 valid = SCG_PLL_PFD2_VALID_MASK;
 240                 mask = SCG_PLL_PFD2_FRAC_MASK;
 241                 shift = SCG_PLL_PFD2_FRAC_SHIFT;
 242                 break;
 243         case SCG_SPLL_PFD3_CLK:
 244                 gate = SCG_PLL_PFD3_GATE_MASK;
 245                 valid = SCG_PLL_PFD3_VALID_MASK;
 246                 mask = SCG_PLL_PFD3_FRAC_MASK;
 247                 shift = SCG_PLL_PFD3_FRAC_SHIFT;
 248                 break;
 249         default:
 250                 return 0;
 251         }
 252
 253         reg = readl(&scg1_regs->spllpfd);
 254         if (reg & gate || !(reg & valid))
 255                 return 0;
 256
 257         clk_debug("scg_spll_pfd_get_rate reg 0x%x\n", reg);
 258
 259         val = (reg & mask) >> shift;
 260         rate = decode_pll(PLL_A7_SPLL);
 261
 262         rate = rate / val * 18;
 263
 264         clk_debug("scg_spll_pfd_get_rate rate %u\n", rate);
 265
 266         return rate;
 267 }
 268
 269 static u32 scg_apll_get_rate(void)
 270 {
 271         u32 reg, val, rate;
 272
 273         reg = readl(&scg1_regs->apllcfg);
 274         val = (reg & SCG_PLL_CFG_PLLSEL_MASK) >> SCG_PLL_CFG_PLLSEL_SHIFT;
 275
 276         if (!val) {
 277                 /* APLL clock after two dividers */
 278                 rate = decode_pll(PLL_A7_APLL);
 279
 280                 val = (reg & SCG_PLL_CFG_POSTDIV1_MASK) >>
 281                         SCG_PLL_CFG_POSTDIV1_SHIFT;
 282                 rate = rate / (val + 1);
 283
 284                 val = (reg & SCG_PLL_CFG_POSTDIV2_MASK) >>
 285                         SCG_PLL_CFG_POSTDIV2_SHIFT;
 286                 rate = rate / (val + 1);
 287         } else {
 288                 /* APLL PFD clock */
 289                 val = (reg & SCG_PLL_CFG_PFDSEL_MASK) >>
 290                         SCG_PLL_CFG_PFDSEL_SHIFT;
 291                 rate = scg_apll_pfd_get_rate(SCG_APLL_PFD0_CLK + val);
 292         }
 293
 294         return rate;
 295 }
 296
 297 static u32 scg_spll_get_rate(void)
 298 {
 299         u32 reg, val, rate;
 300
 301         reg = readl(&scg1_regs->spllcfg);
 302         val = (reg & SCG_PLL_CFG_PLLSEL_MASK) >> SCG_PLL_CFG_PLLSEL_SHIFT;
 303
 304         clk_debug("scg_spll_get_rate reg 0x%x\n", reg);
 305
 306         if (!val) {
 307                 /* APLL clock after two dividers */
 308                 rate = decode_pll(PLL_A7_SPLL);
 309
 310                 val = (reg & SCG_PLL_CFG_POSTDIV1_MASK) >>
 311                         SCG_PLL_CFG_POSTDIV1_SHIFT;
 312                 rate = rate / (val + 1);
 313
 314                 val = (reg & SCG_PLL_CFG_POSTDIV2_MASK) >>
 315                         SCG_PLL_CFG_POSTDIV2_SHIFT;
 316                 rate = rate / (val + 1);
 317
 318                 clk_debug("scg_spll_get_rate SPLL %u\n", rate);
 319
 320         } else {
 321                 /* APLL PFD clock */
 322                 val = (reg & SCG_PLL_CFG_PFDSEL_MASK) >>
 323                         SCG_PLL_CFG_PFDSEL_SHIFT;
 324                 rate = scg_spll_pfd_get_rate(SCG_SPLL_PFD0_CLK + val);
 325
 326                 clk_debug("scg_spll_get_rate PFD %u\n", rate);
 327         }
 328
 329         return rate;
 330 }
 331
 332 static u32 scg_ddr_get_rate(void)
 333 {
 334         u32 reg, val, rate, div;
 335
 336         reg = readl(&scg1_regs->ddrccr);
 337         val = (reg & SCG_DDRCCR_DDRCS_MASK) >> SCG_DDRCCR_DDRCS_SHIFT;
 338         div = (reg & SCG_DDRCCR_DDRDIV_MASK) >> SCG_DDRCCR_DDRDIV_SHIFT;
 339
 340         if (!div)
 341                 return 0;
 342
 343         if (!val) {
 344                 reg = readl(&scg1_regs->apllcfg);
 345                 val = (reg & SCG_PLL_CFG_PFDSEL_MASK) >>
 346                         SCG_PLL_CFG_PFDSEL_SHIFT;
 347                 rate = scg_apll_pfd_get_rate(SCG_APLL_PFD0_CLK + val);
 348         } else {
 349                 rate = decode_pll(PLL_USB);
 350         }
 351
 352         rate = rate / (1 << (div - 1));
 353         return rate;
 354 }
 355
 356 static u32 scg_nic_get_rate(enum scg_clk clk)
 357 {
 358         u32 reg, val, rate;
 359         u32 shift, mask;
 360
 361         reg = readl(&scg1_regs->niccsr);
 362         val = (reg & SCG_NICCSR_NICCS_MASK) >> SCG_NICCSR_NICCS_SHIFT;
 363
 364         clk_debug("scg_nic_get_rate niccsr 0x%x\n", reg);
 365
 366         if (!val)
 367                 rate = scg_src_get_rate(SCG_FIRC_CLK);
 368         else
 369                 rate = scg_ddr_get_rate();
 370
 371         clk_debug("scg_nic_get_rate parent rate %u\n", rate);
 372
 373         val = (reg & SCG_NICCSR_NIC0DIV_MASK) >> SCG_NICCSR_NIC0DIV_SHIFT;
 374
 375         rate = rate / (val + 1);
 376
 377         clk_debug("scg_nic_get_rate NIC0 rate %u\n", rate);
 378
 379         switch (clk) {
 380         case SCG_NIC0_CLK:
 381                 return rate;
 382         case SCG_GPU_CLK:
 383                 mask = SCG_NICCSR_GPUDIV_MASK;
 384                 shift = SCG_NICCSR_GPUDIV_SHIFT;
 385                 break;
 386         case SCG_NIC1_EXT_CLK:
 387         case SCG_NIC1_BUS_CLK:
 388         case SCG_NIC1_CLK:
 389                 mask = SCG_NICCSR_NIC1DIV_MASK;
 390                 shift = SCG_NICCSR_NIC1DIV_SHIFT;
 391                 break;
 392         default:
 393                 return 0;
 394         }
 395
 396         val = (reg & mask) >> shift;
 397         rate = rate / (val + 1);
 398
 399         clk_debug("scg_nic_get_rate NIC1 rate %u\n", rate);
 400
 401         switch (clk) {
 402         case SCG_GPU_CLK:
 403         case SCG_NIC1_CLK:
 404                 return rate;
 405         case SCG_NIC1_EXT_CLK:
 406                 mask = SCG_NICCSR_NIC1EXTDIV_MASK;
 407                 shift = SCG_NICCSR_NIC1EXTDIV_SHIFT;
 408                 break;
 409         case SCG_NIC1_BUS_CLK:
 410                 mask = SCG_NICCSR_NIC1BUSDIV_MASK;
 411                 shift = SCG_NICCSR_NIC1BUSDIV_SHIFT;
 412                 break;
 413         default:
 414                 return 0;
 415         }
 416
 417         val = (reg & mask) >> shift;
 418         rate = rate / (val + 1);
 419
 420         clk_debug("scg_nic_get_rate NIC1 bus rate %u\n", rate);
 421         return rate;
 422 }
 423
 424
 425 static enum scg_clk scg_scs_array[4] = {
 426         SCG_SOSC_CLK, SCG_SIRC_CLK, SCG_FIRC_CLK, SCG_ROSC_CLK,
 427 };
 428
 429 static u32 scg_sys_get_rate(enum scg_clk clk)
 430 {
 431         u32 reg, val, rate;
 432
 433         if (clk != SCG_CORE_CLK && clk != SCG_BUS_CLK)
 434                 return 0;
 435
 436         reg = readl(&scg1_regs->csr);
 437         val = (reg & SCG_CCR_SCS_MASK) >> SCG_CCR_SCS_SHIFT;
 438
 439         clk_debug("scg_sys_get_rate reg 0x%x\n", reg);
 440
 441         switch (val) {
 442         case SCG_SCS_SYS_OSC:
 443         case SCG_SCS_SLOW_IRC:
 444         case SCG_SCS_FAST_IRC:
 445         case SCG_SCS_RTC_OSC:
 446                 rate = scg_src_get_rate(scg_scs_array[val]);
 447                 break;
 448         case 5:
 449                 rate = scg_apll_get_rate();
 450                 break;
 451         case 6:
 452                 rate = scg_spll_get_rate();
 453                 break;
 454         default:
 455                 return 0;
 456         }
 457
 458         clk_debug("scg_sys_get_rate parent rate %u\n", rate);
 459
 460         val = (reg & SCG_CCR_DIVCORE_MASK) >> SCG_CCR_DIVCORE_SHIFT;
 461
 462         rate = rate / (val + 1);
 463
 464         if (clk == SCG_BUS_CLK) {
 465                 val = (reg & SCG_CCR_DIVBUS_MASK) >> SCG_CCR_DIVBUS_SHIFT;
 466                 rate = rate / (val + 1);
 467         }
 468
 469         return rate;
 470 }
 471
 472 u32 decode_pll(enum pll_clocks pll)
 473 {
 474         u32 reg,  pre_div, infreq, mult;
 475         u32 num, denom;
 476
 477         /*
 478          * Alought there are four choices for the bypass src,
 479          * we choose OSC_24M which is the default set in ROM.
 480          */
 481         switch (pll) {
 482         case PLL_A7_SPLL:
 483                 reg = readl(&scg1_regs->spllcsr);
 484
 485                 if (!(reg & SCG_SPLL_CSR_SPLLVLD_MASK))
 486                         return 0;
 487
 488                 reg = readl(&scg1_regs->spllcfg);
 489
 490                 pre_div = (reg & SCG_PLL_CFG_PREDIV_MASK) >>
 491                            SCG_PLL_CFG_PREDIV_SHIFT;
 492                 pre_div += 1;
 493
 494                 mult = (reg & SCG1_SPLL_CFG_MULT_MASK) >>
 495                            SCG_PLL_CFG_MULT_SHIFT;
 496
 497                 infreq = (reg & SCG_PLL_CFG_CLKSRC_MASK) >>
 498                            SCG_PLL_CFG_CLKSRC_SHIFT;
 499                 if (!infreq)
 500                         infreq = scg_src_get_rate(SCG_SOSC_CLK);
 501                 else
 502                         infreq = scg_src_get_rate(SCG_FIRC_CLK);
 503
 504                 num = readl(&scg1_regs->spllnum);
 505                 denom = readl(&scg1_regs->splldenom);
 506
 507                 return (infreq / pre_div) * (mult + num / denom);
 508
 509         case PLL_A7_APLL:
 510                 reg = readl(&scg1_regs->apllcsr);
 511
 512                 if (!(reg & SCG_APLL_CSR_APLLVLD_MASK))
 513                         return 0;
 514
 515                 reg = readl(&scg1_regs->apllcfg);
 516
 517                 pre_div = (reg & SCG_PLL_CFG_PREDIV_MASK) >>
 518                            SCG_PLL_CFG_PREDIV_SHIFT;
 519                 pre_div += 1;
 520
 521                 mult = (reg & SCG_APLL_CFG_MULT_MASK) >>
 522                            SCG_PLL_CFG_MULT_SHIFT;
 523
 524                 infreq = (reg & SCG_PLL_CFG_CLKSRC_MASK) >>
 525                            SCG_PLL_CFG_CLKSRC_SHIFT;
 526                 if (!infreq)
 527                         infreq = scg_src_get_rate(SCG_SOSC_CLK);
 528                 else
 529                         infreq = scg_src_get_rate(SCG_FIRC_CLK);
 530
 531                 num = readl(&scg1_regs->apllnum);
 532                 denom = readl(&scg1_regs->aplldenom);
 533
 534                 return (infreq / pre_div) * (mult + num / denom);
 535
 536         case PLL_USB:
 537                 reg = readl(&scg1_regs->upllcsr);
 538
 539                 if (!(reg & SCG_UPLL_CSR_UPLLVLD_MASK))
 540                         return 0;
 541
 542                 return 480000000u;
 543
 544         case PLL_MIPI:
 545                 return 480000000u;
 546         default:
 547                 printf("Unsupported pll clocks %d\n", pll);
 548                 break;
 549         }
 550
 551         return 0;
 552 }
 553
 554 u32 scg_clk_get_rate(enum scg_clk clk)
 555 {
 556         switch (clk) {
 557         case SCG_SIRC_DIV1_CLK:
 558         case SCG_SIRC_DIV2_CLK:
 559         case SCG_SIRC_DIV3_CLK:
 560                 return scg_sircdiv_get_rate(clk);
 561
 562         case SCG_FIRC_DIV1_CLK:
 563         case SCG_FIRC_DIV2_CLK:
 564         case SCG_FIRC_DIV3_CLK:
 565                 return scg_fircdiv_get_rate(clk);
 566
 567         case SCG_SOSC_DIV1_CLK:
 568         case SCG_SOSC_DIV2_CLK:
 569         case SCG_SOSC_DIV3_CLK:
 570                 return scg_soscdiv_get_rate(clk);
 571
 572         case SCG_CORE_CLK:
 573         case SCG_BUS_CLK:
 574                 return scg_sys_get_rate(clk);
 575
 576         case SCG_SPLL_PFD0_CLK:
 577         case SCG_SPLL_PFD1_CLK:
 578         case SCG_SPLL_PFD2_CLK:
 579         case SCG_SPLL_PFD3_CLK:
 580                 return scg_spll_pfd_get_rate(clk);
 581
 582         case SCG_APLL_PFD0_CLK:
 583         case SCG_APLL_PFD1_CLK:
 584         case SCG_APLL_PFD2_CLK:
 585         case SCG_APLL_PFD3_CLK:
 586                 return scg_apll_pfd_get_rate(clk);
 587
 588         case SCG_DDR_CLK:
 589                 return scg_ddr_get_rate();
 590
 591         case SCG_NIC0_CLK:
 592         case SCG_GPU_CLK:
 593         case SCG_NIC1_CLK:
 594         case SCG_NIC1_BUS_CLK:
 595         case SCG_NIC1_EXT_CLK:
 596                 return scg_nic_get_rate(clk);
 597
 598         case USB_PLL_OUT:
 599                 return decode_pll(PLL_USB);
 600
 601         case MIPI_PLL_OUT:
 602                 return decode_pll(PLL_MIPI);
 603
 604         case SCG_SOSC_CLK:
 605         case SCG_FIRC_CLK:
 606         case SCG_SIRC_CLK:
 607         case SCG_ROSC_CLK:
 608                 return scg_src_get_rate(clk);
 609         default:
 610                 return 0;
 611         }
 612 }
 613
 614 int scg_enable_pll_pfd(enum scg_clk clk, u32 frac)
 615 {
 616         u32 reg;
 617         u32 shift, mask, gate, valid;
 618         u32 addr;
 619
 620         if (frac < 12 || frac > 35)
 621                 return -EINVAL;
 622
 623         switch (clk) {
 624         case SCG_SPLL_PFD0_CLK:
 625         case SCG_APLL_PFD0_CLK:
 626                 gate = SCG_PLL_PFD0_GATE_MASK;
 627                 valid = SCG_PLL_PFD0_VALID_MASK;
 628                 mask = SCG_PLL_PFD0_FRAC_MASK;
 629                 shift = SCG_PLL_PFD0_FRAC_SHIFT;
 630
 631                 if (clk == SCG_SPLL_PFD0_CLK)
 632                         addr = (u32)(&scg1_regs->spllpfd);
 633                 else
 634                         addr = (u32)(&scg1_regs->apllpfd);
 635                 break;
 636         case SCG_SPLL_PFD1_CLK:
 637         case SCG_APLL_PFD1_CLK:
 638                 gate = SCG_PLL_PFD1_GATE_MASK;
 639                 valid = SCG_PLL_PFD1_VALID_MASK;
 640                 mask = SCG_PLL_PFD1_FRAC_MASK;
 641                 shift = SCG_PLL_PFD1_FRAC_SHIFT;
 642
 643                 if (clk == SCG_SPLL_PFD1_CLK)
 644                         addr = (u32)(&scg1_regs->spllpfd);
 645                 else
 646                         addr = (u32)(&scg1_regs->apllpfd);
 647                 break;
 648         case SCG_SPLL_PFD2_CLK:
 649         case SCG_APLL_PFD2_CLK:
 650                 gate = SCG_PLL_PFD2_GATE_MASK;
 651                 valid = SCG_PLL_PFD2_VALID_MASK;
 652                 mask = SCG_PLL_PFD2_FRAC_MASK;
 653                 shift = SCG_PLL_PFD2_FRAC_SHIFT;
 654
 655                 if (clk == SCG_SPLL_PFD2_CLK)
 656                         addr = (u32)(&scg1_regs->spllpfd);
 657                 else
 658                         addr = (u32)(&scg1_regs->apllpfd);
 659                 break;
 660         case SCG_SPLL_PFD3_CLK:
 661         case SCG_APLL_PFD3_CLK:
 662                 gate = SCG_PLL_PFD3_GATE_MASK;
 663                 valid = SCG_PLL_PFD3_VALID_MASK;
 664                 mask = SCG_PLL_PFD3_FRAC_MASK;
 665                 shift = SCG_PLL_PFD3_FRAC_SHIFT;
 666
 667                 if (clk == SCG_SPLL_PFD3_CLK)
 668                         addr = (u32)(&scg1_regs->spllpfd);
 669                 else
 670                         addr = (u32)(&scg1_regs->apllpfd);
 671                 break;
 672         default:
 673                 return -EINVAL;
 674         }
 675
 676         /* Gate the PFD */
 677         reg = readl(addr);
 678         reg |= gate;
 679         writel(reg, addr);
 680
 681         /* Write Frac divider */
 682         reg &= ~mask;
 683         reg |= (frac << shift) & mask;
 684         writel(reg, addr);
 685
 686         /*
 687          * Un-gate the PFD
 688          * (Need un-gate before checking valid, not align with RM)
 689          */
 690         reg &= ~gate;
 691         writel(reg, addr);
 692
 693         /* Wait for PFD clock being valid */
 694         do {
 695                 reg = readl(addr);
 696         } while (!(reg & valid));
 697
 698         return 0;
 699 }
 700
 701 #define SIM_MISC_CTRL0_USB_PLL_EN_MASK (0x1 << 2)
 702 int scg_enable_usb_pll(bool usb_control)
 703 {
 704         u32 sosc_rate;
 705         s32 timeout = 1000000;
 706         u32 reg;
 707
 708         struct usbphy_regs *usbphy =
 709                 (struct usbphy_regs *)USBPHY_RBASE;
 710
 711         sosc_rate = scg_src_get_rate(SCG_SOSC_CLK);
 712         if (!sosc_rate)
 713                 return -EPERM;
 714
 715         reg = readl(SIM0_RBASE + 0x3C);
 716         if (usb_control)
 717                 reg &= ~SIM_MISC_CTRL0_USB_PLL_EN_MASK;
 718         else
 719                 reg |= SIM_MISC_CTRL0_USB_PLL_EN_MASK;
 720         writel(reg, SIM0_RBASE + 0x3C);
 721
 722         if (!(readl(&usbphy->usb1_pll_480_ctrl) & PLL_USB_LOCK_MASK)) {
 723                 writel(0x1c00000, &usbphy->usb1_pll_480_ctrl_clr);
 724
 725                 switch (sosc_rate) {
 726                 case 24000000:
 727                         writel(0xc00000, &usbphy->usb1_pll_480_ctrl_set);
 728                         break;
 729
 730                 case 30000000:
 731                         writel(0x800000, &usbphy->usb1_pll_480_ctrl_set);
 732                         break;
 733
 734                 case 19200000:
 735                         writel(0x1400000, &usbphy->usb1_pll_480_ctrl_set);
 736                         break;
 737
 738                 default:
 739                         writel(0xc00000, &usbphy->usb1_pll_480_ctrl_set);
 740                         break;
 741                 }
 742
 743                 /* Enable the regulator first */
 744                 writel(PLL_USB_REG_ENABLE_MASK,
 745                        &usbphy->usb1_pll_480_ctrl_set);
 746
 747                 /* Wait at least 15us */
 748                 udelay(15);
 749
 750                 /* Enable the power */
 751                 writel(PLL_USB_PWR_MASK, &usbphy->usb1_pll_480_ctrl_set);
 752
 753                 /* Wait lock */
 754                 while (timeout--) {
 755                         if (readl(&usbphy->usb1_pll_480_ctrl) &
 756                             PLL_USB_LOCK_MASK)
 757                                 break;
 758                 }
 759
 760                 if (timeout <= 0) {
 761                         /* If timeout, we power down the pll */
 762                         writel(PLL_USB_PWR_MASK,
 763                                &usbphy->usb1_pll_480_ctrl_clr);
 764                         return -ETIME;
 765                 }
 766         }
 767
 768         /* Clear the bypass */
 769         writel(PLL_USB_BYPASS_MASK, &usbphy->usb1_pll_480_ctrl_clr);
 770
 771         /* Enable the PLL clock out to USB */
 772         writel((PLL_USB_EN_USB_CLKS_MASK | PLL_USB_ENABLE_MASK),
 773                &usbphy->usb1_pll_480_ctrl_set);
 774
 775         if (!usb_control) {
 776                 while (timeout--) {
 777                         if (readl(&scg1_regs->upllcsr) &
 778                             SCG_UPLL_CSR_UPLLVLD_MASK)
 779                                 break;
 780                 }
 781
 782                 if (timeout <= 0) {
 783                         reg = readl(SIM0_RBASE + 0x3C);
 784                         reg &= ~SIM_MISC_CTRL0_USB_PLL_EN_MASK;
 785                         writel(reg, SIM0_RBASE + 0x3C);
 786                         return -ETIME;
 787                 }
 788         }
 789
 790         return 0;
 791 }
 792
 793
 794 /* A7 domain system clock source is SPLL */
 795 #define SCG1_RCCR_SCS_NUM       ((SCG_SCS_SYS_PLL) << SCG_CCR_SCS_SHIFT)
 796
 797 /* A7 Core clck = SPLL PFD0 / 1 = 500MHz / 1 = 500MHz */
 798 #define SCG1_RCCR_DIVCORE_NUM   ((0x0)  << SCG_CCR_DIVCORE_SHIFT)
 799 #define SCG1_RCCR_CFG_MASK      (SCG_CCR_SCS_MASK | SCG_CCR_DIVBUS_MASK)
 800
 801 /* A7 Plat clck = A7 Core Clock / 2 = 250MHz / 1 = 250MHz */
 802 #define SCG1_RCCR_DIVBUS_NUM    ((0x1)  << SCG_CCR_DIVBUS_SHIFT)
 803 #define SCG1_RCCR_CFG_NUM       (SCG1_RCCR_SCS_NUM | SCG1_RCCR_DIVBUS_NUM)
 804
 805 void scg_a7_rccr_init(void)
 806 {
 807         u32 rccr_reg_val = 0;
 808
 809         rccr_reg_val = readl(&scg1_regs->rccr);
 810
 811         rccr_reg_val &= (~SCG1_RCCR_CFG_MASK);
 812         rccr_reg_val |= (SCG1_RCCR_CFG_NUM);
 813
 814         writel(rccr_reg_val, &scg1_regs->rccr);
 815 }
 816
 817 /* POSTDIV2 = 1 */
 818 #define SCG1_SPLL_CFG_POSTDIV2_NUM      ((0x0)  << SCG_PLL_CFG_POSTDIV2_SHIFT)
 819 /* POSTDIV1 = 1 */
 820 #define SCG1_SPLL_CFG_POSTDIV1_NUM      ((0x0)  << SCG_PLL_CFG_POSTDIV1_SHIFT)
 821
 822 /* MULT = 22 */
 823 #define SCG1_SPLL_CFG_MULT_NUM          ((22)   << SCG_PLL_CFG_MULT_SHIFT)
 824
 825 /* PFD0 output clock selected */
 826 #define SCG1_SPLL_CFG_PFDSEL_NUM        ((0) << SCG_PLL_CFG_PFDSEL_SHIFT)
 827 /* PREDIV = 1 */
 828 #define SCG1_SPLL_CFG_PREDIV_NUM        ((0x0)  << SCG_PLL_CFG_PREDIV_SHIFT)
 829 /* SPLL output clocks (including PFD outputs) selected */
 830 #define SCG1_SPLL_CFG_BYPASS_NUM        ((0x0)  << SCG_PLL_CFG_BYPASS_SHIFT)
 831 /* SPLL PFD output clock selected */
 832 #define SCG1_SPLL_CFG_PLLSEL_NUM        ((0x1)  << SCG_PLL_CFG_PLLSEL_SHIFT)
 833 /* Clock source is System OSC */
 834 #define SCG1_SPLL_CFG_CLKSRC_NUM        ((0x0)  << SCG_PLL_CFG_CLKSRC_SHIFT)
 835 #define SCG1_SPLL_CFG_NUM_24M_OSC       (SCG1_SPLL_CFG_POSTDIV2_NUM     | \
 836                                          SCG1_SPLL_CFG_POSTDIV1_NUM     | \
 837                                          (22 << SCG_PLL_CFG_MULT_SHIFT) | \
 838                                          SCG1_SPLL_CFG_PFDSEL_NUM       | \
 839                                          SCG1_SPLL_CFG_PREDIV_NUM       | \
 840                                          SCG1_SPLL_CFG_BYPASS_NUM       | \
 841                                          SCG1_SPLL_CFG_PLLSEL_NUM       | \
 842                                          SCG1_SPLL_CFG_CLKSRC_NUM)
 843 /*413Mhz = A7 SPLL(528MHz) * 18/23 */
 844 #define SCG1_SPLL_PFD0_FRAC_NUM         ((23) << SCG_PLL_PFD0_FRAC_SHIFT)
 845
 846 void scg_a7_spll_init(void)
 847 {
 848         u32 val = 0;
 849
 850         /* Disable A7 System PLL */
 851         val = readl(&scg1_regs->spllcsr);
 852         val &= ~SCG_SPLL_CSR_SPLLEN_MASK;
 853         writel(val, &scg1_regs->spllcsr);
 854
 855         /*
 856          * Per block guide,
 857          * "When changing PFD values, it is recommneded PFDx clock
 858          * gets gated first by writing a value of 1 to PFDx_CLKGATE register,
 859          * then program the new PFD value, then poll the PFDx_VALID
 860          * flag to set before writing a value of 0 to PFDx_CLKGATE
 861          * to ungate the PFDx clock and allow PFDx clock to run"
 862          */
 863
 864         /* Gate off A7 SPLL PFD0 ~ PDF4  */
 865         val = readl(&scg1_regs->spllpfd);
 866         val |= (SCG_PLL_PFD3_GATE_MASK |
 867                         SCG_PLL_PFD2_GATE_MASK |
 868                         SCG_PLL_PFD1_GATE_MASK |
 869                         SCG_PLL_PFD0_GATE_MASK);
 870         writel(val, &scg1_regs->spllpfd);
 871
 872         /* ================ A7 SPLL Configuration Start ============== */
 873
 874         /* Configure A7 System PLL */
 875         writel(SCG1_SPLL_CFG_NUM_24M_OSC, &scg1_regs->spllcfg);
 876
 877         /* Enable A7 System PLL */
 878         val = readl(&scg1_regs->spllcsr);
 879         val |= SCG_SPLL_CSR_SPLLEN_MASK;
 880         writel(val, &scg1_regs->spllcsr);
 881
 882         /* Wait for A7 SPLL clock ready */
 883         while (!(readl(&scg1_regs->spllcsr) & SCG_SPLL_CSR_SPLLVLD_MASK))
 884                 ;
 885
 886         /* Configure A7 SPLL PFD0 */
 887         val = readl(&scg1_regs->spllpfd);
 888         val &= ~SCG_PLL_PFD0_FRAC_MASK;
 889         val |= SCG1_SPLL_PFD0_FRAC_NUM;
 890         writel(val, &scg1_regs->spllpfd);
 891
 892         /* Un-gate A7 SPLL PFD0 */
 893         val = readl(&scg1_regs->spllpfd);
 894         val &= ~SCG_PLL_PFD0_GATE_MASK;
 895         writel(val, &scg1_regs->spllpfd);
 896
 897         /* Wait for A7 SPLL PFD0 clock being valid */
 898         while (!(readl(&scg1_regs->spllpfd) & SCG_PLL_PFD0_VALID_MASK))
 899                 ;
 900
 901         /* ================ A7 SPLL Configuration End ============== */
 902 }
 903
 904 /* DDR clock source is APLL PFD0 (396MHz) */
 905 #define SCG1_DDRCCR_DDRCS_NUM           ((0x0) << SCG_DDRCCR_DDRCS_SHIFT)
 906 /* DDR clock = APLL PFD0 / 1 = 396MHz / 1 = 396MHz */
 907 #define SCG1_DDRCCR_DDRDIV_NUM          ((0x1) << SCG_DDRCCR_DDRDIV_SHIFT)
 908 /* DDR clock = APLL PFD0 / 2 = 396MHz / 2 = 198MHz */
 909 #define SCG1_DDRCCR_DDRDIV_LF_NUM       ((0x2) << SCG_DDRCCR_DDRDIV_SHIFT)
 910 #define SCG1_DDRCCR_CFG_NUM             (SCG1_DDRCCR_DDRCS_NUM  | \
 911                                          SCG1_DDRCCR_DDRDIV_NUM)
 912 #define SCG1_DDRCCR_CFG_LF_NUM          (SCG1_DDRCCR_DDRCS_NUM  | \
 913                                          SCG1_DDRCCR_DDRDIV_LF_NUM)
 914 void scg_a7_ddrclk_init(void)
 915 {
 916         writel(SCG1_DDRCCR_CFG_NUM, &scg1_regs->ddrccr);
 917 }
 918
 919 /* SCG1(A7) APLLCFG configurations */
 920 /* divide by 1 <<28 */
 921 #define SCG1_APLL_CFG_POSTDIV2_NUM      ((0x0) << SCG_PLL_CFG_POSTDIV2_SHIFT)
 922 /* divide by 1 <<24 */
 923 #define SCG1_APLL_CFG_POSTDIV1_NUM      ((0x0) << SCG_PLL_CFG_POSTDIV1_SHIFT)
 924 /* MULT is 22  <<16 */
 925 #define SCG1_APLL_CFG_MULT_NUM          ((22)  << SCG_PLL_CFG_MULT_SHIFT)
 926 /* PFD0 output clock selected  <<14 */
 927 #define SCG1_APLL_CFG_PFDSEL_NUM        ((0) << SCG_PLL_CFG_PFDSEL_SHIFT)
 928 /* PREDIV = 1   <<8 */
 929 #define SCG1_APLL_CFG_PREDIV_NUM        ((0x0) << SCG_PLL_CFG_PREDIV_SHIFT)
 930 /* APLL output clocks (including PFD outputs) selected  <<2 */
 931 #define SCG1_APLL_CFG_BYPASS_NUM        ((0x0) << SCG_PLL_CFG_BYPASS_SHIFT)
 932 /* APLL PFD output clock selected <<1 */
 933 #define SCG1_APLL_CFG_PLLSEL_NUM        ((0x0) << SCG_PLL_CFG_PLLSEL_SHIFT)
 934 /* Clock source is System OSC <<0 */
 935 #define SCG1_APLL_CFG_CLKSRC_NUM        ((0x0) << SCG_PLL_CFG_CLKSRC_SHIFT)
 936
 937 /*
 938  * A7 APLL = 24MHz / 1 * 22 / 1 / 1 = 528MHz,
 939  * system PLL is sourced from APLL,
 940  * APLL clock source is system OSC (24MHz)
 941  */
 942 #define SCG1_APLL_CFG_NUM_24M_OSC (SCG1_APLL_CFG_POSTDIV2_NUM     |   \
 943                                    SCG1_APLL_CFG_POSTDIV1_NUM     |   \
 944                                    (22 << SCG_PLL_CFG_MULT_SHIFT) |   \
 945                                    SCG1_APLL_CFG_PFDSEL_NUM       |   \
 946                                    SCG1_APLL_CFG_PREDIV_NUM       |   \
 947                                    SCG1_APLL_CFG_BYPASS_NUM       |   \
 948                                    SCG1_APLL_CFG_PLLSEL_NUM       |   \
 949                                    SCG1_APLL_CFG_CLKSRC_NUM)
 950
 951 /* PFD0 Freq = A7 APLL(528MHz) * 18 / 27 = 352MHz */
 952 #define SCG1_APLL_PFD0_FRAC_NUM (27)
 953
 954
 955 void scg_a7_apll_init(void)
 956 {
 957         u32 val = 0;
 958
 959         /* Disable A7 Auxiliary PLL */
 960         val = readl(&scg1_regs->apllcsr);
 961         val &= ~SCG_APLL_CSR_APLLEN_MASK;
 962         writel(val, &scg1_regs->apllcsr);
 963
 964         /* Gate off A7 APLL PFD0 ~ PDF4  */
 965         val = readl(&scg1_regs->apllpfd);
 966         val |= 0x80808080;
 967         writel(val, &scg1_regs->apllpfd);
 968
 969         /* ================ A7 APLL Configuration Start ============== */
 970         /* Configure A7 Auxiliary PLL */
 971         writel(SCG1_APLL_CFG_NUM_24M_OSC, &scg1_regs->apllcfg);
 972
 973         /* Enable A7 Auxiliary PLL */
 974         val = readl(&scg1_regs->apllcsr);
 975         val |= SCG_APLL_CSR_APLLEN_MASK;
 976         writel(val, &scg1_regs->apllcsr);
 977
 978         /* Wait for A7 APLL clock ready */
 979         while (!(readl(&scg1_regs->apllcsr) & SCG_APLL_CSR_APLLVLD_MASK))
 980                 ;
 981
 982         /* Configure A7 APLL PFD0 */
 983         val = readl(&scg1_regs->apllpfd);
 984         val &= ~SCG_PLL_PFD0_FRAC_MASK;
 985         val |= SCG1_APLL_PFD0_FRAC_NUM;
 986         writel(val, &scg1_regs->apllpfd);
 987
 988         /* Un-gate A7 APLL PFD0 */
 989         val = readl(&scg1_regs->apllpfd);
 990         val &= ~SCG_PLL_PFD0_GATE_MASK;
 991         writel(val, &scg1_regs->apllpfd);
 992
 993         /* Wait for A7 APLL PFD0 clock being valid */
 994         while (!(readl(&scg1_regs->apllpfd) & SCG_PLL_PFD0_VALID_MASK))
 995                 ;
 996 }
 997
 998 /* SCG1(A7) FIRC DIV configurations */
 999 /* Disable FIRC DIV3 */
1000 #define SCG1_FIRCDIV_DIV3_NUM           ((0x0) << SCG_FIRCDIV_DIV3_SHIFT)
1001 /* FIRC DIV2 = 48MHz / 1 = 48MHz */
1002 #define SCG1_FIRCDIV_DIV2_NUM           ((0x1) << SCG_FIRCDIV_DIV2_SHIFT)
1003 /* Disable FIRC DIV1 */
1004 #define SCG1_FIRCDIV_DIV1_NUM           ((0x0) << SCG_FIRCDIV_DIV1_SHIFT)
1005
1006 void scg_a7_firc_init(void)
1007 {
1008         /* Wait for FIRC clock ready */
1009         while (!(readl(&scg1_regs->firccsr) & SCG_FIRC_CSR_FIRCVLD_MASK))
1010                 ;
1011
1012         /* Configure A7 FIRC DIV1 ~ DIV3 */
1013         writel((SCG1_FIRCDIV_DIV3_NUM |
1014                         SCG1_FIRCDIV_DIV2_NUM |
1015                         SCG1_FIRCDIV_DIV1_NUM), &scg1_regs->fircdiv);
1016 }
1017
1018 /* SCG1(A7) NICCCR configurations */
1019 /* NIC clock source is DDR clock (396/198MHz) */
1020 #define SCG1_NICCCR_NICCS_NUM           ((0x1) << SCG_NICCCR_NICCS_SHIFT)
1021
1022 /* NIC0 clock = DDR Clock / 2 = 396MHz / 2 = 198MHz */
1023 #define SCG1_NICCCR_NIC0_DIV_NUM        ((0x1) << SCG_NICCCR_NIC0_DIV_SHIFT)
1024 /* NIC0 clock = DDR Clock / 1 = 198MHz / 1 = 198MHz */
1025 #define SCG1_NICCCR_NIC0_DIV_LF_NUM     ((0x0) << SCG_NICCCR_NIC0_DIV_SHIFT)
1026 /* NIC1 clock = NIC0 Clock / 1 = 198MHz / 2 = 198MHz */
1027 #define SCG1_NICCCR_NIC1_DIV_NUM        ((0x0) << SCG_NICCCR_NIC1_DIV_SHIFT)
1028 /* NIC1 bus clock = NIC1 Clock / 3 = 198MHz / 3 = 66MHz */
1029 #define SCG1_NICCCR_NIC1_DIVBUS_NUM     ((0x2) << SCG_NICCCR_NIC1_DIVBUS_SHIFT)
1030 #define SCG1_NICCCR_CFG_NUM             (SCG1_NICCCR_NICCS_NUM      | \
1031                                          SCG1_NICCCR_NIC0_DIV_NUM   | \
1032                                          SCG1_NICCCR_NIC1_DIV_NUM   | \
1033                                          SCG1_NICCCR_NIC1_DIVBUS_NUM)
1034
1035 void scg_a7_nicclk_init(void)
1036 {
1037         writel(SCG1_NICCCR_CFG_NUM, &scg1_regs->nicccr);
1038 }
1039
1040 /* SCG1(A7) FIRC DIV configurations */
1041 /* Enable FIRC DIV3 */
1042 #define SCG1_SOSCDIV_DIV3_NUM           ((0x1) << SCG_SOSCDIV_DIV3_SHIFT)
1043 /* FIRC DIV2 = 48MHz / 1 = 48MHz */
1044 #define SCG1_SOSCDIV_DIV2_NUM           ((0x1) << SCG_SOSCDIV_DIV2_SHIFT)
1045 /* Enable FIRC DIV1 */
1046 #define SCG1_SOSCDIV_DIV1_NUM           ((0x1) << SCG_SOSCDIV_DIV1_SHIFT)
1047
1048 void scg_a7_soscdiv_init(void)
1049 {
1050         /* Wait for FIRC clock ready */
1051         while (!(readl(&scg1_regs->sosccsr) & SCG_SOSC_CSR_SOSCVLD_MASK))
1052                 ;
1053
1054         /* Configure A7 FIRC DIV1 ~ DIV3 */
1055         writel((SCG1_SOSCDIV_DIV3_NUM | SCG1_SOSCDIV_DIV2_NUM |
1056                SCG1_SOSCDIV_DIV1_NUM), &scg1_regs->soscdiv);
1057 }
1058
1059 void scg_a7_sys_clk_sel(enum scg_sys_src clk)
1060 {
1061         u32 rccr_reg_val = 0;
1062
1063         clk_debug("%s: system clock selected as %s\n", "[SCG]",
1064                   clk == SCG_SCS_SYS_OSC ? "SYS_OSC" :
1065                   clk == SCG_SCS_SLOW_IRC  ? "SLOW_IRC" :
1066                   clk == SCG_SCS_FAST_IRC  ? "FAST_IRC" :
1067                   clk == SCG_SCS_RTC_OSC   ? "RTC_OSC" :
1068                   clk == SCG_SCS_AUX_PLL   ? "AUX_PLL" :
1069                   clk == SCG_SCS_SYS_PLL   ? "SYS_PLL" :
1070                   clk == SCG_SCS_USBPHY_PLL ? "USBPHY_PLL" :
1071                   "Invalid source"
1072         );
1073
1074         rccr_reg_val = readl(&scg1_regs->rccr);
1075         rccr_reg_val &= ~SCG_CCR_SCS_MASK;
1076         rccr_reg_val |= (clk << SCG_CCR_SCS_SHIFT);
1077         writel(rccr_reg_val, &scg1_regs->rccr);
1078 }
1079
1080 void scg_a7_info(void)
1081 {
1082         debug("SCG Version: 0x%x\n", readl(&scg1_regs->verid));
1083         debug("SCG Parameter: 0x%x\n", readl(&scg1_regs->param));
1084         debug("SCG RCCR Value: 0x%x\n", readl(&scg1_regs->rccr));
1085         debug("SCG Clock Status: 0x%x\n", readl(&scg1_regs->csr));
1086 }