020ca79b8d33200b3c6f4c29c582e4528cf5a00b
[linux-3.10.git] / 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 "asm/irq.h"
17 #include "asm/param.h"
18 #include "asm/current.h"
19 #include "kern_util.h"
20 #include "user_util.h"
21 #include "time_user.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_usecs;
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 usecs = os_usecs();
62
63                 delta += usecs - prev_usecs;
64                 prev_usecs = usecs;
65
66                 /* Protect against the host clock being set backwards */
67                 if(delta < 0)
68                         delta = 0;
69
70                 ticks += (delta * HZ) / MILLION;
71                 delta -= (ticks * MILLION) / HZ;
72 #else
73                 ticks = 1;
74 #endif
75         }
76         else {
77                 prev_usecs = os_usecs();
78                 first_tick = 1;
79         }
80
81         while(ticks > 0){
82                 do_IRQ(TIMER_IRQ, regs);
83                 ticks--;
84         }
85 }
86
87 void boot_timer_handler(int sig)
88 {
89         struct pt_regs regs;
90
91         CHOOSE_MODE((void) 
92                     (UPT_SC(&regs.regs) = (struct sigcontext *) (&sig + 1)),
93                     (void) (regs.regs.skas.is_user = 0));
94         do_timer(&regs);
95 }
96
97 irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
98 {
99         unsigned long flags;
100
101         do_timer(regs);
102         write_seqlock_irqsave(&xtime_lock, flags);
103         timer();
104         write_sequnlock_irqrestore(&xtime_lock, flags);
105         return(IRQ_HANDLED);
106 }
107
108 long um_time(int __user *tloc)
109 {
110         struct timeval now;
111
112         do_gettimeofday(&now);
113         if (tloc) {
114                 if (put_user(now.tv_sec, tloc))
115                         now.tv_sec = -EFAULT;
116         }
117         return now.tv_sec;
118 }
119
120 long um_stime(int __user *tptr)
121 {
122         int value;
123         struct timespec new;
124
125         if (get_user(value, tptr))
126                 return -EFAULT;
127         new.tv_sec = value;
128         new.tv_nsec = 0;
129         do_settimeofday(&new);
130         return 0;
131 }
132
133 void timer_handler(int sig, union uml_pt_regs *regs)
134 {
135         local_irq_disable();
136         irq_enter();
137         update_process_times(CHOOSE_MODE(user_context(UPT_SP(regs)),
138                                          (regs)->skas.is_user));
139         irq_exit();
140         local_irq_enable();
141         if(current_thread->cpu == 0)
142                 timer_irq(regs);
143 }
144
145 static DEFINE_SPINLOCK(timer_spinlock);
146
147 unsigned long time_lock(void)
148 {
149         unsigned long flags;
150
151         spin_lock_irqsave(&timer_spinlock, flags);
152         return(flags);
153 }
154
155 void time_unlock(unsigned long flags)
156 {
157         spin_unlock_irqrestore(&timer_spinlock, flags);
158 }
159
160 int __init timer_init(void)
161 {
162         int err;
163
164         user_time_init();
165         err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
166         if(err != 0)
167                 printk(KERN_ERR "timer_init : request_irq failed - "
168                        "errno = %d\n", -err);
169         timer_irq_inited = 1;
170         return(0);
171 }
172
173 __initcall(timer_init);
174
175 /*
176  * Overrides for Emacs so that we follow Linus's tabbing style.
177  * Emacs will notice this stuff at the end of the file and automatically
178  * adjust the settings for this buffer only.  This must remain at the end
179  * of the file.
180  * ---------------------------------------------------------------------------
181  * Local variables:
182  * c-file-style: "linux"
183  * End:
184  */