[deliverable/linux.git] / arch / x86_64 / kernel / hpet.c

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/mc146818rtc.h>
#include <linux/time.h>
#include <linux/clocksource.h>
#include <linux/ioport.h>
#include <linux/acpi.h>
#include <linux/hpet.h>
#include <asm/pgtable.h>
#include <asm/vsyscall.h>
#include <asm/timex.h>
#include <asm/hpet.h>

int nohpet __initdata;

unsigned long hpet_address;
unsigned long hpet_period;	/* fsecs / HPET clock */
unsigned long hpet_tick;	/* HPET clocks / interrupt */

int hpet_use_timer;		/* Use counter of hpet for time keeping,
				 * otherwise PIT
				 */

#ifdef	CONFIG_HPET
static __init int late_hpet_init(void)
{
	struct hpet_data	hd;
	unsigned int 		ntimer;

	if (!hpet_address)
        	return 0;

	memset(&hd, 0, sizeof(hd));

	ntimer = hpet_readl(HPET_ID);
	ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
	ntimer++;

	/*
	 * Register with driver.
	 * Timer0 and Timer1 is used by platform.
	 */
	hd.hd_phys_address = hpet_address;
	hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
	hd.hd_nirqs = ntimer;
	hd.hd_flags = HPET_DATA_PLATFORM;
	hpet_reserve_timer(&hd, 0);
#ifdef	CONFIG_HPET_EMULATE_RTC
	hpet_reserve_timer(&hd, 1);
#endif
	hd.hd_irq[0] = HPET_LEGACY_8254;
	hd.hd_irq[1] = HPET_LEGACY_RTC;
	if (ntimer > 2) {
		struct hpet		*hpet;
		struct hpet_timer	*timer;
		int			i;

		hpet = (struct hpet *) fix_to_virt(FIX_HPET_BASE);
		timer = &hpet->hpet_timers[2];
		for (i = 2; i < ntimer; timer++, i++)
			hd.hd_irq[i] = (timer->hpet_config &
					Tn_INT_ROUTE_CNF_MASK) >>
				Tn_INT_ROUTE_CNF_SHIFT;

	}

	hpet_alloc(&hd);
	return 0;
}
fs_initcall(late_hpet_init);
#endif

int hpet_timer_stop_set_go(unsigned long tick)
{
	unsigned int cfg;

/*
 * Stop the timers and reset the main counter.
 */

	cfg = hpet_readl(HPET_CFG);
	cfg &= ~(HPET_CFG_ENABLE | HPET_CFG_LEGACY);
	hpet_writel(cfg, HPET_CFG);
	hpet_writel(0, HPET_COUNTER);
	hpet_writel(0, HPET_COUNTER + 4);

/*
 * Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
 * and period also hpet_tick.
 */
	if (hpet_use_timer) {
		hpet_writel(HPET_TN_ENABLE | HPET_TN_PERIODIC | HPET_TN_SETVAL |
		    HPET_TN_32BIT, HPET_T0_CFG);
		hpet_writel(hpet_tick, HPET_T0_CMP); /* next interrupt */
		hpet_writel(hpet_tick, HPET_T0_CMP); /* period */
		cfg |= HPET_CFG_LEGACY;
	}
/*
 * Go!
 */

	cfg |= HPET_CFG_ENABLE;
	hpet_writel(cfg, HPET_CFG);

	return 0;
}

int hpet_arch_init(void)
{
	unsigned int id;

	if (!hpet_address)
		return -1;
	set_fixmap_nocache(FIX_HPET_BASE, hpet_address);
	__set_fixmap(VSYSCALL_HPET, hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);

/*
 * Read the period, compute tick and quotient.
 */

	id = hpet_readl(HPET_ID);

	if (!(id & HPET_ID_VENDOR) || !(id & HPET_ID_NUMBER))
		return -1;

	hpet_period = hpet_readl(HPET_PERIOD);
	if (hpet_period < 100000 || hpet_period > 100000000)
		return -1;

	hpet_tick = (FSEC_PER_TICK + hpet_period / 2) / hpet_period;

	hpet_use_timer = (id & HPET_ID_LEGSUP);

	return hpet_timer_stop_set_go(hpet_tick);
}

