Merge master.kernel.org:/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / arch / powerpc / kernel / smp-tbsync.c
1 /*
2  * Smp timebase synchronization for ppc.
3  *
4  * Copyright (C) 2003 Samuel Rydh (samuel@ibrium.se)
5  *
6  */
7
8 #include <linux/kernel.h>
9 #include <linux/sched.h>
10 #include <linux/smp.h>
11 #include <linux/unistd.h>
12 #include <linux/init.h>
13 #include <asm/atomic.h>
14 #include <asm/smp.h>
15 #include <asm/time.h>
16
17 #define NUM_ITER                300
18
19 enum {
20         kExit=0, kSetAndTest, kTest
21 };
22
23 static struct {
24         volatile u64            tb;
25         volatile u64            mark;
26         volatile int            cmd;
27         volatile int            handshake;
28         int                     filler[2];
29
30         volatile int            ack;
31         int                     filler2[7];
32
33         volatile int            race_result;
34 } *tbsync;
35
36 static volatile int             running;
37
38 static void __devinit enter_contest(u64 mark, long add)
39 {
40         while (get_tb() < mark)
41                 tbsync->race_result = add;
42 }
43
44 void __devinit smp_generic_take_timebase(void)
45 {
46         int cmd;
47         u64 tb;
48         unsigned long flags;
49
50         local_irq_save(flags);
51         while (!running)
52                 barrier();
53         rmb();
54
55         for (;;) {
56                 tbsync->ack = 1;
57                 while (!tbsync->handshake)
58                         barrier();
59                 rmb();
60
61                 cmd = tbsync->cmd;
62                 tb = tbsync->tb;
63                 mb();
64                 tbsync->ack = 0;
65                 if (cmd == kExit)
66                         break;
67
68                 while (tbsync->handshake)
69                         barrier();
70                 if (cmd == kSetAndTest)
71                         set_tb(tb >> 32, tb & 0xfffffffful);
72                 enter_contest(tbsync->mark, -1);
73         }
74         local_irq_restore(flags);
75 }
76
77 static int __devinit start_contest(int cmd, long offset, int num)
78 {
79         int i, score=0;
80         u64 tb;
81         u64 mark;
82
83         tbsync->cmd = cmd;
84
85         local_irq_disable();
86         for (i = -3; i < num; ) {
87                 tb = get_tb() + 400;
88                 tbsync->tb = tb + offset;
89                 tbsync->mark = mark = tb + 400;
90
91                 wmb();
92
93                 tbsync->handshake = 1;
94                 while (tbsync->ack)
95                         barrier();
96
97                 while (get_tb() <= tb)
98                         barrier();
99                 tbsync->handshake = 0;
100                 enter_contest(mark, 1);
101
102                 while (!tbsync->ack)
103                         barrier();
104
105                 if (i++ > 0)
106                         score += tbsync->race_result;
107         }
108         local_irq_enable();
109         return score;
110 }
111
112 void __devinit smp_generic_give_timebase(void)
113 {
114         int i, score, score2, old, min=0, max=5000, offset=1000;
115
116         printk("Synchronizing timebase\n");
117
118         /* if this fails then this kernel won't work anyway... */
119         tbsync = kzalloc( sizeof(*tbsync), GFP_KERNEL );
120         mb();
121         running = 1;
122
123         while (!tbsync->ack)
124                 barrier();
125
126         printk("Got ack\n");
127
128         /* binary search */
129         for (old = -1; old != offset ; offset = (min+max) / 2) {
130                 score = start_contest(kSetAndTest, offset, NUM_ITER);
131
132                 printk("score %d, offset %d\n", score, offset );
133
134                 if( score > 0 )
135                         max = offset;
136                 else
137                         min = offset;
138                 old = offset;
139         }
140         score = start_contest(kSetAndTest, min, NUM_ITER);
141         score2 = start_contest(kSetAndTest, max, NUM_ITER);
142
143         printk("Min %d (score %d), Max %d (score %d)\n",
144                min, score, max, score2);
145         score = abs(score);
146         score2 = abs(score2);
147         offset = (score < score2) ? min : max;
148
149         /* guard against inaccurate mttb */
150         for (i = 0; i < 10; i++) {
151                 start_contest(kSetAndTest, offset, NUM_ITER/10);
152
153                 if ((score2 = start_contest(kTest, offset, NUM_ITER)) < 0)
154                         score2 = -score2;
155                 if (score2 <= score || score2 < 20)
156                         break;
157         }
158         printk("Final offset: %d (%d/%d)\n", offset, score2, NUM_ITER );
159
160         /* exiting */
161         tbsync->cmd = kExit;
162         wmb();
163         tbsync->handshake = 1;
164         while (tbsync->ack)
165                 barrier();
166         tbsync->handshake = 0;
167         kfree(tbsync);
168         tbsync = NULL;
169         running = 0;
170 }