ARM: delete struct sys_timer
[linux-3.10.git] / arch / arm / mach-imx / cpufreq.c
index 434b4ca..36e8b39 100644 (file)
 /*
- * cpu.c: clock scaling for the iMX
- *
- * Copyright (C) 2000 2001, The Delft University of Technology
- * Copyright (c) 2004 Sascha Hauer <sascha@saschahauer.de>
- * Copyright (C) 2006 Inky Lung <ilung@cwlinux.com>
- * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com>
- *
- * Based on SA1100 version written by:
- * - Johan Pouwelse (J.A.Pouwelse@its.tudelft.nl): initial version
- * - Erik Mouw (J.A.K.Mouw@its.tudelft.nl):
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Copyright (C) 2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ */
+
+/*
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
  *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
  */
 
-/*#define DEBUG*/
+/*
+ * A driver for the Freescale Semiconductor i.MXC CPUfreq module.
+ * The CPUFREQ driver is for controlling CPU frequency. It allows you to change
+ * the CPU clock speed on the fly.
+ */
 
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
+#include <linux/module.h>
 #include <linux/cpufreq.h>
 #include <linux/clk.h>
 #include <linux/err.h>
-#include <asm/system.h>
+#include <linux/slab.h>
 
-#include <mach/hardware.h>
+#include "hardware.h"
 
-#include "generic.h"
+#define CLK32_FREQ     32768
+#define NANOSECOND     (1000 * 1000 * 1000)
 
-#ifndef __val2mfld
-#define __val2mfld(mask,val) (((mask)&~((mask)<<1))*(val)&(mask))
-#endif
-#ifndef __mfld2val
-#define __mfld2val(mask,val) (((val)&(mask))/((mask)&~((mask)<<1)))
-#endif
+struct cpu_op *(*get_cpu_op)(int *op);
 
-#define CR_920T_CLOCK_MODE     0xC0000000
-#define CR_920T_FASTBUS_MODE   0x00000000
-#define CR_920T_ASYNC_MODE     0xC0000000
+static int cpu_freq_khz_min;
+static int cpu_freq_khz_max;
 
-static u32 mpctl0_at_boot;
-static u32 bclk_div_at_boot;
+static struct clk *cpu_clk;
+static struct cpufreq_frequency_table *imx_freq_table;
 
-static struct clk *system_clk, *mcu_clk;
+static int cpu_op_nr;
+static struct cpu_op *cpu_op_tbl;
 
-static void imx_set_async_mode(void)
+static int set_cpu_freq(int freq)
 {
-       adjust_cr(CR_920T_CLOCK_MODE, CR_920T_ASYNC_MODE);
-}
+       int ret = 0;
+       int org_cpu_rate;
 
-static void imx_set_fastbus_mode(void)
-{
-       adjust_cr(CR_920T_CLOCK_MODE, CR_920T_FASTBUS_MODE);
+       org_cpu_rate = clk_get_rate(cpu_clk);
+       if (org_cpu_rate == freq)
+               return ret;
+
+       ret = clk_set_rate(cpu_clk, freq);
+       if (ret != 0) {
+               printk(KERN_DEBUG "cannot set CPU clock rate\n");
+               return ret;
+       }
+
+       return ret;
 }
 
-static void imx_set_mpctl0(u32 mpctl0)
+static int mxc_verify_speed(struct cpufreq_policy *policy)
 {
-       unsigned long flags;
-
-       if (mpctl0 == 0) {
-               local_irq_save(flags);
-               CSCR &= ~CSCR_MPEN;
-               local_irq_restore(flags);
-               return;
-       }
+       if (policy->cpu != 0)
+               return -EINVAL;
 
-       local_irq_save(flags);
-       MPCTL0 = mpctl0;
-       CSCR |= CSCR_MPEN;
-       local_irq_restore(flags);
+       return cpufreq_frequency_table_verify(policy, imx_freq_table);
 }
 
