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