arch/arm/mach-at91rm9200/clock.c

   1 /*
   2  * linux/arch/arm/mach-at91rm9200/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
  26 #include <asm/semaphore.h>
  27 #include <asm/io.h>
  28 #include <asm/mach-types.h>
  29
  30 #include <asm/hardware.h>
  31
  32 #include "clock.h"
  33
  34
  35 /*
  36  * There's a lot more which can be done with clocks, including cpufreq
  37  * integration, slow clock mode support (for system suspend), letting
  38  * PLLB be used at other rates (on boards that don't need USB), etc.
  39  */
  40
  41 #define clk_is_primary(x)       ((x)->type & CLK_TYPE_PRIMARY)
  42 #define clk_is_programmable(x)  ((x)->type & CLK_TYPE_PROGRAMMABLE)
  43 #define clk_is_peripheral(x)    ((x)->type & CLK_TYPE_PERIPHERAL)
  44
  45
  46 static LIST_HEAD(clocks);
  47 static DEFINE_SPINLOCK(clk_lock);
  48
  49 static u32 at91_pllb_usb_init;
  50
  51 /*
  52  * Four primary clock sources:  two crystal oscillators (32K, main), and
  53  * two PLLs.  PLLA usually runs the master clock; and PLLB must run at
  54  * 48 MHz (unless no USB function clocks are needed).  The main clock and
  55  * both PLLs are turned off to run in "slow clock mode" (system suspend).
  56  */
  57 static struct clk clk32k = {
  58         .name           = "clk32k",
  59         .rate_hz        = AT91_SLOW_CLOCK,
  60         .users          = 1,            /* always on */
  61         .id             = 0,
  62         .type           = CLK_TYPE_PRIMARY,
  63 };
  64 static struct clk main_clk = {
  65         .name           = "main",
  66         .pmc_mask       = AT91_PMC_MOSCS,       /* in PMC_SR */
  67         .id             = 1,
  68         .type           = CLK_TYPE_PRIMARY,
  69 };
  70 static struct clk plla = {
  71         .name           = "plla",
  72         .parent         = &main_clk,
  73         .pmc_mask       = AT91_PMC_LOCKA,       /* in PMC_SR */
  74         .id             = 2,
  75         .type           = CLK_TYPE_PRIMARY | CLK_TYPE_PLL,
  76 };
  77
  78 static void pllb_mode(struct clk *clk, int is_on)
  79 {
  80         u32     value;
  81
  82         if (is_on) {
  83                 is_on = AT91_PMC_LOCKB;
  84                 value = at91_pllb_usb_init;
  85         } else
  86                 value = 0;
  87
  88         // REVISIT: Add work-around for AT91RM9200 Errata #26 ?
  89         at91_sys_write(AT91_CKGR_PLLBR, value);
  90
  91         do {
  92                 cpu_relax();
  93         } while ((at91_sys_read(AT91_PMC_SR) & AT91_PMC_LOCKB) != is_on);
  94 }
  95
  96 static struct clk pllb = {
  97         .name           = "pllb",
  98         .parent         = &main_clk,
  99         .pmc_mask       = AT91_PMC_LOCKB,       /* in PMC_SR */
 100         .mode           = pllb_mode,
 101         .id             = 3,
 102         .type           = CLK_TYPE_PRIMARY | CLK_TYPE_PLL,
 103 };
 104
 105 static void pmc_sys_mode(struct clk *clk, int is_on)
 106 {
 107         if (is_on)
 108                 at91_sys_write(AT91_PMC_SCER, clk->pmc_mask);
 109         else
 110                 at91_sys_write(AT91_PMC_SCDR, clk->pmc_mask);
 111 }
 112
 113 /* USB function clocks (PLLB must be 48 MHz) */
 114 static struct clk udpck = {
 115         .name           = "udpck",
 116         .parent         = &pllb,
 117         .pmc_mask       = AT91_PMC_UDP,
 118         .mode           = pmc_sys_mode,
 119 };
 120 static struct clk uhpck = {
 121         .name           = "uhpck",
 122         .parent         = &pllb,
 123         .pmc_mask       = AT91_PMC_UHP,
 124         .mode           = pmc_sys_mode,
 125 };
 126
 127
 128 /*
 129  * The master clock is divided from the CPU clock (by 1-4).  It's used for
 130  * memory, interfaces to on-chip peripherals, the AIC, and sometimes more
 131  * (e.g baud rate generation).  It's sourced from one of the primary clocks.
 132  */
 133 static struct clk mck = {
 134         .name           = "mck",
 135         .pmc_mask       = AT91_PMC_MCKRDY,      /* in PMC_SR */
 136 };
 137
 138 static void pmc_periph_mode(struct clk *clk, int is_on)
 139 {
 140         if (is_on)
 141                 at91_sys_write(AT91_PMC_PCER, clk->pmc_mask);
 142         else
 143                 at91_sys_write(AT91_PMC_PCDR, clk->pmc_mask);
 144 }
 145
 146 static struct clk __init *at91_css_to_clk(unsigned long css)
 147 {
 148         switch (css) {
 149                 case AT91_PMC_CSS_SLOW:
 150                         return &clk32k;
 151                 case AT91_PMC_CSS_MAIN:
 152                         return &main_clk;
 153                 case AT91_PMC_CSS_PLLA:
 154                         return &plla;
 155                 case AT91_PMC_CSS_PLLB:
 156                         return &pllb;
 157         }
 158
 159         return NULL;
 160 }
 161
 162 /*
 163  * Associate a particular clock with a function (eg, "uart") and device.
 164  * The drivers can then request the same 'function' with several different
 165  * devices and not care about which clock name to use.
 166  */
 167 void __init at91_clock_associate(const char *id, struct device *dev, const char *func)
 168 {
 169         struct clk *clk = clk_get(NULL, id);
 170
 171         if (!dev || !clk || !IS_ERR(clk_get(dev, func)))
 172                 return;
 173
 174         clk->function = func;
 175         clk->dev = dev;
 176 }
 177
 178 /* clocks cannot be de-registered no refcounting necessary */
 179 struct clk *clk_get(struct device *dev, const char *id)
 180 {
 181         struct clk *clk;
 182
 183         list_for_each_entry(clk, &clocks, node) {
 184                 if (strcmp(id, clk->name) == 0)
 185                         return clk;
 186                 if (clk->function && (dev == clk->dev) && strcmp(id, clk->function) == 0)
 187                         return clk;
 188         }
 189
 190         return ERR_PTR(-ENOENT);
 191 }
 192 EXPORT_SYMBOL(clk_get);
 193
 194 void clk_put(struct clk *clk)
 195 {
 196 }
 197 EXPORT_SYMBOL(clk_put);
 198
 199 static void __clk_enable(struct clk *clk)
 200 {
 201         if (clk->parent)
 202                 __clk_enable(clk->parent);
 203         if (clk->users++ == 0 && clk->mode)
 204                 clk->mode(clk, 1);
 205 }
 206
 207 int clk_enable(struct clk *clk)
 208 {
 209         unsigned long   flags;
 210
 211         spin_lock_irqsave(&clk_lock, flags);
 212         __clk_enable(clk);
 213         spin_unlock_irqrestore(&clk_lock, flags);
 214         return 0;
 215 }
 216 EXPORT_SYMBOL(clk_enable);
 217
 218 static void __clk_disable(struct clk *clk)
 219 {
 220         BUG_ON(clk->users == 0);
 221         if (--clk->users == 0 && clk->mode)
 222                 clk->mode(clk, 0);
 223         if (clk->parent)
 224                 __clk_disable(clk->parent);
 225 }
 226
 227 void clk_disable(struct clk *clk)
 228 {
 229         unsigned long   flags;
 230
 231         spin_lock_irqsave(&clk_lock, flags);
 232         __clk_disable(clk);
 233         spin_unlock_irqrestore(&clk_lock, flags);
 234 }
 235 EXPORT_SYMBOL(clk_disable);
 236
 237 unsigned long clk_get_rate(struct clk *clk)
 238 {
 239         unsigned long   flags;
 240         unsigned long   rate;
 241
 242         spin_lock_irqsave(&clk_lock, flags);
 243         for (;;) {
 244                 rate = clk->rate_hz;
 245                 if (rate || !clk->parent)
 246                         break;
 247                 clk = clk->parent;
 248         }
 249         spin_unlock_irqrestore(&clk_lock, flags);
 250         return rate;
 251 }
 252 EXPORT_SYMBOL(clk_get_rate);
 253
 254 /*------------------------------------------------------------------------*/
 255
 256 #ifdef CONFIG_AT91_PROGRAMMABLE_CLOCKS
 257
 258 /*
 259  * For now, only the programmable clocks support reparenting (MCK could
 260  * do this too, with care) or rate changing (the PLLs could do this too,
 261  * ditto MCK but that's more for cpufreq).  Drivers may reparent to get
 262  * a better rate match; we don't.
 263  */
 264
 265 long clk_round_rate(struct clk *clk, unsigned long rate)
 266 {
 267         unsigned long   flags;
 268         unsigned        prescale;
 269         unsigned long   actual;
 270
 271         if (!clk_is_programmable(clk))
 272                 return -EINVAL;
 273         spin_lock_irqsave(&clk_lock, flags);
 274
 275         actual = clk->parent->rate_hz;
 276         for (prescale = 0; prescale < 7; prescale++) {
 277                 if (actual && actual <= rate)
 278                         break;
 279                 actual >>= 1;
 280         }
 281
 282         spin_unlock_irqrestore(&clk_lock, flags);
 283         return (prescale < 7) ? actual : -ENOENT;
 284 }
 285 EXPORT_SYMBOL(clk_round_rate);
 286
 287 int clk_set_rate(struct clk *clk, unsigned long rate)
 288 {
 289         unsigned long   flags;
 290         unsigned        prescale;
 291         unsigned long   actual;
 292
 293         if (!clk_is_programmable(clk))
 294                 return -EINVAL;
 295         if (clk->users)
 296                 return -EBUSY;
 297         spin_lock_irqsave(&clk_lock, flags);
 298
 299         actual = clk->parent->rate_hz;
 300         for (prescale = 0; prescale < 7; prescale++) {
 301                 if (actual && actual <= rate) {
 302                         u32     pckr;
 303
 304                         pckr = at91_sys_read(AT91_PMC_PCKR(clk->id));
 305                         pckr &= AT91_PMC_CSS_PLLB;      /* clock selection */
 306                         pckr |= prescale << 2;
 307                         at91_sys_write(AT91_PMC_PCKR(clk->id), pckr);
 308                         clk->rate_hz = actual;
 309                         break;
 310                 }
 311                 actual >>= 1;
 312         }
 313
 314         spin_unlock_irqrestore(&clk_lock, flags);
 315         return (prescale < 7) ? actual : -ENOENT;
 316 }
 317 EXPORT_SYMBOL(clk_set_rate);
 318
 319 struct clk *clk_get_parent(struct clk *clk)
 320 {
 321         return clk->parent;
 322 }
 323 EXPORT_SYMBOL(clk_get_parent);
 324
 325 int clk_set_parent(struct clk *clk, struct clk *parent)
 326 {
 327         unsigned long   flags;
 328
 329         if (clk->users)
 330                 return -EBUSY;
 331         if (!clk_is_primary(parent) || !clk_is_programmable(clk))
 332                 return -EINVAL;
 333         spin_lock_irqsave(&clk_lock, flags);
 334
 335         clk->rate_hz = parent->rate_hz;
 336         clk->parent = parent;
 337         at91_sys_write(AT91_PMC_PCKR(clk->id), parent->id);
 338
 339         spin_unlock_irqrestore(&clk_lock, flags);
 340         return 0;
 341 }
 342 EXPORT_SYMBOL(clk_set_parent);
 343
 344 /* establish PCK0..PCK3 parentage and rate */
 345 static void init_programmable_clock(struct clk *clk)
 346 {
 347         struct clk      *parent;
 348         u32             pckr;
 349
 350         pckr = at91_sys_read(AT91_PMC_PCKR(clk->id));
 351         parent = at91_css_to_clk(pckr & AT91_PMC_CSS);
 352         clk->parent = parent;
 353         clk->rate_hz = parent->rate_hz / (1 << ((pckr >> 2) & 3));
 354 }
 355
 356 #endif  /* CONFIG_AT91_PROGRAMMABLE_CLOCKS */
 357
 358 /*------------------------------------------------------------------------*/
 359
 360 #ifdef CONFIG_DEBUG_FS
 361
 362 static int at91_clk_show(struct seq_file *s, void *unused)
 363 {
 364         u32             scsr, pcsr, sr;
 365         struct clk      *clk;
 366         unsigned        i;
 367
 368         seq_printf(s, "SCSR = %8x\n", scsr = at91_sys_read(AT91_PMC_SCSR));
 369         seq_printf(s, "PCSR = %8x\n", pcsr = at91_sys_read(AT91_PMC_PCSR));
 370
 371         seq_printf(s, "MOR  = %8x\n", at91_sys_read(AT91_CKGR_MOR));
 372         seq_printf(s, "MCFR = %8x\n", at91_sys_read(AT91_CKGR_MCFR));
 373         seq_printf(s, "PLLA = %8x\n", at91_sys_read(AT91_CKGR_PLLAR));
 374         seq_printf(s, "PLLB = %8x\n", at91_sys_read(AT91_CKGR_PLLBR));
 375
 376         seq_printf(s, "MCKR = %8x\n", at91_sys_read(AT91_PMC_MCKR));
 377         for (i = 0; i < 4; i++)
 378                 seq_printf(s, "PCK%d = %8x\n", i, at91_sys_read(AT91_PMC_PCKR(i)));
 379         seq_printf(s, "SR   = %8x\n", sr = at91_sys_read(AT91_PMC_SR));
 380
 381         seq_printf(s, "\n");
 382
 383         list_for_each_entry(clk, &clocks, node) {
 384                 char    *state;
 385
 386                 if (clk->mode == pmc_sys_mode)
 387                         state = (scsr & clk->pmc_mask) ? "on" : "off";
 388                 else if (clk->mode == pmc_periph_mode)
 389                         state = (pcsr & clk->pmc_mask) ? "on" : "off";
 390                 else if (clk->pmc_mask)
 391                         state = (sr & clk->pmc_mask) ? "on" : "off";
 392                 else if (clk == &clk32k || clk == &main_clk)
 393                         state = "on";
 394                 else
 395                         state = "";
 396
 397                 seq_printf(s, "%-10s users=%2d %-3s %9ld Hz %s\n",
 398                         clk->name, clk->users, state, clk_get_rate(clk),
 399                         clk->parent ? clk->parent->name : "");
 400         }
 401         return 0;
 402 }
 403
 404 static int at91_clk_open(struct inode *inode, struct file *file)
 405 {
 406         return single_open(file, at91_clk_show, NULL);
 407 }
 408
 409 static struct file_operations at91_clk_operations = {
 410         .open           = at91_clk_open,
 411         .read           = seq_read,
 412         .llseek         = seq_lseek,
 413         .release        = single_release,
 414 };
 415
 416 static int __init at91_clk_debugfs_init(void)
 417 {
 418         /* /sys/kernel/debug/at91_clk */
 419         (void) debugfs_create_file("at91_clk", S_IFREG | S_IRUGO, NULL, NULL, &at91_clk_operations);
 420
 421         return 0;
 422 }
 423 postcore_initcall(at91_clk_debugfs_init);
 424
 425 #endif
 426
 427 /*------------------------------------------------------------------------*/
 428
 429 /* Register a new clock */
 430 int __init clk_register(struct clk *clk)
 431 {
 432         if (clk_is_peripheral(clk)) {
 433                 clk->parent = &mck;
 434                 clk->mode = pmc_periph_mode;
 435                 list_add_tail(&clk->node, &clocks);
 436         }
 437 #ifdef CONFIG_AT91_PROGRAMMABLE_CLOCKS
 438         else if (clk_is_programmable(clk)) {
 439                 clk->mode = pmc_sys_mode;
 440                 init_programmable_clock(clk);
 441                 list_add_tail(&clk->node, &clocks);
 442         }
 443 #endif
 444
 445         return 0;
 446 }
 447
 448
 449 /*------------------------------------------------------------------------*/
 450
 451 static u32 __init at91_pll_rate(struct clk *pll, u32 freq, u32 reg)
 452 {
 453         unsigned mul, div;
 454
 455         div = reg & 0xff;
 456         mul = (reg >> 16) & 0x7ff;
 457         if (div && mul) {
 458                 freq /= div;
 459                 freq *= mul + 1;
 460         } else
 461                 freq = 0;
 462
 463         return freq;
 464 }
 465
 466 static u32 __init at91_usb_rate(struct clk *pll, u32 freq, u32 reg)
 467 {
 468         if (pll == &pllb && (reg & AT91_PMC_USB96M))
 469                 return freq / 2;
 470         else
 471                 return freq;
 472 }
 473
 474 static unsigned __init at91_pll_calc(unsigned main_freq, unsigned out_freq)
 475 {
 476         unsigned i, div = 0, mul = 0, diff = 1 << 30;
 477         unsigned ret = (out_freq > 155000000) ? 0xbe00 : 0x3e00;
 478
 479         /* PLL output max 240 MHz (or 180 MHz per errata) */
 480         if (out_freq > 240000000)
 481                 goto fail;
 482
 483         for (i = 1; i < 256; i++) {
 484                 int diff1;
 485                 unsigned input, mul1;
 486
 487                 /*
 488                  * PLL input between 1MHz and 32MHz per spec, but lower
 489                  * frequences seem necessary in some cases so allow 100K.
 490                  */
 491                 input = main_freq / i;
 492                 if (input < 100000)
 493                         continue;
 494                 if (input > 32000000)
 495                         continue;
 496
 497                 mul1 = out_freq / input;
 498                 if (mul1 > 2048)
 499                         continue;
 500                 if (mul1 < 2)
 501                         goto fail;
 502
 503                 diff1 = out_freq - input * mul1;
 504                 if (diff1 < 0)
 505                         diff1 = -diff1;
 506                 if (diff > diff1) {
 507                         diff = diff1;
 508                         div = i;
 509                         mul = mul1;
 510                         if (diff == 0)
 511                                 break;
 512                 }
 513         }
 514         if (i == 256 && diff > (out_freq >> 5))
 515                 goto fail;
 516         return ret | ((mul - 1) << 16) | div;
 517 fail:
 518         return 0;
 519 }
 520
 521 /*
 522  * Several unused clocks may be active.  Turn them off.
 523  */
 524 static void __init at91_periphclk_reset(void)
 525 {
 526         unsigned long reg;
 527         struct clk *clk;
 528
 529         reg = at91_sys_read(AT91_PMC_PCSR);
 530
 531         list_for_each_entry(clk, &clocks, node) {
 532                 if (clk->mode != pmc_periph_mode)
 533                         continue;
 534
 535                 if (clk->users > 0)
 536                         reg &= ~clk->pmc_mask;
 537         }
 538
 539         at91_sys_write(AT91_PMC_PCDR, reg);
 540 }
 541
 542 static struct clk *const standard_pmc_clocks[] __initdata = {
 543         /* four primary clocks */
 544         &clk32k,
 545         &main_clk,
 546         &plla,
 547         &pllb,
 548
 549         /* PLLB children (USB) */
 550         &udpck,
 551         &uhpck,
 552
 553         /* MCK */
 554         &mck
 555 };
 556
 557 int __init at91_clock_init(unsigned long main_clock)
 558 {
 559         unsigned tmp, freq, mckr;
 560         int i;
 561
 562         /*
 563          * When the bootloader initialized the main oscillator correctly,
 564          * there's no problem using the cycle counter.  But if it didn't,
 565          * or when using oscillator bypass mode, we must be told the speed
 566          * of the main clock.
 567          */
 568         if (!main_clock) {
 569                 do {
 570                         tmp = at91_sys_read(AT91_CKGR_MCFR);
 571                 } while (!(tmp & AT91_PMC_MAINRDY));
 572                 main_clock = (tmp & AT91_PMC_MAINF) * (AT91_SLOW_CLOCK / 16);
 573         }
 574         main_clk.rate_hz = main_clock;
 575
 576         /* report if PLLA is more than mildly overclocked */
 577         plla.rate_hz = at91_pll_rate(&plla, main_clock, at91_sys_read(AT91_CKGR_PLLAR));
 578         if (plla.rate_hz > 209000000)
 579                 pr_info("Clocks: PLLA overclocked, %ld MHz\n", plla.rate_hz / 1000000);
 580
 581         /*
 582          * USB clock init:  choose 48 MHz PLLB value, turn all clocks off,
 583          * disable 48MHz clock during usb peripheral suspend.
 584          *
 585          * REVISIT:  assumes MCK doesn't derive from PLLB!
 586          */
 587         at91_pllb_usb_init = at91_pll_calc(main_clock, 48000000 * 2) | AT91_PMC_USB96M;
 588         pllb.rate_hz = at91_pll_rate(&pllb, main_clock, at91_pllb_usb_init);
 589         at91_sys_write(AT91_PMC_SCDR, AT91_PMC_UHP | AT91_PMC_UDP);
 590         at91_sys_write(AT91_CKGR_PLLBR, 0);
 591         at91_sys_write(AT91_PMC_SCER, AT91_PMC_MCKUDP);
 592
 593         udpck.rate_hz = at91_usb_rate(&pllb, pllb.rate_hz, at91_pllb_usb_init);
 594         uhpck.rate_hz = at91_usb_rate(&pllb, pllb.rate_hz, at91_pllb_usb_init);
 595
 596         /*
 597          * MCK and CPU derive from one of those primary clocks.
 598          * For now, assume this parentage won't change.
 599          */
 600         mckr = at91_sys_read(AT91_PMC_MCKR);
 601         mck.parent = at91_css_to_clk(mckr & AT91_PMC_CSS);
 602         freq = mck.parent->rate_hz;
 603         freq /= (1 << ((mckr >> 2) & 3));               /* prescale */
 604         mck.rate_hz = freq / (1 + ((mckr >> 8) & 3));   /* mdiv */
 605
 606         /* Register the PMC's standard clocks */
 607         for (i = 0; i < ARRAY_SIZE(standard_pmc_clocks); i++)
 608                 list_add_tail(&standard_pmc_clocks[i]->node, &clocks);
 609
 610         /* MCK and CPU clock are "always on" */
 611         clk_enable(&mck);
 612
 613         printk("Clocks: CPU %u MHz, master %u MHz, main %u.%03u MHz\n",
 614                 freq / 1000000, (unsigned) mck.rate_hz / 1000000,
 615                 (unsigned) main_clock / 1000000,
 616                 ((unsigned) main_clock % 1000000) / 1000);
 617
 618         /* disable all programmable clocks */
 619         at91_sys_write(AT91_PMC_SCDR, AT91_PMC_PCK0 | AT91_PMC_PCK1 | AT91_PMC_PCK2 | AT91_PMC_PCK3);
 620
 621         /* disable all other unused peripheral clocks */
 622         at91_periphclk_reset();
 623
 624         return 0;
 625 }