[SPARC]: Kill __irq_itoa().
[linux-2.6] / arch / um / kernel / time_kern.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 /* Changed at early boot */
39 int timer_irq_inited = 0;
40
41 static int first_tick;
42 static unsigned long long prev_nsecs;
43 #ifdef CONFIG_UML_REAL_TIME_CLOCK
44 static long long delta;                 /* Deviation per interval */
45 #endif
46
47 void timer_irq(union uml_pt_regs *regs)
48 {
49         unsigned long long ticks = 0;
50
51         if(!timer_irq_inited){
52                 /* This is to ensure that ticks don't pile up when
53                  * the timer handler is suspended */
54                 first_tick = 0;
55                 return;
56         }
57
58         if(first_tick){
59 #ifdef CONFIG_UML_REAL_TIME_CLOCK
60                 /* We've had 1 tick */
61                 unsigned long long nsecs = os_nsecs();
62
63                 delta += nsecs - prev_nsecs;
64                 prev_nsecs = nsecs;
65
66                 /* Protect against the host clock being set backwards */
67                 if(delta < 0)
68                         delta = 0;
69
70                 ticks += (delta * HZ) / BILLION;
71                 delta -= (ticks * BILLION) / HZ;
72 #else
73                 ticks = 1;
74 #endif
75         }
76         else {
77                 prev_nsecs = os_nsecs();
78                 first_tick = 1;
79         }
80
81         while(ticks > 0){
82                 do_IRQ(TIMER_IRQ, regs);
83                 ticks--;
84         }
85 }
86
87
88 void time_init_kern(void)
89 {
90         unsigned long long nsecs;
91
92         nsecs = os_nsecs();
93         set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
94                                 -nsecs % BILLION);
95 }
96
97 void do_boot_timer_handler(struct sigcontext * sc)
98 {
99         struct pt_regs regs;
100
101         CHOOSE_MODE((void) (UPT_SC(&regs.regs) = sc),
102                     (void) (regs.regs.skas.is_user = 0));
103         do_timer(&regs);
104 }
105
106 static DEFINE_SPINLOCK(timer_spinlock);
107
108 static unsigned long long local_offset = 0;
109
110 static inline unsigned long long get_time(void)
111 {
112         unsigned long long nsecs;
113         unsigned long flags;
114
115         spin_lock_irqsave(&timer_spinlock, flags);
116         nsecs = os_nsecs();
117         nsecs += local_offset;
118         spin_unlock_irqrestore(&timer_spinlock, flags);
119
120         return nsecs;
121 }
122
123 irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
124 {
125         unsigned long long nsecs;
126         unsigned long flags;
127
128         do_timer(regs);
129
130         write_seqlock_irqsave(&xtime_lock, flags);
131         nsecs = get_time() + local_offset;
132         xtime.tv_sec = nsecs / NSEC_PER_SEC;
133         xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
134         write_sequnlock_irqrestore(&xtime_lock, flags);
135
136         return(IRQ_HANDLED);
137 }
138
139 long um_time(int __user *tloc)
140 {
141         long ret = get_time() / NSEC_PER_SEC;
142
143         if((tloc != NULL) && put_user(ret, tloc))
144                 return -EFAULT;
145
146         return ret;
147 }
148
149 void do_gettimeofday(struct timeval *tv)
150 {
151         unsigned long long nsecs = get_time();
152
153         tv->tv_sec = nsecs / NSEC_PER_SEC;
154         /* Careful about calculations here - this was originally done as
155          * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
156          * which gave bogus (> 1000000) values.  Dunno why, suspect gcc
157          * (4.0.0) miscompiled it, or there's a subtle 64/32-bit conversion
158          * problem that I missed.
159          */
160         nsecs -= tv->tv_sec * NSEC_PER_SEC;
161         tv->tv_usec = (unsigned long) nsecs / NSEC_PER_USEC;
162 }
163
164 static inline void set_time(unsigned long long nsecs)
165 {
166         unsigned long long now;
167         unsigned long flags;
168
169         spin_lock_irqsave(&timer_spinlock, flags);
170         now = os_nsecs();
171         local_offset = nsecs - now;
172         spin_unlock_irqrestore(&timer_spinlock, flags);
173
174         clock_was_set();
175 }
176
177 long um_stime(int __user *tptr)
178 {
179         int value;
180
181         if (get_user(value, tptr))
182                 return -EFAULT;
183
184         set_time((unsigned long long) value * NSEC_PER_SEC);
185
186         return 0;
187 }
188
189 int do_settimeofday(struct timespec *tv)
190 {
191         set_time((unsigned long long) tv->tv_sec * NSEC_PER_SEC + tv->tv_nsec);
192
193         return 0;
194 }
195
196 void timer_handler(int sig, union uml_pt_regs *regs)
197 {
198         local_irq_disable();
199         irq_enter();
200         update_process_times(CHOOSE_MODE(
201                              (UPT_SC(regs) && user_context(UPT_SP(regs))),
202                              (regs)->skas.is_user));
203         irq_exit();
204         local_irq_enable();
205         if(current_thread->cpu == 0)
206                 timer_irq(regs);
207 }
208
209 int __init timer_init(void)
210 {
211         int err;
212
213         user_time_init();
214         err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
215         if(err != 0)
216                 printk(KERN_ERR "timer_init : request_irq failed - "
217                        "errno = %d\n", -err);
218         timer_irq_inited = 1;
219         return(0);
220 }
221
222 arch_initcall(timer_init);