int hpet_reenable(void)
{
	return hpet_timer_stop_set_go(hpet_tick);
}

/*
 * calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
 * it to the HPET timer of known frequency.
 */

#define TICK_COUNT 100000000
#define TICK_MIN   5000

/*
 * Some platforms take periodic SMI interrupts with 5ms duration. Make sure none
 * occurs between the reads of the hpet & TSC.
 */
static void __init read_hpet_tsc(int *hpet, int *tsc)
{
	int tsc1, tsc2, hpet1;

	do {
		tsc1 = get_cycles_sync();
		hpet1 = hpet_readl(HPET_COUNTER);
		tsc2 = get_cycles_sync();
	} while (tsc2 - tsc1 > TICK_MIN);
	*hpet = hpet1;
	*tsc = tsc2;
}

unsigned int __init hpet_calibrate_tsc(void)
{
	int tsc_start, hpet_start;
	int tsc_now, hpet_now;
	unsigned long flags;

	local_irq_save(flags);

	read_hpet_tsc(&hpet_start, &tsc_start);

	do {
		local_irq_disable();
		read_hpet_tsc(&hpet_now, &tsc_now);
		local_irq_restore(flags);
	} while ((tsc_now - tsc_start) < TICK_COUNT &&
		(hpet_now - hpet_start) < TICK_COUNT);

	return (tsc_now - tsc_start) * 1000000000L
		/ ((hpet_now - hpet_start) * hpet_period / 1000);
}

#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/rtc.h>

#define DEFAULT_RTC_INT_FREQ 	64
#define RTC_NUM_INTS 		1

static unsigned long UIE_on;
static unsigned long prev_update_sec;

static unsigned long AIE_on;
static struct rtc_time alarm_time;

static unsigned long PIE_on;
static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
static unsigned long PIE_count;

static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
static unsigned int hpet_t1_cmp; /* cached comparator register */

int is_hpet_enabled(void)
{
	return hpet_address != 0;
}

/*
 * Timer 1 for RTC, we do not use periodic interrupt feature,
 * even if HPET supports periodic interrupts on Timer 1.
 * The reason being, to set up a periodic interrupt in HPET, we need to
 * stop the main counter. And if we do that everytime someone diables/enables
 * RTC, we will have adverse effect on main kernel timer running on Timer 0.
 * So, for the time being, simulate the periodic interrupt in software.
 *
 * hpet_rtc_timer_init() is called for the first time and during subsequent
 * interuppts reinit happens through hpet_rtc_timer_reinit().
 */
int hpet_rtc_timer_init(void)
{
	unsigned int cfg, cnt;
	unsigned long flags;

	if (!is_hpet_enabled())
		return 0;
	/*
	 * Set the counter 1 and enable the interrupts.
	 */
	if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
		hpet_rtc_int_freq = PIE_freq;
	else
		hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;

	local_irq_save(flags);

	cnt = hpet_readl(HPET_COUNTER);
	cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
	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;
}

static void hpet_rtc_timer_reinit(void)
{
	unsigned int cfg, cnt, ticks_per_int, lost_ints;

	if (unlikely(!(PIE_on | AIE_on | UIE_on))) {
		cfg = hpet_readl(HPET_T1_CFG);
		cfg &= ~HPET_TN_ENABLE;
		hpet_writel(cfg, HPET_T1_CFG);
		return;
	}

	if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
		hpet_rtc_int_freq = PIE_freq;
	else
		hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;

	/* It is more accurate to use the comparator value than current count.*/
	ticks_per_int = hpet_tick * HZ / hpet_rtc_int_freq;
	hpet_t1_cmp += ticks_per_int;
	hpet_writel(hpet_t1_cmp, HPET_T1_CMP);

	/*
	 * If the interrupt handler was delayed too long, the write above tries
	 * to schedule the next interrupt in the past and the hardware would
	 * not interrupt until the counter had wrapped around.
	 * So we have to check that the comparator wasn't set to a past time.
	 */
	cnt = hpet_readl(HPET_COUNTER);
	if (unlikely((int)(cnt - hpet_t1_cmp) > 0)) {
		lost_ints = (cnt - hpet_t1_cmp) / ticks_per_int + 1;
		/* Make sure that, even with the time needed to execute
		 * this code, the next scheduled interrupt has been moved
		 * back to the future: */
		lost_ints++;

		hpet_t1_cmp += lost_ints * ticks_per_int;
		hpet_writel(hpet_t1_cmp, HPET_T1_CMP);

		if (PIE_on)
			PIE_count += lost_ints;

		if (printk_ratelimit())
			printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
			       hpet_rtc_int_freq);
	}
}

