/* * linux/arch/arm/mach-integrator/cpu.c * * Copyright (C) 2001-2002 Deep Blue Solutions Ltd. * * $Id: cpu.c,v 1.6 2002/07/18 13:58:51 rmk Exp $ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * CPU support functions */ #include <linux/module.h> #include <linux/types.h> #include <linux/kernel.h> #include <linux/cpufreq.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/smp.h> #include <linux/init.h> #include <asm/hardware.h> #include <asm/io.h> #include <asm/mach-types.h> #include <asm/hardware/icst525.h> static struct cpufreq_driver integrator_driver; #define CM_ID (IO_ADDRESS(INTEGRATOR_HDR_BASE)+INTEGRATOR_HDR_ID_OFFSET) #define CM_OSC (IO_ADDRESS(INTEGRATOR_HDR_BASE)+INTEGRATOR_HDR_OSC_OFFSET) #define CM_STAT (IO_ADDRESS(INTEGRATOR_HDR_BASE)+INTEGRATOR_HDR_STAT_OFFSET) #define CM_LOCK (IO_ADDRESS(INTEGRATOR_HDR_BASE)+INTEGRATOR_HDR_LOCK_OFFSET) static const struct icst525_params lclk_params = { .ref = 24000, .vco_max = 320000, .vd_min = 8, .vd_max = 132, .rd_min = 24, .rd_max = 24, }; static const struct icst525_params cclk_params = { .ref = 24000, .vco_max = 320000, .vd_min = 12, .vd_max = 160, .rd_min = 24, .rd_max = 24, }; /* * Validate the speed policy. */ static int integrator_verify_policy(struct cpufreq_policy *policy) { struct icst525_vco vco; cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, policy->cpuinfo.max_freq); vco = icst525_khz_to_vco(&cclk_params, policy->max); policy->max = icst525_khz(&cclk_params, vco); vco = icst525_khz_to_vco(&cclk_params, policy->min); policy->min = icst525_khz(&cclk_params, vco); cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, policy->cpuinfo.max_freq); return 0; } static int integrator_set_target(struct cpufreq_policy *policy, unsigned int target_freq, unsigned int relation) { cpumask_t cpus_allowed; int cpu = policy->cpu; struct icst525_vco vco; struct cpufreq_freqs freqs; u_int cm_osc; /* * Save this threads cpus_allowed mask. */ cpus_allowed = current->cpus_allowed; /* * Bind to the specified CPU. When this call returns, * we should be running on the right CPU. */ set_cpus_allowed(current, cpumask_of_cpu(cpu)); BUG_ON(cpu != smp_processor_id()); /* get current setting */ cm_osc = __raw_readl(CM_OSC); if (machine_is_integrator()) { vco.s = (cm_osc >> 8) & 7; } else if (machine_is_cintegrator()) { vco.s = 1; } vco.v = cm_osc & 255; vco.r = 22; freqs.old = icst525_khz(&cclk_params, vco); /* icst525_khz_to_vco rounds down -- so we need the next * larger freq in case of CPUFREQ_RELATION_L. */ if (relation == CPUFREQ_RELATION_L) target_freq += 999; if (target_freq > policy->max) target_freq = policy->max; vco = icst525_khz_to_vco(&cclk_params, target_freq); freqs.new = icst525_khz(&cclk_params, vco); freqs.cpu = policy->cpu; if (freqs.old == freqs.new) { set_cpus_allowed(current, cpus_allowed); return 0; } cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); cm_osc = __raw_readl(CM_OSC); if (machine_is_integrator()) { cm_osc &= 0xfffff800; cm_osc |= vco.s << 8; } else if (machine_is_cintegrator()) { cm_osc &= 0xffffff00; } cm_osc |= vco.v; __raw_writel(0xa05f, CM_LOCK); __raw_writel(cm_osc, CM_OSC); __raw_writel(0, CM_LOCK); /* * Restore the CPUs allowed mask. */ set_cpus_allowed(current, cpus_allowed); cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); return 0; } static unsigned int integrator_get(unsigned int cpu) { cpumask_t cpus_allowed; unsigned int current_freq; u_int cm_osc; struct icst525_vco vco; cpus_allowed = current->cpus_allowed; set_cpus_allowed(current, cpumask_of_cpu(cpu)); BUG_ON(cpu != smp_processor_id()); /* detect memory etc. */ cm_osc = __raw_readl(CM_OSC); if (machine_is_integrator()) { vco.s = (cm_osc >> 8) & 7; } else if (machine_is_cintegrator()) { vco.s = 1; } vco.v = cm_osc & 255; vco.r = 22; current_freq = icst525_khz(&cclk_params, vco); /* current freq */ set_cpus_allowed(current, cpus_allowed); return current_freq; } static int integrator_cpufreq_init(struct cpufreq_policy *policy) { /* set default policy and cpuinfo */ policy->governor = CPUFREQ_DEFAULT_GOVERNOR; policy->cpuinfo.max_freq = 160000; policy->cpuinfo.min_freq = 12000; policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */ policy->cur = policy->min = policy->max = integrator_get(policy->cpu); return 0; } static struct cpufreq_driver integrator_driver = { .verify = integrator_verify_policy, .target = integrator_set_target, .get = integrator_get, .init = integrator_cpufreq_init, .name = "integrator", }; static int __init integrator_cpu_init(void) { return cpufreq_register_driver(&integrator_driver); } static void __exit integrator_cpu_exit(void) { cpufreq_unregister_driver(&integrator_driver); } MODULE_AUTHOR ("Russell M. King"); MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs"); MODULE_LICENSE ("GPL"); module_init(integrator_cpu_init); module_exit(integrator_cpu_exit);