LXR linux/include/linux/clockchips.h

   1/*  linux/include/linux/clockchips.h
   2 *
   3 *  This file contains the structure definitions for clockchips.
   4 *
   5 *  If you are not a clockchip, or the time of day code, you should
   6 *  not be including this file!
   7 */
   8#ifndef _LINUX_CLOCKCHIPS_H
   9#define _LINUX_CLOCKCHIPS_H
  10
  11#ifdef CONFIG_GENERIC_CLOCKEVENTS
  12
  13# include <linux/clocksource.h>
  14# include <linux/cpumask.h>
  15# include <linux/ktime.h>
  16# include <linux/notifier.h>
  17
  18struct clock_event_device;
  19struct module;
  20
  21/* Clock event mode commands for legacy ->set_mode(): OBSOLETE */
  22enum clock_event_mode {
  23        CLOCK_EVT_MODE_UNUSED,
  24        CLOCK_EVT_MODE_SHUTDOWN,
  25        CLOCK_EVT_MODE_PERIODIC,
  26        CLOCK_EVT_MODE_ONESHOT,
  27        CLOCK_EVT_MODE_RESUME,
  28};
  29
  30/*
  31 * Possible states of a clock event device.
  32 *
  33 * DETACHED:    Device is not used by clockevents core. Initial state or can be
  34 *              reached from SHUTDOWN.
  35 * SHUTDOWN:    Device is powered-off. Can be reached from PERIODIC or ONESHOT.
  36 * PERIODIC:    Device is programmed to generate events periodically. Can be
  37 *              reached from DETACHED or SHUTDOWN.
  38 * ONESHOT:     Device is programmed to generate event only once. Can be reached
  39 *              from DETACHED or SHUTDOWN.
  40 */
  41enum clock_event_state {
  42        CLOCK_EVT_STATE_DETACHED,
  43        CLOCK_EVT_STATE_SHUTDOWN,
  44        CLOCK_EVT_STATE_PERIODIC,
  45        CLOCK_EVT_STATE_ONESHOT,
  46};
  47
  48/*
  49 * Clock event features
  50 */
  51# define CLOCK_EVT_FEAT_PERIODIC        0x000001
  52# define CLOCK_EVT_FEAT_ONESHOT         0x000002
  53# define CLOCK_EVT_FEAT_KTIME           0x000004
  54
  55/*
  56 * x86(64) specific (mis)features:
  57 *
  58 * - Clockevent source stops in C3 State and needs broadcast support.
  59 * - Local APIC timer is used as a dummy device.
  60 */
  61# define CLOCK_EVT_FEAT_C3STOP          0x000008
  62# define CLOCK_EVT_FEAT_DUMMY           0x000010
  63
  64/*
  65 * Core shall set the interrupt affinity dynamically in broadcast mode
  66 */
  67# define CLOCK_EVT_FEAT_DYNIRQ          0x000020
  68# define CLOCK_EVT_FEAT_PERCPU          0x000040
  69
  70/*
  71 * Clockevent device is based on a hrtimer for broadcast
  72 */
  73# define CLOCK_EVT_FEAT_HRTIMER         0x000080
  74
  75/**
  76 * struct clock_event_device - clock event device descriptor
  77 * @event_handler:      Assigned by the framework to be called by the low
  78 *                      level handler of the event source
  79 * @set_next_event:     set next event function using a clocksource delta
  80 * @set_next_ktime:     set next event function using a direct ktime value
  81 * @next_event:         local storage for the next event in oneshot mode
  82 * @max_delta_ns:       maximum delta value in ns
  83 * @min_delta_ns:       minimum delta value in ns
  84 * @mult:               nanosecond to cycles multiplier
  85 * @shift:              nanoseconds to cycles divisor (power of two)
  86 * @mode:               operating mode, relevant only to ->set_mode(), OBSOLETE
  87 * @state:              current state of the device, assigned by the core code
  88 * @features:           features
  89 * @retries:            number of forced programming retries
  90 * @set_mode:           legacy set mode function, only for modes <= CLOCK_EVT_MODE_RESUME.
  91 * @set_state_periodic: switch state to periodic, if !set_mode
  92 * @set_state_oneshot:  switch state to oneshot, if !set_mode
  93 * @set_state_shutdown: switch state to shutdown, if !set_mode
  94 * @tick_resume:        resume clkevt device, if !set_mode
  95 * @broadcast:          function to broadcast events
  96 * @min_delta_ticks:    minimum delta value in ticks stored for reconfiguration
  97 * @max_delta_ticks:    maximum delta value in ticks stored for reconfiguration
  98 * @name:               ptr to clock event name
  99 * @rating:             variable to rate clock event devices
 100 * @irq:                IRQ number (only for non CPU local devices)
 101 * @bound_on:           Bound on CPU
 102 * @cpumask:            cpumask to indicate for which CPUs this device works
 103 * @list:               list head for the management code
 104 * @owner:              module reference
 105 */
 106struct clock_event_device {
 107        void                    (*event_handler)(struct clock_event_device *);
 108        int                     (*set_next_event)(unsigned long evt, struct clock_event_device *);
 109        int                     (*set_next_ktime)(ktime_t expires, struct clock_event_device *);
 110        ktime_t                 next_event;
 111        u64                     max_delta_ns;
 112        u64                     min_delta_ns;
 113        u32                     mult;
 114        u32                     shift;
 115        enum clock_event_mode   mode;
 116        enum clock_event_state  state;
 117        unsigned int            features;
 118        unsigned long           retries;
 119
 120        /*
 121         * State transition callback(s): Only one of the two groups should be
 122         * defined:
 123         * - set_mode(), only for modes <= CLOCK_EVT_MODE_RESUME.
 124         * - set_state_{shutdown|periodic|oneshot}(), tick_resume().
 125         */
 126        void                    (*set_mode)(enum clock_event_mode mode, struct clock_event_device *);
 127        int                     (*set_state_periodic)(struct clock_event_device *);
 128        int                     (*set_state_oneshot)(struct clock_event_device *);
 129        int                     (*set_state_shutdown)(struct clock_event_device *);
 130        int                     (*tick_resume)(struct clock_event_device *);
 131
 132        void                    (*broadcast)(const struct cpumask *mask);
 133        void                    (*suspend)(struct clock_event_device *);
 134        void                    (*resume)(struct clock_event_device *);
 135        unsigned long           min_delta_ticks;
 136        unsigned long           max_delta_ticks;
 137
 138        const char              *name;
 139        int                     rating;
 140        int                     irq;
 141        int                     bound_on;
 142        const struct cpumask    *cpumask;
 143        struct list_head        list;
 144        struct module           *owner;
 145} ____cacheline_aligned;
 146
 147/*
 148 * Calculate a multiplication factor for scaled math, which is used to convert
 149 * nanoseconds based values to clock ticks:
 150 *
 151 * clock_ticks = (nanoseconds * factor) >> shift.
 152 *
 153 * div_sc is the rearranged equation to calculate a factor from a given clock
 154 * ticks / nanoseconds ratio:
 155 *
 156 * factor = (clock_ticks << shift) / nanoseconds
 157 */
 158static inline unsigned long
 159div_sc(unsigned long ticks, unsigned long nsec, int shift)
 160{
 161        u64 tmp = ((u64)ticks) << shift;
 162
 163        do_div(tmp, nsec);
 164
 165        return (unsigned long) tmp;
 166}
 167
 168/* Clock event layer functions */
 169extern u64 clockevent_delta2ns(unsigned long latch, struct clock_event_device *evt);
 170extern void clockevents_register_device(struct clock_event_device *dev);
 171extern int clockevents_unbind_device(struct clock_event_device *ced, int cpu);
 172
 173extern void clockevents_config(struct clock_event_device *dev, u32 freq);
 174extern void clockevents_config_and_register(struct clock_event_device *dev,
 175                                            u32 freq, unsigned long min_delta,
 176                                            unsigned long max_delta);
 177
 178extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);
 179
 180static inline void
 181clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
 182{
 183        return clocks_calc_mult_shift(&ce->mult, &ce->shift, NSEC_PER_SEC, freq, minsec);
 184}
 185
 186extern void clockevents_suspend(void);
 187extern void clockevents_resume(void);
 188
 189# ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
 190#  ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
 191extern void tick_broadcast(const struct cpumask *mask);
 192#  else
 193#   define tick_broadcast       NULL
 194#  endif
 195extern int tick_receive_broadcast(void);
 196# endif
 197
 198# if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
 199extern void tick_setup_hrtimer_broadcast(void);
 200extern int tick_check_broadcast_expired(void);
 201# else
 202static inline int tick_check_broadcast_expired(void) { return 0; }
 203static inline void tick_setup_hrtimer_broadcast(void) { }
 204# endif
 205
 206extern int clockevents_notify(unsigned long reason, void *arg);
 207
 208#else /* !CONFIG_GENERIC_CLOCKEVENTS: */
 209
 210static inline void clockevents_suspend(void) { }
 211static inline void clockevents_resume(void) { }
 212static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
 213static inline int tick_check_broadcast_expired(void) { return 0; }
 214static inline void tick_setup_hrtimer_broadcast(void) { }
 215
 216#endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 217
 218#endif /* _LINUX_CLOCKCHIPS_H */
 219