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