/*
 * 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;

	if (bit_mask & RTC_UIE)
		UIE_on = 0;
	if (bit_mask & RTC_PIE)
		PIE_on = 0;
	if (bit_mask & RTC_AIE)
		AIE_on = 0;

	return 1;
}

int hpet_set_rtc_irq_bit(unsigned long bit_mask)
{
	int timer_init_reqd = 0;

	if (!is_hpet_enabled())
		return 0;

	if (!(PIE_on | AIE_on | UIE_on))
		timer_init_reqd = 1;

	if (bit_mask & RTC_UIE) {
		UIE_on = 1;
	}
	if (bit_mask & RTC_PIE) {
		PIE_on = 1;
		PIE_count = 0;
	}
	if (bit_mask & RTC_AIE) {
		AIE_on = 1;
	}

	if (timer_init_reqd)
		hpet_rtc_timer_init();

	return 1;
}

int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
{
	if (!is_hpet_enabled())
		return 0;

	alarm_time.tm_hour = hrs;
	alarm_time.tm_min = min;
	alarm_time.tm_sec = sec;

	return 1;
}

int hpet_set_periodic_freq(unsigned long freq)
{
	if (!is_hpet_enabled())
		return 0;

	PIE_freq = freq;
	PIE_count = 0;

	return 1;
}

int hpet_rtc_dropped_irq(void)
{
	if (!is_hpet_enabled())
		return 0;

	return 1;
}

irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	struct rtc_time curr_time;
	unsigned long rtc_int_flag = 0;
	int call_rtc_interrupt = 0;

	hpet_rtc_timer_reinit();

	if (UIE_on | AIE_on) {
		rtc_get_rtc_time(&curr_time);
	}
	if (UIE_on) {
		if (curr_time.tm_sec != prev_update_sec) {
			/* Set update int info, call real rtc int routine */
			call_rtc_interrupt = 1;
			rtc_int_flag = RTC_UF;
			prev_update_sec = curr_time.tm_sec;
		}
	}
	if (PIE_on) {
		PIE_count++;
		if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
			/* Set periodic int info, call real rtc int routine */
			call_rtc_interrupt = 1;
			rtc_int_flag |= RTC_PF;
			PIE_count = 0;
		}
	}
	if (AIE_on) {
		if ((curr_time.tm_sec == alarm_time.tm_sec) &&
		    (curr_time.tm_min == alarm_time.tm_min) &&
		    (curr_time.tm_hour == alarm_time.tm_hour)) {
			/* Set alarm int info, call real rtc int routine */
			call_rtc_interrupt = 1;
			rtc_int_flag |= RTC_AF;
		}
	}
	if (call_rtc_interrupt) {
		rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
		rtc_interrupt(rtc_int_flag, dev_id);
	}
	return IRQ_HANDLED;
}
#endif

static int __init nohpet_setup(char *s)
{
	nohpet = 1;
	return 1;
}

__setup("nohpet", nohpet_setup);

#define HPET_MASK	0xFFFFFFFF
#define HPET_SHIFT	22

/* FSEC = 10^-15 NSEC = 10^-9 */
#define FSEC_PER_NSEC	1000000

static void *hpet_ptr;

