git.oblomov.eu Git - linux-2.6/blob - arch/um/kernel/time.c

   1 /*
   2  * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include "linux/kernel.h"
   7 #include "linux/module.h"
   8 #include "linux/unistd.h"
   9 #include "linux/stddef.h"
  10 #include "linux/spinlock.h"
  11 #include "linux/time.h"
  12 #include "linux/sched.h"
  13 #include "linux/interrupt.h"
  14 #include "linux/init.h"
  15 #include "linux/delay.h"
  16 #include "linux/hrtimer.h"
  17 #include "asm/irq.h"
  18 #include "asm/param.h"
  19 #include "asm/current.h"
  20 #include "kern_util.h"
  21 #include "user_util.h"
  22 #include "mode.h"
  23 #include "os.h"
  24
  25 int hz(void)
  26 {
  27         return(HZ);
  28 }
  29
  30 /*
  31  * Scheduler clock - returns current time in nanosec units.
  32  */
  33 unsigned long long sched_clock(void)
  34 {
  35         return (unsigned long long)jiffies_64 * (1000000000 / HZ);
  36 }
  37
  38 static unsigned long long prev_nsecs;
  39 #ifdef CONFIG_UML_REAL_TIME_CLOCK
  40 static long long delta;                 /* Deviation per interval */
  41 #endif
  42
  43 void timer_irq(union uml_pt_regs *regs)
  44 {
  45         unsigned long long ticks = 0;
  46
  47 #ifdef CONFIG_UML_REAL_TIME_CLOCK
  48         if(prev_nsecs){
  49                 /* We've had 1 tick */
  50                 unsigned long long nsecs = os_nsecs();
  51
  52                 delta += nsecs - prev_nsecs;
  53                 prev_nsecs = nsecs;
  54
  55                 /* Protect against the host clock being set backwards */
  56                 if(delta < 0)
  57                         delta = 0;
  58
  59                 ticks += (delta * HZ) / BILLION;
  60                 delta -= (ticks * BILLION) / HZ;
  61         }
  62         else prev_nsecs = os_nsecs();
  63 #else
  64         ticks = 1;
  65 #endif
  66         while(ticks > 0){
  67                 do_IRQ(TIMER_IRQ, regs);
  68                 ticks--;
  69         }
  70 }
  71
  72 static DEFINE_SPINLOCK(timer_spinlock);
  73
  74 static unsigned long long local_offset = 0;
  75
  76 static inline unsigned long long get_time(void)
  77 {
  78         unsigned long long nsecs;
  79         unsigned long flags;
  80
  81         spin_lock_irqsave(&timer_spinlock, flags);
  82         nsecs = os_nsecs();
  83         nsecs += local_offset;
  84         spin_unlock_irqrestore(&timer_spinlock, flags);
  85
  86         return nsecs;
  87 }
  88
  89 irqreturn_t um_timer(int irq, void *dev)
  90 {
  91         unsigned long long nsecs;
  92         unsigned long flags;
  93
  94         write_seqlock_irqsave(&xtime_lock, flags);
  95
  96         do_timer(1);
  97
  98         nsecs = get_time();
  99         xtime.tv_sec = nsecs / NSEC_PER_SEC;
 100         xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
 101
 102         write_sequnlock_irqrestore(&xtime_lock, flags);
 103
 104         return IRQ_HANDLED;
 105 }
 106
 107 static void register_timer(void)
 108 {
 109         int err;
 110
 111         err = request_irq(TIMER_IRQ, um_timer, IRQF_DISABLED, "timer", NULL);
 112         if(err != 0)
 113                 printk(KERN_ERR "register_timer : request_irq failed - "
 114                        "errno = %d\n", -err);
 115
 116         err = set_interval(1);
 117         if(err != 0)
 118                 printk(KERN_ERR "register_timer : set_interval failed - "
 119                        "errno = %d\n", -err);
 120 }
 121
 122 extern void (*late_time_init)(void);
 123
 124 void time_init(void)
 125 {
 126         long long nsecs;
 127
 128         nsecs = os_nsecs();
 129         set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
 130                                 -nsecs % BILLION);
 131         late_time_init = register_timer;
 132 }
 133
 134 void do_gettimeofday(struct timeval *tv)
 135 {
 136         unsigned long long nsecs = get_time();
 137
 138         tv->tv_sec = nsecs / NSEC_PER_SEC;
 139         /* Careful about calculations here - this was originally done as
 140          * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
 141          * which gave bogus (> 1000000) values.  Dunno why, suspect gcc
 142          * (4.0.0) miscompiled it, or there's a subtle 64/32-bit conversion
 143          * problem that I missed.
 144          */
 145         nsecs -= tv->tv_sec * NSEC_PER_SEC;
 146         tv->tv_usec = (unsigned long) nsecs / NSEC_PER_USEC;
 147 }
 148
 149 static inline void set_time(unsigned long long nsecs)
 150 {
 151         unsigned long long now;
 152         unsigned long flags;
 153
 154         spin_lock_irqsave(&timer_spinlock, flags);
 155         now = os_nsecs();
 156         local_offset = nsecs - now;
 157         spin_unlock_irqrestore(&timer_spinlock, flags);
 158
 159         clock_was_set();
 160 }
 161
 162 int do_settimeofday(struct timespec *tv)
 163 {
 164         set_time((unsigned long long) tv->tv_sec * NSEC_PER_SEC + tv->tv_nsec);
 165
 166         return 0;
 167 }
 168
 169 void timer_handler(int sig, union uml_pt_regs *regs)
 170 {
 171         local_irq_disable();
 172         irq_enter();
 173         update_process_times(CHOOSE_MODE(
 174                              (UPT_SC(regs) && user_context(UPT_SP(regs))),
 175                              (regs)->skas.is_user));
 176         irq_exit();
 177         local_irq_enable();
 178         if(current_thread->cpu == 0)
 179                 timer_irq(regs);
 180 }