/*
 * VMI paravirtual timer support routines.
 *
 * Copyright (C) 2007, VMware, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 * NON INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <linux/smp.h>
#include <linux/interrupt.h>
#include <linux/cpumask.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>

#include <asm/vmi.h>
#include <asm/vmi_time.h>
#include <asm/apicdef.h>
#include <asm/apic.h>
#include <asm/timer.h>
#include <asm/i8253.h>
#include <asm/irq_vectors.h>

#define VMI_ONESHOT  (VMI_ALARM_IS_ONESHOT  | VMI_CYCLES_REAL | vmi_get_alarm_wiring())
#define VMI_PERIODIC (VMI_ALARM_IS_PERIODIC | VMI_CYCLES_REAL | vmi_get_alarm_wiring())

static DEFINE_PER_CPU(struct clock_event_device, local_events);

static inline u32 vmi_counter(u32 flags)
{
        /* Given VMI_ONESHOT or VMI_PERIODIC, return the corresponding
         * cycle counter. */
        return flags & VMI_ALARM_COUNTER_MASK;
}

/* paravirt_ops.get_wallclock = vmi_get_wallclock */
unsigned long vmi_get_wallclock(void)
{
        unsigned long long wallclock;
        wallclock = vmi_timer_ops.get_wallclock(); // nsec
        (void)do_div(wallclock, 1000000000);       // sec

        return wallclock;
}

/* paravirt_ops.set_wallclock = vmi_set_wallclock */
int vmi_set_wallclock(unsigned long now)
{
        return 0;
}

/* paravirt_ops.sched_clock = vmi_sched_clock */
unsigned long long vmi_sched_clock(void)
{
        return cycles_2_ns(vmi_timer_ops.get_cycle_counter(VMI_CYCLES_AVAILABLE));
}

/* x86_platform.calibrate_tsc = vmi_tsc_khz */
unsigned long vmi_tsc_khz(void)
{
        unsigned long long khz;
        khz = vmi_timer_ops.get_cycle_frequency();
        (void)do_div(khz, 1000);
        return khz;
}

static inline unsigned int vmi_get_timer_vector(void)
{
#ifdef CONFIG_X86_IO_APIC
        return FIRST_DEVICE_VECTOR;
#else
        return FIRST_EXTERNAL_VECTOR;
#endif
}

/** vmi clockchip */
#ifdef CONFIG_X86_LOCAL_APIC
static unsigned int startup_timer_irq(unsigned int irq)
{
        unsigned long val = apic_read(APIC_LVTT);
        apic_write(APIC_LVTT, vmi_get_timer_vector());

        return (val & APIC_SEND_PENDING);
}

static void mask_timer_irq(unsigned int irq)
{
        unsigned long val = apic_read(APIC_LVTT);
        apic_write(APIC_LVTT, val | APIC_LVT_MASKED);
}

static void unmask_timer_irq(unsigned int irq)
{
        unsigned long val = apic_read(APIC_LVTT);
        apic_write(APIC_LVTT, val & ~APIC_LVT_MASKED);
}

static void ack_timer_irq(unsigned int irq)
{
        ack_APIC_irq();
}

static struct irq_chip vmi_chip __read_mostly = {
        .name           = "VMI-LOCAL",
        .startup        = startup_timer_irq,
        .mask           = mask_timer_irq,
        .unmask         = unmask_timer_irq,
        .ack            = ack_timer_irq
};
#endif

/** vmi clockevent */
#define VMI_ALARM_WIRED_IRQ0    0x00000000
#define VMI_ALARM_WIRED_LVTT    0x00010000
static int vmi_wiring = VMI_ALARM_WIRED_IRQ0;

static inline int vmi_get_alarm_wiring(void)
{
        return vmi_wiring;
}

static void vmi_timer_set_mode(enum clock_event_mode mode,
                               struct clock_event_device *evt)
{
        cycle_t now, cycles_per_hz;
        BUG_ON(!irqs_disabled());

        switch (mode) {
        case CLOCK_EVT_MODE_ONESHOT:
        case CLOCK_EVT_MODE_RESUME:
                break;
        case CLOCK_EVT_MODE_PERIODIC:
                cycles_per_hz = vmi_timer_ops.get_cycle_frequency();
                (void)do_div(cycles_per_hz, HZ);
                now = vmi_timer_ops.get_cycle_counter(vmi_counter(VMI_PERIODIC));
                vmi_timer_ops.set_alarm(VMI_PERIODIC, now, cycles_per_hz);
                break;
        case CLOCK_EVT_MODE_UNUSED:
        case CLOCK_EVT_MODE_SHUTDOWN:
                switch (evt->mode) {
                case CLOCK_EVT_MODE_ONESHOT:
                        vmi_timer_ops.cancel_alarm(VMI_ONESHOT);
                        break;
                case CLOCK_EVT_MODE_PERIODIC:
                        vmi_timer_ops.cancel_alarm(VMI_PERIODIC);
                        break;
                default:
                        break;
                }
                break;
        default:
                break;
        }
}

static int vmi_timer_next_event(unsigned long delta,
                                struct clock_event_device *evt)
{
        /* Unfortunately, set_next_event interface only passes relative
         * expiry, but we want absolute expiry.  It'd be better if were
         * were passed an aboslute expiry, since a bunch of time may
         * have been stolen between the time the delta is computed and
         * when we set the alarm below. */
        cycle_t now = vmi_timer_ops.get_cycle_counter(vmi_counter(VMI_ONESHOT));