static cycle_t read_hpet(void)
{
	return (cycle_t)readl(hpet_ptr);
}

static cycle_t __vsyscall_fn vread_hpet(void)
{
	return readl((void __iomem *)fix_to_virt(VSYSCALL_HPET) + 0xf0);
}

struct clocksource clocksource_hpet = {
	.name		= "hpet",
	.rating		= 250,
	.read		= read_hpet,
	.mask		= (cycle_t)HPET_MASK,
	.mult		= 0, /* set below */
	.shift		= HPET_SHIFT,
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
	.vread		= vread_hpet,
};

static int __init init_hpet_clocksource(void)
{
	unsigned long hpet_period;
	void __iomem *hpet_base;
	u64 tmp;

	if (!hpet_address)
		return -ENODEV;

	/* calculate the hpet address: */
	hpet_base = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
	hpet_ptr = hpet_base + HPET_COUNTER;

	/* calculate the frequency: */
	hpet_period = readl(hpet_base + HPET_PERIOD);

	/*
	 * hpet period is in femto seconds per cycle
	 * so we need to convert this to ns/cyc units
	 * aproximated by mult/2^shift
	 *
	 *  fsec/cyc * 1nsec/1000000fsec = nsec/cyc = mult/2^shift
	 *  fsec/cyc * 1ns/1000000fsec * 2^shift = mult
	 *  fsec/cyc * 2^shift * 1nsec/1000000fsec = mult
	 *  (fsec/cyc << shift)/1000000 = mult
	 *  (hpet_period << shift)/FSEC_PER_NSEC = mult
	 */
	tmp = (u64)hpet_period << HPET_SHIFT;
	do_div(tmp, FSEC_PER_NSEC);
	clocksource_hpet.mult = (u32)tmp;

	return clocksource_register(&clocksource_hpet);
}

module_init(init_hpet_clocksource);
Commit	Line	Data
c37e7bb5	1	#include <linux/kernel.h>
	2	#include <linux/sched.h>
	3	#include <linux/init.h>
	4	#include <linux/mc146818rtc.h>
	5	#include <linux/time.h>
	6	#include <linux/clocksource.h>
	7	#include <linux/ioport.h>
	8	#include <linux/acpi.h>
	9	#include <linux/hpet.h>
	10	#include <asm/pgtable.h>
	11	#include <asm/vsyscall.h>
	12	#include <asm/timex.h>
	13	#include <asm/hpet.h>
	14
	15	int nohpet __initdata;
	16
	17	unsigned long hpet_address;
	18	unsigned long hpet_period; /* fsecs / HPET clock */
	19	unsigned long hpet_tick; /* HPET clocks / interrupt */
	20
	21	int hpet_use_timer; /* Use counter of hpet for time keeping,
	22	* otherwise PIT
	23	*/
