include/asm-ppc/time.h

   1 /*
   2  * Common time prototypes and such for all ppc machines.
   3  *
   4  * Written by Cort Dougan (cort@fsmlabs.com) to merge
   5  * Paul Mackerras' version and mine for PReP and Pmac.
   6  */
   7
   8 #ifdef __KERNEL__
   9 #ifndef __ASM_TIME_H__
  10 #define __ASM_TIME_H__
  11
  12 #include <linux/types.h>
  13 #include <linux/rtc.h>
  14 #include <linux/threads.h>
  15
  16 #include <asm/reg.h>
  17
  18 /* time.c */
  19 extern unsigned tb_ticks_per_jiffy;
  20 extern unsigned tb_to_us;
  21 extern unsigned tb_last_stamp;
  22 extern unsigned long disarm_decr[NR_CPUS];
  23
  24 extern void to_tm(int tim, struct rtc_time * tm);
  25 extern time_t last_rtc_update;
  26
  27 extern void set_dec_cpu6(unsigned int val);
  28
  29 int via_calibrate_decr(void);
  30
  31 /* Accessor functions for the decrementer register.
  32  * The 4xx doesn't even have a decrementer.  I tried to use the
  33  * generic timer interrupt code, which seems OK, with the 4xx PIT
  34  * in auto-reload mode.  The problem is PIT stops counting when it
  35  * hits zero.  If it would wrap, we could use it just like a decrementer.
  36  */
  37 static __inline__ unsigned int get_dec(void)
  38 {
  39 #if defined(CONFIG_40x)
  40         return (mfspr(SPRN_PIT));
  41 #else
  42         return (mfspr(SPRN_DEC));
  43 #endif
  44 }
  45
  46 static __inline__ void set_dec(unsigned int val)
  47 {
  48 #if defined(CONFIG_40x)
  49         return;         /* Have to let it auto-reload */
  50 #elif defined(CONFIG_8xx_CPU6)
  51         set_dec_cpu6(val);
  52 #else
  53         mtspr(SPRN_DEC, val);
  54 #endif
  55 }
  56
  57 /* Accessor functions for the timebase (RTC on 601) registers. */
  58 /* If one day CONFIG_POWER is added just define __USE_RTC as 1 */
  59 #ifdef CONFIG_6xx
  60 extern __inline__ int __pure __USE_RTC(void) {
  61         return (mfspr(SPRN_PVR)>>16) == 1;
  62 }
  63 #else
  64 #define __USE_RTC() 0
  65 #endif
  66
  67 extern __inline__ unsigned long get_tbl(void) {
  68         unsigned long tbl;
  69 #if defined(CONFIG_403GCX)
  70         asm volatile("mfspr %0, 0x3dd" : "=r" (tbl));
  71 #else
  72         asm volatile("mftb %0" : "=r" (tbl));
  73 #endif
  74         return tbl;
  75 }
  76
  77 extern __inline__ unsigned long get_tbu(void) {
  78         unsigned long tbl;
  79 #if defined(CONFIG_403GCX)
  80         asm volatile("mfspr %0, 0x3dc" : "=r" (tbl));
  81 #else
  82         asm volatile("mftbu %0" : "=r" (tbl));
  83 #endif
  84         return tbl;
  85 }
  86
  87 extern __inline__ void set_tb(unsigned int upper, unsigned int lower)
  88 {
  89         mtspr(SPRN_TBWL, 0);
  90         mtspr(SPRN_TBWU, upper);
  91         mtspr(SPRN_TBWL, lower);
  92 }
  93
  94 extern __inline__ unsigned long get_rtcl(void) {
  95         unsigned long rtcl;
  96         asm volatile("mfrtcl %0" : "=r" (rtcl));
  97         return rtcl;
  98 }
  99
 100 extern __inline__ unsigned long get_rtcu(void)
 101 {
 102         unsigned long rtcu;
 103         asm volatile("mfrtcu %0" : "=r" (rtcu));
 104         return rtcu;
 105 }
 106
 107 extern __inline__ unsigned get_native_tbl(void) {
 108         if (__USE_RTC())
 109                 return get_rtcl();
 110         else
 111                 return get_tbl();
 112 }
 113
 114 /* On machines with RTC, this function can only be used safely
 115  * after the timestamp and for 1 second. It is only used by gettimeofday
 116  * however so it should not matter.
 117  */
 118 extern __inline__ unsigned tb_ticks_since(unsigned tstamp) {
 119         if (__USE_RTC()) {
 120                 int delta = get_rtcl() - tstamp;
 121                 return delta<0 ? delta + 1000000000 : delta;
 122         } else {
 123                 return get_tbl() - tstamp;
 124         }
 125 }
 126
 127 #if 0
 128 extern __inline__ unsigned long get_bin_rtcl(void) {
 129       unsigned long rtcl, rtcu1, rtcu2;
 130       asm volatile("\
 131 1:    mfrtcu  %0\n\
 132       mfrtcl  %1\n\
 133       mfrtcu  %2\n\
 134       cmpw    %0,%2\n\
 135       bne-    1b\n"
 136       : "=r" (rtcu1), "=r" (rtcl), "=r" (rtcu2)
 137       : : "cr0");
 138       return rtcu2*1000000000+rtcl;
 139 }
 140
 141 extern __inline__ unsigned binary_tbl(void) {
 142       if (__USE_RTC())
 143               return get_bin_rtcl();
 144       else
 145               return get_tbl();
 146 }
 147 #endif
 148
 149 /* Use mulhwu to scale processor timebase to timeval */
 150 /* Specifically, this computes (x * y) / 2^32.  -- paulus */
 151 #define mulhwu(x,y) \
 152 ({unsigned z; asm ("mulhwu %0,%1,%2" : "=r" (z) : "r" (x), "r" (y)); z;})
 153
 154 unsigned mulhwu_scale_factor(unsigned, unsigned);
 155
 156 #define account_process_vtime(tsk)              do { } while (0)
 157 #define calculate_steal_time()                  do { } while (0)
 158 #define snapshot_timebases()                    do { } while (0)
 159
 160 #endif /* __ASM_TIME_H__ */
 161 #endif /* __KERNEL__ */