arch/arm/mach-vexpress/tc2_pm.c

   1 /*
   2  * arch/arm/mach-vexpress/tc2_pm.c - TC2 power management support
   3  *
   4  * Created by:  Nicolas Pitre, October 2012
   5  * Copyright:   (C) 2012-2013  Linaro Limited
   6  *
   7  * Some portions of this file were originally written by Achin Gupta
   8  * Copyright:   (C) 2012  ARM Limited
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/io.h>
  17 #include <linux/kernel.h>
  18 #include <linux/of_address.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/errno.h>
  21 #include <linux/irqchip/arm-gic.h>
  22
  23 #include <asm/mcpm.h>
  24 #include <asm/proc-fns.h>
  25 #include <asm/cacheflush.h>
  26 #include <asm/cputype.h>
  27 #include <asm/cp15.h>
  28
  29 #include <linux/arm-cci.h>
  30
  31 #include "spc.h"
  32
  33 /* SCC conf registers */
  34 #define A15_CONF                0x400
  35 #define A7_CONF                 0x500
  36 #define SYS_INFO                0x700
  37 #define SPC_BASE                0xb00
  38
  39 /*
  40  * We can't use regular spinlocks. In the switcher case, it is possible
  41  * for an outbound CPU to call power_down() after its inbound counterpart
  42  * is already live using the same logical CPU number which trips lockdep
  43  * debugging.
  44  */
  45 static arch_spinlock_t tc2_pm_lock = __ARCH_SPIN_LOCK_UNLOCKED;
  46
  47 #define TC2_CLUSTERS                    2
  48 #define TC2_MAX_CPUS_PER_CLUSTER        3
  49
  50 static unsigned int tc2_nr_cpus[TC2_CLUSTERS];
  51
  52 /* Keep per-cpu usage count to cope with unordered up/down requests */
  53 static int tc2_pm_use_count[TC2_MAX_CPUS_PER_CLUSTER][TC2_CLUSTERS];
  54
  55 #define tc2_cluster_unused(cluster) \
  56         (!tc2_pm_use_count[0][cluster] && \
  57          !tc2_pm_use_count[1][cluster] && \
  58          !tc2_pm_use_count[2][cluster])
  59
  60 static int tc2_pm_power_up(unsigned int cpu, unsigned int cluster)
  61 {
  62         pr_debug("%s: cpu %u cluster %u\n", __func__, cpu, cluster);
  63         if (cluster >= TC2_CLUSTERS || cpu >= tc2_nr_cpus[cluster])
  64                 return -EINVAL;
  65
  66         /*
  67          * Since this is called with IRQs enabled, and no arch_spin_lock_irq
  68          * variant exists, we need to disable IRQs manually here.
  69          */
  70         local_irq_disable();
  71         arch_spin_lock(&tc2_pm_lock);
  72
  73         if (tc2_cluster_unused(cluster))
  74                 ve_spc_powerdown(cluster, false);
  75
  76         tc2_pm_use_count[cpu][cluster]++;
  77         if (tc2_pm_use_count[cpu][cluster] == 1) {
  78                 ve_spc_set_resume_addr(cluster, cpu,
  79                                        virt_to_phys(mcpm_entry_point));
  80                 ve_spc_cpu_wakeup_irq(cluster, cpu, true);
  81         } else if (tc2_pm_use_count[cpu][cluster] != 2) {
  82                 /*
  83                  * The only possible values are:
  84                  * 0 = CPU down
  85                  * 1 = CPU (still) up
  86                  * 2 = CPU requested to be up before it had a chance
  87                  *     to actually make itself down.
  88                  * Any other value is a bug.
  89                  */
  90                 BUG();
  91         }
  92
  93         arch_spin_unlock(&tc2_pm_lock);
  94         local_irq_enable();
  95
  96         return 0;
  97 }
  98
  99 static void tc2_pm_down(u64 residency)
 100 {
 101         unsigned int mpidr, cpu, cluster;
 102         bool last_man = false, skip_wfi = false;
 103
 104         mpidr = read_cpuid_mpidr();
 105         cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);
 106         cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);
 107
 108         pr_debug("%s: cpu %u cluster %u\n", __func__, cpu, cluster);
 109         BUG_ON(cluster >= TC2_CLUSTERS || cpu >= TC2_MAX_CPUS_PER_CLUSTER);
 110
 111         __mcpm_cpu_going_down(cpu, cluster);
 112
 113         arch_spin_lock(&tc2_pm_lock);
 114         BUG_ON(__mcpm_cluster_state(cluster) != CLUSTER_UP);
 115         tc2_pm_use_count[cpu][cluster]--;
 116         if (tc2_pm_use_count[cpu][cluster] == 0) {
 117                 ve_spc_cpu_wakeup_irq(cluster, cpu, true);
 118                 if (tc2_cluster_unused(cluster)) {
 119                         ve_spc_powerdown(cluster, true);
 120                         ve_spc_global_wakeup_irq(true);
 121                         last_man = true;
 122                 }
 123         } else if (tc2_pm_use_count[cpu][cluster] == 1) {
 124                 /*
 125                  * A power_up request went ahead of us.
 126                  * Even if we do not want to shut this CPU down,
 127                  * the caller expects a certain state as if the WFI
 128                  * was aborted.  So let's continue with cache cleaning.
 129                  */
 130                 skip_wfi = true;
 131         } else
 132                 BUG();
 133
 134         /*
 135          * If the CPU is committed to power down, make sure
 136          * the power controller will be in charge of waking it
 137          * up upon IRQ, ie IRQ lines are cut from GIC CPU IF
 138          * to the CPU by disabling the GIC CPU IF to prevent wfi
 139          * from completing execution behind power controller back
 140          */
 141         if (!skip_wfi)
 142                 gic_cpu_if_down();
 143
 144         if (last_man && __mcpm_outbound_enter_critical(cpu, cluster)) {
 145                 arch_spin_unlock(&tc2_pm_lock);
 146
 147                 if (read_cpuid_part_number() == ARM_CPU_PART_CORTEX_A15) {
 148                         /*
 149                          * On the Cortex-A15 we need to disable
 150                          * L2 prefetching before flushing the cache.
 151                          */
 152                         asm volatile(
 153                         "mcr    p15, 1, %0, c15, c0, 3 \n\t"
 154                         "isb    \n\t"
 155                         "dsb    "
 156                         : : "r" (0x400) );
 157                 }
 158
 159                 v7_exit_coherency_flush(all);
 160
 161                 cci_disable_port_by_cpu(mpidr);
 162
 163                 __mcpm_outbound_leave_critical(cluster, CLUSTER_DOWN);
 164         } else {
 165                 /*
 166                  * If last man then undo any setup done previously.
 167                  */
 168                 if (last_man) {
 169                         ve_spc_powerdown(cluster, false);
 170                         ve_spc_global_wakeup_irq(false);
 171                 }
 172
 173                 arch_spin_unlock(&tc2_pm_lock);
 174
 175                 v7_exit_coherency_flush(louis);
 176         }
 177
 178         __mcpm_cpu_down(cpu, cluster);
 179
 180         /* Now we are prepared for power-down, do it: */
 181         if (!skip_wfi)
 182                 wfi();
 183
 184         /* Not dead at this point?  Let our caller cope. */
 185 }
 186
 187 static void tc2_pm_power_down(void)
 188 {
 189         tc2_pm_down(0);
 190 }
 191
 192 static void tc2_pm_suspend(u64 residency)
 193 {
 194         unsigned int mpidr, cpu, cluster;
 195
 196         mpidr = read_cpuid_mpidr();
 197         cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);
 198         cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);
 199         ve_spc_set_resume_addr(cluster, cpu, virt_to_phys(mcpm_entry_point));
 200         tc2_pm_down(residency);
 201 }
 202
 203 static void tc2_pm_powered_up(void)
 204 {
 205         unsigned int mpidr, cpu, cluster;
 206         unsigned long flags;
 207
 208         mpidr = read_cpuid_mpidr();
 209         cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);
 210         cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);
 211
 212         pr_debug("%s: cpu %u cluster %u\n", __func__, cpu, cluster);
 213         BUG_ON(cluster >= TC2_CLUSTERS || cpu >= TC2_MAX_CPUS_PER_CLUSTER);
 214
 215         local_irq_save(flags);
 216         arch_spin_lock(&tc2_pm_lock);
 217
 218         if (tc2_cluster_unused(cluster)) {
 219                 ve_spc_powerdown(cluster, false);
 220                 ve_spc_global_wakeup_irq(false);
 221         }
 222
 223         if (!tc2_pm_use_count[cpu][cluster])
 224                 tc2_pm_use_count[cpu][cluster] = 1;
 225
 226         ve_spc_cpu_wakeup_irq(cluster, cpu, false);
 227         ve_spc_set_resume_addr(cluster, cpu, 0);
 228
 229         arch_spin_unlock(&tc2_pm_lock);
 230         local_irq_restore(flags);
 231 }
 232
 233 static const struct mcpm_platform_ops tc2_pm_power_ops = {
 234         .power_up       = tc2_pm_power_up,
 235         .power_down     = tc2_pm_power_down,
 236         .suspend        = tc2_pm_suspend,
 237         .powered_up     = tc2_pm_powered_up,
 238 };
 239
 240 static bool __init tc2_pm_usage_count_init(void)
 241 {
 242         unsigned int mpidr, cpu, cluster;
 243
 244         mpidr = read_cpuid_mpidr();
 245         cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);
 246         cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);
 247
 248         pr_debug("%s: cpu %u cluster %u\n", __func__, cpu, cluster);
 249         if (cluster >= TC2_CLUSTERS || cpu >= tc2_nr_cpus[cluster]) {
 250                 pr_err("%s: boot CPU is out of bound!\n", __func__);
 251                 return false;
 252         }
 253         tc2_pm_use_count[cpu][cluster] = 1;
 254         return true;
 255 }
 256
 257 /*
 258  * Enable cluster-level coherency, in preparation for turning on the MMU.
 259  */
 260 static void __naked tc2_pm_power_up_setup(unsigned int affinity_level)
 261 {
 262         asm volatile (" \n"
 263 "       cmp     r0, #1 \n"
 264 "       bxne    lr \n"
 265 "       b       cci_enable_port_for_self ");
 266 }
 267
 268 static int __init tc2_pm_init(void)
 269 {
 270         int ret;
 271         void __iomem *scc;
 272         u32 a15_cluster_id, a7_cluster_id, sys_info;
 273         struct device_node *np;
 274
 275         /*
 276          * The power management-related features are hidden behind
 277          * SCC registers. We need to extract runtime information like
 278          * cluster ids and number of CPUs really available in clusters.
 279          */
 280         np = of_find_compatible_node(NULL, NULL,
 281                         "arm,vexpress-scc,v2p-ca15_a7");
 282         scc = of_iomap(np, 0);
 283         if (!scc)
 284                 return -ENODEV;
 285
 286         a15_cluster_id = readl_relaxed(scc + A15_CONF) & 0xf;
 287         a7_cluster_id = readl_relaxed(scc + A7_CONF) & 0xf;
 288         if (a15_cluster_id >= TC2_CLUSTERS || a7_cluster_id >= TC2_CLUSTERS)
 289                 return -EINVAL;
 290
 291         sys_info = readl_relaxed(scc + SYS_INFO);
 292         tc2_nr_cpus[a15_cluster_id] = (sys_info >> 16) & 0xf;
 293         tc2_nr_cpus[a7_cluster_id] = (sys_info >> 20) & 0xf;
 294
 295         /*
 296          * A subset of the SCC registers is also used to communicate
 297          * with the SPC (power controller). We need to be able to
 298          * drive it very early in the boot process to power up
 299          * processors, so we initialize the SPC driver here.
 300          */
 301         ret = ve_spc_init(scc + SPC_BASE, a15_cluster_id);
 302         if (ret)
 303                 return ret;
 304
 305         if (!cci_probed())
 306                 return -ENODEV;
 307
 308         if (!tc2_pm_usage_count_init())
 309                 return -EINVAL;
 310
 311         ret = mcpm_platform_register(&tc2_pm_power_ops);
 312         if (!ret) {
 313                 mcpm_sync_init(tc2_pm_power_up_setup);
 314                 pr_info("TC2 power management initialized\n");
 315         }
 316         return ret;
 317 }
 318
 319 early_initcall(tc2_pm_init);