c37e7bb5	24
	25	#ifdef CONFIG_HPET
	26	static __init int late_hpet_init(void)
	27	{
	28	struct hpet_data hd;
	29	unsigned int ntimer;
	30
	31	if (!hpet_address)
	32	return 0;
	33
	34	memset(&hd, 0, sizeof(hd));
	35
	36	ntimer = hpet_readl(HPET_ID);
	37	ntimer = (ntimer & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT;
	38	ntimer++;
	39
	40	/*
	41	* Register with driver.
	42	* Timer0 and Timer1 is used by platform.
	43	*/
	44	hd.hd_phys_address = hpet_address;
	45	hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
	46	hd.hd_nirqs = ntimer;
	47	hd.hd_flags = HPET_DATA_PLATFORM;
	48	hpet_reserve_timer(&hd, 0);
	49	#ifdef CONFIG_HPET_EMULATE_RTC
	50	hpet_reserve_timer(&hd, 1);
	51	#endif
	52	hd.hd_irq[0] = HPET_LEGACY_8254;
	53	hd.hd_irq[1] = HPET_LEGACY_RTC;
	54	if (ntimer > 2) {
	55	struct hpet *hpet;
	56	struct hpet_timer *timer;
	57	int i;
	58
	59	hpet = (struct hpet *) fix_to_virt(FIX_HPET_BASE);
	60	timer = &hpet->hpet_timers[2];
	61	for (i = 2; i < ntimer; timer++, i++)
	62	hd.hd_irq[i] = (timer->hpet_config &
	63	Tn_INT_ROUTE_CNF_MASK) >>
	64	Tn_INT_ROUTE_CNF_SHIFT;
	65
	66	}
	67
	68	hpet_alloc(&hd);
	69	return 0;
	70	}
	71	fs_initcall(late_hpet_init);
	72	#endif
	73
	74	int hpet_timer_stop_set_go(unsigned long tick)
	75	{
	76	unsigned int cfg;
	77
	78	/*
	79	* Stop the timers and reset the main counter.
	80	*/
	81
	82	cfg = hpet_readl(HPET_CFG);
	83	cfg &= ~(HPET_CFG_ENABLE \| HPET_CFG_LEGACY);
	84	hpet_writel(cfg, HPET_CFG);
	85	hpet_writel(0, HPET_COUNTER);
	86	hpet_writel(0, HPET_COUNTER + 4);
	87
88	/*
89	* Set up timer 0, as periodic with first interrupt to happen at hpet_tick,
90	* and period also hpet_tick.
91	*/
92	if (hpet_use_timer) {
93	hpet_writel(HPET_TN_ENABLE \| HPET_TN_PERIODIC \| HPET_TN_SETVAL \|
94	HPET_TN_32BIT, HPET_T0_CFG);
95	hpet_writel(hpet_tick, HPET_T0_CMP); /* next interrupt */
96	hpet_writel(hpet_tick, HPET_T0_CMP); /* period */
97	cfg \|= HPET_CFG_LEGACY;
98	}
99	/*
100	* Go!
101	*/
102
103	cfg \|= HPET_CFG_ENABLE;
104	hpet_writel(cfg, HPET_CFG);
105
106	return 0;
107	}
108
109	int hpet_arch_init(void)
110	{
111	unsigned int id;
112
113	if (!hpet_address)
114	return -1;
115	set_fixmap_nocache(FIX_HPET_BASE, hpet_address);
116	__set_fixmap(VSYSCALL_HPET, hpet_address, PAGE_KERNEL_VSYSCALL_NOCACHE);
117
118	/*
119	* Read the period, compute tick and quotient.
120	*/
121
122	id = hpet_readl(HPET_ID);
123
124	if (!(id & HPET_ID_VENDOR) \|\| !(id & HPET_ID_NUMBER))
125	return -1;
126
127	hpet_period = hpet_readl(HPET_PERIOD);
128	if (hpet_period < 100000 \|\| hpet_period > 100000000)
129	return -1;
130
131	hpet_tick = (FSEC_PER_TICK + hpet_period / 2) / hpet_period;
132
133	hpet_use_timer = (id & HPET_ID_LEGSUP);
134
135	return hpet_timer_stop_set_go(hpet_tick);
136	}
137
138	int hpet_reenable(void)
139	{
140	return hpet_timer_stop_set_go(hpet_tick);
141	}
142
143	/*
144	* calibrate_tsc() calibrates the processor TSC in a very simple way, comparing
145	* it to the HPET timer of known frequency.
146	*/
147
148	#define TICK_COUNT 100000000
149	#define TICK_MIN 5000
150
151	/*
152	* Some platforms take periodic SMI interrupts with 5ms duration. Make sure none
153	* occurs between the reads of the hpet & TSC.
154	*/
155	static void __init read_hpet_tsc(int hpet, int tsc)
156	{
157	int tsc1, tsc2, hpet1;
158
159	do {
160	tsc1 = get_cycles_sync();
161	hpet1 = hpet_readl(HPET_COUNTER);
162	tsc2 = get_cycles_sync();
163	} while (tsc2 - tsc1 > TICK_MIN);
164	*hpet = hpet1;
165	*tsc = tsc2;
166	}
167
168	unsigned int __init hpet_calibrate_tsc(void)
169	{
170	int tsc_start, hpet_start;
171	int tsc_now, hpet_now;
172	unsigned long flags;
173
174	local_irq_save(flags);
175
176	read_hpet_tsc(&hpet_start, &tsc_start);
177
178	do {
179	local_irq_disable();
180	read_hpet_tsc(&hpet_now, &tsc_now);
181	local_irq_restore(flags);
182	} while ((tsc_now - tsc_start) < TICK_COUNT &&
183	(hpet_now - hpet_start) < TICK_COUNT);
184
185	return (tsc_now - tsc_start) * 1000000000L
186	/ ((hpet_now - hpet_start) * hpet_period / 1000);
187	}
188
189	#ifdef CONFIG_HPET_EMULATE_RTC
190	/* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
191	* is enabled, we support RTC interrupt functionality in software.
192	* RTC has 3 kinds of interrupts:
193	* 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
194	* is updated
195	* 2) Alarm Interrupt - generate an interrupt at a specific time of day
196	* 3) Periodic Interrupt - generate periodic interrupt, with frequencies
197	* 2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
198	* (1) and (2) above are implemented using polling at a frequency of
199	* 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
200	* overhead. (DEFAULT_RTC_INT_FREQ)
201	* For (3), we use interrupts at 64Hz or user specified periodic
202	* frequency, whichever is higher.
203	*/
204	#include <linux/rtc.h>
205
206	#define DEFAULT_RTC_INT_FREQ 64
207	#define RTC_NUM_INTS 1
208
209	static unsigned long UIE_on;
210	static unsigned long prev_update_sec;
211
212	static unsigned long AIE_on;
213	static struct rtc_time alarm_time;
214
215	static unsigned long PIE_on;
216	static unsigned long PIE_freq = DEFAULT_RTC_INT_FREQ;
217	static unsigned long PIE_count;
218
219	static unsigned long hpet_rtc_int_freq; /* RTC interrupt frequency */
220	static unsigned int hpet_t1_cmp; /* cached comparator register */
221
222	int is_hpet_enabled(void)
223	{
224	return hpet_address != 0;
225	}
226
227	/*
228	* Timer 1 for RTC, we do not use periodic interrupt feature,
229	* even if HPET supports periodic interrupts on Timer 1.
230	* The reason being, to set up a periodic interrupt in HPET, we need to
231	* stop the main counter. And if we do that everytime someone diables/enables
232	* RTC, we will have adverse effect on main kernel timer running on Timer 0.
233	* So, for the time being, simulate the periodic interrupt in software.
234	*
235	* hpet_rtc_timer_init() is called for the first time and during subsequent
236	* interuppts reinit happens through hpet_rtc_timer_reinit().
237	*/
238	int hpet_rtc_timer_init(void)
239	{
240	unsigned int cfg, cnt;
241	unsigned long flags;
242
243	if (!is_hpet_enabled())
244	return 0;
245	/*
246	* Set the counter 1 and enable the interrupts.
247	*/
248	if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
249	hpet_rtc_int_freq = PIE_freq;
250	else
251	hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
252
253	local_irq_save(flags);
254
255	cnt = hpet_readl(HPET_COUNTER);
256	cnt += ((hpet_tick*HZ)/hpet_rtc_int_freq);
257	hpet_writel(cnt, HPET_T1_CMP);
258	hpet_t1_cmp = cnt;
259
260	cfg = hpet_readl(HPET_T1_CFG);
261	cfg &= ~HPET_TN_PERIODIC;
262	cfg \|= HPET_TN_ENABLE \| HPET_TN_32BIT;
263	hpet_writel(cfg, HPET_T1_CFG);
264
265	local_irq_restore(flags);
266
267	return 1;
268	}
269
270	static void hpet_rtc_timer_reinit(void)
271	{
272	unsigned int cfg, cnt, ticks_per_int, lost_ints;
273
274	if (unlikely(!(PIE_on \| AIE_on \| UIE_on))) {
275	cfg = hpet_readl(HPET_T1_CFG);
276	cfg &= ~HPET_TN_ENABLE;
277	hpet_writel(cfg, HPET_T1_CFG);
278	return;
279	}
280
281	if (PIE_on && (PIE_freq > DEFAULT_RTC_INT_FREQ))
282	hpet_rtc_int_freq = PIE_freq;
283	else
284	hpet_rtc_int_freq = DEFAULT_RTC_INT_FREQ;
285
286	/* It is more accurate to use the comparator value than current count.*/
287	ticks_per_int = hpet_tick * HZ / hpet_rtc_int_freq;
288	hpet_t1_cmp += ticks_per_int;
289	hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
290
291	/*
292	* If the interrupt handler was delayed too long, the write above tries
293	* to schedule the next interrupt in the past and the hardware would
294	* not interrupt until the counter had wrapped around.
295	* So we have to check that the comparator wasn't set to a past time.
296	*/
297	cnt = hpet_readl(HPET_COUNTER);
298	if (unlikely((int)(cnt - hpet_t1_cmp) > 0)) {
299	lost_ints = (cnt - hpet_t1_cmp) / ticks_per_int + 1;
300	/* Make sure that, even with the time needed to execute
301	* this code, the next scheduled interrupt has been moved
302	* back to the future: */
303	lost_ints++;
304
305	hpet_t1_cmp += lost_ints * ticks_per_int;
306	hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
307
308	if (PIE_on)
309	PIE_count += lost_ints;
310
311	if (printk_ratelimit())
312	printk(KERN_WARNING "rtc: lost some interrupts at %ldHz.\n",
313	hpet_rtc_int_freq);
314	}
315	}
316
317	/*
318	* The functions below are called from rtc driver.
319	* Return 0 if HPET is not being used.
320	* Otherwise do the necessary changes and return 1.
321	*/
322	int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
323	{
324	if (!is_hpet_enabled())
325	return 0;
326
327	if (bit_mask & RTC_UIE)
328	UIE_on = 0;
329	if (bit_mask & RTC_PIE)
330	PIE_on = 0;
331	if (bit_mask & RTC_AIE)
332	AIE_on = 0;
333
334	return 1;
335	}
336
337	int hpet_set_rtc_irq_bit(unsigned long bit_mask)
338	{
339	int timer_init_reqd = 0;
340
341	if (!is_hpet_enabled())
342	return 0;
343
344	if (!(PIE_on \| AIE_on \| UIE_on))
345	timer_init_reqd = 1;
346
347	if (bit_mask & RTC_UIE) {
348	UIE_on = 1;
349	}
350	if (bit_mask & RTC_PIE) {
351	PIE_on = 1;
352	PIE_count = 0;
353	}
354	if (bit_mask & RTC_AIE) {
355	AIE_on = 1;
356	}
357
358	if (timer_init_reqd)
359	hpet_rtc_timer_init();
360
361	return 1;
362	}
363
364	int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec)
365	{
366	if (!is_hpet_enabled())
367	return 0;
368
369	alarm_time.tm_hour = hrs;
370	alarm_time.tm_min = min;
371	alarm_time.tm_sec = sec;
372
373	return 1;
374	}
375
376	int hpet_set_periodic_freq(unsigned long freq)
377	{
378	if (!is_hpet_enabled())
379	return 0;
380
381	PIE_freq = freq;
382	PIE_count = 0;
383
384	return 1;
385	}
386
387	int hpet_rtc_dropped_irq(void)
388	{
389	if (!is_hpet_enabled())
390	return 0;
391
392	return 1;
393	}
394
395	irqreturn_t hpet_rtc_interrupt(int irq, void dev_id, struct pt_regs regs)
396	{
397	struct rtc_time curr_time;
398	unsigned long rtc_int_flag = 0;
399	int call_rtc_interrupt = 0;
400
401	hpet_rtc_timer_reinit();
402
403	if (UIE_on \| AIE_on) {
404	rtc_get_rtc_time(&curr_time);
405	}
406	if (UIE_on) {
407	if (curr_time.tm_sec != prev_update_sec) {
408	/* Set update int info, call real rtc int routine */
409	call_rtc_interrupt = 1;
410	rtc_int_flag = RTC_UF;
411	prev_update_sec = curr_time.tm_sec;
412	}
413	}
414	if (PIE_on) {
415	PIE_count++;
416	if (PIE_count >= hpet_rtc_int_freq/PIE_freq) {
417	/* Set periodic int info, call real rtc int routine */
418	call_rtc_interrupt = 1;
419	rtc_int_flag \|= RTC_PF;
420	PIE_count = 0;
421	}
422	}
423	if (AIE_on) {
424	if ((curr_time.tm_sec == alarm_time.tm_sec) &&
425	(curr_time.tm_min == alarm_time.tm_min) &&
426	(curr_time.tm_hour == alarm_time.tm_hour)) {
427	/* Set alarm int info, call real rtc int routine */
428	call_rtc_interrupt = 1;
429	rtc_int_flag \|= RTC_AF;
430	}
431	}
432	if (call_rtc_interrupt) {
433	rtc_int_flag \|= (RTC_IRQF \| (RTC_NUM_INTS << 8));
434	rtc_interrupt(rtc_int_flag, dev_id);
435	}
436	return IRQ_HANDLED;
437	}
438	#endif
439
440	static int __init nohpet_setup(char *s)
441	{
442	nohpet = 1;
443	return 1;
444	}
445
446	__setup("nohpet", nohpet_setup);
447
1489939f	448	#define HPET_MASK 0xFFFFFFFF
	449	#define HPET_SHIFT 22
	450
	451	/* FSEC = 10^-15 NSEC = 10^-9 */
	452	#define FSEC_PER_NSEC 1000000
	453
	454	static void *hpet_ptr;
	455
	456	static cycle_t read_hpet(void)
	457	{
	458	return (cycle_t)readl(hpet_ptr);
	459	}
	460
