1/* 2 * VMI paravirtual timer support routines. 3 * 4 * Copyright (C) 2007, VMware, Inc. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 14 * NON INFRINGEMENT. See the GNU General Public License for more 15 * details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * 21 */ 22 23#include <linux/smp.h> 24#include <linux/interrupt.h> 25#include <linux/cpumask.h> 26#include <linux/clocksource.h> 27#include <linux/clockchips.h> 28 29#include <asm/vmi.h> 30#include <asm/vmi_time.h> 31#include <asm/apicdef.h> 32#include <asm/apic.h> 33#include <asm/timer.h> 34#include <asm/i8253.h> 35#include <asm/irq_vectors.h> 36 37#define VMI_ONESHOT (VMI_ALARM_IS_ONESHOT | VMI_CYCLES_REAL | vmi_get_alarm_wiring()) 38#define VMI_PERIODIC (VMI_ALARM_IS_PERIODIC | VMI_CYCLES_REAL | vmi_get_alarm_wiring()) 39 40static DEFINE_PER_CPU(struct clock_event_device, local_events); 41 42static inline u32 vmi_counter(u32 flags) 43{ 44 /* Given VMI_ONESHOT or VMI_PERIODIC, return the corresponding 45 * cycle counter. */ 46 return flags & VMI_ALARM_COUNTER_MASK; 47} 48 49/* paravirt_ops.get_wallclock = vmi_get_wallclock */ 50unsigned long vmi_get_wallclock(void) 51{ 52 unsigned long long wallclock; 53 wallclock = vmi_timer_ops.get_wallclock(); // nsec 54 (void)do_div(wallclock, 1000000000); // sec 55 56 return wallclock; 57} 58 59/* paravirt_ops.set_wallclock = vmi_set_wallclock */ 60int vmi_set_wallclock(unsigned long now) 61{ 62 return 0; 63} 64 65/* paravirt_ops.sched_clock = vmi_sched_clock */ 66unsigned long long vmi_sched_clock(void) 67{ 68 return cycles_2_ns(vmi_timer_ops.get_cycle_counter(VMI_CYCLES_AVAILABLE)); 69} 70 71/* x86_platform.calibrate_tsc = vmi_tsc_khz */ 72unsigned long vmi_tsc_khz(void) 73{ 74 unsigned long long khz; 75 khz = vmi_timer_ops.get_cycle_frequency(); 76 (void)do_div(khz, 1000); 77 return khz; 78} 79 80static inline unsigned int vmi_get_timer_vector(void) 81{ 82 return IRQ0_VECTOR; 83} 84 85/** vmi clockchip */ 86#ifdef CONFIG_X86_LOCAL_APIC 87static unsigned int startup_timer_irq(unsigned int irq) 88{ 89 unsigned long val = apic_read(APIC_LVTT); 90 apic_write(APIC_LVTT, vmi_get_timer_vector()); 91 92 return (val & APIC_SEND_PENDING); 93} 94 95static void mask_timer_irq(unsigned int irq) 96{ 97 unsigned long val = apic_read(APIC_LVTT); 98 apic_write(APIC_LVTT, val | APIC_LVT_MASKED); 99} 100 101static void unmask_timer_irq(unsigned int irq) 102{ 103 unsigned long val = apic_read(APIC_LVTT); 104 apic_write(APIC_LVTT, val & ~APIC_LVT_MASKED); 105} 106 107static void ack_timer_irq(unsigned int irq) 108{ 109 ack_APIC_irq(); 110} 111 112static struct irq_chip vmi_chip __read_mostly = { 113 .name = "VMI-LOCAL", 114 .startup = startup_timer_irq, 115 .mask = mask_timer_irq, 116 .unmask = unmask_timer_irq, 117 .ack = ack_timer_irq 118}; 119#endif 120 121/** vmi clockevent */ 122#define VMI_ALARM_WIRED_IRQ0 0x00000000 123#define VMI_ALARM_WIRED_LVTT 0x00010000 124static int vmi_wiring = VMI_ALARM_WIRED_IRQ0; 125 126static inline int vmi_get_alarm_wiring(void) 127{ 128 return vmi_wiring; 129} 130 131static void vmi_timer_set_mode(enum clock_event_mode mode, 132 struct clock_event_device *evt) 133{ 134 cycle_t now, cycles_per_hz; 135 BUG_ON(!irqs_disabled()); 136 137 switch (mode) { 138 case CLOCK_EVT_MODE_ONESHOT: 139 case CLOCK_EVT_MODE_RESUME: 140 break; 141 case CLOCK_EVT_MODE_PERIODIC: 142 cycles_per_hz = vmi_timer_ops.get_cycle_frequency(); 143 (void)do_div(cycles_per_hz, HZ); 144 now = vmi_timer_ops.get_cycle_counter(vmi_counter(VMI_PERIODIC)); 145 vmi_timer_ops.set_alarm(VMI_PERIODIC, now, cycles_per_hz); 146 break; 147 case CLOCK_EVT_MODE_UNUSED: 148 case CLOCK_EVT_MODE_SHUTDOWN: 149 switch (evt->mode) { 150 case CLOCK_EVT_MODE_ONESHOT: 151 vmi_timer_ops.cancel_alarm(VMI_ONESHOT); 152 break; 153 case CLOCK_EVT_MODE_PERIODIC: 154 vmi_timer_ops.cancel_alarm(VMI_PERIODIC); 155 break; 156 default: 157 break; 158 } 159 break; 160 default: 161 break; 162 } 163} 164 165static int vmi_timer_next_event(unsigned long delta, 166 struct clock_event_device *evt) 167{ 168 /* Unfortunately, set_next_event interface only passes relative 169 * expiry, but we want absolute expiry. It'd be better if were 170 * were passed an absolute expiry, since a bunch of time may 171 * have been stolen between the time the delta is computed and 172 * when we set the alarm below. */ 173 cycle_t now = vmi_timer_ops.get_cycle_counter(vmi_counter(VMI_ONESHOT)); 174 175 BUG_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT); 176 vmi_timer_ops.set_alarm(VMI_ONESHOT, now + delta, 0); 177 return 0; 178} 179 180static struct clock_event_device vmi_clockevent = { 181 .name = "vmi-timer", 182 .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, 183 .shift = 22, 184 .set_mode = vmi_timer_set_mode, 185 .set_next_event = vmi_timer_next_event, 186 .rating = 1000, 187 .irq = 0, 188}; 189 190static irqreturn_t vmi_timer_interrupt(int irq, void *dev_id) 191{ 192 struct clock_event_device *evt = &__get_cpu_var(local_events); 193 evt->event_handler(evt); 194 return IRQ_HANDLED; 195} 196 197static struct irqaction vmi_clock_action = { 198 .name = "vmi-timer", 199 .handler = vmi_timer_interrupt, 200 .flags = IRQF_DISABLED | IRQF_NOBALANCING | IRQF_TIMER, 201}; 202 203static void __devinit vmi_time_init_clockevent(void) 204{ 205 cycle_t cycles_per_msec; 206 struct clock_event_device *evt; 207 208 int cpu = smp_processor_id(); 209 evt = &__get_cpu_var(local_events); 210 211 /* Use cycles_per_msec since div_sc params are 32-bits. */ 212 cycles_per_msec = vmi_timer_ops.get_cycle_frequency(); 213 (void)do_div(cycles_per_msec, 1000); 214 215 memcpy(evt, &vmi_clockevent, sizeof(*evt)); 216 /* Must pick .shift such that .mult fits in 32-bits. Choosing 217 * .shift to be 22 allows 2^(32-22) cycles per nano-seconds 218 * before overflow. */ 219 evt->mult = div_sc(cycles_per_msec, NSEC_PER_MSEC, evt->shift); 220 /* Upper bound is clockevent's use of ulong for cycle deltas. */ 221 evt->max_delta_ns = clockevent_delta2ns(ULONG_MAX, evt); 222 evt->min_delta_ns = clockevent_delta2ns(1, evt); 223 evt->cpumask = cpumask_of(cpu); 224 225 printk(KERN_WARNING "vmi: registering clock event %s. mult=%u shift=%u\n", 226 evt->name, evt->mult, evt->shift); 227 clockevents_register_device(evt); 228} 229 230void __init vmi_time_init(void) 231{ 232 unsigned int cpu; 233 /* Disable PIT: BIOSes start PIT CH0 with 18.2hz peridic. */ 234 outb_pit(0x3a, PIT_MODE); /* binary, mode 5, LSB/MSB, ch 0 */ 235 236 vmi_time_init_clockevent(); 237 setup_irq(0, &vmi_clock_action); 238 for_each_possible_cpu(cpu) 239 per_cpu(vector_irq, cpu)[vmi_get_timer_vector()] = 0; 240} 241 242#ifdef CONFIG_X86_LOCAL_APIC 243void __devinit vmi_time_bsp_init(void) 244{ 245 /* 246 * On APIC systems, we want local timers to fire on each cpu. We do 247 * this by programming LVTT to deliver timer events to the IRQ handler 248 * for IRQ-0, since we can't re-use the APIC local timer handler 249 * without interfering with that code. 250 */ 251 clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL); 252 local_irq_disable(); 253#ifdef CONFIG_SMP 254 set_irq_chip_and_handler_name(0, &vmi_chip, handle_percpu_irq, "lvtt"); 255#else 256 set_irq_chip_and_handler_name(0, &vmi_chip, handle_edge_irq, "lvtt"); 257#endif 258 vmi_wiring = VMI_ALARM_WIRED_LVTT; 259 apic_write(APIC_LVTT, vmi_get_timer_vector()); 260 local_irq_enable(); 261 clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL); 262} 263 264void __devinit vmi_time_ap_init(void) 265{ 266 vmi_time_init_clockevent(); 267 apic_write(APIC_LVTT, vmi_get_timer_vector()); 268} 269#endif 270 271/** vmi clocksource */ 272static struct clocksource clocksource_vmi; 273 274static cycle_t read_real_cycles(struct clocksource *cs) 275{ 276 cycle_t ret = (cycle_t)vmi_timer_ops.get_cycle_counter(VMI_CYCLES_REAL); 277 return max(ret, clocksource_vmi.cycle_last); 278} 279 280static struct clocksource clocksource_vmi = { 281 .name = "vmi-timer", 282 .rating = 450, 283 .read = read_real_cycles, 284 .mask = CLOCKSOURCE_MASK(64), 285 .mult = 0, /* to be set */ 286 .shift = 22, 287 .flags = CLOCK_SOURCE_IS_CONTINUOUS, 288}; 289 290static int __init init_vmi_clocksource(void) 291{ 292 cycle_t cycles_per_msec; 293 294 if (!vmi_timer_ops.get_cycle_frequency) 295 return 0; 296 /* Use khz2mult rather than hz2mult since hz arg is only 32-bits. */ 297 cycles_per_msec = vmi_timer_ops.get_cycle_frequency(); 298 (void)do_div(cycles_per_msec, 1000); 299 300 /* Note that clocksource.{mult, shift} converts in the opposite direction 301 * as clockevents. */ 302 clocksource_vmi.mult = clocksource_khz2mult(cycles_per_msec, 303 clocksource_vmi.shift); 304 305 printk(KERN_WARNING "vmi: registering clock source khz=%lld\n", cycles_per_msec); 306 return clocksource_register(&clocksource_vmi); 307 308} 309module_init(init_vmi_clocksource); 310