2 * $Id: idle.c,v 1.63 1999/06/10 22:55:35 geert Exp $
4 * Idle daemon for PowerPC. Idle daemon will handle any action
5 * that needs to be taken when the system becomes idle.
7 * Written by Cort Dougan (cort@cs.nmt.edu)
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
14 #include <linux/config.h>
15 #include <linux/errno.h>
16 #include <linux/sched.h>
17 #include <linux/kernel.h>
19 #include <linux/smp.h>
20 #include <linux/smp_lock.h>
21 #include <linux/stddef.h>
22 #include <linux/unistd.h>
23 #include <linux/ptrace.h>
24 #include <linux/malloc.h>
26 #include <asm/pgtable.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
30 #include <asm/processor.h>
32 #include <asm/cache.h>
34 void zero_paged(void);
35 void power_save(void);
36 void inline htab_reclaim(void);
38 unsigned long htab_reclaim_on
= 0;
39 unsigned long zero_paged_on
= 0;
40 unsigned long powersave_nap
= 0;
42 unsigned long *zero_cache
; /* head linked list of pre-zero'd pages */
43 unsigned long zero_sz
; /* # currently pre-zero'd pages */
44 unsigned long zeropage_hits
; /* # zero'd pages request that we've done */
45 unsigned long zeropage_calls
; /* # zero'd pages request that've been made */
46 unsigned long zerototal
; /* # pages zero'd over time */
48 int idled(void *unused
)
50 /* endless loop with no priority at all */
51 current
->priority
= 0;
52 current
->counter
= -100;
60 if ( !current
->need_resched
&& zero_paged_on
) zero_paged();
61 if ( !current
->need_resched
&& htab_reclaim_on
) htab_reclaim();
62 if ( !current
->need_resched
) power_save();
65 if (current
->need_resched
)
74 * SMP entry into the idle task - calls the same thing as the
75 * non-smp versions. -- Cort
77 int cpu_idle(void *unused
)
85 * Syscall entry into the idle task. -- Cort
87 asmlinkage
int sys_idle(void)
93 return 0; /* should never execute this but it makes gcc happy -- Cort */
97 * Mark 'zombie' pte's in the hash table as invalid.
98 * This improves performance for the hash table reload code
99 * a bit since we don't consider unused pages as valid.
102 PTE
*reclaim_ptr
= 0;
103 void inline htab_reclaim(void)
110 struct task_struct
*p
;
111 unsigned long valid
= 0;
112 extern PTE
*Hash
, *Hash_end
;
113 extern unsigned long Hash_size
;
115 /* if we don't have a htab */
116 if ( Hash_size
== 0 )
119 /* find a random place in the htab to start each time */
120 start
= &Hash
[jiffies
%(Hash_size
/sizeof(PTE
))];
121 /* go a different direction each time */
124 !current
->need_resched
&& (ptr
!= Hash_end
) && (ptr
!= Hash
);
128 if ( !reclaim_ptr
) reclaim_ptr
= Hash
;
129 while ( !current
->need_resched
)
132 if ( reclaim_ptr
== Hash_end
) reclaim_ptr
= Hash
;
139 if ( current
->need_resched
)
141 /* if this vsid/context is in use */
142 if ( (reclaim_ptr
->vsid
>> 4) == p
->mm
->context
)
150 /* this pte isn't used */
154 if ( current
->need_resched
) printk("need_resched: %lx\n", current
->need_resched
);
155 #endif /* CONFIG_8xx */
159 * Returns a pre-zero'd page from the list otherwise returns
162 unsigned long get_zero_page_fast(void)
164 unsigned long page
= 0;
166 atomic_inc((atomic_t
*)&zero_cache_calls
);
167 if ( zero_quicklist
)
169 /* atomically remove this page from the list */
170 asm ( "101:lwarx %1,0,%2\n" /* reserve zero_cache */
171 " lwz %0,0(%1)\n" /* get next -- new zero_cache */
172 " stwcx. %0,0,%2\n" /* update zero_cache */
173 " bne- 101b\n" /* if lost reservation try again */
174 : "=&r" (zero_quicklist
), "=&r" (page
)
175 : "r" (&zero_quicklist
)
178 /* if another cpu beat us above this can happen -- Cort */
182 /* we can update zerocount after the fact since it is not
183 * used for anything but control of a loop which doesn't
184 * matter since it won't affect anything if it zeros one
187 atomic_inc((atomic_t
*)&zero_cache_hits
);
188 atomic_dec((atomic_t
*)&zero_cache_sz
);
190 /* zero out the pointer to next in the page */
191 *(unsigned long *)page
= 0;
198 * Experimental stuff to zero out pages in the idle task
199 * to speed up get_free_pages(). Zero's out pages until
200 * we've reached the limit of zero'd pages. We handle
201 * reschedule()'s in here so when we return we know we've
202 * zero'd all we need to for now.
204 int zero_cache_water
[2] = { 25, 96 }; /* high and low water marks for zero cache */
205 void zero_paged(void)
207 unsigned long pageptr
= 0; /* current page being zero'd */
208 unsigned long bytecount
= 0;
211 if ( zero_cache_sz
>= zero_cache_water
[0] )
213 while ( (zero_cache_sz
< zero_cache_water
[1]) && (!current
->need_resched
) )
216 * Mark a page as reserved so we can mess with it
217 * If we're interrupted we keep this page and our place in it
218 * since we validly hold it and it's reserved for us.
220 pageptr
= __get_free_pages(GFP_ATOMIC
, 0);
224 if ( current
->need_resched
)
228 * Make the page no cache so we don't blow our cache with 0's
230 pte
= find_pte(init_task
.mm
, pageptr
);
233 printk("pte NULL in zero_paged()\n");
238 flush_tlb_page(find_vma(init_task
.mm
,pageptr
),pageptr
);
240 * Important here to not take time away from real processes.
242 for ( bytecount
= 0; bytecount
< PAGE_SIZE
; bytecount
+= 4 )
244 if ( current
->need_resched
)
246 *(unsigned long *)(bytecount
+ pageptr
) = 0;
250 * If we finished zero-ing out a page add this page to
251 * the zero_cache atomically -- we can't use
252 * down/up since we can't sleep in idle.
253 * Disabling interrupts is also a bad idea since we would
254 * steal time away from real processes.
255 * We can also have several zero_paged's running
256 * on different processors so we can't interfere with them.
257 * So we update the list atomically without locking it.
261 /* turn cache on for this page */
263 flush_tlb_page(find_vma(init_task
.mm
,pageptr
),pageptr
);
264 /* atomically add this page to the list */
265 asm ( "101:lwarx %0,0,%1\n" /* reserve zero_cache */
266 " stw %0,0(%2)\n" /* update *pageptr */
268 " sync\n" /* let store settle */
270 " mr %0,%2\n" /* update zero_cache in reg */
271 " stwcx. %2,0,%1\n" /* update zero_cache in mem */
272 " bne- 101b\n" /* if lost reservation try again */
273 : "=&r" (zero_quicklist
)
274 : "r" (&zero_quicklist
), "r" (pageptr
)
277 * This variable is used in the above loop and nowhere
278 * else so the worst that could happen is we would
279 * zero out one more or one less page than we want
280 * per processor on the machine. This is because
281 * we could add our page to the list but not have
282 * zerocount updated yet when another processor
285 atomic_inc((atomic_t
*)&zero_cache_sz
);
286 atomic_inc((atomic_t
*)&zero_cache_total
);
290 void power_save(void)
292 unsigned long msr
, hid0
;
294 /* only sleep on the 603-family/750 processors */
295 switch (_get_PVR() >> 16) {
302 if (!current
->need_resched
) {
303 asm("mfspr %0,1008" : "=r" (hid0
) :);
304 hid0
&= ~(HID0_NAP
| HID0_SLEEP
| HID0_DOZE
);
305 hid0
|= (powersave_nap
? HID0_NAP
: HID0_DOZE
) | HID0_DPM
;
306 asm("mtspr 1008,%0" : : "r" (hid0
));
308 /* set the POW bit in the MSR, and enable interrupts
309 * so we wake up sometime! */
310 _nmask_and_or_msr(0, MSR_POW
| MSR_EE
);
312 /* Disable interrupts again so restore_flags will
314 _nmask_and_or_msr(MSR_EE
, 0);