2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Cyrix MediaGX and NatSemi Geode Suspend Modulation
|
|
|
|
* (C) 2002 Zwane Mwaikambo <zwane@commfireservices.com>
|
|
|
|
* (C) 2002 Hiroshi Miura <miura@da-cha.org>
|
|
|
|
* All Rights Reserved
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
2006-02-27 22:43:23 -07:00
|
|
|
* version 2 as published by the Free Software Foundation
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* The author(s) of this software shall not be held liable for damages
|
|
|
|
* of any nature resulting due to the use of this software. This
|
|
|
|
* software is provided AS-IS with no warranties.
|
2006-02-27 22:43:23 -07:00
|
|
|
*
|
2007-10-19 17:13:56 -06:00
|
|
|
* Theoretical note:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* (see Geode(tm) CS5530 manual (rev.4.1) page.56)
|
|
|
|
*
|
|
|
|
* CPU frequency control on NatSemi Geode GX1/GXLV processor and CS55x0
|
2007-10-19 17:13:56 -06:00
|
|
|
* are based on Suspend Modulation.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Suspend Modulation works by asserting and de-asserting the SUSP# pin
|
|
|
|
* to CPU(GX1/GXLV) for configurable durations. When asserting SUSP#
|
2006-02-27 22:43:23 -07:00
|
|
|
* the CPU enters an idle state. GX1 stops its core clock when SUSP# is
|
2005-04-16 16:20:36 -06:00
|
|
|
* asserted then power consumption is reduced.
|
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* Suspend Modulation's OFF/ON duration are configurable
|
2005-04-16 16:20:36 -06:00
|
|
|
* with 'Suspend Modulation OFF Count Register'
|
|
|
|
* and 'Suspend Modulation ON Count Register'.
|
2006-02-27 22:43:23 -07:00
|
|
|
* These registers are 8bit counters that represent the number of
|
2005-04-16 16:20:36 -06:00
|
|
|
* 32us intervals which the SUSP# pin is asserted(ON)/de-asserted(OFF)
|
|
|
|
* to the processor.
|
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* These counters define a ratio which is the effective frequency
|
|
|
|
* of operation of the system.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* OFF Count
|
|
|
|
* F_eff = Fgx * ----------------------
|
|
|
|
* OFF Count + ON Count
|
|
|
|
*
|
|
|
|
* 0 <= On Count, Off Count <= 255
|
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* From these limits, we can get register values
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* off_duration + on_duration <= MAX_DURATION
|
|
|
|
* on_duration = off_duration * (stock_freq - freq) / freq
|
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* off_duration = (freq * DURATION) / stock_freq
|
|
|
|
* on_duration = DURATION - off_duration
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*
|
|
|
|
*---------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* ChangeLog:
|
2006-02-27 22:43:23 -07:00
|
|
|
* Dec. 12, 2003 Hiroshi Miura <miura@da-cha.org>
|
|
|
|
* - fix on/off register mistake
|
|
|
|
* - fix cpu_khz calc when it stops cpu modulation.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* Dec. 11, 2002 Hiroshi Miura <miura@da-cha.org>
|
|
|
|
* - rewrite for Cyrix MediaGX Cx5510/5520 and
|
2005-04-16 16:20:36 -06:00
|
|
|
* NatSemi Geode Cs5530(A).
|
|
|
|
*
|
|
|
|
* Jul. ??, 2002 Zwane Mwaikambo <zwane@commfireservices.com>
|
|
|
|
* - cs5530_mod patch for 2.4.19-rc1.
|
|
|
|
*
|
|
|
|
*---------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* Todo
|
|
|
|
* Test on machines with 5510, 5530, 5530A
|
|
|
|
*/
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* Suspend Modulation - Definitions *
|
|
|
|
************************************************************************/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
2006-02-27 22:43:23 -07:00
|
|
|
#include <linux/module.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/cpufreq.h>
|
|
|
|
#include <linux/pci.h>
|
2009-01-17 21:06:57 -07:00
|
|
|
#include <linux/errno.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-01-17 21:06:57 -07:00
|
|
|
|
2012-01-25 16:09:12 -07:00
|
|
|
#include <asm/cpu_device_id.h>
|
2007-07-22 03:12:38 -06:00
|
|
|
#include <asm/processor-cyrix.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* PCI config registers, all at F0 */
|
2006-02-27 22:43:23 -07:00
|
|
|
#define PCI_PMER1 0x80 /* power management enable register 1 */
|
|
|
|
#define PCI_PMER2 0x81 /* power management enable register 2 */
|
|
|
|
#define PCI_PMER3 0x82 /* power management enable register 3 */
|
|
|
|
#define PCI_IRQTC 0x8c /* irq speedup timer counter register:typical 2 to 4ms */
|
|
|
|
#define PCI_VIDTC 0x8d /* video speedup timer counter register: typical 50 to 100ms */
|
|
|
|
#define PCI_MODOFF 0x94 /* suspend modulation OFF counter register, 1 = 32us */
|
|
|
|
#define PCI_MODON 0x95 /* suspend modulation ON counter register */
|
|
|
|
#define PCI_SUSCFG 0x96 /* suspend configuration register */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* PMER1 bits */
|
2006-02-27 22:43:23 -07:00
|
|
|
#define GPM (1<<0) /* global power management */
|
|
|
|
#define GIT (1<<1) /* globally enable PM device idle timers */
|
|
|
|
#define GTR (1<<2) /* globally enable IO traps */
|
|
|
|
#define IRQ_SPDUP (1<<3) /* disable clock throttle during interrupt handling */
|
|
|
|
#define VID_SPDUP (1<<4) /* disable clock throttle during vga video handling */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* SUSCFG bits */
|
2006-02-27 22:43:23 -07:00
|
|
|
#define SUSMOD (1<<0) /* enable/disable suspend modulation */
|
2007-10-19 17:13:56 -06:00
|
|
|
/* the below is supported only with cs5530 (after rev.1.2)/cs5530A */
|
2006-02-27 22:43:23 -07:00
|
|
|
#define SMISPDUP (1<<1) /* select how SMI re-enable suspend modulation: */
|
|
|
|
/* IRQTC timer or read SMI speedup disable reg.(F1BAR[08-09h]) */
|
|
|
|
#define SUSCFG (1<<2) /* enable powering down a GXLV processor. "Special 3Volt Suspend" mode */
|
2007-10-19 17:13:56 -06:00
|
|
|
/* the below is supported only with cs5530A */
|
2006-02-27 22:43:23 -07:00
|
|
|
#define PWRSVE_ISA (1<<3) /* stop ISA clock */
|
|
|
|
#define PWRSVE (1<<4) /* active idle */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct gxfreq_params {
|
|
|
|
u8 on_duration;
|
|
|
|
u8 off_duration;
|
|
|
|
u8 pci_suscfg;
|
|
|
|
u8 pci_pmer1;
|
|
|
|
u8 pci_pmer2;
|
|
|
|
struct pci_dev *cs55x0;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gxfreq_params *gx_params;
|
|
|
|
static int stock_freq;
|
|
|
|
|
|
|
|
/* PCI bus clock - defaults to 30.000 if cpu_khz is not available */
|
2009-01-17 21:06:57 -07:00
|
|
|
static int pci_busclk;
|
|
|
|
module_param(pci_busclk, int, 0444);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* maximum duration for which the cpu may be suspended
|
|
|
|
* (32us * MAX_DURATION). If no parameter is given, this defaults
|
2006-02-27 22:43:23 -07:00
|
|
|
* to 255.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Note that this leads to a maximum of 8 ms(!) where the CPU clock
|
|
|
|
* is suspended -- processing power is just 0.39% of what it used to be,
|
|
|
|
* though. 781.25 kHz(!) for a 200 MHz processor -- wow. */
|
|
|
|
static int max_duration = 255;
|
2009-01-17 21:06:57 -07:00
|
|
|
module_param(max_duration, int, 0444);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* For the default policy, we want at least some processing power
|
|
|
|
* - let's say 5%. (min = maxfreq / POLICY_MIN_DIV)
|
|
|
|
*/
|
|
|
|
#define POLICY_MIN_DIV 20
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-02-27 22:43:23 -07:00
|
|
|
* we can detect a core multipiler from dir0_lsb
|
|
|
|
* from GX1 datasheet p.56,
|
|
|
|
* MULT[3:0]:
|
|
|
|
* 0000 = SYSCLK multiplied by 4 (test only)
|
|
|
|
* 0001 = SYSCLK multiplied by 10
|
|
|
|
* 0010 = SYSCLK multiplied by 4
|
|
|
|
* 0011 = SYSCLK multiplied by 6
|
|
|
|
* 0100 = SYSCLK multiplied by 9
|
|
|
|
* 0101 = SYSCLK multiplied by 5
|
|
|
|
* 0110 = SYSCLK multiplied by 7
|
|
|
|
* 0111 = SYSCLK multiplied by 8
|
2005-04-16 16:20:36 -06:00
|
|
|
* of 33.3MHz
|
|
|
|
**/
|
|
|
|
static int gx_freq_mult[16] = {
|
|
|
|
4, 10, 4, 6, 9, 5, 7, 8,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
2006-02-27 22:43:23 -07:00
|
|
|
* Low Level chipset interface *
|
2005-04-16 16:20:36 -06:00
|
|
|
****************************************************************/
|
|
|
|
static struct pci_device_id gx_chipset_tbl[] __initdata = {
|
2010-07-15 12:36:41 -06:00
|
|
|
{ PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY), },
|
|
|
|
{ PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5520), },
|
|
|
|
{ PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5510), },
|
2006-02-27 22:43:23 -07:00
|
|
|
{ 0, },
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2012-01-30 07:47:28 -07:00
|
|
|
MODULE_DEVICE_TABLE(pci, gx_chipset_tbl);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
static void gx_write_byte(int reg, int value)
|
|
|
|
{
|
|
|
|
pci_write_config_byte(gx_params->cs55x0, reg, value);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2006-02-27 22:43:23 -07:00
|
|
|
* gx_detect_chipset:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
**/
|
2013-08-13 04:20:08 -06:00
|
|
|
static struct pci_dev * __init gx_detect_chipset(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pci_dev *gx_pci = NULL;
|
|
|
|
|
|
|
|
/* detect which companion chip is used */
|
2010-07-03 10:03:55 -06:00
|
|
|
for_each_pci_dev(gx_pci) {
|
2006-02-27 22:43:23 -07:00
|
|
|
if ((pci_match_id(gx_chipset_tbl, gx_pci)) != NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return gx_pci;
|
|
|
|
}
|
|
|
|
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("error: no supported chipset found!\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-02-27 22:43:23 -07:00
|
|
|
* gx_get_cpuspeed:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2009-01-17 21:06:57 -07:00
|
|
|
* Finds out at which efficient frequency the Cyrix MediaGX/NatSemi
|
|
|
|
* Geode CPU runs.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static unsigned int gx_get_cpuspeed(unsigned int cpu)
|
|
|
|
{
|
2006-02-27 22:43:23 -07:00
|
|
|
if ((gx_params->pci_suscfg & SUSMOD) == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return stock_freq;
|
|
|
|
|
2006-02-27 22:43:23 -07:00
|
|
|
return (stock_freq * gx_params->off_duration)
|
2005-04-16 16:20:36 -06:00
|
|
|
/ (gx_params->on_duration + gx_params->off_duration);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gx_validate_speed:
|
|
|
|
* determine current cpu speed
|
2006-02-27 22:43:23 -07:00
|
|
|
*
|
|
|
|
**/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
static unsigned int gx_validate_speed(unsigned int khz, u8 *on_duration,
|
|
|
|
u8 *off_duration)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
u8 tmp_on, tmp_off;
|
|
|
|
int old_tmp_freq = stock_freq;
|
|
|
|
int tmp_freq;
|
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
*off_duration = 1;
|
|
|
|
*on_duration = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
for (i = max_duration; i > 0; i--) {
|
2006-02-27 22:43:23 -07:00
|
|
|
tmp_off = ((khz * i) / stock_freq) & 0xff;
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp_on = i - tmp_off;
|
|
|
|
tmp_freq = (stock_freq * tmp_off) / i;
|
|
|
|
/* if this relation is closer to khz, use this. If it's equal,
|
|
|
|
* prefer it, too - lower latency */
|
|
|
|
if (abs(tmp_freq - khz) <= abs(old_tmp_freq - khz)) {
|
|
|
|
*on_duration = tmp_on;
|
|
|
|
*off_duration = tmp_off;
|
|
|
|
old_tmp_freq = tmp_freq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return old_tmp_freq;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2006-02-27 22:43:23 -07:00
|
|
|
* gx_set_cpuspeed:
|
|
|
|
* set cpu speed in khz.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
|
|
|
|
2013-03-24 00:26:43 -06:00
|
|
|
static void gx_set_cpuspeed(struct cpufreq_policy *policy, unsigned int khz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-02-27 22:43:23 -07:00
|
|
|
u8 suscfg, pmer1;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int new_khz;
|
|
|
|
unsigned long flags;
|
|
|
|
struct cpufreq_freqs freqs;
|
|
|
|
|
|
|
|
freqs.old = gx_get_cpuspeed(0);
|
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
new_khz = gx_validate_speed(khz, &gx_params->on_duration,
|
|
|
|
&gx_params->off_duration);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
freqs.new = new_khz;
|
|
|
|
|
2013-03-24 00:26:43 -06:00
|
|
|
cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
|
2005-04-16 16:20:36 -06:00
|
|
|
local_irq_save(flags);
|
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
if (new_khz != stock_freq) {
|
|
|
|
/* if new khz == 100% of CPU speed, it is special case */
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (gx_params->cs55x0->device) {
|
|
|
|
case PCI_DEVICE_ID_CYRIX_5530_LEGACY:
|
|
|
|
pmer1 = gx_params->pci_pmer1 | IRQ_SPDUP | VID_SPDUP;
|
|
|
|
/* FIXME: need to test other values -- Zwane,Miura */
|
2009-01-17 21:06:57 -07:00
|
|
|
/* typical 2 to 4ms */
|
|
|
|
gx_write_byte(PCI_IRQTC, 4);
|
|
|
|
/* typical 50 to 100ms */
|
|
|
|
gx_write_byte(PCI_VIDTC, 100);
|
|
|
|
gx_write_byte(PCI_PMER1, pmer1);
|
|
|
|
|
|
|
|
if (gx_params->cs55x0->revision < 0x10) {
|
|
|
|
/* CS5530(rev 1.2, 1.3) */
|
|
|
|
suscfg = gx_params->pci_suscfg|SUSMOD;
|
|
|
|
} else {
|
|
|
|
/* CS5530A,B.. */
|
|
|
|
suscfg = gx_params->pci_suscfg|SUSMOD|PWRSVE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PCI_DEVICE_ID_CYRIX_5520:
|
|
|
|
case PCI_DEVICE_ID_CYRIX_5510:
|
|
|
|
suscfg = gx_params->pci_suscfg | SUSMOD;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
local_irq_restore(flags);
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("fatal: try to set unknown chipset.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
suscfg = gx_params->pci_suscfg & ~(SUSMOD);
|
|
|
|
gx_params->off_duration = 0;
|
|
|
|
gx_params->on_duration = 0;
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("suspend modulation disabled: cpu runs 100%% speed.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
gx_write_byte(PCI_MODOFF, gx_params->off_duration);
|
|
|
|
gx_write_byte(PCI_MODON, gx_params->on_duration);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
gx_write_byte(PCI_SUSCFG, suscfg);
|
2006-02-27 22:43:23 -07:00
|
|
|
pci_read_config_byte(gx_params->cs55x0, PCI_SUSCFG, &suscfg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-27 22:43:23 -07:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
gx_params->pci_suscfg = suscfg;
|
|
|
|
|
2013-03-24 00:26:43 -06:00
|
|
|
cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("suspend modulation w/ duration of ON:%d us, OFF:%d us\n",
|
2006-02-27 22:43:23 -07:00
|
|
|
gx_params->on_duration * 32, gx_params->off_duration * 32);
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("suspend modulation w/ clock speed: %d kHz.\n", freqs.new);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
* High level functions *
|
|
|
|
****************************************************************/
|
|
|
|
|
|
|
|
/*
|
2006-02-27 22:43:23 -07:00
|
|
|
* cpufreq_gx_verify: test if frequency range is valid
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-02-27 22:43:23 -07:00
|
|
|
* This function checks if a given frequency range in kHz is valid
|
|
|
|
* for the hardware supported by the driver.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int cpufreq_gx_verify(struct cpufreq_policy *policy)
|
|
|
|
{
|
|
|
|
unsigned int tmp_freq = 0;
|
|
|
|
u8 tmp1, tmp2;
|
|
|
|
|
2006-02-27 22:43:23 -07:00
|
|
|
if (!stock_freq || !policy)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
policy->cpu = 0;
|
2009-01-17 21:06:57 -07:00
|
|
|
cpufreq_verify_within_limits(policy, (stock_freq / max_duration),
|
|
|
|
stock_freq);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* it needs to be assured that at least one supported frequency is
|
|
|
|
* within policy->min and policy->max. If it is not, policy->max
|
|
|
|
* needs to be increased until one freuqency is supported.
|
2006-02-27 22:43:23 -07:00
|
|
|
* policy->min may not be decreased, though. This way we guarantee a
|
2005-04-16 16:20:36 -06:00
|
|
|
* specific processing capacity.
|
|
|
|
*/
|
|
|
|
tmp_freq = gx_validate_speed(policy->min, &tmp1, &tmp2);
|
2006-02-27 22:43:23 -07:00
|
|
|
if (tmp_freq < policy->min)
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp_freq += stock_freq / max_duration;
|
|
|
|
policy->min = tmp_freq;
|
2006-02-27 22:43:23 -07:00
|
|
|
if (policy->min > policy->max)
|
2005-04-16 16:20:36 -06:00
|
|
|
policy->max = tmp_freq;
|
|
|
|
tmp_freq = gx_validate_speed(policy->max, &tmp1, &tmp2);
|
|
|
|
if (tmp_freq > policy->max)
|
|
|
|
tmp_freq -= stock_freq / max_duration;
|
|
|
|
policy->max = tmp_freq;
|
|
|
|
if (policy->max < policy->min)
|
|
|
|
policy->max = policy->min;
|
2009-01-17 21:06:57 -07:00
|
|
|
cpufreq_verify_within_limits(policy, (stock_freq / max_duration),
|
|
|
|
stock_freq);
|
2006-02-27 22:43:23 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-02-27 22:43:23 -07:00
|
|
|
* cpufreq_gx_target:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int cpufreq_gx_target(struct cpufreq_policy *policy,
|
|
|
|
unsigned int target_freq,
|
|
|
|
unsigned int relation)
|
|
|
|
{
|
|
|
|
u8 tmp1, tmp2;
|
|
|
|
unsigned int tmp_freq;
|
|
|
|
|
2006-02-27 22:43:23 -07:00
|
|
|
if (!stock_freq || !policy)
|
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
policy->cpu = 0;
|
|
|
|
|
|
|
|
tmp_freq = gx_validate_speed(target_freq, &tmp1, &tmp2);
|
|
|
|
while (tmp_freq < policy->min) {
|
|
|
|
tmp_freq += stock_freq / max_duration;
|
|
|
|
tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2);
|
|
|
|
}
|
|
|
|
while (tmp_freq > policy->max) {
|
|
|
|
tmp_freq -= stock_freq / max_duration;
|
|
|
|
tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2);
|
|
|
|
}
|
|
|
|
|
2013-03-24 00:26:43 -06:00
|
|
|
gx_set_cpuspeed(policy, tmp_freq);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cpufreq_gx_cpu_init(struct cpufreq_policy *policy)
|
|
|
|
{
|
2013-10-03 08:58:43 -06:00
|
|
|
unsigned int maxfreq;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!policy || policy->cpu != 0)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* determine maximum frequency */
|
2009-01-17 21:06:57 -07:00
|
|
|
if (pci_busclk)
|
2005-04-16 16:20:36 -06:00
|
|
|
maxfreq = pci_busclk * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f];
|
2009-01-17 21:06:57 -07:00
|
|
|
else if (cpu_khz)
|
2005-04-16 16:20:36 -06:00
|
|
|
maxfreq = cpu_khz;
|
2009-01-17 21:06:57 -07:00
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
maxfreq = 30000 * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f];
|
2009-01-17 21:06:57 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
stock_freq = maxfreq;
|
|
|
|
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("cpu max frequency is %d.\n", maxfreq);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* setup basic struct for cpufreq API */
|
|
|
|
policy->cpu = 0;
|
|
|
|
|
|
|
|
if (max_duration < POLICY_MIN_DIV)
|
|
|
|
policy->min = maxfreq / max_duration;
|
|
|
|
else
|
|
|
|
policy->min = maxfreq / POLICY_MIN_DIV;
|
|
|
|
policy->max = maxfreq;
|
|
|
|
policy->cpuinfo.min_freq = maxfreq / max_duration;
|
|
|
|
policy->cpuinfo.max_freq = maxfreq;
|
|
|
|
policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-02-27 22:43:23 -07:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* cpufreq_gx_init:
|
|
|
|
* MediaGX/Geode GX initialize cpufreq driver
|
|
|
|
*/
|
2007-02-26 15:55:48 -07:00
|
|
|
static struct cpufreq_driver gx_suspmod_driver = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.get = gx_get_cpuspeed,
|
|
|
|
.verify = cpufreq_gx_verify,
|
|
|
|
.target = cpufreq_gx_target,
|
|
|
|
.init = cpufreq_gx_cpu_init,
|
|
|
|
.name = "gx-suspmod",
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init cpufreq_gx_init(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct gxfreq_params *params;
|
|
|
|
struct pci_dev *gx_pci;
|
|
|
|
|
|
|
|
/* Test if we have the right hardware */
|
2009-01-17 21:06:57 -07:00
|
|
|
gx_pci = gx_detect_chipset();
|
|
|
|
if (gx_pci == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* check whether module parameters are sane */
|
|
|
|
if (max_duration > 0xff)
|
|
|
|
max_duration = 0xff;
|
|
|
|
|
2011-03-27 07:04:46 -06:00
|
|
|
pr_debug("geode suspend modulation available.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-06 11:23:06 -06:00
|
|
|
params = kzalloc(sizeof(*params), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (params == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
params->cs55x0 = gx_pci;
|
|
|
|
gx_params = params;
|
|
|
|
|
|
|
|
/* keep cs55x0 configurations */
|
|
|
|
pci_read_config_byte(params->cs55x0, PCI_SUSCFG, &(params->pci_suscfg));
|
|
|
|
pci_read_config_byte(params->cs55x0, PCI_PMER1, &(params->pci_pmer1));
|
|
|
|
pci_read_config_byte(params->cs55x0, PCI_PMER2, &(params->pci_pmer2));
|
|
|
|
pci_read_config_byte(params->cs55x0, PCI_MODON, &(params->on_duration));
|
2009-01-17 21:06:57 -07:00
|
|
|
pci_read_config_byte(params->cs55x0, PCI_MODOFF,
|
|
|
|
&(params->off_duration));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
ret = cpufreq_register_driver(&gx_suspmod_driver);
|
|
|
|
if (ret) {
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(params);
|
|
|
|
return ret; /* register error! */
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit cpufreq_gx_exit(void)
|
|
|
|
{
|
|
|
|
cpufreq_unregister_driver(&gx_suspmod_driver);
|
|
|
|
pci_dev_put(gx_params->cs55x0);
|
|
|
|
kfree(gx_params);
|
|
|
|
}
|
|
|
|
|
2009-01-17 21:06:57 -07:00
|
|
|
MODULE_AUTHOR("Hiroshi Miura <miura@da-cha.org>");
|
|
|
|
MODULE_DESCRIPTION("Cpufreq driver for Cyrix MediaGX and NatSemi Geode");
|
|
|
|
MODULE_LICENSE("GPL");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
module_init(cpufreq_gx_init);
|
|
|
|
module_exit(cpufreq_gx_exit);
|
|
|
|
|