blob: d13a13678b5f1989fd7906d2fb7dd4bcc61e6e06 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Andreas Herrmannb2bd68e2012-01-06 15:59:33 +01002 * (c) 2003-2012 Advanced Micro Devices, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Your use of this code is subject to the terms and conditions of the
4 * GNU general public license version 2. See "COPYING" or
5 * http://www.gnu.org/licenses/gpl.html
6 *
Andreas Herrmannb2bd68e2012-01-06 15:59:33 +01007 * Maintainer:
Andreas Herrmann29c4bcd2012-10-31 00:30:38 +01008 * Andreas Herrmann <herrmann.der.user@googlemail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * Based on the powernow-k7.c module written by Dave Jones.
Dave Jonesf4432c52008-10-20 13:31:45 -040011 * (C) 2003 Dave Jones on behalf of SuSE Labs
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * (C) 2004 Dominik Brodowski <linux@brodo.de>
Pavel Macheka2531292010-07-18 14:27:13 +020013 * (C) 2004 Pavel Machek <pavel@ucw.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * Licensed under the terms of the GNU GPL License version 2.
15 * Based upon datasheets & sample CPUs kindly provided by AMD.
16 *
17 * Valuable input gratefully received from Dave Jones, Pavel Machek,
Dave Jones1f729e02006-06-04 19:37:58 -040018 * Dominik Brodowski, Jacob Shin, and others.
Dave Jones065b8072005-05-31 19:03:46 -070019 * Originally developed by Paul Devriendt.
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 *
Andreas Herrmannb2bd68e2012-01-06 15:59:33 +010021 * Processor information obtained from Chapter 9 (Power and Thermal
22 * Management) of the "BIOS and Kernel Developer's Guide (BKDG) for
23 * the AMD Athlon 64 and AMD Opteron Processors" and section "2.x
24 * Power Management" in BKDGs for newer AMD CPU families.
25 *
26 * Tables for specific CPUs can be inferred from AMD's processor
27 * power and thermal data sheets, (e.g. 30417.pdf, 30430.pdf, 43375.pdf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 */
29
30#include <linux/kernel.h>
31#include <linux/smp.h>
32#include <linux/module.h>
33#include <linux/init.h>
34#include <linux/cpufreq.h>
35#include <linux/slab.h>
36#include <linux/string.h>
Dave Jones065b8072005-05-31 19:03:46 -070037#include <linux/cpumask.h>
Dave Jones0e64a0c2009-02-04 14:37:50 -050038#include <linux/io.h>
39#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include <asm/msr.h>
Andi Kleenfa8031a2012-01-26 00:09:12 +010042#include <asm/cpu_device_id.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/acpi.h>
Ingo Molnar14cc3e22006-03-26 01:37:14 -080045#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define PFX "powernow-k8: "
Mark Langsdorfc5829cd2007-10-17 16:52:08 -050049#define VERSION "version 2.20.00"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include "powernow-k8.h"
51
52/* serialize freq changes */
Ingo Molnar14cc3e22006-03-26 01:37:14 -080053static DEFINE_MUTEX(fidvid_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
travis@sgi.com2c6b8c02008-01-30 13:33:11 +010055static DEFINE_PER_CPU(struct powernow_k8_data *, powernow_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Mark Langsdorfa2fed572010-03-18 18:41:46 +010057static struct cpufreq_driver cpufreq_amd64_driver;
58
Dave Jones065b8072005-05-31 19:03:46 -070059#ifndef CONFIG_SMP
Rusty Russell7ad728f2009-03-13 14:49:50 +103060static inline const struct cpumask *cpu_core_mask(int cpu)
61{
62 return cpumask_of(0);
63}
Dave Jones065b8072005-05-31 19:03:46 -070064#endif
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066/* Return a frequency in MHz, given an input fid */
67static u32 find_freq_from_fid(u32 fid)
68{
69 return 800 + (fid * 100);
70}
71
72/* Return a frequency in KHz, given an input fid */
73static u32 find_khz_freq_from_fid(u32 fid)
74{
75 return 1000 * find_freq_from_fid(fid);
76}
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078/* Return the vco fid for an input fid
79 *
80 * Each "low" fid has corresponding "high" fid, and you can get to "low" fids
81 * only from corresponding high fids. This returns "high" fid corresponding to
82 * "low" one.
83 */
84static u32 convert_fid_to_vco_fid(u32 fid)
85{
Dave Jones32ee8c32006-02-28 00:43:23 -050086 if (fid < HI_FID_TABLE_BOTTOM)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 return 8 + (2 * fid);
Dave Jones32ee8c32006-02-28 00:43:23 -050088 else
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return fid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
91
92/*
93 * Return 1 if the pending bit is set. Unless we just instructed the processor
94 * to transition to a new state, seeing this bit set is really bad news.
95 */
96static int pending_bit_stuck(void)
97{
98 u32 lo, hi;
99
100 rdmsr(MSR_FIDVID_STATUS, lo, hi);
101 return lo & MSR_S_LO_CHANGE_PENDING ? 1 : 0;
102}
103
104/*
105 * Update the global current fid / vid values from the status msr.
106 * Returns 1 on error.
107 */
108static int query_current_values_with_pending_wait(struct powernow_k8_data *data)
109{
110 u32 lo, hi;
111 u32 i = 0;
112
Dave Jones7153d962005-07-28 09:45:10 -0700113 do {
Dave Jones0213df72005-10-21 17:21:03 -0400114 if (i++ > 10000) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200115 pr_debug("detected change pending stuck\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return 1;
117 }
118 rdmsr(MSR_FIDVID_STATUS, lo, hi);
Dave Jones7153d962005-07-28 09:45:10 -0700119 } while (lo & MSR_S_LO_CHANGE_PENDING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
121 data->currvid = hi & MSR_S_HI_CURRENT_VID;
122 data->currfid = lo & MSR_S_LO_CURRENT_FID;
123
124 return 0;
125}
126
127/* the isochronous relief time */
128static void count_off_irt(struct powernow_k8_data *data)
129{
130 udelay((1 << data->irt) * 10);
131 return;
132}
133
Simon Arlott27b46d72007-10-20 01:13:56 +0200134/* the voltage stabilization time */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static void count_off_vst(struct powernow_k8_data *data)
136{
137 udelay(data->vstable * VST_UNITS_20US);
138 return;
139}
140
141/* need to init the control msr to a safe value (for each cpu) */
142static void fidvid_msr_init(void)
143{
144 u32 lo, hi;
145 u8 fid, vid;
146
147 rdmsr(MSR_FIDVID_STATUS, lo, hi);
148 vid = hi & MSR_S_HI_CURRENT_VID;
149 fid = lo & MSR_S_LO_CURRENT_FID;
150 lo = fid | (vid << MSR_C_LO_VID_SHIFT);
151 hi = MSR_C_HI_STP_GNT_BENIGN;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200152 pr_debug("cpu%d, init lo 0x%x, hi 0x%x\n", smp_processor_id(), lo, hi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 wrmsr(MSR_FIDVID_CTL, lo, hi);
154}
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156/* write the new fid value along with the other control fields to the msr */
157static int write_new_fid(struct powernow_k8_data *data, u32 fid)
158{
159 u32 lo;
160 u32 savevid = data->currvid;
Dave Jones0213df72005-10-21 17:21:03 -0400161 u32 i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 if ((fid & INVALID_FID_MASK) || (data->currvid & INVALID_VID_MASK)) {
164 printk(KERN_ERR PFX "internal error - overflow on fid write\n");
165 return 1;
166 }
167
Dave Jones0e64a0c2009-02-04 14:37:50 -0500168 lo = fid;
169 lo |= (data->currvid << MSR_C_LO_VID_SHIFT);
170 lo |= MSR_C_LO_INIT_FID_VID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200172 pr_debug("writing fid 0x%x, lo 0x%x, hi 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 fid, lo, data->plllock * PLL_LOCK_CONVERSION);
174
Dave Jones0213df72005-10-21 17:21:03 -0400175 do {
176 wrmsr(MSR_FIDVID_CTL, lo, data->plllock * PLL_LOCK_CONVERSION);
177 if (i++ > 100) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500178 printk(KERN_ERR PFX
179 "Hardware error - pending bit very stuck - "
180 "no further pstate changes possible\n");
Chris Wright63172cb2005-10-21 16:56:08 -0700181 return 1;
Dave Jones32ee8c32006-02-28 00:43:23 -0500182 }
Dave Jones0213df72005-10-21 17:21:03 -0400183 } while (query_current_values_with_pending_wait(data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 count_off_irt(data);
186
187 if (savevid != data->currvid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500188 printk(KERN_ERR PFX
189 "vid change on fid trans, old 0x%x, new 0x%x\n",
190 savevid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 return 1;
192 }
193
194 if (fid != data->currfid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500195 printk(KERN_ERR PFX
196 "fid trans failed, fid 0x%x, curr 0x%x\n", fid,
197 data->currfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return 1;
199 }
200
201 return 0;
202}
203
204/* Write a new vid to the hardware */
205static int write_new_vid(struct powernow_k8_data *data, u32 vid)
206{
207 u32 lo;
208 u32 savefid = data->currfid;
Dave Jones0213df72005-10-21 17:21:03 -0400209 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 if ((data->currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
212 printk(KERN_ERR PFX "internal error - overflow on vid write\n");
213 return 1;
214 }
215
Dave Jones0e64a0c2009-02-04 14:37:50 -0500216 lo = data->currfid;
217 lo |= (vid << MSR_C_LO_VID_SHIFT);
218 lo |= MSR_C_LO_INIT_FID_VID;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200220 pr_debug("writing vid 0x%x, lo 0x%x, hi 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 vid, lo, STOP_GRANT_5NS);
222
Dave Jones0213df72005-10-21 17:21:03 -0400223 do {
224 wrmsr(MSR_FIDVID_CTL, lo, STOP_GRANT_5NS);
Dave Jones6df89002005-11-30 13:33:30 -0800225 if (i++ > 100) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500226 printk(KERN_ERR PFX "internal error - pending bit "
227 "very stuck - no further pstate "
228 "changes possible\n");
Dave Jones6df89002005-11-30 13:33:30 -0800229 return 1;
230 }
Dave Jones0213df72005-10-21 17:21:03 -0400231 } while (query_current_values_with_pending_wait(data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 if (savefid != data->currfid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500234 printk(KERN_ERR PFX "fid changed on vid trans, old "
235 "0x%x new 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 savefid, data->currfid);
237 return 1;
238 }
239
240 if (vid != data->currvid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500241 printk(KERN_ERR PFX "vid trans failed, vid 0x%x, "
242 "curr 0x%x\n",
243 vid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return 1;
245 }
246
247 return 0;
248}
249
250/*
251 * Reduce the vid by the max of step or reqvid.
252 * Decreasing vid codes represent increasing voltages:
Dave Jones841e40b2005-07-28 09:40:04 -0700253 * vid of 0 is 1.550V, vid of 0x1e is 0.800V, vid of VID_OFF is off.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500255static int decrease_vid_code_by_step(struct powernow_k8_data *data,
256 u32 reqvid, u32 step)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
258 if ((data->currvid - reqvid) > step)
259 reqvid = data->currvid - step;
260
261 if (write_new_vid(data, reqvid))
262 return 1;
263
264 count_off_vst(data);
265
266 return 0;
267}
268
Dave Jones1f729e02006-06-04 19:37:58 -0400269/* Change Opteron/Athlon64 fid and vid, by the 3 phases. */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500270static int transition_fid_vid(struct powernow_k8_data *data,
271 u32 reqfid, u32 reqvid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500273 if (core_voltage_pre_transition(data, reqvid, reqfid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 return 1;
275
276 if (core_frequency_transition(data, reqfid))
277 return 1;
278
279 if (core_voltage_post_transition(data, reqvid))
280 return 1;
281
282 if (query_current_values_with_pending_wait(data))
283 return 1;
284
285 if ((reqfid != data->currfid) || (reqvid != data->currvid)) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500286 printk(KERN_ERR PFX "failed (cpu%d): req 0x%x 0x%x, "
287 "curr 0x%x 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 smp_processor_id(),
289 reqfid, reqvid, data->currfid, data->currvid);
290 return 1;
291 }
292
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200293 pr_debug("transitioned (cpu%d): new fid 0x%x, vid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 smp_processor_id(), data->currfid, data->currvid);
295
296 return 0;
297}
298
299/* Phase 1 - core voltage transition ... setup voltage */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500300static int core_voltage_pre_transition(struct powernow_k8_data *data,
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500301 u32 reqvid, u32 reqfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302{
303 u32 rvosteps = data->rvo;
304 u32 savefid = data->currfid;
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500305 u32 maxvid, lo, rvomult = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200307 pr_debug("ph1 (cpu%d): start, currfid 0x%x, currvid 0x%x, "
Dave Jones0e64a0c2009-02-04 14:37:50 -0500308 "reqvid 0x%x, rvo 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 smp_processor_id(),
310 data->currfid, data->currvid, reqvid, data->rvo);
311
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500312 if ((savefid < LO_FID_TABLE_TOP) && (reqfid < LO_FID_TABLE_TOP))
313 rvomult = 2;
314 rvosteps *= rvomult;
Dave Jones065b8072005-05-31 19:03:46 -0700315 rdmsr(MSR_FIDVID_STATUS, lo, maxvid);
316 maxvid = 0x1f & (maxvid >> 16);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200317 pr_debug("ph1 maxvid=0x%x\n", maxvid);
Dave Jones065b8072005-05-31 19:03:46 -0700318 if (reqvid < maxvid) /* lower numbers are higher voltages */
319 reqvid = maxvid;
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 while (data->currvid > reqvid) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200322 pr_debug("ph1: curr 0x%x, req vid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 data->currvid, reqvid);
324 if (decrease_vid_code_by_step(data, reqvid, data->vidmvs))
325 return 1;
326 }
327
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500328 while ((rvosteps > 0) &&
329 ((rvomult * data->rvo + data->currvid) > reqvid)) {
Dave Jones065b8072005-05-31 19:03:46 -0700330 if (data->currvid == maxvid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 rvosteps = 0;
332 } else {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200333 pr_debug("ph1: changing vid for rvo, req 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 data->currvid - 1);
Dave Jones0e64a0c2009-02-04 14:37:50 -0500335 if (decrease_vid_code_by_step(data, data->currvid-1, 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 return 1;
337 rvosteps--;
338 }
339 }
340
341 if (query_current_values_with_pending_wait(data))
342 return 1;
343
344 if (savefid != data->currfid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500345 printk(KERN_ERR PFX "ph1 err, currfid changed 0x%x\n",
346 data->currfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return 1;
348 }
349
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200350 pr_debug("ph1 complete, currfid 0x%x, currvid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 data->currfid, data->currvid);
352
353 return 0;
354}
355
356/* Phase 2 - core frequency transition */
357static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
358{
Dave Jones0e64a0c2009-02-04 14:37:50 -0500359 u32 vcoreqfid, vcocurrfid, vcofiddiff;
360 u32 fid_interval, savevid = data->currvid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (data->currfid == reqfid) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500363 printk(KERN_ERR PFX "ph2 null fid transition 0x%x\n",
364 data->currfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return 0;
366 }
367
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200368 pr_debug("ph2 (cpu%d): starting, currfid 0x%x, currvid 0x%x, "
Dave Jones0e64a0c2009-02-04 14:37:50 -0500369 "reqfid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 smp_processor_id(),
371 data->currfid, data->currvid, reqfid);
372
373 vcoreqfid = convert_fid_to_vco_fid(reqfid);
374 vcocurrfid = convert_fid_to_vco_fid(data->currfid);
375 vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
376 : vcoreqfid - vcocurrfid;
377
Mark Langsdorfa2e1b4c2009-07-26 10:55:25 -0500378 if ((reqfid <= LO_FID_TABLE_TOP) && (data->currfid <= LO_FID_TABLE_TOP))
379 vcofiddiff = 0;
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 while (vcofiddiff > 2) {
Langsdorf, Mark019a61b2005-11-29 14:18:03 -0600382 (data->currfid & 1) ? (fid_interval = 1) : (fid_interval = 2);
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 if (reqfid > data->currfid) {
385 if (data->currfid > LO_FID_TABLE_TOP) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500386 if (write_new_fid(data,
387 data->currfid + fid_interval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 } else {
390 if (write_new_fid
Dave Jones0e64a0c2009-02-04 14:37:50 -0500391 (data,
392 2 + convert_fid_to_vco_fid(data->currfid)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
395 } else {
Langsdorf, Mark019a61b2005-11-29 14:18:03 -0600396 if (write_new_fid(data, data->currfid - fid_interval))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return 1;
398 }
399
400 vcocurrfid = convert_fid_to_vco_fid(data->currfid);
401 vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
402 : vcoreqfid - vcocurrfid;
403 }
404
405 if (write_new_fid(data, reqfid))
406 return 1;
407
408 if (query_current_values_with_pending_wait(data))
409 return 1;
410
411 if (data->currfid != reqfid) {
412 printk(KERN_ERR PFX
Dave Jones0e64a0c2009-02-04 14:37:50 -0500413 "ph2: mismatch, failed fid transition, "
414 "curr 0x%x, req 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 data->currfid, reqfid);
416 return 1;
417 }
418
419 if (savevid != data->currvid) {
420 printk(KERN_ERR PFX "ph2: vid changed, save 0x%x, curr 0x%x\n",
421 savevid, data->currvid);
422 return 1;
423 }
424
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200425 pr_debug("ph2 complete, currfid 0x%x, currvid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 data->currfid, data->currvid);
427
428 return 0;
429}
430
431/* Phase 3 - core voltage transition flow ... jump to the final vid. */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500432static int core_voltage_post_transition(struct powernow_k8_data *data,
433 u32 reqvid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 u32 savefid = data->currfid;
436 u32 savereqvid = reqvid;
437
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200438 pr_debug("ph3 (cpu%d): starting, currfid 0x%x, currvid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 smp_processor_id(),
440 data->currfid, data->currvid);
441
442 if (reqvid != data->currvid) {
443 if (write_new_vid(data, reqvid))
444 return 1;
445
446 if (savefid != data->currfid) {
447 printk(KERN_ERR PFX
448 "ph3: bad fid change, save 0x%x, curr 0x%x\n",
449 savefid, data->currfid);
450 return 1;
451 }
452
453 if (data->currvid != reqvid) {
454 printk(KERN_ERR PFX
Dave Jones0e64a0c2009-02-04 14:37:50 -0500455 "ph3: failed vid transition\n, "
456 "req 0x%x, curr 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 reqvid, data->currvid);
458 return 1;
459 }
460 }
461
462 if (query_current_values_with_pending_wait(data))
463 return 1;
464
465 if (savereqvid != data->currvid) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200466 pr_debug("ph3 failed, currvid 0x%x\n", data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 return 1;
468 }
469
470 if (savefid != data->currfid) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200471 pr_debug("ph3 failed, currfid changed 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 data->currfid);
473 return 1;
474 }
475
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200476 pr_debug("ph3 complete, currfid 0x%x, currvid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 data->currfid, data->currvid);
478
479 return 0;
480}
481
Andi Kleenfa8031a2012-01-26 00:09:12 +0100482static const struct x86_cpu_id powernow_k8_ids[] = {
483 /* IO based frequency switching */
484 { X86_VENDOR_AMD, 0xf },
Andi Kleenfa8031a2012-01-26 00:09:12 +0100485 {}
486};
487MODULE_DEVICE_TABLE(x86cpu, powernow_k8_ids);
488
Rusty Russell1ff6e972009-06-12 20:55:37 +0930489static void check_supported_cpu(void *_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 u32 eax, ebx, ecx, edx;
Rusty Russell1ff6e972009-06-12 20:55:37 +0930492 int *rc = _rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Rusty Russell1ff6e972009-06-12 20:55:37 +0930494 *rc = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
Dave Jones2c906ae2006-02-28 00:36:32 -0500497
Dave Jones1f729e02006-06-04 19:37:58 -0400498 if ((eax & CPUID_XFAM) == CPUID_XFAM_K8) {
499 if (((eax & CPUID_USE_XFAM_XMOD) != CPUID_USE_XFAM_XMOD) ||
Dave Jones99fbe1a2007-05-14 18:27:29 -0400500 ((eax & CPUID_XMOD) > CPUID_XMOD_REV_MASK)) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500501 printk(KERN_INFO PFX
502 "Processor cpuid %x not supported\n", eax);
Rusty Russell1ff6e972009-06-12 20:55:37 +0930503 return;
Dave Jones1f729e02006-06-04 19:37:58 -0400504 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Dave Jones1f729e02006-06-04 19:37:58 -0400506 eax = cpuid_eax(CPUID_GET_MAX_CAPABILITIES);
507 if (eax < CPUID_FREQ_VOLT_CAPABILITIES) {
508 printk(KERN_INFO PFX
509 "No frequency change capabilities detected\n");
Rusty Russell1ff6e972009-06-12 20:55:37 +0930510 return;
Dave Jones1f729e02006-06-04 19:37:58 -0400511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Dave Jones1f729e02006-06-04 19:37:58 -0400513 cpuid(CPUID_FREQ_VOLT_CAPABILITIES, &eax, &ebx, &ecx, &edx);
Dave Jones0e64a0c2009-02-04 14:37:50 -0500514 if ((edx & P_STATE_TRANSITION_CAPABLE)
515 != P_STATE_TRANSITION_CAPABLE) {
516 printk(KERN_INFO PFX
517 "Power state transitions not supported\n");
Rusty Russell1ff6e972009-06-12 20:55:37 +0930518 return;
Dave Jones1f729e02006-06-04 19:37:58 -0400519 }
Matthew Garrette1f0b8e2012-09-04 08:28:09 +0000520 *rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522}
523
Dave Jones0e64a0c2009-02-04 14:37:50 -0500524static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst,
525 u8 maxvid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
527 unsigned int j;
528 u8 lastfid = 0xff;
529
530 for (j = 0; j < data->numps; j++) {
531 if (pst[j].vid > LEAST_VID) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200532 printk(KERN_ERR FW_BUG PFX "vid %d invalid : 0x%x\n",
533 j, pst[j].vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 return -EINVAL;
535 }
Dave Jones0e64a0c2009-02-04 14:37:50 -0500536 if (pst[j].vid < data->rvo) {
537 /* vid + rvo >= 0 */
Thomas Renninger2fd47092008-09-01 14:27:03 +0200538 printk(KERN_ERR FW_BUG PFX "0 vid exceeded with pstate"
539 " %d\n", j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 return -ENODEV;
541 }
Dave Jones0e64a0c2009-02-04 14:37:50 -0500542 if (pst[j].vid < maxvid + data->rvo) {
543 /* vid + rvo >= maxvid */
Thomas Renninger2fd47092008-09-01 14:27:03 +0200544 printk(KERN_ERR FW_BUG PFX "maxvid exceeded with pstate"
545 " %d\n", j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return -ENODEV;
547 }
Jacob Shin8aae8282005-11-21 07:23:08 -0800548 if (pst[j].fid > MAX_FID) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200549 printk(KERN_ERR FW_BUG PFX "maxfid exceeded with pstate"
550 " %d\n", j);
Jacob Shin8aae8282005-11-21 07:23:08 -0800551 return -ENODEV;
552 }
Jacob Shin8aae8282005-11-21 07:23:08 -0800553 if (j && (pst[j].fid < HI_FID_TABLE_BOTTOM)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 /* Only first fid is allowed to be in "low" range */
Thomas Renninger2fd47092008-09-01 14:27:03 +0200555 printk(KERN_ERR FW_BUG PFX "two low fids - %d : "
556 "0x%x\n", j, pst[j].fid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return -EINVAL;
558 }
559 if (pst[j].fid < lastfid)
560 lastfid = pst[j].fid;
561 }
562 if (lastfid & 1) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200563 printk(KERN_ERR FW_BUG PFX "lastfid invalid\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 return -EINVAL;
565 }
566 if (lastfid > LO_FID_TABLE_TOP)
Dave Jones0e64a0c2009-02-04 14:37:50 -0500567 printk(KERN_INFO FW_BUG PFX
568 "first fid not from lo freq table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 return 0;
571}
572
Kurt Roeckxf0adb132009-09-16 11:09:32 -0400573static void invalidate_entry(struct cpufreq_frequency_table *powernow_table,
574 unsigned int entry)
Dave Jones0e64a0c2009-02-04 14:37:50 -0500575{
Kurt Roeckxf0adb132009-09-16 11:09:32 -0400576 powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
Dave Jones0e64a0c2009-02-04 14:37:50 -0500577}
578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579static void print_basics(struct powernow_k8_data *data)
580{
581 int j;
582 for (j = 0; j < data->numps; j++) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500583 if (data->powernow_table[j].frequency !=
584 CPUFREQ_ENTRY_INVALID) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500585 printk(KERN_INFO PFX
Thomas Renninger9e918692011-03-03 21:31:24 +0100586 "fid 0x%x (%d MHz), vid 0x%x\n",
Dave Jones9a60ddb2007-07-13 01:34:10 -0400587 data->powernow_table[j].index & 0xff,
588 data->powernow_table[j].frequency/1000,
589 data->powernow_table[j].index >> 8);
Dave Jones1f729e02006-06-04 19:37:58 -0400590 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 }
592 if (data->batps)
Dave Jones0e64a0c2009-02-04 14:37:50 -0500593 printk(KERN_INFO PFX "Only %d pstates on battery\n",
594 data->batps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595}
596
Dave Jones0e64a0c2009-02-04 14:37:50 -0500597static int fill_powernow_table(struct powernow_k8_data *data,
598 struct pst_s *pst, u8 maxvid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
600 struct cpufreq_frequency_table *powernow_table;
601 unsigned int j;
602
Dave Jones0e64a0c2009-02-04 14:37:50 -0500603 if (data->batps) {
604 /* use ACPI support to get full speed on mains power */
605 printk(KERN_WARNING PFX
606 "Only %d pstates usable (use ACPI driver for full "
607 "range\n", data->batps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 data->numps = data->batps;
609 }
610
Dave Jones0e64a0c2009-02-04 14:37:50 -0500611 for (j = 1; j < data->numps; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (pst[j-1].fid >= pst[j].fid) {
613 printk(KERN_ERR PFX "PST out of sequence\n");
614 return -EINVAL;
615 }
616 }
617
618 if (data->numps < 2) {
619 printk(KERN_ERR PFX "no p states to transition\n");
620 return -ENODEV;
621 }
622
623 if (check_pst_table(data, pst, maxvid))
624 return -EINVAL;
625
626 powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
627 * (data->numps + 1)), GFP_KERNEL);
628 if (!powernow_table) {
629 printk(KERN_ERR PFX "powernow_table memory alloc failure\n");
630 return -ENOMEM;
631 }
632
633 for (j = 0; j < data->numps; j++) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500634 int freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 powernow_table[j].index = pst[j].fid; /* lower 8 bits */
636 powernow_table[j].index |= (pst[j].vid << 8); /* upper 8 bits */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500637 freq = find_khz_freq_from_fid(pst[j].fid);
638 powernow_table[j].frequency = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 }
640 powernow_table[data->numps].frequency = CPUFREQ_TABLE_END;
641 powernow_table[data->numps].index = 0;
642
643 if (query_current_values_with_pending_wait(data)) {
644 kfree(powernow_table);
645 return -EIO;
646 }
647
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200648 pr_debug("cfid 0x%x, cvid 0x%x\n", data->currfid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 data->powernow_table = powernow_table;
Rusty Russell7ad728f2009-03-13 14:49:50 +1030650 if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
Mark Langsdorf2e497622007-04-30 14:15:05 -0500651 print_basics(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 for (j = 0; j < data->numps; j++)
Dave Jones0e64a0c2009-02-04 14:37:50 -0500654 if ((pst[j].fid == data->currfid) &&
655 (pst[j].vid == data->currvid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return 0;
657
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200658 pr_debug("currfid/vid do not match PST, ignoring\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 return 0;
660}
661
662/* Find and validate the PSB/PST table in BIOS. */
663static int find_psb_table(struct powernow_k8_data *data)
664{
665 struct psb_s *psb;
666 unsigned int i;
667 u32 mvs;
668 u8 maxvid;
669 u32 cpst = 0;
670 u32 thiscpuid;
671
672 for (i = 0xc0000; i < 0xffff0; i += 0x10) {
673 /* Scan BIOS looking for the signature. */
674 /* It can not be at ffff0 - it is too big. */
675
676 psb = phys_to_virt(i);
677 if (memcmp(psb, PSB_ID_STRING, PSB_ID_STRING_LEN) != 0)
678 continue;
679
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200680 pr_debug("found PSB header at 0x%p\n", psb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200682 pr_debug("table vers: 0x%x\n", psb->tableversion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 if (psb->tableversion != PSB_VERSION_1_4) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200684 printk(KERN_ERR FW_BUG PFX "PSB table is not v1.4\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return -ENODEV;
686 }
687
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200688 pr_debug("flags: 0x%x\n", psb->flags1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if (psb->flags1) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200690 printk(KERN_ERR FW_BUG PFX "unknown flags\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 return -ENODEV;
692 }
693
694 data->vstable = psb->vstable;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200695 pr_debug("voltage stabilization time: %d(*20us)\n",
Dave Jones0e64a0c2009-02-04 14:37:50 -0500696 data->vstable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200698 pr_debug("flags2: 0x%x\n", psb->flags2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 data->rvo = psb->flags2 & 3;
700 data->irt = ((psb->flags2) >> 2) & 3;
701 mvs = ((psb->flags2) >> 4) & 3;
702 data->vidmvs = 1 << mvs;
703 data->batps = ((psb->flags2) >> 6) & 3;
704
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200705 pr_debug("ramp voltage offset: %d\n", data->rvo);
706 pr_debug("isochronous relief time: %d\n", data->irt);
707 pr_debug("maximum voltage step: %d - 0x%x\n", mvs, data->vidmvs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200709 pr_debug("numpst: 0x%x\n", psb->num_tables);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 cpst = psb->num_tables;
Dave Jones0e64a0c2009-02-04 14:37:50 -0500711 if ((psb->cpuid == 0x00000fc0) ||
712 (psb->cpuid == 0x00000fe0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 thiscpuid = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
Dave Jones0e64a0c2009-02-04 14:37:50 -0500714 if ((thiscpuid == 0x00000fc0) ||
715 (thiscpuid == 0x00000fe0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 cpst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 }
718 if (cpst != 1) {
Thomas Renninger2fd47092008-09-01 14:27:03 +0200719 printk(KERN_ERR FW_BUG PFX "numpst must be 1\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 return -ENODEV;
721 }
722
723 data->plllock = psb->plllocktime;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200724 pr_debug("plllocktime: 0x%x (units 1us)\n", psb->plllocktime);
725 pr_debug("maxfid: 0x%x\n", psb->maxfid);
726 pr_debug("maxvid: 0x%x\n", psb->maxvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 maxvid = psb->maxvid;
728
729 data->numps = psb->numps;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200730 pr_debug("numpstates: 0x%x\n", data->numps);
Dave Jones0e64a0c2009-02-04 14:37:50 -0500731 return fill_powernow_table(data,
732 (struct pst_s *)(psb+1), maxvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 }
734 /*
735 * If you see this message, complain to BIOS manufacturer. If
736 * he tells you "we do not support Linux" or some similar
737 * nonsense, remember that Windows 2000 uses the same legacy
738 * mechanism that the old Linux PSB driver uses. Tell them it
739 * is broken with Windows 2000.
740 *
741 * The reference to the AMD documentation is chapter 9 in the
742 * BIOS and Kernel Developer's Guide, which is available on
743 * www.amd.com
744 */
Thomas Renninger79cc56a2009-02-04 11:56:11 +0100745 printk(KERN_ERR FW_BUG PFX "No PSB or ACPI _PSS objects\n");
Marti Raudsepp298decf2010-01-20 19:19:33 +0200746 printk(KERN_ERR PFX "Make sure that your BIOS is up to date"
747 " and Cool'N'Quiet support is enabled in BIOS setup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 return -ENODEV;
749}
750
Dave Jones0e64a0c2009-02-04 14:37:50 -0500751static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data,
752 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Lin Ming439913f2010-01-28 10:53:19 +0800754 u64 control;
Dave Jones0e64a0c2009-02-04 14:37:50 -0500755
Matthew Garrette1f0b8e2012-09-04 08:28:09 +0000756 if (!data->acpi_data.state_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return;
758
Luis Henriques21335d02009-04-23 19:45:04 +0100759 control = data->acpi_data.states[index].control;
760 data->irt = (control >> IRT_SHIFT) & IRT_MASK;
761 data->rvo = (control >> RVO_SHIFT) & RVO_MASK;
762 data->exttype = (control >> EXT_TYPE_SHIFT) & EXT_TYPE_MASK;
763 data->plllock = (control >> PLL_L_SHIFT) & PLL_L_MASK;
764 data->vidmvs = 1 << ((control >> MVS_SHIFT) & MVS_MASK);
765 data->vstable = (control >> VST_SHIFT) & VST_MASK;
766}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
768static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
769{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 struct cpufreq_frequency_table *powernow_table;
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800771 int ret_val = -ENODEV;
Lin Ming439913f2010-01-28 10:53:19 +0800772 u64 control, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700774 if (acpi_processor_register_performance(&data->acpi_data, data->cpu)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200775 pr_debug("register performance failed: bad ACPI data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 return -EIO;
777 }
778
779 /* verify the data contained in the ACPI structures */
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700780 if (data->acpi_data.state_count <= 1) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200781 pr_debug("No ACPI P-States\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 goto err_out;
783 }
784
Dave Jones2c701b12009-06-05 12:37:07 -0400785 control = data->acpi_data.control_register.space_id;
786 status = data->acpi_data.status_register.space_id;
787
788 if ((control != ACPI_ADR_SPACE_FIXED_HARDWARE) ||
789 (status != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200790 pr_debug("Invalid control/status registers (%llx - %llx)\n",
Dave Jones2c701b12009-06-05 12:37:07 -0400791 control, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 goto err_out;
793 }
794
795 /* fill in data->powernow_table */
796 powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700797 * (data->acpi_data.state_count + 1)), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (!powernow_table) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200799 pr_debug("powernow_table memory alloc failure\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 goto err_out;
801 }
802
Mark Langsdorfdb39d552009-08-21 19:15:28 -0500803 /* fill in data */
804 data->numps = data->acpi_data.state_count;
805 powernow_k8_acpi_pst_values(data, 0);
806
Matthew Garrette1f0b8e2012-09-04 08:28:09 +0000807 ret_val = fill_powernow_table_fidvid(data, powernow_table);
Dave Jones1f729e02006-06-04 19:37:58 -0400808 if (ret_val)
809 goto err_out_mem;
810
Dave Jones0e64a0c2009-02-04 14:37:50 -0500811 powernow_table[data->acpi_data.state_count].frequency =
812 CPUFREQ_TABLE_END;
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700813 powernow_table[data->acpi_data.state_count].index = 0;
Dave Jones1f729e02006-06-04 19:37:58 -0400814 data->powernow_table = powernow_table;
815
Rusty Russell7ad728f2009-03-13 14:49:50 +1030816 if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
Mark Langsdorf2e497622007-04-30 14:15:05 -0500817 print_basics(data);
Dave Jones1f729e02006-06-04 19:37:58 -0400818
819 /* notify BIOS that we exist */
820 acpi_processor_notify_smm(THIS_MODULE);
821
Yinghai Lueaa95842009-06-06 14:51:36 -0700822 if (!zalloc_cpumask_var(&data->acpi_data.shared_cpu_map, GFP_KERNEL)) {
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800823 printk(KERN_ERR PFX
824 "unable to alloc powernow_k8_data cpumask\n");
825 ret_val = -ENOMEM;
826 goto err_out_mem;
827 }
828
Dave Jones1f729e02006-06-04 19:37:58 -0400829 return 0;
830
831err_out_mem:
832 kfree(powernow_table);
833
834err_out:
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700835 acpi_processor_unregister_performance(&data->acpi_data, data->cpu);
Dave Jones1f729e02006-06-04 19:37:58 -0400836
Dave Jones0e64a0c2009-02-04 14:37:50 -0500837 /* data->acpi_data.state_count informs us at ->exit()
838 * whether ACPI was used */
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700839 data->acpi_data.state_count = 0;
Dave Jones1f729e02006-06-04 19:37:58 -0400840
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800841 return ret_val;
Dave Jones1f729e02006-06-04 19:37:58 -0400842}
843
Dave Jones0e64a0c2009-02-04 14:37:50 -0500844static int fill_powernow_table_fidvid(struct powernow_k8_data *data,
845 struct cpufreq_frequency_table *powernow_table)
Dave Jones1f729e02006-06-04 19:37:58 -0400846{
847 int i;
Dave Jones0e64a0c2009-02-04 14:37:50 -0500848
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700849 for (i = 0; i < data->acpi_data.state_count; i++) {
Dave Jones094ce7f2005-07-29 12:55:40 -0700850 u32 fid;
851 u32 vid;
Dave Jones0e64a0c2009-02-04 14:37:50 -0500852 u32 freq, index;
Lin Ming439913f2010-01-28 10:53:19 +0800853 u64 status, control;
Dave Jones094ce7f2005-07-29 12:55:40 -0700854
855 if (data->exttype) {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500856 status = data->acpi_data.states[i].status;
857 fid = status & EXT_FID_MASK;
858 vid = (status >> VID_SHIFT) & EXT_VID_MASK;
Dave Jones841e40b2005-07-28 09:40:04 -0700859 } else {
Dave Jones0e64a0c2009-02-04 14:37:50 -0500860 control = data->acpi_data.states[i].control;
861 fid = control & FID_MASK;
862 vid = (control >> VID_SHIFT) & VID_MASK;
Dave Jones841e40b2005-07-28 09:40:04 -0700863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200865 pr_debug(" %d : fid 0x%x, vid 0x%x\n", i, fid, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Dave Jones0e64a0c2009-02-04 14:37:50 -0500867 index = fid | (vid<<8);
868 powernow_table[i].index = index;
869
870 freq = find_khz_freq_from_fid(fid);
871 powernow_table[i].frequency = freq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
873 /* verify frequency is OK */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500874 if ((freq > (MAX_FREQ * 1000)) || (freq < (MIN_FREQ * 1000))) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200875 pr_debug("invalid freq %u kHz, ignoring\n", freq);
Kurt Roeckxf0adb132009-09-16 11:09:32 -0400876 invalidate_entry(powernow_table, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 continue;
878 }
879
Dave Jones0e64a0c2009-02-04 14:37:50 -0500880 /* verify voltage is OK -
881 * BIOSs are using "off" to indicate invalid */
Dave Jones841e40b2005-07-28 09:40:04 -0700882 if (vid == VID_OFF) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200883 pr_debug("invalid vid %u, ignoring\n", vid);
Kurt Roeckxf0adb132009-09-16 11:09:32 -0400884 invalidate_entry(powernow_table, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 continue;
886 }
887
Dave Jones0e64a0c2009-02-04 14:37:50 -0500888 if (freq != (data->acpi_data.states[i].core_frequency * 1000)) {
889 printk(KERN_INFO PFX "invalid freq entries "
890 "%u kHz vs. %u kHz\n", freq,
891 (unsigned int)
892 (data->acpi_data.states[i].core_frequency
893 * 1000));
Kurt Roeckxf0adb132009-09-16 11:09:32 -0400894 invalidate_entry(powernow_table, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 continue;
896 }
897 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
901static void powernow_k8_cpu_exit_acpi(struct powernow_k8_data *data)
902{
Linus Torvaldsf607e3a2008-08-19 13:34:59 -0700903 if (data->acpi_data.state_count)
Dave Jones0e64a0c2009-02-04 14:37:50 -0500904 acpi_processor_unregister_performance(&data->acpi_data,
905 data->cpu);
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800906 free_cpumask_var(data->acpi_data.shared_cpu_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907}
908
Mark Langsdorf732553e2009-02-03 17:46:43 +0100909static int get_transition_latency(struct powernow_k8_data *data)
910{
911 int max_latency = 0;
912 int i;
913 for (i = 0; i < data->acpi_data.state_count; i++) {
914 int cur_latency = data->acpi_data.states[i].transition_latency
915 + data->acpi_data.states[i].bus_master_latency;
916 if (cur_latency > max_latency)
917 max_latency = cur_latency;
918 }
Thomas Renninger86e13682009-04-22 13:48:30 +0200919 if (max_latency == 0) {
Matthew Garrette1f0b8e2012-09-04 08:28:09 +0000920 pr_err(FW_WARN PFX "Invalid zero transition latency\n");
Thomas Renninger86e13682009-04-22 13:48:30 +0200921 max_latency = 1;
922 }
Mark Langsdorf732553e2009-02-03 17:46:43 +0100923 /* value in usecs, needs to be in nanoseconds */
924 return 1000 * max_latency;
925}
926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927/* Take a frequency, and issue the fid/vid transition command */
Dave Jones0e64a0c2009-02-04 14:37:50 -0500928static int transition_frequency_fidvid(struct powernow_k8_data *data,
929 unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930{
Dave Jones1f729e02006-06-04 19:37:58 -0400931 u32 fid = 0;
932 u32 vid = 0;
Dave Jones065b8072005-05-31 19:03:46 -0700933 int res, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 struct cpufreq_freqs freqs;
935
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200936 pr_debug("cpu %d transition to index %u\n", smp_processor_id(), index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Dave Jones1f729e02006-06-04 19:37:58 -0400938 /* fid/vid correctness check for k8 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 /* fid are the lower 8 bits of the index we stored into
Dave Jones1f729e02006-06-04 19:37:58 -0400940 * the cpufreq frequency table in find_psb_table, vid
941 * are the upper 8 bits.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 fid = data->powernow_table[index].index & 0xFF;
944 vid = (data->powernow_table[index].index & 0xFF00) >> 8;
945
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200946 pr_debug("table matched fid 0x%x, giving vid 0x%x\n", fid, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
948 if (query_current_values_with_pending_wait(data))
949 return 1;
950
951 if ((data->currvid == vid) && (data->currfid == fid)) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200952 pr_debug("target matches current values (fid 0x%x, vid 0x%x)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 fid, vid);
954 return 0;
955 }
956
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200957 pr_debug("cpu %d, changing to fid 0x%x, vid 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 smp_processor_id(), fid, vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 freqs.old = find_khz_freq_from_fid(data->currfid);
960 freqs.new = find_khz_freq_from_fid(fid);
Dave Jones1f729e02006-06-04 19:37:58 -0400961
Rusty Russell8e7c2592009-06-12 20:58:37 +0930962 for_each_cpu(i, data->available_cores) {
Dave Jones065b8072005-05-31 19:03:46 -0700963 freqs.cpu = i;
964 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 res = transition_fid_vid(data, fid, vid);
Konrad Rzeszutek Wilka9d3d202011-06-16 15:36:39 -0400968 if (res)
969 return res;
970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 freqs.new = find_khz_freq_from_fid(data->currfid);
Dave Jones1f729e02006-06-04 19:37:58 -0400972
Rusty Russell8e7c2592009-06-12 20:58:37 +0930973 for_each_cpu(i, data->available_cores) {
Dave Jones1f729e02006-06-04 19:37:58 -0400974 freqs.cpu = i;
975 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
976 }
977 return res;
978}
979
Tejun Heo68891252012-09-18 14:24:59 -0700980struct powernowk8_target_arg {
981 struct cpufreq_policy *pol;
982 unsigned targfreq;
983 unsigned relation;
984};
985
986static long powernowk8_target_fn(void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987{
Tejun Heo68891252012-09-18 14:24:59 -0700988 struct powernowk8_target_arg *pta = arg;
989 struct cpufreq_policy *pol = pta->pol;
990 unsigned targfreq = pta->targfreq;
991 unsigned relation = pta->relation;
travis@sgi.com2c6b8c02008-01-30 13:33:11 +0100992 struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
Adrian Bunk91800532006-04-19 00:07:28 +0200993 u32 checkfid;
994 u32 checkvid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 unsigned int newstate;
Tejun Heo68891252012-09-18 14:24:59 -0700996 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Jacob Shin4211a302006-04-07 19:49:51 +0200998 if (!data)
999 return -EINVAL;
1000
Adrian Bunk91800532006-04-19 00:07:28 +02001001 checkfid = data->currfid;
1002 checkvid = data->currvid;
1003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 if (pending_bit_stuck()) {
1005 printk(KERN_ERR PFX "failing targ, change pending bit set\n");
Tejun Heo68891252012-09-18 14:24:59 -07001006 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 }
1008
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001009 pr_debug("targ: cpu %d, %d kHz, min %d, max %d, relation %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 pol->cpu, targfreq, pol->min, pol->max, relation);
1011
Dave Jones83844512006-05-30 17:43:54 -04001012 if (query_current_values_with_pending_wait(data))
Tejun Heo68891252012-09-18 14:24:59 -07001013 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001015 pr_debug("targ: curr fid 0x%x, vid 0x%x\n",
1016 data->currfid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001018 if ((checkvid != data->currvid) ||
1019 (checkfid != data->currfid)) {
1020 pr_info(PFX
1021 "error - out of sync, fix 0x%x 0x%x, vid 0x%x 0x%x\n",
1022 checkfid, data->currfid,
1023 checkvid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 }
1025
Dave Jones0e64a0c2009-02-04 14:37:50 -05001026 if (cpufreq_frequency_table_target(pol, data->powernow_table,
1027 targfreq, relation, &newstate))
Tejun Heo68891252012-09-18 14:24:59 -07001028 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001030 mutex_lock(&fidvid_mutex);
Dave Jones065b8072005-05-31 19:03:46 -07001031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 powernow_k8_acpi_pst_values(data, newstate);
1033
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001034 ret = transition_frequency_fidvid(data, newstate);
1035
Dave Jones1f729e02006-06-04 19:37:58 -04001036 if (ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 printk(KERN_ERR PFX "transition frequency failed\n");
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001038 mutex_unlock(&fidvid_mutex);
Tejun Heo68891252012-09-18 14:24:59 -07001039 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 }
Ingo Molnar14cc3e22006-03-26 01:37:14 -08001041 mutex_unlock(&fidvid_mutex);
Dave Jones065b8072005-05-31 19:03:46 -07001042
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001043 pol->cur = find_khz_freq_from_fid(data->currfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
Tejun Heo68891252012-09-18 14:24:59 -07001045 return 0;
1046}
1047
1048/* Driver entry point to switch to the target frequency */
1049static int powernowk8_target(struct cpufreq_policy *pol,
1050 unsigned targfreq, unsigned relation)
1051{
1052 struct powernowk8_target_arg pta = { .pol = pol, .targfreq = targfreq,
1053 .relation = relation };
1054
Andreas Herrmanne4df1cb2012-10-23 00:55:10 +02001055 return work_on_cpu(pol->cpu, powernowk8_target_fn, &pta);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056}
1057
1058/* Driver entry point to verify the policy and range of frequencies */
1059static int powernowk8_verify(struct cpufreq_policy *pol)
1060{
travis@sgi.com2c6b8c02008-01-30 13:33:11 +01001061 struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Jacob Shin4211a302006-04-07 19:49:51 +02001063 if (!data)
1064 return -EINVAL;
1065
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 return cpufreq_frequency_table_verify(pol, data->powernow_table);
1067}
1068
Rusty Russell1ff6e972009-06-12 20:55:37 +09301069struct init_on_cpu {
1070 struct powernow_k8_data *data;
1071 int rc;
1072};
1073
1074static void __cpuinit powernowk8_cpu_init_on_cpu(void *_init_on_cpu)
1075{
1076 struct init_on_cpu *init_on_cpu = _init_on_cpu;
1077
1078 if (pending_bit_stuck()) {
1079 printk(KERN_ERR PFX "failing init, change pending bit set\n");
1080 init_on_cpu->rc = -ENODEV;
1081 return;
1082 }
1083
1084 if (query_current_values_with_pending_wait(init_on_cpu->data)) {
1085 init_on_cpu->rc = -ENODEV;
1086 return;
1087 }
1088
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001089 fidvid_msr_init();
Rusty Russell1ff6e972009-06-12 20:55:37 +09301090
1091 init_on_cpu->rc = 0;
1092}
1093
Borislav Petkov56835e62012-09-05 00:50:26 +02001094static const char missing_pss_msg[] =
1095 KERN_ERR
1096 FW_BUG PFX "No compatible ACPI _PSS objects found.\n"
1097 FW_BUG PFX "First, make sure Cool'N'Quiet is enabled in the BIOS.\n"
1098 FW_BUG PFX "If that doesn't help, try upgrading your BIOS.\n";
1099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100/* per CPU init entry point to the driver */
Andi Kleenaa41eb92006-01-16 01:56:36 +01001101static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102{
1103 struct powernow_k8_data *data;
Rusty Russell1ff6e972009-06-12 20:55:37 +09301104 struct init_on_cpu init_on_cpu;
Andi Kleend7fa7062006-04-07 19:49:48 +02001105 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Jacob Shin8aae8282005-11-21 07:23:08 -08001107 if (!cpu_online(pol->cpu))
1108 return -ENODEV;
1109
Rusty Russell1ff6e972009-06-12 20:55:37 +09301110 smp_call_function_single(pol->cpu, check_supported_cpu, &rc, 1);
1111 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 return -ENODEV;
1113
Dave Jonesbfdc7082005-10-20 15:16:15 -07001114 data = kzalloc(sizeof(struct powernow_k8_data), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 if (!data) {
1116 printk(KERN_ERR PFX "unable to alloc powernow_k8_data");
1117 return -ENOMEM;
1118 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
1120 data->cpu = pol->cpu;
1121
Rusty Russella0abd522009-02-16 17:31:58 -06001122 if (powernow_k8_cpu_init_acpi(data)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 /*
Lucas De Marchi0d2eb442011-03-17 16:24:16 -03001124 * Use the PSB BIOS structure. This is only available on
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 * an UP version, and is deprecated by AMD.
1126 */
Randy Dunlap9ed059e2006-06-20 22:32:56 -07001127 if (num_online_cpus() != 1) {
Borislav Petkov56835e62012-09-05 00:50:26 +02001128 printk_once(missing_pss_msg);
Dave Jones0cb8bc22009-02-18 14:11:00 -05001129 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
1131 if (pol->cpu != 0) {
Thomas Renninger2fd47092008-09-01 14:27:03 +02001132 printk(KERN_ERR FW_BUG PFX "No ACPI _PSS objects for "
1133 "CPU other than CPU0. Complain to your BIOS "
1134 "vendor.\n");
Dave Jones0cb8bc22009-02-18 14:11:00 -05001135 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 }
1137 rc = find_psb_table(data);
Dave Jones0cb8bc22009-02-18 14:11:00 -05001138 if (rc)
1139 goto err_out;
1140
Mark Langsdorf732553e2009-02-03 17:46:43 +01001141 /* Take a crude guess here.
1142 * That guess was in microseconds, so multiply with 1000 */
1143 pol->cpuinfo.transition_latency = (
1144 ((data->rvo + 8) * data->vstable * VST_UNITS_20US) +
1145 ((1 << data->irt) * 30)) * 1000;
1146 } else /* ACPI _PSS objects available */
1147 pol->cpuinfo.transition_latency = get_transition_latency(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
1149 /* only run on specific CPU from here on */
Rusty Russell1ff6e972009-06-12 20:55:37 +09301150 init_on_cpu.data = data;
1151 smp_call_function_single(data->cpu, powernowk8_cpu_init_on_cpu,
1152 &init_on_cpu, 1);
1153 rc = init_on_cpu.rc;
1154 if (rc != 0)
1155 goto err_out_exit_acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001157 cpumask_copy(pol->cpus, cpu_core_mask(pol->cpu));
Rusty Russell835481d2009-01-04 05:18:06 -08001158 data->available_cores = pol->cpus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001160 pol->cur = find_khz_freq_from_fid(data->currfid);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001161 pr_debug("policy current frequency %d kHz\n", pol->cur);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
1163 /* min/max the cpu is capable of */
1164 if (cpufreq_frequency_table_cpuinfo(pol, data->powernow_table)) {
Thomas Renninger2fd47092008-09-01 14:27:03 +02001165 printk(KERN_ERR FW_BUG PFX "invalid powernow_table\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 powernow_k8_cpu_exit_acpi(data);
1167 kfree(data->powernow_table);
1168 kfree(data);
1169 return -EINVAL;
1170 }
1171
1172 cpufreq_frequency_table_get_attr(data->powernow_table, pol->cpu);
1173
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001174 pr_debug("cpu_init done, current fid 0x%x, vid 0x%x\n",
1175 data->currfid, data->currvid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
travis@sgi.com2c6b8c02008-01-30 13:33:11 +01001177 per_cpu(powernow_data, pol->cpu) = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 return 0;
1180
Rusty Russell1ff6e972009-06-12 20:55:37 +09301181err_out_exit_acpi:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 powernow_k8_cpu_exit_acpi(data);
1183
Dave Jones0cb8bc22009-02-18 14:11:00 -05001184err_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 kfree(data);
1186 return -ENODEV;
1187}
1188
Bill Pembertonc0e61cb2012-11-21 01:18:49 +01001189static int powernowk8_cpu_exit(struct cpufreq_policy *pol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
travis@sgi.com2c6b8c02008-01-30 13:33:11 +01001191 struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193 if (!data)
1194 return -EINVAL;
1195
1196 powernow_k8_cpu_exit_acpi(data);
1197
1198 cpufreq_frequency_table_put_attr(pol->cpu);
1199
1200 kfree(data->powernow_table);
1201 kfree(data);
Thomas Renninger557a7012009-12-14 11:44:15 +01001202 per_cpu(powernow_data, pol->cpu) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
1204 return 0;
1205}
1206
Rusty Russell1ff6e972009-06-12 20:55:37 +09301207static void query_values_on_cpu(void *_err)
1208{
1209 int *err = _err;
Tejun Heo0a3aee02010-12-18 16:28:55 +01001210 struct powernow_k8_data *data = __this_cpu_read(powernow_data);
Rusty Russell1ff6e972009-06-12 20:55:37 +09301211
1212 *err = query_current_values_with_pending_wait(data);
1213}
1214
Dave Jones0e64a0c2009-02-04 14:37:50 -05001215static unsigned int powernowk8_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216{
Naga Chumbalkare15bc452009-06-11 15:26:54 +00001217 struct powernow_k8_data *data = per_cpu(powernow_data, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 unsigned int khz = 0;
Rusty Russell1ff6e972009-06-12 20:55:37 +09301219 int err;
shin, jacobeef51672006-03-27 09:57:20 -06001220
1221 if (!data)
Thomas Renninger557a7012009-12-14 11:44:15 +01001222 return 0;
shin, jacobeef51672006-03-27 09:57:20 -06001223
Rusty Russell1ff6e972009-06-12 20:55:37 +09301224 smp_call_function_single(cpu, query_values_on_cpu, &err, true);
1225 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 goto out;
1227
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001228 khz = find_khz_freq_from_fid(data->currfid);
Joachim Deguara58389a82007-01-30 16:53:54 +01001229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
Dave Jonesb9111b72005-09-23 11:10:42 -07001231out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 return khz;
1233}
1234
Dave Jones0e64a0c2009-02-04 14:37:50 -05001235static struct freq_attr *powernow_k8_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 &cpufreq_freq_attr_scaling_available_freqs,
1237 NULL,
1238};
1239
Linus Torvalds221dee22007-02-26 14:55:48 -08001240static struct cpufreq_driver cpufreq_amd64_driver = {
Thomas Renningere2f74f32009-11-19 12:31:01 +01001241 .verify = powernowk8_verify,
1242 .target = powernowk8_target,
1243 .bios_limit = acpi_processor_get_bios_limit,
1244 .init = powernowk8_cpu_init,
Bill Pembertonce2650d2012-11-21 01:18:30 +01001245 .exit = powernowk8_cpu_exit,
Thomas Renningere2f74f32009-11-19 12:31:01 +01001246 .get = powernowk8_get,
1247 .name = "powernow-k8",
1248 .owner = THIS_MODULE,
1249 .attr = powernow_k8_attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250};
1251
Borislav Petkov4827ea62013-01-20 10:24:29 +00001252static void __request_acpi_cpufreq(void)
1253{
1254 const char *cur_drv, *drv = "acpi-cpufreq";
1255
1256 cur_drv = cpufreq_get_current_driver();
1257 if (!cur_drv)
1258 goto request;
1259
1260 if (strncmp(cur_drv, drv, min_t(size_t, strlen(cur_drv), strlen(drv))))
1261 pr_warn(PFX "WTF driver: %s\n", cur_drv);
1262
1263 return;
1264
1265 request:
1266 pr_warn(PFX "This CPU is not supported anymore, using acpi-cpufreq instead.\n");
1267 request_module(drv);
1268}
1269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270/* driver entry point for init */
Andi Kleenaa41eb92006-01-16 01:56:36 +01001271static int __cpuinit powernowk8_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001273 unsigned int i, supported_cpus = 0;
Borislav Petkovc0939e42013-01-20 10:24:30 +00001274 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001276 if (static_cpu_has(X86_FEATURE_HW_PSTATE)) {
Borislav Petkov4827ea62013-01-20 10:24:29 +00001277 __request_acpi_cpufreq();
Matthew Garrette1f0b8e2012-09-04 08:28:09 +00001278 return -ENODEV;
1279 }
1280
Andi Kleenfa8031a2012-01-26 00:09:12 +01001281 if (!x86_match_cpu(powernow_k8_ids))
1282 return -ENODEV;
1283
Borislav Petkovc0939e42013-01-20 10:24:30 +00001284 get_online_cpus();
Andrew Mortona7201152006-03-24 03:15:07 -08001285 for_each_online_cpu(i) {
Borislav Petkovc0939e42013-01-20 10:24:30 +00001286 smp_call_function_single(i, check_supported_cpu, &ret, 1);
1287 if (!ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 supported_cpus++;
1289 }
1290
Borislav Petkovc0939e42013-01-20 10:24:30 +00001291 if (supported_cpus != num_online_cpus()) {
1292 put_online_cpus();
Borislav Petkov73860c62010-03-31 21:56:42 +02001293 return -ENODEV;
Borislav Petkovc0939e42013-01-20 10:24:30 +00001294 }
1295 put_online_cpus();
Borislav Petkov73860c62010-03-31 21:56:42 +02001296
Borislav Petkovc0939e42013-01-20 10:24:30 +00001297 ret = cpufreq_register_driver(&cpufreq_amd64_driver);
1298 if (ret)
1299 return ret;
Andre Przywaraa2060952012-09-04 08:28:05 +00001300
Borislav Petkovc0939e42013-01-20 10:24:30 +00001301 pr_info(PFX "Found %d %s (%d cpu cores) (" VERSION ")\n",
1302 num_online_nodes(), boot_cpu_data.x86_model_id, supported_cpus);
Andre Przywaraa2060952012-09-04 08:28:05 +00001303
Borislav Petkovc0939e42013-01-20 10:24:30 +00001304 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305}
1306
1307/* driver entry point for term */
1308static void __exit powernowk8_exit(void)
1309{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +02001310 pr_debug("exit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311
1312 cpufreq_unregister_driver(&cpufreq_amd64_driver);
1313}
1314
Dave Jones0e64a0c2009-02-04 14:37:50 -05001315MODULE_AUTHOR("Paul Devriendt <paul.devriendt@amd.com> and "
1316 "Mark Langsdorf <mark.langsdorf@amd.com>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317MODULE_DESCRIPTION("AMD Athlon 64 and Opteron processor frequency driver.");
1318MODULE_LICENSE("GPL");
1319
1320late_initcall(powernowk8_init);
1321module_exit(powernowk8_exit);