arch/s390/include/asm/timex.h

   1 /*
   2  *  S390 version
   3  *    Copyright IBM Corp. 1999
   4  *
   5  *  Derived from "include/asm-i386/timex.h"
   6  *    Copyright (C) 1992, Linus Torvalds
   7  */
   8
   9 #ifndef _ASM_S390_TIMEX_H
  10 #define _ASM_S390_TIMEX_H
  11
  12 #include <asm/lowcore.h>
  13
  14 /* The value of the TOD clock for 1.1.1970. */
  15 #define TOD_UNIX_EPOCH 0x7d91048bca000000ULL
  16
  17 /* Inline functions for clock register access. */
  18 static inline int set_tod_clock(__u64 time)
  19 {
  20         int cc;
  21
  22         asm volatile(
  23                 "   sck   %1\n"
  24                 "   ipm   %0\n"
  25                 "   srl   %0,28\n"
  26                 : "=d" (cc) : "Q" (time) : "cc");
  27         return cc;
  28 }
  29
  30 static inline int store_tod_clock(__u64 *time)
  31 {
  32         int cc;
  33
  34         asm volatile(
  35                 "   stck  %1\n"
  36                 "   ipm   %0\n"
  37                 "   srl   %0,28\n"
  38                 : "=d" (cc), "=Q" (*time) : : "cc");
  39         return cc;
  40 }
  41
  42 static inline void set_clock_comparator(__u64 time)
  43 {
  44         asm volatile("sckc %0" : : "Q" (time));
  45 }
  46
  47 static inline void store_clock_comparator(__u64 *time)
  48 {
  49         asm volatile("stckc %0" : "=Q" (*time));
  50 }
  51
  52 void clock_comparator_work(void);
  53
  54 static inline unsigned long long local_tick_disable(void)
  55 {
  56         unsigned long long old;
  57
  58         old = S390_lowcore.clock_comparator;
  59         S390_lowcore.clock_comparator = -1ULL;
  60         set_clock_comparator(S390_lowcore.clock_comparator);
  61         return old;
  62 }
  63
  64 static inline void local_tick_enable(unsigned long long comp)
  65 {
  66         S390_lowcore.clock_comparator = comp;
  67         set_clock_comparator(S390_lowcore.clock_comparator);
  68 }
  69
  70 #define CLOCK_TICK_RATE 1193180 /* Underlying HZ */
  71
  72 typedef unsigned long long cycles_t;
  73
  74 static inline void get_tod_clock_ext(char clk[16])
  75 {
  76         typedef struct { char _[sizeof(clk)]; } addrtype;
  77
  78         asm volatile("stcke %0" : "=Q" (*(addrtype *) clk) : : "cc");
  79 }
  80
  81 static inline unsigned long long get_tod_clock(void)
  82 {
  83         unsigned char clk[16];
  84         get_tod_clock_ext(clk);
  85         return *((unsigned long long *)&clk[1]);
  86 }
  87
  88 static inline unsigned long long get_tod_clock_fast(void)
  89 {
  90 #ifdef CONFIG_HAVE_MARCH_Z9_109_FEATURES
  91         unsigned long long clk;
  92
  93         asm volatile("stckf %0" : "=Q" (clk) : : "cc");
  94         return clk;
  95 #else
  96         return get_tod_clock();
  97 #endif
  98 }
  99
 100 static inline cycles_t get_cycles(void)
 101 {
 102         return (cycles_t) get_tod_clock() >> 2;
 103 }
 104
 105 int get_sync_clock(unsigned long long *clock);
 106 void init_cpu_timer(void);
 107 unsigned long long monotonic_clock(void);
 108
 109 void tod_to_timeval(__u64, struct timespec *);
 110
 111 static inline
 112 void stck_to_timespec(unsigned long long stck, struct timespec *ts)
 113 {
 114         tod_to_timeval(stck - TOD_UNIX_EPOCH, ts);
 115 }
 116
 117 extern u64 sched_clock_base_cc;
 118
 119 /**
 120  * get_clock_monotonic - returns current time in clock rate units
 121  *
 122  * The caller must ensure that preemption is disabled.
 123  * The clock and sched_clock_base get changed via stop_machine.
 124  * Therefore preemption must be disabled when calling this
 125  * function, otherwise the returned value is not guaranteed to
 126  * be monotonic.
 127  */
 128 static inline unsigned long long get_tod_clock_monotonic(void)
 129 {
 130         return get_tod_clock() - sched_clock_base_cc;
 131 }
 132
 133 /**
 134  * tod_to_ns - convert a TOD format value to nanoseconds
 135  * @todval: to be converted TOD format value
 136  * Returns: number of nanoseconds that correspond to the TOD format value
 137  *
 138  * Converting a 64 Bit TOD format value to nanoseconds means that the value
 139  * must be divided by 4.096. In order to achieve that we multiply with 125
 140  * and divide by 512:
 141  *
 142  *    ns = (todval * 125) >> 9;
 143  *
 144  * In order to avoid an overflow with the multiplication we can rewrite this.
 145  * With a split todval == 2^32 * th + tl (th upper 32 bits, tl lower 32 bits)
 146  * we end up with
 147  *
 148  *    ns = ((2^32 * th + tl) * 125 ) >> 9;
 149  * -> ns = (2^23 * th * 125) + ((tl * 125) >> 9);
 150  *
 151  */
 152 static inline unsigned long long tod_to_ns(unsigned long long todval)
 153 {
 154         unsigned long long ns;
 155
 156         ns = ((todval >> 32) << 23) * 125;
 157         ns += ((todval & 0xffffffff) * 125) >> 9;
 158         return ns;
 159 }
 160
 161 #endif