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