-/**
- * imx_compute_mpctl - compute new PLL parameters
- * @new_mpctl: pointer to location assigned by new PLL control register value
- * @cur_mpctl: current PLL control register parameters
- * @f_ref:     reference source frequency Hz
- * @freq:      required frequency in Hz
- * @relation:  is one of %CPUFREQ_RELATION_L (supremum)
- *             and %CPUFREQ_RELATION_H (infimum)
- */
-long imx_compute_mpctl(u32 *new_mpctl, u32 cur_mpctl, u32 f_ref, unsigned long freq, int relation)
+static unsigned int mxc_get_speed(unsigned int cpu)
 {
-        u32 mfi;
-        u32 mfn;
-        u32 mfd;
-        u32 pd;
-       unsigned long long ll;
-       long l;
-       long quot;
-
-       /* Fdppl=2*Fref*(MFI+MFN/(MFD+1))/(PD+1) */
-       /*  PD=<0,15>, MFD=<1,1023>, MFI=<5,15> MFN=<0,1022> */
-
-       if (cur_mpctl) {
-               mfd = ((cur_mpctl >> 16) & 0x3ff) + 1;
-               pd =  ((cur_mpctl >> 26) & 0xf) + 1;
-       } else {
-               pd=2; mfd=313;
-       }
+       if (cpu)
+               return 0;
 
-       /* pd=2; mfd=313; mfi=8; mfn=183; */
-       /* (MFI+MFN/(MFD)) = Fdppl / (2*Fref) * (PD); */
+       return clk_get_rate(cpu_clk) / 1000;
+}
 
-       quot = (f_ref + (1 << 9)) >> 10;
-       l = (freq * pd + quot) / (2 * quot);
-       mfi = l >> 10;
-       mfn = ((l & ((1 << 10) - 1)) * mfd + (1 << 9)) >> 10;
+static int mxc_set_target(struct cpufreq_policy *policy,
+                         unsigned int target_freq, unsigned int relation)
+{
+       struct cpufreq_freqs freqs;
+       int freq_Hz;
+       int ret = 0;
+       unsigned int index;
 
-       mfd -= 1;
-       pd -= 1;
+       cpufreq_frequency_table_target(policy, imx_freq_table,
+                       target_freq, relation, &index);
+       freq_Hz = imx_freq_table[index].frequency * 1000;
 
-       *new_mpctl = ((mfi & 0xf) << 10) | (mfn & 0x3ff) | ((mfd & 0x3ff) << 16)
-               | ((pd & 0xf) << 26);
+       freqs.old = clk_get_rate(cpu_clk) / 1000;
+       freqs.new = freq_Hz / 1000;
+       freqs.cpu = 0;
+       freqs.flags = 0;
+       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
 
-       ll = 2 * (unsigned long long)f_ref * ( (mfi<<16) + (mfn<<16) / (mfd+1) );
-       quot = (pd+1) * (1<<16);
-       ll += quot / 2;
-       do_div(ll, quot);
-       freq = ll;
+       ret = set_cpu_freq(freq_Hz);
 
-       pr_debug(KERN_DEBUG "imx: new PLL parameters pd=%d mfd=%d mfi=%d mfn=%d, freq=%ld\n",
-               pd, mfd, mfi, mfn, freq);
+       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
 
-       return freq;
+       return ret;
 }
 
-
-static int imx_verify_speed(struct cpufreq_policy *policy)
+static int mxc_cpufreq_init(struct cpufreq_policy *policy)
 {
-       if (policy->cpu != 0)
-               return -EINVAL;
-
-       cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, policy->cpuinfo.max_freq);
+       int ret;
+       int i;
 
-       return 0;
-}
+       printk(KERN_INFO "i.MXC CPU frequency driver\n");
 
