| /* | |
| * linux/arch/i386/kernel/time_hpet.c | |
| * This code largely copied from arch/x86_64/kernel/time.c | |
| * See that file for credits. | |
| * | |
| * 2003-06-30 Venkatesh Pallipadi - Additional changes for HPET support | |
| */ | |
| #include <linux/errno.h> | |
| #include <linux/kernel.h> | |
| #include <linux/param.h> | |
| #include <linux/string.h> | |
| #include <linux/init.h> | |
| #include <linux/smp.h> | |
| #include <asm/timer.h> | |
| #include <asm/fixmap.h> | |
| #include <asm/apic.h> | |
| #include <linux/timex.h> | |
| #include <asm/hpet.h> | |
| #include <linux/hpet.h> | |
| static unsigned long hpet_period; /* fsecs / HPET clock */ | |
| unsigned long hpet_tick; /* hpet clks count per tick */ | |
| unsigned long hpet_address; /* hpet memory map physical address */ | |
| int hpet_use_timer; | |
| static int use_hpet; /* can be used for runtime check of hpet */ | |
| static int boot_hpet_disable; /* boottime override for HPET timer */ | |
| static void __iomem * hpet_virt_address; /* hpet kernel virtual address */ | |
| #define FSEC_TO_USEC (1000000000UL) | |
| int hpet_readl(unsigned long a) | |
| { | |
| return readl(hpet_virt_address + a); | |
| } | |
| static void hpet_writel(unsigned long d, unsigned long a) | |
| { | |
| writel(d, hpet_virt_address + a); | |
| } | |
| #ifdef CONFIG_X86_LOCAL_APIC | |
| /* | |
| * HPET counters dont wrap around on every tick. They just change the | |
| * comparator value and continue. Next tick can be caught by checking | |
| * for a change in the comparator value. Used in apic.c. | |
| */ | |
| static void __devinit wait_hpet_tick(void) | |
| { | |
| unsigned int start_cmp_val, end_cmp_val; | |
| start_cmp_val = hpet_readl(HPET_T0_CMP); | |
| do { | |
| end_cmp_val = hpet_readl(HPET_T0_CMP); | |
| } while (start_cmp_val == end_cmp_val); | |
| } | |
| #endif | |
| static 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_writel(cfg, HPET_CFG); | |
| hpet_writel(0, HPET_COUNTER); | |
| hpet_writel(0, HPET_COUNTER + 4); | |
| if (hpet_use_timer) { | |
| /* | |
| * Set up timer 0, as periodic with first interrupt to happen at | |
| * hpet_tick, and period also hpet_tick. | |
| */ | |
| cfg = hpet_readl(HPET_T0_CFG); | |
| cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC | | |
| HPET_TN_SETVAL | HPET_TN_32BIT; | |
| hpet_writel(cfg, HPET_T0_CFG); | |
| /* | |
| * The first write after writing TN_SETVAL to the config register sets | |
| * the counter value, the second write sets the threshold. | |
| */ | |
| hpet_writel(tick, HPET_T0_CMP); | |
| hpet_writel(tick, HPET_T0_CMP); | |
| } | |
| /* | |
| * Go! | |
| */ | |
| cfg = hpet_readl(HPET_CFG); | |
| if (hpet_use_timer) | |
| cfg |= HPET_CFG_LEGACY; | |
| cfg |= HPET_CFG_ENABLE; | |
| hpet_writel(cfg, HPET_CFG); | |
| return 0; | |
| } | |
| /* | |
| * Check whether HPET was found by ACPI boot parse. If yes setup HPET | |
| * counter 0 for kernel base timer. | |
| */ | |
| int __init hpet_enable(void) | |
| { | |
| unsigned int id; | |
| unsigned long tick_fsec_low, tick_fsec_high; /* tick in femto sec */ | |
| unsigned long hpet_tick_rem; | |
| if (boot_hpet_disable) | |
| return -1; | |
| if (!hpet_address) { | |
| return -1; | |
| } | |
| hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE); | |
| /* | |
| * Read the period, compute tick and quotient. | |
| */ | |
| id = hpet_readl(HPET_ID); | |
| /* | |
| * We are checking for value '1' or more in number field if | |
| * CONFIG_HPET_EMULATE_RTC is set because we will need an | |
| * additional timer for RTC emulation. | |
| * However, we can do with one timer otherwise using the | |
| * the single HPET timer for system time. | |
| */ | |
| #ifdef CONFIG_HPET_EMULATE_RTC | |
| if (!(id & HPET_ID_NUMBER)) | |
| return -1; | |
| #endif | |
| hpet_period = hpet_readl(HPET_PERIOD); | |
| if ((hpet_period < HPET_MIN_PERIOD) || (hpet_period > HPET_MAX_PERIOD)) | |
| return -1; | |
| /* | |
| * 64 bit math | |
| * First changing tick into fsec | |
| * Then 64 bit div to find number of hpet clk per tick | |
| */ | |
| ASM_MUL64_REG(tick_fsec_low, tick_fsec_high, | |
| KERNEL_TICK_USEC, FSEC_TO_USEC); | |
| ASM_DIV64_REG(hpet_tick, hpet_tick_rem, | |
| hpet_period, tick_fsec_low, tick_fsec_high); | |
| if (hpet_tick_rem > (hpet_period >> 1)) | |
| hpet_tick++; /* rounding the result */ | |
| hpet_use_timer = id & HPET_ID_LEGSUP; | |
| if (hpet_timer_stop_set_go(hpet_tick)) | |
| return -1; | |
| use_hpet = 1; | |
| #ifdef CONFIG_HPET | |
| { | |
| struct hpet_data hd; | |
| unsigned int ntimer; | |
| 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 = hpet_virt_address; | |
| 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 __iomem *hpet; | |
| struct hpet_timer __iomem *timer; | |
| int i; | |
| hpet = hpet_virt_address; | |
| for (i = 2, timer = &hpet->hpet_timers[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); | |
| } | |
| #endif | |
| #ifdef CONFIG_X86_LOCAL_APIC | |
| if (hpet_use_timer) | |
| wait_timer_tick = wait_hpet_tick; | |
| #endif | |
| return 0; | |
| } | |
| int hpet_reenable(void) | |
| { | |
| return hpet_timer_stop_set_go(hpet_tick); | |
| } | |
| int is_hpet_enabled(void) | |
| { | |
| return use_hpet; | |
| } | |
| int is_hpet_capable(void) | |
| { | |
| if (!boot_hpet_disable && hpet_address) | |
| return 1; | |
| return 0; | |
| } | |
| static int __init hpet_setup(char* str) | |
| { | |
| if (str) { | |
| if (!strncmp("disable", str, 7)) | |
| boot_hpet_disable = 1; | |
| } | |
| return 1; | |
| } | |
| __setup("hpet=", hpet_setup); | |
| #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 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 */ | |
| /* | |
| * 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; | |
| 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 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 | |