2006-06-26 07:25:12 +00:00
|
|
|
#include <linux/clocksource.h>
|
2007-02-16 09:28:04 +00:00
|
|
|
#include <linux/clockchips.h>
|
2008-09-06 12:19:17 +00:00
|
|
|
#include <linux/interrupt.h>
|
2011-05-26 16:22:53 +00:00
|
|
|
#include <linux/export.h>
|
2007-10-12 21:04:06 +00:00
|
|
|
#include <linux/delay.h>
|
2006-06-26 07:25:12 +00:00
|
|
|
#include <linux/errno.h>
|
2011-06-01 18:04:57 +00:00
|
|
|
#include <linux/i8253.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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2006-06-26 07:25:12 +00:00
|
|
|
#include <linux/hpet.h>
|
|
|
|
#include <linux/init.h>
|
2008-09-06 01:02:17 +00:00
|
|
|
#include <linux/cpu.h>
|
2008-09-06 12:19:17 +00:00
|
|
|
#include <linux/pm.h>
|
|
|
|
#include <linux/io.h>
|
2006-06-26 07:25:12 +00:00
|
|
|
|
2016-01-26 21:12:04 +00:00
|
|
|
#include <asm/cpufeature.h>
|
2015-04-14 02:30:09 +00:00
|
|
|
#include <asm/irqdomain.h>
|
2007-10-12 21:04:06 +00:00
|
|
|
#include <asm/fixmap.h>
|
2008-09-06 12:19:17 +00:00
|
|
|
#include <asm/hpet.h>
|
2011-06-01 18:05:06 +00:00
|
|
|
#include <asm/time.h>
|
2006-06-26 07:25:12 +00:00
|
|
|
|
2008-09-06 12:19:17 +00:00
|
|
|
#define HPET_MASK CLOCKSOURCE_MASK(32)
|
2006-06-26 07:25:12 +00:00
|
|
|
|
2008-01-30 12:30:00 +00:00
|
|
|
/* FSEC = 10^-15
|
|
|
|
NSEC = 10^-9 */
|
2008-09-06 12:19:17 +00:00
|
|
|
#define FSEC_PER_NSEC 1000000L
|
2006-06-26 07:25:12 +00:00
|
|
|
|
2008-09-06 01:02:18 +00:00
|
|
|
#define HPET_DEV_USED_BIT 2
|
|
|
|
#define HPET_DEV_USED (1 << HPET_DEV_USED_BIT)
|
|
|
|
#define HPET_DEV_VALID 0x8
|
|
|
|
#define HPET_DEV_FSB_CAP 0x1000
|
|
|
|
#define HPET_DEV_PERI_CAP 0x2000
|
|
|
|
|
2010-12-13 11:43:23 +00:00
|
|
|
#define HPET_MIN_CYCLES 128
|
|
|
|
#define HPET_MIN_PROG_DELTA (HPET_MIN_CYCLES + (HPET_MIN_CYCLES >> 1))
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
/*
|
|
|
|
* HPET address is set in acpi/boot.c, when an ACPI entry exists
|
|
|
|
*/
|
2008-09-06 12:19:17 +00:00
|
|
|
unsigned long hpet_address;
|
2009-08-04 19:07:09 +00:00
|
|
|
u8 hpet_blockid; /* OS timer block num */
|
2015-10-19 10:35:44 +00:00
|
|
|
bool hpet_msi_disable;
|
2010-01-21 19:09:52 +00:00
|
|
|
|
2008-11-25 07:42:01 +00:00
|
|
|
#ifdef CONFIG_PCI_MSI
|
2015-10-19 10:35:44 +00:00
|
|
|
static unsigned int hpet_num_timers;
|
2008-11-25 07:42:01 +00:00
|
|
|
#endif
|
2008-09-06 12:19:17 +00:00
|
|
|
static void __iomem *hpet_virt_address;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2008-09-06 01:02:17 +00:00
|
|
|
struct hpet_dev {
|
2008-09-06 12:19:17 +00:00
|
|
|
struct clock_event_device evt;
|
|
|
|
unsigned int num;
|
|
|
|
int cpu;
|
|
|
|
unsigned int irq;
|
|
|
|
unsigned int flags;
|
|
|
|
char name[10];
|
2008-09-06 01:02:17 +00:00
|
|
|
};
|
|
|
|
|
2016-04-15 17:00:26 +00:00
|
|
|
static inline struct hpet_dev *EVT_TO_HPET_DEV(struct clock_event_device *evtdev)
|
2011-11-18 14:28:22 +00:00
|
|
|
{
|
|
|
|
return container_of(evtdev, struct hpet_dev, evt);
|
|
|
|
}
|
|
|
|
|
2009-08-19 07:44:24 +00:00
|
|
|
inline unsigned int hpet_readl(unsigned int a)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
|
|
|
return readl(hpet_virt_address + a);
|
|
|
|
}
|
|
|
|
|
2009-08-19 07:44:24 +00:00
|
|
|
static inline void hpet_writel(unsigned int d, unsigned int a)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
|
|
|
writel(d, hpet_virt_address + a);
|
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:06 +00:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
#include <asm/pgtable.h>
|
2008-07-13 21:50:56 +00:00
|
|
|
#endif
|
2007-10-12 21:04:06 +00:00
|
|
|
|
2007-10-12 21:04:06 +00:00
|
|
|
static inline void hpet_set_mapping(void)
|
|
|
|
{
|
|
|
|
hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void hpet_clear_mapping(void)
|
|
|
|
{
|
|
|
|
iounmap(hpet_virt_address);
|
|
|
|
hpet_virt_address = NULL;
|
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
/*
|
|
|
|
* HPET command line enable / disable
|
|
|
|
*/
|
2015-10-19 10:35:44 +00:00
|
|
|
bool boot_hpet_disable;
|
|
|
|
bool hpet_force_user;
|
|
|
|
static bool hpet_verbose;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2008-09-06 12:19:17 +00:00
|
|
|
static int __init hpet_setup(char *str)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
2012-04-02 14:17:36 +00:00
|
|
|
while (str) {
|
|
|
|
char *next = strchr(str, ',');
|
|
|
|
|
|
|
|
if (next)
|
|
|
|
*next++ = 0;
|
2007-02-16 09:28:04 +00:00
|
|
|
if (!strncmp("disable", str, 7))
|
2015-10-19 10:35:44 +00:00
|
|
|
boot_hpet_disable = true;
|
2007-10-19 18:35:02 +00:00
|
|
|
if (!strncmp("force", str, 5))
|
2015-10-19 10:35:44 +00:00
|
|
|
hpet_force_user = true;
|
2009-02-20 23:09:47 +00:00
|
|
|
if (!strncmp("verbose", str, 7))
|
2015-10-19 10:35:44 +00:00
|
|
|
hpet_verbose = true;
|
2012-04-02 14:17:36 +00:00
|
|
|
str = next;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("hpet=", hpet_setup);
|
|
|
|
|
2007-10-12 21:04:06 +00:00
|
|
|
static int __init disable_hpet(char *str)
|
|
|
|
{
|
2015-10-19 10:35:44 +00:00
|
|
|
boot_hpet_disable = true;
|
2007-10-12 21:04:06 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("nohpet", disable_hpet);
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
static inline int is_hpet_capable(void)
|
|
|
|
{
|
2008-09-06 12:19:17 +00:00
|
|
|
return !boot_hpet_disable && hpet_address;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HPET timer interrupt enable / disable
|
|
|
|
*/
|
2015-10-19 10:35:44 +00:00
|
|
|
static bool hpet_legacy_int_enabled;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* is_hpet_enabled - check whether the hpet timer interrupt is enabled
|
|
|
|
*/
|
|
|
|
int is_hpet_enabled(void)
|
|
|
|
{
|
|
|
|
return is_hpet_capable() && hpet_legacy_int_enabled;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(is_hpet_enabled);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2009-02-20 23:09:47 +00:00
|
|
|
static void _hpet_print_config(const char *function, int line)
|
|
|
|
{
|
|
|
|
u32 i, timers, l, h;
|
|
|
|
printk(KERN_INFO "hpet: %s(%d):\n", function, line);
|
|
|
|
l = hpet_readl(HPET_ID);
|
|
|
|
h = hpet_readl(HPET_PERIOD);
|
|
|
|
timers = ((l & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
|
|
|
|
printk(KERN_INFO "hpet: ID: 0x%x, PERIOD: 0x%x\n", l, h);
|
|
|
|
l = hpet_readl(HPET_CFG);
|
|
|
|
h = hpet_readl(HPET_STATUS);
|
|
|
|
printk(KERN_INFO "hpet: CFG: 0x%x, STATUS: 0x%x\n", l, h);
|
|
|
|
l = hpet_readl(HPET_COUNTER);
|
|
|
|
h = hpet_readl(HPET_COUNTER+4);
|
|
|
|
printk(KERN_INFO "hpet: COUNTER_l: 0x%x, COUNTER_h: 0x%x\n", l, h);
|
|
|
|
|
|
|
|
for (i = 0; i < timers; i++) {
|
|
|
|
l = hpet_readl(HPET_Tn_CFG(i));
|
|
|
|
h = hpet_readl(HPET_Tn_CFG(i)+4);
|
|
|
|
printk(KERN_INFO "hpet: T%d: CFG_l: 0x%x, CFG_h: 0x%x\n",
|
|
|
|
i, l, h);
|
|
|
|
l = hpet_readl(HPET_Tn_CMP(i));
|
|
|
|
h = hpet_readl(HPET_Tn_CMP(i)+4);
|
|
|
|
printk(KERN_INFO "hpet: T%d: CMP_l: 0x%x, CMP_h: 0x%x\n",
|
|
|
|
i, l, h);
|
|
|
|
l = hpet_readl(HPET_Tn_ROUTE(i));
|
|
|
|
h = hpet_readl(HPET_Tn_ROUTE(i)+4);
|
|
|
|
printk(KERN_INFO "hpet: T%d ROUTE_l: 0x%x, ROUTE_h: 0x%x\n",
|
|
|
|
i, l, h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define hpet_print_config() \
|
|
|
|
do { \
|
|
|
|
if (hpet_verbose) \
|
2015-02-12 23:01:31 +00:00
|
|
|
_hpet_print_config(__func__, __LINE__); \
|
2009-02-20 23:09:47 +00:00
|
|
|
} while (0)
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
/*
|
|
|
|
* When the hpet driver (/dev/hpet) is enabled, we need to reserve
|
|
|
|
* timer 0 and timer 1 in case of RTC emulation.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_HPET
|
x86: using HPET in MSI mode and setting up per CPU HPET timers, fix
On Sat, Sep 06, 2008 at 06:03:53AM -0700, Ingo Molnar wrote:
>
> it crashes two testsystems, the fault on a NULL pointer in hpet init,
> with:
>
> initcall print_all_ICs+0x0/0x520 returned 0 after 26 msecs
> calling hpet_late_init+0x0/0x1c0
> BUG: unable to handle kernel NULL pointer dereference at 000000000000008c
> IP: [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> PGD 0
> Oops: 0000 [1] SMP
> CPU 0
> Modules linked in:
> Pid: 1, comm: swapper Not tainted 2.6.27-rc5 #29725
> RIP: 0010:[<ffffffff80d228be>] [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP: 0018:ffff88003fa07dd0 EFLAGS: 00010246
> RAX: 0000000000000000 RBX: 0000000000000003 RCX: 0000000000000000
> RDX: ffffc20000000160 RSI: 0000000000000000 RDI: 0000000000000003
> RBP: ffff88003fa07e90 R08: 0000000000000000 R09: ffff88003fa07dd0
> R10: 0000000000000001 R11: 0000000000000000 R12: ffff88003fa07dd0
> R13: 0000000000000002 R14: ffffc20000000000 R15: 000000006f57e511
> FS: 0000000000000000(0000) GS:ffffffff80cf6a80(0000) knlGS:0000000000000000
> CS: 0010 DS: 0018 ES: 0018 CR0: 000000008005003b
> CR2: 000000000000008c CR3: 0000000000201000 CR4: 00000000000006e0
> DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
> Process swapper (pid: 1, threadinfo ffff88003fa06000, task ffff88003fa08000)
> Stack: 00000000fed00000 ffffc20000000000 0000000100000003 0000000800000002
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> Call Trace:
> [<ffffffff80d227c0>] ? hpet_late_init+0x0/0x1c0
> [<ffffffff80209045>] do_one_initcall+0x45/0x190
> [<ffffffff80296f39>] ? register_irq_proc+0x19/0xe0
> [<ffffffff80d0d140>] ? early_idt_handler+0x0/0x73
> [<ffffffff80d0dabc>] kernel_init+0x14c/0x1b0
> [<ffffffff80942ac1>] ? trace_hardirqs_on_thunk+0x3a/0x3f
> [<ffffffff8020dbd9>] child_rip+0xa/0x11
> [<ffffffff8020ceee>] ? restore_args+0x0/0x30
> [<ffffffff80d0d970>] ? kernel_init+0x0/0x1b0
> [<ffffffff8020dbcf>] ? child_rip+0x0/0x11
> Code: 20 48 83 c1 01 48 39 f1 75 e3 44 89 e8 4c 8b 05 29 29 22 00 31 f6 48 8d 78 01 66 66 90 89 f0 48 8d 04 80 48 c1 e0 05 4a 8d 0c 00 <f6> 81 8c 00 00 00 08 74 26 8b 81 80 00 00 00 8b 91 88 00 00 00
> RIP [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP <ffff88003fa07dd0>
> CR2: 000000000000008c
> Kernel panic - not syncing: Fatal exception
There was one code path, with CONFIG_PCI_MSI disabled, where we were accessing
hpet_devs without initialization. That resulted in the above crash. The change
below adds a check for hpet_devs.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-08 17:18:40 +00:00
|
|
|
|
2008-09-24 17:03:17 +00:00
|
|
|
static void hpet_reserve_msi_timers(struct hpet_data *hd);
|
x86: using HPET in MSI mode and setting up per CPU HPET timers, fix
On Sat, Sep 06, 2008 at 06:03:53AM -0700, Ingo Molnar wrote:
>
> it crashes two testsystems, the fault on a NULL pointer in hpet init,
> with:
>
> initcall print_all_ICs+0x0/0x520 returned 0 after 26 msecs
> calling hpet_late_init+0x0/0x1c0
> BUG: unable to handle kernel NULL pointer dereference at 000000000000008c
> IP: [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> PGD 0
> Oops: 0000 [1] SMP
> CPU 0
> Modules linked in:
> Pid: 1, comm: swapper Not tainted 2.6.27-rc5 #29725
> RIP: 0010:[<ffffffff80d228be>] [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP: 0018:ffff88003fa07dd0 EFLAGS: 00010246
> RAX: 0000000000000000 RBX: 0000000000000003 RCX: 0000000000000000
> RDX: ffffc20000000160 RSI: 0000000000000000 RDI: 0000000000000003
> RBP: ffff88003fa07e90 R08: 0000000000000000 R09: ffff88003fa07dd0
> R10: 0000000000000001 R11: 0000000000000000 R12: ffff88003fa07dd0
> R13: 0000000000000002 R14: ffffc20000000000 R15: 000000006f57e511
> FS: 0000000000000000(0000) GS:ffffffff80cf6a80(0000) knlGS:0000000000000000
> CS: 0010 DS: 0018 ES: 0018 CR0: 000000008005003b
> CR2: 000000000000008c CR3: 0000000000201000 CR4: 00000000000006e0
> DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
> Process swapper (pid: 1, threadinfo ffff88003fa06000, task ffff88003fa08000)
> Stack: 00000000fed00000 ffffc20000000000 0000000100000003 0000000800000002
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> Call Trace:
> [<ffffffff80d227c0>] ? hpet_late_init+0x0/0x1c0
> [<ffffffff80209045>] do_one_initcall+0x45/0x190
> [<ffffffff80296f39>] ? register_irq_proc+0x19/0xe0
> [<ffffffff80d0d140>] ? early_idt_handler+0x0/0x73
> [<ffffffff80d0dabc>] kernel_init+0x14c/0x1b0
> [<ffffffff80942ac1>] ? trace_hardirqs_on_thunk+0x3a/0x3f
> [<ffffffff8020dbd9>] child_rip+0xa/0x11
> [<ffffffff8020ceee>] ? restore_args+0x0/0x30
> [<ffffffff80d0d970>] ? kernel_init+0x0/0x1b0
> [<ffffffff8020dbcf>] ? child_rip+0x0/0x11
> Code: 20 48 83 c1 01 48 39 f1 75 e3 44 89 e8 4c 8b 05 29 29 22 00 31 f6 48 8d 78 01 66 66 90 89 f0 48 8d 04 80 48 c1 e0 05 4a 8d 0c 00 <f6> 81 8c 00 00 00 08 74 26 8b 81 80 00 00 00 8b 91 88 00 00 00
> RIP [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP <ffff88003fa07dd0>
> CR2: 000000000000008c
> Kernel panic - not syncing: Fatal exception
There was one code path, with CONFIG_PCI_MSI disabled, where we were accessing
hpet_devs without initialization. That resulted in the above crash. The change
below adds a check for hpet_devs.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-08 17:18:40 +00:00
|
|
|
|
2009-08-19 07:44:24 +00:00
|
|
|
static void hpet_reserve_platform_timers(unsigned int id)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
|
|
|
struct hpet __iomem *hpet = hpet_virt_address;
|
2008-01-30 12:30:03 +00:00
|
|
|
struct hpet_timer __iomem *timer = &hpet->hpet_timers[2];
|
|
|
|
unsigned int nrtimers, i;
|
2007-02-16 09:28:04 +00:00
|
|
|
struct hpet_data hd;
|
|
|
|
|
|
|
|
nrtimers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
|
|
|
|
|
2008-09-06 12:19:17 +00:00
|
|
|
memset(&hd, 0, sizeof(hd));
|
|
|
|
hd.hd_phys_address = hpet_address;
|
|
|
|
hd.hd_address = hpet;
|
|
|
|
hd.hd_nirqs = nrtimers;
|
2007-02-16 09:28:04 +00:00
|
|
|
hpet_reserve_timer(&hd, 0);
|
|
|
|
|
|
|
|
#ifdef CONFIG_HPET_EMULATE_RTC
|
|
|
|
hpet_reserve_timer(&hd, 1);
|
|
|
|
#endif
|
2008-04-04 14:26:10 +00:00
|
|
|
|
2008-07-29 19:47:38 +00:00
|
|
|
/*
|
|
|
|
* NOTE that hd_irq[] reflects IOAPIC input pins (LEGACY_8254
|
|
|
|
* is wrong for i8259!) not the output IRQ. Many BIOS writers
|
|
|
|
* don't bother configuring *any* comparator interrupts.
|
|
|
|
*/
|
2007-02-16 09:28:04 +00:00
|
|
|
hd.hd_irq[0] = HPET_LEGACY_8254;
|
|
|
|
hd.hd_irq[1] = HPET_LEGACY_RTC;
|
|
|
|
|
2008-04-27 12:04:14 +00:00
|
|
|
for (i = 2; i < nrtimers; timer++, i++) {
|
2008-09-06 12:19:17 +00:00
|
|
|
hd.hd_irq[i] = (readl(&timer->hpet_config) &
|
|
|
|
Tn_INT_ROUTE_CNF_MASK) >> Tn_INT_ROUTE_CNF_SHIFT;
|
2008-04-27 12:04:14 +00:00
|
|
|
}
|
2008-04-04 14:26:10 +00:00
|
|
|
|
x86: using HPET in MSI mode and setting up per CPU HPET timers, fix
On Sat, Sep 06, 2008 at 06:03:53AM -0700, Ingo Molnar wrote:
>
> it crashes two testsystems, the fault on a NULL pointer in hpet init,
> with:
>
> initcall print_all_ICs+0x0/0x520 returned 0 after 26 msecs
> calling hpet_late_init+0x0/0x1c0
> BUG: unable to handle kernel NULL pointer dereference at 000000000000008c
> IP: [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> PGD 0
> Oops: 0000 [1] SMP
> CPU 0
> Modules linked in:
> Pid: 1, comm: swapper Not tainted 2.6.27-rc5 #29725
> RIP: 0010:[<ffffffff80d228be>] [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP: 0018:ffff88003fa07dd0 EFLAGS: 00010246
> RAX: 0000000000000000 RBX: 0000000000000003 RCX: 0000000000000000
> RDX: ffffc20000000160 RSI: 0000000000000000 RDI: 0000000000000003
> RBP: ffff88003fa07e90 R08: 0000000000000000 R09: ffff88003fa07dd0
> R10: 0000000000000001 R11: 0000000000000000 R12: ffff88003fa07dd0
> R13: 0000000000000002 R14: ffffc20000000000 R15: 000000006f57e511
> FS: 0000000000000000(0000) GS:ffffffff80cf6a80(0000) knlGS:0000000000000000
> CS: 0010 DS: 0018 ES: 0018 CR0: 000000008005003b
> CR2: 000000000000008c CR3: 0000000000201000 CR4: 00000000000006e0
> DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
> DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
> Process swapper (pid: 1, threadinfo ffff88003fa06000, task ffff88003fa08000)
> Stack: 00000000fed00000 ffffc20000000000 0000000100000003 0000000800000002
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> 0000000000000000 0000000000000000 0000000000000000 0000000000000000
> Call Trace:
> [<ffffffff80d227c0>] ? hpet_late_init+0x0/0x1c0
> [<ffffffff80209045>] do_one_initcall+0x45/0x190
> [<ffffffff80296f39>] ? register_irq_proc+0x19/0xe0
> [<ffffffff80d0d140>] ? early_idt_handler+0x0/0x73
> [<ffffffff80d0dabc>] kernel_init+0x14c/0x1b0
> [<ffffffff80942ac1>] ? trace_hardirqs_on_thunk+0x3a/0x3f
> [<ffffffff8020dbd9>] child_rip+0xa/0x11
> [<ffffffff8020ceee>] ? restore_args+0x0/0x30
> [<ffffffff80d0d970>] ? kernel_init+0x0/0x1b0
> [<ffffffff8020dbcf>] ? child_rip+0x0/0x11
> Code: 20 48 83 c1 01 48 39 f1 75 e3 44 89 e8 4c 8b 05 29 29 22 00 31 f6 48 8d 78 01 66 66 90 89 f0 48 8d 04 80 48 c1 e0 05 4a 8d 0c 00 <f6> 81 8c 00 00 00 08 74 26 8b 81 80 00 00 00 8b 91 88 00 00 00
> RIP [<ffffffff80d228be>] hpet_late_init+0xfe/0x1c0
> RSP <ffff88003fa07dd0>
> CR2: 000000000000008c
> Kernel panic - not syncing: Fatal exception
There was one code path, with CONFIG_PCI_MSI disabled, where we were accessing
hpet_devs without initialization. That resulted in the above crash. The change
below adds a check for hpet_devs.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-08 17:18:40 +00:00
|
|
|
hpet_reserve_msi_timers(&hd);
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
hpet_alloc(&hd);
|
2008-04-04 14:26:10 +00:00
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
#else
|
2009-08-19 07:44:24 +00:00
|
|
|
static void hpet_reserve_platform_timers(unsigned int id) { }
|
2007-02-16 09:28:04 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Common hpet info
|
|
|
|
*/
|
2011-05-18 21:33:43 +00:00
|
|
|
static unsigned long hpet_freq;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
static struct clock_event_device hpet_clockevent;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2009-02-20 23:10:44 +00:00
|
|
|
static void hpet_stop_counter(void)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
2015-10-19 10:35:44 +00:00
|
|
|
u32 cfg = hpet_readl(HPET_CFG);
|
2007-02-16 09:28:04 +00:00
|
|
|
cfg &= ~HPET_CFG_ENABLE;
|
|
|
|
hpet_writel(cfg, HPET_CFG);
|
2009-04-21 18:00:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hpet_reset_counter(void)
|
|
|
|
{
|
2007-02-16 09:28:04 +00:00
|
|
|
hpet_writel(0, HPET_COUNTER);
|
|
|
|
hpet_writel(0, HPET_COUNTER + 4);
|
2009-02-20 23:10:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hpet_start_counter(void)
|
|
|
|
{
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg = hpet_readl(HPET_CFG);
|
2007-02-16 09:28:04 +00:00
|
|
|
cfg |= HPET_CFG_ENABLE;
|
|
|
|
hpet_writel(cfg, HPET_CFG);
|
|
|
|
}
|
|
|
|
|
2009-02-20 23:10:44 +00:00
|
|
|
static void hpet_restart_counter(void)
|
|
|
|
{
|
|
|
|
hpet_stop_counter();
|
2009-04-21 18:00:37 +00:00
|
|
|
hpet_reset_counter();
|
2009-02-20 23:10:44 +00:00
|
|
|
hpet_start_counter();
|
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
static void hpet_resume_device(void)
|
|
|
|
{
|
2007-10-12 21:04:24 +00:00
|
|
|
force_hpet_resume();
|
2007-10-12 21:04:23 +00:00
|
|
|
}
|
|
|
|
|
2010-02-02 22:41:39 +00:00
|
|
|
static void hpet_resume_counter(struct clocksource *cs)
|
2007-10-12 21:04:23 +00:00
|
|
|
{
|
|
|
|
hpet_resume_device();
|
2009-02-20 23:10:44 +00:00
|
|
|
hpet_restart_counter();
|
2007-10-12 21:04:23 +00:00
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
static void hpet_enable_legacy_int(void)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg = hpet_readl(HPET_CFG);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
cfg |= HPET_CFG_LEGACY;
|
|
|
|
hpet_writel(cfg, HPET_CFG);
|
2015-10-19 10:35:44 +00:00
|
|
|
hpet_legacy_int_enabled = true;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
static void hpet_legacy_clockevent_register(void)
|
|
|
|
{
|
|
|
|
/* Start HPET legacy interrupts */
|
|
|
|
hpet_enable_legacy_int();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start hpet with the boot cpu mask and make it
|
|
|
|
* global after the IO_APIC has been initialized.
|
|
|
|
*/
|
2017-06-20 09:31:54 +00:00
|
|
|
hpet_clockevent.cpumask = cpumask_of(boot_cpu_data.cpu_index);
|
2011-05-18 21:33:43 +00:00
|
|
|
clockevents_config_and_register(&hpet_clockevent, hpet_freq,
|
|
|
|
HPET_MIN_PROG_DELTA, 0x7FFFFFFF);
|
2007-10-12 21:04:23 +00:00
|
|
|
global_clock_event = &hpet_clockevent;
|
|
|
|
printk(KERN_DEBUG "hpet clockevent registered\n");
|
|
|
|
}
|
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
static int hpet_set_periodic(struct clock_event_device *evt, int timer)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg, cmp, now;
|
2007-02-16 09:28:04 +00:00
|
|
|
uint64_t delta;
|
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
hpet_stop_counter();
|
|
|
|
delta = ((uint64_t)(NSEC_PER_SEC / HZ)) * evt->mult;
|
|
|
|
delta >>= evt->shift;
|
|
|
|
now = hpet_readl(HPET_COUNTER);
|
|
|
|
cmp = now + (unsigned int)delta;
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(timer));
|
|
|
|
cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
|
|
|
|
HPET_TN_32BIT;
|
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(timer));
|
|
|
|
hpet_writel(cmp, HPET_Tn_CMP(timer));
|
|
|
|
udelay(1);
|
|
|
|
/*
|
|
|
|
* HPET on AMD 81xx needs a second write (with HPET_TN_SETVAL
|
|
|
|
* cleared) to T0_CMP to set the period. The HPET_TN_SETVAL
|
|
|
|
* bit is automatically cleared after the first write.
|
|
|
|
* (See AMD-8111 HyperTransport I/O Hub Data Sheet,
|
|
|
|
* Publication # 24674)
|
|
|
|
*/
|
|
|
|
hpet_writel((unsigned int)delta, HPET_Tn_CMP(timer));
|
|
|
|
hpet_start_counter();
|
|
|
|
hpet_print_config();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_set_oneshot(struct clock_event_device *evt, int timer)
|
|
|
|
{
|
|
|
|
unsigned int cfg;
|
|
|
|
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(timer));
|
|
|
|
cfg &= ~HPET_TN_PERIODIC;
|
|
|
|
cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
|
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(timer));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_shutdown(struct clock_event_device *evt, int timer)
|
|
|
|
{
|
|
|
|
unsigned int cfg;
|
|
|
|
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(timer));
|
|
|
|
cfg &= ~HPET_TN_ENABLE;
|
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(timer));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_resume(struct clock_event_device *evt, int timer)
|
|
|
|
{
|
|
|
|
if (!timer) {
|
|
|
|
hpet_enable_legacy_int();
|
|
|
|
} else {
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
|
|
|
|
2017-01-31 18:03:21 +00:00
|
|
|
irq_domain_deactivate_irq(irq_get_irq_data(hdev->irq));
|
2015-07-16 10:58:45 +00:00
|
|
|
irq_domain_activate_irq(irq_get_irq_data(hdev->irq));
|
2017-03-01 20:10:17 +00:00
|
|
|
disable_hardirq(hdev->irq);
|
2015-07-16 10:58:45 +00:00
|
|
|
irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu));
|
|
|
|
enable_irq(hdev->irq);
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
2015-07-16 10:58:45 +00:00
|
|
|
hpet_print_config();
|
|
|
|
|
|
|
|
return 0;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
|
2008-09-06 01:02:16 +00:00
|
|
|
static int hpet_next_event(unsigned long delta,
|
|
|
|
struct clock_event_device *evt, int timer)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
2008-09-06 01:03:32 +00:00
|
|
|
u32 cnt;
|
2010-09-15 13:11:57 +00:00
|
|
|
s32 res;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
cnt = hpet_readl(HPET_COUNTER);
|
2008-09-06 01:03:32 +00:00
|
|
|
cnt += (u32) delta;
|
2008-09-06 01:02:16 +00:00
|
|
|
hpet_writel(cnt, HPET_Tn_CMP(timer));
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2008-09-06 01:06:08 +00:00
|
|
|
/*
|
2010-09-15 13:11:57 +00:00
|
|
|
* HPETs are a complete disaster. The compare register is
|
|
|
|
* based on a equal comparison and neither provides a less
|
|
|
|
* than or equal functionality (which would require to take
|
|
|
|
* the wraparound into account) nor a simple count down event
|
|
|
|
* mode. Further the write to the comparator register is
|
|
|
|
* delayed internally up to two HPET clock cycles in certain
|
2010-12-13 11:43:23 +00:00
|
|
|
* chipsets (ATI, ICH9,10). Some newer AMD chipsets have even
|
|
|
|
* longer delays. We worked around that by reading back the
|
|
|
|
* compare register, but that required another workaround for
|
|
|
|
* ICH9,10 chips where the first readout after write can
|
|
|
|
* return the old stale value. We already had a minimum
|
|
|
|
* programming delta of 5us enforced, but a NMI or SMI hitting
|
2010-09-15 13:11:57 +00:00
|
|
|
* between the counter readout and the comparator write can
|
|
|
|
* move us behind that point easily. Now instead of reading
|
|
|
|
* the compare register back several times, we make the ETIME
|
|
|
|
* decision based on the following: Return ETIME if the
|
2010-12-13 11:43:23 +00:00
|
|
|
* counter value after the write is less than HPET_MIN_CYCLES
|
2010-09-15 13:11:57 +00:00
|
|
|
* away from the event or if the counter is already ahead of
|
2010-12-13 11:43:23 +00:00
|
|
|
* the event. The minimum programming delta for the generic
|
|
|
|
* clockevents code is set to 1.5 * HPET_MIN_CYCLES.
|
2008-09-06 01:06:08 +00:00
|
|
|
*/
|
2010-09-15 13:11:57 +00:00
|
|
|
res = (s32)(cnt - hpet_readl(HPET_COUNTER));
|
2008-09-06 01:06:08 +00:00
|
|
|
|
2010-12-13 11:43:23 +00:00
|
|
|
return res < HPET_MIN_CYCLES ? -ETIME : 0;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
static int hpet_legacy_shutdown(struct clock_event_device *evt)
|
2008-09-06 01:02:16 +00:00
|
|
|
{
|
2015-07-16 10:58:45 +00:00
|
|
|
return hpet_shutdown(evt, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_legacy_set_oneshot(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
return hpet_set_oneshot(evt, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_legacy_set_periodic(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
return hpet_set_periodic(evt, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_legacy_resume(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
return hpet_resume(evt, 0);
|
2008-09-06 01:02:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_legacy_next_event(unsigned long delta,
|
|
|
|
struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
return hpet_next_event(delta, evt, 0);
|
|
|
|
}
|
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
/*
|
|
|
|
* The hpet clock event device
|
|
|
|
*/
|
|
|
|
static struct clock_event_device hpet_clockevent = {
|
|
|
|
.name = "hpet",
|
|
|
|
.features = CLOCK_EVT_FEAT_PERIODIC |
|
|
|
|
CLOCK_EVT_FEAT_ONESHOT,
|
|
|
|
.set_state_periodic = hpet_legacy_set_periodic,
|
|
|
|
.set_state_oneshot = hpet_legacy_set_oneshot,
|
|
|
|
.set_state_shutdown = hpet_legacy_shutdown,
|
|
|
|
.tick_resume = hpet_legacy_resume,
|
|
|
|
.set_next_event = hpet_legacy_next_event,
|
|
|
|
.irq = 0,
|
|
|
|
.rating = 50,
|
|
|
|
};
|
|
|
|
|
2008-09-06 01:02:17 +00:00
|
|
|
/*
|
|
|
|
* HPET MSI Support
|
|
|
|
*/
|
2008-09-06 01:02:18 +00:00
|
|
|
#ifdef CONFIG_PCI_MSI
|
2008-09-24 17:03:17 +00:00
|
|
|
|
|
|
|
static DEFINE_PER_CPU(struct hpet_dev *, cpu_hpet_dev);
|
|
|
|
static struct hpet_dev *hpet_devs;
|
2015-04-13 06:11:34 +00:00
|
|
|
static struct irq_domain *hpet_domain;
|
2008-09-24 17:03:17 +00:00
|
|
|
|
2010-09-28 14:18:39 +00:00
|
|
|
void hpet_msi_unmask(struct irq_data *data)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
2015-06-01 08:05:18 +00:00
|
|
|
struct hpet_dev *hdev = irq_data_get_irq_handler_data(data);
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg;
|
2008-09-06 01:02:17 +00:00
|
|
|
|
|
|
|
/* unmask it */
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
|
2012-11-02 14:02:40 +00:00
|
|
|
cfg |= HPET_TN_ENABLE | HPET_TN_FSB;
|
2008-09-06 01:02:17 +00:00
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
|
|
|
|
}
|
|
|
|
|
2010-09-28 14:18:39 +00:00
|
|
|
void hpet_msi_mask(struct irq_data *data)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
2015-06-01 08:05:18 +00:00
|
|
|
struct hpet_dev *hdev = irq_data_get_irq_handler_data(data);
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg;
|
2008-09-06 01:02:17 +00:00
|
|
|
|
|
|
|
/* mask it */
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
|
2012-11-02 14:02:40 +00:00
|
|
|
cfg &= ~(HPET_TN_ENABLE | HPET_TN_FSB);
|
2008-09-06 01:02:17 +00:00
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
|
|
|
|
}
|
|
|
|
|
2010-09-28 14:18:39 +00:00
|
|
|
void hpet_msi_write(struct hpet_dev *hdev, struct msi_msg *msg)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
|
|
|
hpet_writel(msg->data, HPET_Tn_ROUTE(hdev->num));
|
|
|
|
hpet_writel(msg->address_lo, HPET_Tn_ROUTE(hdev->num) + 4);
|
|
|
|
}
|
|
|
|
|
2010-09-28 14:18:39 +00:00
|
|
|
void hpet_msi_read(struct hpet_dev *hdev, struct msi_msg *msg)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
|
|
|
msg->data = hpet_readl(HPET_Tn_ROUTE(hdev->num));
|
|
|
|
msg->address_lo = hpet_readl(HPET_Tn_ROUTE(hdev->num) + 4);
|
|
|
|
msg->address_hi = 0;
|
|
|
|
}
|
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
static int hpet_msi_shutdown(struct clock_event_device *evt)
|
2008-09-06 01:02:18 +00:00
|
|
|
{
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
2015-07-16 10:58:45 +00:00
|
|
|
|
|
|
|
return hpet_shutdown(evt, hdev->num);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_msi_set_oneshot(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
|
|
|
|
|
|
|
return hpet_set_oneshot(evt, hdev->num);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_msi_set_periodic(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
|
|
|
|
|
|
|
return hpet_set_periodic(evt, hdev->num);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_msi_resume(struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
|
|
|
|
|
|
|
return hpet_resume(evt, hdev->num);
|
2008-09-06 01:02:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_msi_next_event(unsigned long delta,
|
|
|
|
struct clock_event_device *evt)
|
|
|
|
{
|
|
|
|
struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
|
|
|
|
return hpet_next_event(delta, evt, hdev->num);
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t hpet_interrupt_handler(int irq, void *data)
|
|
|
|
{
|
|
|
|
struct hpet_dev *dev = (struct hpet_dev *)data;
|
|
|
|
struct clock_event_device *hevt = &dev->evt;
|
|
|
|
|
|
|
|
if (!hevt->event_handler) {
|
|
|
|
printk(KERN_INFO "Spurious HPET timer interrupt on HPET timer %d\n",
|
|
|
|
dev->num);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
hevt->event_handler(hevt);
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_setup_irq(struct hpet_dev *dev)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (request_irq(dev->irq, hpet_interrupt_handler,
|
2014-03-04 20:35:05 +00:00
|
|
|
IRQF_TIMER | IRQF_NOBALANCING,
|
2009-06-14 15:46:01 +00:00
|
|
|
dev->name, dev))
|
2008-09-06 01:02:18 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
disable_irq(dev->irq);
|
2008-12-13 10:50:26 +00:00
|
|
|
irq_set_affinity(dev->irq, cpumask_of(dev->cpu));
|
2008-09-06 01:02:18 +00:00
|
|
|
enable_irq(dev->irq);
|
|
|
|
|
2008-09-25 18:53:11 +00:00
|
|
|
printk(KERN_DEBUG "hpet: %s irq %d for MSI\n",
|
|
|
|
dev->name, dev->irq);
|
|
|
|
|
2008-09-06 01:02:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This should be called in specific @cpu */
|
|
|
|
static void init_one_hpet_msi_clockevent(struct hpet_dev *hdev, int cpu)
|
|
|
|
{
|
|
|
|
struct clock_event_device *evt = &hdev->evt;
|
|
|
|
|
|
|
|
WARN_ON(cpu != smp_processor_id());
|
|
|
|
if (!(hdev->flags & HPET_DEV_VALID))
|
|
|
|
return;
|
|
|
|
|
|
|
|
hdev->cpu = cpu;
|
|
|
|
per_cpu(cpu_hpet_dev, cpu) = hdev;
|
|
|
|
evt->name = hdev->name;
|
|
|
|
hpet_setup_irq(hdev);
|
|
|
|
evt->irq = hdev->irq;
|
|
|
|
|
|
|
|
evt->rating = 110;
|
|
|
|
evt->features = CLOCK_EVT_FEAT_ONESHOT;
|
2015-07-16 10:58:45 +00:00
|
|
|
if (hdev->flags & HPET_DEV_PERI_CAP) {
|
2008-09-06 01:02:18 +00:00
|
|
|
evt->features |= CLOCK_EVT_FEAT_PERIODIC;
|
2015-07-16 10:58:45 +00:00
|
|
|
evt->set_state_periodic = hpet_msi_set_periodic;
|
|
|
|
}
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2015-07-16 10:58:45 +00:00
|
|
|
evt->set_state_shutdown = hpet_msi_shutdown;
|
|
|
|
evt->set_state_oneshot = hpet_msi_set_oneshot;
|
|
|
|
evt->tick_resume = hpet_msi_resume;
|
2008-09-06 01:02:18 +00:00
|
|
|
evt->set_next_event = hpet_msi_next_event;
|
2008-12-13 10:50:26 +00:00
|
|
|
evt->cpumask = cpumask_of(hdev->cpu);
|
2011-05-18 21:33:43 +00:00
|
|
|
|
|
|
|
clockevents_config_and_register(evt, hpet_freq, HPET_MIN_PROG_DELTA,
|
|
|
|
0x7FFFFFFF);
|
2008-09-06 01:02:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HPET
|
|
|
|
/* Reserve at least one timer for userspace (/dev/hpet) */
|
|
|
|
#define RESERVE_TIMERS 1
|
|
|
|
#else
|
|
|
|
#define RESERVE_TIMERS 0
|
|
|
|
#endif
|
2008-09-24 17:03:17 +00:00
|
|
|
|
|
|
|
static void hpet_msi_capability_lookup(unsigned int start_timer)
|
2008-09-06 01:02:18 +00:00
|
|
|
{
|
|
|
|
unsigned int id;
|
|
|
|
unsigned int num_timers;
|
|
|
|
unsigned int num_timers_used = 0;
|
2015-04-13 06:11:34 +00:00
|
|
|
int i, irq;
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2010-01-21 19:09:52 +00:00
|
|
|
if (hpet_msi_disable)
|
|
|
|
return;
|
|
|
|
|
2009-08-12 03:16:12 +00:00
|
|
|
if (boot_cpu_has(X86_FEATURE_ARAT))
|
|
|
|
return;
|
2008-09-06 01:02:18 +00:00
|
|
|
id = hpet_readl(HPET_ID);
|
|
|
|
|
|
|
|
num_timers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT);
|
|
|
|
num_timers++; /* Value read out starts from 0 */
|
2009-02-20 23:09:47 +00:00
|
|
|
hpet_print_config();
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2015-04-13 06:11:34 +00:00
|
|
|
hpet_domain = hpet_create_irq_domain(hpet_blockid);
|
|
|
|
if (!hpet_domain)
|
|
|
|
return;
|
|
|
|
|
2008-09-06 01:02:18 +00:00
|
|
|
hpet_devs = kzalloc(sizeof(struct hpet_dev) * num_timers, GFP_KERNEL);
|
|
|
|
if (!hpet_devs)
|
|
|
|
return;
|
|
|
|
|
|
|
|
hpet_num_timers = num_timers;
|
|
|
|
|
|
|
|
for (i = start_timer; i < num_timers - RESERVE_TIMERS; i++) {
|
|
|
|
struct hpet_dev *hdev = &hpet_devs[num_timers_used];
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg = hpet_readl(HPET_Tn_CFG(i));
|
2008-09-06 01:02:18 +00:00
|
|
|
|
|
|
|
/* Only consider HPET timer with MSI support */
|
|
|
|
if (!(cfg & HPET_TN_FSB_CAP))
|
|
|
|
continue;
|
|
|
|
|
2015-06-21 14:21:50 +00:00
|
|
|
hdev->flags = 0;
|
|
|
|
if (cfg & HPET_TN_PERIODIC_CAP)
|
|
|
|
hdev->flags |= HPET_DEV_PERI_CAP;
|
|
|
|
sprintf(hdev->name, "hpet%d", i);
|
|
|
|
hdev->num = i;
|
|
|
|
|
2015-04-13 06:11:34 +00:00
|
|
|
irq = hpet_assign_irq(hpet_domain, hdev, hdev->num);
|
2015-06-20 09:50:50 +00:00
|
|
|
if (irq <= 0)
|
2015-04-13 06:11:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
hdev->irq = irq;
|
2008-09-06 01:02:18 +00:00
|
|
|
hdev->flags |= HPET_DEV_FSB_CAP;
|
|
|
|
hdev->flags |= HPET_DEV_VALID;
|
|
|
|
num_timers_used++;
|
|
|
|
if (num_timers_used == num_possible_cpus())
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO "HPET: %d timers in total, %d timers will be used for per-cpu timer\n",
|
|
|
|
num_timers, num_timers_used);
|
|
|
|
}
|
|
|
|
|
2008-09-24 17:03:17 +00:00
|
|
|
#ifdef CONFIG_HPET
|
|
|
|
static void hpet_reserve_msi_timers(struct hpet_data *hd)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!hpet_devs)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < hpet_num_timers; i++) {
|
|
|
|
struct hpet_dev *hdev = &hpet_devs[i];
|
|
|
|
|
|
|
|
if (!(hdev->flags & HPET_DEV_VALID))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hd->hd_irq[hdev->num] = hdev->irq;
|
|
|
|
hpet_reserve_timer(hd, hdev->num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-09-06 01:02:18 +00:00
|
|
|
static struct hpet_dev *hpet_get_unused_timer(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!hpet_devs)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < hpet_num_timers; i++) {
|
|
|
|
struct hpet_dev *hdev = &hpet_devs[i];
|
|
|
|
|
|
|
|
if (!(hdev->flags & HPET_DEV_VALID))
|
|
|
|
continue;
|
|
|
|
if (test_and_set_bit(HPET_DEV_USED_BIT,
|
|
|
|
(unsigned long *)&hdev->flags))
|
|
|
|
continue;
|
|
|
|
return hdev;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct hpet_work_struct {
|
|
|
|
struct delayed_work work;
|
|
|
|
struct completion complete;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void hpet_work(struct work_struct *w)
|
|
|
|
{
|
|
|
|
struct hpet_dev *hdev;
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
struct hpet_work_struct *hpet_work;
|
|
|
|
|
|
|
|
hpet_work = container_of(w, struct hpet_work_struct, work.work);
|
|
|
|
|
|
|
|
hdev = hpet_get_unused_timer();
|
|
|
|
if (hdev)
|
|
|
|
init_one_hpet_msi_clockevent(hdev, cpu);
|
|
|
|
|
|
|
|
complete(&hpet_work->complete);
|
|
|
|
}
|
|
|
|
|
2016-07-13 17:16:30 +00:00
|
|
|
static int hpet_cpuhp_online(unsigned int cpu)
|
2008-09-06 01:02:18 +00:00
|
|
|
{
|
|
|
|
struct hpet_work_struct work;
|
2016-07-13 17:16:30 +00:00
|
|
|
|
|
|
|
INIT_DELAYED_WORK_ONSTACK(&work.work, hpet_work);
|
|
|
|
init_completion(&work.complete);
|
|
|
|
/* FIXME: add schedule_work_on() */
|
|
|
|
schedule_delayed_work_on(cpu, &work.work, 0);
|
|
|
|
wait_for_completion(&work.complete);
|
|
|
|
destroy_delayed_work_on_stack(&work.work);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hpet_cpuhp_dead(unsigned int cpu)
|
|
|
|
{
|
2008-09-06 01:02:18 +00:00
|
|
|
struct hpet_dev *hdev = per_cpu(cpu_hpet_dev, cpu);
|
|
|
|
|
2016-07-13 17:16:30 +00:00
|
|
|
if (!hdev)
|
|
|
|
return 0;
|
|
|
|
free_irq(hdev->irq, hdev);
|
|
|
|
hdev->flags &= ~HPET_DEV_USED;
|
|
|
|
per_cpu(cpu_hpet_dev, cpu) = NULL;
|
|
|
|
return 0;
|
2008-09-06 01:02:18 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
|
2008-09-24 17:03:17 +00:00
|
|
|
static void hpet_msi_capability_lookup(unsigned int start_timer)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HPET
|
|
|
|
static void hpet_reserve_msi_timers(struct hpet_data *hd)
|
2008-09-06 01:02:18 +00:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2008-09-24 17:03:17 +00:00
|
|
|
#endif
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2016-07-13 17:16:30 +00:00
|
|
|
#define hpet_cpuhp_online NULL
|
|
|
|
#define hpet_cpuhp_dead NULL
|
2008-09-06 01:02:18 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2007-03-05 08:30:50 +00:00
|
|
|
/*
|
|
|
|
* Clock source related code
|
|
|
|
*/
|
2016-09-06 17:22:10 +00:00
|
|
|
#if defined(CONFIG_SMP) && defined(CONFIG_64BIT)
|
|
|
|
/*
|
|
|
|
* Reading the HPET counter is a very slow operation. If a large number of
|
|
|
|
* CPUs are trying to access the HPET counter simultaneously, it can cause
|
|
|
|
* massive delay and slow down system performance dramatically. This may
|
|
|
|
* happen when HPET is the default clock source instead of TSC. For a
|
|
|
|
* really large system with hundreds of CPUs, the slowdown may be so
|
|
|
|
* severe that it may actually crash the system because of a NMI watchdog
|
|
|
|
* soft lockup, for example.
|
|
|
|
*
|
|
|
|
* If multiple CPUs are trying to access the HPET counter at the same time,
|
|
|
|
* we don't actually need to read the counter multiple times. Instead, the
|
|
|
|
* other CPUs can use the counter value read by the first CPU in the group.
|
|
|
|
*
|
|
|
|
* This special feature is only enabled on x86-64 systems. It is unlikely
|
|
|
|
* that 32-bit x86 systems will have enough CPUs to require this feature
|
|
|
|
* with its associated locking overhead. And we also need 64-bit atomic
|
|
|
|
* read.
|
|
|
|
*
|
|
|
|
* The lock and the hpet value are stored together and can be read in a
|
|
|
|
* single atomic 64-bit read. It is explicitly assumed that arch_spinlock_t
|
|
|
|
* is 32 bits in size.
|
|
|
|
*/
|
|
|
|
union hpet_lock {
|
|
|
|
struct {
|
|
|
|
arch_spinlock_t lock;
|
|
|
|
u32 value;
|
|
|
|
};
|
|
|
|
u64 lockval;
|
|
|
|
};
|
|
|
|
|
|
|
|
static union hpet_lock hpet __cacheline_aligned = {
|
|
|
|
{ .lock = __ARCH_SPIN_LOCK_UNLOCKED, },
|
|
|
|
};
|
|
|
|
|
2016-12-21 19:32:01 +00:00
|
|
|
static u64 read_hpet(struct clocksource *cs)
|
2016-09-06 17:22:10 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
union hpet_lock old, new;
|
|
|
|
|
|
|
|
BUILD_BUG_ON(sizeof(union hpet_lock) != 8);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read HPET directly if in NMI.
|
|
|
|
*/
|
|
|
|
if (in_nmi())
|
2016-12-21 19:32:01 +00:00
|
|
|
return (u64)hpet_readl(HPET_COUNTER);
|
2016-09-06 17:22:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the current state of the lock and HPET value atomically.
|
|
|
|
*/
|
|
|
|
old.lockval = READ_ONCE(hpet.lockval);
|
|
|
|
|
|
|
|
if (arch_spin_is_locked(&old.lock))
|
|
|
|
goto contended;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
if (arch_spin_trylock(&hpet.lock)) {
|
|
|
|
new.value = hpet_readl(HPET_COUNTER);
|
|
|
|
/*
|
|
|
|
* Use WRITE_ONCE() to prevent store tearing.
|
|
|
|
*/
|
|
|
|
WRITE_ONCE(hpet.value, new.value);
|
|
|
|
arch_spin_unlock(&hpet.lock);
|
|
|
|
local_irq_restore(flags);
|
2016-12-21 19:32:01 +00:00
|
|
|
return (u64)new.value;
|
2016-09-06 17:22:10 +00:00
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
contended:
|
|
|
|
/*
|
|
|
|
* Contended case
|
|
|
|
* --------------
|
|
|
|
* Wait until the HPET value change or the lock is free to indicate
|
|
|
|
* its value is up-to-date.
|
|
|
|
*
|
|
|
|
* It is possible that old.value has already contained the latest
|
|
|
|
* HPET value while the lock holder was in the process of releasing
|
|
|
|
* the lock. Checking for lock state change will enable us to return
|
|
|
|
* the value immediately instead of waiting for the next HPET reader
|
|
|
|
* to come along.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
cpu_relax();
|
|
|
|
new.lockval = READ_ONCE(hpet.lockval);
|
|
|
|
} while ((new.value == old.value) && arch_spin_is_locked(&new.lock));
|
|
|
|
|
2016-12-21 19:32:01 +00:00
|
|
|
return (u64)new.value;
|
2016-09-06 17:22:10 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* For UP or 32-bit.
|
|
|
|
*/
|
2016-12-21 19:32:01 +00:00
|
|
|
static u64 read_hpet(struct clocksource *cs)
|
2007-03-05 08:30:50 +00:00
|
|
|
{
|
2016-12-21 19:32:01 +00:00
|
|
|
return (u64)hpet_readl(HPET_COUNTER);
|
2007-03-05 08:30:50 +00:00
|
|
|
}
|
2016-09-06 17:22:10 +00:00
|
|
|
#endif
|
2007-03-05 08:30:50 +00:00
|
|
|
|
|
|
|
static struct clocksource clocksource_hpet = {
|
|
|
|
.name = "hpet",
|
|
|
|
.rating = 250,
|
|
|
|
.read = read_hpet,
|
|
|
|
.mask = HPET_MASK,
|
|
|
|
.flags = CLOCK_SOURCE_IS_CONTINUOUS,
|
2009-02-20 23:10:44 +00:00
|
|
|
.resume = hpet_resume_counter,
|
2007-03-05 08:30:50 +00:00
|
|
|
};
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
static int hpet_clocksource_register(void)
|
2007-02-16 09:28:04 +00:00
|
|
|
{
|
x86: clean up computation of HPET .mult variables
While reading through the HPET code I realized that the
computation of .mult variables could be done with less
lines of code, resulting in a 1.6% text size saving
for hpet.o
So I propose the following patch, which applies against
today's Linus -git tree.
>From 0c6507e400e9ca5f7f14331e18f8c12baf75a9d3 Mon Sep 17 00:00:00 2001
From: Carlos R. Mafra <crmafra@ift.unesp.br>
Date: Mon, 5 May 2008 19:38:53 -0300
The computation of clocksource_hpet.mult
tmp = (u64)hpet_period << HPET_SHIFT;
do_div(tmp, FSEC_PER_NSEC);
clocksource_hpet.mult = (u32)tmp;
can be streamlined if we note that it is equal to
clocksource_hpet.mult = div_sc(hpet_period, FSEC_PER_NSEC, HPET_SHIFT);
Furthermore, the computation of hpet_clockevent.mult
uint64_t hpet_freq;
hpet_freq = 1000000000000000ULL;
do_div(hpet_freq, hpet_period);
hpet_clockevent.mult = div_sc((unsigned long) hpet_freq,
NSEC_PER_SEC, hpet_clockevent.shift);
can also be streamlined with the observation that hpet_period and hpet_freq are
inverse to each other (in proper units).
So instead of computing hpet_freq and using (schematically)
div_sc(hpet_freq, 10^9, shift) we use the trick of calling with the
arguments in reverse order, div_sc(10^6, hpet_period, shift).
The different power of ten is due to frequency being in Hertz (1/sec)
and the period being in units of femtosecond. Explicitly,
mult = (hpet_freq * 2^shift)/10^9 (before)
mult = (10^6 * 2^shift)/hpet_period (after)
because hpet_freq = 10^15/hpet_period.
The comments in the code are also updated to reflect the changes.
As a result,
text data bss dec hex filename
2957 425 92 3474 d92 arch/x86/kernel/hpet.o
3006 425 92 3523 dc3 arch/x86/kernel/hpet.o.old
a 1.6% reduction in text size.
Signed-off-by: Carlos R. Mafra <crmafra@ift.unesp.br>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-05 23:11:22 +00:00
|
|
|
u64 start, now;
|
2016-12-21 19:32:01 +00:00
|
|
|
u64 t1;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
/* Start the counter */
|
2009-02-20 23:10:44 +00:00
|
|
|
hpet_restart_counter();
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2007-07-21 15:11:12 +00:00
|
|
|
/* Verify whether hpet counter works */
|
2009-04-21 19:24:00 +00:00
|
|
|
t1 = hpet_readl(HPET_COUNTER);
|
2015-06-25 16:44:07 +00:00
|
|
|
start = rdtsc();
|
2007-07-21 15:11:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't know the TSC frequency yet, but waiting for
|
|
|
|
* 200000 TSC cycles is safe:
|
|
|
|
* 4 GHz == 50us
|
|
|
|
* 1 GHz == 200us
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
rep_nop();
|
2015-06-25 16:44:07 +00:00
|
|
|
now = rdtsc();
|
2007-07-21 15:11:12 +00:00
|
|
|
} while ((now - start) < 200000UL);
|
|
|
|
|
2009-04-21 19:24:00 +00:00
|
|
|
if (t1 == hpet_readl(HPET_COUNTER)) {
|
2007-07-21 15:11:12 +00:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"HPET counter not counting. HPET disabled\n");
|
2007-10-12 21:04:23 +00:00
|
|
|
return -ENODEV;
|
2007-07-21 15:11:12 +00:00
|
|
|
}
|
|
|
|
|
2010-07-14 00:56:27 +00:00
|
|
|
clocksource_register_hz(&clocksource_hpet, (u32)hpet_freq);
|
2007-10-12 21:04:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-02 14:15:55 +00:00
|
|
|
static u32 *hpet_boot_cfg;
|
|
|
|
|
2008-02-04 23:48:13 +00:00
|
|
|
/**
|
|
|
|
* hpet_enable - Try to setup the HPET timer. Returns 1 on success.
|
2007-10-12 21:04:23 +00:00
|
|
|
*/
|
|
|
|
int __init hpet_enable(void)
|
|
|
|
{
|
2012-04-02 14:15:55 +00:00
|
|
|
u32 hpet_period, cfg, id;
|
2011-05-18 21:33:43 +00:00
|
|
|
u64 freq;
|
2012-04-02 14:15:55 +00:00
|
|
|
unsigned int i, last;
|
2007-10-12 21:04:23 +00:00
|
|
|
|
|
|
|
if (!is_hpet_capable())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hpet_set_mapping();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the period and check for a sane value:
|
|
|
|
*/
|
|
|
|
hpet_period = hpet_readl(HPET_PERIOD);
|
2008-08-14 10:17:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* AMD SB700 based systems with spread spectrum enabled use a
|
|
|
|
* SMM based HPET emulation to provide proper frequency
|
|
|
|
* setting. The SMM code is initialized with the first HPET
|
|
|
|
* register access and takes some time to complete. During
|
|
|
|
* this time the config register reads 0xffffffff. We check
|
|
|
|
* for max. 1000 loops whether the config register reads a non
|
|
|
|
* 0xffffffff value to make sure that HPET is up and running
|
|
|
|
* before we go further. A counting loop is safe, as the HPET
|
|
|
|
* access takes thousands of CPU cycles. On non SB700 based
|
|
|
|
* machines this check is only done once and has no side
|
|
|
|
* effects.
|
|
|
|
*/
|
|
|
|
for (i = 0; hpet_readl(HPET_CFG) == 0xFFFFFFFF; i++) {
|
|
|
|
if (i == 1000) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"HPET config register value = 0xFFFFFFFF. "
|
|
|
|
"Disabling HPET\n");
|
|
|
|
goto out_nohpet;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
if (hpet_period < HPET_MIN_PERIOD || hpet_period > HPET_MAX_PERIOD)
|
|
|
|
goto out_nohpet;
|
|
|
|
|
2011-05-18 21:33:43 +00:00
|
|
|
/*
|
|
|
|
* The period is a femto seconds value. Convert it to a
|
|
|
|
* frequency.
|
|
|
|
*/
|
|
|
|
freq = FSEC_PER_SEC;
|
|
|
|
do_div(freq, hpet_period);
|
|
|
|
hpet_freq = freq;
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
/*
|
|
|
|
* Read the HPET ID register to retrieve the IRQ routing
|
|
|
|
* information and the number of channels
|
|
|
|
*/
|
|
|
|
id = hpet_readl(HPET_ID);
|
2009-02-20 23:09:47 +00:00
|
|
|
hpet_print_config();
|
2007-10-12 21:04:23 +00:00
|
|
|
|
2012-04-02 14:15:55 +00:00
|
|
|
last = (id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
#ifdef CONFIG_HPET_EMULATE_RTC
|
|
|
|
/*
|
|
|
|
* The legacy routing mode needs at least two channels, tick timer
|
|
|
|
* and the rtc emulation channel.
|
|
|
|
*/
|
2012-04-02 14:15:55 +00:00
|
|
|
if (!last)
|
2007-10-12 21:04:23 +00:00
|
|
|
goto out_nohpet;
|
|
|
|
#endif
|
|
|
|
|
2012-04-02 14:15:55 +00:00
|
|
|
cfg = hpet_readl(HPET_CFG);
|
|
|
|
hpet_boot_cfg = kmalloc((last + 2) * sizeof(*hpet_boot_cfg),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (hpet_boot_cfg)
|
|
|
|
*hpet_boot_cfg = cfg;
|
|
|
|
else
|
|
|
|
pr_warn("HPET initial state will not be saved\n");
|
|
|
|
cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
|
2012-05-25 10:40:09 +00:00
|
|
|
hpet_writel(cfg, HPET_CFG);
|
2012-04-02 14:15:55 +00:00
|
|
|
if (cfg)
|
|
|
|
pr_warn("HPET: Unrecognized bits %#x set in global cfg\n",
|
|
|
|
cfg);
|
|
|
|
|
|
|
|
for (i = 0; i <= last; ++i) {
|
|
|
|
cfg = hpet_readl(HPET_Tn_CFG(i));
|
|
|
|
if (hpet_boot_cfg)
|
|
|
|
hpet_boot_cfg[i + 1] = cfg;
|
|
|
|
cfg &= ~(HPET_TN_ENABLE | HPET_TN_LEVEL | HPET_TN_FSB);
|
|
|
|
hpet_writel(cfg, HPET_Tn_CFG(i));
|
|
|
|
cfg &= ~(HPET_TN_PERIODIC | HPET_TN_PERIODIC_CAP
|
|
|
|
| HPET_TN_64BIT_CAP | HPET_TN_32BIT | HPET_TN_ROUTE
|
|
|
|
| HPET_TN_FSB | HPET_TN_FSB_CAP);
|
|
|
|
if (cfg)
|
|
|
|
pr_warn("HPET: Unrecognized bits %#x set in cfg#%u\n",
|
|
|
|
cfg, i);
|
|
|
|
}
|
|
|
|
hpet_print_config();
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
if (hpet_clocksource_register())
|
|
|
|
goto out_nohpet;
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
if (id & HPET_ID_LEGSUP) {
|
2007-10-12 21:04:23 +00:00
|
|
|
hpet_legacy_clockevent_register();
|
2007-02-16 09:28:04 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-06-26 07:25:12 +00:00
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
out_nohpet:
|
2007-10-12 21:04:06 +00:00
|
|
|
hpet_clear_mapping();
|
2008-12-16 11:39:57 +00:00
|
|
|
hpet_address = 0;
|
2007-02-16 09:28:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-12 21:04:06 +00:00
|
|
|
/*
|
|
|
|
* Needs to be late, as the reserve_timer code calls kalloc !
|
|
|
|
*
|
|
|
|
* Not a problem on i386 as hpet_enable is called from late_time_init,
|
|
|
|
* but on x86_64 it is necessary !
|
|
|
|
*/
|
|
|
|
static __init int hpet_late_init(void)
|
|
|
|
{
|
2016-07-13 17:16:30 +00:00
|
|
|
int ret;
|
2008-09-06 01:02:18 +00:00
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
if (boot_hpet_disable)
|
2007-10-12 21:04:06 +00:00
|
|
|
return -ENODEV;
|
|
|
|
|
2007-10-12 21:04:23 +00:00
|
|
|
if (!hpet_address) {
|
|
|
|
if (!force_hpet_address)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
hpet_address = force_hpet_address;
|
|
|
|
hpet_enable();
|
|
|
|
}
|
|
|
|
|
2008-12-16 20:32:23 +00:00
|
|
|
if (!hpet_virt_address)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2009-08-12 03:16:12 +00:00
|
|
|
if (hpet_readl(HPET_ID) & HPET_ID_LEGSUP)
|
|
|
|
hpet_msi_capability_lookup(2);
|
|
|
|
else
|
|
|
|
hpet_msi_capability_lookup(0);
|
|
|
|
|
2007-10-12 21:04:06 +00:00
|
|
|
hpet_reserve_platform_timers(hpet_readl(HPET_ID));
|
2009-02-20 23:09:47 +00:00
|
|
|
hpet_print_config();
|
2007-10-12 21:04:23 +00:00
|
|
|
|
2010-01-21 19:09:52 +00:00
|
|
|
if (hpet_msi_disable)
|
|
|
|
return 0;
|
|
|
|
|
2009-08-12 03:16:12 +00:00
|
|
|
if (boot_cpu_has(X86_FEATURE_ARAT))
|
|
|
|
return 0;
|
|
|
|
|
2008-09-06 01:02:18 +00:00
|
|
|
/* This notifier should be called after workqueue is ready */
|
2016-12-21 19:19:54 +00:00
|
|
|
ret = cpuhp_setup_state(CPUHP_AP_X86_HPET_ONLINE, "x86/hpet:online",
|
2016-07-13 17:16:30 +00:00
|
|
|
hpet_cpuhp_online, NULL);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2016-12-21 19:19:54 +00:00
|
|
|
ret = cpuhp_setup_state(CPUHP_X86_HPET_DEAD, "x86/hpet:dead", NULL,
|
2016-07-13 17:16:30 +00:00
|
|
|
hpet_cpuhp_dead);
|
|
|
|
if (ret)
|
|
|
|
goto err_cpuhp;
|
2007-10-12 21:04:06 +00:00
|
|
|
return 0;
|
2016-07-13 17:16:30 +00:00
|
|
|
|
|
|
|
err_cpuhp:
|
|
|
|
cpuhp_remove_state(CPUHP_AP_X86_HPET_ONLINE);
|
|
|
|
return ret;
|
2007-10-12 21:04:06 +00:00
|
|
|
}
|
|
|
|
fs_initcall(hpet_late_init);
|
|
|
|
|
2007-12-03 16:17:10 +00:00
|
|
|
void hpet_disable(void)
|
|
|
|
{
|
2010-07-21 17:32:37 +00:00
|
|
|
if (is_hpet_capable() && hpet_virt_address) {
|
2012-04-02 14:15:55 +00:00
|
|
|
unsigned int cfg = hpet_readl(HPET_CFG), id, last;
|
2007-12-03 16:17:10 +00:00
|
|
|
|
2012-04-02 14:15:55 +00:00
|
|
|
if (hpet_boot_cfg)
|
|
|
|
cfg = *hpet_boot_cfg;
|
|
|
|
else if (hpet_legacy_int_enabled) {
|
2007-12-03 16:17:10 +00:00
|
|
|
cfg &= ~HPET_CFG_LEGACY;
|
2015-10-19 10:35:44 +00:00
|
|
|
hpet_legacy_int_enabled = false;
|
2007-12-03 16:17:10 +00:00
|
|
|
}
|
|
|
|
cfg &= ~HPET_CFG_ENABLE;
|
|
|
|
hpet_writel(cfg, HPET_CFG);
|
2012-04-02 14:15:55 +00:00
|
|
|
|
|
|
|
if (!hpet_boot_cfg)
|
|
|
|
return;
|
|
|
|
|
|
|
|
id = hpet_readl(HPET_ID);
|
|
|
|
last = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT);
|
|
|
|
|
|
|
|
for (id = 0; id <= last; ++id)
|
|
|
|
hpet_writel(hpet_boot_cfg[id + 1], HPET_Tn_CFG(id));
|
|
|
|
|
|
|
|
if (*hpet_boot_cfg & HPET_CFG_ENABLE)
|
|
|
|
hpet_writel(*hpet_boot_cfg, HPET_CFG);
|
2007-12-03 16:17:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
#ifdef CONFIG_HPET_EMULATE_RTC
|
|
|
|
|
|
|
|
/* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
|
|
|
|
* is enabled, we support RTC interrupt functionality in software.
|
|
|
|
* RTC has 3 kinds of interrupts:
|
|
|
|
* 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
|
|
|
|
* is updated
|
|
|
|
* 2) Alarm Interrupt - generate an interrupt at a specific time of day
|
|
|
|
* 3) Periodic Interrupt - generate periodic interrupt, with frequencies
|
|
|
|
* 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
|
|
|
|
* (1) and (2) above are implemented using polling at a frequency of
|
|
|
|
* 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
|
|
|
|
* overhead. (DEFAULT_RTC_INT_FREQ)
|
|
|
|
* For (3), we use interrupts at 64Hz or user specified periodic
|
|
|
|
* frequency, whichever is higher.
|
|
|
|
*/
|
|
|
|
#include <linux/mc146818rtc.h>
|
|
|
|
#include <linux/rtc.h>
|
|
|
|
|
|
|
|
#define DEFAULT_RTC_INT_FREQ 64
|
|
|
|
#define DEFAULT_RTC_SHIFT 6
|
|
|
|
#define RTC_NUM_INTS 1
|
|
|
|
|
|
|
|
static unsigned long hpet_rtc_flags;
|
2008-07-24 04:30:47 +00:00
|
|
|
static int hpet_prev_update_sec;
|
2007-02-16 09:28:04 +00:00
|
|
|
static struct rtc_time hpet_alarm_time;
|
|
|
|
static unsigned long hpet_pie_count;
|
2009-02-04 10:40:31 +00:00
|
|
|
static u32 hpet_t1_cmp;
|
2009-08-19 07:44:24 +00:00
|
|
|
static u32 hpet_default_delta;
|
|
|
|
static u32 hpet_pie_delta;
|
2007-02-16 09:28:04 +00:00
|
|
|
static unsigned long hpet_pie_limit;
|
|
|
|
|
2008-01-30 12:33:28 +00:00
|
|
|
static rtc_irq_handler irq_handler;
|
|
|
|
|
2009-02-04 10:40:31 +00:00
|
|
|
/*
|
|
|
|
* Check that the hpet counter c1 is ahead of the c2
|
|
|
|
*/
|
|
|
|
static inline int hpet_cnt_ahead(u32 c1, u32 c2)
|
|
|
|
{
|
|
|
|
return (s32)(c2 - c1) < 0;
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:33:28 +00:00
|
|
|
/*
|
|
|
|
* Registers a IRQ handler.
|
|
|
|
*/
|
|
|
|
int hpet_register_irq_handler(rtc_irq_handler handler)
|
|
|
|
{
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return -ENODEV;
|
|
|
|
if (irq_handler)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
irq_handler = handler;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hpet_register_irq_handler);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deregisters the IRQ handler registered with hpet_register_irq_handler()
|
|
|
|
* and does cleanup.
|
|
|
|
*/
|
|
|
|
void hpet_unregister_irq_handler(rtc_irq_handler handler)
|
|
|
|
{
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return;
|
|
|
|
|
|
|
|
irq_handler = NULL;
|
|
|
|
hpet_rtc_flags = 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(hpet_unregister_irq_handler);
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
/*
|
|
|
|
* Timer 1 for RTC emulation. We use one shot mode, as periodic mode
|
|
|
|
* is not supported by all HPET implementations for timer 1.
|
|
|
|
*
|
|
|
|
* hpet_rtc_timer_init() is called when the rtc is initialized.
|
|
|
|
*/
|
|
|
|
int hpet_rtc_timer_init(void)
|
|
|
|
{
|
2009-08-19 07:44:24 +00:00
|
|
|
unsigned int cfg, cnt, delta;
|
|
|
|
unsigned long flags;
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!hpet_default_delta) {
|
|
|
|
uint64_t clc;
|
|
|
|
|
|
|
|
clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
|
|
|
|
clc >>= hpet_clockevent.shift + DEFAULT_RTC_SHIFT;
|
2009-08-19 07:44:24 +00:00
|
|
|
hpet_default_delta = clc;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
|
|
|
|
delta = hpet_default_delta;
|
|
|
|
else
|
|
|
|
delta = hpet_pie_delta;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
cnt = delta + hpet_readl(HPET_COUNTER);
|
|
|
|
hpet_writel(cnt, HPET_T1_CMP);
|
|
|
|
hpet_t1_cmp = cnt;
|
|
|
|
|
|
|
|
cfg = hpet_readl(HPET_T1_CFG);
|
|
|
|
cfg &= ~HPET_TN_PERIODIC;
|
|
|
|
cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
|
|
|
|
hpet_writel(cfg, HPET_T1_CFG);
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_rtc_timer_init);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
2011-11-18 15:33:06 +00:00
|
|
|
static void hpet_disable_rtc_channel(void)
|
|
|
|
{
|
2015-10-19 10:35:44 +00:00
|
|
|
u32 cfg = hpet_readl(HPET_T1_CFG);
|
2011-11-18 15:33:06 +00:00
|
|
|
cfg &= ~HPET_TN_ENABLE;
|
|
|
|
hpet_writel(cfg, HPET_T1_CFG);
|
|
|
|
}
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
/*
|
|
|
|
* The functions below are called from rtc driver.
|
|
|
|
* Return 0 if HPET is not being used.
|
|
|
|
* Otherwise do the necessary changes and return 1.
|
|
|
|
*/
|
|
|
|
int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
|
|
|
|
{
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hpet_rtc_flags &= ~bit_mask;
|
2011-11-18 15:33:06 +00:00
|
|
|
if (unlikely(!hpet_rtc_flags))
|
|
|
|
hpet_disable_rtc_channel();
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_mask_rtc_irq_bit);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
int hpet_set_rtc_irq_bit(unsigned long bit_mask)
|
|
|
|
{
|
|
|
|
unsigned long oldbits = hpet_rtc_flags;
|
|
|
|
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hpet_rtc_flags |= bit_mask;
|
|
|
|
|
2008-07-24 04:30:47 +00:00
|
|
|
if ((bit_mask & RTC_UIE) && !(oldbits & RTC_UIE))
|
|
|
|
hpet_prev_update_sec = -1;
|
|
|
|
|
2007-02-16 09:28:04 +00:00
|
|
|
if (!oldbits)
|
|
|
|
hpet_rtc_timer_init();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_set_rtc_irq_bit);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
int hpet_set_alarm_time(unsigned char hrs, unsigned char min,
|
|
|
|
unsigned char sec)
|
|
|
|
{
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hpet_alarm_time.tm_hour = hrs;
|
|
|
|
hpet_alarm_time.tm_min = min;
|
|
|
|
hpet_alarm_time.tm_sec = sec;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_set_alarm_time);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
int hpet_set_periodic_freq(unsigned long freq)
|
|
|
|
{
|
|
|
|
uint64_t clc;
|
|
|
|
|
|
|
|
if (!is_hpet_enabled())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (freq <= DEFAULT_RTC_INT_FREQ)
|
|
|
|
hpet_pie_limit = DEFAULT_RTC_INT_FREQ / freq;
|
|
|
|
else {
|
|
|
|
clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
|
|
|
|
do_div(clc, freq);
|
|
|
|
clc >>= hpet_clockevent.shift;
|
2009-08-19 07:44:24 +00:00
|
|
|
hpet_pie_delta = clc;
|
x86, hpet: Fix bug in RTC emulation
We think there exists a bug in the HPET code that emulates the RTC.
In the normal case, when the RTC frequency is set, the rtc driver tells
the hpet code about it here:
int hpet_set_periodic_freq(unsigned long freq)
{
uint64_t clc;
if (!is_hpet_enabled())
return 0;
if (freq <= DEFAULT_RTC_INT_FREQ)
hpet_pie_limit = DEFAULT_RTC_INT_FREQ / freq;
else {
clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
do_div(clc, freq);
clc >>= hpet_clockevent.shift;
hpet_pie_delta = (unsigned long) clc;
}
return 1;
}
If freq is set to 64Hz (DEFAULT_RTC_INT_FREQ) or lower, then
hpet_pie_limit (a static) is set to non-zero. Then, on every one-shot
HPET interrupt, hpet_rtc_timer_reinit is called to compute the next
timeout. Well, that function has this logic:
if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
delta = hpet_default_delta;
else
delta = hpet_pie_delta;
Since hpet_pie_limit is not 0, hpet_default_delta is used. That
corresponds to 64Hz.
Now, if you set a different rtc frequency, you'll take the else path
through hpet_set_periodic_freq, but unfortunately no one resets
hpet_pie_limit back to 0.
Boom....now you are stuck with 64Hz RTC interrupts forever.
The patch below just resets the hpet_pie_limit value when requested freq
is greater than DEFAULT_RTC_INT_FREQ, which we think fixes this problem.
Signed-off-by: Alok N Kataria <akataria@vmware.com>
LKML-Reference: <201003112200.o2BM0Hre012875@imap1.linux-foundation.org>
Signed-off-by: Daniel Hecht <dhecht@vmware.com>
Cc: Venkatesh Pallipadi <venkatesh.pallipadi@gmail.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: H. Peter Anvin <hpa@zytor.com>
2010-03-11 22:00:16 +00:00
|
|
|
hpet_pie_limit = 0;
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_set_periodic_freq);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
int hpet_rtc_dropped_irq(void)
|
|
|
|
{
|
|
|
|
return is_hpet_enabled();
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
static void hpet_rtc_timer_reinit(void)
|
|
|
|
{
|
2011-11-18 15:33:06 +00:00
|
|
|
unsigned int delta;
|
2007-02-16 09:28:04 +00:00
|
|
|
int lost_ints = -1;
|
|
|
|
|
2011-11-18 15:33:06 +00:00
|
|
|
if (unlikely(!hpet_rtc_flags))
|
|
|
|
hpet_disable_rtc_channel();
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
|
|
|
|
delta = hpet_default_delta;
|
|
|
|
else
|
|
|
|
delta = hpet_pie_delta;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Increment the comparator value until we are ahead of the
|
|
|
|
* current count.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
hpet_t1_cmp += delta;
|
|
|
|
hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
|
|
|
|
lost_ints++;
|
2009-02-04 10:40:31 +00:00
|
|
|
} while (!hpet_cnt_ahead(hpet_t1_cmp, hpet_readl(HPET_COUNTER)));
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
if (lost_ints) {
|
|
|
|
if (hpet_rtc_flags & RTC_PIE)
|
|
|
|
hpet_pie_count += lost_ints;
|
|
|
|
if (printk_ratelimit())
|
2008-07-24 04:30:47 +00:00
|
|
|
printk(KERN_WARNING "hpet1: lost %d rtc interrupts\n",
|
2007-02-16 09:28:04 +00:00
|
|
|
lost_ints);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct rtc_time curr_time;
|
|
|
|
unsigned long rtc_int_flag = 0;
|
|
|
|
|
|
|
|
hpet_rtc_timer_reinit();
|
2008-01-30 12:33:28 +00:00
|
|
|
memset(&curr_time, 0, sizeof(struct rtc_time));
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
if (hpet_rtc_flags & (RTC_UIE | RTC_AIE))
|
x86/hpet: Fix /dev/rtc breakage caused by RTC cleanup
Ville Syrjälä reports "The first time I run hwclock after rebooting
I get this:
open("/dev/rtc", O_RDONLY) = 3
ioctl(3, PHN_SET_REGS or RTC_UIE_ON, 0) = 0
select(4, [3], NULL, NULL, {10, 0}) = 0 (Timeout)
ioctl(3, PHN_NOT_OH or RTC_UIE_OFF, 0) = 0
close(3) = 0
On all subsequent runs I get this:
open("/dev/rtc", O_RDONLY) = 3
ioctl(3, PHN_SET_REGS or RTC_UIE_ON, 0) = -1 EINVAL (Invalid argument)
ioctl(3, RTC_RD_TIME, 0x7ffd76b3ae70) = -1 EINVAL (Invalid argument)
close(3) = 0"
This was caused by a stupid typo in a patch that should have been
a simple rename to move around contents of a header file, but
accidentally wrote zeroes into the rtc rather than reading from
it:
463a86304cae ("char/genrtc: x86: remove remnants of asm/rtc.h")
Reported-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Tested-by: Jarkko Nikula <jarkko.nikula@linux.intel.com>
Tested-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Alessandro Zummo <a.zummo@towertech.it>
Cc: Alexandre Belloni <alexandre.belloni@free-electrons.com>
Cc: Borislav Petkov <bp@suse.de>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: rtc-linux@googlegroups.com
Fixes: 463a86304cae ("char/genrtc: x86: remove remnants of asm/rtc.h")
Link: http://lkml.kernel.org/r/20160809195528.1604312-1-arnd@arndb.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-08-09 19:54:53 +00:00
|
|
|
mc146818_get_time(&curr_time);
|
2007-02-16 09:28:04 +00:00
|
|
|
|
|
|
|
if (hpet_rtc_flags & RTC_UIE &&
|
|
|
|
curr_time.tm_sec != hpet_prev_update_sec) {
|
2008-07-24 04:30:47 +00:00
|
|
|
if (hpet_prev_update_sec >= 0)
|
|
|
|
rtc_int_flag = RTC_UF;
|
2007-02-16 09:28:04 +00:00
|
|
|
hpet_prev_update_sec = curr_time.tm_sec;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hpet_rtc_flags & RTC_PIE &&
|
|
|
|
++hpet_pie_count >= hpet_pie_limit) {
|
|
|
|
rtc_int_flag |= RTC_PF;
|
|
|
|
hpet_pie_count = 0;
|
|
|
|
}
|
|
|
|
|
2008-01-15 15:44:38 +00:00
|
|
|
if (hpet_rtc_flags & RTC_AIE &&
|
2007-02-16 09:28:04 +00:00
|
|
|
(curr_time.tm_sec == hpet_alarm_time.tm_sec) &&
|
|
|
|
(curr_time.tm_min == hpet_alarm_time.tm_min) &&
|
|
|
|
(curr_time.tm_hour == hpet_alarm_time.tm_hour))
|
|
|
|
rtc_int_flag |= RTC_AF;
|
|
|
|
|
|
|
|
if (rtc_int_flag) {
|
|
|
|
rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
|
2008-01-30 12:33:28 +00:00
|
|
|
if (irq_handler)
|
|
|
|
irq_handler(rtc_int_flag, dev_id);
|
2007-02-16 09:28:04 +00:00
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
2008-01-30 12:33:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(hpet_rtc_interrupt);
|
2007-02-16 09:28:04 +00:00
|
|
|
#endif
|