        BUG_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT);
        vmi_timer_ops.set_alarm(VMI_ONESHOT, now + delta, 0);
        return 0;
}

static struct clock_event_device vmi_clockevent = {
        .name           = "vmi-timer",
        .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
        .shift          = 22,
        .set_mode       = vmi_timer_set_mode,
        .set_next_event = vmi_timer_next_event,
        .rating         = 1000,
        .irq            = 0,
};

static irqreturn_t vmi_timer_interrupt(int irq, void *dev_id)
{
        struct clock_event_device *evt = &__get_cpu_var(local_events);
        evt->event_handler(evt);
        return IRQ_HANDLED;
}

static struct irqaction vmi_clock_action  = {
        .name           = "vmi-timer",
        .handler        = vmi_timer_interrupt,
        .flags          = IRQF_DISABLED | IRQF_NOBALANCING | IRQF_TIMER,
};

static void __devinit vmi_time_init_clockevent(void)
{
        cycle_t cycles_per_msec;
        struct clock_event_device *evt;

        int cpu = smp_processor_id();
        evt = &__get_cpu_var(local_events);

        /* Use cycles_per_msec since div_sc params are 32-bits. */
        cycles_per_msec = vmi_timer_ops.get_cycle_frequency();
        (void)do_div(cycles_per_msec, 1000);

        memcpy(evt, &vmi_clockevent, sizeof(*evt));
        /* Must pick .shift such that .mult fits in 32-bits.  Choosing
         * .shift to be 22 allows 2^(32-22) cycles per nano-seconds
         * before overflow. */
        evt->mult = div_sc(cycles_per_msec, NSEC_PER_MSEC, evt->shift);
        /* Upper bound is clockevent's use of ulong for cycle deltas. */
        evt->max_delta_ns = clockevent_delta2ns(ULONG_MAX, evt);
        evt->min_delta_ns = clockevent_delta2ns(1, evt);
        evt->cpumask = cpumask_of(cpu);

        printk(KERN_WARNING "vmi: registering clock event %s. mult=%lu shift=%u\n",
               evt->name, evt->mult, evt->shift);
        clockevents_register_device(evt);
}

void __init vmi_time_init(void)
{
        unsigned int cpu;
        /* Disable PIT: BIOSes start PIT CH0 with 18.2hz peridic. */
        outb_pit(0x3a, PIT_MODE); /* binary, mode 5, LSB/MSB, ch 0 */

        vmi_time_init_clockevent();
        setup_irq(0, &vmi_clock_action);
        for_each_possible_cpu(cpu)
                per_cpu(vector_irq, cpu)[vmi_get_timer_vector()] = 0;
}

#ifdef CONFIG_X86_LOCAL_APIC
void __devinit vmi_time_bsp_init(void)
{
        /*
         * On APIC systems, we want local timers to fire on each cpu.  We do
         * this by programming LVTT to deliver timer events to the IRQ handler
         * for IRQ-0, since we can't re-use the APIC local timer handler
         * without interfering with that code.
         */
        clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
        local_irq_disable();
#ifdef CONFIG_SMP
        /*
         * XXX handle_percpu_irq only defined for SMP; we need to switch over
         * to using it, since this is a local interrupt, which each CPU must
         * handle individually without locking out or dropping simultaneous
         * local timers on other CPUs.  We also don't want to trigger the
         * quirk workaround code for interrupts which gets invoked from
         * handle_percpu_irq via eoi, so we use our own IRQ chip.
         */
        set_irq_chip_and_handler_name(0, &vmi_chip, handle_percpu_irq, "lvtt");
#else
        set_irq_chip_and_handler_name(0, &vmi_chip, handle_edge_irq, "lvtt");
#endif
        vmi_wiring = VMI_ALARM_WIRED_LVTT;
        apic_write(APIC_LVTT, vmi_get_timer_vector());
        local_irq_enable();
        clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);
}

void __devinit vmi_time_ap_init(void)
{
        vmi_time_init_clockevent();
        apic_write(APIC_LVTT, vmi_get_timer_vector());
}
#endif

/** vmi clocksource */
static struct clocksource clocksource_vmi;

static cycle_t read_real_cycles(struct clocksource *cs)
{
        cycle_t ret = (cycle_t)vmi_timer_ops.get_cycle_counter(VMI_CYCLES_REAL);
        return max(ret, clocksource_vmi.cycle_last);
}

static struct clocksource clocksource_vmi = {
        .name                   = "vmi-timer",
        .rating                 = 450,
        .read                   = read_real_cycles,
        .mask                   = CLOCKSOURCE_MASK(64),
        .mult                   = 0, /* to be set */
        .shift                  = 22,
        .flags                  = CLOCK_SOURCE_IS_CONTINUOUS,
};

static int __init init_vmi_clocksource(void)
{
        cycle_t cycles_per_msec;

        if (!vmi_timer_ops.get_cycle_frequency)
                return 0;
        /* Use khz2mult rather than hz2mult since hz arg is only 32-bits. */
        cycles_per_msec = vmi_timer_ops.get_cycle_frequency();
        (void)do_div(cycles_per_msec, 1000);

        /* Note that clocksource.{mult, shift} converts in the opposite direction
         * as clockevents.  */
        clocksource_vmi.mult = clocksource_khz2mult(cycles_per_msec,
                                                    clocksource_vmi.shift);

        printk(KERN_WARNING "vmi: registering clock source khz=%lld\n", cycles_per_msec);
        return clocksource_register(&clocksource_vmi);

}
module_init(init_vmi_clocksource);