Logo Search packages:      
Sourcecode: linux version File versions

cpu.c

/*
 *  linux/arch/arm/mach-integrator/cpu.c
 *
 *  Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
 *
 * 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 <linux/io.h>

#include <mach/hardware.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->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);

Generated by  Doxygen 1.6.0   Back to index