Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * tick internal variable and functions used by low/high res code
       4             :  */
       5             : #include <linux/hrtimer.h>
       6             : #include <linux/tick.h>
       7             : 
       8             : #include "timekeeping.h"
       9             : #include "tick-sched.h"
      10             : 
      11             : #ifdef CONFIG_GENERIC_CLOCKEVENTS
      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 int tick_do_timer_cpu __read_mostly;
      19             : 
      20             : extern void tick_setup_periodic(struct clock_event_device *dev, int broadcast);
      21             : extern void tick_handle_periodic(struct clock_event_device *dev);
      22             : extern void tick_check_new_device(struct clock_event_device *dev);
      23             : extern void tick_shutdown(unsigned int cpu);
      24             : extern void tick_suspend(void);
      25             : extern void tick_resume(void);
      26             : extern bool tick_check_replacement(struct clock_event_device *curdev,
      27             :                                    struct clock_event_device *newdev);
      28             : extern void tick_install_replacement(struct clock_event_device *dev);
      29             : extern int tick_is_oneshot_available(void);
      30             : extern struct tick_device *tick_get_device(int cpu);
      31             : 
      32             : extern int clockevents_tick_resume(struct clock_event_device *dev);
      33             : /* Check, if the device is functional or a dummy for broadcast */
      34          12 : static inline int tick_device_is_functional(struct clock_event_device *dev)
      35             : {
      36          12 :         return !(dev->features & CLOCK_EVT_FEAT_DUMMY);
      37             : }
      38             : 
      39          12 : static inline enum clock_event_state clockevent_get_state(struct clock_event_device *dev)
      40             : {
      41          12 :         return dev->state_use_accessors;
      42             : }
      43             : 
      44          12 : static inline void clockevent_set_state(struct clock_event_device *dev,
      45             :                                         enum clock_event_state state)
      46             : {
      47          12 :         dev->state_use_accessors = state;
      48             : }
      49             : 
      50             : extern void clockevents_shutdown(struct clock_event_device *dev);
      51             : extern void clockevents_exchange_device(struct clock_event_device *old,
      52             :                                         struct clock_event_device *new);
      53             : extern void clockevents_switch_state(struct clock_event_device *dev,
      54             :                                      enum clock_event_state state);
      55             : extern int clockevents_program_event(struct clock_event_device *dev,
      56             :                                      ktime_t expires, bool force);
      57             : extern void clockevents_handle_noop(struct clock_event_device *dev);
      58             : extern int __clockevents_update_freq(struct clock_event_device *dev, u32 freq);
      59             : extern ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt);
      60             : 
      61             : /* Broadcasting support */
      62             : # ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
      63             : extern int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu);
      64             : extern void tick_install_broadcast_device(struct clock_event_device *dev);
      65             : extern int tick_is_broadcast_device(struct clock_event_device *dev);
      66             : extern void tick_suspend_broadcast(void);
      67             : extern void tick_resume_broadcast(void);
      68             : extern bool tick_resume_check_broadcast(void);
      69             : extern void tick_broadcast_init(void);
      70             : extern void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast);
      71             : extern int tick_broadcast_update_freq(struct clock_event_device *dev, u32 freq);
      72             : extern struct tick_device *tick_get_broadcast_device(void);
      73             : extern struct cpumask *tick_get_broadcast_mask(void);
      74             : # else /* !CONFIG_GENERIC_CLOCKEVENTS_BROADCAST: */
      75             : static inline void tick_install_broadcast_device(struct clock_event_device *dev) { }
      76             : static inline int tick_is_broadcast_device(struct clock_event_device *dev) { return 0; }
      77             : static inline int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu) { return 0; }
      78             : static inline void tick_do_periodic_broadcast(struct clock_event_device *d) { }
      79             : static inline void tick_suspend_broadcast(void) { }
      80             : static inline void tick_resume_broadcast(void) { }
      81             : static inline bool tick_resume_check_broadcast(void) { return false; }
      82             : static inline void tick_broadcast_init(void) { }
      83             : static inline int tick_broadcast_update_freq(struct clock_event_device *dev, u32 freq) { return -ENODEV; }
      84             : 
      85             : /* Set the periodic handler in non broadcast mode */
      86             : static inline void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
      87             : {
      88             :         dev->event_handler = tick_handle_periodic;
      89             : }
      90             : # endif /* !CONFIG_GENERIC_CLOCKEVENTS_BROADCAST */
      91             : 
      92             : #else /* !GENERIC_CLOCKEVENTS: */
      93             : static inline void tick_suspend(void) { }
      94             : static inline void tick_resume(void) { }
      95             : #endif /* !GENERIC_CLOCKEVENTS */
      96             : 
      97             : /* Oneshot related functions */
      98             : #ifdef CONFIG_TICK_ONESHOT
      99             : extern void tick_setup_oneshot(struct clock_event_device *newdev,
     100             :                                void (*handler)(struct clock_event_device *),
     101             :                                ktime_t nextevt);
     102             : extern int tick_program_event(ktime_t expires, int force);
     103             : extern void tick_oneshot_notify(void);
     104             : extern int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *));
     105             : extern void tick_resume_oneshot(void);
     106             : static inline bool tick_oneshot_possible(void) { return true; }
     107             : extern int tick_oneshot_mode_active(void);
     108             : extern void tick_clock_notify(void);
     109             : extern int tick_check_oneshot_change(int allow_nohz);
     110             : extern int tick_init_highres(void);
     111             : #else /* !CONFIG_TICK_ONESHOT: */
     112             : static inline
     113             : void tick_setup_oneshot(struct clock_event_device *newdev,
     114             :                         void (*handler)(struct clock_event_device *),
     115             :                         ktime_t nextevt) { BUG(); }
     116             : static inline void tick_resume_oneshot(void) { BUG(); }
     117             : static inline int tick_program_event(ktime_t expires, int force) { return 0; }
     118             : static inline void tick_oneshot_notify(void) { }
     119             : static inline bool tick_oneshot_possible(void) { return false; }
     120             : static inline int tick_oneshot_mode_active(void) { return 0; }
     121             : static inline void tick_clock_notify(void) { }
     122             : static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
     123             : #endif /* !CONFIG_TICK_ONESHOT */
     124             : 
     125             : /* Functions related to oneshot broadcasting */
     126             : #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
     127             : extern void tick_broadcast_switch_to_oneshot(void);
     128             : extern int tick_broadcast_oneshot_active(void);
     129             : extern void tick_check_oneshot_broadcast_this_cpu(void);
     130             : bool tick_broadcast_oneshot_available(void);
     131             : extern struct cpumask *tick_get_broadcast_oneshot_mask(void);
     132             : #else /* !(BROADCAST && ONESHOT): */
     133             : static inline void tick_broadcast_switch_to_oneshot(void) { }
     134             : static inline int tick_broadcast_oneshot_active(void) { return 0; }
     135             : static inline void tick_check_oneshot_broadcast_this_cpu(void) { }
     136             : static inline bool tick_broadcast_oneshot_available(void) { return tick_oneshot_possible(); }
     137             : #endif /* !(BROADCAST && ONESHOT) */
     138             : 
     139             : #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_HOTPLUG_CPU)
     140             : extern void tick_broadcast_offline(unsigned int cpu);
     141             : #else
     142             : static inline void tick_broadcast_offline(unsigned int cpu) { }
     143             : #endif
     144             : 
     145             : /* NO_HZ_FULL internal */
     146             : #ifdef CONFIG_NO_HZ_FULL
     147             : extern void tick_nohz_init(void);
     148             : # else
     149           1 : static inline void tick_nohz_init(void) { }
     150             : #endif
     151             : 
     152             : #ifdef CONFIG_NO_HZ_COMMON
     153             : extern unsigned long tick_nohz_active;
     154             : extern void timers_update_nohz(void);
     155             : # ifdef CONFIG_SMP
     156             : extern struct static_key_false timers_migration_enabled;
     157             : # endif
     158             : #else /* CONFIG_NO_HZ_COMMON */
     159             : static inline void timers_update_nohz(void) { }
     160             : #define tick_nohz_active (0)
     161             : #endif
     162             : 
     163             : DECLARE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases);
     164             : 
     165             : extern u64 get_next_timer_interrupt(unsigned long basej, u64 basem);
     166             : void timer_clear_idle(void);