/* * Common time prototypes and such for all ppc machines. * * Written by Cort Dougan (cort@fsmlabs.com) to merge * Paul Mackerras' version and mine for PReP and Pmac. */ #ifdef __KERNEL__#ifndef __ASM_TIME_H__#define __ASM_TIME_H__ #include <linux/types.h>#include <linux/rtc.h>#include <linux/threads.h> #include <asm/reg.h> /* time.c */extern unsigned tb_ticks_per_jiffy;extern unsigned tb_to_us;extern unsigned tb_last_stamp;extern unsigned long disarm_decr[NR_CPUS]; extern void to_tm(int tim, struct rtc_time * tm);extern time_t last_rtc_update; extern void set_dec_cpu6(unsigned int val); int via_calibrate_decr(void); /* Accessor functions for the decrementer register. * The 4xx doesn't even have a decrementer.  I tried to use the * generic timer interrupt code, which seems OK, with the 4xx PIT * in auto-reload mode.  The problem is PIT stops counting when it * hits zero.  If it would wrap, we could use it just like a decrementer. */static __inline__ unsigned int get_dec(void){#if defined(CONFIG_40x)	return (mfspr(SPRN_PIT));#else	return (mfspr(SPRN_DEC));#endif} static __inline__ void set_dec(unsigned int val){#if defined(CONFIG_40x)	return;		/* Have to let it auto-reload */#elif defined(CONFIG_8xx_CPU6)	set_dec_cpu6(val);#else	mtspr(SPRN_DEC, val);#endif} /* Accessor functions for the timebase (RTC on 601) registers. *//* If one day CONFIG_POWER is added just define __USE_RTC as 1 */#ifdef CONFIG_6xxextern __inline__ int __attribute_pure__ __USE_RTC(void) {	return (mfspr(SPRN_PVR)>>16) == 1;}#else#define __USE_RTC() 0#endif extern __inline__ unsigned long get_tbl(void) {	unsigned long tbl;#if defined(CONFIG_403GCX)	asm volatile("mfspr %0, 0x3dd" : "=r" (tbl));#else	asm volatile("mftb %0" : "=r" (tbl));#endif	return tbl;} extern __inline__ unsigned long get_tbu(void) {	unsigned long tbl;#if defined(CONFIG_403GCX)	asm volatile("mfspr %0, 0x3dc" : "=r" (tbl));#else	asm volatile("mftbu %0" : "=r" (tbl));#endif	return tbl;} extern __inline__ void set_tb(unsigned int upper, unsigned int lower){	mtspr(SPRN_TBWL, 0);	mtspr(SPRN_TBWU, upper);	mtspr(SPRN_TBWL, lower);} extern __inline__ unsigned long get_rtcl(void) {	unsigned long rtcl;	asm volatile("mfrtcl %0" : "=r" (rtcl));	return rtcl;} extern __inline__ unsigned long get_rtcu(void){	unsigned long rtcu;	asm volatile("mfrtcu %0" : "=r" (rtcu));	return rtcu;} extern __inline__ unsigned get_native_tbl(void) {	if (__USE_RTC())		return get_rtcl();	else	  	return get_tbl();} /* On machines with RTC, this function can only be used safely * after the timestamp and for 1 second. It is only used by gettimeofday * however so it should not matter. */extern __inline__ unsigned tb_ticks_since(unsigned tstamp) {	if (__USE_RTC()) {		int delta = get_rtcl() - tstamp;		return delta<0 ? delta + 1000000000 : delta;	} else {        	return get_tbl() - tstamp;	}} #if 0extern __inline__ unsigned long get_bin_rtcl(void) {      unsigned long rtcl, rtcu1, rtcu2;      asm volatile("\1:    mfrtcu  %0\n\      mfrtcl  %1\n\      mfrtcu  %2\n\      cmpw    %0,%2\n\      bne-    1b\n"      : "=r" (rtcu1), "=r" (rtcl), "=r" (rtcu2)      : : "cr0");      return rtcu2*1000000000+rtcl;} extern __inline__ unsigned binary_tbl(void) {      if (__USE_RTC())              return get_bin_rtcl();      else              return get_tbl();}#endif /* Use mulhwu to scale processor timebase to timeval *//* Specifically, this computes (x * y) / 2^32.  -- paulus */#define mulhwu(x,y) \({unsigned z; asm ("mulhwu %0,%1,%2" : "=r" (z) : "r" (x), "r" (y)); z;}) unsigned mulhwu_scale_factor(unsigned, unsigned); #define account_process_vtime(tsk)		do { } while (0)#define calculate_steal_time()			do { } while (0)#define snapshot_timebases()			do { } while (0) #endif /* __ASM_TIME_H__ */#endif /* __KERNEL__ */