git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-s3c2443/clock.c

   1 /* linux/arch/arm/mach-s3c2443/clock.c
   2  *
   3  * Copyright (c) 2007 Simtec Electronics
   4  *      Ben Dooks <ben@simtec.co.uk>
   5  *
   6  * S3C2443 Clock control support
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22
  23 #include <linux/init.h>
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/list.h>
  27 #include <linux/errno.h>
  28 #include <linux/err.h>
  29 #include <linux/sysdev.h>
  30 #include <linux/clk.h>
  31 #include <linux/mutex.h>
  32 #include <linux/delay.h>
  33 #include <linux/serial_core.h>
  34
  35 #include <asm/mach/map.h>
  36
  37 #include <asm/hardware.h>
  38 #include <asm/io.h>
  39
  40 #include <asm/arch/regs-s3c2443-clock.h>
  41
  42 #include <asm/plat-s3c24xx/s3c2443.h>
  43 #include <asm/plat-s3c24xx/clock.h>
  44 #include <asm/plat-s3c24xx/cpu.h>
  45
  46 /* We currently have to assume that the system is running
  47  * from the XTPll input, and that all ***REFCLKs are being
  48  * fed from it, as we cannot read the state of OM[4] from
  49  * software.
  50  *
  51  * It would be possible for each board initialisation to
  52  * set the correct muxing at initialisation
  53 */
  54
  55 static int s3c2443_clkcon_enable_h(struct clk *clk, int enable)
  56 {
  57         unsigned int clocks = clk->ctrlbit;
  58         unsigned long clkcon;
  59
  60         clkcon = __raw_readl(S3C2443_HCLKCON);
  61
  62         if (enable)
  63                 clkcon |= clocks;
  64         else
  65                 clkcon &= ~clocks;
  66
  67         __raw_writel(clkcon, S3C2443_HCLKCON);
  68
  69         return 0;
  70 }
  71
  72 static int s3c2443_clkcon_enable_p(struct clk *clk, int enable)
  73 {
  74         unsigned int clocks = clk->ctrlbit;
  75         unsigned long clkcon;
  76
  77         clkcon = __raw_readl(S3C2443_PCLKCON);
  78
  79         if (enable)
  80                 clkcon |= clocks;
  81         else
  82                 clkcon &= ~clocks;
  83
  84         __raw_writel(clkcon, S3C2443_HCLKCON);
  85
  86         return 0;
  87 }
  88
  89 static int s3c2443_clkcon_enable_s(struct clk *clk, int enable)
  90 {
  91         unsigned int clocks = clk->ctrlbit;
  92         unsigned long clkcon;
  93
  94         clkcon = __raw_readl(S3C2443_SCLKCON);
  95
  96         if (enable)
  97                 clkcon |= clocks;
  98         else
  99                 clkcon &= ~clocks;
 100
 101         __raw_writel(clkcon, S3C2443_SCLKCON);
 102
 103         return 0;
 104 }
 105
 106 static unsigned long s3c2443_roundrate_clksrc(struct clk *clk,
 107                                               unsigned long rate,
 108                                               unsigned int max)
 109 {
 110         unsigned long parent_rate = clk_get_rate(clk->parent);
 111         int div;
 112
 113         if (rate > parent_rate)
 114                 return parent_rate;
 115
 116         /* note, we remove the +/- 1 calculations as they cancel out */
 117
 118         div = (rate / parent_rate);
 119
 120         if (div < 1)
 121                 div = 1;
 122         else if (div > max)
 123                 div = max;
 124
 125         return parent_rate / div;
 126 }
 127
 128 static unsigned long s3c2443_roundrate_clksrc4(struct clk *clk,
 129                                                unsigned long rate)
 130 {
 131         return s3c2443_roundrate_clksrc(clk, rate, 4);
 132 }
 133
 134 static unsigned long s3c2443_roundrate_clksrc16(struct clk *clk,
 135                                                 unsigned long rate)
 136 {
 137         return s3c2443_roundrate_clksrc(clk, rate, 16);
 138 }
 139
 140 static unsigned long s3c2443_roundrate_clksrc256(struct clk *clk,
 141                                                  unsigned long rate)
 142 {
 143         return s3c2443_roundrate_clksrc(clk, rate, 256);
 144 }
 145
 146 /* clock selections */
 147
 148 /* CPU EXTCLK input */
 149 static struct clk clk_ext = {
 150         .name           = "ext",
 151         .id             = -1,
 152 };
 153
 154 static struct clk clk_mpllref = {
 155         .name           = "mpllref",
 156         .parent         = &clk_xtal,
 157         .id             = -1,
 158 };
 159
 160 #if 0
 161 static struct clk clk_mpll = {
 162         .name           = "mpll",
 163         .parent         = &clk_mpllref,
 164         .id             = -1,
 165 };
 166 #endif
 167
 168 static struct clk clk_epllref;
 169
 170 static struct clk clk_epll = {
 171         .name           = "epll",
 172         .parent         = &clk_epllref,
 173         .id             = -1,
 174 };
 175
 176 static struct clk clk_i2s_ext = {
 177         .name           = "i2s-ext",
 178         .id             = -1,
 179 };
 180
 181 static int s3c2443_setparent_epllref(struct clk *clk, struct clk *parent)
 182 {
 183         unsigned long clksrc = __raw_readl(S3C2443_CLKSRC);
 184
 185         clksrc &= ~S3C2443_CLKSRC_EPLLREF_MASK;
 186
 187         if (parent == &clk_xtal)
 188                 clksrc |= S3C2443_CLKSRC_EPLLREF_XTAL;
 189         else if (parent == &clk_ext)
 190                 clksrc |= S3C2443_CLKSRC_EPLLREF_EXTCLK;
 191         else if (parent != &clk_mpllref)
 192                 return -EINVAL;
 193
 194         __raw_writel(clksrc, S3C2443_CLKSRC);
 195         clk->parent = parent;
 196
 197         return 0;
 198 }
 199
 200 static struct clk clk_epllref = {
 201         .name           = "epllref",
 202         .id             = -1,
 203         .set_parent     = s3c2443_setparent_epllref,
 204 };
 205
 206 static unsigned long s3c2443_getrate_mdivclk(struct clk *clk)
 207 {
 208         unsigned long parent_rate = clk_get_rate(clk->parent);
 209         unsigned long div = __raw_readl(S3C2443_CLKDIV0);
 210
 211         div  &= S3C2443_CLKDIV0_EXTDIV_MASK;
 212         div >>= (S3C2443_CLKDIV0_EXTDIV_SHIFT-1);       /* x2 */
 213
 214         return parent_rate / (div + 1);
 215 }
 216
 217 static struct clk clk_mdivclk = {
 218         .name           = "mdivclk",
 219         .parent         = &clk_mpllref,
 220         .id             = -1,
 221         .get_rate       = s3c2443_getrate_mdivclk,
 222 };
 223
 224
 225 static int s3c2443_setparent_msysclk(struct clk *clk, struct clk *parent)
 226 {
 227         unsigned long clksrc = __raw_readl(S3C2443_CLKSRC);
 228
 229         clksrc &= ~(S3C2443_CLKSRC_MSYSCLK_MPLL |
 230                     S3C2443_CLKSRC_EXTCLK_DIV);
 231
 232         if (parent == &clk_mpll)
 233                 clksrc |= S3C2443_CLKSRC_MSYSCLK_MPLL;
 234         else if (parent == &clk_mdivclk)
 235                 clksrc |= S3C2443_CLKSRC_EXTCLK_DIV;
 236         else if (parent != &clk_mpllref)
 237                 return -EINVAL;
 238
 239         __raw_writel(clksrc, S3C2443_CLKSRC);
 240         clk->parent = parent;
 241
 242         return 0;
 243 }
 244
 245 static struct clk clk_msysclk = {
 246         .name           = "msysclk",
 247         .parent         = &clk_xtal,
 248         .id             = -1,
 249         .set_parent     = s3c2443_setparent_msysclk,
 250 };
 251
 252
 253 /* esysclk
 254  *
 255  * this is sourced from either the EPLL or the EPLLref clock
 256 */
 257
 258 static int s3c2443_setparent_esysclk(struct clk *clk, struct clk *parent)
 259 {
 260         unsigned long clksrc = __raw_readl(S3C2443_CLKSRC);
 261
 262         if (parent == &clk_epll)
 263                 clksrc |= S3C2443_CLKSRC_ESYSCLK_EPLL;
 264         else if (parent == &clk_epllref)
 265                 clksrc &= ~S3C2443_CLKSRC_ESYSCLK_EPLL;
 266         else
 267                 return -EINVAL;
 268
 269         __raw_writel(clksrc, S3C2443_CLKSRC);
 270         clk->parent = parent;
 271
 272         return 0;
 273 }
 274
 275 static struct clk clk_esysclk = {
 276         .name           = "esysclk",
 277         .parent         = &clk_epll,
 278         .id             = -1,
 279         .set_parent     = s3c2443_setparent_esysclk,
 280 };
 281
 282 /* uartclk
 283  *
 284  * UART baud-rate clock sourced from esysclk via a divisor
 285 */
 286
 287 static unsigned long s3c2443_getrate_uart(struct clk *clk)
 288 {
 289         unsigned long parent_rate = clk_get_rate(clk->parent);
 290         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 291
 292         div &= S3C2443_CLKDIV1_UARTDIV_MASK;
 293         div >>= S3C2443_CLKDIV1_UARTDIV_SHIFT;
 294
 295         return parent_rate / (div + 1);
 296 }
 297
 298
 299 static int s3c2443_setrate_uart(struct clk *clk, unsigned long rate)
 300 {
 301         unsigned long parent_rate = clk_get_rate(clk->parent);
 302         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 303
 304         rate = s3c2443_roundrate_clksrc16(clk, rate);
 305         rate = parent_rate / rate;
 306
 307         clkdivn &= ~S3C2443_CLKDIV1_UARTDIV_MASK;
 308         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_UARTDIV_SHIFT;
 309
 310         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 311         return 0;
 312 }
 313
 314 static struct clk clk_uart = {
 315         .name           = "uartclk",
 316         .id             = -1,
 317         .parent         = &clk_esysclk,
 318         .get_rate       = s3c2443_getrate_uart,
 319         .set_rate       = s3c2443_setrate_uart,
 320         .round_rate     = s3c2443_roundrate_clksrc16,
 321 };
 322
 323 /* hsspi
 324  *
 325  * high-speed spi clock, sourced from esysclk
 326 */
 327
 328 static unsigned long s3c2443_getrate_hsspi(struct clk *clk)
 329 {
 330         unsigned long parent_rate = clk_get_rate(clk->parent);
 331         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 332
 333         div &= S3C2443_CLKDIV1_HSSPIDIV_MASK;
 334         div >>= S3C2443_CLKDIV1_HSSPIDIV_SHIFT;
 335
 336         return parent_rate / (div + 1);
 337 }
 338
 339
 340 static int s3c2443_setrate_hsspi(struct clk *clk, unsigned long rate)
 341 {
 342         unsigned long parent_rate = clk_get_rate(clk->parent);
 343         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 344
 345         rate = s3c2443_roundrate_clksrc4(clk, rate);
 346         rate = parent_rate / rate;
 347
 348         clkdivn &= ~S3C2443_CLKDIV1_HSSPIDIV_MASK;
 349         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_HSSPIDIV_SHIFT;
 350
 351         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 352         return 0;
 353 }
 354
 355 static struct clk clk_hsspi = {
 356         .name           = "hsspi",
 357         .id             = -1,
 358         .parent         = &clk_esysclk,
 359         .ctrlbit        = S3C2443_SCLKCON_HSSPICLK,
 360         .enable         = s3c2443_clkcon_enable_s,
 361         .get_rate       = s3c2443_getrate_hsspi,
 362         .set_rate       = s3c2443_setrate_hsspi,
 363         .round_rate     = s3c2443_roundrate_clksrc4,
 364 };
 365
 366 /* usbhost
 367  *
 368  * usb host bus-clock, usually 48MHz to provide USB bus clock timing
 369 */
 370
 371 static unsigned long s3c2443_getrate_usbhost(struct clk *clk)
 372 {
 373         unsigned long parent_rate = clk_get_rate(clk->parent);
 374         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 375
 376         div &= S3C2443_CLKDIV1_USBHOSTDIV_MASK;
 377         div >>= S3C2443_CLKDIV1_USBHOSTDIV_SHIFT;
 378
 379         return parent_rate / (div + 1);
 380 }
 381
 382 static int s3c2443_setrate_usbhost(struct clk *clk, unsigned long rate)
 383 {
 384         unsigned long parent_rate = clk_get_rate(clk->parent);
 385         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 386
 387         rate = s3c2443_roundrate_clksrc4(clk, rate);
 388         rate = parent_rate / rate;
 389
 390         clkdivn &= ~S3C2443_CLKDIV1_USBHOSTDIV_MASK;
 391         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_USBHOSTDIV_SHIFT;
 392
 393         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 394         return 0;
 395 }
 396
 397 struct clk clk_usb_bus_host = {
 398         .name           = "usb-bus-host-parent",
 399         .id             = -1,
 400         .parent         = &clk_esysclk,
 401         .ctrlbit        = S3C2443_SCLKCON_USBHOST,
 402         .enable         = s3c2443_clkcon_enable_s,
 403         .get_rate       = s3c2443_getrate_usbhost,
 404         .set_rate       = s3c2443_setrate_usbhost,
 405         .round_rate     = s3c2443_roundrate_clksrc4,
 406 };
 407
 408 /* clk_hsmcc_div
 409  *
 410  * this clock is sourced from epll, and is fed through a divider,
 411  * to a mux controlled by sclkcon where either it or a extclk can
 412  * be fed to the hsmmc block
 413 */
 414
 415 static unsigned long s3c2443_getrate_hsmmc_div(struct clk *clk)
 416 {
 417         unsigned long parent_rate = clk_get_rate(clk->parent);
 418         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 419
 420         div &= S3C2443_CLKDIV1_HSMMCDIV_MASK;
 421         div >>= S3C2443_CLKDIV1_HSMMCDIV_SHIFT;
 422
 423         return parent_rate / (div + 1);
 424 }
 425
 426 static int s3c2443_setrate_hsmmc_div(struct clk *clk, unsigned long rate)
 427 {
 428         unsigned long parent_rate = clk_get_rate(clk->parent);
 429         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 430
 431         rate = s3c2443_roundrate_clksrc4(clk, rate);
 432         rate = parent_rate / rate;
 433
 434         clkdivn &= ~S3C2443_CLKDIV1_HSMMCDIV_MASK;
 435         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_HSMMCDIV_SHIFT;
 436
 437         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 438         return 0;
 439 }
 440
 441 static struct clk clk_hsmmc_div = {
 442         .name           = "hsmmc-div",
 443         .id             = -1,
 444         .parent         = &clk_esysclk,
 445         .get_rate       = s3c2443_getrate_hsmmc_div,
 446         .set_rate       = s3c2443_setrate_hsmmc_div,
 447         .round_rate     = s3c2443_roundrate_clksrc4,
 448 };
 449
 450 static int s3c2443_setparent_hsmmc(struct clk *clk, struct clk *parent)
 451 {
 452         unsigned long clksrc = __raw_readl(S3C2443_SCLKCON);
 453
 454         clksrc &= ~(S3C2443_SCLKCON_HSMMCCLK_EXT |
 455                     S3C2443_SCLKCON_HSMMCCLK_EPLL);
 456
 457         if (parent == &clk_epll)
 458                 clksrc |= S3C2443_SCLKCON_HSMMCCLK_EPLL;
 459         else if (parent == &clk_ext)
 460                 clksrc |= S3C2443_SCLKCON_HSMMCCLK_EXT;
 461         else
 462                 return -EINVAL;
 463
 464         if (clk->usage > 0) {
 465                 __raw_writel(clksrc, S3C2443_SCLKCON);
 466         }
 467
 468         clk->parent = parent;
 469         return 0;
 470 }
 471
 472 static int s3c2443_enable_hsmmc(struct clk *clk, int enable)
 473 {
 474         return s3c2443_setparent_hsmmc(clk, clk->parent);
 475 }
 476
 477 static struct clk clk_hsmmc = {
 478         .name           = "hsmmc-if",
 479         .id             = -1,
 480         .parent         = &clk_hsmmc_div,
 481         .enable         = s3c2443_enable_hsmmc,
 482         .set_parent     = s3c2443_setparent_hsmmc,
 483 };
 484
 485 /* i2s_eplldiv
 486  *
 487  * this clock is the output from the i2s divisor of esysclk
 488 */
 489
 490 static unsigned long s3c2443_getrate_i2s_eplldiv(struct clk *clk)
 491 {
 492         unsigned long parent_rate = clk_get_rate(clk->parent);
 493         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 494
 495         div &= S3C2443_CLKDIV1_I2SDIV_MASK;
 496         div >>= S3C2443_CLKDIV1_I2SDIV_SHIFT;
 497
 498         return parent_rate / (div + 1);
 499 }
 500
 501 static int s3c2443_setrate_i2s_eplldiv(struct clk *clk, unsigned long rate)
 502 {
 503         unsigned long parent_rate = clk_get_rate(clk->parent);
 504         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 505
 506         rate = s3c2443_roundrate_clksrc16(clk, rate);
 507         rate = parent_rate / rate;
 508
 509         clkdivn &= ~S3C2443_CLKDIV1_I2SDIV_MASK;
 510         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_I2SDIV_SHIFT;
 511
 512         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 513         return 0;
 514 }
 515
 516 static struct clk clk_i2s_eplldiv = {
 517         .name           = "i2s-eplldiv",
 518         .id             = -1,
 519         .parent         = &clk_esysclk,
 520         .get_rate       = s3c2443_getrate_i2s_eplldiv,
 521         .set_rate       = s3c2443_setrate_i2s_eplldiv,
 522         .round_rate     = s3c2443_roundrate_clksrc16,
 523 };
 524
 525 /* i2s-ref
 526  *
 527  * i2s bus reference clock, selectable from external, esysclk or epllref
 528 */
 529
 530 static int s3c2443_setparent_i2s(struct clk *clk, struct clk *parent)
 531 {
 532         unsigned long clksrc = __raw_readl(S3C2443_CLKSRC);
 533
 534         clksrc &= ~S3C2443_CLKSRC_I2S_MASK;
 535
 536         if (parent == &clk_epllref)
 537                 clksrc |= S3C2443_CLKSRC_I2S_EPLLREF;
 538         else if (parent == &clk_i2s_ext)
 539                 clksrc |= S3C2443_CLKSRC_I2S_EXT;
 540         else if (parent != &clk_i2s_eplldiv)
 541                 return -EINVAL;
 542
 543         clk->parent = parent;
 544         __raw_writel(clksrc, S3C2443_CLKSRC);
 545
 546         return 0;
 547 }
 548
 549 static struct clk clk_i2s = {
 550         .name           = "i2s-if",
 551         .id             = -1,
 552         .parent         = &clk_i2s_eplldiv,
 553         .ctrlbit        = S3C2443_SCLKCON_I2SCLK,
 554         .enable         = s3c2443_clkcon_enable_s,
 555         .set_parent     = s3c2443_setparent_i2s,
 556 };
 557
 558 /* cam-if
 559  *
 560  * camera interface bus-clock, divided down from esysclk
 561 */
 562
 563 static unsigned long s3c2443_getrate_cam(struct clk *clk)
 564 {
 565         unsigned long parent_rate = clk_get_rate(clk->parent);
 566         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 567
 568         div  &= S3C2443_CLKDIV1_CAMDIV_MASK;
 569         div >>= S3C2443_CLKDIV1_CAMDIV_SHIFT;
 570
 571         return parent_rate / (div + 1);
 572 }
 573
 574 static int s3c2443_setrate_cam(struct clk *clk, unsigned long rate)
 575 {
 576         unsigned long parent_rate = clk_get_rate(clk->parent);
 577         unsigned long clkdiv1 = __raw_readl(S3C2443_CLKDIV1);
 578
 579         rate = s3c2443_roundrate_clksrc16(clk, rate);
 580         rate = parent_rate / rate;
 581
 582         clkdiv1 &= ~S3C2443_CLKDIV1_CAMDIV_MASK;
 583         clkdiv1 |= (rate - 1) << S3C2443_CLKDIV1_CAMDIV_SHIFT;
 584
 585         __raw_writel(clkdiv1, S3C2443_CLKDIV1);
 586         return 0;
 587 }
 588
 589 static struct clk clk_cam = {
 590         .name           = "camif-upll",         /* same as 2440 name */
 591         .id             = -1,
 592         .parent         = &clk_esysclk,
 593         .ctrlbit        = S3C2443_SCLKCON_CAMCLK,
 594         .enable         = s3c2443_clkcon_enable_s,
 595         .get_rate       = s3c2443_getrate_cam,
 596         .set_rate       = s3c2443_setrate_cam,
 597         .round_rate     = s3c2443_roundrate_clksrc16,
 598 };
 599
 600 /* display-if
 601  *
 602  * display interface clock, divided from esysclk
 603 */
 604
 605 static unsigned long s3c2443_getrate_display(struct clk *clk)
 606 {
 607         unsigned long parent_rate = clk_get_rate(clk->parent);
 608         unsigned long div = __raw_readl(S3C2443_CLKDIV1);
 609
 610         div &= S3C2443_CLKDIV1_DISPDIV_MASK;
 611         div >>= S3C2443_CLKDIV1_DISPDIV_SHIFT;
 612
 613         return parent_rate / (div + 1);
 614 }
 615
 616 static int s3c2443_setrate_display(struct clk *clk, unsigned long rate)
 617 {
 618         unsigned long parent_rate = clk_get_rate(clk->parent);
 619         unsigned long clkdivn = __raw_readl(S3C2443_CLKDIV1);
 620
 621         rate = s3c2443_roundrate_clksrc256(clk, rate);
 622         rate = parent_rate / rate;
 623
 624         clkdivn &= ~S3C2443_CLKDIV1_UARTDIV_MASK;
 625         clkdivn |= (rate - 1) << S3C2443_CLKDIV1_UARTDIV_SHIFT;
 626
 627         __raw_writel(clkdivn, S3C2443_CLKDIV1);
 628         return 0;
 629 }
 630
 631 static struct clk clk_display = {
 632         .name           = "display-if",
 633         .id             = -1,
 634         .parent         = &clk_esysclk,
 635         .ctrlbit        = S3C2443_SCLKCON_DISPCLK,
 636         .enable         = s3c2443_clkcon_enable_s,
 637         .get_rate       = s3c2443_getrate_display,
 638         .set_rate       = s3c2443_setrate_display,
 639         .round_rate     = s3c2443_roundrate_clksrc256,
 640 };
 641
 642 /* standard clock definitions */
 643
 644 static struct clk init_clocks_disable[] = {
 645         {
 646                 .name           = "nand",
 647                 .id             = -1,
 648                 .parent         = &clk_h,
 649         }, {
 650                 .name           = "sdi",
 651                 .id             = -1,
 652                 .parent         = &clk_p,
 653                 .enable         = s3c2443_clkcon_enable_p,
 654                 .ctrlbit        = S3C2443_PCLKCON_SDI,
 655         }, {
 656                 .name           = "adc",
 657                 .id             = -1,
 658                 .parent         = &clk_p,
 659                 .enable         = s3c2443_clkcon_enable_p,
 660                 .ctrlbit        = S3C2443_PCLKCON_ADC,
 661         }, {
 662                 .name           = "i2c",
 663                 .id             = -1,
 664                 .parent         = &clk_p,
 665                 .enable         = s3c2443_clkcon_enable_p,
 666                 .ctrlbit        = S3C2443_PCLKCON_IIC,
 667         }, {
 668                 .name           = "iis",
 669                 .id             = -1,
 670                 .parent         = &clk_p,
 671                 .enable         = s3c2443_clkcon_enable_p,
 672                 .ctrlbit        = S3C2443_PCLKCON_IIS,
 673         }, {
 674                 .name           = "spi",
 675                 .id             = 0,
 676                 .parent         = &clk_p,
 677                 .enable         = s3c2443_clkcon_enable_p,
 678                 .ctrlbit        = S3C2443_PCLKCON_SPI0,
 679         }, {
 680                 .name           = "spi",
 681                 .id             = 1,
 682                 .parent         = &clk_p,
 683                 .enable         = s3c2443_clkcon_enable_p,
 684                 .ctrlbit        = S3C2443_PCLKCON_SPI1,
 685         }
 686 };
 687
 688 static struct clk init_clocks[] = {
 689         {
 690                 .name           = "dma",
 691                 .id             = 0,
 692                 .parent         = &clk_h,
 693                 .enable         = s3c2443_clkcon_enable_h,
 694                 .ctrlbit        = S3C2443_HCLKCON_DMA0,
 695         }, {
 696                 .name           = "dma",
 697                 .id             = 1,
 698                 .parent         = &clk_h,
 699                 .enable         = s3c2443_clkcon_enable_h,
 700                 .ctrlbit        = S3C2443_HCLKCON_DMA1,
 701         }, {
 702                 .name           = "dma",
 703                 .id             = 2,
 704                 .parent         = &clk_h,
 705                 .enable         = s3c2443_clkcon_enable_h,
 706                 .ctrlbit        = S3C2443_HCLKCON_DMA2,
 707         }, {
 708                 .name           = "dma",
 709                 .id             = 3,
 710                 .parent         = &clk_h,
 711                 .enable         = s3c2443_clkcon_enable_h,
 712                 .ctrlbit        = S3C2443_HCLKCON_DMA3,
 713         }, {
 714                 .name           = "dma",
 715                 .id             = 4,
 716                 .parent         = &clk_h,
 717                 .enable         = s3c2443_clkcon_enable_h,
 718                 .ctrlbit        = S3C2443_HCLKCON_DMA4,
 719         }, {
 720                 .name           = "dma",
 721                 .id             = 5,
 722                 .parent         = &clk_h,
 723                 .enable         = s3c2443_clkcon_enable_h,
 724                 .ctrlbit        = S3C2443_HCLKCON_DMA5,
 725         }, {
 726                 .name           = "lcd",
 727                 .id             = -1,
 728                 .parent         = &clk_h,
 729                 .enable         = s3c2443_clkcon_enable_h,
 730                 .ctrlbit        = S3C2443_HCLKCON_LCDC,
 731         }, {
 732                 .name           = "gpio",
 733                 .id             = -1,
 734                 .parent         = &clk_p,
 735                 .enable         = s3c2443_clkcon_enable_p,
 736                 .ctrlbit        = S3C2443_PCLKCON_GPIO,
 737         }, {
 738                 .name           = "usb-host",
 739                 .id             = -1,
 740                 .parent         = &clk_h,
 741                 .enable         = s3c2443_clkcon_enable_h,
 742                 .ctrlbit        = S3C2443_HCLKCON_USBH,
 743         }, {
 744                 .name           = "usb-device",
 745                 .id             = -1,
 746                 .parent         = &clk_h,
 747                 .enable         = s3c2443_clkcon_enable_h,
 748                 .ctrlbit        = S3C2443_HCLKCON_USBD,
 749         }, {
 750                 .name           = "timers",
 751                 .id             = -1,
 752                 .parent         = &clk_p,
 753                 .enable         = s3c2443_clkcon_enable_p,
 754                 .ctrlbit        = S3C2443_PCLKCON_PWMT,
 755         }, {
 756                 .name           = "uart",
 757                 .id             = 0,
 758                 .parent         = &clk_p,
 759                 .enable         = s3c2443_clkcon_enable_p,
 760                 .ctrlbit        = S3C2443_PCLKCON_UART0,
 761         }, {
 762                 .name           = "uart",
 763                 .id             = 1,
 764                 .parent         = &clk_p,
 765                 .enable         = s3c2443_clkcon_enable_p,
 766                 .ctrlbit        = S3C2443_PCLKCON_UART1,
 767         }, {
 768                 .name           = "uart",
 769                 .id             = 2,
 770                 .parent         = &clk_p,
 771                 .enable         = s3c2443_clkcon_enable_p,
 772                 .ctrlbit        = S3C2443_PCLKCON_UART2,
 773         }, {
 774                 .name           = "uart",
 775                 .id             = 3,
 776                 .parent         = &clk_p,
 777                 .enable         = s3c2443_clkcon_enable_p,
 778                 .ctrlbit        = S3C2443_PCLKCON_UART3,
 779         }, {
 780                 .name           = "rtc",
 781                 .id             = -1,
 782                 .parent         = &clk_p,
 783                 .enable         = s3c2443_clkcon_enable_p,
 784                 .ctrlbit        = S3C2443_PCLKCON_RTC,
 785         }, {
 786                 .name           = "watchdog",
 787                 .id             = -1,
 788                 .parent         = &clk_p,
 789                 .ctrlbit        = S3C2443_PCLKCON_WDT,
 790         }, {
 791                 .name           = "usb-bus-host",
 792                 .id             = -1,
 793                 .parent         = &clk_usb_bus_host,
 794         }
 795 };
 796
 797 /* clocks to add where we need to check their parentage */
 798
 799 /* s3c2443_clk_initparents
 800  *
 801  * Initialise the parents for the clocks that we get at start-time
 802 */
 803
 804 static int __init clk_init_set_parent(struct clk *clk, struct clk *parent)
 805 {
 806         printk(KERN_DEBUG "clock %s: parent %s\n", clk->name, parent->name);
 807         return clk_set_parent(clk, parent);
 808 }
 809
 810 static void __init s3c2443_clk_initparents(void)
 811 {
 812         unsigned long clksrc = __raw_readl(S3C2443_CLKSRC);
 813         struct clk *parent;
 814
 815         switch (clksrc & S3C2443_CLKSRC_EPLLREF_MASK) {
 816         case S3C2443_CLKSRC_EPLLREF_EXTCLK:
 817                 parent = &clk_ext;
 818                 break;
 819
 820         case S3C2443_CLKSRC_EPLLREF_XTAL:
 821         default:
 822                 parent = &clk_xtal;
 823                 break;
 824
 825         case S3C2443_CLKSRC_EPLLREF_MPLLREF:
 826         case S3C2443_CLKSRC_EPLLREF_MPLLREF2:
 827                 parent = &clk_mpllref;
 828                 break;
 829         }
 830
 831         clk_init_set_parent(&clk_epllref, parent);
 832
 833         switch (clksrc & S3C2443_CLKSRC_I2S_MASK) {
 834         case S3C2443_CLKSRC_I2S_EXT:
 835                 parent = &clk_i2s_ext;
 836                 break;
 837
 838         case S3C2443_CLKSRC_I2S_EPLLDIV:
 839         default:
 840                 parent = &clk_i2s_eplldiv;
 841                 break;
 842
 843         case S3C2443_CLKSRC_I2S_EPLLREF:
 844         case S3C2443_CLKSRC_I2S_EPLLREF3:
 845                 parent = &clk_epllref;
 846         }
 847
 848         clk_init_set_parent(&clk_i2s, &clk_epllref);
 849
 850         /* esysclk source */
 851
 852         parent = (clksrc & S3C2443_CLKSRC_ESYSCLK_EPLL) ?
 853                 &clk_epll : &clk_epllref;
 854
 855         clk_init_set_parent(&clk_esysclk, parent);
 856
 857         /* msysclk source */
 858
 859         if (clksrc & S3C2443_CLKSRC_MSYSCLK_MPLL) {
 860                 parent = &clk_mpll;
 861         } else {
 862                 parent = (clksrc & S3C2443_CLKSRC_EXTCLK_DIV) ?
 863                         &clk_mdivclk : &clk_mpllref;
 864         }
 865
 866         clk_init_set_parent(&clk_msysclk, parent);
 867 }
 868
 869 /* armdiv divisor table */
 870
 871 static unsigned int armdiv[16] = {
 872         [S3C2443_CLKDIV0_ARMDIV_1 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 1,
 873         [S3C2443_CLKDIV0_ARMDIV_2 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 2,
 874         [S3C2443_CLKDIV0_ARMDIV_3 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 3,
 875         [S3C2443_CLKDIV0_ARMDIV_4 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 4,
 876         [S3C2443_CLKDIV0_ARMDIV_6 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 6,
 877         [S3C2443_CLKDIV0_ARMDIV_8 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]      = 8,
 878         [S3C2443_CLKDIV0_ARMDIV_12 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]     = 12,
 879         [S3C2443_CLKDIV0_ARMDIV_16 >> S3C2443_CLKDIV0_ARMDIV_SHIFT]     = 16,
 880 };
 881
 882 static inline unsigned int s3c2443_fclk_div(unsigned long clkcon0)
 883 {
 884         clkcon0 &= S3C2443_CLKDIV0_ARMDIV_MASK;
 885
 886         return armdiv[clkcon0 >> S3C2443_CLKDIV0_ARMDIV_SHIFT];
 887 }
 888
 889 static inline unsigned long s3c2443_get_prediv(unsigned long clkcon0)
 890 {
 891         clkcon0 &= S3C2443_CLKDIV0_PREDIV_MASK;
 892         clkcon0 >>= S3C2443_CLKDIV0_PREDIV_SHIFT;
 893
 894         return clkcon0 + 1;
 895 }
 896
 897 /* clocks to add straight away */
 898
 899 static struct clk *clks[] __initdata = {
 900         &clk_ext,
 901         &clk_epll,
 902         &clk_usb_bus_host,
 903         &clk_usb_bus,
 904         &clk_esysclk,
 905         &clk_epllref,
 906         &clk_mpllref,
 907         &clk_msysclk,
 908         &clk_uart,
 909         &clk_display,
 910         &clk_cam,
 911         &clk_i2s_eplldiv,
 912         &clk_i2s,
 913         &clk_hsspi,
 914         &clk_hsmmc_div,
 915         &clk_hsmmc,
 916 };
 917
 918 void __init s3c2443_init_clocks(int xtal)
 919 {
 920         unsigned long epllcon = __raw_readl(S3C2443_EPLLCON);
 921         unsigned long mpllcon = __raw_readl(S3C2443_MPLLCON);
 922         unsigned long clkdiv0 = __raw_readl(S3C2443_CLKDIV0);
 923         unsigned long pll;
 924         unsigned long fclk;
 925         unsigned long hclk;
 926         unsigned long pclk;
 927         struct clk *clkp;
 928         int ret;
 929         int ptr;
 930
 931         pll = s3c2443_get_mpll(mpllcon, xtal);
 932
 933         fclk = pll / s3c2443_fclk_div(clkdiv0);
 934         hclk = fclk / s3c2443_get_prediv(clkdiv0);
 935         hclk = hclk / ((clkdiv0 & S3C2443_CLKDIV0_HALF_HCLK) ? 2 : 1);
 936         pclk = hclk / ((clkdiv0 & S3C2443_CLKDIV0_HALF_PCLK) ? 2 : 1);
 937
 938         s3c24xx_setup_clocks(xtal, fclk, hclk, pclk);
 939
 940         printk("S3C2443: mpll %s %ld.%03ld MHz, cpu %ld.%03ld MHz, mem %ld.%03ld MHz, pclk %ld.%03ld MHz\n",
 941                (mpllcon & S3C2443_PLLCON_OFF) ? "off":"on",
 942                print_mhz(pll), print_mhz(fclk),
 943                print_mhz(hclk), print_mhz(pclk));
 944
 945         s3c2443_clk_initparents();
 946
 947         for (ptr = 0; ptr < ARRAY_SIZE(clks); ptr++) {
 948                 clkp = clks[ptr];
 949
 950                 ret = s3c24xx_register_clock(clkp);
 951                 if (ret < 0) {
 952                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
 953                                clkp->name, ret);
 954                 }
 955         }
 956
 957         clk_epll.rate = s3c2443_get_epll(epllcon, xtal);
 958
 959         clk_usb_bus.parent = &clk_usb_bus_host;
 960
 961         /* ensure usb bus clock is within correct rate of 48MHz */
 962
 963         if (clk_get_rate(&clk_usb_bus_host) != (48 * 1000 * 1000)) {
 964                 printk(KERN_INFO "Warning: USB host bus not at 48MHz\n");
 965                 clk_set_rate(&clk_usb_bus_host, 48*1000*1000);
 966         }
 967
 968         printk("S3C2443: epll %s %ld.%03ld MHz, usb-bus %ld.%03ld MHz\n",
 969                (epllcon & S3C2443_PLLCON_OFF) ? "off":"on",
 970                print_mhz(clk_get_rate(&clk_epll)),
 971                print_mhz(clk_get_rate(&clk_usb_bus)));
 972
 973         /* register clocks from clock array */
 974
 975         clkp = init_clocks;
 976         for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {
 977                 ret = s3c24xx_register_clock(clkp);
 978                 if (ret < 0) {
 979                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
 980                                clkp->name, ret);
 981                 }
 982         }
 983
 984         /* We must be careful disabling the clocks we are not intending to
 985          * be using at boot time, as subsytems such as the LCD which do
 986          * their own DMA requests to the bus can cause the system to lockup
 987          * if they where in the middle of requesting bus access.
 988          *
 989          * Disabling the LCD clock if the LCD is active is very dangerous,
 990          * and therefore the bootloader should be careful to not enable
 991          * the LCD clock if it is not needed.
 992         */
 993
 994         /* install (and disable) the clocks we do not need immediately */
 995
 996         clkp = init_clocks_disable;
 997         for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) {
 998
 999                 ret = s3c24xx_register_clock(clkp);
1000                 if (ret < 0) {
1001                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
1002                                clkp->name, ret);
1003                 }
1004
1005                 (clkp->enable)(clkp, 0);
1006         }
1007 }