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