2 * cpufreq driver for the cell processor
4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
6 * Author: Christian Krafft <krafft@de.ibm.com>
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)
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.
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.
23 #include <linux/cpufreq.h>
24 #include <linux/timer.h>
26 #include <asm/hw_irq.h>
28 #include <asm/machdep.h>
29 #include <asm/processor.h>
33 #include <asm/of_platform.h>
37 static DEFINE_MUTEX(cbe_switch_mutex
);
40 /* the CBE supports an 8 step frequency scaling */
41 static struct cpufreq_frequency_table cbe_freqs
[] = {
50 {0, CPUFREQ_TABLE_END
},
53 /* to write to MIC register */
54 static u64 MIC_Slow_Fast_Timer_table
[] = {
55 [0 ... 7] = 0x007fc00000000000ull
,
58 /* more values for the MIC */
59 static u64 MIC_Slow_Next_Timer_table
[] = {
60 0x0000240000000000ull
,
61 0x0000268000000000ull
,
62 0x000029C000000000ull
,
63 0x00002D0000000000ull
,
64 0x0000300000000000ull
,
65 0x0000334000000000ull
,
66 0x000039C000000000ull
,
67 0x00003FC000000000ull
,
70 static u8 pmi_slow_mode_limit
[MAX_BE
];
73 * hardware specific functions
76 static bool cbe_cpufreq_has_pmi
;
79 static int set_pmode_pmi(int cpu
, unsigned int pmode
)
82 pmi_message_t pmi_msg
;
87 pmi_msg
.type
= PMI_TYPE_FREQ_CHANGE
;
88 pmi_msg
.data1
= cbe_cpu_to_node(cpu
);
89 pmi_msg
.data2
= pmode
;
95 pmi_send_message(pmi_msg
);
98 pr_debug("PMI returned slow mode %d\n", ret
);
101 time
= jiffies
- time
; /* actual cycles (not cpu cycles!) */
102 time
= jiffies_to_msecs(time
);
103 pr_debug("had to wait %lu ms for a transition using PMI.\n", time
);
109 static int get_pmode(int cpu
)
112 struct cbe_pmd_regs __iomem
*pmd_regs
;
114 pmd_regs
= cbe_get_cpu_pmd_regs(cpu
);
115 ret
= in_be64(&pmd_regs
->pmsr
) & 0x07;
120 static int set_pmode_reg(int cpu
, unsigned int pmode
)
122 struct cbe_pmd_regs __iomem
*pmd_regs
;
123 struct cbe_mic_tm_regs __iomem
*mic_tm_regs
;
130 local_irq_save(flags
);
132 mic_tm_regs
= cbe_get_cpu_mic_tm_regs(cpu
);
133 pmd_regs
= cbe_get_cpu_pmd_regs(cpu
);
138 out_be64(&mic_tm_regs
->slow_fast_timer_0
, MIC_Slow_Fast_Timer_table
[pmode
]);
139 out_be64(&mic_tm_regs
->slow_fast_timer_1
, MIC_Slow_Fast_Timer_table
[pmode
]);
141 out_be64(&mic_tm_regs
->slow_next_timer_0
, MIC_Slow_Next_Timer_table
[pmode
]);
142 out_be64(&mic_tm_regs
->slow_next_timer_1
, MIC_Slow_Next_Timer_table
[pmode
]);
144 value
= in_be64(&pmd_regs
->pmcr
);
145 /* set bits to zero */
146 value
&= 0xFFFFFFFFFFFFFFF8ull
;
147 /* set bits to next pmode */
150 out_be64(&pmd_regs
->pmcr
, value
);
153 /* wait until new pmode appears in status register */
154 value
= in_be64(&pmd_regs
->pmsr
) & 0x07;
155 while(value
!= pmode
) {
157 value
= in_be64(&pmd_regs
->pmsr
) & 0x07;
160 time
= jiffies
- time
;
161 time
= jiffies_to_msecs(time
);
162 pr_debug("had to wait %lu ms for a transition using " \
163 "the pervasive unit.\n", time
);
165 local_irq_restore(flags
);
170 static int set_pmode(int cpu
, unsigned int slow_mode
)
173 #ifdef CONFIG_PPC_PMI
174 if (cbe_cpufreq_has_pmi
)
175 rc
= set_pmode_pmi(cpu
, slow_mode
);
178 rc
= set_pmode_reg(cpu
, slow_mode
);
180 pr_debug("register contains slow mode %d\n", get_pmode(cpu
));
185 static void cbe_cpufreq_handle_pmi(pmi_message_t pmi_msg
)
189 BUG_ON(pmi_msg
.type
!= PMI_TYPE_FREQ_CHANGE
);
191 node
= pmi_msg
.data1
;
192 slow_mode
= pmi_msg
.data2
;
194 pmi_slow_mode_limit
[node
] = slow_mode
;
196 pr_debug("cbe_handle_pmi: node: %d, max slow_mode=%d\n", slow_mode
);
199 static int pmi_notifier(struct notifier_block
*nb
,
200 unsigned long event
, void *data
)
202 struct cpufreq_policy
*policy
= data
;
205 node
= cbe_cpu_to_node(policy
->cpu
);
207 pr_debug("got notified, event=%lu, node=%u\n", event
, node
);
209 if (pmi_slow_mode_limit
[node
] != 0) {
210 pr_debug("limiting node %d to slow mode %d\n",
211 node
, pmi_slow_mode_limit
[node
]);
213 cpufreq_verify_within_limits(policy
, 0,
214 cbe_freqs
[pmi_slow_mode_limit
[node
]].frequency
);
220 static struct notifier_block pmi_notifier_block
= {
221 .notifier_call
= pmi_notifier
,
224 static struct pmi_handler cbe_pmi_handler
= {
225 .type
= PMI_TYPE_FREQ_CHANGE
,
226 .handle_pmi_message
= cbe_cpufreq_handle_pmi
,
234 static int cbe_cpufreq_cpu_init(struct cpufreq_policy
*policy
)
236 const u32
*max_freqp
;
239 struct device_node
*cpu
;
241 cpu
= of_get_cpu_node(policy
->cpu
, NULL
);
246 pr_debug("init cpufreq on CPU %d\n", policy
->cpu
);
248 max_freqp
= of_get_property(cpu
, "clock-frequency", NULL
);
255 /* we need the freq in kHz */
256 max_freq
= *max_freqp
/ 1000;
258 pr_debug("max clock-frequency is at %u kHz\n", max_freq
);
259 pr_debug("initializing frequency table\n");
261 /* initialize frequency table */
262 for (i
=0; cbe_freqs
[i
].frequency
!=CPUFREQ_TABLE_END
; i
++) {
263 cbe_freqs
[i
].frequency
= max_freq
/ cbe_freqs
[i
].index
;
264 pr_debug("%d: %d\n", i
, cbe_freqs
[i
].frequency
);
267 policy
->governor
= CPUFREQ_DEFAULT_GOVERNOR
;
269 /* if DEBUG is enabled set_pmode() measures the latency
271 policy
->cpuinfo
.transition_latency
= 25000;
273 cur_pmode
= get_pmode(policy
->cpu
);
274 pr_debug("current pmode is at %d\n",cur_pmode
);
276 policy
->cur
= cbe_freqs
[cur_pmode
].frequency
;
279 policy
->cpus
= cpu_sibling_map
[policy
->cpu
];
282 cpufreq_frequency_table_get_attr(cbe_freqs
, policy
->cpu
);
284 /* this ensures that policy->cpuinfo_min
285 * and policy->cpuinfo_max are set correctly */
286 return cpufreq_frequency_table_cpuinfo(policy
, cbe_freqs
);
289 static int cbe_cpufreq_cpu_exit(struct cpufreq_policy
*policy
)
291 cpufreq_frequency_table_put_attr(policy
->cpu
);
295 static int cbe_cpufreq_verify(struct cpufreq_policy
*policy
)
297 return cpufreq_frequency_table_verify(policy
, cbe_freqs
);
301 static int cbe_cpufreq_target(struct cpufreq_policy
*policy
,
302 unsigned int target_freq
,
303 unsigned int relation
)
306 struct cpufreq_freqs freqs
;
307 unsigned int cbe_pmode_new
;
309 cpufreq_frequency_table_target(policy
,
315 freqs
.old
= policy
->cur
;
316 freqs
.new = cbe_freqs
[cbe_pmode_new
].frequency
;
317 freqs
.cpu
= policy
->cpu
;
319 mutex_lock(&cbe_switch_mutex
);
320 cpufreq_notify_transition(&freqs
, CPUFREQ_PRECHANGE
);
322 pr_debug("setting frequency for cpu %d to %d kHz, " \
323 "1/%d of max frequency\n",
325 cbe_freqs
[cbe_pmode_new
].frequency
,
326 cbe_freqs
[cbe_pmode_new
].index
);
328 rc
= set_pmode(policy
->cpu
, cbe_pmode_new
);
330 cpufreq_notify_transition(&freqs
, CPUFREQ_POSTCHANGE
);
331 mutex_unlock(&cbe_switch_mutex
);
336 static struct cpufreq_driver cbe_cpufreq_driver
= {
337 .verify
= cbe_cpufreq_verify
,
338 .target
= cbe_cpufreq_target
,
339 .init
= cbe_cpufreq_cpu_init
,
340 .exit
= cbe_cpufreq_cpu_exit
,
341 .name
= "cbe-cpufreq",
342 .owner
= THIS_MODULE
,
343 .flags
= CPUFREQ_CONST_LOOPS
,
347 * module init and destoy
350 static int __init
cbe_cpufreq_init(void)
352 if (!machine_is(cell
))
355 cbe_cpufreq_has_pmi
= pmi_register_handler(&cbe_pmi_handler
) == 0;
357 if (cbe_cpufreq_has_pmi
)
358 cpufreq_register_notifier(&pmi_notifier_block
, CPUFREQ_POLICY_NOTIFIER
);
360 return cpufreq_register_driver(&cbe_cpufreq_driver
);
363 static void __exit
cbe_cpufreq_exit(void)
365 cpufreq_unregister_driver(&cbe_cpufreq_driver
);
367 if (cbe_cpufreq_has_pmi
) {
368 cpufreq_unregister_notifier(&pmi_notifier_block
, CPUFREQ_POLICY_NOTIFIER
);
369 pmi_unregister_handler(&cbe_pmi_handler
);
373 module_init(cbe_cpufreq_init
);
374 module_exit(cbe_cpufreq_exit
);
376 MODULE_LICENSE("GPL");
377 MODULE_AUTHOR("Christian Krafft <krafft@de.ibm.com>");