[PATCH] Char: stallion, correct __init macros
[linux-2.6] / 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 }