drivers/cpufreq/pasemi-cpufreq.c

   1 /*
   2  * Copyright (C) 2007 PA Semi, Inc
   3  *
   4  * Authors: Egor Martovetsky <egor@pasemi.com>
   5  *          Olof Johansson <olof@lixom.net>
   6  *
   7  * Maintained by: Olof Johansson <olof@lixom.net>
   8  *
   9  * Based on arch/powerpc/platforms/cell/cbe_cpufreq.c:
  10  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2, or (at your option)
  15  * any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  *
  26  */
  27
  28 #include <linux/cpufreq.h>
  29 #include <linux/timer.h>
  30 #include <linux/module.h>
  31 #include <linux/of_address.h>
  32
  33 #include <asm/hw_irq.h>
  34 #include <asm/io.h>
  35 #include <asm/prom.h>
  36 #include <asm/time.h>
  37 #include <asm/smp.h>
  38
  39 #define SDCASR_REG              0x0100
  40 #define SDCASR_REG_STRIDE       0x1000
  41 #define SDCPWR_CFGA0_REG        0x0100
  42 #define SDCPWR_PWST0_REG        0x0000
  43 #define SDCPWR_GIZTIME_REG      0x0440
  44
  45 /* SDCPWR_GIZTIME_REG fields */
  46 #define SDCPWR_GIZTIME_GR       0x80000000
  47 #define SDCPWR_GIZTIME_LONGLOCK 0x000000ff
  48
  49 /* Offset of ASR registers from SDC base */
  50 #define SDCASR_OFFSET           0x120000
  51
  52 static void __iomem *sdcpwr_mapbase;
  53 static void __iomem *sdcasr_mapbase;
  54
  55 static DEFINE_MUTEX(pas_switch_mutex);
  56
  57 /* Current astate, is used when waking up from power savings on
  58  * one core, in case the other core has switched states during
  59  * the idle time.
  60  */
  61 static int current_astate;
  62
  63 /* We support 5(A0-A4) power states excluding turbo(A5-A6) modes */
  64 static struct cpufreq_frequency_table pas_freqs[] = {
  65         {0,     0},
  66         {1,     0},
  67         {2,     0},
  68         {3,     0},
  69         {4,     0},
  70         {0,     CPUFREQ_TABLE_END},
  71 };
  72
  73 /*
  74  * hardware specific functions
  75  */
  76
  77 static int get_astate_freq(int astate)
  78 {
  79         u32 ret;
  80         ret = in_le32(sdcpwr_mapbase + SDCPWR_CFGA0_REG + (astate * 0x10));
  81
  82         return ret & 0x3f;
  83 }
  84
  85 static int get_cur_astate(int cpu)
  86 {
  87         u32 ret;
  88
  89         ret = in_le32(sdcpwr_mapbase + SDCPWR_PWST0_REG);
  90         ret = (ret >> (cpu * 4)) & 0x7;
  91
  92         return ret;
  93 }
  94
  95 static int get_gizmo_latency(void)
  96 {
  97         u32 giztime, ret;
  98
  99         giztime = in_le32(sdcpwr_mapbase + SDCPWR_GIZTIME_REG);
 100
 101         /* just provide the upper bound */
 102         if (giztime & SDCPWR_GIZTIME_GR)
 103                 ret = (giztime & SDCPWR_GIZTIME_LONGLOCK) * 128000;
 104         else
 105                 ret = (giztime & SDCPWR_GIZTIME_LONGLOCK) * 1000;
 106
 107         return ret;
 108 }
 109
 110 static void set_astate(int cpu, unsigned int astate)
 111 {
 112         unsigned long flags;
 113
 114         /* Return if called before init has run */
 115         if (unlikely(!sdcasr_mapbase))
 116                 return;
 117
 118         local_irq_save(flags);
 119
 120         out_le32(sdcasr_mapbase + SDCASR_REG + SDCASR_REG_STRIDE*cpu, astate);
 121
 122         local_irq_restore(flags);
 123 }
 124
 125 int check_astate(void)
 126 {
 127         return get_cur_astate(hard_smp_processor_id());
 128 }
 129
 130 void restore_astate(int cpu)
 131 {
 132         set_astate(cpu, current_astate);
 133 }
 134
 135 /*
 136  * cpufreq functions
 137  */
 138
 139 static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
 140 {
 141         const u32 *max_freqp;
 142         u32 max_freq;
 143         int i, cur_astate;
 144         struct resource res;
 145         struct device_node *cpu, *dn;
 146         int err = -ENODEV;
 147
 148         cpu = of_get_cpu_node(policy->cpu, NULL);
 149
 150         if (!cpu)
 151                 goto out;
 152
 153         dn = of_find_compatible_node(NULL, NULL, "1682m-sdc");
 154         if (!dn)
 155                 dn = of_find_compatible_node(NULL, NULL,
 156                                              "pasemi,pwrficient-sdc");
 157         if (!dn)
 158                 goto out;
 159         err = of_address_to_resource(dn, 0, &res);
 160         of_node_put(dn);
 161         if (err)
 162                 goto out;
 163         sdcasr_mapbase = ioremap(res.start + SDCASR_OFFSET, 0x2000);
 164         if (!sdcasr_mapbase) {
 165                 err = -EINVAL;
 166                 goto out;
 167         }
 168
 169         dn = of_find_compatible_node(NULL, NULL, "1682m-gizmo");
 170         if (!dn)
 171                 dn = of_find_compatible_node(NULL, NULL,
 172                                              "pasemi,pwrficient-gizmo");
 173         if (!dn) {
 174                 err = -ENODEV;
 175                 goto out_unmap_sdcasr;
 176         }
 177         err = of_address_to_resource(dn, 0, &res);
 178         of_node_put(dn);
 179         if (err)
 180                 goto out_unmap_sdcasr;
 181         sdcpwr_mapbase = ioremap(res.start, 0x1000);
 182         if (!sdcpwr_mapbase) {
 183                 err = -EINVAL;
 184                 goto out_unmap_sdcasr;
 185         }
 186
 187         pr_debug("init cpufreq on CPU %d\n", policy->cpu);
 188
 189         max_freqp = of_get_property(cpu, "clock-frequency", NULL);
 190         if (!max_freqp) {
 191                 err = -EINVAL;
 192                 goto out_unmap_sdcpwr;
 193         }
 194
 195         /* we need the freq in kHz */
 196         max_freq = *max_freqp / 1000;
 197
 198         pr_debug("max clock-frequency is at %u kHz\n", max_freq);
 199         pr_debug("initializing frequency table\n");
 200
 201         /* initialize frequency table */
 202         for (i=0; pas_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
 203                 pas_freqs[i].frequency =
 204                         get_astate_freq(pas_freqs[i].driver_data) * 100000;
 205                 pr_debug("%d: %d\n", i, pas_freqs[i].frequency);
 206         }
 207
 208         cur_astate = get_cur_astate(policy->cpu);
 209         pr_debug("current astate is at %d\n",cur_astate);
 210
 211         policy->cur = pas_freqs[cur_astate].frequency;
 212         ppc_proc_freq = policy->cur * 1000ul;
 213
 214         return cpufreq_generic_init(policy, pas_freqs, get_gizmo_latency());
 215
 216 out_unmap_sdcpwr:
 217         iounmap(sdcpwr_mapbase);
 218
 219 out_unmap_sdcasr:
 220         iounmap(sdcasr_mapbase);
 221 out:
 222         return err;
 223 }
 224
 225 static int pas_cpufreq_cpu_exit(struct cpufreq_policy *policy)
 226 {
 227         /*
 228          * We don't support CPU hotplug. Don't unmap after the system
 229          * has already made it to a running state.
 230          */
 231         if (system_state != SYSTEM_BOOTING)
 232                 return 0;
 233
 234         if (sdcasr_mapbase)
 235                 iounmap(sdcasr_mapbase);
 236         if (sdcpwr_mapbase)
 237                 iounmap(sdcpwr_mapbase);
 238
 239         cpufreq_frequency_table_put_attr(policy->cpu);
 240         return 0;
 241 }
 242
 243 static int pas_cpufreq_target(struct cpufreq_policy *policy,
 244                               unsigned int target_freq,
 245                               unsigned int relation)
 246 {
 247         struct cpufreq_freqs freqs;
 248         int pas_astate_new;
 249         int i;
 250
 251         cpufreq_frequency_table_target(policy,
 252                                        pas_freqs,
 253                                        target_freq,
 254                                        relation,
 255                                        &pas_astate_new);
 256
 257         freqs.old = policy->cur;
 258         freqs.new = pas_freqs[pas_astate_new].frequency;
 259
 260         mutex_lock(&pas_switch_mutex);
 261         cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
 262
 263         pr_debug("setting frequency for cpu %d to %d kHz, 1/%d of max frequency\n",
 264                  policy->cpu,
 265                  pas_freqs[pas_astate_new].frequency,
 266                  pas_freqs[pas_astate_new].driver_data);
 267
 268         current_astate = pas_astate_new;
 269
 270         for_each_online_cpu(i)
 271                 set_astate(i, pas_astate_new);
 272
 273         cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
 274         mutex_unlock(&pas_switch_mutex);
 275
 276         ppc_proc_freq = freqs.new * 1000ul;
 277         return 0;
 278 }
 279
 280 static struct cpufreq_driver pas_cpufreq_driver = {
 281         .name           = "pas-cpufreq",
 282         .flags          = CPUFREQ_CONST_LOOPS,
 283         .init           = pas_cpufreq_cpu_init,
 284         .exit           = pas_cpufreq_cpu_exit,
 285         .verify         = cpufreq_generic_frequency_table_verify,
 286         .target         = pas_cpufreq_target,
 287         .attr           = cpufreq_generic_attr,
 288 };
 289
 290 /*
 291  * module init and destoy
 292  */
 293
 294 static int __init pas_cpufreq_init(void)
 295 {
 296         if (!of_machine_is_compatible("PA6T-1682M") &&
 297             !of_machine_is_compatible("pasemi,pwrficient"))
 298                 return -ENODEV;
 299
 300         return cpufreq_register_driver(&pas_cpufreq_driver);
 301 }
 302
 303 static void __exit pas_cpufreq_exit(void)
 304 {
 305         cpufreq_unregister_driver(&pas_cpufreq_driver);
 306 }
 307
 308 module_init(pas_cpufreq_init);
 309 module_exit(pas_cpufreq_exit);
 310
 311 MODULE_LICENSE("GPL");
 312 MODULE_AUTHOR("Egor Martovetsky <egor@pasemi.com>, Olof Johansson <olof@lixom.net>");