arch/arm/mach-at91/clock.c

   1 /*
   2  * linux/arch/arm/mach-at91/clock.c
   3  *
   4  * Copyright (C) 2005 David Brownell
   5  * Copyright (C) 2005 Ivan Kokshaysky
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/fs.h>
  17 #include <linux/debugfs.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/list.h>
  20 #include <linux/errno.h>
  21 #include <linux/err.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/delay.h>
  24 #include <linux/clk.h>
  25 #include <linux/io.h>
  26 #include <linux/of_address.h>
  27
  28 #include <mach/hardware.h>
  29 #include <mach/at91_pmc.h>
  30 #include <mach/cpu.h>
  31
  32 #include <asm/proc-fns.h>
  33
  34 #include "clock.h"
  35 #include "generic.h"
  36
  37 void __iomem *at91_pmc_base;
  38 EXPORT_SYMBOL_GPL(at91_pmc_base);
  39
  40 /*
  41  * There's a lot more which can be done with clocks, including cpufreq
  42  * integration, slow clock mode support (for system suspend), letting
  43  * PLLB be used at other rates (on boards that don't need USB), etc.
  44  */
  45
  46 #define clk_is_primary(x)       ((x)->type & CLK_TYPE_PRIMARY)
  47 #define clk_is_programmable(x)  ((x)->type & CLK_TYPE_PROGRAMMABLE)
  48 #define clk_is_peripheral(x)    ((x)->type & CLK_TYPE_PERIPHERAL)
  49 #define clk_is_sys(x)           ((x)->type & CLK_TYPE_SYSTEM)
  50
  51
  52 /*
  53  * Chips have some kind of clocks : group them by functionality
  54  */
  55 #define cpu_has_utmi()          (  cpu_is_at91sam9rl() \
  56                                 || cpu_is_at91sam9g45() \
  57                                 || cpu_is_at91sam9x5())
  58
  59 #define cpu_has_800M_plla()     (  cpu_is_at91sam9g20() \
  60                                 || cpu_is_at91sam9g45() \
  61                                 || cpu_is_at91sam9x5())
  62
  63 #define cpu_has_300M_plla()     (cpu_is_at91sam9g10())
  64
  65 #define cpu_has_pllb()          (!(cpu_is_at91sam9rl() \
  66                                 || cpu_is_at91sam9g45() \
  67                                 || cpu_is_at91sam9x5()))
  68
  69 #define cpu_has_upll()          (cpu_is_at91sam9g45() \
  70                                 || cpu_is_at91sam9x5())
  71
  72 /* USB host HS & FS */
  73 #define cpu_has_uhp()           (!cpu_is_at91sam9rl())
  74
  75 /* USB device FS only */
  76 #define cpu_has_udpfs()         (!(cpu_is_at91sam9rl() \
  77                                 || cpu_is_at91sam9g45() \
  78                                 || cpu_is_at91sam9x5()))
  79
  80 #define cpu_has_plladiv2()      (cpu_is_at91sam9g45() \
  81                                 || cpu_is_at91sam9x5())
  82
  83 #define cpu_has_mdiv3()         (cpu_is_at91sam9g45() \
  84                                 || cpu_is_at91sam9x5())
  85
  86 #define cpu_has_alt_prescaler() (cpu_is_at91sam9x5())
  87
  88 static LIST_HEAD(clocks);
  89 static DEFINE_SPINLOCK(clk_lock);
  90
  91 static u32 at91_pllb_usb_init;
  92
  93 /*
  94  * Four primary clock sources:  two crystal oscillators (32K, main), and
  95  * two PLLs.  PLLA usually runs the master clock; and PLLB must run at
  96  * 48 MHz (unless no USB function clocks are needed).  The main clock and
  97  * both PLLs are turned off to run in "slow clock mode" (system suspend).
  98  */
  99 static struct clk clk32k = {
 100         .name           = "clk32k",
 101         .rate_hz        = AT91_SLOW_CLOCK,
 102         .users          = 1,            /* always on */
 103         .id             = 0,
 104         .type           = CLK_TYPE_PRIMARY,
 105 };
 106 static struct clk main_clk = {
 107         .name           = "main",
 108         .pmc_mask       = AT91_PMC_MOSCS,       /* in PMC_SR */
 109         .id             = 1,
 110         .type           = CLK_TYPE_PRIMARY,
 111 };
 112 static struct clk plla = {
 113         .name           = "plla",
 114         .parent         = &main_clk,
 115         .pmc_mask       = AT91_PMC_LOCKA,       /* in PMC_SR */
 116         .id             = 2,
 117         .type           = CLK_TYPE_PRIMARY | CLK_TYPE_PLL,
 118 };
 119
 120 static void pllb_mode(struct clk *clk, int is_on)
 121 {
 122         u32     value;
 123
 124         if (is_on) {
 125                 is_on = AT91_PMC_LOCKB;
 126                 value = at91_pllb_usb_init;
 127         } else
 128                 value = 0;
 129
 130         // REVISIT: Add work-around for AT91RM9200 Errata #26 ?
 131         at91_pmc_write(AT91_CKGR_PLLBR, value);
 132
 133         do {
 134                 cpu_relax();
 135         } while ((at91_pmc_read(AT91_PMC_SR) & AT91_PMC_LOCKB) != is_on);
 136 }
 137
 138 static struct clk pllb = {
 139         .name           = "pllb",
 140         .parent         = &main_clk,
 141         .pmc_mask       = AT91_PMC_LOCKB,       /* in PMC_SR */
 142         .mode           = pllb_mode,
 143         .id             = 3,
 144         .type           = CLK_TYPE_PRIMARY | CLK_TYPE_PLL,
 145 };
 146
 147 static void pmc_sys_mode(struct clk *clk, int is_on)
 148 {
 149         if (is_on)
 150                 at91_pmc_write(AT91_PMC_SCER, clk->pmc_mask);
 151         else
 152                 at91_pmc_write(AT91_PMC_SCDR, clk->pmc_mask);
 153 }
 154
 155 static void pmc_uckr_mode(struct clk *clk, int is_on)
 156 {
 157         unsigned int uckr = at91_pmc_read(AT91_CKGR_UCKR);
 158
 159         if (is_on) {
 160                 is_on = AT91_PMC_LOCKU;
 161                 at91_pmc_write(AT91_CKGR_UCKR, uckr | clk->pmc_mask);
 162         } else
 163                 at91_pmc_write(AT91_CKGR_UCKR, uckr & ~(clk->pmc_mask));
 164
 165         do {
 166                 cpu_relax();
 167         } while ((at91_pmc_read(AT91_PMC_SR) & AT91_PMC_LOCKU) != is_on);
 168 }
 169
 170 /* USB function clocks (PLLB must be 48 MHz) */
 171 static struct clk udpck = {
 172         .name           = "udpck",
 173         .parent         = &pllb,
 174         .mode           = pmc_sys_mode,
 175 };
 176 struct clk utmi_clk = {
 177         .name           = "utmi_clk",
 178         .parent         = &main_clk,
 179         .pmc_mask       = AT91_PMC_UPLLEN,      /* in CKGR_UCKR */
 180         .mode           = pmc_uckr_mode,
 181         .type           = CLK_TYPE_PLL,
 182 };
 183 static struct clk uhpck = {
 184         .name           = "uhpck",
 185         /*.parent               = ... we choose parent at runtime */
 186         .mode           = pmc_sys_mode,
 187 };
 188
 189
 190 /*
 191  * The master clock is divided from the CPU clock (by 1-4).  It's used for
 192  * memory, interfaces to on-chip peripherals, the AIC, and sometimes more
 193  * (e.g baud rate generation).  It's sourced from one of the primary clocks.
 194  */
 195 struct clk mck = {
 196         .name           = "mck",
 197         .pmc_mask       = AT91_PMC_MCKRDY,      /* in PMC_SR */
 198 };
 199
 200 static void pmc_periph_mode(struct clk *clk, int is_on)
 201 {
 202         if (is_on)
 203                 at91_pmc_write(AT91_PMC_PCER, clk->pmc_mask);
 204         else
 205                 at91_pmc_write(AT91_PMC_PCDR, clk->pmc_mask);
 206 }
 207
 208 static struct clk __init *at91_css_to_clk(unsigned long css)
 209 {
 210         switch (css) {
 211                 case AT91_PMC_CSS_SLOW:
 212                         return &clk32k;
 213                 case AT91_PMC_CSS_MAIN:
 214                         return &main_clk;
 215                 case AT91_PMC_CSS_PLLA:
 216                         return &plla;
 217                 case AT91_PMC_CSS_PLLB:
 218                         if (cpu_has_upll())
 219                                 /* CSS_PLLB == CSS_UPLL */
 220                                 return &utmi_clk;
 221                         else if (cpu_has_pllb())
 222                                 return &pllb;
 223                         break;
 224                 /* alternate PMC: can use master clock */
 225                 case AT91_PMC_CSS_MASTER:
 226                         return &mck;
 227         }
 228
 229         return NULL;
 230 }
 231
 232 static int pmc_prescaler_divider(u32 reg)
 233 {
 234         if (cpu_has_alt_prescaler()) {
 235                 return 1 << ((reg & AT91_PMC_ALT_PRES) >> PMC_ALT_PRES_OFFSET);
 236         } else {
 237                 return 1 << ((reg & AT91_PMC_PRES) >> PMC_PRES_OFFSET);
 238         }
 239 }
 240
 241 static void __clk_enable(struct clk *clk)
 242 {
 243         if (clk->parent)
 244                 __clk_enable(clk->parent);
 245         if (clk->users++ == 0 && clk->mode)
 246                 clk->mode(clk, 1);
 247 }
 248
 249 int clk_enable(struct clk *clk)
 250 {
 251         unsigned long   flags;
 252
 253         spin_lock_irqsave(&clk_lock, flags);
 254         __clk_enable(clk);
 255         spin_unlock_irqrestore(&clk_lock, flags);
 256         return 0;
 257 }
 258 EXPORT_SYMBOL(clk_enable);
 259
 260 static void __clk_disable(struct clk *clk)
 261 {
 262         BUG_ON(clk->users == 0);
 263         if (--clk->users == 0 && clk->mode)
 264                 clk->mode(clk, 0);
 265         if (clk->parent)
 266                 __clk_disable(clk->parent);
 267 }
 268
 269 void clk_disable(struct clk *clk)
 270 {
 271         unsigned long   flags;
 272
 273         spin_lock_irqsave(&clk_lock, flags);
 274         __clk_disable(clk);
 275         spin_unlock_irqrestore(&clk_lock, flags);
 276 }
 277 EXPORT_SYMBOL(clk_disable);
 278
 279 unsigned long clk_get_rate(struct clk *clk)
 280 {
 281         unsigned long   flags;
 282         unsigned long   rate;
 283
 284         spin_lock_irqsave(&clk_lock, flags);
 285         for (;;) {
 286                 rate = clk->rate_hz;
 287                 if (rate || !clk->parent)
 288                         break;
 289                 clk = clk->parent;
 290         }
 291         spin_unlock_irqrestore(&clk_lock, flags);
 292         return rate;
 293 }
 294 EXPORT_SYMBOL(clk_get_rate);
 295
 296 /*------------------------------------------------------------------------*/
 297
 298 #ifdef CONFIG_AT91_PROGRAMMABLE_CLOCKS
 299
 300 /*
 301  * For now, only the programmable clocks support reparenting (MCK could
 302  * do this too, with care) or rate changing (the PLLs could do this too,
 303  * ditto MCK but that's more for cpufreq).  Drivers may reparent to get
 304  * a better rate match; we don't.
 305  */
 306
 307 long clk_round_rate(struct clk *clk, unsigned long rate)
 308 {
 309         unsigned long   flags;
 310         unsigned        prescale;
 311         unsigned long   actual;
 312         unsigned long   prev = ULONG_MAX;
 313
 314         if (!clk_is_programmable(clk))
 315                 return -EINVAL;
 316         spin_lock_irqsave(&clk_lock, flags);
 317
 318         actual = clk->parent->rate_hz;
 319         for (prescale = 0; prescale < 7; prescale++) {
 320                 if (actual > rate)
 321                         prev = actual;
 322
 323                 if (actual && actual <= rate) {
 324                         if ((prev - rate) < (rate - actual)) {
 325                                 actual = prev;
 326                                 prescale--;
 327                         }
 328                         break;
 329                 }
 330                 actual >>= 1;
 331         }
 332
 333         spin_unlock_irqrestore(&clk_lock, flags);
 334         return (prescale < 7) ? actual : -ENOENT;
 335 }
 336 EXPORT_SYMBOL(clk_round_rate);
 337
 338 int clk_set_rate(struct clk *clk, unsigned long rate)
 339 {
 340         unsigned long   flags;
 341         unsigned        prescale;
 342         unsigned long   prescale_offset, css_mask;
 343         unsigned long   actual;
 344
 345         if (!clk_is_programmable(clk))
 346                 return -EINVAL;
 347         if (clk->users)
 348                 return -EBUSY;
 349
 350         if (cpu_has_alt_prescaler()) {
 351                 prescale_offset = PMC_ALT_PRES_OFFSET;
 352                 css_mask = AT91_PMC_ALT_PCKR_CSS;
 353         } else {
 354                 prescale_offset = PMC_PRES_OFFSET;
 355                 css_mask = AT91_PMC_CSS;
 356         }
 357
 358         spin_lock_irqsave(&clk_lock, flags);
 359
 360         actual = clk->parent->rate_hz;
 361         for (prescale = 0; prescale < 7; prescale++) {
 362                 if (actual && actual <= rate) {
 363                         u32     pckr;
 364
 365                         pckr = at91_pmc_read(AT91_PMC_PCKR(clk->id));
 366                         pckr &= css_mask;       /* keep clock selection */
 367                         pckr |= prescale << prescale_offset;
 368                         at91_pmc_write(AT91_PMC_PCKR(clk->id), pckr);
 369                         clk->rate_hz = actual;
 370                         break;
 371                 }
 372                 actual >>= 1;
 373         }
 374
 375         spin_unlock_irqrestore(&clk_lock, flags);
 376         return (prescale < 7) ? actual : -ENOENT;
 377 }
 378 EXPORT_SYMBOL(clk_set_rate);
 379
 380 struct clk *clk_get_parent(struct clk *clk)
 381 {
 382         return clk->parent;
 383 }
 384 EXPORT_SYMBOL(clk_get_parent);
 385
 386 int clk_set_parent(struct clk *clk, struct clk *parent)
 387 {
 388         unsigned long   flags;
 389
 390         if (clk->users)
 391                 return -EBUSY;
 392         if (!clk_is_primary(parent) || !clk_is_programmable(clk))
 393                 return -EINVAL;
 394
 395         if (cpu_is_at91sam9rl() && parent->id == AT91_PMC_CSS_PLLB)
 396                 return -EINVAL;
 397
 398         spin_lock_irqsave(&clk_lock, flags);
 399
 400         clk->rate_hz = parent->rate_hz;
 401         clk->parent = parent;
 402         at91_pmc_write(AT91_PMC_PCKR(clk->id), parent->id);
 403
 404         spin_unlock_irqrestore(&clk_lock, flags);
 405         return 0;
 406 }
 407 EXPORT_SYMBOL(clk_set_parent);
 408
 409 /* establish PCK0..PCKN parentage and rate */
 410 static void __init init_programmable_clock(struct clk *clk)
 411 {
 412         struct clk      *parent;
 413         u32             pckr;
 414         unsigned int    css_mask;
 415
 416         if (cpu_has_alt_prescaler())
 417                 css_mask = AT91_PMC_ALT_PCKR_CSS;
 418         else
 419                 css_mask = AT91_PMC_CSS;
 420
 421         pckr = at91_pmc_read(AT91_PMC_PCKR(clk->id));
 422         parent = at91_css_to_clk(pckr & css_mask);
 423         clk->parent = parent;
 424         clk->rate_hz = parent->rate_hz / pmc_prescaler_divider(pckr);
 425 }
 426
 427 #endif  /* CONFIG_AT91_PROGRAMMABLE_CLOCKS */
 428
 429 /*------------------------------------------------------------------------*/
 430
 431 #ifdef CONFIG_DEBUG_FS
 432
 433 static int at91_clk_show(struct seq_file *s, void *unused)
 434 {
 435         u32             scsr, pcsr, uckr = 0, sr;
 436         struct clk      *clk;
 437
 438         scsr = at91_pmc_read(AT91_PMC_SCSR);
 439         pcsr = at91_pmc_read(AT91_PMC_PCSR);
 440         sr = at91_pmc_read(AT91_PMC_SR);
 441         seq_printf(s, "SCSR = %8x\n", scsr);
 442         seq_printf(s, "PCSR = %8x\n", pcsr);
 443         seq_printf(s, "MOR  = %8x\n", at91_pmc_read(AT91_CKGR_MOR));
 444         seq_printf(s, "MCFR = %8x\n", at91_pmc_read(AT91_CKGR_MCFR));
 445         seq_printf(s, "PLLA = %8x\n", at91_pmc_read(AT91_CKGR_PLLAR));
 446         if (cpu_has_pllb())
 447                 seq_printf(s, "PLLB = %8x\n", at91_pmc_read(AT91_CKGR_PLLBR));
 448         if (cpu_has_utmi()) {
 449                 uckr = at91_pmc_read(AT91_CKGR_UCKR);
 450                 seq_printf(s, "UCKR = %8x\n", uckr);
 451         }
 452         seq_printf(s, "MCKR = %8x\n", at91_pmc_read(AT91_PMC_MCKR));
 453         if (cpu_has_upll())
 454                 seq_printf(s, "USB  = %8x\n", at91_pmc_read(AT91_PMC_USB));
 455         seq_printf(s, "SR   = %8x\n", sr);
 456
 457         seq_printf(s, "\n");
 458
 459         list_for_each_entry(clk, &clocks, node) {
 460                 char    *state;
 461
 462                 if (clk->mode == pmc_sys_mode)
 463                         state = (scsr & clk->pmc_mask) ? "on" : "off";
 464                 else if (clk->mode == pmc_periph_mode)
 465                         state = (pcsr & clk->pmc_mask) ? "on" : "off";
 466                 else if (clk->mode == pmc_uckr_mode)
 467                         state = (uckr & clk->pmc_mask) ? "on" : "off";
 468                 else if (clk->pmc_mask)
 469                         state = (sr & clk->pmc_mask) ? "on" : "off";
 470                 else if (clk == &clk32k || clk == &main_clk)
 471                         state = "on";
 472                 else
 473                         state = "";
 474
 475                 seq_printf(s, "%-10s users=%2d %-3s %9ld Hz %s\n",
 476                         clk->name, clk->users, state, clk_get_rate(clk),
 477                         clk->parent ? clk->parent->name : "");
 478         }
 479         return 0;
 480 }
 481
 482 static int at91_clk_open(struct inode *inode, struct file *file)
 483 {
 484         return single_open(file, at91_clk_show, NULL);
 485 }
 486
 487 static const struct file_operations at91_clk_operations = {
 488         .open           = at91_clk_open,
 489         .read           = seq_read,
 490         .llseek         = seq_lseek,
 491         .release        = single_release,
 492 };
 493
 494 static int __init at91_clk_debugfs_init(void)
 495 {
 496         /* /sys/kernel/debug/at91_clk */
 497         (void) debugfs_create_file("at91_clk", S_IFREG | S_IRUGO, NULL, NULL, &at91_clk_operations);
 498
 499         return 0;
 500 }
 501 postcore_initcall(at91_clk_debugfs_init);
 502
 503 #endif
 504
 505 /*------------------------------------------------------------------------*/
 506
 507 /* Register a new clock */
 508 static void __init at91_clk_add(struct clk *clk)
 509 {
 510         list_add_tail(&clk->node, &clocks);
 511
 512         clk->cl.con_id = clk->name;
 513         clk->cl.clk = clk;
 514         clkdev_add(&clk->cl);
 515 }
 516
 517 int __init clk_register(struct clk *clk)
 518 {
 519         if (clk_is_peripheral(clk)) {
 520                 if (!clk->parent)
 521                         clk->parent = &mck;
 522                 clk->mode = pmc_periph_mode;
 523         }
 524         else if (clk_is_sys(clk)) {
 525                 clk->parent = &mck;
 526                 clk->mode = pmc_sys_mode;
 527         }
 528 #ifdef CONFIG_AT91_PROGRAMMABLE_CLOCKS
 529         else if (clk_is_programmable(clk)) {
 530                 clk->mode = pmc_sys_mode;
 531                 init_programmable_clock(clk);
 532         }
 533 #endif
 534
 535         at91_clk_add(clk);
 536
 537         return 0;
 538 }
 539
 540 /*------------------------------------------------------------------------*/
 541
 542 static u32 __init at91_pll_rate(struct clk *pll, u32 freq, u32 reg)
 543 {
 544         unsigned mul, div;
 545
 546         div = reg & 0xff;
 547         mul = (reg >> 16) & 0x7ff;
 548         if (div && mul) {
 549                 freq /= div;
 550                 freq *= mul + 1;
 551         } else
 552                 freq = 0;
 553
 554         return freq;
 555 }
 556
 557 static u32 __init at91_usb_rate(struct clk *pll, u32 freq, u32 reg)
 558 {
 559         if (pll == &pllb && (reg & AT91_PMC_USB96M))
 560                 return freq / 2;
 561         else
 562                 return freq;
 563 }
 564
 565 static unsigned __init at91_pll_calc(unsigned main_freq, unsigned out_freq)
 566 {
 567         unsigned i, div = 0, mul = 0, diff = 1 << 30;
 568         unsigned ret = (out_freq > 155000000) ? 0xbe00 : 0x3e00;
 569
 570         /* PLL output max 240 MHz (or 180 MHz per errata) */
 571         if (out_freq > 240000000)
 572                 goto fail;
 573
 574         for (i = 1; i < 256; i++) {
 575                 int diff1;
 576                 unsigned input, mul1;
 577
 578                 /*
 579                  * PLL input between 1MHz and 32MHz per spec, but lower
 580                  * frequences seem necessary in some cases so allow 100K.
 581                  * Warning: some newer products need 2MHz min.
 582                  */
 583                 input = main_freq / i;
 584                 if (cpu_is_at91sam9g20() && input < 2000000)
 585                         continue;
 586                 if (input < 100000)
 587                         continue;
 588                 if (input > 32000000)
 589                         continue;
 590
 591                 mul1 = out_freq / input;
 592                 if (cpu_is_at91sam9g20() && mul > 63)
 593                         continue;
 594                 if (mul1 > 2048)
 595                         continue;
 596                 if (mul1 < 2)
 597                         goto fail;
 598
 599                 diff1 = out_freq - input * mul1;
 600                 if (diff1 < 0)
 601                         diff1 = -diff1;
 602                 if (diff > diff1) {
 603                         diff = diff1;
 604                         div = i;
 605                         mul = mul1;
 606                         if (diff == 0)
 607                                 break;
 608                 }
 609         }
 610         if (i == 256 && diff > (out_freq >> 5))
 611                 goto fail;
 612         return ret | ((mul - 1) << 16) | div;
 613 fail:
 614         return 0;
 615 }
 616
 617 static struct clk *const standard_pmc_clocks[] __initdata = {
 618         /* four primary clocks */
 619         &clk32k,
 620         &main_clk,
 621         &plla,
 622
 623         /* MCK */
 624         &mck
 625 };
 626
 627 /* PLLB generated USB full speed clock init */
 628 static void __init at91_pllb_usbfs_clock_init(unsigned long main_clock)
 629 {
 630         /*
 631          * USB clock init:  choose 48 MHz PLLB value,
 632          * disable 48MHz clock during usb peripheral suspend.
 633          *
 634          * REVISIT:  assumes MCK doesn't derive from PLLB!
 635          */
 636         uhpck.parent = &pllb;
 637
 638         at91_pllb_usb_init = at91_pll_calc(main_clock, 48000000 * 2) | AT91_PMC_USB96M;
 639         pllb.rate_hz = at91_pll_rate(&pllb, main_clock, at91_pllb_usb_init);
 640         if (cpu_is_at91rm9200()) {
 641                 uhpck.pmc_mask = AT91RM9200_PMC_UHP;
 642                 udpck.pmc_mask = AT91RM9200_PMC_UDP;
 643                 at91_pmc_write(AT91_PMC_SCER, AT91RM9200_PMC_MCKUDP);
 644         } else if (cpu_is_at91sam9260() || cpu_is_at91sam9261() ||
 645                    cpu_is_at91sam9263() || cpu_is_at91sam9g20() ||
 646                    cpu_is_at91sam9g10()) {
 647                 uhpck.pmc_mask = AT91SAM926x_PMC_UHP;
 648                 udpck.pmc_mask = AT91SAM926x_PMC_UDP;
 649         }
 650         at91_pmc_write(AT91_CKGR_PLLBR, 0);
 651
 652         udpck.rate_hz = at91_usb_rate(&pllb, pllb.rate_hz, at91_pllb_usb_init);
 653         uhpck.rate_hz = at91_usb_rate(&pllb, pllb.rate_hz, at91_pllb_usb_init);
 654 }
 655
 656 /* UPLL generated USB full speed clock init */
 657 static void __init at91_upll_usbfs_clock_init(unsigned long main_clock)
 658 {
 659         /*
 660          * USB clock init: choose 480 MHz from UPLL,
 661          */
 662         unsigned int usbr = AT91_PMC_USBS_UPLL;
 663
 664         /* Setup divider by 10 to reach 48 MHz */
 665         usbr |= ((10 - 1) << 8) & AT91_PMC_OHCIUSBDIV;
 666
 667         at91_pmc_write(AT91_PMC_USB, usbr);
 668
 669         /* Now set uhpck values */
 670         uhpck.parent = &utmi_clk;
 671         uhpck.pmc_mask = AT91SAM926x_PMC_UHP;
 672         uhpck.rate_hz = utmi_clk.rate_hz;
 673         uhpck.rate_hz /= 1 + ((at91_pmc_read(AT91_PMC_USB) & AT91_PMC_OHCIUSBDIV) >> 8);
 674 }
 675
 676 static int __init at91_pmc_init(unsigned long main_clock)
 677 {
 678         unsigned tmp, freq, mckr;
 679         int i;
 680         int pll_overclock = false;
 681
 682         /*
 683          * When the bootloader initialized the main oscillator correctly,
 684          * there's no problem using the cycle counter.  But if it didn't,
 685          * or when using oscillator bypass mode, we must be told the speed
 686          * of the main clock.
 687          */
 688         if (!main_clock) {
 689                 do {
 690                         tmp = at91_pmc_read(AT91_CKGR_MCFR);
 691                 } while (!(tmp & AT91_PMC_MAINRDY));
 692                 main_clock = (tmp & AT91_PMC_MAINF) * (AT91_SLOW_CLOCK / 16);
 693         }
 694         main_clk.rate_hz = main_clock;
 695
 696         /* report if PLLA is more than mildly overclocked */
 697         plla.rate_hz = at91_pll_rate(&plla, main_clock, at91_pmc_read(AT91_CKGR_PLLAR));
 698         if (cpu_has_300M_plla()) {
 699                 if (plla.rate_hz > 300000000)
 700                         pll_overclock = true;
 701         } else if (cpu_has_800M_plla()) {
 702                 if (plla.rate_hz > 800000000)
 703                         pll_overclock = true;
 704         } else {
 705                 if (plla.rate_hz > 209000000)
 706                         pll_overclock = true;
 707         }
 708         if (pll_overclock)
 709                 pr_info("Clocks: PLLA overclocked, %ld MHz\n", plla.rate_hz / 1000000);
 710
 711         if (cpu_has_plladiv2()) {
 712                 mckr = at91_pmc_read(AT91_PMC_MCKR);
 713                 plla.rate_hz /= (1 << ((mckr & AT91_PMC_PLLADIV2) >> 12));      /* plla divisor by 2 */
 714         }
 715
 716         if (!cpu_has_pllb() && cpu_has_upll()) {
 717                 /* setup UTMI clock as the fourth primary clock
 718                  * (instead of pllb) */
 719                 utmi_clk.type |= CLK_TYPE_PRIMARY;
 720                 utmi_clk.id = 3;
 721         }
 722
 723
 724         /*
 725          * USB HS clock init
 726          */
 727         if (cpu_has_utmi()) {
 728                 /*
 729                  * multiplier is hard-wired to 40
 730                  * (obtain the USB High Speed 480 MHz when input is 12 MHz)
 731                  */
 732                 utmi_clk.rate_hz = 40 * utmi_clk.parent->rate_hz;
 733
 734                 /* UTMI bias and PLL are managed at the same time */
 735                 if (cpu_has_upll())
 736                         utmi_clk.pmc_mask |= AT91_PMC_BIASEN;
 737         }
 738
 739         /*
 740          * USB FS clock init
 741          */
 742         if (cpu_has_pllb())
 743                 at91_pllb_usbfs_clock_init(main_clock);
 744         if (cpu_has_upll())
 745                 /* assumes that we choose UPLL for USB and not PLLA */
 746                 at91_upll_usbfs_clock_init(main_clock);
 747
 748         /*
 749          * MCK and CPU derive from one of those primary clocks.
 750          * For now, assume this parentage won't change.
 751          */
 752         mckr = at91_pmc_read(AT91_PMC_MCKR);
 753         mck.parent = at91_css_to_clk(mckr & AT91_PMC_CSS);
 754         freq = mck.parent->rate_hz;
 755         freq /= pmc_prescaler_divider(mckr);                                    /* prescale */
 756         if (cpu_is_at91rm9200()) {
 757                 mck.rate_hz = freq / (1 + ((mckr & AT91_PMC_MDIV) >> 8));       /* mdiv */
 758         } else if (cpu_is_at91sam9g20()) {
 759                 mck.rate_hz = (mckr & AT91_PMC_MDIV) ?
 760                         freq / ((mckr & AT91_PMC_MDIV) >> 7) : freq;    /* mdiv ; (x >> 7) = ((x >> 8) * 2) */
 761                 if (mckr & AT91_PMC_PDIV)
 762                         freq /= 2;              /* processor clock division */
 763         } else if (cpu_has_mdiv3()) {
 764                 mck.rate_hz = (mckr & AT91_PMC_MDIV) == AT91SAM9_PMC_MDIV_3 ?
 765                         freq / 3 : freq / (1 << ((mckr & AT91_PMC_MDIV) >> 8)); /* mdiv */
 766         } else {
 767                 mck.rate_hz = freq / (1 << ((mckr & AT91_PMC_MDIV) >> 8));              /* mdiv */
 768         }
 769
 770         if (cpu_has_alt_prescaler()) {
 771                 /* Programmable clocks can use MCK */
 772                 mck.type |= CLK_TYPE_PRIMARY;
 773                 mck.id = 4;
 774         }
 775
 776         /* Register the PMC's standard clocks */
 777         for (i = 0; i < ARRAY_SIZE(standard_pmc_clocks); i++)
 778                 at91_clk_add(standard_pmc_clocks[i]);
 779
 780         if (cpu_has_pllb())
 781                 at91_clk_add(&pllb);
 782
 783         if (cpu_has_uhp())
 784                 at91_clk_add(&uhpck);
 785
 786         if (cpu_has_udpfs())
 787                 at91_clk_add(&udpck);
 788
 789         if (cpu_has_utmi())
 790                 at91_clk_add(&utmi_clk);
 791
 792         /* MCK and CPU clock are "always on" */
 793         clk_enable(&mck);
 794
 795         printk("Clocks: CPU %u MHz, master %u MHz, main %u.%03u MHz\n",
 796                 freq / 1000000, (unsigned) mck.rate_hz / 1000000,
 797                 (unsigned) main_clock / 1000000,
 798                 ((unsigned) main_clock % 1000000) / 1000);
 799
 800         return 0;
 801 }
 802
 803 #if defined(CONFIG_OF)
 804 static struct of_device_id pmc_ids[] = {
 805         { .compatible = "atmel,at91rm9200-pmc" },
 806         { /*sentinel*/ }
 807 };
 808
 809 static struct of_device_id osc_ids[] = {
 810         { .compatible = "atmel,osc" },
 811         { /*sentinel*/ }
 812 };
 813
 814 int __init at91_dt_clock_init(void)
 815 {
 816         struct device_node *np;
 817         u32 main_clock = 0;
 818
 819         np = of_find_matching_node(NULL, pmc_ids);
 820         if (!np)
 821                 panic("unable to find compatible pmc node in dtb\n");
 822
 823         at91_pmc_base = of_iomap(np, 0);
 824         if (!at91_pmc_base)
 825                 panic("unable to map pmc cpu registers\n");
 826
 827         of_node_put(np);
 828
 829         /* retrieve the freqency of fixed clocks from device tree */
 830         np = of_find_matching_node(NULL, osc_ids);
 831         if (np) {
 832                 u32 rate;
 833                 if (!of_property_read_u32(np, "clock-frequency", &rate))
 834                         main_clock = rate;
 835         }
 836
 837         of_node_put(np);
 838
 839         return at91_pmc_init(main_clock);
 840 }
 841 #endif
 842
 843 int __init at91_clock_init(unsigned long main_clock)
 844 {
 845         at91_pmc_base = ioremap(AT91_PMC, 256);
 846         if (!at91_pmc_base)
 847                 panic("Impossible to ioremap AT91_PMC 0x%x\n", AT91_PMC);
 848
 849         return at91_pmc_init(main_clock);
 850 }
 851
 852 /*
 853  * Several unused clocks may be active.  Turn them off.
 854  */
 855 static int __init at91_clock_reset(void)
 856 {
 857         unsigned long pcdr = 0;
 858         unsigned long scdr = 0;
 859         struct clk *clk;
 860
 861         list_for_each_entry(clk, &clocks, node) {
 862                 if (clk->users > 0)
 863                         continue;
 864
 865                 if (clk->mode == pmc_periph_mode)
 866                         pcdr |= clk->pmc_mask;
 867
 868                 if (clk->mode == pmc_sys_mode)
 869                         scdr |= clk->pmc_mask;
 870
 871                 pr_debug("Clocks: disable unused %s\n", clk->name);
 872         }
 873
 874         at91_pmc_write(AT91_PMC_PCDR, pcdr);
 875         at91_pmc_write(AT91_PMC_SCDR, scdr);
 876
 877         return 0;
 878 }
 879 late_initcall(at91_clock_reset);
 880
 881 void at91sam9_idle(void)
 882 {
 883         at91_pmc_write(AT91_PMC_SCDR, AT91_PMC_PCK);
 884         cpu_do_idle();
 885 }