7460ed28	461	static cycle_t __vsyscall_fn vread_hpet(void)
	462	{
	463	return readl((void __iomem *)fix_to_virt(VSYSCALL_HPET) + 0xf0);
	464	}
	465
1489939f	466	struct clocksource clocksource_hpet = {
	467	.name = "hpet",
	468	.rating = 250,
	469	.read = read_hpet,
	470	.mask = (cycle_t)HPET_MASK,
	471	.mult = 0, /* set below */
	472	.shift = HPET_SHIFT,
	473	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
7460ed28	474	.vread = vread_hpet,
1489939f	475	};
	476
	477	static int __init init_hpet_clocksource(void)
	478	{
	479	unsigned long hpet_period;
	480	void __iomem *hpet_base;
	481	u64 tmp;
	482
	483	if (!hpet_address)
	484	return -ENODEV;
	485
	486	/* calculate the hpet address: */
	487	hpet_base = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
	488	hpet_ptr = hpet_base + HPET_COUNTER;
	489
	490	/* calculate the frequency: */
	491	hpet_period = readl(hpet_base + HPET_PERIOD);
	492
	493	/*
	494	* hpet period is in femto seconds per cycle
	495	* so we need to convert this to ns/cyc units
	496	* aproximated by mult/2^shift
	497	*
	498	* fsec/cyc * 1nsec/1000000fsec = nsec/cyc = mult/2^shift
	499	* fsec/cyc * 1ns/1000000fsec * 2^shift = mult
	500	* fsec/cyc * 2^shift * 1nsec/1000000fsec = mult
	501	* (fsec/cyc << shift)/1000000 = mult
	502	* (hpet_period << shift)/FSEC_PER_NSEC = mult
	503	*/
	504	tmp = (u64)hpet_period << HPET_SHIFT;
	505	do_div(tmp, FSEC_PER_NSEC);
	506	clocksource_hpet.mult = (u32)tmp;
	507
	508	return clocksource_register(&clocksource_hpet);
	509	}
	510
	511	module_init(init_hpet_clocksource);