-static unsigned int imx_get_speed(unsigned int cpu)
-{
-       unsigned int freq;
-       unsigned int cr;
-       unsigned int cscr;
-       unsigned int bclk_div;
+       if (policy->cpu != 0)
+               return -EINVAL;
 
-       if (cpu)
-               return 0;
+       if (!get_cpu_op)
+               return -EINVAL;
 
-       cscr = CSCR;
-       bclk_div = __mfld2val(CSCR_BCLK_DIV, cscr) + 1;
-       cr = get_cr();
-
-       if((cr & CR_920T_CLOCK_MODE) == CR_920T_FASTBUS_MODE) {
-               freq = clk_get_rate(system_clk);
-               freq = (freq + bclk_div/2) / bclk_div;
-       } else {
-               freq = clk_get_rate(mcu_clk);
-               if (cscr & CSCR_MPU_PRESC)
-                       freq /= 2;
+       cpu_clk = clk_get(NULL, "cpu_clk");
+       if (IS_ERR(cpu_clk)) {
+               printk(KERN_ERR "%s: failed to get cpu clock\n", __func__);
+               return PTR_ERR(cpu_clk);
        }
 
-       freq = (freq + 500) / 1000;
+       cpu_op_tbl = get_cpu_op(&cpu_op_nr);
 
-       return freq;
-}
+       cpu_freq_khz_min = cpu_op_tbl[0].cpu_rate / 1000;
+       cpu_freq_khz_max = cpu_op_tbl[0].cpu_rate / 1000;
 
-static int imx_set_target(struct cpufreq_policy *policy,
-                         unsigned int target_freq,
-                         unsigned int relation)
-{
-       struct cpufreq_freqs freqs;
-       u32 mpctl0 = 0;
-       u32 cscr;
-       unsigned long flags;
-       long freq;
-       long sysclk;
-       unsigned int bclk_div = bclk_div_at_boot;
-
-       /*
-        * Some governors do not respects CPU and policy lower limits
-        * which leads to bad things (division by zero etc), ensure
-        * that such things do not happen.
-        */
-       if(target_freq < policy->cpuinfo.min_freq)
-               target_freq = policy->cpuinfo.min_freq;
-
-       if(target_freq < policy->min)
-               target_freq = policy->min;
-
-       freq = target_freq * 1000;
-
-       pr_debug(KERN_DEBUG "imx: requested frequency %ld Hz, mpctl0 at boot 0x%08x\n",
-                       freq, mpctl0_at_boot);
-
-       sysclk = clk_get_rate(system_clk);
-
-       if (freq > sysclk / bclk_div_at_boot + 1000000) {
-               freq = imx_compute_mpctl(&mpctl0, mpctl0_at_boot, CLK32 * 512, freq, relation);
-               if (freq < 0) {
-                       printk(KERN_WARNING "imx: target frequency %ld Hz cannot be set\n", freq);
-                       return -EINVAL;
-               }
-       } else {
-               if(freq + 1000 < sysclk) {
-                       if (relation == CPUFREQ_RELATION_L)
-                               bclk_div = (sysclk - 1000) / freq;
-                       else
-                               bclk_div = (sysclk + freq + 1000) / freq;
-
-                       if(bclk_div > 16)
-                               bclk_div = 16;
-                       if(bclk_div < bclk_div_at_boot)
-                               bclk_div = bclk_div_at_boot;
-               }
-               freq = (sysclk + bclk_div / 2) / bclk_div;
+       imx_freq_table = kmalloc(
+               sizeof(struct cpufreq_frequency_table) * (cpu_op_nr + 1),
+                       GFP_KERNEL);
+       if (!imx_freq_table) {
+               ret = -ENOMEM;
+               goto err1;
        }
 
-       freqs.old = imx_get_speed(0);
-       freqs.new = (freq + 500) / 1000;
-       freqs.cpu = 0;
-       freqs.flags = 0;
+       for (i = 0; i < cpu_op_nr; i++) {
+               imx_freq_table[i].index = i;
+               imx_freq_table[i].frequency = cpu_op_tbl[i].cpu_rate / 1000;
 
-       cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
+               if ((cpu_op_tbl[i].cpu_rate / 1000) < cpu_freq_khz_min)
+                       cpu_freq_khz_min = cpu_op_tbl[i].cpu_rate / 1000;
 
-       local_irq_save(flags);
-
-       imx_set_fastbus_mode();
+               if ((cpu_op_tbl[i].cpu_rate / 1000) > cpu_freq_khz_max)
+                       cpu_freq_khz_max = cpu_op_tbl[i].cpu_rate / 1000;
+       }
 
-       imx_set_mpctl0(mpctl0);
+       imx_freq_table[i].index = i;
+       imx_freq_table[i].frequency = CPUFREQ_TABLE_END;
 
-       cscr = CSCR;
-       cscr &= ~CSCR_BCLK_DIV;
-       cscr |= __val2mfld(CSCR_BCLK_DIV, bclk_div - 1);
-       CSCR = cscr;
+       policy->cur = clk_get_rate(cpu_clk) / 1000;
+       policy->min = policy->cpuinfo.min_freq = cpu_freq_khz_min;
+       policy->max = policy->cpuinfo.max_freq = cpu_freq_khz_max;
 
-       if(mpctl0) {
-               CSCR |= CSCR_MPLL_RESTART;
+       /* Manual states, that PLL stabilizes in two CLK32 periods */
+       policy->cpuinfo.transition_latency = 2 * NANOSECOND / CLK32_FREQ;
 
-               /* Wait until MPLL is stabilized */
-               while( CSCR & CSCR_MPLL_RESTART );
+       ret = cpufreq_frequency_table_cpuinfo(policy, imx_freq_table);
 
-               imx_set_async_mode();
+       if (ret < 0) {
+               printk(KERN_ERR "%s: failed to register i.MXC CPUfreq with error code %d\n",
+                      __func__, ret);
+               goto err;
        }
 
-       local_irq_restore(flags);
-
-       cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-       pr_debug(KERN_INFO "imx: set frequency %ld Hz, running from %s\n",
-                       freq, mpctl0? "MPLL": "SPLL");
-
+       cpufreq_frequency_table_get_attr(imx_freq_table, policy->cpu);
        return 0;
+err:
+       kfree(imx_freq_table);
+err1:
+       clk_put(cpu_clk);
+       return ret;
 }
 
-static int __init imx_cpufreq_driver_init(struct cpufreq_policy *policy)
+static int mxc_cpufreq_exit(struct cpufreq_policy *policy)
 {
-       printk(KERN_INFO "i.MX cpu freq change driver v1.0\n");
+       cpufreq_frequency_table_put_attr(policy->cpu);
 
-       if (policy->cpu != 0)
-               return -EINVAL;
-
-       policy->cur = policy->min = policy->max = imx_get_speed(0);
-       policy->cpuinfo.min_freq = 8000;
-       policy->cpuinfo.max_freq = 200000;
-        /* Manual states, that PLL stabilizes in two CLK32 periods */
-       policy->cpuinfo.transition_latency = 4 * 1000000000LL / CLK32;
+       set_cpu_freq(cpu_freq_khz_max * 1000);
+       clk_put(cpu_clk);
+       kfree(imx_freq_table);
        return 0;
 }
 
-static struct cpufreq_driver imx_driver = {
-       .flags          = CPUFREQ_STICKY,
-       .verify         = imx_verify_speed,
-       .target         = imx_set_target,
-       .get            = imx_get_speed,
-       .init           = imx_cpufreq_driver_init,
-       .name           = "imx",
+static struct cpufreq_driver mxc_driver = {
+       .flags = CPUFREQ_STICKY,
+       .verify = mxc_verify_speed,
+       .target = mxc_set_target,
+       .get = mxc_get_speed,
+       .init = mxc_cpufreq_init,
+       .exit = mxc_cpufreq_exit,
+       .name = "imx",
 };
 
-static int __init imx_cpufreq_init(void)
+static int __devinit mxc_cpufreq_driver_init(void)
 {
-       bclk_div_at_boot = __mfld2val(CSCR_BCLK_DIV, CSCR) + 1;
-       mpctl0_at_boot = 0;
-
-       system_clk = clk_get(NULL, "system_clk");
-       if (IS_ERR(system_clk))
-               return PTR_ERR(system_clk);
-
-       mcu_clk = clk_get(NULL, "mcu_clk");
-       if (IS_ERR(mcu_clk)) {
-               clk_put(system_clk);
-               return PTR_ERR(mcu_clk);
-       }
-
-       if((CSCR & CSCR_MPEN) &&
-          ((get_cr() & CR_920T_CLOCK_MODE) != CR_920T_FASTBUS_MODE))
-               mpctl0_at_boot = MPCTL0;
+       return cpufreq_register_driver(&mxc_driver);
+}
 
-       return cpufreq_register_driver(&imx_driver);
+static void mxc_cpufreq_driver_exit(void)
+{
+       cpufreq_unregister_driver(&mxc_driver);
 }
 
-arch_initcall(imx_cpufreq_init);
+module_init(mxc_cpufreq_driver_init);
+module_exit(mxc_cpufreq_driver_exit);
 
+MODULE_AUTHOR("Freescale Semiconductor Inc. Yong Shen <yong.shen@linaro.org>");
+MODULE_DESCRIPTION("CPUfreq driver for i.MX");
+MODULE_LICENSE("GPL");