drivers/cpufreq/integrator-cpufreq.c

   1 /*
   2  *  Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * CPU support functions
   9  */
  10 #include <linux/module.h>
  11 #include <linux/types.h>
  12 #include <linux/kernel.h>
  13 #include <linux/cpufreq.h>
  14 #include <linux/sched.h>
  15 #include <linux/smp.h>
  16 #include <linux/init.h>
  17 #include <linux/io.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/of.h>
  20 #include <linux/of_address.h>
  21
  22 #include <asm/mach-types.h>
  23 #include <asm/hardware/icst.h>
  24
  25 static void __iomem *cm_base;
  26 /* The cpufreq driver only use the OSC register */
  27 #define INTEGRATOR_HDR_OSC_OFFSET       0x08
  28 #define INTEGRATOR_HDR_LOCK_OFFSET      0x14
  29
  30 static struct cpufreq_driver integrator_driver;
  31
  32 static const struct icst_params lclk_params = {
  33         .ref            = 24000000,
  34         .vco_max        = ICST525_VCO_MAX_5V,
  35         .vco_min        = ICST525_VCO_MIN,
  36         .vd_min         = 8,
  37         .vd_max         = 132,
  38         .rd_min         = 24,
  39         .rd_max         = 24,
  40         .s2div          = icst525_s2div,
  41         .idx2s          = icst525_idx2s,
  42 };
  43
  44 static const struct icst_params cclk_params = {
  45         .ref            = 24000000,
  46         .vco_max        = ICST525_VCO_MAX_5V,
  47         .vco_min        = ICST525_VCO_MIN,
  48         .vd_min         = 12,
  49         .vd_max         = 160,
  50         .rd_min         = 24,
  51         .rd_max         = 24,
  52         .s2div          = icst525_s2div,
  53         .idx2s          = icst525_idx2s,
  54 };
  55
  56 /*
  57  * Validate the speed policy.
  58  */
  59 static int integrator_verify_policy(struct cpufreq_policy *policy)
  60 {
  61         struct icst_vco vco;
  62
  63         cpufreq_verify_within_cpu_limits(policy);
  64
  65         vco = icst_hz_to_vco(&cclk_params, policy->max * 1000);
  66         policy->max = icst_hz(&cclk_params, vco) / 1000;
  67
  68         vco = icst_hz_to_vco(&cclk_params, policy->min * 1000);
  69         policy->min = icst_hz(&cclk_params, vco) / 1000;
  70
  71         cpufreq_verify_within_cpu_limits(policy);
  72         return 0;
  73 }
  74
  75
  76 static int integrator_set_target(struct cpufreq_policy *policy,
  77                                  unsigned int target_freq,
  78                                  unsigned int relation)
  79 {
  80         cpumask_t cpus_allowed;
  81         int cpu = policy->cpu;
  82         struct icst_vco vco;
  83         struct cpufreq_freqs freqs;
  84         u_int cm_osc;
  85
  86         /*
  87          * Save this threads cpus_allowed mask.
  88          */
  89         cpus_allowed = current->cpus_allowed;
  90
  91         /*
  92          * Bind to the specified CPU.  When this call returns,
  93          * we should be running on the right CPU.
  94          */
  95         set_cpus_allowed_ptr(current, cpumask_of(cpu));
  96         BUG_ON(cpu != smp_processor_id());
  97
  98         /* get current setting */
  99         cm_osc = __raw_readl(cm_base + INTEGRATOR_HDR_OSC_OFFSET);
 100
 101         if (machine_is_integrator()) {
 102                 vco.s = (cm_osc >> 8) & 7;
 103         } else if (machine_is_cintegrator()) {
 104                 vco.s = 1;
 105         }
 106         vco.v = cm_osc & 255;
 107         vco.r = 22;
 108         freqs.old = icst_hz(&cclk_params, vco) / 1000;
 109
 110         /* icst_hz_to_vco rounds down -- so we need the next
 111          * larger freq in case of CPUFREQ_RELATION_L.
 112          */
 113         if (relation == CPUFREQ_RELATION_L)
 114                 target_freq += 999;
 115         if (target_freq > policy->max)
 116                 target_freq = policy->max;
 117         vco = icst_hz_to_vco(&cclk_params, target_freq * 1000);
 118         freqs.new = icst_hz(&cclk_params, vco) / 1000;
 119
 120         if (freqs.old == freqs.new) {
 121                 set_cpus_allowed_ptr(current, &cpus_allowed);
 122                 return 0;
 123         }
 124
 125         cpufreq_freq_transition_begin(policy, &freqs);
 126
 127         cm_osc = __raw_readl(cm_base + INTEGRATOR_HDR_OSC_OFFSET);
 128
 129         if (machine_is_integrator()) {
 130                 cm_osc &= 0xfffff800;
 131                 cm_osc |= vco.s << 8;
 132         } else if (machine_is_cintegrator()) {
 133                 cm_osc &= 0xffffff00;
 134         }
 135         cm_osc |= vco.v;
 136
 137         __raw_writel(0xa05f, cm_base + INTEGRATOR_HDR_LOCK_OFFSET);
 138         __raw_writel(cm_osc, cm_base + INTEGRATOR_HDR_OSC_OFFSET);
 139         __raw_writel(0, cm_base + INTEGRATOR_HDR_LOCK_OFFSET);
 140
 141         /*
 142          * Restore the CPUs allowed mask.
 143          */
 144         set_cpus_allowed_ptr(current, &cpus_allowed);
 145
 146         cpufreq_freq_transition_end(policy, &freqs, 0);
 147
 148         return 0;
 149 }
 150
 151 static unsigned int integrator_get(unsigned int cpu)
 152 {
 153         cpumask_t cpus_allowed;
 154         unsigned int current_freq;
 155         u_int cm_osc;
 156         struct icst_vco vco;
 157
 158         cpus_allowed = current->cpus_allowed;
 159
 160         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 161         BUG_ON(cpu != smp_processor_id());
 162
 163         /* detect memory etc. */
 164         cm_osc = __raw_readl(cm_base + INTEGRATOR_HDR_OSC_OFFSET);
 165
 166         if (machine_is_integrator()) {
 167                 vco.s = (cm_osc >> 8) & 7;
 168         } else {
 169                 vco.s = 1;
 170         }
 171         vco.v = cm_osc & 255;
 172         vco.r = 22;
 173
 174         current_freq = icst_hz(&cclk_params, vco) / 1000; /* current freq */
 175
 176         set_cpus_allowed_ptr(current, &cpus_allowed);
 177
 178         return current_freq;
 179 }
 180
 181 static int integrator_cpufreq_init(struct cpufreq_policy *policy)
 182 {
 183
 184         /* set default policy and cpuinfo */
 185         policy->max = policy->cpuinfo.max_freq = 160000;
 186         policy->min = policy->cpuinfo.min_freq = 12000;
 187         policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */
 188
 189         return 0;
 190 }
 191
 192 static struct cpufreq_driver integrator_driver = {
 193         .flags          = CPUFREQ_NEED_INITIAL_FREQ_CHECK,
 194         .verify         = integrator_verify_policy,
 195         .target         = integrator_set_target,
 196         .get            = integrator_get,
 197         .init           = integrator_cpufreq_init,
 198         .name           = "integrator",
 199 };
 200
 201 static int __init integrator_cpufreq_probe(struct platform_device *pdev)
 202 {
 203         struct resource *res;
 204
 205         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 206         if (!res)
 207                 return -ENODEV;
 208
 209         cm_base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 210         if (!cm_base)
 211                 return -ENODEV;
 212
 213         return cpufreq_register_driver(&integrator_driver);
 214 }
 215
 216 static int __exit integrator_cpufreq_remove(struct platform_device *pdev)
 217 {
 218         return cpufreq_unregister_driver(&integrator_driver);
 219 }
 220
 221 static const struct of_device_id integrator_cpufreq_match[] = {
 222         { .compatible = "arm,core-module-integrator"},
 223         { },
 224 };
 225
 226 static struct platform_driver integrator_cpufreq_driver = {
 227         .driver = {
 228                 .name = "integrator-cpufreq",
 229                 .of_match_table = integrator_cpufreq_match,
 230         },
 231         .remove = __exit_p(integrator_cpufreq_remove),
 232 };
 233
 234 module_platform_driver_probe(integrator_cpufreq_driver,
 235                              integrator_cpufreq_probe);
 236
 237 MODULE_AUTHOR ("Russell M. King");
 238 MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs");
 239 MODULE_LICENSE ("GPL");