1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2012 Linaro : Daniel Lezcano <daniel.lezcano@linaro.org> (IBM) 4 * 5 * Based on the work of Rickard Andersson <rickard.andersson@stericsson.com> 6 * and Jonas Aaberg <jonas.aberg@stericsson.com>. 7 */ 8 9 #include <linux/init.h> 10 #include <linux/cpuidle.h> 11 #include <linux/spinlock.h> 12 #include <linux/atomic.h> 13 #include <linux/smp.h> 14 #include <linux/mfd/dbx500-prcmu.h> 15 #include <linux/platform_data/arm-ux500-pm.h> 16 #include <linux/platform_device.h> 17 18 #include <asm/cpuidle.h> 19 20 static atomic_t master = ATOMIC_INIT(0); 21 static DEFINE_SPINLOCK(master_lock); 22 23 static inline int ux500_enter_idle(struct cpuidle_device *dev, 24 struct cpuidle_driver *drv, int index) 25 { 26 int this_cpu = smp_processor_id(); 27 bool recouple = false; 28 29 if (atomic_inc_return(&master) == num_online_cpus()) { 30 31 /* With this lock, we prevent the other cpu to exit and enter 32 * this function again and become the master */ 33 if (!spin_trylock(&master_lock)) 34 goto wfi; 35 36 /* decouple the gic from the A9 cores */ 37 if (prcmu_gic_decouple()) { 38 spin_unlock(&master_lock); 39 goto out; 40 } 41 42 /* If an error occur, we will have to recouple the gic 43 * manually */ 44 recouple = true; 45 46 /* At this state, as the gic is decoupled, if the other 47 * cpu is in WFI, we have the guarantee it won't be wake 48 * up, so we can safely go to retention */ 49 if (!prcmu_is_cpu_in_wfi(this_cpu ? 0 : 1)) 50 goto out; 51 52 /* The prcmu will be in charge of watching the interrupts 53 * and wake up the cpus */ 54 if (prcmu_copy_gic_settings()) 55 goto out; 56 57 /* Check in the meantime an interrupt did 58 * not occur on the gic ... */ 59 if (prcmu_gic_pending_irq()) 60 goto out; 61 62 /* ... and the prcmu */ 63 if (prcmu_pending_irq()) 64 goto out; 65 66 /* Go to the retention state, the prcmu will wait for the 67 * cpu to go WFI and this is what happens after exiting this 68 * 'master' critical section */ 69 if (prcmu_set_power_state(PRCMU_AP_IDLE, true, true)) 70 goto out; 71 72 /* When we switch to retention, the prcmu is in charge 73 * of recoupling the gic automatically */ 74 recouple = false; 75 76 spin_unlock(&master_lock); 77 } 78 wfi: 79 cpu_do_idle(); 80 out: 81 atomic_dec(&master); 82 83 if (recouple) { 84 prcmu_gic_recouple(); 85 spin_unlock(&master_lock); 86 } 87 88 return index; 89 } 90 91 static struct cpuidle_driver ux500_idle_driver = { 92 .name = "ux500_idle", 93 .owner = THIS_MODULE, 94 .states = { 95 ARM_CPUIDLE_WFI_STATE, 96 { 97 .enter = ux500_enter_idle, 98 .exit_latency = 70, 99 .target_residency = 260, 100 .flags = CPUIDLE_FLAG_TIMER_STOP, 101 .name = "ApIdle", 102 .desc = "ARM Retention", 103 }, 104 }, 105 .safe_state_index = 0, 106 .state_count = 2, 107 }; 108 109 static int dbx500_cpuidle_probe(struct platform_device *pdev) 110 { 111 /* Configure wake up reasons */ 112 prcmu_enable_wakeups(PRCMU_WAKEUP(ARM) | PRCMU_WAKEUP(RTC) | 113 PRCMU_WAKEUP(ABB)); 114 115 return cpuidle_register(&ux500_idle_driver, NULL); 116 } 117 118 static struct platform_driver dbx500_cpuidle_plat_driver = { 119 .driver = { 120 .name = "db8500-cpuidle", 121 }, 122 .probe = dbx500_cpuidle_probe, 123 }; 124 builtin_platform_driver(dbx500_cpuidle_plat_driver); 125