kernel/time/tick-internal.h

   1 /*
   2  * tick internal variable and functions used by low/high res code
   3  */
   4 #include <linux/hrtimer.h>
   5 #include <linux/tick.h>
   6
   7 extern seqlock_t jiffies_lock;
   8
   9 #define CS_NAME_LEN     32
  10
  11 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BUILD
  12
  13 #define TICK_DO_TIMER_NONE      -1
  14 #define TICK_DO_TIMER_BOOT      -2
  15
  16 DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
  17 extern ktime_t tick_next_period;
  18 extern ktime_t tick_period;
  19 extern int tick_do_timer_cpu __read_mostly;
  20
  21 extern void tick_setup_periodic(struct clock_event_device *dev, int broadcast);
  22 extern void tick_handle_periodic(struct clock_event_device *dev);
  23 extern void tick_check_new_device(struct clock_event_device *dev);
  24 extern void tick_handover_do_timer(int *cpup);
  25 extern void tick_shutdown(unsigned int *cpup);
  26 extern void tick_suspend(void);
  27 extern void tick_resume(void);
  28 extern bool tick_check_replacement(struct clock_event_device *curdev,
  29                                    struct clock_event_device *newdev);
  30 extern void tick_install_replacement(struct clock_event_device *dev);
  31
  32 extern void clockevents_shutdown(struct clock_event_device *dev);
  33
  34 extern ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt);
  35
  36 /*
  37  * NO_HZ / high resolution timer shared code
  38  */
  39 #ifdef CONFIG_TICK_ONESHOT
  40 extern void tick_setup_oneshot(struct clock_event_device *newdev,
  41                                void (*handler)(struct clock_event_device *),
  42                                ktime_t nextevt);
  43 extern int tick_program_event(ktime_t expires, int force);
  44 extern void tick_oneshot_notify(void);
  45 extern int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *));
  46 extern void tick_resume_oneshot(void);
  47 # ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
  48 extern void tick_broadcast_setup_oneshot(struct clock_event_device *bc);
  49 extern void tick_broadcast_oneshot_control(unsigned long reason);
  50 extern void tick_broadcast_switch_to_oneshot(void);
  51 extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);
  52 extern int tick_resume_broadcast_oneshot(struct clock_event_device *bc);
  53 extern int tick_broadcast_oneshot_active(void);
  54 extern void tick_check_oneshot_broadcast(int cpu);
  55 bool tick_broadcast_oneshot_available(void);
  56 # else /* BROADCAST */
  57 static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
  58 {
  59         BUG();
  60 }
  61 static inline void tick_broadcast_oneshot_control(unsigned long reason) { }
  62 static inline void tick_broadcast_switch_to_oneshot(void) { }
  63 static inline void tick_shutdown_broadcast_oneshot(unsigned int *cpup) { }
  64 static inline int tick_broadcast_oneshot_active(void) { return 0; }
  65 static inline void tick_check_oneshot_broadcast(int cpu) { }
  66 static inline bool tick_broadcast_oneshot_available(void) { return true; }
  67 # endif /* !BROADCAST */
  68
  69 #else /* !ONESHOT */
  70 static inline
  71 void tick_setup_oneshot(struct clock_event_device *newdev,
  72                         void (*handler)(struct clock_event_device *),
  73                         ktime_t nextevt)
  74 {
  75         BUG();
  76 }
  77 static inline void tick_resume_oneshot(void)
  78 {
  79         BUG();
  80 }
  81 static inline int tick_program_event(ktime_t expires, int force)
  82 {
  83         return 0;
  84 }
  85 static inline void tick_oneshot_notify(void) { }
  86 static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
  87 {
  88         BUG();
  89 }
  90 static inline void tick_broadcast_oneshot_control(unsigned long reason) { }
  91 static inline void tick_shutdown_broadcast_oneshot(unsigned int *cpup) { }
  92 static inline int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
  93 {
  94         return 0;
  95 }
  96 static inline int tick_broadcast_oneshot_active(void) { return 0; }
  97 static inline bool tick_broadcast_oneshot_available(void) { return false; }
  98 #endif /* !TICK_ONESHOT */
  99
 100 /*
 101  * Broadcasting support
 102  */
 103 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 104 extern int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu);
 105 extern void tick_install_broadcast_device(struct clock_event_device *dev);
 106 extern int tick_is_broadcast_device(struct clock_event_device *dev);
 107 extern void tick_broadcast_on_off(unsigned long reason, int *oncpu);
 108 extern void tick_shutdown_broadcast(unsigned int *cpup);
 109 extern void tick_suspend_broadcast(void);
 110 extern int tick_resume_broadcast(void);
 111 extern void tick_broadcast_init(void);
 112 extern void
 113 tick_set_periodic_handler(struct clock_event_device *dev, int broadcast);
 114
 115 #else /* !BROADCAST */
 116
 117 static inline void tick_install_broadcast_device(struct clock_event_device *dev)
 118 {
 119 }
 120
 121 static inline int tick_is_broadcast_device(struct clock_event_device *dev)
 122 {
 123         return 0;
 124 }
 125 static inline int tick_device_uses_broadcast(struct clock_event_device *dev,
 126                                              int cpu)
 127 {
 128         return 0;
 129 }
 130 static inline void tick_do_periodic_broadcast(struct clock_event_device *d) { }
 131 static inline void tick_broadcast_on_off(unsigned long reason, int *oncpu) { }
 132 static inline void tick_shutdown_broadcast(unsigned int *cpup) { }
 133 static inline void tick_suspend_broadcast(void) { }
 134 static inline int tick_resume_broadcast(void) { return 0; }
 135 static inline void tick_broadcast_init(void) { }
 136
 137 /*
 138  * Set the periodic handler in non broadcast mode
 139  */
 140 static inline void tick_set_periodic_handler(struct clock_event_device *dev,
 141                                              int broadcast)
 142 {
 143         dev->event_handler = tick_handle_periodic;
 144 }
 145 #endif /* !BROADCAST */
 146
 147 /*
 148  * Check, if the device is functional or a dummy for broadcast
 149  */
 150 static inline int tick_device_is_functional(struct clock_event_device *dev)
 151 {
 152         return !(dev->features & CLOCK_EVT_FEAT_DUMMY);
 153 }
 154
 155 #endif
 156
 157 extern void do_timer(unsigned long ticks);