1 /* 2 * spu aware cpufreq governor for the cell processor 3 * 4 * © Copyright IBM Corporation 2006-2008 5 * 6 * Author: Christian Krafft <krafft@de.ibm.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2, or (at your option) 11 * any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/cpufreq.h> 24 #include <linux/sched.h> 25 #include <linux/sched/loadavg.h> 26 #include <linux/module.h> 27 #include <linux/timer.h> 28 #include <linux/workqueue.h> 29 #include <linux/atomic.h> 30 #include <asm/machdep.h> 31 #include <asm/spu.h> 32 33 #define POLL_TIME 100000 /* in µs */ 34 #define EXP 753 /* exp(-1) in fixed-point */ 35 36 struct spu_gov_info_struct { 37 unsigned long busy_spus; /* fixed-point */ 38 struct cpufreq_policy *policy; 39 struct delayed_work work; 40 unsigned int poll_int; /* µs */ 41 }; 42 static DEFINE_PER_CPU(struct spu_gov_info_struct, spu_gov_info); 43 44 static int calc_freq(struct spu_gov_info_struct *info) 45 { 46 int cpu; 47 int busy_spus; 48 49 cpu = info->policy->cpu; 50 busy_spus = atomic_read(&cbe_spu_info[cpu_to_node(cpu)].busy_spus); 51 52 info->busy_spus = calc_load(info->busy_spus, EXP, busy_spus * FIXED_1); 53 pr_debug("cpu %d: busy_spus=%d, info->busy_spus=%ld\n", 54 cpu, busy_spus, info->busy_spus); 55 56 return info->policy->max * info->busy_spus / FIXED_1; 57 } 58 59 static void spu_gov_work(struct work_struct *work) 60 { 61 struct spu_gov_info_struct *info; 62 int delay; 63 unsigned long target_freq; 64 65 info = container_of(work, struct spu_gov_info_struct, work.work); 66 67 /* after cancel_delayed_work_sync we unset info->policy */ 68 BUG_ON(info->policy == NULL); 69 70 target_freq = calc_freq(info); 71 __cpufreq_driver_target(info->policy, target_freq, CPUFREQ_RELATION_H); 72 73 delay = usecs_to_jiffies(info->poll_int); 74 schedule_delayed_work_on(info->policy->cpu, &info->work, delay); 75 } 76 77 static void spu_gov_init_work(struct spu_gov_info_struct *info) 78 { 79 int delay = usecs_to_jiffies(info->poll_int); 80 INIT_DEFERRABLE_WORK(&info->work, spu_gov_work); 81 schedule_delayed_work_on(info->policy->cpu, &info->work, delay); 82 } 83 84 static void spu_gov_cancel_work(struct spu_gov_info_struct *info) 85 { 86 cancel_delayed_work_sync(&info->work); 87 } 88 89 static int spu_gov_start(struct cpufreq_policy *policy) 90 { 91 unsigned int cpu = policy->cpu; 92 struct spu_gov_info_struct *info = &per_cpu(spu_gov_info, cpu); 93 struct spu_gov_info_struct *affected_info; 94 int i; 95 96 if (!cpu_online(cpu)) { 97 printk(KERN_ERR "cpu %d is not online\n", cpu); 98 return -EINVAL; 99 } 100 101 if (!policy->cur) { 102 printk(KERN_ERR "no cpu specified in policy\n"); 103 return -EINVAL; 104 } 105 106 /* initialize spu_gov_info for all affected cpus */ 107 for_each_cpu(i, policy->cpus) { 108 affected_info = &per_cpu(spu_gov_info, i); 109 affected_info->policy = policy; 110 } 111 112 info->poll_int = POLL_TIME; 113 114 /* setup timer */ 115 spu_gov_init_work(info); 116 117 return 0; 118 } 119 120 static void spu_gov_stop(struct cpufreq_policy *policy) 121 { 122 unsigned int cpu = policy->cpu; 123 struct spu_gov_info_struct *info = &per_cpu(spu_gov_info, cpu); 124 int i; 125 126 /* cancel timer */ 127 spu_gov_cancel_work(info); 128 129 /* clean spu_gov_info for all affected cpus */ 130 for_each_cpu (i, policy->cpus) { 131 info = &per_cpu(spu_gov_info, i); 132 info->policy = NULL; 133 } 134 } 135 136 static struct cpufreq_governor spu_governor = { 137 .name = "spudemand", 138 .start = spu_gov_start, 139 .stop = spu_gov_stop, 140 .owner = THIS_MODULE, 141 }; 142 143 /* 144 * module init and destoy 145 */ 146 147 static int __init spu_gov_init(void) 148 { 149 int ret; 150 151 ret = cpufreq_register_governor(&spu_governor); 152 if (ret) 153 printk(KERN_ERR "registration of governor failed\n"); 154 return ret; 155 } 156 157 static void __exit spu_gov_exit(void) 158 { 159 cpufreq_unregister_governor(&spu_governor); 160 } 161 162 163 module_init(spu_gov_init); 164 module_exit(spu_gov_exit); 165 166 MODULE_LICENSE("GPL"); 167 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>"); 168 169